Spannung mit einem Ergometer-Fahrrad erzeugen - Gunook

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

Die Ausarbeitung des Projekts bestand in der Zusammenstellung eines „Spiels“mit dem Ziel, in einem Ergometer-Fahrrad zu treten, das mit einem Generator und einem Lampenturm verbunden ist, der mit zunehmender Motordrehzahl aktiviert wird – was entsprechend dem Treten des Fahrrads geschieht. Das System basierte auf dem Auslesen – über einen analogen Port eines Arduino Mega – der erzeugten sofortigen Spannung, der anschließenden Übertragung dieser Daten an einen Raspberry Pi 3 über eine serielle RX-TX-Kommunikation und der anschließenden Aktivierung der Lampen über ein Relais.

Schritt 1: Materialien:

• 1 Himbeer-Pi 3;
• 1 Arduino Mega 2560;
• 1 Relaisschild mit 10 Relais 12 V;
• 10 Glühlampen 127 V;
• 1 Ergometer-Fahrrad;
• 1 Elektrische Maschine (Generator) 12 V;
• Widerstände (1x1kΩ, 2x10kΩ);
• 1 Elektrolytkondensator 10 µF;
• 1 Zenerdiode 5,3 V;
• 1,5 mm Kabel (rot, schwarz, braun);
• 1 MDF-Turm mit Halterung für 10 Lampen.

Schritt 2: Systemblockdiagramm:

Schritt 3: Systembetrieb:

Das System basiert auf der Umwandlung der beim Radfahren erzeugten kinetischen Energie in elektrische Energie, die für die Aktivierung der Relais verantwortlich ist, die die Lampen einschalten.

Die vom Generator erzeugte Spannung wird von einem analogen Pin von Arduino gelesen und über RX-TX an den Raspberry Pi gesendet. Die Ansteuerung der Relais ist proportional zur erzeugten Spannung – je höher die Spannung, desto mehr Relais werden angesteuert und mehr Lampen leuchten.

Schritt 4: Mechanikaspekte

Um den Gleichstromgenerator mechanisch mit dem Fahrrad zu koppeln, musste das Riemensystem durch das gängige Fahrradsystem (bestehend aus Krone, Kette und Ritzel) ersetzt werden. Am Fahrradrahmen wurde eine Metallplatte angeschweißt, damit der Motor mit Schrauben befestigt werden konnte. Danach wurde das Ritzel an die Generatorwelle geschweißt, damit die Kette platziert werden konnte, die das Pedalsystem mit dem Generator verband.

Schritt 5: Spannungsmessung:

Um die Spannung des Generators mit Arduino auszulesen, ist es notwendig, den Pluspol der elektrischen Maschine mit dem A0-Pin des Controllers und den Minuspol mit GND zu verbinden – um zu vermeiden, dass die maximale Spannung des Generators größer als die 5 V des ist Arduino-Pins, ein Spannungsfilter mit einem Kondensator von 10 µF, einem Widerstand von 1 kΩ und einer Zener-Diode von 5,3 V wurden konstruiert und zwischen Controller und Generator geschaltet. Die in Arduino geladene Firmware ist sehr einfach und besteht nur aus dem Lesen eines analogen Ports, dem Multiplizieren des gelesenen Werts mit der Konstanten 0,0048828125 (5/1024, das ist die GPIO-Spannung des Arduino geteilt durch die Anzahl der Bits seines analogen Ports) und das Senden der Variable an die Seriennummer – der Code wird im Artikel verfügbar sein.

Das Verfahren zum Aktivieren der RX-TX-Kommunikation in Raspberry Pi ist etwas komplexer und Sie müssen das im Link beschriebene Verfahren befolgen. Kurz gesagt, Sie müssen eine Datei namens „inittab“bearbeiten – die sich in „/etc/inittab“befindet –, die Zeile „T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100“kommentieren (wenn die Datei nicht im Betriebssystem von Raspberry gegründet, müssen Sie den Befehl „sudo leafpad /boot/config.txt“eingeben und die Zeile „enable_uart=1“an das Ende der Datei anhängen). Sobald dies erledigt ist, müssen Sie das LX-Terminal erneut öffnen und das Serial mit den Befehlen "sudo systemctl stop [email protected]" und "sudo systemctl disable [email protected]" deaktivieren. Danach müssen Sie den Befehl "sudo leafpad /boot/cmdline.txt" ausführen, die Zeile "console = serial0, 115200" löschen, die Datei speichern und das Gerät neu starten. Damit eine RX-TX-Kommunikation möglich ist, muss die Serial Library auf dem Raspberry Pi mit dem Befehl "sudo apt-get install -f python-serial" installiert und die Bibliothek durch Einfügen der Zeile "import serial" in den Code importiert werden, Initialisieren der Seriell durch Einfügen der Zeile "ser = serial. Serial (" / dev / ttyS0 ", 9600)" und Lesen der vom Arduino gesendeten Spannung mit dem Befehl "ser.readline ()" - der vollständige verwendete Code in Raspberry wird am Ende des Artikels zur Verfügung gestellt.

Nach dem oben beschriebenen Verfahren ist der Schritt zum Lesen und Senden der Spannung abgeschlossen.

Schritt 6: Arduino-Programmierung:

Wie bereits erwähnt, ist der Code, der für das Lesen der beim Radfahren erzeugten Spannung verantwortlich ist, sehr einfach.

Zunächst ist es notwendig, den A0-Pin als Verantwortlicher für das Lesen der Spannung zu wählen.

In der Funktion "void setup ()" müssen Sie Pin A0 mit dem Befehl "pinMode(sensor, INPUT)" auf INPUT setzen und die Übertragungsgeschwindigkeit der seriellen Schnittstelle mit dem Befehl "Serial.begin(9600)" auswählen.

In der "void loop ()" wird die Funktion "Serial.flush ()" verwendet, um den Puffer jedes Mal zu löschen, wenn sie das Senden von Informationen über seriell beendet; die Spannungsmessung erfolgt durch die Funktion "analogRead (Sensor)" – wobei zu beachten ist, dass der vom analogen Port gelesene Wert in Volt umgerechnet werden muss – Prozess, der im Abschnitt "Spannung lesen" des Artikels beschrieben wird.

Auch in der Funktion "void loop()" ist es notwendig, die Variable x von float in string umzuwandeln, da nur so die Variable über RX-TX gesendet werden kann. Der letzte Schritt in der Schleifenfunktion besteht darin, den String in der seriellen Schnittstelle zu drucken, damit er an Raspberry gesendet werden kann - dazu müssen Sie die Funktion "Serial.println (y)" verwenden. Die Zeile "delay (100)" wurde dem Code nur hinzugefügt, damit die Variable in Intervallen von 100 ms gesendet wird - wenn diese Zeit nicht eingehalten wird, tritt die Serial Overload auf, was zu möglichen Abstürzen im Programm führt.

voltage_read.ino

Schwimmersensor = A0;

voidsetup() {

PinMode (Sensor, EINGANG);

Serial.begin (9600);

}

Leerschleife () {

Serial.flush();

Float x = analogRead (Sensor) * 0,0048828125 * 16,67;

Zeichenfolge y="";

y+=x;

Serial.println(y);

Verzögerung (100);

}

rawvoltage_read.ino anzeigen, gehostet mit ❤ von GitHub

Schritt 7: Raspberry Pi 3-Programmierung:

Lampen_bike.py

import os #import der os-Bibliothek (wird verwendet, um den Bildschirm bei Bedarf zu löschen)

import RPi. GPIOas gpio #import Bibliothek zur Steuerung des GPIO der Raspnerry

import serial #import-Bibliothek, die für die serielle Kommunikation verantwortlich ist

Importzeit #importbibliothek, die es ermöglicht, die Verzögerungsfunktion zu verwenden

Unterprozess importieren #Bibliothek importieren, die für das Abspielen der Songs verantwortlich ist

#Serie starten

ser = serial. Serial("/dev/ttyS0", 9600) #definiere den Gerätenamen und die Baudrate

#Bildschirm löschen

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

#Pins für Relaissteuerung setzen

gpio.setmode(gpio. BOARD)

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

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

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

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

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

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

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

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

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

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

#Aufzeichnungen starten

name=["Keiner"]*10

Spannung=[0.00]*10

#Datei mit Datensätzen lesen

f =open('Datensätze', 'r')

for i inrange(10): #die 10 besten Ergebnisse erscheinen auf der Liste

name=f.readline()

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

Spannung=f.readline()

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

f.schließen()

klar()

#maximale Spannung einstellen

max=50,00

#schalte die Lampen aus

für i inrange(11, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. HIGH) #auf HIGH gesetzt, die Relais sind ausgeschaltet

#Anfang

whileTrue:

#Einstiegsbild

print"Datensätze:\n"

für ich inrange(10):

Druckname, ":", Spannung, "V"

current_name=raw_input("Schreibe deinen Namen, um zu beginnen: ")

klar()

#Maximalwert ändern

if aktueller_name =="max":

max=input("Schreibe die maximale Spannung: (2 Dezimalstellen)")

klar()

anders:

#Warnung starten

for i inrange(11, 24, 1): #die Schleife beginnt in PIN 11 und endet in PIN 24

if i!=14and i!=17and i!=20: #PIN 14 und 20 sind GND-Pins und 20 ist ein 3,3-V-Pin

gpio.output(i, gpio. LOW) #schalte die Lampen ein

time.sleep(0.5)

k=10

für i inrange (23, 10, -1):

klar()

wenn ich!=14und ich!=17und ich!=20:

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

time.sleep(0.03)

klar()

print"Vorbereiten!\n", k

Zeit. Schlaf(1)

k-=1

gpio.output(i, gpio. HIGH) #schalte die Lampen aus (eine nach der anderen)

subprocess. Popen(['aplay', 'Audios/go.wav']) #spielt die Startmusik

time.sleep(0.03)

klar()

drucken"GO!"

Zeit. Schlaf(1)

klar()

#Spannung lesen

Stromspannung=0.00

Spannung1=0,00

für ich inrange(200):

ser.flushInput()

zurück=Spannung1

voltage1=float(ser.readline()) #sammelt Arduinos Daten, die von RX-TX übertragen werden

klar()

Druckspannung1, "V"

wenn Spannung1>Strom_Spannung:

Strom_Spannung=Spannung1

# Je nach erzeugter Spannung leuchten mehr Lampen.

wenn Spannung1<max/10:

für i inrange(11, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=max/10:

gpio.output(11, gpio. LOW)

für i inrange(12, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=2*max/10:

für i inrange (11, 13, 1):

gpio.output(i, gpio. LOW)

für i inrange(13, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=3*max/10:

für i inrange (11, 14, 1):

gpio.output(i, gpio. LOW)

für i inrange(15, 24, 1):

wenn ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=4*max/10:

für i inrange (11, 16, 1):

wenn ich!=14:

gpio.output(i, gpio. LOW)

für i inrange (16, 24, 1):

wenn ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=5*max/10:

für i inrange (11, 17, 1):

wenn ich!=14:

gpio.output(i, gpio. LOW)

für i inrange(18, 24, 1):

wenn ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=6*max/10:

für i inrange (11, 19, 1):

wenn ich!=14und ich!=17:

gpio.output(i, gpio. LOW)

für i inrange (19, 24, 1):

wenn ich!=20:

gpio.output(i, gpio. HIGH)

wenn Spannung1>=7*max/10:

für i inrange (11, 20, 1):

wenn ich!=14und ich!=17:

gpio.output(i, gpio. LOW)

für i inrange(21, 24, 1):

gpio.output(i, gpio. HIGH)

wenn Spannung1>=8*max/10:

für i inrange (11, 22, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. LOW)

für i inrange(22, 24, 1):

gpio.output(i, gpio. HIGH)

wenn Spannung1>=9*max/10:

für i inrange (11, 23, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. LOW)

gpio.output(23, gpio. HIGH)

wenn Spannung1>=max:

für i inrange (11, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. LOW)

wenn Spannung1

brechen

#schalte die Lampen aus

für i inrange (11, 24, 1):

wenn ich!=14und ich!=17und ich!=20:

gpio.output(i, gpio. HIGH)

#siegmusik

wenn Stromspannung>=max:

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

time.sleep(0.03)

klar()

print"SEHR GUT, DU GEWONNEN!"% (u'\u00c9', u'\u00ca', u'\u00c2')

für ich inrange(10):

für j inrange(11, 24, 1):

wenn j!=14und j!=17und j!=20:

gpio.output(j, gpio. LOW)

time.sleep(0.05)

für j inrange(11, 24, 1):

wenn j!=14und j!=17und j!=20:

gpio.output(j, gpio. HIGH)

time.sleep(0.05)

time.sleep(0.5)

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

time.sleep(0.03)

klar()

print"Spiel beenden…\n", current_voltage, "V"

#Aufzeichnungen

Zeit. Schlaf(1.2)

erreicht=0

für ich inrange(10):

wenn Strom_Spannung > Spannung:

erreicht+=1

Temperatur_Spannung=Spannung

Spannung=Strom_Spannung

Strom_Spannung=Temp_Spannung

temp_name=name

name=aktueller_name

current_name=temp_name

wenn erreicht >0:

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

time.sleep(0.03)

klar()

f =open('Datensätze', 'w')

für ich inrange(10):

f.write(name)

f.write("\n")

f.write(str(Spannung))

f.write("\n")

f.schließen()

klar()

rawlamps_bike.py anzeigen, gehostet mit ❤ von GitHub

Schritt 8: Elektrisches Schema:

Der Arduino und der Raspberry Pi 3 werden von einer 5V-Quelle mit 3A Strom versorgt.

Der Stromkreis beginnt mit dem Anschluss des DC-Generators (mit dem Fahrrad gekoppelt) an den Arduino über einen Spannungsfilter bestehend aus einer Zener-Diode von 5,3 V, einem Kondensator von 10μF und einem Widerstand von 1kΩ – der Filtereingang ist mit dem verbunden Generatorklemmen und der Ausgang ist mit dem A0-Port und dem GND des Controllers verbunden.

Der Arduino ist über RX-TX-Kommunikation mit Raspberry verbunden – durchgeführt über einen Widerstandsteiler mit 10kΩ-Widerständen (erforderlich für die Ports der Controller, die mit unterschiedlichen Spannungen arbeiten).

Die GPIOs des Raspberry Pi sind mit den Relais verbunden, die für das Einschalten der Lampen verantwortlich sind. Der „COM“aller Relais wurde miteinander verbunden und mit der Phase (AC-Netz) verbunden und der „N. O“(normalerweise offen) jedes Relais wurde mit jeder Lampe verbunden und der Neutralleiter des AC-Netzes wurde mit allen Lampen verbunden. Wenn also der für jedes Relais zuständige GPIO aktiviert wird, wird das Relais auf die Phase des Wechselstromnetzes geschaltet und die jeweilige Lampe eingeschaltet.

Schritt 9: Ergebnisse:

Nach der Endmontage des Projekts wurde bestätigt, dass es wie erwartet funktioniert – je nach Geschwindigkeit, mit der der Benutzer auf dem Fahrrad tritt, wird mehr Spannung erzeugt und mehr Lampen leuchten.