Generazione di tensione con una bici ergonomica: 9 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

L'elaborazione del progetto è consistita nell'assemblaggio di un "gioco" con l'obiettivo di pedalare in una bicicletta ergometrica collegata a un generatore e una torre di lampade che si attivano all'aumentare della velocità del motore - che avviene in base alla pedalata della bicicletta. Il sistema si basava sulla lettura – tramite una porta analogica di un Arduino Mega – della tensione istantanea generata, trasmettendo poi questi dati ad un Raspberry Pi 3 tramite comunicazione seriale RX-TX e la successiva attivazione delle lampade tramite relè.

Fase 1: Materiali:

• 1 Lampone Pi 3;
• 1 Arduino Mega 2560;
• 1 Relè Schermo con 10 Relè 12 V;
• 10 lampade ad incandescenza 127 V;
• 1 Bicicletta Ergometro;
• 1 Macchina Elettrica (Generatore) 12 V;
• Resistori (1x1kΩ, 2x10kΩ);
• 1 Condensatore Elettrolitico 10 µF;
• 1 Diodo Zener 5,3 V;
• Cavo da 1,5 mm (rosso, nero, marrone);
• 1 torre in MDF con supporto per 10 lampade.

Passaggio 2: diagramma a blocchi di sistema:

Passaggio 3: funzionamento del sistema:

Il sistema si basa sulla trasformazione dell'energia cinetica generata durante la pedalata della bicicletta in energia elettrica responsabile dell'attivazione dei relè che accenderanno le lampade.

La tensione generata dal generatore viene letta da un pin analogico di Arduino e inviata tramite RX-TX al Raspberry Pi. L'attivazione dei relè è proporzionale alla tensione generata: maggiore è la tensione, più relè verranno attivati e più lampade si accendono.

Passaggio 4: aspetti meccanici

Per accoppiare meccanicamente il generatore DC alla bicicletta, il sistema a cinghia doveva essere sostituito dal sistema utilizzato sulle biciclette comuni (composto da corona, catena e pignone). Una piastra metallica è stata saldata al telaio della bicicletta in modo che il motore potesse essere fissato con viti. Successivamente, il pignone è stato saldato all'albero del generatore in modo da poter posizionare la catena, collegando il sistema di pedali al generatore.

Passaggio 5: lettura della tensione:

Per leggere la tensione del generatore tramite Arduino è necessario collegare il polo positivo della macchina elettrica al pin A0 del controller e il polo negativo al GND – per evitare che la tensione massima del generatore sia maggiore dei 5 V del Pin Arduino, un filtro di tensione che utilizza un condensatore da 10 µF, un resistore da 1 kΩ e un diodo Zener da 5,3 V è stato costruito e collegato tra il controller e il generatore. Il firmware caricato in Arduino è molto semplice e consiste solo nel leggere una porta analogica, moltiplicare il valore letto per la costante 0.0048828125 (5/1024, ovvero la tensione GPIO di Arduino divisa per il numero di bit della sua porta analogica) e inviare il variabile al Seriale – il codice sarà disponibile nell'articolo.

La procedura per abilitare la comunicazione RX-TX in Raspberry Pi è un po' più complessa e devi seguire la procedura descritta nel link. In breve, devi modificare un file chiamato “inittab” – che si trova in “/etc/inittab” –, commentare la riga “T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100” (se il file non è fondata nel sistema operativo Raspberry, è necessario inserire il comando: "sudo leafpad /boot/config.txt" e aggiungere la riga "enable_uart=1" alla fine del file). Fatto ciò, è necessario riaprire il Terminale LX e disabilitare il Serial con i comandi "sudo systemctl stop [email protected]" e "sudo systemctl disable [email protected]". Dopodiché devi eseguire il comando "sudo leafpad /boot/cmdline.txt", eliminare la riga "console = serial0, 115200", salvare il file e riavviare il dispositivo. Affinché sia possibile la comunicazione RX-TX, la libreria Serial deve essere installata su Raspberry Pi con il comando "sudo apt-get install -f python-serial" e importare la libreria nel codice inserendo la riga "import serial", inizializzando la seriale inserendo la riga "ser = serial. Serial (" / dev / ttyS0 ", 9600)" e la lettura della tensione inviata da Arduino tramite il comando “ser.readline()” – il codice completo utilizzato in Raspberry sarà reso disponibile alla fine dell'articolo.

Seguendo la procedura sopra descritta, la fase di lettura e invio della tensione è completata.

Passaggio 6: Programmazione Arduino:

Come affermato in precedenza, il codice responsabile della lettura della tensione generata durante la pedalata è molto semplice.

Innanzitutto è necessario scegliere il pin A0 come responsabile della lettura della tensione.

Nella funzione "void setup ()", è necessario impostare il pin A0 su INPUT con il comando "pinMode(sensor, INPUT)" e selezionare la velocità di trasmissione della porta seriale utilizzando il comando "Serial.begin(9600)".

Nel "void loop()", la funzione "Serial.flush()" viene utilizzata per cancellare il buffer ogni volta che termina l'invio di informazioni via seriale; la lettura della tensione viene effettuata dalla funzione "analogRead (sensor)" – ricordando che è necessario convertire il valore letto dalla porta analogica in Volt – processo citato nella sezione "lettura della tensione" dell'articolo.

Inoltre, nella funzione "void loop()", è necessario convertire la variabile x da float a stringa, poiché questo è l'unico modo per inviare la variabile tramite RX-TX. L'ultimo passaggio nella funzione loop è stampare la stringa nella porta seriale in modo che possa essere inviata a Raspberry - per questo è necessario utilizzare la funzione "Serial.println (y)". Al codice è stata aggiunta la riga "delay (100)" solo in modo che la variabile venga inviata ad intervalli di 100 ms - se questo tempo non viene rispettato si verificherà il Serial overload, generando possibili crash del programma.

voltage_read.ino

sensore galleggiante = A0;

voidsetup() {

pinMode(sensore, INGRESSO);

Serial.begin(9600);

}

voidloop() {

Serial.flush();

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

Stringa y="";

y+=x;

Serial.println(y);

ritardo(100);

}

visualizza rawvoltage_read.ino ospitato con ❤ da GitHub

Passaggio 7: Programmazione Raspberry Pi 3:

lamp_bike.py

import os #import la libreria del sistema operativo (usata per cancellare lo schermo quando necessario)

import RPi. GPIOas gpio #import libreria usata per controllare il GPIO di Raspnerry

import serial #import libreria responsabile della comunicazione seriale

import time #import libreria che permette di utilizzare la funzione delay

import subprocess #import libreria responsabile della riproduzione dei brani

#inizio seriale

ser = serial. Serial("/dev/ttyS0", 9600) #definisce il nome del dispositivo e la velocità di trasmissione

#schermo pulito

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

#impostare i pin per il controllo del relè

gpio.setmode(gpio. BOARD)

gpio.setup(11, gpio. OUT) #lampada 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) #lampada 5

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

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

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

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

#iniziare a registrare

nome=["Nessuno"]*10

tensione=[0,00]*10

#leggi il file dei record

f =open('record', 'r')

for i inrange(10): #i 10 migliori punteggi appaiono nell'elenco

nome=f.readline()

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

tensione=f.readline()

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

f.chiudi()

chiaro()

#imposta la tensione massima

max=50.00

#spegni le lampade

per i inrange(11, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. HIGH) #set su HIGH, i relè sono spenti

#cominciare

mentreVero:

#schermata iniziale

print"Record:\n"

per i inrange(10):

stampa nome, ":", tensione, "V"

current_name=raw_input("Scrivi il tuo nome per iniziare: ")

chiaro()

#Cambia valore massimo

if nome_corrente =="max":

max=input("Scrivi la tensione massima: (2 decimali)")

chiaro()

altro:

#avvia di avvio

for i inrange(11, 24, 1): #il loop inizia nel PIN 11 e si ferma nel PIN 24

se i!=14e i!=17e i!=20: #PIN 14 e 20 sono pin GND e 20 è un pin da 3,3 V

gpio.output(i, gpio. LOW) #accendi le lampade

tempo.sonno(0.5)

k=10

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

chiaro()

se io!=14e io!=17e io!=20:

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

tempo.sonno(0.03)

chiaro()

print"Preparati!\n", k

tempo.sonno(1)

k-=1

gpio.output(i, gpio. HIGH) #spegni le lampade (una per una)

subprocess. Popen(['aplay', 'Audios/go.wav']) #riproduce la musica iniziale

tempo.sonno(0.03)

chiaro()

stampa"VAI!"

tempo.sonno(1)

chiaro()

#tensione letta

tensione_corrente=0.00

tensione1=0,00

per i inrange(200):

ser.flushInput()

precedente=tensione1

voltage1=float(ser.readline()) #raccoglie i dati di Arduino trasferiti da RX-TX

chiaro()

tensione di stampa1, "V"

se tensione1>corrente_tensione:

corrente_tensione=tensione1

# a seconda della tensione generata si accendono più lampade.

se tensione1<max/10:

per i inrange(11, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=max/10:

gpio.output(11, gpio. LOW)

per i inrange (12, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=2*max/10:

per i inrange (11, 13, 1):

gpio.output(i, gpio. LOW)

per i inrange(13, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=3*max/10:

per i inrange (11, 14, 1):

gpio.output(i, gpio. LOW)

per i inrange (15, 24, 1):

se io!=17e io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=4*max/10:

per i inrange (11, 16, 1):

se io!=14:

gpio.output(i, gpio. LOW)

per i inrange (16, 24, 1):

se io!=17e io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=5*max/10:

per i inrange (11, 17, 1):

se io!=14:

gpio.output(i, gpio. LOW)

per i inrange (18, 24, 1):

se io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=6*max/10:

per i inrange (11, 19, 1):

se io!=14e io!=17:

gpio.output(i, gpio. LOW)

per i inrange (19, 24, 1):

se io!=20:

gpio.output(i, gpio. HIGH)

se tensione1>=7*max/10:

per i inrange (11, 20, 1):

se io!=14e io!=17:

gpio.output(i, gpio. LOW)

per i inrange(21, 24, 1):

gpio.output(i, gpio. HIGH)

se tensione1>=8*max/10:

per i inrange (11, 22, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. LOW)

per i inrange(22, 24, 1):

gpio.output(i, gpio. HIGH)

se tensione1>=9*max/10:

per i inrange (11, 23, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. LOW)

gpio.output(23, gpio. HIGH)

se tensione1>=max:

per i inrange (11, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. LOW)

se tensione1

rottura

#spegni le lampade

per i inrange (11, 24, 1):

se io!=14e io!=17e io!=20:

gpio.output(i, gpio. HIGH)

#musica della vittoria

if current_voltage>=max:

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

tempo.sonno(0.03)

chiaro()

print"MOLTO BENE, HAI VINTO!"% (u'\u00c9', u'\u00ca', u'\u00c2')

per i inrange(10):

per j inrange(11, 24, 1):

se j!=14e j!=17e j!=20:

gpio.output(j, gpio. LOW)

tempo.sonno(0.05)

per j inrange(11, 24, 1):

se j!=14e j!=17e j!=20:

gpio.output(j, gpio. HIGH)

tempo.sonno(0.05)

tempo.sonno(0.5)

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

tempo.sonno(0.03)

chiaro()

print"Fine partita…\n", current_voltage, "V"

#record

tempo.sonno(1.2)

raggiunto=0

per i inrange(10):

se corrente_tensione > tensione:

raggiunto+=1

temperatura_tensione=tensione

tensione=tensione_corrente

tensione_corrente=tensione_temp

nome_temp=nome

nome=nome_corrente

nome_corrente=nome_temp

se raggiunto >0:

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

tempo.sonno(0.03)

chiaro()

f =open('record', 'w')

per i inrange(10):

f.write(nome)

f.write("\n")

f.write(str(tensione))

f.write("\n")

f.chiudi()

chiaro()

visualizza rawlamps_bike.py ospitato con ❤ da GitHub

Passaggio 8: schema elettrico:

L'Arduino e il Raspberry Pi 3 sono alimentati da una sorgente 5V con corrente 3A.

Il circuito elettrico inizia con la connessione del generatore DC (accoppiato alla bicicletta) all'Arduino tramite un filtro di tensione composto da un diodo Zener da 5,3V, un condensatore da 10μF e un resistore da 1kΩ – l'ingresso del filtro è collegato al terminali del generatore e l'uscita è collegata alla porta A0 e al GND del controller.

L'Arduino è collegato a Raspberry tramite comunicazione RX-TX, eseguita tramite un divisore resistivo utilizzando resistori da 10 kΩ (richiesto dalle porte dei controller che funzionano a tensioni diverse).

I GPIO di Raspberry Pi sono collegati ai relè responsabili dell'accensione delle lampade. Il “COM” di tutti i relè è stato interconnesso e connesso alla fase (rete AC) e il “N. O” (normalmente aperto) di ogni relè è stato collegato ad ogni lampada e il neutro della rete AC è stato interconnesso a tutte le lampade. Pertanto, quando viene attivato il GPIO responsabile di ciascun relè, il relè viene commutato sulla fase della rete CA e accende la rispettiva lampada.

Passaggio 9: risultati:

Dopo l'assemblaggio finale del progetto, è stato verificato che funzionasse come previsto: in base alla velocità con cui l'utente pedala sulla bici, viene generata più tensione e si accendono più lampade.