Gerando tensão com uma bicicleta ergométrica: 9 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

A elaboração do projeto consistiu na montagem de um “jogo” com o objetivo de pedalar em uma bicicleta ergométrica conectada a um gerador e uma torre de lâmpadas que são acionadas conforme a rotação do motor aumenta - o que ocorre em função da pedalada da bicicleta. O sistema se baseava na leitura - por meio de uma porta analógica de um Arduino Mega - da tensão instantânea gerada, depois na transmissão desses dados para um Raspberry Pi 3 via comunicação serial RX-TX e no posterior acionamento das lâmpadas via relé.

Etapa 1: Materiais:

• 1 Raspberry Pi 3;
• 1 Arduino Mega 2560;
• 1 Relé Blindagem com 10 Relés 12 V;
• 10 Lâmpadas Incandescentes de 127 V;
• 1 bicicleta ergométrica;
• 1 Máquina Elétrica (Gerador) 12 V;
• Resistores (1x1kΩ, 2x10kΩ);
• 1 Capacitor eletrolítico de 10 µF;
• 1 diodo Zener 5,3 V;
• Cabo de 1,5 mm (vermelho, preto, marrom);
• 1 torre de MDF com suporte para 10 lâmpadas.

Etapa 2: Diagrama de blocos do sistema:

Etapa 3: Operação do sistema:

O sistema é baseado na transformação da energia cinética gerada durante a ciclagem da bicicleta em energia elétrica responsável pelo acionamento dos relés que irão acender as lâmpadas.

A tensão gerada pelo gerador é lida por um pino analógico do Arduino e enviada via RX-TX para o Raspberry Pi. O acionamento dos relés é proporcional à tensão gerada - quanto maior a tensão, mais relés serão acionados e mais lâmpadas acenderão.

Etapa 4: Aspectos mecânicos

Para acoplar mecanicamente o gerador CC à bicicleta, o sistema de correias teve que ser substituído pelo sistema usado nas bicicletas comuns (composto por coroa, corrente e pinhão). Uma placa de metal foi soldada ao quadro da bicicleta para que o motor pudesse ser preso por parafusos. Em seguida, o pinhão foi soldado ao eixo do gerador para que a corrente pudesse ser colocada, interligando o sistema de pedais ao gerador.

Etapa 5: Leitura de tensão:

Para ler a tensão do gerador usando o Arduino é necessário conectar o pólo positivo da máquina elétrica ao pino A0 do controlador e o pólo negativo ao GND - para evitar que a tensão máxima do gerador seja maior que os 5 V do Pinos do Arduino, um filtro de tensão usando um capacitor de 10 µF, um resistor de 1 kΩ e um diodo Zener de 5,3 V foi construído e conectado entre o controlador e o gerador. O firmware carregado no Arduino é muito simples e consiste apenas em ler uma porta analógica, multiplicar o valor lido pela constante 0,0048828125 (5/1024, que é a tensão GPIO do Arduino dividida pelo número de bits de sua porta analógica) e enviar o variável para o Serial - o código estará disponível no artigo.

O procedimento para habilitar a comunicação RX-TX no Raspberry Pi é um pouco mais complexo e você deve seguir o procedimento descrito no link. Resumidamente, você precisa editar um arquivo chamado “inittab” - localizado em “/ etc / inittab” -, comentar a linha “T0: 23: respawn: / sbin / getty -L ttyAMA0 115200 vt100” (se o arquivo não for fundado no sistema operacional do Raspberry, você deve inserir o comando: “sudo leafpad /boot/config.txt” e acrescentar a linha “enable_uart = 1” ao final do arquivo). Feito isso, você deve reabrir o Terminal LX e desabilitar o Serial com os comandos "sudo systemctl stop [email protected]" e "sudo systemctl disable [email protected]". Depois disso você deve executar o comando "sudo leafpad /boot/cmdline.txt", excluir a linha "console = serial0, 115200", salvar o arquivo e reiniciar o dispositivo. Para que a comunicação RX-TX seja possível, a biblioteca Serial deve ser instalada no Raspberry Pi com o comando "sudo apt-get install -f python-serial" e importar a biblioteca para o código inserindo a linha "import serial", inicializando o serial inserindo a linha "ser = serial. Serial (" / dev / ttyS0 ", 9600)" e a leitura da tensão enviada pelo Arduino usando o comando “ser.readline ()” - o código completo utilizado em Raspberry estarão disponíveis no final do artigo.

Seguindo o procedimento descrito acima, a etapa de leitura e envio de tensão está concluída.

Etapa 6: Programação do Arduino:

Como afirmado anteriormente, o código responsável pela leitura da tensão gerada durante o ciclo é muito simples.

Em primeiro lugar, é necessário escolher o pino A0 como responsável pela leitura da tensão.

Na função "void setup ()", você precisa definir o pino A0 para INPUT com o comando "pinMode (sensor, INPUT)" e selecionar a velocidade de transmissão da porta serial usando o comando "Serial.begin (9600)".

No "void loop ()", a função "Serial.flush ()" é usada para limpar o buffer toda vez que ele termina de enviar informações via serial; a leitura da tensão é realizada pela função "analogRead (sensor)" - lembrando que é necessário converter o valor lido pela porta analógica para Volts - processo citado na seção "leitura da tensão" do artigo.

Além disso, na função "void loop ()", é necessário converter a variável x de float para string, pois é a única forma de enviar a variável via RX-TX. A última etapa da função de loop é imprimir a string na porta serial para que possa ser enviada ao Raspberry - para isso, você deve usar a função "Serial.println (y)". A linha "delay (100)" foi adicionada ao código apenas para que a variável seja enviada em intervalos de 100 ms - se este tempo não for respeitado, ocorrerá a sobrecarga Serial, gerando possíveis travamentos no programa.

voltage_read.ino

sensor flutuante = A0;

voidsetup () {

pinMode (sensor, INPUT);

Serial.begin (9600);

}

voidloop () {

Serial.flush ();

float x = analogRead (sensor) * 0,0048828125 * 16,67;

String y = "";

y + = x;

Serial.println (y);

atraso (100);

}

visualizar rawvoltage_read.ino hospedado com ❤ por GitHub

Etapa 7: Programação do Raspberry Pi 3:

lamp_bike.py

import os #import the OS library (usado para limpar a tela quando necessário)

import RPi. GPIOas gpio #import library usada para controlar o GPIO do Raspnerry

import serial #import library responsável pela comunicação serial

import time #import library que possibilita o uso da função delay

import subprocess #import library responsável por tocar as músicas

#start serial

ser = serial. Serial ("/ dev / ttyS0", 9600) # define o nome do dispositivo e a taxa de transmissão

#limpar tela

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

# definir pinos para controle de relé

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

#start records

nome = ["Nenhum"] * 10

tensão = [0,00] * 10

#read arquivo de registros

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

for i inrange (10): # as 10 melhores pontuações aparecem na lista

nome = f.readline ()

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

tensão = f.readline ()

tensão = flutuação (tensão [: len (tensão ) - 1])

f.close ()

Claro()

#defina a tensão máxima

máx = 50,00

#desligue as lâmpadas

para i inrange (11, 24, 1):

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

gpio.output (i, gpio. HIGH) #definido para HIGH, os relés são desligados

#começar

whileTrue:

#tela inicial

imprimir "Registros: / n"

para i inrange (10):

imprimir nome , ":", tensão , "V"

current_name = raw_input ("Escreva seu nome para começar:")

Claro()

#Change max value

if current_name == "max":

max = entrada ("Escreva a tensão máxima: (2 casas decimais)")

Claro()

outro:

#start warning

para i inrange (11, 24, 1): # o loop começa no PIN 11 e termina no PIN 24

se i! = 14 e i! = 17 e i! = 20: #PIN 14 e 20 são pinos GND e 20 é um pino de 3,3 V

gpio.output (i, gpio. LOW) #ligar as lâmpadas

tempo.sono (0,5)

k = 10

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

Claro()

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

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

tempo.sono (0,03)

Claro()

imprimir "Prepare! / n", k

tempo.sono (1)

k- = 1

gpio.output (i, gpio. HIGH) #desligue as lâmpadas (uma por uma)

subprocess. Popen (['aplay', 'Audios / go.wav']) # reproduz a música inicial

tempo.sono (0,03)

Claro()

imprimir "VAI!"

tempo.sono (1)

Claro()

#voltage read

current_voltage = 0,00

voltagem 1 = 0,00

para i inrange (200):

ser.flushInput ()

anterior = voltagem1

Voltagem1 = float (ser.readline ()) # coleta os dados do Arduino transferidos por RX-TX

Claro()

tensão de impressão 1, "V"

se voltagem1> voltagem_atual:

tensão_atual = tensão1

# dependendo da tensão gerada, mais lâmpadas acendem.

se voltagem 1 <máx / 10:

para i inrange (11, 24, 1):

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

gpio.output (i, gpio. HIGH)

se voltagem1> = máx / 10:

gpio.output (11, gpio. LOW)

para i inrange (12, 24, 1):

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

gpio.output (i, gpio. HIGH)

se voltagem1> = 2 * máx / 10:

para i inrange (11, 13, 1):

gpio.output (i, gpio. LOW)

para i inrange (13, 24, 1):

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

gpio.output (i, gpio. HIGH)

se voltagem1> = 3 * máx / 10:

para i inrange (11, 14, 1):

gpio.output (i, gpio. LOW)

para i inrange (15, 24, 1):

se i! = 17 e i! = 20:

gpio.output (i, gpio. HIGH)

se voltagem1> = 4 * máx / 10:

para i inrange (11, 16, 1):

se eu! = 14:

gpio.output (i, gpio. LOW)

para i inrange (16, 24, 1):

se i! = 17 e i! = 20:

gpio.output (i, gpio. HIGH)

se voltagem1> = 5 * máx / 10:

para i inrange (11, 17, 1):

se eu! = 14:

gpio.output (i, gpio. LOW)

para i inrange (18, 24, 1):

se eu! = 20:

gpio.output (i, gpio. HIGH)

se voltagem1> = 6 * máx / 10:

para i inrange (11, 19, 1):

se i! = 14 e i! = 17:

gpio.output (i, gpio. LOW)

para i inrange (19, 24, 1):

se eu! = 20:

gpio.output (i, gpio. HIGH)

se voltagem1> = 7 * máx / 10:

para i inrange (11, 20, 1):

se i! = 14 e i! = 17:

gpio.output (i, gpio. LOW)

para i inrange (21, 24, 1):

gpio.output (i, gpio. HIGH)

se voltagem1> = 8 * máx / 10:

para i inrange (11, 22, 1):

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

gpio.output (i, gpio. LOW)

para i inrange (22, 24, 1):

gpio.output (i, gpio. HIGH)

se voltagem1> = 9 * máx / 10:

para i inrange (11, 23, 1):

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

gpio.output (i, gpio. LOW)

gpio.output (23, gpio. HIGH)

se voltagem1> = máx.:

para i inrange (11, 24, 1):

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

gpio.output (i, gpio. LOW)

se voltagem 1

pausa

#desligue as lâmpadas

para i inrange (11, 24, 1):

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

gpio.output (i, gpio. HIGH)

#victory music

if current_voltage> = max:

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

tempo.sono (0,03)

Claro()

print "MUITO BOM, VOCÊ GANHOU!"% (u '\u00c9', u '\u00ca', u '\u00c2')

para i inrange (10):

para j inrange (11, 24, 1):

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

gpio.output (j, gpio. LOW)

tempo.sono (0,05)

para j inrange (11, 24, 1):

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

gpio.output (j, gpio. HIGH)

tempo.sono (0,05)

tempo.sono (0,5)

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

tempo.sono (0,03)

Claro()

imprimir "Fim do jogo … / n", corrente_voltagem, "V"

#records

time.sleep (1,2)

atingiu = 0

para i inrange (10):

se tensão_atual> tensão :

atingiu + = 1

temp_voltage = tensão

tensão = tensão_atual

current_voltage = temp_voltage

temp_name = nome

nome = nome_atual

current_name = temp_name

se alcançado> 0:

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

tempo.sono (0,03)

Claro()

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

para i inrange (10):

f.write (nome )

f.write ("\ n")

f.write (str (tensão ))

f.write ("\ n")

f.close ()

Claro()

veja rawlamps_bike.py hospedado com ❤ por GitHub

Etapa 8: Esquema elétrico:

O Arduino e o Raspberry Pi 3 são alimentados por uma fonte de 5 V com corrente de 3 A.

O circuito elétrico inicia com a conexão do gerador DC (acoplado à bicicleta) ao Arduino através de um filtro de tensão composto por um diodo Zener de 5,3 V, um capacitor de 10μF e um resistor de 1kΩ - a entrada do filtro é conectada ao terminais do gerador e a saída é conectada à porta A0 e ao GND do controlador.

O Arduino é conectado ao Raspberry via comunicação RX-TX - realizada por meio de um divisor resistivo usando resistores de 10kΩ (exigidos pelas portas dos controladores operando em tensões diferentes).

Os GPIOs do Raspberry Pi são conectados aos relés responsáveis por acender as lâmpadas. O “COM” de todos os relés foi interligado e conectado à fase (rede CA) e o “N. O” (normalmente aberto) de cada relé foi conectado a cada lâmpada e o neutro da rede CA foi interligado a todas as lâmpadas. Assim, quando o GPIO responsável por cada relé é acionado, o relé é comutado para a fase da rede CA e acende a respectiva lâmpada.

Etapa 9: Resultados:

Após a montagem final do projeto, verificou-se que funcionou conforme o esperado - de acordo com a velocidade que o usuário pedala na bicicleta, mais tensão é gerada e mais lâmpadas acendem.