एर्गोमीटर बाइक के साथ वोल्टेज उत्पन्न करना: 9 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

प्रोजेक्ट के विस्तार में एक "गेम" की असेंबली शामिल थी जिसका उद्देश्य जनरेटर से जुड़ी एर्गोमीटर बाइक में पेडल करना और इंजन की गति बढ़ने पर सक्रिय होने वाले लैंप के एक टॉवर - जो साइकिल पेडलिंग के अनुसार होता है। सिस्टम पढ़ने पर आधारित था - एक Arduino मेगा के एक एनालॉग पोर्ट के माध्यम से - उत्पन्न तत्काल वोल्टेज, फिर इस डेटा को सीरियल RX-TX संचार के माध्यम से रास्पबेरी पाई 3 में प्रेषित करना और रिले के माध्यम से लैंप के बाद के सक्रियण पर आधारित था।

चरण 1: सामग्री:

• 1 रास्पबेरी पाई 3;
• 1 अरुडिनो मेगा 2560;
• 10 रिले 12 वी के साथ 1 रिले शील्ड;
• 10 गरमागरम लैंप 127 वी;
• 1 एर्गोमीटर बाइक;
• 1 विद्युत मशीन (जनरेटर) 12 वी;
• प्रतिरोधी (1x1kΩ, 2x10kΩ);
• 1 इलेक्ट्रोलाइटिक संधारित्र 10 µF;
• 1 जेनर डायोड 5.3 वी;
• 1.5 मिमी केबल (लाल, काला, भूरा);
• 10 लैंप के समर्थन के साथ 1 एमडीएफ टॉवर।

चरण 2: सिस्टम ब्लॉक आरेख:

चरण 3: सिस्टम ऑपरेशन:

सिस्टम विद्युत ऊर्जा में साइकिल चलाते समय उत्पन्न गतिज ऊर्जा के परिवर्तन पर आधारित है, जो रिले के सक्रियण के लिए जिम्मेदार है जो लैंप को चालू करेगा।

जनरेटर द्वारा उत्पन्न वोल्टेज को Arduino के एक एनालॉग पिन द्वारा पढ़ा जाता है और RX-TX के माध्यम से रास्पबेरी पाई को भेजा जाता है। रिले की सक्रियता उत्पन्न वोल्टेज के समानुपाती होती है - वोल्टेज जितना अधिक होगा, उतने ही अधिक रिले चालू होंगे और अधिक लैंप प्रकाश करेंगे।

चरण 4: यांत्रिकी पहलू

यंत्रवत् रूप से डीसी जनरेटर को साइकिल से जोड़ने के लिए, बेल्ट सिस्टम को सामान्य साइकिल (एक मुकुट, चेन और पिनियन से मिलकर) पर इस्तेमाल होने वाले सिस्टम से बदलना पड़ा। एक धातु की प्लेट को साइकिल के फ्रेम में वेल्ड किया गया था ताकि इंजन को शिकंजा द्वारा सुरक्षित किया जा सके। उसके बाद, पिनियन को जनरेटर शाफ्ट में वेल्ड किया गया ताकि चेन को रखा जा सके, पेडल सिस्टम को जनरेटर से जोड़कर।

चरण 5: वोल्टेज पढ़ना:

Arduino का उपयोग करके जनरेटर के वोल्टेज को पढ़ने के लिए विद्युत मशीन के सकारात्मक ध्रुव को नियंत्रक के A0 पिन और नकारात्मक ध्रुव को GND से जोड़ना आवश्यक है - इससे बचने के लिए जनरेटर का अधिकतम वोल्टेज 5 V से अधिक है Arduino पिन, 10 µF के कैपेसिटर का उपयोग करते हुए एक वोल्टेज फ़िल्टर, 1 kΩ का एक रोकनेवाला और 5.3 V के जेनर डायोड का निर्माण और नियंत्रक और जनरेटर के बीच जुड़ा हुआ था। Arduino में लोड किया गया फर्मवेयर बहुत सरल है और इसमें केवल एक एनालॉग पोर्ट को पढ़ना शामिल है, निरंतर 0.0048828125 (5/1024, जो कि Arduino का GPIO वोल्टेज है, इसके एनालॉग पोर्ट के बिट्स की संख्या से विभाजित है) द्वारा पढ़े गए मान को गुणा करें और भेजना सीरियल के लिए चर - कोड लेख में उपलब्ध होगा।

रास्पबेरी पाई में RX-TX संचार को सक्षम करने की प्रक्रिया थोड़ी अधिक जटिल है, और आपको लिंक में वर्णित प्रक्रिया का पालन करना चाहिए। संक्षेप में, आपको "inittab" नामक एक फ़ाइल को संपादित करने की आवश्यकता है - "/ etc / inittab" में स्थित -, "T0: 23: respawn: / sbin / getty -L ttyAMA0 115200 vt100" लाइन पर टिप्पणी करें (यदि फ़ाइल नहीं है रास्पबेरी के ओएस में स्थापित, आपको कमांड दर्ज करनी होगी: "सुडो लीफपैड /बूट/कॉन्फिग.txt" और फ़ाइल के अंत में "enable_uart=1" लाइन संलग्न करें)। एक बार यह हो जाने के बाद, आपको LX टर्मिनल को फिर से खोलना होगा और "sudo systemctl stop [email protected]" और "sudo systemctl disable [email protected]" कमांड के साथ सीरियल को अक्षम करना होगा। उसके बाद आपको "सुडो लीफपैड /बूट/cmdline.txt" कमांड को निष्पादित करना होगा, "कंसोल = सीरियल0, 115200" लाइन को हटाना होगा, फाइल को सेव करना होगा और डिवाइस को रीस्टार्ट करना होगा। RX-TX संचार संभव होने के लिए, सीरियल लाइब्रेरी को रास्पबेरी पाई पर "sudo apt-get install -f python-serial" कमांड के साथ स्थापित किया जाना चाहिए और "इंपोर्ट सीरियल" लाइन डालकर लाइब्रेरी को कोड में आयात करना चाहिए।, "ser = serial. Serial ("/ dev / ttyS0 ", 9600)" लाइन डालकर सीरियल को इनिशियलाइज़ करना और Arduino द्वारा "ser.readline ()" कमांड का उपयोग करके भेजे गए वोल्टेज को पढ़ना - इस्तेमाल किया गया पूरा कोड रास्पबेरी में लेख के अंत में उपलब्ध कराया जाएगा।

ऊपर वर्णित प्रक्रिया के बाद, वोल्टेज पढ़ने और भेजने का चरण पूरा हो गया है।

चरण 6: Arduino प्रोग्रामिंग:

जैसा कि पहले कहा गया है, साइकिल चलाते समय उत्पन्न वोल्टेज को पढ़ने के लिए जिम्मेदार कोड बहुत सरल है।

सबसे पहले, वोल्टेज को पढ़ने के लिए जिम्मेदार के रूप में A0 पिन चुनना आवश्यक है।

"शून्य सेटअप ()" फ़ंक्शन में, आपको "पिनमोड (सेंसर, INPUT)" कमांड के साथ पिन A0 को INPUT पर सेट करना होगा और "Serial.begin (9600)" कमांड का उपयोग करके सीरियल पोर्ट ट्रांसमिशन गति का चयन करना होगा।

"शून्य लूप ()" में, "Serial.flush ()" फ़ंक्शन का उपयोग हर बार सीरियल के माध्यम से सूचना भेजने को समाप्त करने के लिए बफर को साफ़ करने के लिए किया जाता है; वोल्टेज रीडिंग फ़ंक्शन "एनालॉग रीड (सेंसर)" द्वारा किया जाता है - यह याद रखना कि एनालॉग पोर्ट द्वारा पढ़े गए मान को वोल्ट में परिवर्तित करना आवश्यक है - लेख के "रीडिंग वोल्टेज" खंड में उद्धृत प्रक्रिया।

इसके अलावा, "शून्य लूप ()" फ़ंक्शन में, चर x को फ्लोट से स्ट्रिंग में परिवर्तित करना आवश्यक है, क्योंकि यह RX-TX के माध्यम से चर भेजने का एकमात्र तरीका है। लूप फ़ंक्शन में अंतिम चरण सीरियल पोर्ट में स्ट्रिंग को प्रिंट करना है ताकि इसे रास्पबेरी को भेजा जा सके - इसके लिए आपको "Serial.println (y)" फ़ंक्शन का उपयोग करना होगा। लाइन "देरी (100)" को केवल कोड में जोड़ा गया है ताकि चर 100 एमएस के अंतराल में भेजा जा सके - यदि इस समय का सम्मान नहीं किया जाता है, तो सीरियल अधिभार होगा, प्रोग्राम में संभावित क्रैश उत्पन्न करना।

वोल्टेज_रीड.इनो

फ्लोट सेंसर = A0;

व्यर्थ व्यवस्था() {

पिनमोड (सेंसर, INPUT);

सीरियल.बेगिन (९६००);

}

शून्य लूप () {

सीरियल फ्लश ();

फ्लोट x=analogRead(sensor)*0.0048828125*16.67;

स्ट्रिंग वाई = "";

वाई+=एक्स;

सीरियल.प्रिंट्लन (वाई);

देरी (100);

}

देखें rawvoltage_read.ino GitHub द्वारा ❤ के साथ होस्ट किया गया

चरण 7: रास्पबेरी पाई 3 प्रोग्रामिंग:

लैंप_बाइक.py

आयात ओएस #ओएस पुस्तकालय आयात करें (आवश्यक होने पर स्क्रीन को साफ़ करने के लिए उपयोग किया जाता है)

आयात RPi. GPIOas gpio #import लाइब्रेरी का उपयोग रास्पनेरी के GPIO को नियंत्रित करने के लिए किया जाता है

सीरियल संचार के लिए जिम्मेदार सीरियल आयात करें #आयात पुस्तकालय

आयात समय #आयात पुस्तकालय जो विलंब फ़ंक्शन का उपयोग करना संभव बनाता है

आयात उपप्रक्रिया #आयात पुस्तकालय गाने चलाने के लिए जिम्मेदार है

#सीरियल शुरू करें

ser = serial. Serial("/dev/ttyS0", 9600) #डिवाइस का नाम और बॉड दर निर्धारित करें

#साफ़ स्क्रीन

स्पष्ट = लैम्ब्डा: ओएस सिस्टम ('स्पष्ट')

#रिले नियंत्रण के लिए पिन सेट करें

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

#रिकॉर्ड फ़ाइल पढ़ें

एफ = खुला ('रिकॉर्ड', 'आर')

for i inrange(10): #10 सर्वश्रेष्ठ स्कोर सूची में दिखाई देते हैं

नाम = f.readline ()

नाम = नाम [: लेन (नाम ) -1]

वोल्टेज = f.readline ()

वोल्टेज = फ्लोट (वोल्टेज [: लेन (वोल्टेज ) -1])

एफ.क्लोज़ ()

स्पष्ट()

#अधिकतम वोल्टेज सेट करें

अधिकतम=50.00

#दीप बंद करो

मैं व्यवस्था के लिए (11, 24, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output(i, gpio. HIGH) # उच्च पर सेट, रिले बंद हैं

#प्रारंभ

जबकि सच:

#प्राथमिक स्क्रीन

प्रिंट"रिकॉर्ड:\n"

मैं व्यवस्था के लिए(10):

प्रिंट नाम , ":", वोल्टेज , "वी"

current_name=raw_input("शुरू करने के लिए अपना नाम लिखें:")

स्पष्ट()

#अधिकतम मूल्य बदलें

अगर current_name == "अधिकतम":

अधिकतम = इनपुट ("अधिकतम वोल्टेज लिखें: (2 दशमलव स्थान)")

स्पष्ट()

अन्यथा:

#चेतावनी शुरू करें

मैं इनरेंज (११, २४, १) के लिए: #लूप पिन ११ में शुरू होता है और पिन २४ में रुकता है

अगर मैं!=14और मैं!=17और मैं!=20: #पिन 14 और 20 जीएनडी पिन हैं और 20 एक 3.3 वी पिन है

gpio.output(i, gpio. LOW) #लैंप चालू करें

समय सो जाओ (0.5)

कश्मीर = 10

मैं व्यवस्था के लिए (23, 10, -1):

स्पष्ट()

अगर मैं!=14और मैं!=17और मैं!=20:

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

समय सो जाओ (0.03)

स्पष्ट()

प्रिंट करें"तैयार करें!\n", k

समय सो जाओ(1)

के- = 1

gpio.output(i, gpio.high) #लैंप बंद करें (एक-एक करके)

subprocess. Popen(['aplay', 'Audios/go.wav']) # स्टार्ट म्यूजिक बजाता है

समय सो जाओ (0.03)

स्पष्ट()

प्रिंट "जाओ!"

समय सो जाओ(1)

स्पष्ट()

#वोल्टेज पढ़ें

करंट_वोल्टेज = 0.00

वोल्टेज1=0.00

मैं व्यवस्था के लिए (200):

ser.flushInput ()

पिछला=वोल्टेज1

वोल्टेज 1 = फ्लोट (सेर.रीडलाइन ()) # आरएक्स-टीएक्स द्वारा स्थानांतरित अरुडिनो का डेटा एकत्र करता है

स्पष्ट()

प्रिंट वोल्टेज1, "वी"

अगर वोल्टेज 1> करंट_वोल्टेज:

करंट_वोल्टेज = वोल्टेज1

# उत्पन्न वोल्टेज के आधार पर, अधिक लैंप प्रकाश करते हैं।

अगर वोल्टेज 1 <अधिकतम / 10:

मैं व्यवस्था के लिए (11, 24, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज 1> = अधिकतम / 10:

gpio.output(11, gpio. LOW)

मैं व्यवस्था के लिए(१२, २४, १):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज1>=2*अधिकतम/10:

मैं व्यवस्था के लिए (11, 13, 1):

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए (13, 24, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज1>=3*अधिकतम/10:

मैं व्यवस्था के लिए (11, 14, 1):

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए (15, 24, 1):

अगर मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज 1> = 4 * अधिकतम / 10:

मैं व्यवस्था के लिए (11, 16, 1):

अगर मैं!=14:

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए (16, 24, 1):

अगर मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज1>=5*अधिकतम/10:

मैं व्यवस्था के लिए (11, 17, 1):

अगर मैं!=14:

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए(१८, २४, १):

अगर मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज 1> = 6 * अधिकतम / 10:

मैं व्यवस्था के लिए (11, 19, 1):

अगर मैं!=14और मैं!=17:

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए(१९, २४, १):

अगर मैं!=20:

gpio.output(i, gpio.high)

अगर वोल्टेज1>=7*अधिकतम/10:

मैं व्यवस्था के लिए (11, 20, 1):

अगर मैं!=14और मैं!=17:

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए (21, 24, 1):

gpio.output(i, gpio.high)

अगर वोल्टेज 1> = 8 * अधिकतम / 10:

मैं व्यवस्था के लिए (11, 22, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output (i, gpio. LOW)

मैं व्यवस्था के लिए (22, 24, 1):

gpio.output(i, gpio.high)

अगर वोल्टेज1>=9*अधिकतम/10:

मैं व्यवस्था के लिए (11, 23, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output (i, gpio. LOW)

gpio.output(23, gpio.high)

अगर वोल्टेज 1> = अधिकतम:

मैं व्यवस्था के लिए (11, 24, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output (i, gpio. LOW)

अगर वोल्टेज1

टूटना

#दीप बंद करो

मैं व्यवस्था के लिए (11, 24, 1):

अगर मैं!=14और मैं!=17और मैं!=20:

gpio.output(i, gpio.high)

#विजय संगीत

अगर करंट_वोल्टेज> = अधिकतम:

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

समय सो जाओ (0.03)

स्पष्ट()

प्रिंट करें "बहुत अच्छा, आप जीत गए!"% (u'\u00c9', u'\u00ca', u'\u00c2')

मैं व्यवस्था के लिए(10):

जे इनरेंज के लिए (11, 24, 1):

अगर जे!=14और जे!=17और जे!=20:

gpio.output(j, gpio. LOW)

समय सो जाओ (0.05)

जे इनरेंज के लिए (11, 24, 1):

अगर जे!=14और जे!=17और जे!=20:

gpio.output(j, gpio.high)

समय सो जाओ (0.05)

समय सो जाओ (0.5)

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

समय सो जाओ (0.03)

स्पष्ट()

प्रिंट करें"खेल समाप्त करें…\n", current_voltage, "V"

#रिकॉर्ड

समय सो जाओ (1.2)

पहुंच गया = 0

मैं व्यवस्था के लिए(10):

अगर करंट_वोल्टेज> वोल्टेज :

पहुंच गया+=1

अस्थायी_वोल्टेज = वोल्टेज

वोल्टेज = वर्तमान_वोल्टेज

वर्तमान_वोल्टेज = अस्थायी_वोल्टेज

अस्थायी_नाम = नाम

नाम = current_name

current_name=temp_name

अगर पहुंच गया> 0:

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

समय सो जाओ (0.03)

स्पष्ट()

एफ = खुला ('रिकॉर्ड', 'डब्ल्यू')

मैं व्यवस्था के लिए(10):

f.लिखें (नाम )

f.लिखें ("\ n")

f.लिखें (str (वोल्टेज ))

f.लिखें ("\ n")

एफ.क्लोज़ ()

स्पष्ट()

देखें rawlamps_bike.py GitHub द्वारा ❤ के साथ होस्ट किया गया

चरण 8: विद्युत योजना:

Arduino और रास्पबेरी पाई 3 3A करंट के साथ 5V स्रोत द्वारा संचालित होते हैं।

विद्युत सर्किट डीसी जनरेटर (साइकिल से युग्मित) के कनेक्शन के साथ शुरू होता है, जो 5.3V के जेनर डायोड, 10μF के कैपेसिटर और 1kΩ के प्रतिरोधी से बने वोल्टेज फ़िल्टर के माध्यम से Arduino से जुड़ा होता है - फ़िल्टर इनपुट से जुड़ा होता है जनरेटर टर्मिनल और आउटपुट A0 पोर्ट और कंट्रोलर के GND से जुड़ा है।

Arduino RX-TX संचार के माध्यम से रास्पबेरी से जुड़ा है - 10kΩ प्रतिरोधों (विभिन्न वोल्टेज पर संचालित नियंत्रकों के बंदरगाहों द्वारा आवश्यक) का उपयोग करके एक प्रतिरोधक विभक्त के माध्यम से किया जाता है।

रास्पबेरी पाई के जीपीआईओ लैंप को चालू करने के लिए जिम्मेदार रिले से जुड़े हैं। सभी रिले का "COM" आपस में जुड़ा हुआ था और चरण (एसी ग्रिड) से जुड़ा था और प्रत्येक रिले का "एन.ओ" (सामान्य रूप से खुला) प्रत्येक दीपक से जुड़ा था और एसी ग्रिड का तटस्थ सभी लैंप से जुड़ा हुआ था। इस प्रकार, जब प्रत्येक रिले के लिए जिम्मेदार GPIO सक्रिय होता है, तो रिले को AC नेटवर्क के चरण में बदल दिया जाता है और संबंधित लैंप को चालू कर दिया जाता है।

चरण 9: परिणाम:

परियोजना की अंतिम असेंबली के बाद, यह सत्यापित किया गया था कि यह अपेक्षित रूप से काम करता है - जिस गति से उपयोगकर्ता बाइक पर पेडल करता है, उससे अधिक वोल्टेज उत्पन्न होता है और अधिक लैंप जलते हैं।