Afișaj Digilog_Bike POV: 14 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Digilog

Digital + Analog

Digitalul întâlnește analogul

POV

Persistența vizuală

De asemenea, cunoscut sub numele de afișare postimagine, dacă este scuturat la viteză mare, imaginea posterioară rămâne.

Oamenii cred că se uită la videoclipuri când se uită la televizor. Dar, de fapt, se uită la mai multe poze consecutive. Acest lucru este confundat cu o imagine datorită efectului imaginilor rămase pe retine atunci când vizualizăm imagini succesive. Acest tip de iluzie se numește POV.

Pasul 1: Conceptul de idee

POV este implementat prin atașarea unei curele LED la roata unei biciclete.

Pasul 2: Lista materialelor

Calcul și I / O

1. Arduino Mega 2560 [arduino] x3

2. Modul senzor Hall V2 [YwRobot] x3

3. WS2812-5050 Neopixel flexibil [Adafruit] x3

4. Magnetic (diametru de 15 mm, grosime de 50 mm) x3

5. Arduino Mega Case x3

Linie de alimentare

5. Baterie litiu 5000mAh / 3.7V [TheHan] x3

6. Regulator AVR 5V și modul de încărcare și PCM: JBATT-U5-LC [Jcnet] x3

7. 4Kit cablu jumper 65BUC / SET [OR0012] x3

Pasul 3: Instrumente

Nu sunt necesare prea multe instrumente, cu toate acestea, veți avea nevoie de:

1. Mașină de lipit

2. Un fier de lipit

3. Pistol de lipit

4. Nipper

Pasul 4: Realizarea cadrului

Tăierea bicicletei și atașarea bazei

Râșnița a fost folosită pentru a tăia roțile bicicletei de pe bicicletă și a plăcilor de oțel sudate pentru a asigura roțile.

Pasul 5: Schițarea imaginilor și conceptelor finale

Am ales un dragon ca imagine finală. Deoarece valul dragonului părea să fie cel mai bine reprezentat de efectul de postimagine.

Pasul 6: Faceți tăierea imaginii în mișcare

Împărțiți imaginea în trei părți care se vor potrivi pe fiecare bicicletă și împărțiți totalul de 12 imagini după culoare și mișcare.

Pasul 7: Pregătirea software-ului

Subpartea 1. Instalați Arduino

Descărcare Arduino:

(Instalați pentru a se potrivi versiunii și sistemului dvs. de sistem de operare.)

-

Subpartea 2. Instalați biblioteca

* (Dacă doriți să instalați prin Github, vă rugăm să vizitați linkul de mai sus Biblioteca Github Arduino:

1. Rulați programul Arduino

2. Permiteți linkul Meniul de sus - schiță - includeți biblioteca - adăugați biblioteca. Zip

3. Ar trebui să alegeți fișierul. Zip care a instalat deja biblioteca github4

* (Dacă doriți să utilizați serviciile programului Arduino)

1. Rulați programele Arduino

2. Permiteți linkul Meniul de sus - schiță - includeți biblioteca - biblioteca de gestionare - căutați „Adafruit neopixel” - puteți vedea „Adafruit Neopixel by Adafruit”

3. Instalați și actualizați biblioteca

-

Subpartea 3. Instalați programul convertor

1. Instalați programul Rotation Circle (R. C. P):

2. Trebuie să citiți un fișier README

Pasul 8: Realizarea sursei de alimentare hardware

* Acesta este modul în care se furnizează tensiunea Arduino 5V prin baterie. Vă rugăm să urmați pașii de mai jos.

1. Conectați bateria litiu și modulul de încărcare JBATT. (Pentru referință, modulul JBATT are un comutator de alimentare încorporat.)

2. Conectați terminalul de ieșire al JBATT la terminalul Vin al Arduino și terminalul la sol.

3. Conectați portul USB Micro 5pin la portul de încărcare pentru a verifica dacă produsul a funcționat corect.

4. Apoi, rotiți comutatorul încorporat pe ON.

5. Dacă ledul roșu se aprinde și ledul verde se aprinde în Arduino, configurația etapei de alimentare a produsului este finalizată în mod normal.

Pasul 9: Realizarea I / O hardware și verificarea ieșirii (funcționarea NeoPixel)

* Această parte constă din senzor și etapa de ieșire

1. Conectați senzorii Arduino și Hall. Pinul de date se conectează la pinul Arduino 2.

2. Când Arduino este pornit și magnetul este în contact strâns cu senzorul Hall, ledul roșu se va aprinde.

3. Conectați Arduino și Neopixel. Se utilizează doar 30 de Neopixeli.

4. Conectați pinul de date cu pinul Arduino 6.

5. Conectați Arduino și descărcați cablul la portul USB al computerului și rulați Arduino pe computer.

6. Selectați Tool - board - „Arduino / Genuino Mega sau Mega 2560” din bara de meniu de sus a programului Arduino.

7. Verificați dacă există o listă de produse care pot fi conectate direct la port. Dacă nu este bifată, faceți clic pentru a o selecta.

8. Lipiți codul de mai jos și faceți clic pe Încărcare în partea stângă sus. (Ulterior, toate încărcările de programe urmează pașii 5-8.)

9. Configurarea este finalizată când se activează toți cei 30 de pixeli neoled.

# 1. inclusiv fișierul antet și preprocesarea

Mai întâi trebuie să aducem biblioteca Adafruit_NeoPixel care poate acționa Neopixels.

Biblioteca poate fi utilizată declarând obiecte.

Clasa Adafruit_NeoPixel poate introduce 3 parametri în public.

Primul parametru este numărul de LED-uri.

parametrul secunde este numărul pinului conectat la intrarea digitală Neopixel.

Al treilea parametru este de a introduce opțiuni în funcție de caracteristicile produsului. produsul WS2812b în trei culori folosește intrarea „NEO_GRB”

#include

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

# 2. înființat

În partea de configurare, inițializați obiectul și pregătiți-l pentru utilizare.

„Adafruit_Neopixle_Object.begin ()” setează toate LED-urile să se stingă.

„Adafruit_Neopixle_Object.show ()” produce ieșiri cu luminozitatea setată în LED.

configurare nulă () {

strip.begin (); strip.show (); }

# 3. bucla principală

Acțiunea buclei principale utilizează o buclă for pentru a scoate secvențial (0,1 secunde) LED-urile în alb

bucla nulă () {

pentru (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, 255, 255, 255); strip.show (); întârziere (100); }}

Pasul 10: Asamblarea și atașarea la roată

1. Conectați Neopixeli. (Atenție la verificarea numărului de pin)

2. Conectați senzorul Hall. (Consultați Pasul 9)

3. Atașați cadrul la Arduino între biciclete. (Atașați carcasa Arduino paralelă cu cadrul bicicletei).

4. Introduceți Arduino conectat la Neopixel. (Aveți grijă, deoarece pistolul de lipit este fierbinte).

5. Introduceți senzorul Hall conectat în Arduino, (fixați legătura cablului astfel încât senzorul Hall să nu cadă).

6. Lipire pentru conectarea bateriei. (Aveți grijă când lipiți).

7. Fixați-l cu un pistol de lipit. (Atașați modulul de încărcare pe baterie pentru a asigura spațiul).

8. Conectați fiecare linie înainte de a vă conecta la Arduino, 9. Conectați în funcție de fiecare număr de pin. (Conectați liniile de salt pentru modulul de încărcare fără a le deruta).

10. Finalizați cu o pistol de lipit o dată, (Vă rugăm să aveți grijă să nu cadă).

Pasul 11: Verificarea INPUT (date senzor HALL)

* Verificați codul software-ului pentru a vedea dacă senzorul funcționează.

1. Lipiți și încărcați codul de mai jos.

2. Faceți clic pe butonul Serial Monitor din partea dreaptă sus a Arduino.

3. Când magnetul este în contact cu senzorul Hall mai mult de 1 secundă, configurația este finalizată atunci când cuvântul „contact magnetic” apare pe monitorul serial.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- # 1. Definiți numărul pinului și configurația

Primul număr de pin de configurare care utilizează senzorul Hall și setează numărul pinului ca un port numai pentru intrare.

Setați comunicarea pentru a verifica datele senzorului Hall de pe monitorul serial.

#define HALL 2

void setup () {pinMode (HALL, INPUT); Serial.begin (9600); }

# 2. bucla principală

Verificați datele senzorului Hall la intervale de 0,1 secunde.

Dacă magnetul este detectat și datele sunt schimbate, „contact magnetic” este transmis la monitorul serial.

bucla nulă () {

if (digitalRead (HALL)) {Serial.println ("contact magnetic"); } întârziere (100); }

Pasul 12: Algoritm de codare

* Creați logică și codificare pentru a controla Neopixeli pe baza valorilor senzorilor.

1. Lipiți și încărcați codul de mai jos.

2. Este normal ca imaginea să nu fie afișată corect, deoarece nu se produce cadru. Dar puteți vedea că funcționează aproximativ.

3. Atingeți rapid și eliberați senzorul Hall și magnetul în decurs de 1 secundă. Repetați această operație de aproximativ 10 ori.

4. Configurarea este completă atunci când culorile Neopixelilor se schimbă regulat.

# 1. Inclusiv fișiere antet și preprocesare

În primul rând, trebuie să înțelegem că memoria Arduino Mega nu este suficient de mare pentru a conține un fișier imagine.

Prin urmare, fișierul antet „avr / pgmspace” este utilizat pentru a utiliza spațiu de memorie diferit.

Pentru a utiliza Neopixeli, declarați un obiect și configurați un număr PIN I / O.

Matricea de imagini este prea mare pentru codare, deci descărcați și lipiți fișierele atașate.

#include

#include #define PIN 6 #define NUMPIXELS 30 #define HALL 2 Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800); // lipiți matricea în 'image_array_1.txt' // "'image_array_2.txt' //" 'image_array_3.txt' // "'image_array_4.txt'

# 2. Variabilă globală și configurare

Setați o variabilă globală.

Principalul lucru este să setați luminozitatea, a determinat ciclul de viață al produsului.

int count = 0;

dublu v = 0; dublu last_v = 0; timer dublu = micros (); dublu ex_timer = micros (); dublu ultim_timer = micros (); int deg = 36; int pix = 35; int rgb = 3; double q_arr [2] = {0, 0}; int HALL_COUNT = 0; dublu VELO; timer_prelucrare dublă = micros (); void setup () {strip.setBrightness (255); strip.begin (); strip.show (); Serial.begin (230400); }

# 3. bucla principală - partea de ieșire a expresiei imaginii

Acest cod este o afirmație condiționată despre modul de ieșire a timpului rotirii roții prin rezoluție.

Această parte folosește ciclul de rotire a roții bicicletei o dată ca un parametru foarte important.

De asemenea, este important să citiți datele matricei de imagini din memorie.

bucla nulă () {

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 (); } else if (VELO <= 204000) {for (int i = 0 + 5; i = 120)) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Culoare (0, 0, 0)); } strip.show (); }

# 4. bucla principală - procesare și verificare și detectare a timpului ciclului

Aceasta este cea mai importantă parte a întregului sistem.

Mai întâi, verificați timpul necesar pentru executarea întregului cod și reglați timpul de ieșire LED pe ciclu.

Timpul detectat de fiecare dată când roata se învârte prezice ora ciclului următor.

Accelerarea poate fi estimată prin scăderea ultimului ciclu măsurat din timpul ciclului măsurat la timp.

Sistemul calculează timpul de procesare și accelerația pentru a calcula cât timp LED-urile se aprind continuu.

processing_timer = micros ();

if ((digitalRead (HALL) == HIGH) && (HALL_COUNT == 1)) {VELO = v; v = micros () - ultimul_timer; ex_timer = q_arr [0] - q_arr [1] + v; last_timer = micros (); q_arr [0] = q_arr [1]; q_arr [1] = v; număr = 0; HALL_COUNT = 0; } else if (digitalRead (HALL) == LOW) {HALL_COUNT = 1; }}

Pasul 13: Utilizarea software-ului

* Folosiți software pentru a transforma imaginea și a insera datele procesiunii în cod

1. Introduceți imaginea din pasul de mai sus în folderul de imagini din folderul R. C. P instalat în etapa de pregătire.

- Cum să puneți imaginea este după cum urmează. - Redenumiți 4 imagini animate ale produsului # 1 în ordinea 1.png, 2.png, 3-p.webp

2. Rulați fișierul Ver.5.exe.

3. Verificați dacă 12 fișiere pro_1_code_1.txt la pro_3_code_4.txt sunt create în folderul R. C. P.

4. Dacă nu este creat, modificați conținutul config.txt ca fișier de configurare următor.

5. Odată ce fișierul este creat, copiați întregul conținut din fișierul pro_1_code_1.txt și lipiți-l în partea prezentată în codul de mai jos.

6. Adăugați conținutul pro_1_code_2.txt, pro_1_code_3.txt și pro_1_code_4.txt la partea marcată în ordinea a 5-a.

7. Referindu-ne la 5 și 6, pro_2_code …, pro_3_code completează codul în același mod.

Pasul 14: Finalizați

A finalizat producția unui POV care creează o imagine cu trei roți.