Generación de voltaje con una bicicleta ergómetro: 9 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

La elaboración del proyecto consistió en el montaje de un "juego" con el objetivo de pedalear en una bicicleta ergómetro conectada a un generador y una torre de lámparas que se activan a medida que aumenta la velocidad del motor, lo que ocurre de acuerdo con el pedaleo de la bicicleta. El sistema se basó en leer - a través de un puerto analógico de un Arduino Mega - el voltaje instantáneo generado, luego transmitir estos datos a una Raspberry Pi 3 vía comunicación serial RX-TX y la posterior activación de las lámparas vía relé.

Paso 1: Materiales:

• 1 frambuesa Pi 3;
• 1 Arduino Mega 2560;
• 1 blindaje de relé con 10 relés de 12 V;
• 10 lámparas incandescentes 127 V;
• 1 bicicleta ergómetro;
• 1 máquina eléctrica (generador) 12 V;
• Resistencias (1x1kΩ, 2x10kΩ);
• 1 condensador electrolítico de 10 µF;
• 1 diodo Zener de 5,3 V;
• Cable de 1,5 mm (rojo, negro, marrón);
• 1 torre de MDF con soporte para 10 lámparas.

Paso 2: Diagrama de bloques del sistema:

Paso 3: Operación del sistema:

El sistema se basa en la transformación de la energía cinética generada al ciclar la bicicleta en energía eléctrica responsable de la activación de los relés que encenderán las lámparas.

El voltaje generado por el generador se lee mediante un pin analógico de Arduino y se envía a través de RX-TX a la Raspberry Pi. La activación de los relés es proporcional al voltaje generado: cuanto mayor sea el voltaje, más relés se activarán y más lámparas se encenderán.

Paso 4: Aspectos mecánicos

Para acoplar mecánicamente el generador de CC a la bicicleta, el sistema de cinturón tuvo que ser reemplazado por el sistema utilizado en las bicicletas comunes (que consta de corona, cadena y piñón). Se soldó una placa de metal al cuadro de la bicicleta para que el motor pudiera fijarse con tornillos. Posteriormente, se solda el piñón al eje del generador para que se pueda colocar la cadena, interconectando el sistema de pedales al generador.

Paso 5: Lectura de voltaje:

Para leer el voltaje del generador usando Arduino es necesario conectar el polo positivo de la máquina eléctrica al pin A0 del controlador y el polo negativo al GND - para evitar que el voltaje máximo del generador sea mayor que los 5 V del Se construyeron pines Arduino, un filtro de voltaje que usa un capacitor de 10 µF, una resistencia de 1 kΩ y un diodo Zener de 5.3 V y se conectaron entre el controlador y el generador. El firmware cargado en Arduino es muy simple y consiste solo en leer un puerto analógico, multiplicar el valor leído por la constante 0.0048828125 (5/1024, que es el voltaje GPIO del Arduino dividido por el número de bits de su puerto analógico) y enviar el variable a la serie: el código estará disponible en el artículo.

El procedimiento para habilitar la comunicación RX-TX en Raspberry Pi es un poco más complejo y debe seguir el procedimiento descrito en el enlace. Brevemente, necesita editar un archivo llamado "inittab" - ubicado en "/ etc / inittab" -, comente la línea "T0: 23: respawn: / sbin / getty -L ttyAMA0 115200 vt100" (si el archivo no fundada en el sistema operativo de Raspberry, debe ingresar el comando: "sudo leafpad /boot/config.txt" y agregar la línea "enable_uart = 1" al final del archivo). Una vez hecho esto, debe volver a abrir la Terminal LX y deshabilitar el Serial con los comandos "sudo systemctl stop [email protected]" y "sudo systemctl disable [email protected]". Después de eso, debe ejecutar el comando "sudo leafpad /boot/cmdline.txt", eliminar la línea "console = serial0, 115200", guardar el archivo y reiniciar el dispositivo. Para que la comunicación RX-TX sea posible, la biblioteca serial debe instalarse en Raspberry Pi con el comando "sudo apt-get install -f python-serial" e importar la biblioteca en el código insertando la línea "import serial", inicializando el serial insertando la línea "ser = serial. Serial (" / dev / ttyS0 ", 9600)" y la lectura del voltaje enviado por el Arduino usando el comando "ser.readline ()" - el código completo utilizado en Raspberry estará disponible al final del artículo.

Siguiendo el procedimiento descrito anteriormente, se completa el paso de voltaje de lectura y envío.

Paso 6: programación de Arduino:

Como se dijo anteriormente, el código encargado de leer la tensión generada al pedalear es muy sencillo.

En primer lugar, es necesario elegir el pin A0 como responsable de la lectura del voltaje.

En la función "void setup ()", debe configurar el pin A0 en INPUT con el comando "pinMode (sensor, INPUT)" y seleccionar la velocidad de transmisión del puerto serie usando el comando "Serial.begin (9600)".

En el "bucle void ()", la función "Serial.flush ()" se usa para borrar el búfer cada vez que termina enviando información vía serial; la lectura de voltaje se realiza mediante la función "analogRead (sensor)" - recordando que es necesario convertir el valor leído por el puerto analógico a Voltios - proceso citado en la sección "lectura de voltaje" del artículo.

Además, en la función "void loop ()", es necesario convertir la variable x de float a string, ya que esta es la única forma de enviar la variable vía RX-TX. El último paso en la función loop es imprimir la cadena en el puerto serial para que pueda ser enviada a Raspberry - para esto debes usar la función "Serial.println (y)". Se ha agregado al código la línea "delay (100)" solo para que la variable sea enviada en intervalos de 100 ms - si no se respeta este tiempo se producirá la sobrecarga Serial, generando posibles caídas en el programa.

voltage_read.ino

sensor de flotador = A0;

voidsetup () {

pinMode (sensor, ENTRADA);

Serial.begin (9600);

}

voidloop () {

Serial.flush ();

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

String y = "";

y + = x;

Serial.println (y);

retraso (100);

}

ver rawvoltage_read.ino alojado con ❤ por GitHub

Paso 7: Programación de Raspberry Pi 3:

lamp_bike.py

import os #import the os library (usado para borrar la pantalla cuando sea necesario)

importar RPi. GPIOas gpio #import biblioteca utilizada para controlar el GPIO de Raspnerry

importar serial #import biblioteca responsable de la comunicación serial

tiempo de importación # biblioteca de importación que permite utilizar la función de retardo

importar subproceso #importar biblioteca responsable de reproducir las canciones

#start serial

ser = serial. Serial ("/ dev / ttyS0", 9600) #define el nombre del dispositivo y la velocidad en baudios

#pantalla clara

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

#set pines para control de relé

gpio.setmode (gpio. BOARD)

gpio.setup (11, gpio. OUT) # lámpara 10

gpio.setup (12, gpio. OUT) # lámpara 9

gpio.setup (13, gpio. OUT) # lámpara 8

gpio.setup (15, gpio. OUT) # lámpara 7

gpio.setup (16, gpio. OUT) # lámpara 6

gpio.setup (18, gpio. OUT) # lámpara 5

gpio.setup (19, gpio. OUT) # lámpara 4

gpio.setup (21, gpio. OUT) # lámpara 3

gpio.setup (22, gpio. OUT) #lámpara 2

gpio.setup (23, gpio. OUT) #lámpara 1

#start records

nombre = ["Ninguno"] * 10

voltaje = [0.00] * 10

#leer archivo de registros

f = abierto ('registros', 'r')

for i inrange (10): #las 10 mejores puntuaciones aparecen en la lista

nombre = f.readline ()

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

voltaje = f.readline ()

voltaje = flotador (voltaje [: len (voltaje ) - 1])

f.close ()

claro()

# establecer el voltaje máximo

máx = 50,00

#apaga las lámparas

para i inrange (11, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH) # establecido en HIGH, los relés están apagados

#comienzo

whileTrue:

#pantalla inicial

imprimir "Registros: / n"

para i inrange (10):

imprimir nombre , ":", voltaje , "V"

current_name = raw_input ("Escriba su nombre para comenzar:")

claro()

#Cambiar valor máximo

if current_name == "max":

max = input ("Escriba el voltaje máximo: (2 lugares decimales)")

claro()

demás:

#start warning

for i inrange (11, 24, 1): # el bucle comienza en el PIN 11 y se detiene en el PIN 24

si i! = 14 y i! = 17 y i! = 20: #PIN 14 y 20 son pines GND y 20 es un pin de 3.3 V

gpio.output (i, gpio. LOW) # enciende las lámparas

tiempo. de sueño (0.5)

k = 10

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

claro()

si yo! = 14 y yo! = 17 y yo! = 20:

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

time.sleep (0.03)

claro()

imprime "¡Prepara! / n", k

hora de dormir (1)

k- = 1

gpio.output (i, gpio. HIGH) #apagar las lámparas (una por una)

subprocess. Popen (['aplay', 'Audios / go.wav']) # reproduce la música de inicio

time.sleep (0.03)

claro()

imprimir "GO!"

hora de dormir (1)

claro()

#voltaje leído

voltaje_corriente = 0.00

voltaje1 = 0.00

para i inrange (200):

ser.flushInput ()

anterior = voltaje1

voltage1 = float (ser.readline ()) # recopila los datos de Arduino transferidos por RX-TX

claro()

voltaje de impresión1, "V"

si voltaje1> voltaje_corriente:

voltaje_corriente = voltaje1

# dependiendo de la tensión generada, se encienden más lámparas.

si voltaje1 <max / 10:

para i inrange (11, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = max / 10:

gpio.output (11, gpio. LOW)

para i inrange (12, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 2 * max / 10:

para i inrange (11, 13, 1):

gpio.output (i, gpio. LOW)

para i inrange (13, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 3 * max / 10:

para i inrange (11, 14, 1):

gpio.output (i, gpio. LOW)

para i inrange (15, 24, 1):

si yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 4 * max / 10:

para i inrange (11, 16, 1):

si yo! = 14:

gpio.output (i, gpio. LOW)

para i inrange (16, 24, 1):

si yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 5 * max / 10:

para i inrange (11, 17, 1):

si yo! = 14:

gpio.output (i, gpio. LOW)

para i inrange (18, 24, 1):

si yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 6 * max / 10:

para i inrange (11, 19, 1):

si yo! = 14 y yo! = 17:

gpio.output (i, gpio. LOW)

para i inrange (19, 24, 1):

si yo! = 20:

gpio.output (i, gpio. HIGH)

si voltaje1> = 7 * max / 10:

para i inrange (11, 20, 1):

si yo! = 14 y yo! = 17:

gpio.output (i, gpio. LOW)

para yo en rango (21, 24, 1):

gpio.output (i, gpio. HIGH)

si voltaje1> = 8 * max / 10:

para i inrange (11, 22, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. LOW)

para i inrange (22, 24, 1):

gpio.output (i, gpio. HIGH)

si voltaje1> = 9 * max / 10:

para i inrange (11, 23, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. LOW)

gpio.output (23, gpio. HIGH)

si voltaje1> = max:

para i inrange (11, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. LOW)

si voltaje1

rotura

#apaga las lámparas

para i inrange (11, 24, 1):

si yo! = 14 y yo! = 17 y yo! = 20:

gpio.output (i, gpio. HIGH)

#victory music

si current_voltage> = max:

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

time.sleep (0.03)

claro()

print "MUY BUENO, ¡GANASTE!"% (u '\u00c9', u '\u00ca', u '\u00c2')

para i inrange (10):

para j en rango (11, 24, 1):

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

gpio.output (j, gpio. LOW)

tiempo de sueño (0.05)

para j en rango (11, 24, 1):

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

gpio.output (j, gpio. HIGH)

tiempo de sueño (0.05)

tiempo. de sueño (0.5)

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

time.sleep (0.03)

claro()

imprimir "Fin del juego … / n", current_voltage, "V"

#registros

tiempo.sueño (1.2)

alcanzado = 0

para i inrange (10):

si voltaje_corriente> voltaje :

alcanzado + = 1

temp_voltage = voltaje

voltaje = voltaje_corriente

current_voltage = temp_voltage

temp_name = nombre

nombre = nombre_actual

nombre_actual = nombre_temp

si se alcanza> 0:

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

time.sleep (0.03)

claro()

f = abierto ('registros', 'w')

para i inrange (10):

f.write (nombre )

f.write ("\ n")

f.write (str (voltaje ))

f.write ("\ n")

f.close ()

claro()

ver rawlamps_bike.py alojado con ❤ por GitHub

Paso 8: Esquema eléctrico:

El Arduino y el Raspberry Pi 3 funcionan con una fuente de 5 V con una corriente de 3 A.

El circuito eléctrico comienza con la conexión del generador DC (acoplado a la bicicleta) al Arduino a través de un filtro de voltaje compuesto por un diodo Zener de 5.3V, un capacitor de 10μF y una resistencia de 1kΩ - la entrada del filtro está conectada al terminales del generador y la salida está conectada al puerto A0 y al GND del controlador.

El Arduino está conectado a Raspberry a través de la comunicación RX-TX, realizada a través de un divisor resistivo usando resistencias de 10kΩ (requeridas por los puertos de los controladores que operan a diferentes voltajes).

Los GPIO de Raspberry Pi están conectados a los relés responsables de encender las lámparas. El “COM” de todos los relés se interconectó y conectó a la fase (red de CA) y el “N. O” (normalmente abierto) de cada relé se conectó a cada lámpara y el neutro de la red de CA se interconectó a todas las lámparas. Así, cuando se activa el GPIO responsable de cada relé, el relé se conmuta a la fase de la red AC y enciende la lámpara respectiva.

Paso 9: Resultados:

Tras el montaje final del proyecto, se comprobó que funcionó como se esperaba - según la velocidad a la que el usuario pedalea en la bicicleta, se genera más voltaje y se encienden más lámparas.