Spanning opwek met 'n ergometerfiets: 9 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Die uitwerking van die projek het bestaan uit die samestelling van 'n 'spel' met die doel om in 'n ergometerfiets te trap wat gekoppel is aan 'n kragopwekker en 'n toring lampe wat geaktiveer word namate die enjinsnelheid toeneem - wat gebeur as gevolg van die fiets trap. Die stelsel was gebaseer op die lees van die onmiddellike spanning wat deur die analoogpoort van 'n Arduino Mega gelees is, en dan die data na 'n Raspberry Pi 3 deur middel van seriële RX-TX-kommunikasie en die daaropvolgende aktivering van die lampe via relais.

Stap 1: materiaal:

• 1 Framboos Pi 3;
• 1 Arduino Mega 2560;
• 1 Relay Shield met 10 Relays 12 V;
• 10 gloeilampe 127 V;
• 1 Ergometerfiets;
• 1 Elektriese masjien (kragopwekker) 12 V;
• Weerstande (1x1kΩ, 2x10kΩ);
• 1 Elektrolitiese kondensator 10 µF;
• 1 Zenerdiode 5,3 V;
• 1,5 mm kabel (rooi, swart, bruin);
• 1 MDF -toring met ondersteuning vir 10 lampe.

Stap 2: Diagram van stelselblokke:

Stap 3: Stelselbediening:

Die stelsel is gebaseer op die transformasie van die kinetiese energie wat opgewek word tydens die fietsry met elektriese energie wat verantwoordelik is vir die aktivering van die relais wat die lampe aanskakel.

Die spanning wat deur die generator opgewek word, word gelees deur 'n analoog pen van Arduino en word via RX-TX na die Raspberry Pi gestuur. Die aktivering van die relais is eweredig aan die spanning wat opgewek word - hoe hoër die spanning, hoe meer relais word geaktiveer en meer lampe brand.

Stap 4: Meganiese aspekte

Om die GS -kragopwekker meganies aan die fiets te koppel, moes die gordelstelsel vervang word deur die stelsel wat op gewone fietse gebruik word (bestaande uit 'n kroon, ketting en tandwiel). 'N Metaalplaat is aan die fietsraam gesweis sodat die enjin met skroewe vasgemaak kon word. Daarna is die rondsel aan die generatoras gesweis, sodat die ketting geplaas kon word, wat die pedaalstelsel met die kragopwekker verbind.

Stap 5: Spanningslesing:

Om die spanning van die kragopwekker met behulp van Arduino te lees, is dit nodig om die positiewe pool van die elektriese masjien aan die A0 -pen van die kontroleerder en die negatiewe pool aan die GND te koppel - om te voorkom dat die maksimum spanning van die kragopwekker groter is as die 5 V van die Arduino -penne, 'n spanningsfilter met 'n kapasitor van 10 µF, 'n weerstand van 1 kΩ en 'n Zener -diode van 5,3 V, is gebou en verbind tussen die beheerder en die kragopwekker. Die firmware wat in Arduino gelaai is, is baie eenvoudig en bestaan slegs uit die lees van 'n analoogpoort, vermenigvuldig die waarde wat gelees word met die konstante 0.0048828125 (5/1024, dit is die Arduino se GPIO -spanning gedeel deur die aantal bisse van die analoogpoort) en stuur die veranderlike na die reeks - die kode sal in die artikel beskikbaar wees.

Die prosedure om RX-TX-kommunikasie in Raspberry Pi moontlik te maak, is 'n bietjie meer kompleks, en u moet die prosedure volg wat in die skakel beskryf word. Kortliks moet u 'n lêer met die naam 'inittab' -in '/etc/inittab' -wysig, kommentaar lewer op die reël 'T0: 23: respawn:/sbin/getty -L ttyAMA0 115200 vt100' (as die lêer nie wat in Raspberry se bedryfstelsel gebaseer is, moet u die opdrag: "sudo leafpad /boot/config.txt" invoer en die reël "enable_uart = 1" by die einde van die lêer voeg). Sodra dit gedoen is, moet u die LX Terminal weer oopmaak en die Serial uitskakel met die opdragte "sudo systemctl stop [email protected]" en "sudo systemctl deaktiveer [email protected]". Daarna moet u die opdrag "sudo leafpad /boot/cmdline.txt" uitvoer, die reël "console = serial0, 115200" uitvee, die lêer stoor en die toestel weer begin. Om RX-TX-kommunikasie moontlik te maak, moet die seriële biblioteek op Raspberry Pi geïnstalleer word met die opdrag "sudo apt-get install -f python-serial" en die biblioteek in die kode invoer deur die reël "import serial" in te voeg, die initialisering van die reeks deur die reël "ser = serial. Serial (" / dev / ttyS0 ", 9600)" in te voeg en die spanning van die Arduino te lees met die opdrag "ser.readline ()" - die volledige kode wat gebruik word in Framboos sal aan die einde van die artikel beskikbaar gestel word.

Volgens die prosedure hierbo beskryf, is die lees- en stuurspanningsstap voltooi.

Stap 6: Arduino -programmering:

Soos voorheen gesê, is die kode wat verantwoordelik is vir die lees van die spanning wat opgewek word tydens fietsry, baie eenvoudig.

Eerstens is dit nodig om die A0 -pen te kies as verantwoordelik vir die lees van die spanning.

In die "void setup ()" -funksie moet u pin A0 op INPUT stel met die "pinMode (sensor, INPUT)" opdrag en die transmissiesnelheid van die seriële poort kies met die opdrag "Serial.begin (9600)".

In die "void lus ()" word die "Serial.flush ()" funksie gebruik om die buffer te verwyder elke keer as dit die stuur van inligting via seriële beëindig; die spanningslesing word uitgevoer deur die funksie "analogRead (sensor)" - onthou dat dit nodig is om die waarde wat deur die analoogpoort gelees is, om te skakel na Volt - die proses wat in die afdeling "leesspanning" van die artikel genoem word.

In die funksie "void loop ()" is dit ook nodig om die veranderlike x van float na string om te skakel, aangesien dit die enigste manier is om die veranderlike via RX-TX te stuur. Die laaste stap in die lusfunksie is om die string in die seriële poort te druk sodat dit na Raspberry gestuur kan word - hiervoor moet u die funksie "Serial.println (y)" gebruik. Die reël "vertraging (100)" is slegs by die kode gevoeg sodat die veranderlike met tussenposes van 100 ms gestuur word - as hierdie tyd nie nagekom word nie, sal die seriële oorlading plaasvind, wat moontlike ineenstortings in die program kan veroorsaak.

spanning_lees.ino

vlot sensor = A0;

voidsetup () {

pinMode (sensor, INVOER);

Serial.begin (9600);

}

voidloop () {

Serial.flush ();

float x = analogRead (sensor)*0.0048828125*16.67;

String y = "";

y+= x;

Serial.println (y);

vertraging (100);

}

sien rawvoltage_read.ino aangebied deur ❤ deur GitHub

Stap 7: Raspberry Pi 3 -programmering:

lampe_fiets.py

voer os #in, voer die os -biblioteek in (word gebruik om die skerm skoon te maak indien nodig)

voer RPi. GPIO in as gpio #import -biblioteek wat gebruik word om die GPIO van die Raspnerry te beheer

invoer reeks #import -biblioteek wat verantwoordelik is vir die reekskommunikasie

invoer tyd #import biblioteek wat dit moontlik maak om die vertragingsfunksie te gebruik

invoer subproses #invoerbiblioteek wat verantwoordelik is vir die speel van die liedjies

#begin reeks

ser = serial. Serial ("/dev/ttyS0", 9600) #definieer die toestelnaam en die baud -tempo

#duidelike skerm

duidelik = lambda: os.system ('duidelik')

#stel penne vir aflosbeheer

gpio.setmode (gpio. BOARD)

gpio.setup (11, gpio. OUT) #lamp 10

gpio.setup (12, gpio. OUT) #lamp 9

gpio.setup (13, gpio. OUT) #lamp 8

gpio.setup (15, gpio. OUT) #lamp 7

gpio.setup (16, gpio. OUT) #lamp 6

gpio.setup (18, gpio. OUT) #lamp 5

gpio.setup (19, gpio. OUT) #lamp 4

gpio.setup (21, gpio. OUT) #lamp 3

gpio.setup (22, gpio. OUT) #lamp 2

gpio.setup (23, gpio. OUT) #lamp 1

#begin rekords

name = ["Geen"]*10

spanning = [0.00]*10

#lees rekords lêer

f = oop ('rekords', 'r')

vir i inrange (10): #die 10 beste tellings verskyn op die lys

naam = f.readline ()

naam = naam [: len (naam )-1]

spanning = f.readline ()

spanning = float (spanning [: len (spanning )-1])

f.close ()

duidelik ()

#stel die maksimum spanning in

maksimum = 50,00

#skakel die lampe af

vir i inrange (11, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH) #ingestel op HOOG, die aflosse is afgeskakel

#begin

terwyl dit waar is:

#aanvanklike skerm

druk "Rekords: / n"

vir i inrange (10):

druknaam , ":", spanning , "V"

current_name = raw_input ("Skryf u naam om te begin:")

duidelik ()

#Verander die maksimum waarde

as current_name == "max":

max = input ("Skryf die maksimum spanning: (2 desimale plekke)")

duidelik ()

anders:

#begin waarskuwing

vir i inrange (11, 24, 1): #die lus begin in die PIN 11 en stop met PIN 24

as i! = 14 en i! = 17 en i! = 20: #PIN 14 en 20 is GND -penne en 20 is 'n 3.3 V -pen

gpio.output (i, gpio. LOW) #skakel die lampe aan

tyd. slaap (0,5)

k = 10

vir i inrange (23, 10, -1):

duidelik ()

as ek! = 14en ek! = 17en ek! = 20:

subproses. Popen (['aplay', 'Audios/'+str (k)+'. wav'])

tyd. slaap (0,03)

duidelik ()

druk "Berei voor! / n", k

tyd. slaap (1)

k- = 1

gpio.output (i, gpio. HIGH) #skakel die lampe af (een vir een)

subproses. Popen (['aplay', 'Audios/go.wav']) #speel die beginmusiek

tyd. slaap (0,03)

duidelik ()

druk "GO!"

tyd. slaap (1)

duidelik ()

#spanning gelees

stroomspanning = 0.00

spanning1 = 0,00

vir i inrange (200):

ser.flushInput ()

vorige = spanning1

voltage1 = float (ser.readline ()) #collect data van Arduino wat deur RX-TX oorgedra is

duidelik ()

druk spanning1, "V"

as spanning1> stroomspanning:

stroomspanning = spanning1

# afhangende van die spanning wat opgewek word, brand meer lampe.

as spanning1 <maks/10:

vir i inrange (11, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = maksimum/10:

gpio.output (11, gpio. LOW)

vir i inrange (12, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 2*maksimum/10:

vir i inrange (11, 13, 1):

gpio.output (i, gpio. LOW)

vir i inrange (13, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 3*maksimum/10:

vir i inrange (11, 14, 1):

gpio.output (i, gpio. LOW)

vir i inrange (15, 24, 1):

as ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 4*maksimum/10:

vir i inrange (11, 16, 1):

as ek! = 14:

gpio.output (i, gpio. LOW)

vir i inrange (16, 24, 1):

as ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 5*maks/10:

vir i inrange (11, 17, 1):

as ek! = 14:

gpio.output (i, gpio. LOW)

vir i inrange (18, 24, 1):

as ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 6*maks/10:

vir i inrange (11, 19, 1):

as ek! = 14en ek! = 17:

gpio.output (i, gpio. LOW)

vir i inrange (19, 24, 1):

as ek! = 20:

gpio.output (i, gpio. HIGH)

as spanning1> = 7*maks/10:

vir i inrange (11, 20, 1):

as ek! = 14en ek! = 17:

gpio.output (i, gpio. LOW)

vir i inrange (21, 24, 1):

gpio.output (i, gpio. HIGH)

as spanning1> = 8*maks/10:

vir i inrange (11, 22, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. LOW)

vir i inrange (22, 24, 1):

gpio.output (i, gpio. HIGH)

as spanning1> = 9*maks/10:

vir i inrange (11, 23, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. LOW)

gpio.output (23, gpio. HIGH)

as spanning1> = maksimum:

vir i inrange (11, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. LOW)

as spanning1

breek

#skakel die lampe af

vir i inrange (11, 24, 1):

as ek! = 14en ek! = 17en ek! = 20:

gpio.output (i, gpio. HIGH)

#oorwinningsmusiek

as stroomspanning> = maksimum:

subproses. Popen (['aplay', 'Audios/rocky.wav'])

tyd. slaap (0,03)

duidelik ()

druk "BAIE GOED, U WEN!"% (u '\u00c9', u '\u00ca', u '\u00c2')

vir i inrange (10):

vir j inrange (11, 24, 1):

as j! = 14en j! = 17en j! = 20:

gpio.output (j, gpio. LOW)

tyd. slaap (0,05)

vir j inrange (11, 24, 1):

as j! = 14en j! = 17en j! = 20:

gpio.output (j, gpio. HIGH)

tyd. slaap (0,05)

tyd. slaap (0,5)

subproses. Popen (['aplay', 'Audios/end.wav'])

tyd. slaap (0,03)

duidelik ()

druk "Beëindig spel … / n", stroomspanning, "V"

#rekords

tyd. slaap (1.2)

bereik = 0

vir i inrange (10):

as stroomspanning> spanning :

bereik+= 1

temp_voltage = spanning

spanning = stroomspanning

current_voltage = temp_voltage

temp_name = naam

naam = huidige naam

current_name = temp_name

indien bereik> 0:

subproses. Popen (['aplay', 'Audios/record.wav'])

tyd. slaap (0,03)

duidelik ()

f = oop ('rekords', 'w')

vir i inrange (10):

f. skryf (naam )

skryf ("\ n")

f. skryf (str (spanning ))

skryf ("\ n")

f.close ()

duidelik ()

sien rawlamps_bike.py aangebied deur ❤ deur GitHub

Stap 8: Elektriese skema:

Die Arduino en die Raspberry Pi 3 word aangedryf deur 'n 5V bron met 3A stroom.

Die elektriese stroombaan begin met die aansluiting van die GS -kragopwekker (gekoppel aan die fiets) met die Arduino deur 'n spanningsfilter wat bestaan uit 'n Zenerdiode van 5.3V, 'n kapasitor van 10μF en 'n weerstand van 1kΩ - die filterinvoer is gekoppel aan die generator terminale en die uitset is gekoppel aan die A0 poort en die GND van die kontroleerder.

Die Arduino is via RX-TX-kommunikasie met Raspberry verbind-uitgevoer deur 'n weerstandsdeler met behulp van 10kΩ weerstande (benodig deur die beheerders se poorte wat op verskillende spannings werk).

Raspberry Pi se GPIO's is gekoppel aan die relais wat verantwoordelik is vir die aanskakel van die lampe. Die "COM" van alle relais is met mekaar verbind en aan die fase (wisselstroomnet) gekoppel en die "N. O" (normaalweg oop) van elke relais is aan elke lamp gekoppel en die neutraal van die wisselstroomnet is met al die lampe verbind. Wanneer die GPIO wat vir elke relais verantwoordelik is, geaktiveer word, word die relais oorgeskakel na die fase van die AC -netwerk en skakel die onderskeie lamp aan.

Stap 9: Resultate:

Na die finale samestelling van die projek is geverifieer dat dit werk soos verwag - volgens die snelheid wat die gebruiker op die fiets trap, word meer spanning opgewek en meer lampe brand.