יצירת מתח עם אופני ארגומטר: 9 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

פיתוח הפרויקט כלל הרכבה של "משחק" שמטרתו לדווש באופני ארגומטר המחוברים לגנרטור ולמגדל מנורות המופעלות ככל שמהירות המנוע עולה - המתרחשת בהתאם לדוושת האופניים. המערכת התבססה על קריאה-דרך יציאה אנלוגית של Arduino Mega-המתח המיידי שנוצר, ולאחר מכן העברת נתונים אלה ל- Raspberry Pi 3 באמצעות תקשורת RX-TX טורית והפעלת המנורות לאחר מכן באמצעות ממסר.

שלב 1: חומרים:

• 1 פטל פטל 3;
• 1 ארדואינו מגה 2560;
• 1 מגן ממסר עם 10 ממסרים 12 וולט;
• 10 מנורות ליבון 127 וולט;
• 1 אופני ארגומטר;
• 1 מכונה חשמלית (גנרטור) 12 וולט;
• נגדים (1x1kΩ, 2x10kΩ);
• קבל אלקטרוליטי 10 µF;
• דיודה זנר 5.3 V;
• כבל 1.5 מ"מ (אדום, שחור, חום);
• מגדל MDF 1 עם תמיכה ל -10 מנורות.

שלב 2: תרשים חסימות מערכת:

שלב 3: הפעלת המערכת:

המערכת מבוססת על טרנספורמציה של האנרגיה הקינטית הנוצרת בעת רכיבה על אופניים באנרגיה חשמלית האחראית להפעלת הממסרים שידליקו את המנורות.

המתח שנוצר על ידי הגנרטור נקרא על ידי סיכה אנלוגית של Arduino ונשלח באמצעות RX-TX ל- Raspberry Pi. הפעלת הממסרים פרופורציונלית למתח שנוצר - ככל שהמתח גבוה יותר יופעלו יותר ממסרים וידלקו יותר מנורות.

שלב 4: היבטים של מכניקה

על מנת לחבר מכנית את גנרטור DC לאופניים, היה צריך להחליף את מערכת החגורה במערכת המשמשת באופניים נפוצים (המורכבת מכתר, שרשרת ופיניון). לוחית מתכת מולחמה למסגרת האופניים כך שניתן יהיה לאבטח את המנוע באמצעות ברגים. לאחר מכן, הפיניון מולחם אל פיר הגנרטור כך שניתן יהיה למקם את השרשרת, המחברת את מערכת הדוושות לגנרטור.

שלב 5: קריאת מתח:

כדי לקרוא את המתח של הגנרטור באמצעות Arduino יש צורך לחבר את הקוטב החיובי של המכונה החשמלית לפין A0 של הבקר ואת הקוטב השלילי ל- GND - כדי להימנע מכך שהמתח המרבי של הגנרטור גדול מ -5 V של ה- סיכות ארדואינו, מסנן מתח באמצעות קבלים של 10 µF, נגד של 1 kΩ ו דיודת זנר של 5.3 V נבנו ומחוברים בין הבקר לגנרטור. הקושחה הנטענת בארדואינו פשוטה מאוד ומורכבת רק מקריאת יציאה אנלוגית, מכפילים את הערך הנקרא בקבוע 0.0048828125 (5/1024, כלומר מתח ה- GPIO של הארדואינו מחולק במספר הביטים ביציאה האנלוגית שלו) ושליחת משתנה לסדרה - הקוד יהיה זמין במאמר.

ההליך לאפשר תקשורת RX-TX ב- Raspberry Pi הוא קצת יותר מורכב, ועליך לבצע את ההליך המתואר בקישור. בקצרה, עליך לערוך קובץ בשם "inittab" -הממוקם ב- "/etc/inittab" -, הגיב על השורה "T0: 23: respawn:/sbin/getty -L ttyAMA0 115200 vt100" (אם הקובץ אינו מבוסס במערכת ההפעלה של Raspberry, עליך להזין את הפקודה: "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 ()" - הקוד המלא המשמש ב- Raspberry יהיה זמין בסוף המאמר.

בהתאם להליך המתואר לעיל, שלב מתח הקריאה והשלוח הושלם.

שלב 6: תכנות ארדואינו:

כפי שצוין לעיל, הקוד האחראי לקריאת המתח הנוצר בעת רכיבה על אופניים הוא פשוט מאוד.

ראשית, יש לבחור את סיכת A0 כאחראית לקריאת המתח.

בפונקציה "הגדרת void ()", עליך להגדיר את סיכה A0 ל- INPUT באמצעות הפקודה "pinMode (חיישן, INPUT)" ולבחור את מהירות שידור היציאה הטורית באמצעות הפקודה "Serial.begin (9600)".

ב"לולאת void () ", הפונקציה" Serial.flush () "משמשת לניקוי המאגר בכל פעם שהיא מסיימת שליחת מידע באמצעות סדרתי; קריאת המתח מתבצעת על ידי הפונקציה "analogRead (חיישן)" - זכור כי יש צורך להמיר את הערך הנקרא ביציאה האנלוגית ל- Volt - תהליך המצוטט בסעיף "מתח קריאה" של המאמר.

כמו כן, בפונקציה "void loop ()" יש צורך להמיר את המשתנה x מצוף למחרוזת, מכיוון שזו הדרך היחידה לשלוח את המשתנה באמצעות RX-TX. השלב האחרון בפונקציית הלולאה הוא הדפסת המחרוזת ביציאה הטורית כך שניתן לשלוח אותה ל Raspberry - לשם כך עליך להשתמש בפונקציה "Serial.println (y)". השורה "עיכוב (100)" נוספה לקוד רק כך שהמשתנה נשלח במרווחים של 100 אלפיות השנייה - אם הזמן הזה לא יכובד, יתרחש העומס הסידורי שיוצר קריסות אפשריות בתוכנית.

voltage_read.ino

חיישן מצוף = A0;

הגדרת voids () {

pinMode (חיישן, INPUT);

Serial.begin (9600);

}

voidloop () {

Serial.flush ();

float x = analogRead (חיישן)*0.0048828125*16.67;

מחרוזת y = "";

y+= x;

Serial.println (y);

עיכוב (100);

}

הצג rawvoltage_read.ino המתארח אצל ❤ על ידי GitHub

שלב 7: תכנות Raspberry Pi 3:

lampes_bike.py

ייבא את os #ייבא את ספריית מערכת ההפעלה (משמש לניקוי המסך בעת הצורך)

ייבוא ספריית RPi. GPIOas gpio #import המשמשת לשליטה ב- GPIO של ה- Raspnerry

ייבוא ספריית #יבוא סדרתית האחראית על התקשורת הטורית

ייבוא זמן ספריית ייבוא המאפשר להשתמש בפונקציית העיכוב

ייבוא תת -תהליך #ייבוא הספרייה שאחראי להשמעת השירים

#התחל סדרתי

ser = serial. Serial ("/dev/ttyS0", 9600) #הגדירו את שם המכשיר ואת קצב השידור

#מסך נקי

clear = lambda: os.system ('ברור')

סיכות #set לבקרת ממסר

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

#התחל רשומות

name = ["None"]*10

מתח = [0.00]*10

#לקרוא קובץ רשומות

f = open ('רשומות', 'r')

for i inrange (10): #10 הציונים הטובים ביותר מופיעים ברשימה

שם = f.readline ()

שם = שם [: len (שם )-1]

מתח = f.readline ()

מתח = מצוף (מתח [: len (מתח )-1])

f.close ()

ברור()

#הגדר את המתח המרבי

מקסימום = 50.00

#כבו את המנורות

עבור i inrange (11, 24, 1):

אם אני! = 14 ואני! = 17 ואני! = 20:

gpio.output (i, gpio. HIGH) #מוגדר ל- HIGH, הממסרים כבויים

#הַתחָלָה

whileTrue:

#מסך ראשי

הדפס "רשומות: / n"

עבור i inrange (10):

שם ההדפסה , ":", מתח , "V"

current_name = raw_input ("כתוב את שמך כדי להתחיל:")

ברור()

#שנה ערך מקסימלי

אם name_name == "max":

max = input ("כתוב את המתח המרבי: (2 נקודות עשרוניות)")

ברור()

אַחֵר:

אזהרת התחלה #

עבור i inrange (11, 24, 1): #הלולאה מתחילה ב- PIN 11 ומפסיקה ב- PIN 24

אם i! = 14and i! = 17and i! = 20: #PIN 14 ו- 20 הם סיכות GND ו- 20 הוא סיכה של 3.3 V

gpio.output (i, gpio. LOW) #הדלק את המנורות

time.sleep (0.5)

k = 10

עבור i inrange (23, 10, -1):

ברור()

אם אני! = 14 ואני! = 17 ואני! = 20:

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

time.sleep (0.03)

ברור()

- הדפסה "היכונו! / n", ק

time.sleep (1)

k- = 1

gpio.output (i, gpio. HIGH) #t לכבות את המנורות (אחת אחת)

subprocess. Popen (['aplay', 'Audios/go.wav']) #מנגן את מוזיקת ההתחלה

time.sleep (0.03)

ברור()

הדפס "GO!"

time.sleep (1)

ברור()

#מתח קריאה

current_voltage = 0.00

מתח 1 = 0.00

עבור i inrange (200):

ser.flushInput ()

הקודם = מתח 1

voltage1 = float (ser.readline ()) #c אוסף את הנתונים של Arduino המועברים באמצעות RX-TX

ברור()

מתח הדפסה 1, "V"

אם מתח 1> מתח_ הנוכחי:

current_voltage = מתח 1

# בהתאם למתח שנוצר, יותר מנורות נדלקות.

אם מתח 1 <מקסימום/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*מקסימום/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. HIGH)

אם מתח 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> = מקסימום:

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

time.sleep (0.03)

ברור()

הדפיס "טוב מאוד, זכית!"% (u '\u00c9', u '\u00ca', u '\u00c2')

עבור i inrange (10):

עבור j inrange (11, 24, 1):

אם j! = 14and j! = 17and j! = 20:

gpio.output (j, gpio. LOW)

time.sleep (0.05)

עבור j inrange (11, 24, 1):

אם j! = 14and j! = 17and j! = 20:

gpio.output (j, gpio. HIGH)

time.sleep (0.05)

time.sleep (0.5)

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

time.sleep (0.03)

ברור()

הדפס "סיום משחק … / n", מתח_זרם, "V"

#רשומות

time.sleep (1.2)

הגיע = 0

עבור i inrange (10):

אם מתח_ הנוכחי> מתח :

הגיע ל-+= 1

temp_voltage = מתח

מתח = מתח_ הנוכחי

current_voltage = temp_voltage

temp_name = שם

שם = שם נוכחי

current_name = temp_name

אם יגיעו> 0:

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

time.sleep (0.03)

ברור()

f = open ('רשומות', 'w')

עבור i inrange (10):

f.write (שם )

f.write ("\ n")

f.write (str (מתח ))

f.write ("\ n")

f.close ()

ברור()

הצג rawlamps_bike.py המתארח אצל ❤ על ידי GitHub

שלב 8: תוכנית חשמלית:

ה- Arduino ו- Raspberry Pi 3 מופעלים על ידי מקור 5V עם זרם 3A.

המעגל החשמלי מתחיל בחיבור של גנרטור DC (מצמידים לאופניים) לארדואינו באמצעות מסנן מתח המורכב מדיודת זנר של 5.3V, קבל של 10μF ונגד של 1kΩ - קלט המסנן מחובר ל- מסופי הגנרטור והפלט מחובר ליציאת A0 ול- GND של הבקר.

ה- Arduino מחובר ל Raspberry באמצעות תקשורת RX-TX-מבוצע באמצעות מחלק התנגדותי באמצעות נגדים של 10kΩ (נדרש על ידי יציאות הבקרים הפועלים במתח שונה).

מכשירי ה- GPIO של Raspberry Pi מחוברים לממסרים האחראים על הדלקת המנורות. ה- "COM" של כל הממסרים היה מחובר ומחובר לשלב (רשת AC) ו- "N. O" (פתוח בדרך כלל) של כל ממסר היה מחובר לכל מנורה והניטראל של רשת AC היה מחובר לכל המנורות. כך, כאשר GPIO האחראי על כל ממסר מופעל, הממסר מועבר לשלב של רשת AC והדליק את הנורה המתאימה.

שלב 9: תוצאות:

לאחר ההרכבה הסופית של הפרויקט, אומת שהוא פועל כצפוי - בהתאם למהירות שהמשתמש מדווש על האופניים, יותר מתח נוצר ויותר מנורות נדלקות.