Digilog_Bike POV-Anzeige - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Digilog

Digital + Analog

Digital trifft Analog

POV

Beständigkeit des Visuellen

Wird auch als Nachbildanzeige bezeichnet, wenn es mit hoher Geschwindigkeit geschüttelt wird, bleibt Nachbild zurück.

Die Leute denken, sie sehen sich Videos an, wenn sie fernsehen. Tatsächlich sieht er sich jedoch mehrere aufeinanderfolgende Bilder an. Dies wird wegen des Effekts von Nachbildern, die beim Betrachten aufeinanderfolgender Bilder auf unserer Netzhaut verbleiben, mit einem Bild verwechselt. Diese Art von Illusion wird als POV bezeichnet.

Schritt 1: Ideenkonzept

POV wird realisiert, indem ein LED-Band am Rad eines Fahrrads befestigt wird.

Schritt 2: Materialliste

Computer & E/A

1. Arduino Mega 2560 [arduino] x3

2. Hallsensormodul V2 [YwRobot] x3

3. WS2812-5050 Flexibles Neopixel [Adafruit] x3

4. Magnetisch (Durchmesser 15 mm, Dicke 50 mm) x3

5. Arduino Mega-Gehäuse x3

Stromleitung

5. 5000mAh/3,7V Lithiumbatterie [TheHan] x3

6. AVR 5V-Regler & Lade- & PCM-Modul: JBATT-U5-LC [Jcnet] x3

7. 4Jumper Kabelsatz 65PCS/SET [OR0012] x3

Schritt 3: Werkzeuge

Es werden nicht zu viele Werkzeuge benötigt, aber Sie benötigen:

1. Lötmaschine

2. Ein Lötkolben

3. Klebepistole

4. Zange

Schritt 4: Rahmen erstellen

Schneiden des Fahrrads und Anbringen der Basis

Die Schleifmaschine wurde verwendet, um die Fahrradräder vom Fahrrad abzuschneiden und Stahlplatten zu schweißen, um die Räder zu sichern.

Schritt 5: Skizzieren der endgültigen Bilder und Konzepte

Als letztes Bild haben wir einen Drachen ausgewählt. Denn die Welle des Drachen schien am besten durch den Nachbildeffekt dargestellt zu werden.

Schritt 6: Bewegtbild schneiden

Teilen Sie das Bild in drei Teile, die auf jedes Fahrrad passen, und teilen Sie die insgesamt 12 Bilder nach Farbe und Bewegung auf.

Schritt 7: Software vorbereiten

Unterteil 1. Arduino installieren

Arduino-Download:

(Installieren Sie es entsprechend Ihrer Betriebssystemversion und Ihrem System.)

-

Unterteil 2. Bibliothek installieren

*(Wenn Sie über Github installieren möchten, besuchen Sie bitte den Link oben Github Arduino Library:

1. Starten Sie das Arduino-Programm

2. Erlauben Sie den Link Hauptmenü – Skizze – Bibliothek einschließen –. Zip-Bibliothek hinzufügen

3. Sie sollten die. Zip-Datei auswählen, die bereits die github-Bibliothek installiert hat4

*(Wenn Sie die Arduino-Programmdienste verwenden möchten)

1. Arduino-Programme ausführen

2. Erlauben Sie den Link Hauptmenü – Skizze – Bibliothek einschließen – Verwaltungsbibliothek – Suche nach „Adafruit Neopixel“– Sie können „Adafruit Neopixel by Adafruit“sehen.

3. Bibliothek installieren und aktualisieren

-

Unterteil 3. Konverterprogramm installieren

1. Installieren Sie das Rotationskreisprogramm (R. C. P):

2. Sie müssen eine README-Datei lesen

Schritt 8: Hardware-Netzteil herstellen

*So wird die Arduino 5V-Spannung über die Batterie bereitgestellt. Bitte befolgen Sie die folgenden Schritte.

1. Verbinden Sie die Lithiumbatterie und das JBATT-Lademodul. (Als Referenz hat das JBATT-Modul einen eingebauten Netzschalter.)

2. Verbinden Sie den Ausgangsanschluss von JBATT mit dem Vin-Anschluss von Arduino und dem Masseanschluss.

3. Verbinden Sie den Micro-5-Pin-USB-Anschluss mit dem Ladeanschluss, um zu überprüfen, ob das Produkt ordnungsgemäß funktioniert.

4. Als nächstes schalten Sie den eingebauten Schalter auf ON.

5. Wenn in Arduino die rote LED aufleuchtet und die grüne LED aufleuchtet, ist die Konfiguration der Produktendstufe normal abgeschlossen.

Schritt 9: Hardware-E/A durchführen und AUSGABE überprüfen (NeoPixel-Funktion)

*Dieser Teil besteht aus Sensor und Endstufe

1. Schließen Sie die Arduino- und Hall-Sensoren an. Der Daten-Pin wird mit Arduino-Pin 2 verbunden.

2. Wenn das Arduino eingeschaltet ist und der Magnet in engem Kontakt mit dem Hall-Sensor ist, leuchtet die rote LED auf.

3. Verbinden Sie Arduino und Neopixel. Es werden nur 30 Neopixel verwendet.

4. Verbinden Sie den Daten-Pin mit dem Arduino-Pin 6.

5. Verbinden Sie das Arduino- und Download-Kabel mit dem USB-Anschluss Ihres Computers und führen Sie Arduino auf Ihrem Computer aus.

6. Wählen Sie Tool – Board – „Arduino / Genuino Mega oder Mega 2560“aus der oberen Menüleiste des Arduino-Programms.

7. Prüfen Sie, ob eine Liste von Produkten vorhanden ist, die direkt an den Port angeschlossen werden können. Wenn es nicht aktiviert ist, klicken Sie darauf, um es auszuwählen.

8. Fügen Sie den unten stehenden Code ein und klicken Sie oben links auf Hochladen. (Anschließend folgen alle Programm-Uploads den Schritten 5-8.)

9. Die Konfiguration ist abgeschlossen, wenn alle 30 Neoled-Pixel eingeschaltet sind.

#1. inklusive Header-Datei und Vorverarbeitung

Zuerst müssen wir die Bibliothek Adafruit_NeoPixel bringen, die in der Lage ist, Neopixel zu handeln.

Bibliothek kann durch Deklarieren von Objekten verwendet werden.

Die Klasse Adafruit_NeoPixel kann 3 Parameter öffentlich eingeben.

Der erste Parameter ist die Anzahl der LEDs.

Sekunden-Parameter ist die Pin-Nummer, die mit dem Neopixel-Digitaleingang verbunden ist.

Der dritte Parameter ist die Eingabe von Optionen gemäß den Produkteigenschaften. Das dreifarbige WS2812b-Produkt verwendet den 'NEO_GRB'-Eingang

#enthalten

#define PIN 6 Adafruit_NeoPixel-Streifen = Adafruit_Neopixel(30, PIN, NEO_GRB+NEO_KHZ800);

#2. erstellen

Initialisieren Sie im Setup-Teil das Objekt und bereiten Sie es für die Verwendung vor.

'Adafruit_Neopixle_Object.begin()' schaltet alle LEDs aus.

'Adafruit_Neopixle_Object.show()' gibt mit der in der LED eingestellten Helligkeit aus.

Void-Setup () {

strip.begin(); Strip-Show(); }

#3. Hauptschleife

Die Aktion der Hauptschleife verwendet eine for-Schleife, um die LEDs nacheinander (0,1 Sekunden) in Weiß auszugeben

Leere Schleife () {

for(uint16_t i=0;i<strip.numPixels();i++){ strip.setPixelColor(i, 255, 255, 255); Strip-Show(); Verzögerung (100); } }

Schritt 10: Zusammenbauen und Anbringen am Rad

1. Schließen Sie Neopixel an. (Achten Sie auf die Überprüfung der PIN-Nummer)

2. Schließen Sie den Hall-Sensor an. (Siehe Schritt.9)

3. Befestigen Sie den Rahmen zwischen den Fahrrädern am Arduino. (Befestigen Sie das Arduino-Gehäuse parallel zum Fahrradrahmen).

4. Legen Sie das mit Neopixel verbundene Arduino ein. (Seien Sie vorsichtig, da die Klebepistole heiß ist).

5. Stecken Sie den angeschlossenen Hallsensor in Arduino, (sichern Sie den Kabelbinder, damit der Hallsensor nicht abfällt).

6. Löten Sie, um die Batterie anzuschließen. (Vorsicht beim Löten).

7. Fixieren Sie es mit einer Klebepistole. (Befestigen Sie das Lademodul am Akku, um Platz zu schaffen).

8. Stecken Sie jede Leitung ein, bevor Sie eine Verbindung zu Arduino herstellen.

9. Je nach Pin-Nummer einstecken. (Verbinden Sie die Sprungleitungen für das Lademodul, ohne sie zu verwechseln).

10. Beenden Sie einmal mit einer Klebepistole (Bitte achten Sie darauf, nicht zu fallen).

Schritt 11: Überprüfen von INPUT (HALL-Sensordaten)

*Überprüfen Sie den Softwarecode, um zu sehen, ob der Sensor funktioniert.

1. Fügen Sie den folgenden Code ein und laden Sie ihn hoch.

2. Klicken Sie oben rechts auf dem Arduino auf die Schaltfläche Serial Monitor.

3. Wenn der Magnet länger als 1 Sekunde mit dem Hall-Sensor in Kontakt ist, ist die Konfiguration abgeschlossen, wenn auf dem seriellen Monitor das Wort „contact magnet“erscheint.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- #1. PIN-Nummer und Setup definieren

Die erste Konfigurations-Pin-Nummer, um den Hall-Sensor zu verwenden und die Pin-Nummer als Nur-Eingabe-Port festzulegen.

Stellen Sie die Kommunikation ein, um die Daten des Hallsensors auf dem seriellen Monitor zu überprüfen.

#define HALLE 2

Void setup () { PinMode (HALL, INPUT); Serial.begin (9600); }

#2. Hauptschleife

Überprüfen Sie die Hall-Sensordaten in Intervallen von 0,1 Sekunden.

Wenn der Magnet erfasst wird und die Daten geändert werden, wird „kontakt magnetisch“an den seriellen Monitor ausgegeben.

Leere Schleife () {

if (digitalRead (HALL)) {Serial.println ("Kontakt magnetisch"); } Verzögerung (100); }

Schritt 12: Codierungsalgorithmus

*Erstellen Sie Logik und Codierung, um Neopixel basierend auf Sensorwerten zu steuern.

1. Fügen Sie den folgenden Code ein und laden Sie ihn hoch.

2. Es ist normal, dass das Bild nicht richtig angezeigt wird, weil kein Rahmen erzeugt wird. Aber Sie können sehen, dass es ungefähr funktioniert.

3. Berühren Sie den Hall-Sensor und den Magneten schnell und lassen Sie sie innerhalb von 1 Sekunde los. Wiederholen Sie diesen Vorgang etwa 10 Mal.

4. Die Konfiguration ist abgeschlossen, wenn sich die Farben der Neopixel regelmäßig ändern.

#1. Inklusive Header-Dateien und Vorverarbeitung

Zuerst müssen wir verstehen, dass der Speicher des Arduino Mega nicht groß genug ist, um eine Bilddatei aufzunehmen.

Daher wird die Header-Datei 'avr/pgmspace' verwendet, um unterschiedlichen Speicherplatz zu nutzen.

Um Neopixel zu verwenden, deklarieren Sie ein Objekt und konfigurieren eine I/O-Pinnummer.

Das Bild-Array ist zu groß für die Codierung, laden Sie also die angehängten Dateien herunter und fügen Sie sie ein.

#enthalten

#include #define PIN 6 #define NUMPIXELS 30 #define HALL 2 Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800); // Array in 'image_array_1.txt' einfügen // " 'image_array_2.txt' // " 'image_array_3.txt' // " 'image_array_4.txt'

#2. Globale Variable & Einrichtung

Legen Sie eine globale Variable fest.

Die Hauptsache ist, die Helligkeit einzustellen, sie bestimmt den Lebenszyklus des Produkts.

int-Zählung = 0;

doppeltes v = 0; double last_v = 0; doppelter Timer = micros(); double ex_timer = micros(); double last_timer = micros(); int deg = 36; int-Pixel = 35; int-rgb = 3; double q_arr[2] = {0, 0}; int HALL_COUNT = 0; Doppel-VELO; double processing_timer = micros(); Void setup () { strip.setBrightness (255); strip.begin(); Strip-Show(); Serial.begin (230400); }

#3. Hauptschleife - Ausgabeteil des Bildausdrucks

Dieser Code ist eine bedingte Anweisung darüber, wie die Zeit, in der sich das Rad dreht, nach Auflösung ausgegeben wird.

Dieser Teil verwendet den Zyklus des einmaligen Drehens des Fahrradrads als einen sehr wichtigen Parameter.

Außerdem ist es wichtig, Bildfelddaten aus dem Speicher zu lesen.

Leere Schleife () {

if ((count (ex_timer / 120.0) - (micros() - processing_timer))) { timer = micros(); if (VELO > 360000) { for (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_1[count][1])), pgm_read_byte(&(image_1[count][2])), pgm_read_byte(&(image_1[count][0])))); } Strip-Show(); } else if (VELO 264000) { for (int i = 0 + 5; i <pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_2[count][1])), pgm_read_byte(&(image_2[count][2])), pgm_read_byte(&(image_2[count][0])))); } Strip-Show(); } else if (VELO 204000) { for (int i = 0 + 5; i <pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_3[count][1])), pgm_read_byte(&(image_3[count][2])), pgm_read_byte(&(image_3[count][0])))); } Strip-Show(); aufrechtzuerhalten. Sonst if (VELO <= 204000) { for (int i = 0 + 5; i = 120)) { for (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Farbe (0, 0, 0)); } Strip-Show(); }

#4. Hauptschleife - Verarbeitungs- und Zykluszeitprüfung & -erfassung

Dies ist der wichtigste Teil des gesamten Systems.

Überprüfen Sie zunächst die Zeit, die zum Ausführen des gesamten Codes benötigt wird, und passen Sie die LED-Ausgabezeit pro Zyklus an.

Die bei jedem Durchdrehen des Rads erfasste Zeit sagt die Zeit des nächsten Zyklus voraus.

Die Beschleunigung kann geschätzt werden, indem die zuletzt gemessene Zykluszeit von der pünktlich gemessenen Zykluszeit subtrahiert wird.

Das System berechnet die Verarbeitungszeit und Beschleunigung, um zu berechnen, wie lange die LEDs kontinuierlich leuchten.

Processing_timer = micros();

if ((digitalRead (HALL) == HIGH) && (HALL_COUNT == 1)) { VELO = v; v = micros() - last_timer; ex_timer = q_arr[0] – q_arr[1] + v; last_timer = micros(); q_arr[0] = q_arr[1]; q_arr[1] = v; zählen = 0; HALL_COUNT = 0; aufrechtzuerhalten. Sonst if (digitalRead (HALL) == LOW) { HALL_COUNT = 1; } }

Schritt 13: Software verwenden

*Verwenden Sie Software, um das Bild zu transformieren und Prozessionsdaten in den Code einzufügen

1. Fügen Sie das Bild aus dem obigen Schritt in den Bildordner im R. C. P-Ordner ein, der im Vorbereitungsschritt installiert wurde.

- So fügen Sie ein Bild ein. - Benennen Sie 4 animierte Bilder von Produkt Nr. 1 in der Reihenfolge 1.png, 2.png, 3-p.webp

2. Führen Sie die Datei Ver.5.exe aus.

3. Stellen Sie sicher, dass 12 Dateien pro_1_code_1.txt bis pro_3_code_4.txt im R. C. P-Ordner erstellt wurden.

4. Wenn sie nicht erstellt wird, ändern Sie den Inhalt von config.txt in die folgende Konfigurationsdatei.

5. Nachdem die Datei erstellt wurde, kopieren Sie den gesamten Inhalt aus der Datei pro_1_code_1.txt und fügen Sie ihn in den im folgenden Code gezeigten Teil ein.

6. Fügen Sie die Inhalte pro_1_code_2.txt, pro_1_code_3.txt und pro_1_code_4.txt dem markierten Teil in 5. Ordnung hinzu.

7. Unter Bezugnahme auf 5 und 6 vervollständigt der pro_2_code…, pro_3_code den Code auf die gleiche Weise.

Schritt 14: Abschließen

Die Produktion eines POV abgeschlossen, das ein Bild mit drei Rädern erstellt.