ძაბვის გამომუშავება ერგომეტრიანი ველოსიპედით: 9 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

პროექტის შემუშავება შედგებოდა "თამაშის" შეკრებაში, რომლის მიზანი იყო ერგომეტრიანი ველოსიპედის პედლებირება გენერატორთან და ნათურების კოშკთან ერთად, რომლებიც გააქტიურებულია ძრავის სიჩქარის მატებასთან ერთად - რაც ხდება ველოსიპედის პედლების შესაბამისად. სისტემა ემყარებოდა კითხვას-Arduino Mega– ს ანალოგური პორტის საშუალებით-მყისიერი გამომუშავებული ძაბვა, შემდეგ ამ მონაცემების Raspberry Pi 3 –ზე გადაცემა სერიული RX-TX კომუნიკაციის საშუალებით და ნათურების შემდგომი გააქტიურება რელეს საშუალებით.

ნაბიჯი 1: მასალები:

• 1 ჟოლო პი 3;
• 1 არდუინო მეგა 2560;
• 1 სარელეო ფარი 10 რელეით 12 V;
• 10 ინკანდესენტური ნათურები 127 V;
• 1 ერგომეტრი ველოსიპედი;
• 1 ელექტრო მანქანა (გენერატორი) 12 V;
• რეზისტორები (1x1kΩ, 2x10kΩ);
• 1 ელექტროლიტური კონდენსატორი 10 µF;
• 1 ზენერის დიოდი 5.3 V;
• კაბელი 1.5 მმ (წითელი, შავი, ყავისფერი);
• 1 MDF კოშკი 10 ნათურის მხარდაჭერით.

ნაბიჯი 2: სისტემის ბლოკების დიაგრამა:

ნაბიჯი 3: სისტემის მოქმედება:

სისტემა დაფუძნებულია კინეტიკური ენერგიის გარდაქმნაზე, რომელიც წარმოიქმნება ველოსიპედის ველოსიპედით ელექტრულ ენერგიაში, რომელიც პასუხისმგებელია რელეების გააქტიურებაზე, რაც ლამპებს ჩართავს.

გენერატორის მიერ წარმოქმნილი ძაბვა იკითხება Arduino– ს ანალოგიური პინით და იგზავნება RX-TX– ით Raspberry Pi– ზე. რელეების გააქტიურება წარმოქმნილი ძაბვის პროპორციულია - რაც უფრო მაღალია ძაბვა, მით უფრო მეტი რელე იქნება გააქტიურებული და მეტი ნათურა ანათებს.

ნაბიჯი 4: მექანიკის ასპექტები

DC გენერატორის ველოსიპედთან მექანიკურად შესაერთებლად, ქამრის სისტემა უნდა შეიცვალოს სისტემით, რომელიც გამოიყენება ჩვეულებრივ ველოსიპედებზე (გვირგვინის, ჯაჭვისა და პინიონისგან შემდგარი). ველოსიპედის ჩარჩოზე შედუღებული იყო ლითონის ფირფიტა ისე, რომ ძრავა ხრახნებით იყოს დამაგრებული. ამის შემდეგ, პინიონი შედუღდა გენერატორის ლილვზე ისე, რომ ჯაჭვი განთავსდეს, პედლების სისტემა ერთმანეთთან დააკავშირებს გენერატორს.

ნაბიჯი 5: ძაბვის კითხვა:

არდუინოს გამოყენებით გენერატორის ძაბვის წასაკითხად აუცილებელია ელექტრული აპარატის დადებითი პოლუსის დაკავშირება კონტროლერის A0 პინთან და უარყოფითი პოლუსი GND– თან - რათა თავიდან ავიცილოთ გენერატორის მაქსიმალური ძაბვა 5 ვ -ზე მეტი არდუინოს ქინძისთავები, ძაბვის ფილტრი 10 μF კონდენსატორის გამოყენებით, 1 kΩ რეზისტორი და 5.3 V ზენერის დიოდი აშენდა და დაკავშირებულია კონტროლერსა და გენერატორს შორის. არდუინოში ჩატვირთული firmware ძალიან მარტივია და შედგება მხოლოდ ანალოგური პორტის წაკითხვისგან, გამრავლებული მნიშვნელობის წაკითხვით მუდმივი 0.0048828125 (5/1024, ეს არის არდუინოს GPIO ძაბვა გაყოფილი მისი ანალოგური პორტის ბიტების რაოდენობაზე) და გაგზავნით სერიული ცვლადი - კოდი ხელმისაწვდომი იქნება სტატიაში.

Raspberry Pi– ში RX-TX კომუნიკაციის ჩართვის პროცედურა ცოტა უფრო რთულია და თქვენ უნდა დაიცვათ ბმულზე აღწერილი პროცედურა. მოკლედ, თქვენ უნდა შეცვალოთ ფაილი სახელწოდებით "inittab" -მდებარეობს "/etc/inittab" -ში, კომენტარი გააკეთეთ ხაზზე "T0: 23: respawn:/sbin/getty -L ttyAMA0 115200 vt100" (თუ ფაილი არ არის ჟოლოს OS- ში დაფუძნებული, თქვენ უნდა შეიყვანოთ ბრძანება: “sudo leafpad /boot/config.txt” და ფაილის ბოლოს დაურთოთ ხაზი “enable_uart = 1”). ამის დასრულების შემდეგ, თქვენ უნდა გახსნათ LX ტერმინალი და გამორთოთ სერიალი ბრძანებებით "sudo systemctl stop [email protected]" და "sudo systemctl გამორთეთ [email protected]". ამის შემდეგ თქვენ უნდა შეასრულოთ ბრძანება "sudo leafpad /boot/cmdline.txt", წაშალოთ ხაზი "console = serial0, 115200", შეინახოთ ფაილი და გადატვირთოთ მოწყობილობა. იმისათვის, რომ RX-TX კომუნიკაცია იყოს შესაძლებელი, სერიული ბიბლიოთეკა უნდა იყოს დაინსტალირებული Raspberry Pi- ზე ბრძანებით "sudo apt-get install -f python-serial" და ბიბლიოთეკის იმპორტი კოდში "იმპორტი სერიული" ხაზის ჩასმით, სერიალის ინიციალიზაცია ხაზი "ser = serial. Serial (" / dev / ttyS0 ", 9600)" და არდუინოს მიერ გაგზავნილი ძაბვის წაკითხვა ბრძანებით "ser.readline ()" - გამოიყენება სრული კოდი ჟოლოში გახდება ხელმისაწვდომი სტატიის ბოლოს.

ზემოთ აღწერილი პროცედურის შემდეგ, წაკითხვისა და გაგზავნის ძაბვის ნაბიჯი დასრულებულია.

ნაბიჯი 6: Arduino პროგრამირება:

როგორც უკვე ითქვა, ველოსიპედით მოძრაობისას წარმოქმნილი ძაბვის კითხვაზე პასუხისმგებელი კოდი ძალიან მარტივია.

პირველ რიგში, აუცილებელია აირჩიოს A0 pin, როგორც პასუხისმგებელი ძაბვის კითხვაზე.

"Void setup ()" ფუნქციაში თქვენ უნდა დააყენოთ pin A0 INPUT "pinMode (sensor, INPUT)" ბრძანებით და შეარჩიოთ სერიული პორტის გადაცემის სიჩქარე "Serial.begin (9600)" ბრძანების გამოყენებით.

"Void loop ()" - ში, "Serial.flush ()" ფუნქცია გამოიყენება ბუფერის გასასუფთავებლად ყოველ ჯერზე, როდესაც ის წყვეტს ინფორმაციის გაგზავნას სერიული საშუალებით; ძაბვის კითხვას ასრულებს ფუნქცია "analogRead (სენსორი)" - გახსოვდეთ, რომ აუცილებელია ანალოგური პორტის მიერ წაკითხული მნიშვნელობის ვოლტზე გადაყვანა - სტატია "სტაბილურობის ძაბვის" განყოფილებაში მოყვანილი პროცესი.

ასევე, "void loop ()" ფუნქციაში აუცილებელია ცვლადის გადატანა float- დან სტრიქონში, რადგან ეს არის ერთადერთი გზა ცვლადის გაგზავნისთვის RX-TX. მარყუჟის ფუნქციის ბოლო ნაბიჯი არის სტრიქონის დაბეჭდვა სერიულ პორტში ისე, რომ მისი გაგზავნა ჟოლოს - ამისათვის თქვენ უნდა გამოიყენოთ ფუნქცია "Serial.println (y)". ხაზი "დაგვიანებით (100)" დაემატა კოდს მხოლოდ ისე, რომ ცვლადი გაიგზავნოს 100 ms ინტერვალით - თუ ეს დრო არ იქნა დაცული, სერიული გადატვირთვა მოხდება, რაც გამოიწვევს პროგრამის შესაძლო ავარიებს.

ძაბვის_ წაკითხვა

float სენსორი = A0;

voidsetup () {

pinMode (სენსორი, INPUT);

სერიული.დაწყება (9600);

}

voidloop () {

Serial.flush ();

float x = analogRead (სენსორი)*0.0048828125*16.67;

სიმები y = "";

y+= x;

Serial.println (y);

დაგვიანება (100);

}

rawvoltage_read.ino– ს ნახვა GitHub– ით hosted

ნაბიჯი 7: Raspberry Pi 3 პროგრამირება:

ნათურები_ ველოსიპედი. py

იმპორტი os #იმპორტი os ბიბლიოთეკა (გამოიყენება ეკრანის გასასუფთავებლად საჭიროების შემთხვევაში)

იმპორტი RPi. GPIOas gpio #იმპორტის ბიბლიოთეკა გამოიყენება Raspnerry– ის GPIO– ს გასაკონტროლებლად

იმპორტი სერიული #იმპორტი ბიბლიოთეკა, რომელიც პასუხისმგებელია სერიულ კომუნიკაციაზე

იმპორტის დრო #იმპორტის ბიბლიოთეკა, რაც შესაძლებელს ხდის შეფერხების ფუნქციის გამოყენებას

იმპორტირებული ქვეპროცესების #იმპორტის ბიბლიოთეკა, რომელიც პასუხისმგებელია სიმღერების დაკვრაზე

#დაწყება სერიალი

ser = serial. Serial ("/dev/ttyS0", 9600) #განსაზღვრეთ მოწყობილობის სახელი და ბოდის სიჩქარე

#წმინდა ეკრანი

clear = lambda: os.system ('წმინდა')

#დაყენებული ქინძისთავები სარელეო კონტროლისთვის

gpio.setmode (gpio. BOARD)

gpio.setup (11, gpio. OUT) #ნათურა 10

gpio.setup (12, gpio. OUT) #ნათურა 9

gpio.setup (13, gpio. OUT) #ნათურა 8

gpio.setup (15, gpio. OUT) #ნათურა 7

gpio.setup (16, gpio. OUT) #ნათურა 6

gpio.setup (18, gpio. OUT) #ნათურა 5

gpio.setup (19, gpio. OUT) #ნათურა 4

gpio.setup (21, gpio. OUT) #ნათურა 3

gpio.setup (22, gpio. OUT) #ნათურა 2

gpio.setup (23, gpio. OUT) #ნათურა 1

#დაწყება ჩანაწერები

სახელი = ["არცერთი"]*10

ძაბვა = [0.00]*10

#წაიკითხეთ ჩანაწერების ფაილი

f = ღია ('ჩანაწერი', 'რ')

for i inrange (10): #10 საუკეთესო ქულა გამოჩნდება სიაში

სახელი = f.readline ()

სახელი = სახელი [: len (სახელი )-1]

ძაბვა = ვ. სიდიდე ()

ძაბვა = float (ძაბვა [: len (ძაბვა )-1])

ვ. დახურვა ()

გასაგებია ()

#დააყენეთ მაქსიმალური ძაბვა

მაქს = 50.00

#გამორთეთ ნათურები

i inrange (11, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH) #დაყენება HIGH- მდე, რელეები გამორთულია

#დაწყება

მართალია:

#საწყისი ეკრანი

დაბეჭდე "ჩანაწერები: / n"

იყიდება inrange (10):

ბეჭდვის სახელი , ":", ძაბვა , "V"

current_name = raw_input ("დაწერე შენი სახელი დასაწყებად:")

გასაგებია ()

#შეცვალეთ მაქსიმალური მნიშვნელობა

თუ მიმდინარე_სახელი == "მაქსიმუმი":

max = შეყვანა ("ჩაწერეთ მაქსიმალური ძაბვა: (2 ათობითი ადგილი)")

გასაგებია ()

სხვა:

#დაიწყე გაფრთხილება

for i inrange (11, 24, 1): #მარყუჟი იწყება PIN 11 – ში და ჩერდება PIN 24 – ში

თუ მე! = 14 და მე! = 17 და მე! = 20: #PIN 14 და 20 არის GND ქინძისთავები და 20 არის 3.3 V პინი

gpio.output (i, gpio. LOW) #ჩართეთ ნათურები

დრო. ძილი (0.5)

k = 10

i inrange (23, 10, -1):

გასაგებია ()

თუ მე! = 14 და მე! = 17 და მე! = 20:

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

დრო. ძილი (0.03)

გასაგებია ()

ამობეჭდვა "მომზადება! / n", კ

დრო. ძილი (1)

k- = 1

gpio.output (i, gpio. HIGH) #გამორთეთ ნათურები (სათითაოდ)

subprocess. Popen (['' aplay ',' Audios/go.wav ']) #უკრავს დაწყებულ მუსიკას

დრო. ძილი (0.03)

გასაგებია ()

დაბეჭდე "წადი!"

დრო. ძილი (1)

გასაგებია ()

#ძაბვის წაკითხვა

მიმდინარე_ძაბვა = 0.00

ძაბვა 1 = 0.00

for inrange (200):

ser.flushInput ()

წინა = ძაბვა 1

ძაბვა 1 = float (ser.readline ()) #აგროვებს Arduino– ს მონაცემებს გადაცემული RX-TX– ით

გასაგებია ()

ბეჭდვის ძაბვა 1, "V"

თუ ძაბვა 1> მიმდინარე_ძაბვა:

მიმდინარე_ძაბვა = ძაბვა 1

# გამომუშავებული ძაბვის მიხედვით, მეტი ნათურა ანათებს.

თუ ძაბვა 1 <max/10:

i inrange (11, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = მაქს/10:

gpio.output (11, gpio. LOW)

i inrange (12, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 2*მაქს/10:

i inrange (11, 13, 1):

gpio.output (i, gpio. LOW)

i inrange (13, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 3*მაქს/10:

i inrange (11, 14, 1):

gpio.output (i, gpio. LOW)

i inrange (15, 24, 1):

თუ მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 4*მაქს/10:

i inrange (11, 16, 1):

თუ მე! = 14:

gpio.output (i, gpio. LOW)

i inrange (16, 24, 1):

თუ მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 5*მაქს/10:

i inrange (11, 17, 1):

თუ მე! = 14:

gpio.output (i, gpio. LOW)

i inrange (18, 24, 1):

თუ მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 6*მაქს/10:

i inrange (11, 19, 1):

თუ მე! = 14 და მე! = 17:

gpio.output (i, gpio. LOW)

i inrange (19, 24, 1):

თუ მე! = 20:

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 7*მაქს/10:

i inrange (11, 20, 1):

თუ მე! = 14 და მე! = 17:

gpio.output (i, gpio. LOW)

i inrange (21, 24, 1):

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 8*max/10:

i inrange (11, 22, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. LOW)

i inrange (22, 24, 1):

gpio.output (i, gpio. HIGH)

თუ ძაბვა 1> = 9*მაქს/10:

i inrange (11, 23, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. LOW)

gpio.output (23, gpio. HIGHT)

თუ ძაბვა 1> = მაქსიმალური:

i inrange (11, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. LOW)

თუ ძაბვა 1

შესვენება

#გამორთეთ ნათურები

i inrange (11, 24, 1):

თუ მე! = 14 და მე! = 17 და მე! = 20:

gpio.output (i, gpio. HIGH)

#გამარჯვების მუსიკა

თუ current_voltage> = max:

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

დრო. ძილი (0.03)

გასაგებია ()

დაბეჭდე "ძალიან კარგი, შენ მოიგე!"% (u '\u00c9', u '\u00ca', u '\u00c2')

იყიდება inrange (10):

j inrange (11, 24, 1):

თუ j! = 14 და j! = 17 და j! = 20:

gpio.output (j, gpio. LOW)

დრო. ძილი (0.05)

j inrange (11, 24, 1):

თუ j! = 14 და j! = 17 და j! = 20:

gpio.output (j, gpio. HIGH)

დრო. ძილი (0.05)

დრო. ძილი (0.5)

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

დრო. ძილი (0.03)

გასაგებია ()

დაბეჭდე "თამაშის დასრულება … / n", მიმდინარე_ძაბვა, "V"

#ჩანაწერები

დრო. ძილი (1.2)

მიაღწია = 0

იყიდება inrange (10):

თუ მიმდინარე_ძაბვა> ძაბვა :

მიაღწია+= 1 -ს

temp_voltage = ძაბვა

ძაბვა = მიმდინარე_ძაბვა

მიმდინარე_ძაბვა = დროებითი_ძაბვა

temp_name = სახელი

სახელი = მიმდინარე_სახელი

მიმდინარე_სახელი = დრო_სახელი

თუ მიაღწია> 0:

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

დრო. ძილი (0.03)

გასაგებია ()

f = ღია ("ჩანაწერები", "w")

იყიდება inrange (10):

ვ. დაწერე (სახელი )

f.write ("\ n")

ვ. დაწერეთ (str (ძაბვა ))

f.write ("\ n")

ვ. დახურვა ()

გასაგებია ()

rawlamps_bike.py- ს ნახვა GitHub– ით

ნაბიჯი 8: ელექტრო სქემა:

Arduino და Raspberry Pi 3 იკვებება 5V წყლით 3A დენით.

ელექტრული წრე იწყება DC გენერატორის შეერთებით (ველოსიპედთან ერთად) არდუინოსთან ძაბვის ფილტრის საშუალებით, რომელიც შედგება ზენერის დიოდისგან 5.3V, 10μF კონდენსატორისა და 1kΩ რეზისტორისგან - ფილტრის შეყვანა უკავშირდება გენერატორის ტერმინალები და გამომავალი დაკავშირებულია A0 პორტთან და კონტროლერის GND- თან.

Arduino უკავშირდება ჟოლოს RX-TX კომუნიკაციის საშუალებით-შესრულებულია რეზისტენტული გამყოფის საშუალებით 10kΩ რეზისტორების გამოყენებით (ამას მოითხოვს სხვადასხვა ძაბვაზე მომუშავე კონტროლერების პორტები).

Raspberry Pi– ს GPIO– ები უკავშირდება რელეებს, რომლებიც პასუხისმგებელნი არიან ნათურების ჩართვაზე. ყველა რელეს "COM" ურთიერთდაკავშირებული იყო და უკავშირდებოდა ფაზას (AC ქსელს) და თითოეული N. ამრიგად, როდესაც თითოეულ სარელეოზე პასუხისმგებელი GPIO გააქტიურებულია, სარელეო გადადის AC ქსელის ფაზაზე და ჩართავს შესაბამის ნათურას.

ნაბიჯი 9: შედეგები:

პროექტის საბოლოო შეკრების შემდეგ, დადასტურდა, რომ ის მუშაობდა როგორც მოსალოდნელი იყო - სიჩქარის მიხედვით, რომელსაც მომხმარებელი ატარებს ველოსიპედზე, უფრო მეტი ძაბვა წარმოიქმნება და მეტი ნათურა ანათებს.