Générer de la tension avec un vélo ergomètre : 9 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

L'élaboration du projet a consisté en l'assemblage d'un "jeu" avec pour objectif de pédaler dans un vélo ergomètre connecté à un générateur et à une tour de lampes qui s'activent lorsque le régime moteur augmente - ce qui se produit en fonction du pédalage du vélo. Le système était basé sur la lecture - via un port analogique d'un Arduino Mega - de la tension instantanée générée, puis sur la transmission de ces données à un Raspberry Pi 3 via une communication série RX-TX et l'activation ultérieure des lampes via un relais.

Étape 1: Matériaux:

• 1 Raspberry Pi 3;
• 1 Arduino Mega 2560;
• 1 blindage de relais avec 10 relais 12 V;
• 10 lampes à incandescence 127 V;
• 1 vélo ergomètre;
• 1 machine électrique (générateur) 12 V;
• Résistances (1x1kΩ, 2x10kΩ);
• 1 condensateur électrolytique 10 µF;
• 1 diode Zener 5,3 V;
• Câble de 1,5 mm (rouge, noir, marron);
• 1 tour MDF avec support pour 10 lampes.

Étape 2: Schéma des blocs système:

Étape 3: Fonctionnement du système:

Le système est basé sur la transformation de l'énergie cinétique générée lors du cyclage du vélo en énergie électrique responsable de l'activation des relais qui allumeront les lampes.

La tension générée par le générateur est lue par une broche analogique d'Arduino et est envoyée via RX-TX au Raspberry Pi. L'activation des relais est proportionnelle à la tension générée - plus la tension est élevée, plus de relais seront déclenchés et plus de lampes s'allumeront.

Étape 4: Aspects mécaniques

Afin de coupler mécaniquement le générateur à courant continu au vélo, le système de courroie a dû être remplacé par le système utilisé sur les vélos courants (constitué d'une couronne, d'une chaîne et d'un pignon). Une plaque métallique a été soudée au cadre du vélo afin que le moteur puisse être fixé par des vis. Après cela, le pignon a été soudé à l'arbre du générateur afin que la chaîne puisse être placée, reliant le système de pédale au générateur.

Étape 5: Lecture de tension:

Pour lire la tension du générateur à l'aide d'Arduino, il est nécessaire de connecter le pôle positif de la machine électrique à la broche A0 du contrôleur et le pôle négatif au GND - pour éviter que la tension maximale du générateur soit supérieure aux 5 V du Des broches Arduino, un filtre de tension utilisant un condensateur de 10 µF, une résistance de 1 kΩ et une diode Zener de 5,3 V ont été construits et connectés entre le contrôleur et le générateur. Le firmware chargé dans Arduino est très simple et consiste uniquement à lire un port analogique, multiplier la valeur lue par la constante 0,0048828125 (5/1024, c'est-à-dire la tension GPIO de l'Arduino divisée par le nombre de bits de son port analogique) et envoyer le variable au Serial – le code sera disponible dans l'article.

La procédure pour activer la communication RX-TX dans Raspberry Pi est un peu plus complexe, et vous devez suivre la procédure décrite dans le lien. Brièvement, vous devez éditer un fichier appelé « inittab » – situé dans « /etc/inittab » –, commentez la ligne « T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100 » (si le fichier n'est pas fondé dans le système d'exploitation de Raspberry, vous devez entrer la commande: « sudo leafpad /boot/config.txt » et ajouter la ligne « enable_uart=1 » à la fin du fichier). Une fois cela fait, vous devez rouvrir le Terminal LX et désactiver le Serial avec les commandes « sudo systemctl stop [email protected] » et « sudo systemctl disable [email protected] ». Après cela, vous devez exécuter la commande "sudo leafpad /boot/cmdline.txt", supprimez la ligne "console = serial0, 115200", enregistrez le fichier et redémarrez l'appareil. Pour que la communication RX-TX soit possible, la librairie Serial doit être installée sur Raspberry Pi avec la commande " sudo apt-get install -f python-serial " et importer la librairie dans le code en insérant la ligne " import serial ", en initialisant le série en insérant la ligne "ser = serial. Serial (" / dev / ttyS0 ", 9600) " et la lecture de la tension envoyée par l'Arduino à l'aide de la commande " ser.readline() " - le code complet utilisé dans Raspberry sera mis à disposition à la fin de l'article.

En suivant la procédure décrite ci-dessus, l'étape de lecture et d'envoi de la tension est terminée.

Étape 6: Programmation Arduino:

Comme indiqué précédemment, le code chargé de lire la tension générée lors du cyclage est très simple.

Tout d'abord, il est nécessaire de choisir la broche A0 comme responsable de la lecture de la tension.

Dans la fonction "void setup ()", vous devez définir la broche A0 sur INPUT avec la commande "pinMode(sensor, INPUT)" et sélectionner la vitesse de transmission du port série à l'aide de la commande "Serial.begin(9600)".

Dans la "boucle void ()", la fonction "Serial.flush ()" est utilisée pour effacer le tampon chaque fois qu'elle termine l'envoi d'informations via série; la lecture de la tension est effectuée par la fonction "analogRead (capteur)" - en rappelant qu'il faut convertir la valeur lue par le port analogique en Volts - procédé cité dans la section "lecture de la tension" de l'article.

De plus, dans la fonction "void loop ()", il est nécessaire de convertir la variable x de float en string, car c'est le seul moyen d'envoyer la variable via RX-TX. La dernière étape de la fonction de boucle consiste à imprimer la chaîne dans le port série afin qu'elle puisse être envoyée à Raspberry - pour cela, vous devez utiliser la fonction "Serial.println (y)". La ligne "delay (100)" a été ajoutée au code uniquement pour que la variable soit envoyée à des intervalles de 100 ms - si ce temps n'est pas respecté, la surcharge Serial se produira, générant de possibles plantages dans le programme.

voltage_read.ino

capteur à flotteur = A0;

void setup() {

pinMode(capteur, INPUT);

Serial.begin(9600);

}

boucle vide() {

Serial.flush();

float x = lecture analogique (capteur) * 0,0048828125 * 16,67;

Chaîne y="";

y+=x;

Serial.println(y);

retard (100);

}

voir rawvoltage_read.ino hébergé avec ❤ par GitHub

Étape 7: Programmation du Raspberry Pi 3:

lampes_vélo.py

import os #importe la bibliothèque os (utilisée pour effacer l'écran si nécessaire)

import RPi. GPIOas gpio #import bibliothèque utilisée pour contrôler le GPIO du Raspnerry

import serial #import bibliothèque responsable de la communication série

import time #import bibliothèque qui permet d'utiliser la fonction delay

sous-processus d'importation # bibliothèque d'importation responsable de la lecture des chansons

#commencer la série

ser = serial. Serial("/dev/ttyS0", 9600) #définir le nom du périphérique et le débit en bauds

#écran propre

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

#définir les broches pour le contrôle du relais

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

#commencer les enregistrements

nom=["Aucun"]*10

tension=[0.00]*10

#lire le fichier d'enregistrements

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

for i inrange(10): #les 10 meilleurs scores apparaissent sur la liste

nom=f.readline()

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

tension=f.readline()

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

f.fermer()

dégager()

#définir la tension maximale

max=50,00

#éteindre les lampes

pour i inrange (11, 24, 1):

si i!=14et i!=17et i!=20:

gpio.output(i, gpio. HIGH) #réglé sur HIGH, les relais sont désactivés

#début

whileTrue:

#écran initial

print"Enregistrements:\n"

pour i inrange(10):

imprimer le nom, ":", voltage, "V"

current_name=raw_input("Ecrivez votre nom pour commencer: ")

dégager()

#Modifier la valeur maximale

if current_name =="max":

max=input("Ecrire la tension max: (2 chiffres après la virgule)")

dégager()

autre:

#start avertissement

pour i inrange (11, 24, 1): #la boucle commence dans le PIN 11 et s'arrête dans le PIN 24

si i!=14et i!=17et i!=20: #PIN 14 et 20 sont des broches GND et 20 est une broche de 3,3 V

gpio.output(i, gpio. LOW) #allumer les lampes

temps.sommeil (0,5)

k=10

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

dégager()

si i!=14et i!=17et i!=20:

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

temps.sommeil(0.03)

dégager()

print"Préparez!\n", k

heure.sommeil(1)

k-=1

gpio.output(i, gpio. HIGH) #éteindre les lampes (une par une)

subprocess. Popen(['aplay', 'Audios/go.wav']) #joue la musique de départ

temps.sommeil(0.03)

dégager()

imprimer"ALLEZ!"

heure.sommeil(1)

dégager()

#tension lue

tension_courante=0.00

tension1=0.00

pour i inrange(200):

ser.flushInput()

précédent=tension1

voltage1=float(ser.readline()) #collecte les données d'Arduino transférées par RX-TX

dégager()

tension d'impression1, "V"

si tension1>courant_tension:

tension_courante=tension1

# en fonction de la tension générée, plusieurs lampes s'allument.

si tension1<max/10:

pour i inrange (11, 24, 1):

si i!=14et i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=max/10:

gpio.output(11, gpio. LOW)

pour i inrange (12, 24, 1):

si i!=14et i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=2*max/10:

pour i inrange (11, 13, 1):

gpio.output(i, gpio. LOW)

pour i inrange (13, 24, 1):

si i!=14et i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=3*max/10:

pour i inrange (11, 14, 1):

gpio.output(i, gpio. LOW)

pour i inrange (15, 24, 1):

si i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=4*max/10:

pour i inrange (11, 16, 1):

si je!=14:

gpio.output(i, gpio. LOW)

pour i inrange (16, 24, 1):

si i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=5*max/10:

pour i inrange (11, 17, 1):

si je!=14:

gpio.output(i, gpio. LOW)

pour i inrange (18, 24, 1):

si je!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=6*max/10:

pour i inrange (11, 19, 1):

si je!=14et je!=17:

gpio.output(i, gpio. LOW)

pour i inrange (19, 24, 1):

si je!=20:

gpio.sortie(i, gpio. HIGH)

si tension1>=7*max/10:

pour i inrange (11, 20, 1):

si je!=14et je!=17:

gpio.output(i, gpio. LOW)

pour i inrange(21, 24, 1):

gpio.sortie(i, gpio. HIGH)

si tension1>=8*max/10:

pour i inrange (11, 22, 1):

si i!=14et i!=17et i!=20:

gpio.output(i, gpio. LOW)

pour i inrange(22, 24, 1):

gpio.sortie(i, gpio. HIGH)

si tension1>=9*max/10:

pour i inrange (11, 23, 1):

si i!=14et i!=17et i!=20:

gpio.output(i, gpio. LOW)

gpio.output(23, gpio. HIGH)

si tension1>=max:

pour i inrange (11, 24, 1):

si i!=14et i!=17et i!=20:

gpio.output(i, gpio. LOW)

si tension1

Pause

#éteindre les lampes

pour i inrange (11, 24, 1):

si i!=14et i!=17et i!=20:

gpio.sortie(i, gpio. HIGH)

#victoire musique

si courant_tension>=max:

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

temps.sommeil(0.03)

dégager()

print"TRÈS BIEN, VOUS AVEZ GAGNÉ !"% (u'\u00c9', u'\u00ca', u'\u00c2')

pour i inrange(10):

pour j inrange (11, 24, 1):

si j!=14et j!=17et j!=20:

gpio.output(j, gpio. LOW)

temps.sommeil(0,05)

pour j inrange (11, 24, 1):

si j!=14et j!=17et j!=20:

gpio.output(j, gpio. HIGH)

temps.sommeil(0,05)

temps.sommeil (0,5)

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

temps.sommeil(0.03)

dégager()

print"Fin de partie…\n", current_voltage, "V"

#enregistrements

heure.sommeil(1.2)

atteint=0

pour i inrange(10):

si courant_tension > tension:

atteint+=1

temp_voltage=tension

tension=courant_tension

current_voltage=temp_voltage

nom_temp=nom

nom=nom_actuel

nom_actuel=nom_temp

si atteint >0:

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

temps.sommeil(0.03)

dégager()

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

pour i inrange(10):

f.écrire(nom)

f.write("\n")

f.write(str(tension))

f.write("\n")

f.fermer()

dégager()

voir rawlamps_bike.py hébergé avec ❤ par GitHub

Étape 8: Schéma électrique:

L'Arduino et le Raspberry Pi 3 sont alimentés par une source 5V avec un courant 3A.

Le circuit électrique commence par la connexion du générateur de courant continu (couplé au vélo) à l'Arduino à travers un filtre de tension composé d'une diode Zener de 5,3V, d'un condensateur de 10μF et d'une résistance de 1kΩ – l'entrée du filtre est connectée au bornes du générateur et la sortie est connectée au port A0 et au GND du contrôleur.

L'Arduino est connecté à Raspberry via une communication RX-TX - réalisée via un diviseur résistif utilisant des résistances de 10 kΩ (requis par les ports des contrôleurs fonctionnant à différentes tensions).

Les GPIO du Raspberry Pi sont connectés aux relais chargés d'allumer les lampes. Le « COM » de tous les relais était interconnecté et connecté à la phase (réseau AC) et le « N. O » (normalement ouvert) de chaque relais était connecté à chaque lampe et le neutre du réseau AC était interconnecté à toutes les lampes. Ainsi, lorsque le GPIO responsable de chaque relais est activé, le relais est commuté sur la phase du réseau AC et allume la lampe respective.

Étape 9: Résultats:

Après l'assemblage final du projet, il a été vérifié qu'il fonctionnait comme prévu - selon la vitesse à laquelle l'utilisateur pédale sur le vélo, plus de tension est générée et plus de lampes s'allument.