Farbwechselndes Nachtlicht mit Ardruino 101 - Gunook
Farbwechselndes Nachtlicht mit Ardruino 101 - Gunook

Inhaltsverzeichnis:

Anonim
Image
Image
Farbwechselndes Nachtlicht mit Ardruino 101
Farbwechselndes Nachtlicht mit Ardruino 101

In diesem Projekt werden Sie eine Nachtlampe mit Arduino, Adafruit Neo-RGB-Streifen und einem 3D-Drucker herstellen.

Beachten Sie, dass diese intructable ausschließlich für mein Schulprojekt ist. Der Code für dieses Projekt basiert auf einem anderen Projekt. Trotzdem bin ich kein Experte, wenn es um Ardruino geht.

Schritt 1: Anforderungen

Anforderungen
Anforderungen
Anforderungen
Anforderungen
Anforderungen
Anforderungen

Für dieses Projekt benötigen Sie die folgende Hardware und Werkzeuge

Hardware:

1 - Ein ardruino101 (in den USA) oder ein Genuino101 (für außerhalb der USA).

2 - NeoPixel RGB-LED-Streifen von Adafruit (5 Volt).

3 - Ein Arduino-USB-Anschluss (Typ B zu A-Anschluss).

4 - Eine Software von Ardruino, Ardruino IDE In diesem Tutorial verwenden wir die Version 1.8.5. Die Anforderungen an die Softwarebibliothek sind: 101, Adafruit NeoPixel und Madgwick.

5 -Und ein Objekt, um Ihre Hardware zu beherbergen. In diesem Fall verwende ich einen 3D-Drucker. Die Datei für diesen 3D-Druck befindet sich in den Beschreibungen namens "Lampenkopf". Beachten Sie, dass dieses Dateiformat nicht für den 3D-Druck geeignet ist. Abhängig von Ihren 3D-Druckern müssen Sie zuvor die dafür vorgesehene 3D-Druck-Software auf dem 3D-Objekt ausführen. Manchmal wird der Maßstab des 3D-Drucks zurückgesetzt. Stellen Sie also sicher, dass der Durchmesser auf 11 cm x 11 cm eingestellt ist.

6 - Grundset zum Löten.

Schritt 2: Verständnis der Hardware und Software

Ardruin/Genuino101

Nur zur Verdeutlichung sind Ardruino101 und genuino101 neben den Namen genau gleich. Beide haben die gleichen Spezifikationen und verwenden die gleiche Software.

Ardruino101 besitzt die grundlegenden Spezifikationen wie das Arduino UNO und mehr. Das Hauptmerkmal von ardruino101 ist der Beschleunigungsmesser und das Gyroskop, die wir in unserem Projekt verwenden. Auch diese Art von Arduino hat seine einzigartige Codebibliothek namens CurrieIMU (Internal Measurement Units), die in der Bibliothekserweiterung 101 enthalten ist.

Wenn das gesagt ist, können wir über die Software sprechen.

Software und Bibliotheken

Ardruino IDE verwendet Python als Hauptquellcode. Es ist auch die Hauptcodeplattform, auf der die meisten Arduinos ausgeführt werden. Es gibt viele Online-Tutorials zur Verwendung dieser Software, daher empfehle ich Ihnen, diese zuerst zu recherchieren, wenn Sie mit diesem Programm noch nicht vertraut sind.

Vor diesem Hintergrund sind die von uns verwendeten Bibliotheken die folgenden:

Geben Sie im Menü Skizze > Bibliothek einschließen > Bibliotheken verwalten… in das Texteingabefeld ein

- 101 Standardmäßig wird das ardruino 101 nicht automatisch in die ardruino IDE eingebunden. Wir benötigen diese Bibliothekserweiterung, um unseren Arduino-Typ zu codieren.

-Adafruit NeoPixel, um unsere Neo-Pixelstreifen zu codieren.

-Madgwick Um die Rohdaten auszulesen und diese Daten zu Roh-, Nick- und Rolldaten zu berechnen.

Neo RGB-Streifen

Der Typ, den ich verwende, ist ein 5-Volt- oder 5-V-Typ. Mit diesen 5V brauche ich keine erweiterte Stromquelle, um meine Streifen zu steuern. Stattdessen werde ich mein Arduino als Stromquelle verwenden, um die Streifen zu steuern und zu beleuchten.

Hier sind einige Tipps, die Sie wissen müssen, bevor Sie mit diesen Streifen beginnen.

Zuerst benötigen Sie einen Neodigital RGB LED-Streifen von adafruit. Diese Art von Streifen ist über Codes steuerbar. Als nächstes müssen Sie wissen, dass es bei diesem Streifen eine Rückseite und eine Vorderseite gibt. Diese Rück- und Vorderseite ist für das Löten wichtig. Achten Sie darauf, dass Sie die Vorderseite verlöten, an der die Pfeiltaste von der Spitze weg zeigt.

Hier ist eine Anleitung, wie man sie verwendet.

Es gibt 3 Lötpunkte, die Sie beachten müssen: Masseanschluss (GND), Spannungsanschluss (V) und Pin-Anschluss (DIN).

Schritt 3: Einrichten der Komponenten

Einrichten der Komponenten
Einrichten der Komponenten
Einrichten der Komponenten
Einrichten der Komponenten
Einrichten der Komponenten
Einrichten der Komponenten

Zuerst müssen Sie die Komponente in 3D drucken, die Sie in den Anforderungen finden. In diesem Fall verwende ich PLA. Stellen Sie sicher, dass der Durchmesser des gesamten Objekts 11 x 11 cm beträgt. Dadurch wird sichergestellt, dass das Arduino und die Streifen in die Schale passen. Beachten Sie, dass jeder 3D-Drucker verschiedene Software verwendet, um seinen Druckprozess zu berechnen. Vor diesem Hintergrund kann die von Ihnen verwendete Datei unterschiedlich skaliert werden, also denken Sie daran.

Stellen Sie nach dem Drucken sicher, dass sich die Komponenten schließen können. Die 3D-Drucke bilden zusammen eine Kugel. Sie sollten gut passen. Wenn die Komponente verloren gehen soll, kleben Sie etwas Klebeband auf die Innenseite, damit die Kappe gefüllt wird. Und wenn es zu dick ist, verwenden Sie Sandpapier.

Drittens sind die Skematics für das Arduino und die Streifen ziemlich einfach. Sie werden 3 Drähte verwenden, um die Streifen mit dem Arduino zu verbinden. Beachten Sie, dass die einzigen Stellen, an denen ich löte, auf den Streifen sind. nicht auf dem Ardruino selbst.

GND geht zu GND

DIN geht an einen Pin (in unserem Fall Pin6 auf dem Arduino)

5V geht zu 5V

Stellen Sie sicher, dass die Anzahl der von Ihnen verwendeten LED-Streifen auf 30 begrenzt ist. Mehr als das und der Code wird nicht ordnungsgemäß ausgeführt. Sie können einfach alle nicht benötigten Streifen, die mit einem Scherenschild angezeigt werden, abschneiden.

Viertens Alles sollte gut in die Kugel passen. Sie könnten wie ich einen Schnittpunkt zwischen 1 des 3D-Drucks machen, um die Mulde zu sehen, und einen Sichttrog-Kunststoff auf die Oberseite legen.

Schritt 4: Codierung

Jetzt sollten Sie also alle benötigten Komponenten in Ihrer Bibliothek haben.

Hier ist der Code, den Sie benötigen, um das Projekt auszuführen. Das Ergebnis sollte wie der Videolink aussehen, den ich auf dieser Seite sende.

Die Quelle dieses Codes finden Sie hier. Dieses Projekt beinhaltet auch die notwendigen Schritte, um den Code und die Algorithmen hinter den Anwendungen besser zu verstehen.

#einschließen #einschließen #einschließen #einschließen

#define PIN 6 // 11 Pixel NeoPixel Strip

#define PIN1 7 // 1 Pixel NeoPixel Strip #define NUMPIXELS 30 // Anzahl der Pixel #define SAMPLE_RATE 25 // Abtastrate für Beschleunigungsmesser und Gyroskop

// Madgwick-Konfiguration

Madgwick-Filter; unsigned long microsPerReading, microsPrevious; float accelScale, gyroScale;

// NeoPixel-Konfiguration

Adafruit_NeoPixel-Pixel = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel PixelStatus = Adafruit_NeoPixel(1, 7, NEO_GRB + NEO_KHZ800);

// Farbräume

RGBConverter rgbConverter; doppeltes h = 1; doppeltes s = 1; doppeltes v = 1; Byte-rgb[3];

// Status-Bewegungslampe

// Zustand 0 -> Farbton auswählen - Tonhöhe // Zustand 1 -> Sättigung auswählen - Rollen // Zustand 2 -> Wert auswählen - Yaw // Zustand 3 -> Farbe fixieren volatile int statusLamp = 0;

Leere Einrichtung () {

Serial.begin (9600);

// IMU starten und filtern

CurieIMU.begin(); CurieIMU.setGyroRate(SAMPLE_RATE); CurieIMU.setAccelerometerRate(SAMPLE_RATE); filter.begin(SAMPLE_RATE);

// Stellen Sie den Beschleunigungsmesserbereich auf 2G. ein

CurieIMU.setAccelerometerRange(2); // Stellen Sie den Gyroskopbereich auf 250 Grad / Sekunde ein CurieIMU.setGyroRange (250);

CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);

CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1); CurieIMU.autoCalibrateGyroOffset();

CurieIMU.attachInterrupt(eventCallback);

CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 950); CurieIMU.interrupts(CURIE_IMU_TAP);

// Variablen initialisieren, um Aktualisierungen zu takten, um die Rate zu korrigieren

microsPerReading = 1000000 / SAMPLE_RATE; microsPrevious = micros();

// NeoPixel 11 initiieren

Pixel.begin(); Pixel.show();

// NeoPixel 1 initialisieren

PixelStatus.begin(); Pixel.show();

// Status in px anzeigen

setStatusPixel(statusLampe); }

Leere Schleife () {

int aix, aiy, aiz; // Beschleunigungsmesser int gix, giy, giz; Schwimmer ax, ay, az; Schwimmer gx, gy, gz; Schwimmrollen, Nicken, Gieren; statisch unsigned long microsNow;

// Überprüfen Sie, ob es Zeit ist, Daten zu lesen und den Filter zu aktualisieren

microsNow = micros(); if (microsNow - microsPrevious >= microsPerReading) {

// Rohdaten von CurieIMU lesen

CurieIMU.readMotionSensor (aix, aiy, aiz, gix, giy, giz);

// Konvertieren von Rohdaten in Gravitations- und Grad/Sekunden-Einheiten

ax = convertRawAcceleration(aix); ay = convertRawAcceleration(aiy); az = convertRawAcceleration(aiz); gx = convertRawGyro(gix); gy = convertRawGyro(giy); gz = convertRawGyro(giz);

// aktualisiere den Filter, der die Orientierung berechnet

filter.updateIMU(gx, gy, gz, ax, ay, az);

// drucke die Überschrift, Nick und Roll

roll = filter.getRoll(); Pitch = filter.getPitch(); yaw = filter.getYaw();

// Inkrementiere die vorherige Zeit, damit wir das richtige Tempo halten

microsPrevious = microsPrevious + microsPerReading;

// Nur wenn Farbton, Sättigung oder Wert geändert werden

if (statusLamp select Hue if (pitch >= -90 && Pitch <= 90 && statusLamp == 0) { // Transformieren Winkel Pitch = Pitch + 90; // Ermittelt Farbkoordinaten aus Winkeln h = Pitch / 180.0; }

// Winkelbeschränkungen

// Roll only -90º to 90º = 180º // State 1 -> select Saturation if (roll >= -90 && roll <= 90 && statusLamp == 1) { // Transform angle roll = roll + 90; // Ermittelt Farbkoordinaten aus Winkeln s = roll / 180.0; }

// Zustand 2 -> Wert auswählen

if (statusLamp == 2) {// Gieren 0º bis 360º v = Gieren / 360,0; }

// Konvertieren in rgb

rgbConverter.hsvToRgb(h, s, v, rgb); /* Serial.print("Farbe:"); Seriendruck (h); Serial.print (" - "); Seriendruck(e); Serial.print (" - "); Serial.print (v); Serial.println(" ");

Serial.print ("Ausrichtung: ");

Serial.print (gieren); Serial.print (" "); Serial.print (Pitch); Serial.print (" "); Serial.println (Rolle); */

// Farbe der Pixel ändern

for (int px = 0; px < NUMPIXELS; px++) { Pixel.setPixelColor(px, Pixel. Color(rgb[0], rgb[1], rgb[2])); Pixel.show(); } }

// Status in px anzeigen

setStatusPixel(statusLampe); } }

float convertRawAcceleration(int aRaw) {

// da wir den 2G-Bereich verwenden // -2g wird einem Rohwert von -32768 zugeordnet // +2g wird einem Rohwert von 32767. zugeordnet

Gleitkomma a = (aRaw * 2,0) / 32768,0;

zurück a; }

float convertRawGyro(int gRaw) {

// da wir einen Bereich von 250 Grad/Sekunden verwenden // -250 wird einem Rohwert von -32768 zugeordnet // +250 wird einem Rohwert von 32767. zugeordnet

Gleitkomma g = (gRaw * 250,0) / 32768,0;

g zurück; }

statisch void eventCallback()

{// Tippen in allen Achsen erkennen, wenn (CurieIMU.getInterruptStatus(CURIE_IMU_TAP)) {Serial.print("Tap erkannte statusLamp:"); Serial.println (statusLamp);

// Zustand ändern

statusLampe++;

// Zustand initialisieren

if (statusLamp > 3) { statusLamp = 0; } } }

void setStatusPixel(int statusPx)

{ Schalter (statusPx) { Fall 0: PixelStatus.setPixelColor(0, PixelStatus. Color(150, 0, 0)); PixelStatus.show(); brechen; Fall 1: PixelStatus.setPixelColor(0, PixelStatus. Color(0, 150, 0)); PixelStatus.show(); brechen; Fall 2: PixelStatus.setPixelColor(0, PixelStatus. Color(0, 0, 150)); PixelStatus.show(); brechen; Fall 3: PixelStatus.setPixelColor(0, PixelStatus. Color(0, 0, 0)); PixelStatus.show(); brechen;

}

}