Digilog_Bike POV-weergave: 14 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Digilog

Digitaal + Analoog

Digitaal ontmoet analoog

POV

Persistentie van visueel

Ook bekend als nabeeldweergave, blijft er nabeeld achter als het met hoge snelheid wordt geschud.

Mensen denken dat ze naar video kijken als ze tv kijken. Maar in feite kijkt hij naar meerdere opeenvolgende foto's. Dit wordt aangezien voor een afbeelding vanwege het effect van nabeelden die op ons netvlies achterblijven bij het bekijken van opeenvolgende foto's. Dit soort illusie wordt een POV genoemd.

Stap 1: Ideeconcept

POV wordt geïmplementeerd door een LED-riem aan het wiel van een fiets te bevestigen.

Stap 2: Materialenlijst

Computer & I/O

1. Arduino Mega 2560 [arduino] x3

2. Hall-sensormodule V2 [YwRobot] x3

3. WS2812-5050 Flexibele Neopixel [Adafruit] x3

4. Magnetisch (diameter van 15 mm, dikte van 50 mm) x3

5. Arduino Mega Case x3

Hoogspanningslijn

5. 5000mAh/3.7V lithiumbatterij [TheHan] x3

6. AVR 5V-regelaar & opladen & PCM-module: JBATT-U5-LC [Jcnet] x3

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

Stap 3: Gereedschap

Niet te veel gereedschap nodig, maar je hebt wel nodig:

1. Soldeermachine

2. Een soldeerbout

3. Lijmpistool

4. Nipper

Stap 4: Frame maken

De fiets afsnijden en de basis bevestigen

De slijper werd gebruikt om de fietswielen van de fiets af te snijden en stalen platen te lassen om de wielen vast te zetten.

Stap 5: definitieve afbeeldingen en concepten schetsen

We kozen een draak als de uiteindelijke afbeelding. Omdat de golf van de draak het beste leek te worden weergegeven door het nabeeldeffect.

Stap 6: Bewegend beeld knippen

Verdeel de afbeelding in drie delen die op elke fiets passen en deel het totaal van 12 afbeeldingen op kleur en beweging.

Stap 7: Software voorbereiden

Subdeel 1. Installeer Arduino

Arduino downloaden:

(Installeer om te passen bij uw OS-versie en systeem.)

-

Sub deel 2. Bibliotheek installeren

*(Als je via Github wilt installeren, bezoek dan de link hierboven Github Arduino Library:

1. Voer het Arduino-programma uit

2. Sta de link toe Top menu – schets – bibliotheek opnemen – voeg. Zip bibliotheek toe

3. U moet het. Zip-bestand kiezen dat de github-bibliotheek al heeft geïnstalleerd4

*(Als u de Arduino-programmaservices wilt gebruiken)

1. Voer Arduino-programma's uit

2. Sta de link toe Hoofdmenu – schets – bibliotheek opnemen – beheerbibliotheek – zoeken op ‘Adafruit neopixel’ – je kunt ‘Adafruit Neopixel by Adafruit’ zien

3. Bibliotheek installeren en bijwerken

-

Sub deel 3. Installeer het conversieprogramma

1. Installeer het Rotation Circle-programma (R. C. P):

2. U moet een README-bestand lezen

Stap 8: Hardware voeding maken

*Dit is hoe je Arduino 5V-spanning via de batterij kunt leveren. Volg de onderstaande stappen.

1. Sluit de lithiumbatterij en de JBATT-oplaadmodule aan. (Ter referentie: de JBATT-module heeft een ingebouwde aan/uit-schakelaar.)

2. Sluit de uitgangsterminal van JBATT aan op de Vin-terminal van de Arduino en de Ground-terminal.

3. Sluit de Micro 5-pins usb-poort aan op de oplaadpoort om te controleren of het product goed heeft gewerkt.

4. Zet vervolgens de ingebouwde schakelaar op ON.

5. Als de rode led oplicht en de groene led oplicht in Arduino, is de configuratie van de vermogensfase van het product normaal voltooid.

Stap 9: Hardware I/O maken & OUTPUT controleren (NeoPixel werkt)

*Dit onderdeel bestaat uit sensor en eindtrap

1. Sluit de Arduino- en Hall-sensoren aan. De data-pin maakt verbinding met Arduino-pin 2.

2. Wanneer de Arduino is ingeschakeld en de magneet in nauw contact staat met de Hall-sensor, gaat de rode led branden.

3. Sluit Arduino en Neopixel aan. Er worden slechts 30 Neopixels gebruikt.

4. Verbind de data-pin met Arduino-pin 6.

5. Sluit de Arduino- en downloadkabel aan op de USB-poort van uw computer en voer Arduino uit op uw computer.

6. Selecteer Tool – board – “Arduino / Genuino Mega of Mega 2560” in de bovenste menubalk van het Arduino-programma.

7. Controleer of er een lijst is met producten die direct op de poort kunnen worden aangesloten. Als het niet is aangevinkt, klikt u erop om het te selecteren.

8. Plak de onderstaande code en klik linksboven op Uploaden. (Daarna volgen alle programma-uploads stappen 5-8.)

9. De configuratie is voltooid wanneer alle 30 neoled-pixels zijn ingeschakeld.

#1. inclusief headerbestand en voorbewerking

Eerst moeten we de bibliotheek Adafruit_NeoPixel brengen die Neopixels kan gebruiken.

Bibliotheek kan worden gebruikt door objecten te declareren.

De klasse Adafruit_NeoPixel kan 3 parameters in het openbaar invoeren.

De eerste parameter is het aantal LED's.

seconden parameter is het pinnummer dat is aangesloten op de digitale ingang van Neopixel.

De derde parameter is om opties in te voeren op basis van de productkenmerken. driekleuren WS2812b-product gebruikt de 'NEO_GRB'-invoer

#erbij betrekken

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

#2. opstelling

In het setup-gedeelte initialiseert u het object en maakt u het klaar voor gebruik.

'Adafruit_Neopixle_Object.begin()' stelt alle LED's in om uit te gaan.

'Adafruit_Neopixle_Object.show()' wordt uitgevoerd met de helderheid ingesteld in de LED.

ongeldige setup(){

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

#3. Hoofdlus

De actie van de hoofdlus maakt gebruik van een for-lus om de LED's achtereenvolgens (0,1 seconden) in wit uit te voeren

lege lus(){

for(uint16_t i=0;i<strip.numPixels();i++){ strip.setPixelColor(i, 255, 255, 255); strip.show(); vertraging (100); } }

Stap 10: Assembleren en bevestigen aan het wiel

1. Sluit Neopixels aan. (Let op pincode check)

2. Sluit de Hall-sensor aan. (Zie stap.9)

3. Bevestig het frame aan de Arduino tussen de fietsen. (Bevestig de Arduino-koffer parallel aan het fietsframe).

4. Plaats de Arduino die is aangesloten op Neopixel. (Wees voorzichtig, want het lijmpistool is heet).

5. Steek de aangesloten Hall-sensor in Arduino, (Beveilig de kabelbinder zodat de Hall-sensor er niet af valt).

6. Soldeer om de batterij aan te sluiten. (Wees voorzichtig bij het solderen).

7. Bevestig het met een lijmpistool. (Bevestig de oplaadmodule op de batterij om ruimte vrij te maken).

8. Sluit elke lijn aan voordat u verbinding maakt met Arduino, 9. Sluit aan volgens elk pinnummer. (Sluit de springlijnen voor de laadmodule aan zonder ze te verwarren).

10. Werk een keer af met een lijmpistool (pas op dat u niet valt).

Stap 11: INPUT controleren (HALL-sensorgegevens)

*Controleer de softwarecode om te zien of de sensor werkt.

1. Plak en upload de onderstaande code.

2. Klik op de Serial Monitor-knop in de rechterbovenhoek van de Arduino.

3. Wanneer de magneet langer dan 1 seconde in contact is met de Hall-sensor, is de configuratie voltooid wanneer het woord "contact magnetisch" op de seriële monitor verschijnt.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- #1. Pincode en instellingen definiëren

Het eerste configuratiepinnummer om de Hall-sensor te gebruiken en het pinnummer in te stellen als een alleen-invoerpoort.

Stel de communicatie in om de gegevens van de Hall-sensor op de seriële monitor te controleren.

#define HAL 2

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

#2. Hoofdlus

Controleer de Hall-sensorgegevens met intervallen van 0,1 seconde.

Als de magneet wordt gedetecteerd en de gegevens worden gewijzigd, wordt "contact magnetisch" uitgevoerd naar de seriële monitor.

lege lus(){

if (digitalRead (HALL)) { Serial.println ("contact magnetisch"); } vertraging(100); }

Stap 12: Codeeralgoritme

*Creëer logica en codering om Neopixels te besturen op basis van sensorwaarden.

1. Plak en upload de onderstaande code.

2. Het is normaal dat de afbeelding niet goed wordt weergegeven omdat er geen kader wordt geproduceerd. Maar je kunt zien dat het ongeveer werkt.

3. Raak de Hall-sensor en magneet snel aan en laat deze binnen 1 seconde los. Herhaal deze handeling ongeveer 10 keer.

4. De configuratie is voltooid wanneer de kleuren van de Neopixels regelmatig veranderen.

#1. Inclusief header-bestanden en voorbewerking

Ten eerste moeten we begrijpen dat het geheugen van de Arduino Mega niet groot genoeg is voor een afbeeldingsbestand.

Daarom wordt het headerbestand 'avr/pgmspace' gebruikt om verschillende geheugenruimte te gebruiken.

Om Neopixels te gebruiken, declareert u een object en configuratie een I/O-pincode.

De afbeeldingsreeks is te groot om te coderen, dus download en plak de bijgevoegde bestanden.

#erbij betrekken

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

#2. Globale variabele & setup

Stel een globale variabele in.

Het belangrijkste is om de helderheid in te stellen, het was bepalend voor de levenscyclus van het product.

aantal int = 0;

dubbele v = 0; dubbele last_v = 0; dubbele timer = micros(); dubbele ex_timer = micros(); dubbele last_timer = micros(); int deg = 36; int pix = 35; int rgb = 3; dubbele q_arr[2] = {0, 0}; int HALL_COUNT = 0; dubbele VELO; dubbele processing_timer = micros(); void setup(){ strip.setBrightness(255); strip.begin(); strip.show(); Serieel.begin(230400); }

#3. hoofdlus - uitvoergedeelte voor beeldexpressie

Deze code is een voorwaardelijke verklaring over hoe de tijd dat het wiel draait op resolutie kan worden uitgevoerd.

Dit deel gebruikt de cyclus van het eenmaal draaien van het fietswiel als een zeer belangrijke parameter.

Het is ook belangrijk om beeldarraygegevens uit het geheugen te lezen.

lege lus() {

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. Kleur (0, 0, 0)); } strip.show(); }

#4. hoofdlus - verwerking en cyclustijdcontrole & sensing

Dit is het belangrijkste onderdeel van het hele systeem.

Controleer eerst de tijd die nodig is om de volledige code uit te voeren en pas de LED-uitgangstijd per cyclus aan.

De tijd die wordt gemeten elke keer dat het wiel draait, voorspelt de tijd van de volgende cyclus.

Versnelling kan worden geschat door de laatst gemeten cyclustijd af te trekken van de gemeten cyclustijd op tijd.

Het systeem berekent de verwerkingstijd en versnelling om te berekenen hoe lang de LED's continu branden.

processing_timer = micros();

if ((digitalRead (HALL) == HOOG) && (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; aantal = 0; HALL_COUNT = 0; } else if (digitalRead (HALL) == LAAG) { HALL_COUNT = 1; } }

Stap 13: Software gebruiken

*Gebruik software om de afbeelding te transformeren en processiegegevens in de code in te voegen

1. Plaats de afbeelding van de bovenstaande stap in de afbeeldingsmap in de R. C. P-map die in de voorbereidingsstap is geïnstalleerd.

- Hoe u een afbeelding plaatst, gaat als volgt. - Hernoem 4 geanimeerde afbeeldingen van product # 1 in volgorde van 1.png, 2.png, 3-p.webp

2. Voer het bestand Ver.5.exe uit.

3. Controleer of er 12 bestanden pro_1_code_1.txt naar pro_3_code_4.txt zijn gemaakt in de R. C. P-map.

4. Als het niet is gemaakt, wijzigt u de inhoud van config.txt als het volgende configuratiebestand.

5. Zodra het bestand is gemaakt, kopieert u de volledige inhoud van het bestand pro_1_code_1.txt en plakt u het in het gedeelte dat wordt weergegeven in de onderstaande code.

6. Voeg de inhoud pro_1_code_2.txt, pro_1_code_3.txt en pro_1_code_4.txt toe aan het gemarkeerde deel in de 5e volgorde.

7. Verwijzend naar 5 en 6, de pro_2_code…, pro_3_code voltooit de code op dezelfde manier.

Stap 14: Voltooien

De productie van een POV voltooid waarmee één afbeelding met drie wielen wordt gemaakt.