מדריך ארדואינו למתחילים חלק א’
ללמוד בקרה אלקטרוניקה ותכנות עם ארדואינו
פרקים:
- מה זה ארדואינו ומה אפשר לעשות איתו?
- כיבוי והדלקת נורה
- הפעלת זמזם
- אלקטרוניקה בסיסית
- נורת לד RGB
- קבלת קלט מכפתורים ופוטנציומטר
- תקשורת טורית דרך ה-USB
- אוגר הזזה
- קריאה של חיישנים
- שימוש בספריות
- מטריצת לדים
- ג’ויסטיק אנלוגי
- חיישן תנועה אינפרא אדום
- ממסר
- חיישן מרחק אולטראסוני
- תצוגת ספרות 7 מקטעים
- מקורות מתח
מה זה ארדואינו ומה אפשר לעשות איתו?
ארדואינו הוא לוח פיתוח ופלטפורמה בקוד פתוח שכולל סביבת פיתוח קלה ונוחה למשתמש.
הוא מיועד למהנדסי אלקטרוניקה, סטודנטים, אומנים,חובבי רובוטיקה, ילדים וכל מי שמתעניין באלקטרוניקה ומחשבים.
כדי להפעיל ארדואינו אין צורך בידע מוקדם, והרעיון המרכזי הוא לשחק איתו ולבנות פרויקטים ותוך כדי כך ללמוד על עולם האלקטרוניקה והמחשבים. זוהי דרך מצוינת ללמוד בעיקר בזכות הקלות של השימוש בו.
השימושים בארדואינו מוגבלים רק ע”י הדמיון שלכם: הוא יכול להיות מערכת השקיה ממוחשבת, שעון מעורר, שרת אינטרנט, מערכת בית חכם, ואפילו רובוט!! ואלו רק חלק מהשימושים.
הדרך הטובה ביותר לחשוב על ארדואינו הוא כמוח קטן… המוח של האדם מקבל קלט מהחושים שלנו(עיניים, אוזניים, אף) מעבד את הנתונים שהוא קיבל ועושה איתם משהו, לדוגמה מפעיל איברים בגוף כמו ידיים ורגליים.
הארדואינו מקבל קלט מחיישנים(חיישן קרבה, חיישן אור, כפתור) מעבד את הנתונים, ולפי התוכנה שכתובה בו מחליט האם ואיך להפעיל פלט מסוים כמו נורה, מנוע או מסך.
לכן הוא נקרא בקר כי הוא מבקר על הפעולות שנעשות על פי התוכנה שאנחנו מכניסים אליו.
ארדואינו הוא מחשב קטן שיכול להתממשק אל העולם הפיזי. הוא חלש יותר ממחשב ביתי אבל יש לו גישה אל רכיבים חיצוניים בניגוד למחשב הביתי. גם המחשב ביתי מחובר אל אמצעי קלט ופלט כמו מקלדת ומסך אבל בארדואינו האפשרויות הן בלתי מוגבלות.
אין לו שימוש ספציפי מסוים אלא הוא מכונה כללית עם אינספור שימושים ואפליקציות. הוא מזכיר במקצת את הסמארטפון שהוא היבריד בין בקר למחשב, אבל גם הסמארטפון מוגבל במה שהמשתמש יכול לעשות איתו. ארדואינו הוא לא מוצר מוגמר אלא כלי לבניית מוצרים ופרויקטים.
אם אתם אוהבים לקנות מוצר מוכן כמו סמארטפון שמישהו בנה בשבילכם ורוב האפשרויות סגורות בפניכם אז זה גם בסדר גמור אבל הארדואינו הוא שונה – אתם קובעים איך להשתמש בו ומה לעשות איתו. יש לזה מחיר כמובן שהוא הקשיים הראשוניים להבין איך הוא עובד אבל הסיפוק של לבנות משהו בעצמך הוא כל כך גדול שזה שווה את כל הטרחה.
כמו כל מחשב, את הארדואינו ניתן לחלק לחומרה ותוכנה – החומרה היא כל הרכיבים הפיזיים שנמצאים על המעגל המודפס, והשפה שהם מבינים היא חשמל.
התוכנה היא רצף הוראות שכתוב בשפת תכנות ארדואינו(מבוססת על ++C ) והיא אומרת ללוח הארדואינו מה לעשות. המשתמש הוא זה שכותב את התוכנה.
הארדואינו הוא לוח פיתוח ופלטפורמת חומרה בקוד פתוח ולכן שרטוט המעגלים וכל הקבצים נגישים לכל אחד באופן חופשי. עובדה זו הפכה אותו לפופולרי במיוחד בעולם המייקרים ולמעשה מאפשרת לכל אדם לשנות את העיצוב שלו ואפילו לייצר תואם ארדואינו משלו ולמכור אותו.
תואמי ארדואינו בדרך כלל מיוצרים בסין ולא בארץ המקור של הארדואינו שהיא איטליה, ולכן אם אתם קונים תואמים אתם לוקחים סיכון מסוים שכן איכות הארדואינו תלויה באיכות ההרכבה והייצור שלו.
לוחות שונים של ארדואינו
הארדואינו אונו (UNO) הוא הלוח הנפוץ והפופולרי ביותר ומשמש לרוב הפרויקטים ההתחלתיים.
הארדואינו לאונרדו הוא לוח משופר של האונו ומספק את אותן יכולות במחיר מעט זול יותר.
הארדואינו נאנו והמיקרו הם לוחות קטנים ביותר ועדיף להשתמש בהם בפרויקטים בהם יש מגבלת מקום.
ארדואינו מגה הוא גדול יותר ועדיף לשימוש בפרויקטים גדולים ומסובכים יותר.
בספר זה נתרכז בארדואינו אונו והנה תמונה של ארדואינו אונו:
Atmel ATmega328
בליבו של הארדואינו יושב הבקר ATmega328. בקר זה אחראי על ביצוע כל הפקודות שאנחנו כותבים בסביבת הפיתוח ובשמירתם בזכרון שלו.
שפת התכנות של הארדואינו נותנת לנו גישה להפעיל ולכבות פינים מסוימים בבקר ובנוסף יש לנו גישה אל הבקר דרך הפינים השקועים שעל לוח הארדואינו.
ניתן לראות אם כן שלוח הארדואינו פשוט נותן לנו גישה אל בקר ה- ATmega ודרך חיבורו למחשב אנחנו יכולים לכתוב תוכנה בסביבת הפיתוח שתגיד לבקר מה לעשות.
כדי להפעיל את הארדואינו צריך לתת לו כוח אשר יכול להיות מסופק מכניסת ה- USB של המחשב, מכניסת החשמל או מבטריה חיצונית.
האונו מופעל ע”י כבל USB אשר מספק לו מתח של 5 וולט וגם מאפשר העברת נתונים – כתיבת התוכנה מסביבת הפיתוח שעל המחשב לארדואינו.
כדי להתחיל בואו נוריד קודם כל את תוכנת הארדואינו למחשב האישי שלנו.
היכנסו לאתר הראשי של ארדואינו https://www.arduino.cc , היכנסו להורדות ובחרו windows installer. לחצו על just download. לאחר ההורדה לחצו לחיצה כפולה על האייקון ואשרו את ההתקנה. כעת התוכנה תותקן על המחשב שלכם.
המחשב יבקש הרשאה להתקין דרייברים מסוימים קבלו את זה בברכה…
אם אתם מסתבכים הנה הוראות מפורטות איך להתקין את התוכנה על המחשב שלכם.
אם לא בחרתם ב- windows insaller אלא הורדתם את קובץ ה- zip יכול להיות שיהיה צורך להוריד דרייברים. אם המחשב לא מזהה את חומרת הארדואינו צריך ללחוץ לחיצה ימנית על המחשב שלי, מאפיינים, ומנהל ההתקנים.
מתחת לפתחות צריך להופיע הדרייבר. לחצו עליו לחיצה ימנית ועדכון תוכנה. לחצו על חיפוש במחשב ובחרו את הדרייבר המתאים.
סיור בשקעי הארדואינו
שקעי הארדואינו הנקראים גם פינים מהווים את הבסיס להפעלתו. ישנם 14 פינים דיגיטליים שהם הדרך שלנו להפעיל ולכבות את המתח שאותו אנחנו רוצים לספק לפלט כלשהו, או לקבל קלט ממקור כלשהו.
הם למעשה בסיס הלוגיקה של הארדואינו והמתח שבו הם עובדים הוא 5 וולט. ל- 7 פינים מתוך ה- 13 ישנה יכולת לספק מתח מ- 0 עד 5 וולט בדרך שנקראת pwm והם מסומנים ע”י תלתל.
בנוסף ישנם שישה פינים לכניסה אנלוגית המפענחים את המתח המשתנה שהם מקבלים וממירים אותו לערך דיגיטלי שבין 0 עד 1023.
ישנם 3 פינים של GND שהוא אפס או מינוס, ומסמל את נקודת הייחוס של המעגל החשמלי ממנה נמדד המתח. כל מעגל חשמלי מתחיל ממקור מתח כלשהו ומסתיים ב- GND.
ישנם פינים של אספקת 5 וולט ו- 3.3 וולט והם מספקים אספקה קבועה של מתח להתקנים נוספים כמו חיישנים, כלומר לא ניתן לשלוט עליהם ע”י התוכנה.
הפין שנקרא VIN הוא פין שנותן לנו לספק מתח לארדואינו ממקור כח חיצוני לדוגמה בטריה והמתח שהוא אמור לקבל הוא מ- 5 וולט ועד 20 וולט ולאחר מכן המתח מורד ל-5 וולט ומומלץ לספק דרכו 9 וולט .
פינים 0 ו- 1 יכולים לשמש גם להעברת מידע לבקרים אחרים וכך גם SDA ו- SCL שמיועדים לתקשורת בפרוטוקול I2C.
דבר אחד שחשוב לזכור הוא שהיכולת של הפינים הדיגיטליים היא מוגבלת בערך ל- 40 מיליאמפר לכל פין.
כשמדליקים נורה אין עם זה כל בעיה, אבל אם רוצים להפעיל מטען “זולל” כמו מנוע למשל אין להפעיל אותו ישירות מפינים אלו אלא יש להשתמש בממסר או טרנזיסטור.
ניתן להפעיל את המנוע מאספקת המתח הקבועה(פין 5 וולט) אך גם לזה יש גבול של 900 מיליאמפר שהיא כמות הזרם שיכולה לספק יציאת USB סטנדרטית של מחשב.
כך נראית סביבת הפיתוח של ארדואינו:
שפת התכנות שבה אנו משתמשים היא שפת ארדואינו ומבוססת על ++C רק קצת פשוטה וקלה יותר ללימוד.
ישנן שתי פונקציות שחייבות להופיע בכל סקיצה שאנחנו כותבים:
void setup היא פונקציה שרצה פעם אחת כשהארדואינו מופעל. Void loop היא פונקציה שרצה בצורה אינסופית מרגע שהארדואינו נדלק ועד שאנחנו מכבים אותו.
הקוד שאנחנו כותבים נכנס בתוך הסוגריים המסולסלות. כל שאר הקוד שאנחנו כותבים לדוגמה פונקציות משלנו או משתנים גלובליים צריכים לשבת מחוץ לשתי פונקציות אלו.
כיבוי והדלקת נורה
הגיע הזמן ללכלך את הידיים ולהפעיל נורה באמצעות הארדואינו. על לוח הארדואינו ישנה נורה זעירה שמחוברת לפין מספר 13. אנחנו נפעיל בנוסף גם נורה חיצונית שתהיה מחוברת בין פין 13 ל- GND.
כדי להפעיל נורה באמצעות הארדואינו עלינו לחבר אותה דרך נגד. תפקידו של הנגד הוא להפחית את הזרם שרץ במעגל חשמלי ואם לא נשתמש בו הנורה עלולה להישרף!!.
מטריצת חיבורים
בשביל דוגמה זו ובכל הדוגמאות האחרות אנחנו נשתמש בלוח מטריצה. לוח זה מאפשר לנו לחבר בנוחות מעגלים חשמליים אל הארדואינו.
כך הוא נראה:
העקרון שלו הוא די פשוט – שתי השורות העליונות ושתי השורות התחתונות(איפה שרשום פלוס ומינוס) מחוברות אחת לשניה בצורה אופקית, וכל הטורים באמצע מחוברים בצורה אנכית.
הבהוב נורת לד
הכניסו נורת לד בצבע כלשהו למטריצה וזכרו היכן נמצאת הרגל הארוכה. חברו לאותה שורה של הרגל הארוכה חוט לפין מספר 13 בארדואינו.
לשורה של הרגל הקצרה חברו נגד 220ohm ומהשורה של הנגד חוט ל- GND בארדואינו. בהמשך נלמד מדוע אנחנו משתמשים בערך של 220 אוהם.
חברו את כבל ה- USB בין המחשב לארדואינו – הארדואינו עכשיו פועל.
פתחו את סביבת הפיתוח ובחרו ב- כלים > לוח > ובארדואינו אונו. אחרי זה פתחו שוב את כלים > פתחה ובחרו בפתחה המוצעת לדוגמה COM3.
עכשיו ניתן לכתוב את התוכנה:
void setup() { // function that runs once
pinMode(13, OUTPUT); // set pin 13 (led) to output
}
void loop() { // function that runs infinitely
digitalWrite(13, HIGH); // turn pin 13 on
delay(2000); // wait 2 seconds
digitalWrite(13, LOW); // turn pin 13 off
delay(2000); // wait 2 seconds
}
שמרו את את הקוד ע”י לחיצה על שמור, תנו לו שם באנגלית לדוגמה blink ולחצו על אישור. כעת לחצו על העלאה(upload) – הנתונים כעת עוברים מסביבת הפיתוח לארדואינו.
שימו לב להערות המסומנות כך: //. הערות נועדו לתאר מה הקוד עושה והמחשב מתעלם מהם, אבל הן חיוניות ביותר למשתמש ולמתכנתים אחרים שקוראים את הקוד.
עוד דבר שאפשר לשים לב אליו הוא ההזחה שהיא מרווח של כמה רווחים בשורה מתחת לשורה שיש בה סוגריים מסולסלות. הזחה כזו נמצאית בתוך פונקציה, התנייה, ולולאה כדי שיהיה יותר נוח להבין איפה היא מתחילה ואיפה היא נגמרת. מספר הרווחים הוא לא משנה כי התוכנה מתעלמת מרווחים רק חשוב שיהיה קריא ויפה בעין.
כעת הנורה אמורה להידלק ולכבות כל שתי שניות.
אם היא לא נדלקת סימן שמשהו לא בסדר:
הוציאו והכניסו את הכבל ובחרו שוב בפתחה המוצעת.
כתיבת קוד בארדואינו
אם הכל עובד עכשיו אפשר לנסות להבין את הקוד –
כל סקיצה של ארדואינו חייבת לכלול לפחות שתי פונקציות – setup ו loop למרות שהן יכולות להישאר ריקות.
במקרה שלנו בפונקציה הראשונה אנחנו מכינים את פין מספר 13 להיות פין פלט(OUTPUT) כי אנחנו רוצים שהוא יספק מתח לנורה על פי הקוד. פונקציית ה- loop כוללת את הקוד שרץ בצורה אינסופית או עד שמנתקים את הארדואינו.
הפקודה שאנחנו משתמשים בה היא digitalWrite (שימו לב לגודל האותיות) שמקבלת שני ערכים. הערך הראשון הוא מספר הפין שבו אנחנו רוצים לשלוט, והערך השני האם להפעיל או לכבות אותו – HIGH או LOW.
הפקודה השנייה היא delay שאומרת לקוד להמתין והערך שהיא מקבלת נמדד במילישניות – 2000 מילישניות = 2 שניות. בתוך הפונקציות בסוף כל שורה יש גרשיים סופיות שהן כמו נקודה בסוף משפט.
אנחנו מדליקים את הפין, מחכים 2 שניות, מכבים אותו, ואז שוב מחכים 2 שניות. צריך להוסיף שהמעבד של הארדואינו רץ במהירות גבוהה מאוד לכן אנחנו מוסיפים את ההמתנה של ה- 2 שניות. בואו ננסה לבטל את ההמתנה:
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
עכשיו הנורה נשארת דולקת כל הזמן כי הקוד רץ מהר מדי כדי שנבחין בשינוי.
בואו ננסה לשחק קצת עם המספרים בפונקציית ה- delay:
void setup() {
pinMode(13, HIGH);
}
void loop() {
digitalWrite(13, HIGH);
delay(200);
digitalWrite(13, LOW);
delay(1300);
}
ועכשיו נשגע את הארדואינו:
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(50);
digitalWrite(13, LOW);
delay(50);
}
תמשיכו לשחק עם המספרים שנמצאים בפונקציית ה- delay עד שימאס לכם.
פעולה של כיבוי והדלקת נורה היא פעולה פשוטה אבל אפשר לדמיין שבעזרת פעולה זו של כיבוי והדלקת פינים אפשר לשלוט כמעט בכל התקן אחר, ולמעשה כל עולם האלקטרוניקה והתכנות מבוסס על פעולה זו.
אחרי שלמדנו להדליק ולכבות נורה נלמד קצת על סביבת הפיתוח של הארדואינו ועל התכנות שלו. כל קוד שנכתב בארדואינו נקרא סקיצה וצריך לקבל שם ולהישמר.
אם תלחצו על קובץ מצד שמאל למעלה תוכלו לראות שם דוגמאות וסקיצות. הסקיצות הן אלה שכתבתם ושמרתם ונמצאות בתיקיית ארדואינו. הדוגמאות כוללות עשרות סקיצות שאנשים אחרים כתבו והן שימושיות ביותר להפעלה ראשונית של הארדואינו.
בכלים תוכלו למצוא את בחירת לוח שקובע באיזה לוח של ארדואינו אנחנו משתמשים, ובחירת פתחה(port) של המחשב.
פונקציות בסיסיות
כאמור כל סקיצה צריכה לכלול לפחות שתי פונקציות – setup ו- loop. פונקציה בשפת תכנות היא רצף של הוראות שעטוף בסוגריים מסולסלות ובדרך כלל ניתן לה שם.
ישנן פונקציות בסיסיות שמגיעות עם סביבת הפיתוח וניתן גם לבנות פונקציות משלנו. הפונקציות הבסיסיות שמגיעות עם הארדואינו:
digitalWrite – מקבלת שתי ערכים שהם מספר פין ו- HIGH או LOW. היא אומרת לארדואינו האם לספק מתח של 5 וולט לפין מסויים. בדרך כלל היא נמצאת בתוך פונקציית ה- loop. דוגמה – (digitalWrite(8, HIGH.
digitalRead – פונקצייה שקוראת את הערך המתקבל מפין מסויים בארדואינו. הערך יכול להיות 0 או 5 וולט זאת אומרת HIGH או LOW. מקבלת ערך אחד שהוא מספר פין. דוגמה – (digitalRead(6.
analogRead – קוראת את הערך האנלוגי שמתקבל מפין מסויים. הערך המתקבל הוא בין 0- 1023 ומייצג את כמות המתח המתקבלת. לארדואינו יש 6 פינים לכניסה אנלוגית שממוספרים A0-A5. דוגמה – (analogRead(A0.
analogWrite – פונקצייה שמוציאה כמות מתח משתנה ומבוטאת בערכים בין 0-255 . הפינים שבהם ניתן לעשות זאת הן פינים דיגיטליים שיש לידם תלתל(3,5,6,9,10,11) והפעולה הזו נקראית PWM שהיא פעולה שמוציאה כביכול מתח אנלוגי מפין דיגיטלי. דוגמה – (analogWrite(3, 128.
pinMode – בניגוד לפונקציות הקודמות הפונקציה הזו נמצאת בתוך פונקציית ה- setup. היא קובעת מראש האם אנחנו רוצים לכתוב או לקרוא את הערך מפין מסוים. היא מקבלת שני ערכים שהם מספר פין ו- INPUT או OUTPUT . דוגמה – (pinMode(7, OUTPUT .
delay – גורמת לקוד להמתין לפי מספר המילישניות בסוגריים. דוגמה – (delay(1000 . הקוד מחכה שנייה לפני שהוא ממשיך.
הפעלה אנלוגית
בדוגמה הקודמת הפעלנו את נורת הלד ע”י הפין הדיגיטלי מספר 13. כשנשלחה הפקודה digitalWrite הפין סיפק לנורה מתח של 5 וולט.
ישנה עוד דרך לספק מתח לפינים של הארדואינו ע”י מתח משתנה שנקרא pwm. בצורה זו ניתן לשלוט ברמת המתח המסופק לפין. הפונקציה שמבצעת את זה נקראת analogWrite והיא מקבלת ערך מ- 0 ל 255.
שימו לב שרק חלק מהפינים הדיגיטליים בארדואינו מסוגלים לבצע פעולה זו וניתן להבחין בהם ע”י התלתל שמופיע בסמוך למספר הפין. לפין 11 יש תלתל לכן אפשר להעביר את החוט האדום מפין 13 ל- 11.
כדי לדייק קצת בעובדות נוסיף שאנחנו לא בדיוק מספקים לפין ערך משתנה. הפין יכול לספק רק 5 או 0 וולט. מה שקורה למעשה הוא שאנחנו משנים את המהירות שבה הפין נדלק ונכבה וזה יוצר אפקט שגורם לעין לחשוב שהמתח השתנה. לחצו כדי ללמוד עוד על הנושא:
בואו נכתוב את הקוד הבא:
void setup() {
pinMode(11, OUTPUT);
}
void loop() {
analogWrite(11, 10);
delay(1000);
analogWrite(11, 40);
delay(1000);
analogWrite(11, 70);
delay(1000);
analogWrite(11, 100);
delay(1000);
analogWrite(11, 150)
delay(1000);
analogWrite(11, 250);
delay(1000);
}
שימו לב שכל שנייה עוצמת הנורה עולה לפי הערך שאנחנו נותנים לה. אתם יכולים לשנות את הערכים ולבדוק מה קורה. שימו לב שהערכים המתאימים הם מ- 0 ל- 255.
באותו אופן שאנחנו שולטים בנורה נוכל בהמשך גם לסובב מנוע לפי המהירות שנרצה וגם לשלוט בכל התקן אחר שדורש מתח משתנה.
זה הזמן ללמוד על לולאות. בכל שפת תכנות ישנה אפשרות להריץ קוד מסוים מספר פעמים ופונקציה זו נקראת לולאה. בשפת הארדואינו לולאה נראית כך:
(for(initial value, end value, increment
for אומר לארדואינו להתחיל את הלולאה. הערך הראשון הוא ערך האינדקס הראשוני שאנחנו רוצים להתחיל איתו. בהרבה דוגמאות הוא נקרא i.
הערך השני הוא ערך המסיים את הלולאה.
הערך האחרון מחליט מה יקרה לערך הראשוני בכל ריצה של הלולאה.
הכניסו את הקוד הבא לסביבת הפיתוח:
void setup(){
pinMode (11, OUTPUT);
}
void loop(){
for (int i=0; i<256; i++){
analogWrite(11, i);
delay(10);
}
for (int i=255; i>=0; i--){
analogWrite(11, i);
delay(10);
}
}
כל 10 מילישניות ערך האינדקס שבמקרה זה קראנו לו i עולה בערך אחד עד שהוא מגיע לערך הסופי שקבענו שהוא 255. ++I אומר לערך לעלות באחד מהערך הנוכחי.
אחרי שהלולאה הראשונה מסתיימת אנחנו מבצעים לולאה נוספת שמורידה את הערך כל 10 מילישניות עד שהוא מגיע ל- 0 וכך חוזר חלילה(זכרו שכל זה נמצא בתוך הלולאה האינסופית loop).
ללולאות יש חשיבות עצומה בעולם התכנה וככל שנבנה פרויקטים יותר מסובכים נשתמש בהם יותר. אפשר לשחק עם המספרים בתוך הלולאה כרצוננו לדוגמה:
int value=20; value<256; value=value+5
זהו גם המקום להסביר מה זה int ומה זה משתנה. משתנה בשפת תכנות הוא ערך השמור בזיכרון המחשב או הבקר ואנחנו נותנים לו שם. בדוגמה הראשונה קראנו לו i ובשנייה value.
שם המשתנה מפנה את התוכנה לערך המשתנה בזיכרון. בשפת התכנות של ארדואינו אנחנו צריכים לקבוע מראש איזה סוג ערך אנחנו מכניסים למשתנה ובגלל שאנחנו רוצים ערך מספרי(0-255) נודיע מראש שהוא יהיה int שזה קיצור של integer או מספר.
כדי ללמוד עוד על משתנים וסוגי משתנים בשפת הארדואינו:
משתנים בארדואינו
הפעלת זמזם
אחרי שהדלקנו אור הגיע הזמן לעשות קצת רעש.
הכניסו את הזמזם למטריצה(שימו לב איפה ה +). חברו חוט אדום מפלוס לפין 13 בארדואינו וממינוס ל- GND בארדואינו.
הקוד יכול להישאר אותו דבר כמו בדוגמה הקודמת. הזמזם מזמזם שנייה אחת, מחכה שנייה וחוזר חלילה. ישנם הרבה שימושים באלקטרוניקה לזמזמים בעיקר כדי לאותת שלחצנו על כפתור או הפעלנו משהו ואפשר גם להשתמש בו להודיע שמשהו לא בסדר.
אפשר גם ליצור איתו מוזיקה בסיסית ע”י כיבוי והדלקה של הפין מאות פעמים בשנייה, והרבה צעצועים עובדים בטכניקה הזו. כדי לשמוע דוגמה לחצו על קובץ > דוגמאות > דיגיטלי >toneMelody
בדוגמה הפין שמופעל הוא 8, אז החליפו את הפלוס מ- 13 ל- 8.
הדוגמה הזו משתמשת בפונקציה מובנית בארדואינו שנקראת tone. פונקציה זו יכולה להפעיל צופר פסיבי ואקטיבי והיא מקבלת שלושה ערכים שהראשון מביניהם הוא מספר הפין, השני הוא התדר(כמה פולסים אנחנו שולחים בשנייה), והשלישית היא זמן הצפירה במילישניות. לדוגמה –
tone(11, 500, 2000)
יפעיל זמזם המחובר לפין 11 בתדר של 500 הרץ למשך 2 שניות.
אלקטרוניקה בסיסית
אלקטרוניקה היא ענף המתרכז בשליטה של אנרגיה חשמלית בתוך מעגלים חשמליים. מעגל חשמלי כולל בתוכו שלושה דברים: מקור כוח(לדוגמה בטריה), מטען(לדוגמה נורה או מנוע), ונתיב מוליך אשר מאפשר לאלקטרונים לזרום.
בחומרים מוליכים כמו מתכות האלקטרונים רצים בין אטום לאטום בחומר המוליך כל עוד ישנו מתח בין שתי נקודות. ברגע שנחתוך את החוט האלקטרונים לא ירוצו עוד כי האוויר אינו חומר מוליך(אם המתח יהיה מספיק גבוה הם גם ירוצו באוויר לדוגמה כמו בברקים). אפילו אם ישנו מתח ללא מוליך האלקטרונים יישארו במקומם.
בתוך המעגל ישנם רכיבים אלקטרוניים מסוגים שונים שהנפוצים ביניהם הם נגד, קבל, סליל, טרנזיסטור ודיודה. את תנועת האלקטרונים בתוך המעגל ניתן לאפיין ע”י שלוש תכונות עיקריות: מתח זרם והתנגדות.
מתח – מדד שאומר לנו עד כמה האלקטרונים רוצים לזוז מנקודה מסוימת לנקודת ייחוס אחרת. מתח נמדד בוולט והמתחים העיקריים שנעבוד בהם עם הארדואינו הם 5 וולט, 3.3 וולט, 9 וולט, ו 12 וולט. אלו הם מתחים נמוכים ואין בהם סכנה. בתמונה למעלה הבטריה מספקת 9 וולט והמתח הזה מתחלק בין הרכיבים במעגל – המנוע והנגד.
זרם – זרם נמדד באמפר, אך במקרה של הארדואינו אנחנו נתעסק עם זרמים נמוכים יותר של מילי אמפר. זרם הוא מדד של מהירות זרימת האלקטרונים העוברים במוליך מסוים. כדי שאלקטרונים יעברו מנקודת המינוס אל הפלוס הם צריכים מוליך, בדרך כלל חוט נחושת.
התנגדות – היא המדד של החיכוך או ההאטה של אלקטרונים בתוך המעגל החשמלי ונמדדת באוהם. לחוט עצמו יש התנגדות וכך גם לכל רכיב אלקטרוני ומטען. אנחנו משתמשים בנגד, כפי שמופיע בתמונה, להאט את מהירות האלקטרונים במקרים מסוימים. לכל חומר בטבע ישנה התנגדות מסוימת – חומר בעל התנגדות גבוהה נקרא מבודד וחומר בעל התנגדות נמוכה נקרא מוליך.
ישנו קשר ישיר בין מתח, זרם והתנגדות: מתח = זרם כפול התנגדות.
שתי הדרכים הפשוטות ביותר לשלוט באנרגיה העוברת במטען כלשהו הם להגדיל/להקטין את עצמת המתח, או להגדיל/להקטין את ההתנגדות ע”י שינוי ערך הנגד.
לדוגמה במעגל חשמלי שמקור הכח שלו הוא 5 וולט(כמו בארדואינו), אנחנו מכניסים למעגל נגד של 330 אוהם ונורת לד. כמה זרם יעבור בנורה? יש לנו שני מטענים שכל אחד מהם לוקח כמות מתח מסוימת שמתחלקת במתח הכולל של המעגל.
אנחנו יודעים מראש שנורת הלד צורכת מתח באזור ה- 2.5 עד 3 וולט(לכל רכיב אלקטרוני יש מפרט מסודר שניתן להוריד מהאינטרנט). ה 2.5 וולט הנותרים יסופקו לנגד.
2.5 לחלק ל 330 = 0.007 אמפר או 7 מיליאמפר. כמות זרם זו מספיקה כדי להאיר את הנורה ונמצאת בטווח הבטוח שלה שהוא עד 30 מיליאמפר בערך. אם נרצה להאיר אותה באור חזק יותר נקטין את ההתנגדות ע”י החלפת הנגד ל 220 אוהם – 2.5 חלקי 220 = 11 מיליאמפר.
אם נחליף את הנגד ל 100 אוהם נקבל זרם של 25 מיליאמפר שכבר מתקרב לתחום המסוכן ולא מומלץ. חיבור המעגל ללא נגד כאמור ישרוף את הנורה.
רוב הזרמים שבהם נעבוד עם הארדואינו הם בטווחים של כמה עשרות או מאות מיליאמפר. צריך לזכור שהארדואינו הוא בסך הכל בקר ואינו אמור לספק זרמים גבוהים מדי. למשל כל פין של הארדואינו יכול לספק עד 40 מיליאמפר וכדי לספק יותר מכך צריך להשתמש במקור כח חיצוני וטרנזיסטור.
רב מודד
רב מודד הוא מכשיר המסוגל למדוד מתח זרם והתנגדות. בואו נמדוד את המתח הקיים בבטריה מסוימת. חברו את החוט האדום ל v ואת החוט השחור ל com. שנו את הידית ברב מודד ל 20V והצמידו את הזרוע האדומה לפלוס בבטריה ואת השחורה למינוס:
מדידת מתח היא תמיד בין שתי נקודות יחסיות, וכשאנו מודדים מתח במעגל חשמלי חשוב לזכור בין איזה נקודות אנחנו מודדים.
כדי למדוד התנגדות נעביר את המודד למצב של התנגדות.
נציב אותה על הערך הגדול מההתנגדות שאנחנו מודדים, לדוגמה הנגד בתמונה הוא של 2.2 קילו אוהם אז נציב את הידית על 20K אוהם.
נצמיד את הזרועות לקצוות של נגד מסוים וההתנגדות תופיע על הצג:
התוצאה היא 2.2 קילו-אוהם או 2200 אוהם.
כדי למדוד זרם אנחנו צריכים להכניס את הרב מודד לתוך המעגל החשמלי.
חברו חוט מיציאת 5 הוולט של הארדואינו דרך נגד של 220 אוהם ומשם לרב מודד ול-GND. את הרב מודד נציב על 200 מיליאמפר כי זו הדרגה שמעל הזרם שאנחנו מודדים.
קודם כל נחשב את הזרם האמור להופיע ברב המודד, נחשב לפי חוק אוהם: מתח = זרם כפול התנגדות.
5/220 = 0.022 אמפר . נכפיל ב 1000 כדי להמיר למיליאמפר – 22 מיליאמפר.
אתם יכולים לנסות להחליף את נגד ה220 אוהם בנגדים אחרים לחשב ולבדוק את כמות הזרם במעגל החשמלי. ניתן גם לספק מתח של 3.3 וולט מהארדואינו ולבדוק את מידת הזרם עם נגדים שונים.
קריאה של נגדים
ניתן לקרוא את הערך של נגד בשתי צורות – ע”י מדידת התנגדות ברב מודד או על פי פסי הצבע המצוירים עליו.
משמאל לימין קוראים את שלושת(לפעמים ארבעת) הפסים הצמודים. שתי הפסים הראשונים מסמלים שתי מספרים והפס השלישי הוא תוספת של אפסים. הפס האחרון שהוא בצבע זהב או כסף מסמל את אחוז הסטייה של הנגד.
לדוגמה נגד של 330 אוהם אמור להיראות כך: שני פסים כתומים שמסמלים 33 ופס חום שמסמל הכפלה בעשר. 33 כפול 10 שווה 330.
בערכה ישנם נגדים מסוג שונה של 5 פסים. הדרך לקרוא אותם היא להתחיל מצד שמאל בפס הדק ביותר. שלושת הפסים הראשונים משמאל הם המספרים, הרביעי הוא המכפיל והחמישי שהוא העבה יותר הוא אחוז הסטייה.
ענף האלקטרוניקה הוא רחב ובספר זה נתעסק רק בבסיס שלו. ישנו עקרון אחד חשוב שנתעסק בו בחלק ב’ והוא העיקרון של חיבור רכיבים בטור או במקביל. האלקטרונים במעגל מתנהגים בצורה שונה כשרכיבים נמצאים אחד אחרי השני או אחד במקביל לשני.
את נורת הלד חיברנו קודם בטור עם הנגד ובחיבור בטור המתח מתחלק בין הרכיבים והזרם שווה בכל המעגל.
לעומת זאת בחיבור במקביל המתח שווה בכל המעגל והזרם מתחלק בין הרכיבים.
גם חישוב ההתנגדות משתנה בין חיבור טורי למקביל – נגדים שנמצאים אחד אחרי השני מוסיפים התנגדות לדוגמה שני נגדים של 220 אוהם יתנו לנו התנגדות של 440 אוהם.
בחיבור במקביל לעומת זאת שני הנגדים יפחיתו את ההתנגדות הכללית והיא תהיה 110 אוהם.
עוד על חיבור בטור ובמקביל:
עוד נושא חשוב באלקטרוניקה הוא הרכיבים קבל, דיודה, טרנזיסטור וסליל וגם בהם נתעסק בחלק ב’ כשיהיה צורך בכך.
כדי ללמוד עוד על אלקטרוניקה אפשר לקרוא את מדריך אלקטרוניקה למתחילים.
נורת לד RGB
לנורה זו יש ארבעה פינים:
הפין הארוך נקרא common והוא אמור להתחבר ל- GND בשונה מבנורת לד רגילה. שאר הפינים מייצגים את שלושת צבעי הבסיס אדום, ירוק וכחול.
קודם כל נחבר את המעגל – נכניס את הפינים לאזור מסוים במטריצה, חשוב לזכור איפה הפין הארוך! בתמונה הוא השני מימין.
עכשיו נחבר חוט שחור מאחד החורים שבאותו הטור של הפין הארוך ונחבר אותו לשקע ה GND בארדואינו.
נחבר נגד 220 אוהם מהפין הימני לטור המקביל, ומהטור שלו נחבר חוט אדום לפין הדיגיטלי 7.
עכשיו נדליק את הנורה…שימו לב שהנגד נמצא בין הפין הימני בנורה לבין הפין בארדואינו. אם תדליקו את הנורה לזמן ממושך ללא נגד היא תשרף!!!
void setup() {
pinMode(7, OUTPUT);
}
void loop() {
digitalWrite(7, HIGH);
}
הנורה נדלקה בצבע אדום. עכשיו נחבר את הרגל השמאלית של הנגד לפין השמאלי ביותר בנורה:
האור הפך לכחול…נעביר את הרגל השמאלית של הנגד שקע אחד ימינה – האור הפך לירוק.
עכשיו הגיע הזמן לשלב בין הצבעים. חברו שלושה נגדים משלושת הפינים של הצבעים לטורים התחתונים. מהשקעים נמצאים באותו הטור של הנגדים משכו שלושה חוטים לפינים 9 10 ו- 11 בארדואינו:
שילוב של צבעים שונים
עכשיו אפשר לקבל איזה צבע שרוצים ע”י שילוב של הצבעים:
סגול –
void setup() {
pinMode(9, OUTPUT);
pinMode(11, OUTPUT);
}
void loop() {
digitalWrite(9, HIGH);
digitalWrite(11, HIGH);
}
צהוב –
void setup(){
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
}
void loop() {
analogWrite(9,20);
analogWrite(10, 255);
analogWrite(11, 255);
}
אפשר להעזר בטבלת ה- RGB לבחור את הצבע האהוב עליכם –
קבלת קלט מכפתורים ופוטנציומטר
פוטנציומטר
פוטנציומטר הוא נגד משתנה ועל פי כיוון הסיבוב שלו תקבע ההתנגדות לזרם, כך שניתן להשפיע על ההתנגדות לפי הסיבוב. דוגמה לפוטנציומטר הוא מד ווליום שנמצא במערכת סטריאו.
פוטנציומטרים באים בהרבה גדלים סוגים וערכים וחשוב לשים לב מהו ערך ההתנגדות שלו. לדוגמה פוטנציומטר של 10kOhm ישנה את ההתנגדות שלו בין 0-10000 Ohm.
חשוב להסביר מהו ההבדל בין אותות אנלוגיים לדיגיטליים. אותות אנלוגיים הם אינסופיים והם ברירת המחדל של הטבע. אותות אלה שאנחנו קולטים מהטבע לדוגמה בעזרת חיישנים (פוטנציומטר הוא חיישן) אנחנו מנסים להמיר לערכים דיגיטליים.
לדוגמה טמפרטורה היא ערך אינסופי – אפילו אם ננסה לדייק ולומר שהיא 36.6666 תמיד יהיו עוד ערכים אחרי הנקודה. ערכים דיגיטליים לעומת זאת עובדים בצורה בינארית – 0 או 1 . השפה שמחשבים מבינים היא חשמל – האם יש זרם או אין זרם?
כדי להמיר ערכים אנלוגיים לערכים דיגיטליים שהארדואינו יוכל להבין אנחנו משתמשים בממיר אנלוגי/דיגיטלי(ADC). הקלט האנלוגי שמגיע מהפוטנציומטר או מהחיישן אל עבר הפינים האנלוגיים של הארדואינו(A0-A5) מגיע בצורה של זרם או מתח ויש לו אינסוף ערכים.
הארדואינו ממיר את הערך האנלוגי לערך דיגיטלי ע”י ממיר של 10 ביט… 2 בחזקת 10 זה 1024 כך שמתוך אינסוף ערכים שהפין האנלוגי מקבל הוא צריך ליצור איזה שהן מדרגות שנעות מ- 0 ל- 1023 כשכל מדרגה היא בערך 0.005 וולט.
ככל שממיר יהיה בעל יותר ביט רמת הדיוק שלו תעלה. אם לדוגמה נעבוד עם ממיר אנלוגי-דיגיטלי של 11 ביט רמת הרזולוציה תהיה 0-2048.
הגיע הזמן לחבר את הפוטנציומטר בתמונה.
יש לו שלוש רגליים – השמאלית והימנית(לא משנה איזה) הולכות ל- GND ו- 5 וולט. האמצעית הולכת לאחד הפינים האנלוגיים(A0-A5) . במקרה זה נחבר את הרגל האמצעית ל- A0. את נורת הלד נחבר לפין דיגיטלי מספר 9.
יש עוד בעיה אחת שאנחנו צריכים לפתור – הכניסה האנלוגיות מפיקה ערכים מ- 0 עד 1024 בעוד היציאה האנלוגית מ- 0 עד 255. ישנה פונקציה מובנית בארדואינו שפותרת בעיה זו ונקראת map.
היא מקבלת 5 ערכים שמופרדים בפסיקים – הראשון הוא הערך המתקבל, השני והשלישי הם הטווח המתקבל והרביעי והחמישי הן הטווח הרצוי. אנחנו רוצים להמיר מטווח של 0-1023 לטווח של 0-255. הנה הקוד:
void setup() {
pinMode(9, OUTPUT);// set led pin to output
pinMode(A0, INPUT); // set analog pin A0 to input
}
void loop() { // take the value from A0 and map it from 0-1023 to 0-255
analogWrite(9, map(analogRead(A0), 0, 1023, 0, 255));
}
אנחנו למעשה שולחים לרגל 9 את הערך שמתקבל מהפוטנציומטר – שינוי בהתנגדות הפוטנציומטר הופך לשינוי בערך שאנחנו שולחים לרגל 9 ומשם לנורת הלד.
קלט מכפתור
כפתור מפסק הוא אחד הרכיבים השימושיים ביותר במעגל חשמלי. הוא בנוי בצורה מכנית כך שאנחנו לוחצים עליו הוא סוגר מעגל ועובר בו זרם.
הדוגמה הפשוטה ביותר להפעלת כפתור היא הדלקה וכיבוי של נורה. אנחנו רוצים לחבר את הכפתור לפין בארדואינו שאותו נכין להיות קלט, וברגע שמתקבל קלט אנחנו רוצים לספק מתח לנורה ע”י פין אחר שנקבע כפלט. לכפתור יש 2 זוגות של יציאות – אחת מהן צריכה להיות מחוברת למתח קבוע של 5 או 3.3 וולט והשנייה לפין הקלט.
ברגע שלוחצים על הכפתור עובר דרכו זרם לארדואינו והוא מיד מפעיל את הפין של הנורה, אבל חיבור זה אינו מספיק. תחשבו מה קורה כשאנחנו לא לוחצים על הכפתור – הוא אינו מחובר לשום דבר ונמצא במצב “ציפה”.
אנחנו רוצים לקבוע ברירת מחדל לכפתור ע”י חיבור נגד ל- GND. שיטה זו נקראת PULL DOWN כי אנחנו מושכים את הכפתור למטה ל- GND. נגד פופולרי להשתמש כ- PULL DOWN RESISTOR הוא 10K.
בדוגמה זו נקבע את פין הקלט של הכפתור ל- 10, ואת פין הפלט של הנורה ל- 11.
שרטוט מעגלים
כשמעגלים חשמליים הופכים להיות קצת יותר מסובכים אנחנו יוצרים שרטוט או דיאגרמה שלהם כדי שהחיבורים יהיו יותר מובנים. תוכנה אחת שיכולה לעשות זאת היא fritzing והיא תוכנה מצוינת ליצור מעגלים פשוטים:
ישנה דרך יותר אלגנטית גם לחבר וגם לשרטט את המעגל. זוכרים איך מטריצה עובדת? יש שתי שורות למעלה ושתי שורות למטה שיכולות לספק פלוס ומינוס לכל השורה.
הנה שרטוט יותר אלגנטי של אותו מעגל. נסו לחבר את המעגל ע”י שתי השורות התחתונות. כעת יש לנו עשרות כניסות של פלוס ומינוס, ואת החיבורים של הרכיבים אפשר לחבר עם חוטים קצרים יותר:
נכניס את הקוד הבא:
int button = 10; // create variable with name button and number 10
int led = 11; // create variable with name led and value 11
void setup() {
pinMode(button, INPUT); // set button pin to input
pinMode(led, OUTPUT); // set led pin to output
}
void loop() {
if(digitalRead(button) == HIGH){ // if we press the button
digitalWrite(led, HIGH); // turn on led
}
else{ // if we don't press the button
digitalWrite(led, LOW); //turn led off
}
}
משתנים והתניות
זה המקום להסביר מהם משתנים והתניות. כבר דיברנו על משתנים כשיצרנו לולאה אבל שווה לדבר עליהם שוב בגלל החשיבות שלהם. כדי ליצור משתנה אנחנו משתמשים בסימן = . לדוגמה:
int x = 1
int x = 4
int y =6
int z = x + y
השאלה היא כמה שווה z? והתשובה היא 10. הקוד בארדואינו רץ בצורה סדרתית מלמעלה למטה, והערך של x התעדכן בזיכרון מ- 1 ל- 4.
עוד דבר חשוב לגבי משתנים הוא איפה הם נמצאים בסקיצה כי משתנה יכול להיות גלובלי או מקומי לפי המיקום שלו.
משתנה גלובלי נמצא מחוץ לפונקציות ולכל הפונקציות יש גישה אליו – הן יכולות לראות וגם לשנות אותו. משתנים שנמצאים בתוך פונקציה הם מקומיים ורק לקוד בתוך הפונקציה יש גישה אליהם.
בקוד למעלה של הדלקת כפתור יצרנו משתנים גלובליים כי אנחנו רוצים שלכל הפונקציות תהיה גישה אליהם.
התניות הן הרעיון הכי חשוב בתחום התוכנה והן בסיס הלוגיקה של התוכנה. באמצעות לוגיקה פשוטה זו ניתן ליצור כמעט כל דבר אפשרי בתכנות והן מה שהופך את התוכנה לכלי רב עצמה.
תוכנה באתרי אינטרנט, מטוסים, רובוטים ואפילו אינטליגנציה מלאכותית מבוססת על רעיון זה.
בדרך כלל בתוך ההתניות אנחנו בודקים השוואה כלשהי ואת זה עושים ע”י ==. עוד השוואות חשובות הם:
=! לא שווה
< גדול ממספר > קטן ממספר
<= קטן או שווה למספר
אפשר לקרוא עוד על התניות באתר ארדואינו:
בקוד שכתבנו ברגע שאנחנו לוחצים על הכפתור הנורה נדלקת וברגע שעוזבים אותו היא נכבית. אבל בהרבה מאוד מקרים אנחנו רוצים ללחוץ פעם אחת על הכפתור ולשנות את מצבו.
כדי לעשות זאת צריך לשנות קצת את הקוד: אנחנו רוצים לקבוע משתנה גלובלי שנע בין הערכים true ו- false לפי הלחיצה על הכפתור. משתנה זה הוא מסוג boolean מה שאומר שהוא יכול להיות אמת או שקר.
כל פעם שלוחצים על הכפתור המשתנה משנה את מצבו. דבר זה נקרא toggle או שינוי מצב. לא אכפת לנו מה היה המצב הקודם כל מה שאנחנו מעוניינים הוא שהמשתנה יהפוך מצב. את היפוך המצב אנחנו מבצעים ע”י סימן קריאה ! שהופך true ל- false ולהפך.
boolean button_state = false; // create boolean(true or false) variable void setup() { pinMode(11, OUTPUT); // pin 11(led) is going to be output pinMode(10, INPUT); // pin 10(button) is going to be input } void loop() { if(digitalRead(10) == HIGH){ // if we press the button delay(200); // wait a little... primitive way to debounce a button button_state = !button_state; // toggle the state of the boolean variable } if (button_state == true){ // check the variable digitalWrite(11, HIGH); // turn on led } else{ digitalWrite(11, LOW); } }
הנגד שחיברנו ל-GND היה רק להדגמה, יש ברגליים הדיגיטליות של ארדואינו נגדים מובנים ואפשר להפעיל אותם על ידי השורה :
pinMode(10, INPUT_PULLUP);
זה מעלה את פין 10 אל 5V ואז הוא HIGH כברירת המחדל. אם נחבר עכשיו את הרגל השנייה של הכפתור ל-GND נוכל לדעת מתי התבצעה הלחיצה ובכך להפטר מהנגד. עם זאת נצטרך לשנות את הקוד בהתאם:
if(digitalRead(10) == HIGH){ // if we press the button
השורה הזאת כבר לא רלוונטית ונצטרך לשנות אותה לשורה הבאה:
if(digitalRead(10) == LOW){ // if we press the button
תקשורת טורית דרך ה-USB
תקשורת בין הארדואינו למחשב
לכבל ה- USB שמחובר מהמחשב לארדואינו ישנם שתי תפקידים – העברת מתח מהמחשב לארדואינו, במקרה שלנו 5 וולט, והתפקיד השני הוא העברת מידע.
בכל פעם שאנחנו מעלים סקיצה הנתונים עוברים מהמחשב לארדואינו ואפשר גם להעביר מידע בצורה הפוכה – מהארדואינו למחשב. קודם כל בואו נראה איך נתונים עוברים בזמן אמת מהארדואינו למחשב.
הפונקציות שנשתמש בהן בסקיצה זו הן ()Serial.begin – פונקציה המתחילה תקשורת סיריאלית למחשב ומקבלת ערך של קצב העברת סיביות בשנייה במקרה שלנו 9600.
והפונקציה () Serial.println – מדפיסה שורה מהארדואינו לחלון התקשורת הטורית. חברו את הרגל השמאלית של הפוטנציומטר ל- GND ואת הימנית ל- 5 וולט בארדואינו. חברו את הרגל האמצעית לשקע A0.
הכניסו שמרו והעלו את הקוד:
void setup() {
pinMode(A0,INPUT);
Serial.begin(9600);
}
void loop() {
Serial.println(analogRead(A0));
delay(100);
}
עכשיו לחצו על הלחצן בצורת זכוכית מגדלת שנמצא בצד הימני העליון – הוא פותח את חלון התקשורת הטורית. סובבו את הפוטנציומטר ושימו לב איך הערכים משתנים מ- 0 ל- 1023.
תקשורת בכיוון ההפוך
עכשיו ננסה לתקשר בדרך הפוכה – מהמחשב לארדואינו. חברו את הרגל הארוכה של הנורה לשקע 9 בארדואינו(דרך נגד כמובן) ואת הקצרה ל- GND. הכניסו את הקוד הבא:
char data;
int led = 9;
void setup() {
Serial.begin(9600); // start serial communication
pinMode(led, OUTPUT); // set pin 9 to output
}
void loop() {
if(Serial.available() > 0){ // check if we get any data
data = Serial.read(); //update the variable data with the //value we get
}
if(data == '1'){ // if its 1
digitalWrite(led, HIGH); // turn led on
} else if(data == '0'){ // if its 0
digitalWrite(led, LOW); // turn led off
} // end else if
} //end loop
עכשיו פתחו את חלון התקשורת הטורית, הכניסו את הספרה 1 לשורה העליונה בחלון ולחצו send. הנורה אמורה להידלק. הכניסו את הספרה 0 והנורה אמורה להיכבות.
בואו ננסה להבין מה קורה פה.
תוכנת הארדואינו שנמצאת על המחשב שלנו שולחת ערך אחד של מידע(בייט) לפתחה המחוברת אל הארדואינו. הארדואינו מקבל את הערך בצורה הבאה:
- אנחנו יוצרים משתנה שנקרא data מסוג char. Char זה תו וזוהי הדרך לקבל מידע מתקשורת טורית. אם נרצה לקבל מספר (int) נצטרך לבצע המרה.
- הארדואינו בודק ברציפות האם התקבל תו על ידי הפונקציה () serial.available . זוהי פונקציה שמחזירה את מספר התווים בזכרון הזמני של הפתחה.
- אם הוא גדול מ- 0 אנחנו מחלצים אותו מהזיכרון הזמני ומשימים אותו למשתנה data. הוא אוטומטית נמחק מהזיכרון של הפתחה(buffer).
- כל מה שנותר כעת זה להשוות אותו ל- 0 או 1.
אוגר הזזה
אחד המעגלים המשולבים הזולים והשימושיים ביותר הוא אוגר הזזה(shift register). שבב זה נותן לנו להרחיב את מספר הפינים הדיגיטליים בארדואינו כך שבאמצעות שלושה פינים בלבד אנחנו יכולים לקבל 8 יציאות דיגיטליות. זאת גם הזדמנות מצוינת ללמוד על מעגלים משולבים ואיך להפעיל אותם.
כשהתחלתי עם ארדואינו לא האמנתי שייגמרו לי הפינים אבל ככל שעושים יותר פרוייקטים מגלים פתאום שיש מחסור בפינים. הרבה אנשים קופצים ישר לקנות ארדואינו מגה שיש לו 54 פינים אבל הוא יקר וגדול יותר. בהרבה מקרים כשמשתמשים במגיני הרחבה אז נשארים לנו רק כמה פינים פנויים לכן במקרה הזה אוגר הזזה הוא אידיאלי.
השבב שנעבוד איתו הוא SN74HC595N שמקבל 8 ביט נתונים בטור ומוציא אותם במקביל ועל ידי כך נוצרים לנו שמונה ערוצים חדשים להפעלה.
יש שבב אחר שעושה את הפעולה ההפוכה ונותן לנו להרחיב את מספר רגלי הקלט (INPUT ) ל- 8, אבל פה נתעסק בהרחבת רגלי הפלט.
מה שנחמד בשבב הזה הוא שאפשר לשרשר כמה כאלה כדי ליצור עשרות של פינים דיגיטליים לשימוש.
עכשיו נעבור על החיבורים שלו:
QA-QH הם היציאות אותן אפשר לחבר לנורות מנועים וכו’
VCC כמובן הולך ל- 5V בארדואינו
GND כמובן הולך לאדמה בארדואינו
SER /DATA הוא הפין איתו אנחנו שולחים את הביטים מהארדואינו נחבר לפין 3 בארדואינו
SRCLK / CLOCK הוא תזמון השעון בו גם נשלוט מהארדואינו נחבר לפין 4 בארדואינו
RCLK / LATCH הוא הפין שבפועל שולח את הביטים אל השבב כשהם מוכנים נחבר לפין 2 בארדואינו
OE הוא פין המאפשר פלט ואותו נחבר לאדמה. אם רוצים לדוגמה לכבות ולהדליק את כל הפינים בבת אחת אז אפשר לחבר אותו לפין שליטה בארדואינו
SRCLR מוחק את הביטים מהזכרון כשמורידים אותו לאדמה אבל פה אנחנו לא צריכים את זה אז נעלה אותו ל- HIGH
ככה המעגל הבסיסי צריך להראות:
עכשיו יש לנו 7 יציאות חדשות למטה ועוד אחת למעלה בפין השני משמאל(QA). כל מה שנשאר זה לכתוב את הקוד שמפעיל ומכבה את היציאות שאנחנו רוצים. בואו נפעיל את QB:
void setup() {
pinMode(2, OUTPUT); // RCLK or LATCH
pinMode(3, OUTPUT); // SER or DATA
pinMode(4, OUTPUT); // SRCLK or CLOCK
digitalWrite(2, LOW); // turn off shift
shiftOut(3, 4, LSBFIRST, B01000000); //Shift bits from left to right
digitalWrite(2, HIGH); //Latch high - commit to shift
}
void loop() {
}
הפונקציה shiftOut מקבלת 4 ערכים – פין DATA , פין שעון, האם לשלוח את הביטים משמאל לימין או מימין לשמאל ובמקרה שלנו זה משמאל לימין(LSBFIRST) אם היינו רוצים לקרוא מימין לשמאל היינו מכניסים MSBFIRST.
הפרמטר האחרון בפונקציה הוא הביטים שאנחנו שולחים ופה אנחנו קובעים איזה פינים בשבב אנחנו מדליקים ומכבים. את זרם הביטים אנחנו מתחילים עם האות B שאומרת לארדואינו שמדובר בביטים ולא במספרים.
עכשיו אם רוצים לדוגמה לכבות ולהדליק את הפין הזה אפשר לכתוב את הקוד הבא:
void setup() {
pinMode(2, OUTPUT); // RCLK or LATCH
pinMode(3, OUTPUT); // SER or DATA
pinMode(4, OUTPUT); // SRCLK or CLOCK
}
void loop() {
digitalWrite(2, LOW); // turn off shift
shiftOut(3, 4, LSBFIRST, B01000000); //Shift bits from left to right
digitalWrite(2, HIGH); //Latch high - commit to shift
delay(1000);
digitalWrite(2, LOW);
shiftOut(3, 4, LSBFIRST, B00000000);
digitalWrite(2, HIGH);
delay(1000);
}
שלושת הפינים של השליטה 2,3,4 הם שרירותיים ואפשר לבחור בשלושה פינים אחרים.
כדי לשרשר כמה שבבי הזזה כל מה שצריך לעשות זה לחבר את פין ‘QH (שימו לב לגרש העליון) אל פין DATA של השבב השני וגם את LATCH ו- CLOCK בין השבבים.
כך נוצר לנו אוגר הזזה של 16 ביט ועל הפעולה הזו אפשר לחזור עם הרבה שבבים רק צריך לשים לב שיש לנו מקור כח שיכול לספק מספיק זרם.
שליטה במספר נורות
עכשיו הגיע הזמן להשתמש ב-8 נורות ונגדים שיש בערכה ואוגר הזזה הוא מצויין לשימוש הזה.
קודם כל צריך להזכיר שלארדואינו יש מגבלה של זרם שהוא יכול לספק גם מכל פין ספציפי(20mA) וגם מהבקר עצמו(200mA) כך שלהדליק 10 נורות מ-10 פינים בארדואינו זה פחות או יותר המקסימום שהוא יכול.
ישנה טכניקה שנקראית charlieplexing שנותנת להדליק מספר רב של נורות אבל לא נכנס אליה פה. רמז: הן לא דולקות ביחד אלא במרווחים של כמה מילישניות, אי אפשר לעבור על חוקי הפיזיקה.
בכל מקרה אוגר הזזה הוא מקור כח נפרד מהבקר של ארדואינו ויכול להפעיל 8 נורות בקלות.
את כל היציאות של אוגר ההזזה נחבר ל-8 נורות לד דרך נגדים ל-GND. ואז נכתוב קוד שמפעיל את הנורות אחת אחרי השניה כל חצי שניה.
ועכשיו נכתוב את הקוד:
int latchPin = 2;
int clockPin = 4;
int dataPin = 3;
byte leds = 0;
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
leds = 0;
updateShiftRegister(); // refresh and update the shift register
delay(500); // change to 100 for quick switching
for (int i = 0; i < 8; i++){ // loop on all bits
bitSet(leds, i); // arduino function to set bit on or off
updateShiftRegister();
delay(500); // change to 100 for quick switching
}
}
void updateShiftRegister(){
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, leds);
digitalWrite(latchPin, HIGH);
}
בשביל אפקט מרשים יותר אפשר להוריד את ההשהייה ל-100 מילישניות ולקבל אפקט מהיר כמו בנורות של שילוט חוצות.
אפשר לרכוש את הספר המלא כאן
כל הזכויות שמורות להאקסטור – 2016
מדהים מדהים מדהים אולי המדריך הכי טוב שקראתי עד היום.
הסדר הפירוט וההסבר פשוט מצוינים.
תודה רבה.
תודה.
וואו!! איזה כיף שאתם מרפגנים לנו את המדריך המעולה הזה, תודה!
סוף סוף מדריך טוב!!!
כן זה מדריך נחמד כתבו אותו כמה אנשים ואני ערכתי, יש עוד הרבה מקום לתיקונים והוספות. זה ספר פתוח אם מישהו רוצה להוסיף דברים אז אפשר חסרים פרקים על אלקטרוניקה , תקשורת רדיו , בלוטות’ ועוד הרבה נושאים .
מדריך מעולה למתחילים
כל הכבוד על ההשקעה!
תודה רבה על המדריך! נהניתי לקרוא וללמוד.
הכי טוב, מסודר, מקצועי ומדהים שראיתי!
תודה לכל המגיבים
מדריך מעולה ללא ספק! פשוט תענוג.
המדריך מאוד עזר לי, תודה רבה.
אם אפשר להוסיף הסבר על נושא הנגדים זה יהיה מצויין, לא ממש הבנתי מתיי אני אמור להשתמש בהם(חוץ מהלדים שלא ישרפו)
תודה על התגובה. בנגדים משתמשים כמעט בכל פרק לפעמים כדי להוריד כפתור לאדמה למנוע “ציפה” ולפעמים כמחלק מתח עם חיישן אור. הקטע בארדואינו זה שהרבה מודולים וחיישנים שלו מגיעים כבר עם נגדים מובנים אז אין צורך, אבל בגדול אין כמעט מעגל אלקטרוני ללא נגדים.
שלום, תודה על ההסבר הברור כלכך!
אני עושה פרוייקט באלקטרוניקה שכולל תצוגת 7 מקטעים ואני משתמשת במפתח PORT D. זה עובד מצויין אבל משום מה המקטעים a ו b נדלקים גם כאשר אני שולחת להם 0 לוגי. חשוב לציין שאני מקפידה להוציא לפני הצריבה לארדואינו את ההדקים האלו כדי לא להשפיע על התקשורת הטורית. אשמח מאוד לשמוע אם יש משהו שאני יכולה לעשות בנידון.
תודה מראש!
שלום.
קשה לומר בלי לראות קוד וחיבורים, יכול להיות שיש איזו שורה בהמשך שמדליקה אותם מחדש.
בדוגמה בספר הם מחוברים לפינים 2 ו-3 בארדואינו כך שאם לא מדליקים את הפינים הם לא אמורים לעבוד.
דרך אגב לדעתי אין צורך להוציא הדקים לפני הצריבה שכן אף אחד לא מחובר ל-0(rx) או 1(tx) .
בתכנית הספציפית שלי אני חייבת להשתמש ב rx ו tx בגלל שאני משתמשת בport d וזה רק על הדקים 0-7 אז אין לי ברירה. אני רוצה ׳לחסוך׳ בהדקים וגם לא לעשות תכנית של מערכים אם הדרך של port זה כל כך קצר..
הקוד שכתבתי הוא גם לא ישיר לתצוגה, זה על פי לחצנים: יש 4 לחצנים ואם כולם לא לחוצים התצוגה מראה את הספרה 4 אם 1 לחוץ ו3 לא אז היא מראה 3.. וזה עובד ממש יפה חוץ מההדקים הללו שמוסיפים תאורה בזמן הלא נכון….
או קיי עכשיו הבנתי. את מדפיסה למסך במקרה בקוד? serial.print ?
זה נורא מוזר כי כשאני עושה תכנית קצרה להפעיל את אותה פקודה שמפעילה ספרה 4 לדוג זה לא מפעיל את a והעתקתי בדיוק מהתכנית לתכנית ארדואינו חדשה):
כן אני עושה serial
תורידי מהקוד את serial.begin וגם serial.print כי אי אפשר גם תקשורת טורית וגם שימוש בפינים 0 ו-1.
יש!!!
הצלת אותי, אני כבר חודשים בלימודים רק על הדבר הזה ומחכה לי עוד מסך מגע וחיישנים.. המורות לא ידעו לעזור לי, אין לי מילים!
יהיה אפשר להתייעץ כאן אם אתקע בעניין נוסף, או שזה מטריח מידי?
בטח אפשר להתייעץ בכל שעה 🙂
תודה רבה!!!!!
איך משפט אחד יכול להפוך לי את המצב רוח(;
איזה יופי של מדריך – תודה רבה !!!!
מלך!!
תודה על ההשקעה!
בקוד שמתעסק עם חיישן טמפרטורה ולחות דיגיטלי צריל להוסיף את ספריית Adafruit_Sensor בשביל שיפעל.
השורה include DHT.h מוסיפה את הספריה ויש גם הסבר איך להתקין אותה מסביבת הפיתוח לא? או שאני לא מבין אותך כי אצלי זה עובד.
מדריך מעולה!!
אני לא מתחום האלקטרוניקה .. ובא לי לעשות משהו נחמד דקך הארדוניו.. איך אני יכולה להשתמש בפקודות קוליות שיתורגמו לפעולות? למשל להדליק נורה דקך פקודה קולית ?
תודה 🙂
המדריך הכי טוב שקראתי ( למרות שקראתי רק אחד)
ואאאאוווו!!!!! פשוט אין לי מילים אני חולה על כל הנושא של אלקטרוניקה וארדואינו ואני תמיד מנסה לחפש כל מיני מדריכים ביוטיוב ובגוגל ואין צל של ספק שזה המדריך הכי טוב שקראתי מאז ומעולם פשוט מדהייייםם תודה רבה לך המדריך הזה עזר לי בצורה הכי טובה שיש תודה תודה תודה!!!!!!!!!!!!!!!!!!
מדריך מעולה!
מדריך מעולה. תודה רבה!
תודה רבה לכל אלו שיש להם חלק בעניין, תמשיכו בעבודתכם, אתם לעזר רב לכל חובבי התחום.
🙂
שלום
רציתי לשאול המטריצת לדים שיש לי לא באה עם הגבר הזה מאחוריה היא באה לבד ומאחורה ישלה כמה חיבורים מישני הצדדים ואני מאוד רוצה להפעיל אותה תוכל להסביר לי איך לחבר אותה בלי הגבר הזה מאחורה?
בתודה מראש תלמיד:)
לדעתי אפשר עם אוגר הזזה (SHIFT REGISTER) וצריך גם בנוסף 8 נגדים:
http://www.circuitstoday.com/interfacing-8×8-led-matrix-with-arduino
אתחיל בזאת : אני חייב לציין את המדריך המעולה ואת העזרה שאתה נותן וכמובן את התגובות החמות אני שמח שהגיע לבלוג כל הכבוד !!
אני כרגע נמצא בשלבים הראשונים של הפרוייקט ואני נמצא מול אתגר של חיבור 24 LED מסוג : RGB LED Bead IC Built-IN APA106
כאשר אני רוצה לשלוט על כל אחד בנפרד כולל עוצמת אור וצבע ויכולת להפעיל אחד אחד ,קבוצה קבוצה או כולם !!
ו12 מנועי Stepper moror Bipolar , שעליהם אני צריך לשלוט בגיוון ובמהירות .
ואני רוצה לחברם לUno Arduino.
להלן מספר דברים שאני למדתי :
1. אני חייב ספק כח נפרד לטובת כל הכמודת של הרכיבים .
2. אני חייב L298N Dual Motor Controller Modules and Arduino או דומה כדי לחבר כל מנוע
מפה אני קצת מבולבל ..חח ואשמח לקבל הכוונה
אני חושב על Multiplexing אני מבין שעדיף להשתמש ב- SPI ולא I2C כי הוא יותר מהיר ואפשר לתת מספר פקודות במגביל .
אני חושב שלגבי הלדים יש פתרון מובנה IC Built-IN שיכול לקבל פולס דיגיטאלי ולשנות את עוצמות האור .(האם אני צודק ? )
אין לי כרגע פתרון לגבי המנוע !
אשמח לעזרה
מצטער על אורך הפוסט ניסיתי להיות כמה שיותר מדוייק ולתת רקע לפני השאלות .
תודה מראש על תשובתכם .
שלום. הרעיון בנורות נאו-פיקסל הוא שאפשר לשרשר אותן ולשלוט בכולם דרך פרוטוקול I2C כך שהן דורשות רק שתי יציאות. יש המון קוד ברשת למרות ששלך לא בדיוק מקוריות זה עובד עם אותו שבב WS2812 . הייתי ממליץ על נאו-פיקסל מקורי כמו https://www.adafruit.com/product/1734 כדי להמנע מבלבול והעלאת נורות בעשן, בקרוב הם יהיו פה בחנות.
לגבי מנועי צעד אתה צריך 48 יציאות – 4*12 . אפשר עם ארדואינו מגה זה הכי פשוט, כמובן אפשר גם עם אונו להרחיב את מספר ההדקים אבל זה יותר מסובך.
לגבי ספק כח נפרד אפשר לדעתי 5 אמפר זה מספיק…
היי
ראשית המון תודה 🙂
אני מתלבט לגבי Multiplexing אם הכל עובד על DIGITAL PIN למעט המהירות של המנוע שאפשר לקבע אותה בשורת קןד 1 (וזה בסדר מבחינת הפרוייקט )
האם אפשר לדעתך על אותו מטריצה לשלוט ב-LED ובמנועים ( IN1,IN2,IN3,IN4 ) ?
ואז זה הרבה יותר פשוט ?
אשמח לתשובותכם 🙂
הרבה תודה
אורן
Multiplexing לא חוסך בחיבורים, להיפך הוא רק מוסיף חיבורים. הוא מפחית את החיבורים מארדואינו ומעביר אותם למקום אחר(מרבב/אוגר הזזה) ובנוסף אי אפשר לשלוט ביותר ממנוע אחד באותו הזמן. אתה מוזמן לנסות Multiplexing ולראות אם זה עובד. אפשר גם לשאול את השאלה ב- makers.co.il כי אני בהחלט לא סמכות בתחום.
מקסים !!!
ממש נהדר – אהבתי !
שלום
ברצוני לבנות שעון דיגיטלי ענק (גודל סיפרה כ 1 מטר).
האם יש פרוייקט כזה להציע
הזמנתי את הערכה למתחילים מהאתר ולמדתי דרך המדריך,
פשוט מעולה!
תודה רבה!
מדריך מושקע מאוד .
כול הכבוד על השיתוף והסיוע למי שמעלה שאלות.
היי אני ממש שונא את האתר הזה בגללכם המורה שלי רוצה שאני ישנן את כל האתר בעל פה שונא אותכם !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
אתה לא מתכוון ברצינות. נכון?…
(וברצינות – תגיד תודה גם למדריך המדהים הזה וגם למורה שלך שכיוון אותך לכזה מקום.
מעונין לחבר חיישן מרחק LED RGB. עם הפעלת התכנית יתבצעו המשימות הבאות:
1. הדלקת צבע אדום, כחול, ירוק עם השהיה של שנייה בין הדלקה להדלקה.
2. התכנית תקרא את ערכי הגובה מהרצפה ותבצע את המשימות הבאות:
כאשר הגובה בין 0 – 40 ס”מ הלדים יהיו כבויים.
כאשר הגובה מהרצפה בין 40-60 ס”מ הלד האדום יידלק
כאשר הגובה מהרצפה בין 60-100 יידלק הלד הירוק
כאשר הגובה מהרצפה מעל 100 ס”מ יידלק הלד הכחול.
מישהו יכול לכתוב לי את התכנית בארדואינו בבקשה. אני זקוק לזה להשואה..
שלום. תתחיל בלכתוב פונקציה שמכבה את כל הלדים. ואז תכתוב את ההתניות:
אם המרחק קטן מ40 כבה את כל הלדים.
אחרת אם המרחק גדול מ40 אך קטן מ60 כבה את כל הלדים ותדליק אדום.
אחרת אם המרחק גדול מ60 וקטן מ100 כבה לדים ותדליק ירוק
אחרת כבה לדים ותדליק כחול
היי אני ממש בתחילת המדריך, כתוב ללחוץ על כלים ואז על פתחה COM3, אני לא מוצא אופציית פתחה בכלים.
קנית את הארדואינו אצלנו בחנות?
יכול להיות שזה בגלל שלא חיברתי את הארדואינו?
כן. צריך לחבר את הארדואינו למחשב כדי שהוא יזהה אותו.
סבבה תודה (:
מה ההבדל אם אני קונה מאיביי?
קניתי מאיביי ואחכ הכרתי את האתר הזה וקיבלתי ארדואינו עם חלק כזה מעל שצמוד לארדואינו
אתה יכול להסביר איזה חלק בדיוק? כזה שמרכיבים על הארדואינו?
לא הוא בא מובנה
הוא פחות או יותר בגודל של הארדואינו
תנסה לשלוף אותו החוצה אם הוא יוצא אז זה מגן הרחבה. אם לא אז אני לא יודע צריך לראות תמונה
כן.. חשבתי שזה מולחם. אבל למה בתוכנה לא רואים שהוא מחובר?
אין קשר לתוכנה מגן הרחבה מחובר ברמה של החומרה
מזה אומר? כתוב infiduino r3
זה שם שנתנו לארדואינו אין הבדל משמעותי. חלאס שאלות תתחיל להנות
🙂 טנקס
תודה על ההסברים המפורטים, חבל שגולשים אחרים לא מפרגנים למדריך כמעט בלעדי בעברית.
אנשים מפרגנים כל הזמן 🙂
תודה רבה על המדריכים! מושקעים, מקיפים וקלים להבנה גם לאנשים שמגיעים בלי רקע באלקטרוניקה וקוד.
מרגישים שהם נכתבו באהבה ולא רק לצאת ידי חובה ולמלא תוכן באתר.
כל הכבוד!
תודה רבה, יש עוד הרבה בדרך.
ואוו.
מדריך מעולה!!
האם יש גם מדריך שלישי ורביעי ?
ממש מהנה לקרוא, הכל לעניין.
כל הכבוד!
תודה רבה. יפורסמו עוד מדריכים בצורה פרופורציונלית לקניית חומרה בחנות אם אתה מבין את הרמז 🙂 אי אפשר רק לבקש צריך גם לתת חזרה
ממש תודה
אם אפשר גם פירוט על שלט רח IR
היי לא הבנתי איך מחליטים איזו נורה תידלק במטריצת לדים? אם אפשר את זה יותר מפורט אשמח, תודה.
אפשר לקרוא כאן:
http://wayoda.github.io/LedControl/pages/software
הפונקציה setled מקבלת 4 ערכים הראשון הוא ID ,השני מספר שורה, השלישי מספר עמודה והרביעי האם להדליק או לכבות.
תודה
האם אפשר לסגור מעגל חשמלי על ידי קורא ברקוד?
השאלה שלי ביתר פירוט היא כזאת:
האם הברקוד המסויים שנקרא ע”י קורא הברקוד יכול לתת פקודה לארדואינו כך שהוא יסגור מעגל חשמלי?
ברקוד זה פסים שחורים על רקע לבן שמייצגים מידע, איך לדעתך דיו של מדפסת יכול לתת פקודה? קורא הברקוד הוא זה שיכול לתת פקודה בהתאם למה שאתה רוצה שהוא יעשה. רוב קוראי הברקוד מתחברים למחשב על ידי USB כי המטרה שלהם היא ניהול מלאי ותוכנת מלאי נמצאת על מחשב.
מזה זמן אני בונה עם הנכד שלי קיטים. החלטתי “לעלות כיתה” ולנסות לגרות את הנכד לטעום מעולם התיכנות והאלקטרוניקה באמצעות ארדואינו. נפלתי על המדריך שלכם כמוצא שלל רב. הוא לא פחות ממדהים. ערוך לוגית ומוביל בהדרגתיות, מפשט נושאים מורכבים, קריא וברור, איורים וצילומים ברורים ומדויקים. כל הכבוד ותודה רבה!
תודה רבה כיף לקרוא תגובות כאלה
לצוות hackstore
קוראים לי אמיר ואני בן 14 והמדריך הזה עזר לי להבין ת כל הדברים האלה ולבנות דברים מדהימים תודה רבה על כל העזרה !!!
WOW , פעם ראשונה שנחשף לארדואינו , מדריך מעולה הגעתי חצי שלו ואני מרגיש שאני מבין . הזמנתי אחד כזה , מחכה שיגיע – שאפו
Thank you very much. God bless you
Suddenly everything seemed clearer
הי בפרוייקט שלי יש חיישני opt3001 מה ההבדל בינהם לבין חיישני LDR?
שאלה:
האם ניתן לשלוח פקודות מהארדואינו למחשב PC? (דרך חיבור ה-USB של הבקר, או דרך מתאם כלשהו)
ז”א – לחבר חיישן X, שברגע שמתבצעת פעולה Y הארדואינו שולח/מבצע פקודה במחשב.
תודה.
שאלה
איך פועלים כדי להתקין תוכנה שמיועדת לארדיינו וירדה בזיפ להורדות .אני מתקשה מה הסדר הנכון
בתיקשורת בכיוון הפוך זה אפשרי לעשות את זה אנלוגי?
שצריך להכניס מספר מ 0 עד 255 וככה לשנות את הזרם שמגיע ללד.
אם כן אשמח שתיכתבו דוגמא
מעולה !
תודה רבה !
כבר שנתים שאני נכנס ומשכיל מהמאמר.
שוב המון תודה על העשיה!!!!
היי אני מעוניינת לחבר לבקר הארדואינו מנוע של מקדחה כלומר מנוע שעובד על מתח של 18 וולט. האם ניתן לחבר זאת לארדואינו? ואם כן כיצד ניתן לעשות זאת ועם אילו רכיבים?
שלום לינוי
כדי לחבר מנוע לארדואינו את צריכה דחיפת זרם מתאימה מאחר וארדואינו מוציא זרם נמוך מאוד
זה אפשרי בשתי אפשרויות
1. לחבר למנוע מקור מתח מספיק להתנעתו והפעלתו הרציפה דרך ממסר שיבוקר ע”י בקר הארדואינו
2. לחבר את המנוע דרך מודול דוחף זרם מתאים ישירות לבקר
ממליץ תמיד להפעיל מנועים דרך ממסר עם מקורות מתח אחרים מזה שהבקר יכול לספק
מגניב
*:p()#?><!@^$%*&*
*
לא הוא בא מובנה
איך אפשר לחבר בלוטוס לארדואינו אונו? יש מדריך או סרטון הדרכה?
תודה רבה
ליאור
ילד בן 13 מתאים לו הרכה כזאת?
דחוף
תלוי בילד. בבי”ס של בני מלמדים רובוטיקה בעזרת ארדואינו מכיתה ז’.
המדריך מעולה. כהנדסאי אלקטרוניקה שהתנסה מעט בארדואינו, חיפשתי מדריך ע”מ לללמד דרכו את בני בן ה-12. וכפי שאמרתי, המדריך הזה הוא בדיוק מה שחיפשתי. אז ישר כח!.
הערה קטנה- בפרק “אלקטרוניקה בסיסית” הינך קורא ל”צרכן”( למשל- נורה) – “מִטְעַן”. לטעמי זו שגיאה, מאחר ומִטְעַן חשמלי הוא תכונה של חלקיקים ונמדד ב”קולון” וסימונו Q, ובטח לא לזה התכוונת.
האם ניתן לכתוב תנאי IF שלא בתוך לולאת LOOP , כדי לא להיתקל מחדש באותו תנאי IF , האם המפסק נלחץ או לא , זה מה שקורה בתוך לולאת IF
משהו בסגנון :
int button_state = digitalRead(button_pin);
if (button_state == HIGH)
{
digitalWrite(led_pin1, HIGH);
digitalWrite(led_pin2, LOW);
delay(delay_value);
digitalWrite(led_pin1, LOW);
digitalWrite(led_pin2, HIGH);
delay(delay_value);
}
else
{
digitalWrite(led_pin1, LOW);
digitalWrite(led_pin2, LOW);
delay_value = 100;
}
}
שה- IF יהיה מחוץ ללולאת ה- LOOP
כל הכבוד, כמה מידע שאני מחפש לא היה משהו כזה מסודר.
142
שלום
אני מצטרף לכל השבחים שנכתבו באמת מדריך מקיף ומצוין
יש לי 2 שאלות :
האם אפשר לכתוב תוכנית בשפת c ב Visual Studio ולהעביר אותה ישירות לארדאינו או שצריך להשתמש רק ב ide הייחודי של הארדואינו ?
אני לומד עכשיו c מההתחלה האם יש איזשהו מסמך שעושה את ההקבלה בין השלבים ב c לבין איך שעושים את זה בארדואינו
כלומר לדוגמא אני לומד עכשיו על משפטי תנאי ולולאות – איך כותבים את זה עבור הארדואינו
פונקציות – כנ”ל
עבודה עם סיביות – כנ”ל
מערכים ,מטריצות – כנ”ל
פוינטרים , מחרוזות , רשימות מקושרות – כנ”ל
כי אני פשוט רוצה ללמוד לכתוב קוד ב c וכל נושא שאני לומד לראות מייד איך מיישמים אותו בכתיבת קוד לארדאינו
אשמח לקבל תשובה ושוב תודה על המדריך המעולה
מדריך מעולה!