Generowanie napięcia za pomocą ergometru: 9 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:31

Opracowanie projektu polegało na zbudowaniu „gry” mającej na celu pedałowanie na rowerze ergometrowym podłączonym do generatora i wieży lamp, które włączają się wraz ze wzrostem prędkości obrotowej silnika – co następuje w zależności od pedałowania roweru. System opierał się na odczytywaniu – przez port analogowy Arduino Mega – chwilowego generowanego napięcia, a następnie przesyłaniu tych danych do Raspberry Pi 3 za pomocą komunikacji szeregowej RX-TX i późniejszej aktywacji lamp poprzez przekaźnik.

Krok 1: Materiały:

• 1 Raspberry Pi 3;
• 1 Arduino Mega 2560;
• 1 osłona przekaźnika z 10 przekaźnikami 12 V;
• 10 żarówek 127 V;
• 1 rower z ergometrem;
• 1 maszyna elektryczna (generator) 12 V;
• Rezystory (1x1kΩ, 2x10kΩ);
• 1 kondensator elektrolityczny 10 µF;
• 1 dioda Zenera 5,3 V;
• Kabel 1,5 mm (czerwony, czarny, brązowy);
• 1 wieża MDF ze wspornikiem na 10 lamp.

Krok 2: Schemat bloków systemowych:

Krok 3: Działanie systemu:

System opiera się na przemianie energii kinetycznej generowanej podczas jazdy rowerem w energię elektryczną odpowiedzialną za uruchomienie przekaźników, które będą włączać światła.

Napięcie generowane przez generator jest odczytywane przez analogowy pin Arduino i przesyłane poprzez RX-TX do Raspberry Pi. Aktywacja przekaźników jest proporcjonalna do generowanego napięcia - im wyższe napięcie, tym więcej przekaźników zostanie wyzwolonych i więcej lampek się zapali.

Krok 4: Aspekty mechaniki

Aby mechanicznie połączyć prądnicę prądu stałego z rowerem, system pasów musiał zostać zastąpiony systemem stosowanym w zwykłych rowerach (składający się z korony, łańcucha i zębnika). Do ramy roweru przyspawana została metalowa płytka, dzięki której silnik można było przykręcić śrubami. Następnie zębnik został przyspawany do wału generatora, aby można było umieścić łańcuch, łącząc system pedałów z generatorem.

Krok 5: Odczyt napięcia:

Aby odczytać napięcie generatora za pomocą Arduino konieczne jest podłączenie dodatniego bieguna maszyny elektrycznej do wyprowadzenia A0 sterownika a ujemnego do GND – aby uniknąć sytuacji, w której maksymalne napięcie generatora jest większe niż 5 V Wyprowadzenia Arduino, filtr napięciowy z wykorzystaniem kondensatora 10 µF, rezystor 1 kΩ oraz dioda Zenera 5,3 V została zbudowana i wpięta między sterownik a generator. Oprogramowanie wbudowane w Arduino jest bardzo proste i polega jedynie na odczytaniu portu analogowego, pomnożeniu odczytanej wartości przez stałą 0,0048828125 (5/1024, czyli napięciu GPIO Arduino podzielonym przez liczbę bitów jego portu analogowego) i przesłaniu zmienna na Serial – kod będzie dostępny w artykule.

Procedura włączenia komunikacji RX-TX w Raspberry Pi jest nieco bardziej złożona i należy postępować zgodnie z procedurą opisaną w linku. Krótko mówiąc, musisz edytować plik o nazwie „inittab” – znajdujący się w „/etc/inittab” – skomentuj wiersz „T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100” (jeśli plik nie jest założone w systemie Raspberry, należy wpisać polecenie: „sudo leafpad /boot/config.txt” i dopisać na końcu pliku linię „enable_uart=1”). Gdy to zrobisz, musisz ponownie otworzyć Terminal LX i wyłączyć Serial za pomocą poleceń „sudo systemctl stop [email protected]” i „sudo systemctl disable [email protected]”. Następnie musisz wykonać polecenie "sudo leafpad /boot/cmdline.txt", usunąć wiersz "console = serial0, 115200", zapisać plik i ponownie uruchomić urządzenie. Aby komunikacja RX-TX była możliwa należy na Raspberry Pi zainstalować bibliotekę Serial za pomocą polecenia "sudo apt-get install -f python-serial" i zaimportować bibliotekę do kodu wstawiając linię "import serial", inicjalizacja serialu poprzez wstawienie linii "ser = serial. Serial ("/dev/ttyS0", 9600)" i odczyt napięcia przesyłanego przez Arduino za pomocą komendy "ser.readline()" – użyty pełny kod w Raspberry zostanie udostępnione na końcu artykułu.

Postępując zgodnie z procedurą opisaną powyżej, krok odczytu i wysyłania napięcia jest zakończony.

Krok 6: Programowanie Arduino:

Jak wcześniej wspomniano, kod odpowiedzialny za odczyt napięcia generowanego podczas jazdy na rowerze jest bardzo prosty.

Po pierwsze należy wybrać pin A0 jako odpowiedzialny za odczyt napięcia.

W funkcji „void setup()” należy ustawić pin A0 na INPUT za pomocą polecenia „pinMode(sensor, INPUT)” i wybrać prędkość transmisji portu szeregowego za pomocą polecenia „Serial.begin(9600)”.

W „void loop()” funkcja „Serial.flush()” służy do czyszczenia bufora za każdym razem, gdy kończy wysyłanie informacji przez port szeregowy; odczyt napięcia realizuje funkcja „analogRead (sensor)” – pamiętając o konieczności przeliczenia wartości odczytanej przez port analogowy na wolty – proces cytowany w dziale „odczyt napięcia” artykułu.

Również w funkcji "void loop()" konieczne jest przekonwertowanie zmiennej x z float na string, ponieważ jest to jedyny sposób na przesłanie zmiennej przez RX-TX. Ostatnim krokiem w funkcji pętli jest wydrukowanie ciągu w porcie szeregowym, aby można go było wysłać do Raspberry - w tym celu należy użyć funkcji „Serial.println(y)”. Linia "delay (100)" została dodana do kodu tylko po to, aby zmienna była przesyłana w odstępach 100ms - jeśli ten czas nie zostanie dotrzymany, nastąpi przeciążenie Serial, generując możliwe crashe programu.

napięcie_odczyt.ino

czujnik pływakowy = A0;

voidsetup() {

pinMode(czujnik, WEJŚCIE);

Serial.początek(9600);

}

voidloop() {

Serial.flush();

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

Ciąg y="";

y+=x;

Serial.println(y);

opóźnienie (100);

}

zobacz rawvoltage_read.ino hostowany z ❤ przez GitHub

Krok 7: Programowanie Raspberry Pi 3:

lampy_rower.py

import systemu operacyjnego #importuj bibliotekę systemu operacyjnego (używane do czyszczenia ekranu w razie potrzeby)

import RPi. GPIOas gpio #import biblioteka używana do sterowania GPIO Raspnerry

import serial #import biblioteka odpowiedzialna za komunikację szeregową

czas importu #import biblioteki, która umożliwia korzystanie z funkcji opóźnienia

import subproces #import biblioteki odpowiedzialnej za odtwarzanie utworów

#rozpocznij serial

ser = serial. Serial("/dev/ttyS0", 9600) #definiuj nazwę urządzenia i szybkość transmisji

#czysty ekran

wyczyść = lambda: os.system('wyczyść')

#ustaw piny do sterowania przekaźnikiem

gpio.setmode(gpio. BOARD)

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

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

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

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

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

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

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

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

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

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

#rozpocznij zapisy

nazwa=["Brak"]*10

napięcie=[0.00]*10

#odczytaj plik rekordów

f = otwórz('rekordy', 'r')

for i inrange(10): #na liście pojawia się 10 najlepszych wyników

nazwa=f.readline()

imię=imię[:len(imię)-1]

napięcie=f.readline()

napięcie=float(napięcie[:len(napięcie)-1])

f.zamknij()

jasne()

#ustaw maksymalne napięcie

max=50,00

#wyłącz lampy

dla i inrange(11, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.output(i, gpio. HIGH) #ustawiony na HIGH, przekaźniki są wyłączone

#początek

podczas gdy prawda:

#Początkowy ekran

drukuj"Rekordy:\n"

dla i inrange(10):

wypisz nazwę, ":", napięcie, "V"

current_name=raw_input("Wpisz swoje imię, aby rozpocząć: ")

jasne()

#Zmień maksymalną wartość

if current_name =="max":

max=input("Zapisz maksymalne napięcie: (2 miejsca po przecinku)")

jasne()

w przeciwnym razie:

#rozpocznij ostrzeżenie

for i inrange(11, 24, 1): #pętla zaczyna się na PIN 11 i kończy na PIN 24

jeśli i!=14i i!=17i i!=20: #PIN 14 i 20 to piny GND a 20 to pin 3,3 V

gpio.output(i, gpio. LOW) #włącz lampy

czas.sen(0.5)

k=10

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

jasne()

jeśli i!=14i i!=17i i!=20:

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

czas.sen (0.03)

jasne()

print"Przygotuj się!\n", k

czas.sen(1)

k-=1

gpio.output(i, gpio. HIGH) #wyłącz lampy (jedna po drugiej)

subprocess. Popen(['aplay', 'Audios/go.wav']) #odtwarza muzykę startową

czas.sen (0.03)

jasne()

drukuj"GO!"

czas.sen(1)

jasne()

#odczyt napięcia

prąd_napięcie=0.00

napięcie1=0.00

dla i inrange(200):

ser.flushInput()

poprzedni=napięcie1

voltage1=float(ser.readline()) #zbiera dane Arduino przesyłane przez RX-TX

jasne()

napięcie druku1, "V"

jeśli napięcie1>prąd_napięcie:

prąd_napięcie=napięcie1

# w zależności od generowanego napięcia zapala się więcej lampek.

jeśli napięcie1<max/10:

dla i inrange(11, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=max/10:

gpio.output(11, gpio. LOW)

dla i inrange(12, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=2*max/10:

dla i inrange (11, 13, 1):

gpio.output(i, gpio. LOW)

dla i inrange(13, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=3*max/10:

dla i inrange (11, 14, 1):

gpio.output(i, gpio. LOW)

dla i inrange(15, 24, 1):

jeśli ja!=17 i ja!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=4*max/10:

dla i inrange (11, 16, 1):

jeśli ja!=14:

gpio.output(i, gpio. LOW)

dla i inrange(16, 24, 1):

jeśli ja!=17 i ja!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=5*max/10:

dla i inrange (11, 17, 1):

jeśli ja!=14:

gpio.output(i, gpio. LOW)

dla i inrange(18, 24, 1):

jeśli ja!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=6*max/10:

dla i inrange (11, 19, 1):

jeśli ja!=14i ja!=17:

gpio.output(i, gpio. LOW)

dla i inrange(19, 24, 1):

jeśli ja!=20:

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=7*max/10:

dla i inrange (11, 20, 1):

jeśli ja!=14i ja!=17:

gpio.output(i, gpio. LOW)

dla i inrange(21, 24, 1):

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=8*max/10:

dla i inrange (11, 22, 1):

jeśli i!=14i i!=17i i!=20:

gpio.output(i, gpio. LOW)

dla i inrange(22, 24, 1):

gpio.wyjście(i, gpio. HIGH)

jeśli napięcie1>=9*max/10:

dla i inrange (11, 23, 1):

jeśli i!=14i i!=17i i!=20:

gpio.output(i, gpio. LOW)

gpio.output(23, gpio. HIGH)

jeśli napięcie1>=maks.:

dla i inrange (11, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.output(i, gpio. LOW)

jeśli napięcie1

przerwa

#wyłącz lampy

dla i inrange (11, 24, 1):

jeśli i!=14i i!=17i i!=20:

gpio.wyjście(i, gpio. HIGH)

#muzyka zwycięstwa

jeśli prąd_napięcie>=maks.:

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

czas.sen (0.03)

jasne()

print"BARDZO DOBRY, WYGRAŁEŚ!"% (u'\u00c9', u'\u00ca', u'\u00c2')

dla i inrange(10):

dla j w zakresie(11, 24, 1):

jeśli j!=14i j!=17i j!=20:

gpio.output(j, gpio. LOW)

czas.snu(0.05)

dla j w zakresie(11, 24, 1):

jeśli j!=14i j!=17i j!=20:

gpio.wyjście(j, gpio. HIGH)

czas.snu(0.05)

czas.sen(0.5)

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

czas.sen (0.03)

jasne()

print"Zakończ grę…\n", prąd_napięcie, "V"

#dokumentacja

czas.sen(1.2)

osiągnięty=0

dla i inrange(10):

jeśli prąd_napięcie > napięcie:

osiągnął+=1

napięcie_temp=napięcie

napięcie=prąd_napięcie

obecne_napięcie=temp_napięcie

temp_name=nazwa

nazwa=bieżąca_nazwa

bieżąca_nazwa=temp_nazwa

jeśli osiągnie >0:

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

czas.sen (0.03)

jasne()

f = otwórz('rekordy', 'w')

dla i inrange(10):

f.write(nazwa)

f.write("\n")

f.write(str(napięcie))

f.write("\n")

f.zamknij()

jasne()

zobacz rawlamps_bike.py hostowane z ❤ przez GitHub

Krok 8: Schemat elektryczny:

Arduino i Raspberry Pi 3 są zasilane ze źródła 5V o prądzie 3A.

Obwód elektryczny rozpoczyna się od podłączenia generatora prądu stałego (sprzężonego z rowerem) do Arduino przez filtr napięciowy złożony z diody Zenera 5,3 V, kondensatora 10 μF i rezystora 1 kΩ – wejście filtra jest połączone z zaciski generatora i wyjście jest połączone z portem A0 i GND sterownika.

Arduino łączy się z Raspberry za pośrednictwem komunikacji RX-TX – realizowanej przez dzielnik rezystancyjny z wykorzystaniem rezystorów 10kΩ (wymagane przez porty kontrolerów pracujące na różnych napięciach).

GPIO Raspberry Pi są podłączone do przekaźników odpowiedzialnych za włączanie lamp. „COM” wszystkich przekaźników był połączony i podłączony do fazy (sieć AC), a „NO” (normalnie otwarty) każdego przekaźnika był podłączony do każdej lampy, a przewód neutralny sieci AC był połączony ze wszystkimi lampami. Tym samym, gdy aktywowane jest GPIO odpowiedzialne za każdy przekaźnik, przekaźnik przełącza się na fazę sieci AC i włącza odpowiednią lampę.

Krok 9: Wyniki:

Po ostatecznym montażu projektu sprawdzono, czy działa on zgodnie z oczekiwaniami – w zależności od prędkości, z jaką użytkownik pedałuje na rowerze, generowane jest większe napięcie i zapala się więcej lampek.