במדריך זה אנו לומדים כיצד לבצע תכנות בסיסי של Arduino באמצעות קודי דוגמה ותוכניות לדוגמא. מדריך זה יכול להיות קורס בעל ערך רב לכל המצטרפים החדשים המעוניינים להבין את היסודות באמצעות שפה קלה ומובנת.
מבוא
לפי ויקיפדיה מיקרו-בקר שווה למחשב מיני שנבנה בתוך שבב IC יחיד, עם מעבד ליבה משלו, כניסות ניתנות לתכנות, זיכרון וציוד היקפי לפלט.
מיקרו-בקר הופך להיות כל כך שימושי עבור משתמש מכיוון שהוא מציע מעבד מובנה, זיכרון ויציאות קלט / פלט (הנקראות גם GPIO או סיכות קלט / פלט למטרות כלליות) שאותם אנו יכולים לשלוט על ידי המשתמש בהתאם לכל המפרט הרצוי.
במדריך זה נעבוד עם לוח Arduino Uno ללימוד ובדיקת התוכניות. לצורך בדיקה ושילוב הרכבת חומרה נשתמש בקרש לחם.
עכשיו בואו נעבור במהירות ונלמד כיצד להתחיל עם תכנות Arduino.
1.2 התקנת התוכנה (Windows)
לשם כך תזדקק לגישה לאינטרנט, מה שברור שיהיה לך במחשב שלך. אנא היכנסו לקישור הבא והורידו את תוכנת IDE:
קובץ ZIP של Windows להתקנה שאינה מנהל
לאחר ההורדה תמצא את סמל ההתקנה של Arduino בתיקיית ההורדה, שייראה כך:
לאחר שתקבל את זה, אתה יכול פשוט ללחוץ עליו פעמיים ולהתקין את ה- Arduino סביבת הפיתוח המשולבת (IDE) במחשב שלך. ניתן לדמיין את התהליך השלם בסרטון הבא:
https://youtu.be/x7AMn1paCeU1.4 החל מהמעגל הראשון שלנו
לפני שנתחיל ללמוד את טכניקות התכנות בפועל, עבור כל מתחיל חדש יהיה כדאי להתחיל ברכיב בסיסי כמו נורית LED ולהבין כיצד לחבר אותו לארדואינו.
כידוע נורית LED היא דיודה פולטת אור שיש לה קוטביות ולא תידלק אם היא לא מחוברת עם עמודי האספקה הנכונים.
היבט נוסף עם נוריות LED הוא שהתקנים אלה עובדים עם זרם נמוך ועשויים להיפגע באופן מיידי אם נגדי מחושב כראוי לא נכלל בסדרה עם אחד הפינים שלו.
ככלל אצבע, 330 אוהם 1/4 וואט הוא אידיאלי למדי לכל עלייה של 5 וולט בכניסת האספקה כדי להגביל את הזרם לרמה בטוחה הנדרשת. לכן עבור 5V זה עשוי להיות 330 אוהם, עבור 10V זה עשוי להיות 680 אוהם וכן הלאה.
שימוש בלוח לחם לאסיפה
אנא ודא שאתה יודע להשתמש ב- קרש לחם לפני שניסה את ההדרכה המוסברת בפרק זה, מכיוון שנשתמש בקרש לחם לכל הניסויים כאן.
ניתן לראות את הגדרת חיבור ה- LED הבסיסית להלן:
ניתן לראות 3 רכיבים בסיסיים לעיל:
- נורית 5 מ'מ, 20 mA
- נגד 330 אוהם 1/4 וואט
- An מועצת ארדואינו
פשוט הרכיבו את המערכת בהתאם לתרשים.
לאחר מכן, חבר את 5V מהמחשב USB למחשב Arduino. ברגע שתעשה זאת תראה את נורית הלד נדלקת.
אני יודע שזה די בסיסי, אבל תמיד טוב להתחיל מההתחלה. תהיו בטוחים שהדברים יתחילו להיות מעניינים יותר ויותר ככל שנתקדם.
1.5 בקרת LED עם Arduino
כעת נלמד כיצד לשלוט על נורית LED עם תוכנית Arduino.
כדי לכתוב תוכנית עלינו לכלול לפחות שתי פונקציות בכל תוכנית.
ניתן להבין פונקציה כסדרה של הצהרות תכנות שניתן להקצות לשם, כמפורט להלן:
- להכין() זה נקרא או מבוצע במהלך תחילת התוכנית.
- לוּלָאָה() זה נקרא או מבוצע שוב ושוב במהלך כל התקופה המבצעית של הארדואינו.
לכן, למרות שאין לה פונקציונליות מעשית, מבחינה טכנית ניתן לכתוב תוכנית ארדואינו לגיטימית קצרה כ:
התוכנית הפשוטה ביותר
void setup()
{
}
void loop()
{
}
אולי שמתם לב שברבות משפות התכנות, המערכת מתחילה בהצגת הדפסה פשוטה, 'שלום, עולם' על גבי מסך התצוגה.
המקבילה האלקטרונית לביטוי זה בפרשנות המיקרו-בקר היא להבהב נורית לדלוק וכיבוי.
זו התוכנית הבסיסית ביותר שניתן לכתוב וליישם כדי להצביע על תפקוד נכון של המערכת.
ננסה ליישם ולהבין את ההליך באמצעות פיסת הקוד הבאה:
רישום 1.2: led1 / led1.pde
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
בסדר, עכשיו בואו נבין מה פירוש כל שורת קוד וכיצד היא פועלת לביצוע הפונקציה:
const int kPinLed = 13
זה עובד כמו קבוע המאפשר לנו להשתמש בו במהלך תכנות השלם, ללא צורך בשימוש בערך הממשי שמוגדר כנגדו.
לפי הכללים הסטנדרטיים קבועים כאלה מוכרים עם אות ההתחלה ל . למרות שזה לא חובה, זה עושה דברים ברורים יותר ומובנים בכל פעם שמתחשק לך לעבור על פרטי הקוד.
void setup()
{
pinMode(kPinLed, OUTPUT)
}
קוד זה מגדיר את הסיכה הספציפית שאליה מחובר ה- LED שלנו. במילים אחרות, הקוד אומר לארדואינו לשלוט בהיבט ה'כתיבה 'על הסיכה הזו, במקום' לקרוא 'אותה.
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
השורות לעיל מציינות את ביצוע הבקשה בפועל. הקוד מתחיל בכתיבה ועיבוד של HIGH על חיבור ה- LED הרלוונטי, והפעלת ה- LED.
כאן, המונח HIGH פירושו פשוט להשיג +5 וולט על הסיכה המודאגת של הארדואינו. המונח המשלים LOW פשוט מציין אפס או 0V על הסיכה המיועדת.
לאחר מכן, אנו קוראים delay() שתפקידם ליצור עיכוב באלפיות השנייה (1/1000 שנייה). מכיוון שהנתון 500 הוזן, העיכוב המיושם יעמוד על חצי שנייה.
ברגע שחצי שנייה זו פג, השורה הבאה מבוצעת המכבה את נורית הנורית עם המונח LOW על אותו סיכה.
הקו שלאחר מכן מייצר שוב עיכוב של 1/2 שנייה, על מנת לאפשר לנורית להישאר כבויה למשך 1/2 שניות.
והתהליך נמשך לאין ערוך על ידי ביצוע שורות הקוד, כל עוד הארדואינו נשמר.
לפני שתמשיך לשלב הבא, אמליץ לך בבקשה לתכנת את הקוד שלעיל ולבדוק האם אתה מסוגל ליישם את רצף ה- LED ON / OF בצורה נכונה או לא.
מכיוון שנורית ה- LED המוגדרת כברירת מחדל בארדואינו מחוברת עם סיכה מס '13, עליה להגיב מיד לתוכנית הנ'ל ולהתחיל להבהב. עם זאת, אם אתה מוצא שהנורית החיצונית שלך לא מהבהבת, ייתכן שיש תקלה בחיבור עם הנורית שלך, אתה יכול לנסות להפוך את הקוטביות של הנורית שלך ולקוות לראות אותה גם מהבהבת.
אתה יכול לשחק עם זמן ההשהיה על ידי שינוי דמות '500' לערך אחר ולמצוא את ה- LED 'מקשיב' לפקודות וגורם לו להבהב לפי ערכי העיכוב שצוינו.
אך זכור, אם אתה רואה שהנורית לא מהבהבת בקצב שנייה קבוע, ללא קשר לשינוי זמן העיכוב שלך, הדבר עשוי להצביע על כך שהקוד אינו פועל בגלל טעות כלשהי. כי כברירת מחדל הארדואינו יתוכנת בקצב מהבהב של שנייה. לכן שיעור זה חייב להשתנות לפי הקוד שלך כדי לאשר את פעולתו הנכונה.
1.7 הערות
שורות הקודים שהבנו לעיל נכתבו במיוחד עבור תוכנת המחשב.
עם זאת, על מנת להבטיח שהמשתמש יוכל להפנות את משמעות השורות ולהבין אותם, לעתים קרובות עשוי להיות שימושי והגיוני לכתוב את ההסבר לצד שורות הקודים הרצויים.
אלה נקראים הערות אשר נכתבים לעיון אנושי או משתמש בלבד, ומקודדים כדי לאפשר למחשבים להתעלם מכך בבטחה.
שפת ההערות הללו כתובה בכמה פורמטים:
- סגנון החסימה של התגובה, שבו תיאור התגובה מוקף תחת סמל ההתחלה / * וסמל הסיום * /
- זה לא צריך להגביל בשורה אחת, אלא ניתן להרחיב אותה לשורות הבאות, בהתאם לאורך התגובה או לתיאור, כפי שמוצג בדוגמה הבאה:
/ * זו תגובה * /
/ * אז זה * /
/ * וגם
* זה
* כפי ש
* נו */
לכתיבת תיאור מהיר של שורה אחת לתגובה, שני קו נטוי // בתחילת הדרך הופך למספיק. זה אומר למחשב כי לקו זה אין שום קשר לקוד בפועל, ויש להתעלם ממנו. לדוגמה:
// זוהי תגובה ממנה מחשבים יתעלמו.
הנה דוגמה להתייחסות:
/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/
/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
1.8 פתרון בעיות
אם אתה מוצא שהתוכנית שלך מציגה 'שגיאה' בעת הידור, או סוגיה אחרת, העצות הבאות כנראה יעזרו לך לבדוק מחדש את הקוד שלך להיפטר מהמכשול.
- שפת התוכנית שלך תהיה רגישה לאותיות רישיות. למשל הביטוי myVar לא ניתן לכתוב כ MyVar.
- כל מיני רווחים לבנים שעשויים להתבצע על ידי הקלדת המקלדת שלך, ניתנים בסופו של דבר כמרווח יחיד, והוא גלוי או מובן רק עבורך, המחשב לא ייקח זאת בחשבון. במילים פשוטות, רווחים פנויים מכל סוג שלא ישפיעו על תוצאות הקוד.
- יש לסגור כל גוש קוד עם סוגריים מתולתלים שמאלה וימינה, '{' ו '}'
- אין להפריד בין ספרות באמצעות פסיקים. לדוגמא, ייתכן שלא ניתן לכתוב 1000 כ -1,000.
- כל שורת קוד הסגורה בין הסוגריים המסולסלים חייבת להסתיים בנקודה-פסיק
יצירת רצף אור LED מעניין עם Arduino
בפרק הקודם למדנו כיצד להבהב נורית ON / OFF ברציפות עם קצב עיכוב קבוע.
כעת נלמד כיצד ניתן לבצע דפוסי עיכוב שונים באותה נורית באמצעות שדרוג קוד התוכנית.
לא נשתמש ב- LED חיצוני, אלא נשתמש ב- LED ברירת המחדל המובנה בלוח הארדואינו בסיכה מס '13. אתה יכול למצוא את LED ה- SMD הזעיר הזה ממש מאחורי מחבר ה- USB.
2.2 הבנת הצהרות IF
בחלק זה נלמד כיצד מבני בקרה מאפשרים לנו להריץ קודים בודדים, ומתישהו אפילו באופן חוזר ונשנה, כנדרש.
ההצהרה אם הופך למבנה הבקרה הראשון. היישום הבא מראה כיצד משתמשים בו:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
ננסה להבין את הקוד לעיל באופן שלבי ונלמד כיצד ניתן להשתמש בו לביצועים דומים אחרים.
הקודים בין השורה הראשונה לשביעית דומים בדיוק לתוכנית הראשונית שלנו.
השינוי הראשון קורה למעשה בשורה השמינית.
int delayTime = 1000
אתה יכול למצוא שזה דומה לקוד בשורה הראשונה, וחסר עובדה שהוא חסר את המונח קונסט.
זה פשוט בגלל שקוד זה אינו קבוע. במקום זאת זה מוגדר כ- מִשְׁתַנֶה , שיש לו את המאפיין של ערך משתנה במהלך התכנות.
בדוגמה שלעיל ניתן לראות כי משתנה זה מיוחס לערך 1000. זכרו, משתנים כאלה הכלואים בסוגריים מסולסלים צריכים להיכתב בקפדנות בתוך זוגות סוגריים מתולתלים בלבד, והם מכונים משתנים 'מקומיים'.
לחלופין, משתנים שאמורים להיות מחוץ לסוגריים מסולסלים, כמו זה שעליו אנו דנים כעת, מוכרים כ'גלובלים ', ויכולים להתבצע כמעט בכל מקום בקוד התוכנית.
בהמשך, אתה יכול לראות שקודים בין שורה 9 ל -11 דומים גם לתוכנית הראשונה, ובכל זאת הדברים מתחילים להיות מעניינים אחרי שורה 11. בוא נראה איך!
delayTime = delayTime - 100
בקוד זה אנו רואים שערך ברירת המחדל של ה- עיכוב זמן משתנה על ידי הפחתת 100 ממנו.
משמעות 100 מופחתת מהערך ההתחלתי שלה 1000, ומספקת לו ערך חדש של 900.
באמצעות התמונה הבאה ננסה להבין כמה ממפעילי המתמטיקה המשמשים בשפת הארדואינו.
עכשיו בואו נעריך את הקודים בין שורה 13 ל- 15.
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
המטרה העיקרית של פיסת הקוד הנ'ל היא להבטיח שהנורית תמשיך להבהב ללא כל הפרעה.
בשל העובדה שמופחתים 100 מהמקור עיכוב זמן , זה מונע ממצמץ ה- LED להגיע לאפס ומאפשר להבהב להימשך ברציפות.
התמונה הבאה מציגה כמה מפעילי השוואה בהם נשתמש בקודים שלנו:
בקוד שלעיל היינו יכולים לבדוק שהקוד הוא if(delayTime == 0).
עם זאת, מכיוון שהנתון השלילי יכול להיות גרוע באותה מידה, לא הלכנו על זה, וזה נוהג מומלץ.
תחשוב מה יכולה הייתה להיות התוצאה אם היינו מנסים לנכות 300 במקום 100 מ delayTime?
אז עכשיו אולי הבנתם שאם delayTime נכתב כקטן או שווה לאפס, ואז זמן ההשהיה יוחזר לדמות המקורית 1000.
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
ארבע השורות האחרונות של הקוד כפי שמוצג לעיל הופכות אחראיות להפעלת / כיבוי הנורית, הפעלה / כיבוי ברציפות.
כאן ניתן להבחין בבירור שבמקום להשתמש במספר דמויות, השתמשנו במשתנה להקצאת זמן העיכוב כך שנוכל להתאים אותו כרצוננו במהלך תקופת הפעולה של הקוד. זה מגניב, נכון?
2.3 דוחות ELSE
כאן נלמד מדוע ואיך אם לטווח עשוי להיות סעיף אַחֵר כך שהיא תחליט על המצב במקרה אם הצהרה שקרית.
צר לי אם זה נשמע מבלבל מדי, אל תדאגי, ננסה להבין את זה בדוגמה הבאה:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
באמור לעיל ניתן לראות היטב שבקוד השורה ה -10 קוד מבוצע רק כאשר delayTime הוא פחות או שווה ל 100, אם לא אז הקוד בשורה ה -13 מבוצע, אך שניהם יחד לא יכולים לקרות לעולם, השורה העשירית או קוד השורה ה -13 יושמו, לעולם לא שניהם.
יתכן ששמת לב שבניגוד למה שעשינו בסעיף 2.2 הקודם שלנו, כאן לא השווינו עם 0, אלא לעומת 100. זאת מכיוון שבדוגמה זו בהשוואה לפני שחיסרנו 100, לעומת זאת בסעיף 2.2, השווינו אחרי שאנחנו מְחוּסָר. אתה יכול לדעת מה יכול היה לקרות אם היינו משווים 0 במקום 100?
2.4 בעוד הצהרות
ל בזמן ההצהרה דומה למדי ל- אם הצהרה, למעט האמת שהיא גורמת לביצוע חוזר לבלוק קוד (שעשוי להיות בין סוגריים מסולסלים) כל כך הרבה זמן שהתנאים חלים, וזה עובד ללא אַחֵר הַצהָרָה.
הדוגמה הבאה תעזור לך להבין זאת טוב יותר
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}
האם אתה יכול לנחש מה מתוכנת לעשות הקוד הקוד? ובכן, הוא נועד למצמץ את ה- LED מהר יותר ואז לאט יותר.
2.5 מה נכון ושקרי?
בשפת התכנות, שֶׁקֶר מתייחס לאפס (0). למעשה לא משתמשים ב'אמיתי ', במקום להניח שכששום דבר אינו שקרי, כל מה שנכלל נכון.
זה נראה קצת מוזר אולם זה עושה את העבודה די יפה.
ננסה לתפוס את המצב באמצעות הדוגמה הבאה.
לפעמים אתה עלול להיתקל בקוד כמפורט להלן:
while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}
זה מקודד נראה כאילו ביצוע LED ימשיך לרכוב על אופניים לנצח, שכן כוח ארוך זמין.
עם זאת, חסרון אחד של סוג זה של קוד עלול להיווצר כאשר המשתמש משתמש בטעות a = במקום ==.
אני בטוח שאתה כבר יודע ש = מסמל מטלה, כלומר הוא משמש לייעוד ערך נבחר למשתנה, בעוד ש- a == משמש לאכיפת בדיקה אם הערך היה זהה.
לדוגמה, נניח שאתה נדרש מ- LED להבהב עם דפוס מהיר ברצף ובאופן חוזר ונשנה, אך השתמשת באופן שגוי ב- = במקום ==.
הקוד יופיע כך:
int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
הטעות תקצה 0 ל- delayTime ותוביל ל אם הצהרה כדי לבדוק אם 0 היה נכון או לא. מכיוון ש- 0 מתייחס לשקר, הוא יחשוב שזה לא נכון ויפסיק את האכיפה של delayTime = 1000, אלא במקום זאת את הפונקציה delayTime מתקיים בשעה 0 במהלך הלולאה ().
זה נראה מאוד לא רצוי !!
לכן, בדוק תמיד את התוכנית שלך כדי לוודא שלא עשית טעויות מטופשות כאלה.
2.6 שילובים
לפעמים אתה עלול להרגיש צורך לבדוק כמה דברים יחד. כמו, ייתכן שתרצה לבדוק אם משתנה היה בין שני מספרים. אמנם ניתן ליישם זאת באמצעות הצהרת if מספר רב של פעמים, אך אולי נוח יותר להשתמש בשילובים לוגיים לקריאה טובה וקלה יותר.
יישום שילובים במונחים לוגיים יכול להיעשות בשלוש שיטות, כפי שמוצג בטבלה הבאה:
מעניין לדעת שמפעיל ה- NOT יכול לעבוד כמתג עבור משתנה שעשוי להיות מיועד להיות אחד מהם נָכוֹן אוֹ שֶׁקֶר (או LOW או HIGH).
הדוגמה הבאה ממחישה את המצב:
int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}
כאן ledState יהיה LOW, ובהמשך ברגע ledState = !ledState, הוא יהפוך ל- HIGH. הלולאה הבאה תגרום ledState להיות גבוה כאשר ledState = !ledState נמוך.
2.7 הצהרות
כעת ננסה להבין אודות מבנה בקרה אחר שהוא a ל לוּלָאָה. זה יכול להיות מאוד שימושי כאשר תרצה ליישם משהו מספר פעמים.
בואו נבין זאת בדוגמה הבאה:
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}
אתה יכול למצוא משהו ייחודי בקו ל.
זה הקוד אני ++? . זה שימושי עבור מתכנתים עצלנים למדי ורוצים ליישם קידוד באמצעות קיצורי דרך נוחים
המונח הנ'ל מכונה מפעילים מורכבים, מכיוון שהם עושים את העבודה בשילוב מפעיל מטלות אחד עם מפעיל מטלות אחר. ניתן לראות את הפופולרי ביותר מבין אלה בטבלה הבאה:
תגלה שיש 3 הצהרות משנה בהצהרה. הוא בנוי כמוצג להלן:
for (statement1conditionstatement2){
// statements
}
ההצהרה מספר 1 מתרחשת ממש בהתחלה ופעם אחת בלבד. המצב נבדק בכל פעם במהלך הלולאה. מתי שזה יהיה נָכוֹן בתוך הסוגריים המתולתלים, ההצהרה הבאה 2 נאכפת. במקרה של א שֶׁקֶר, המערכת קופצת לגוש הקוד הבא.
חיבור נוריות נוספות
בסדר, עכשיו נראה כיצד אנו יכולים לחבר מספר רב יותר של LEds לקבלת אפקטים מעניינים יותר.
אנא חבר את נוריות ה- LED ואת ה- Arduino כמוצג להלן. החוט האדום הוא למעשה לא הכרחי, אך מכיוון שתמיד מומלץ להכניס את שני מסילות האספקה לקרש הלחם שההגדרה הגיונית.
עכשיו בואו נתקן תוכנית שתאפשר לנו לבדוק אם החומרה שלנו מוגדרת כהלכה או לא.
מומלץ תמיד לקודד ולבצע פיסות קטנות של תוכניות שלב אחר שלב כדי לבדוק אם התוכנות המתאימות מחוברות כראוי או לא.
זה עוזר לפתור במהירות שגיאה אפשרית.
דוגמת הקוד שלהלן מספקת לד 2 עד 5 תבנית ספציפית על ידי סיבוב זה אחר זה בצורה מחזורית.
const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}
כפי שאתה עשוי לשים לב, אין שום דבר רע בקוד, למעט העובדה שהוא נראה ארוך ולכן נוטה לטעויות.
כמובן שישנן דרכים טובות יותר לכתוב את הקוד שלעיל, החלק הבא יגלה אותו.
2.9 הצגת מערכים
מערכים יכולים להיות קבוצת משתנים שניתן לאינדקס עם מספרי אינדקס. הדוגמה הבאה תעזור לנו להבין את זה טוב יותר.
const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i
}
}
void loop()
{
for(int i = 0 i
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}
בסדר, עכשיו בואו נעבור על כל חלק ונבין איך הם עובדים בפועל.
const int k_numLEDs = 4
הקוד שלעיל מגדיר כמה אלמנטים מקסימליים אנו אמורים להיות במערך. קוד זה עוזר לנו בסעיפים הבאים להבטיח שהכל כתוב בתוך מערך ושום דבר ברגע שהמערך מסתיים.
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
בשורה הבאה זו הגדרנו את מבנה המערך. המספרים בתוך הסוגר מציינים את מספר האלמנטים במערך. אם כי, ניתן היה לכתוב את הכמות בפועל, כתיבה כקבועים עובדת טוב יותר. ניתן לראות את הערכים בדרך כלל בתוך הסוגר עם פסיקים ולייעד את הערכים למערך.
כאשר אתה מוצא מערך עם אינדקס מספר 0, זה מציין את האלמנט הראשון במערך, כפי שמוצג במערך code: k_LEDPins is k_LEDPins[0].
באופן דומה האלמנט האחרון יוצג כ- _ _ _, מכיוון שהספירה מ- 0 עד 3 היא 4.
k_LEDPins[3]
הקוד שלעיל מציג את השימוש בלולאה להמשך דרך כל רכיבי מערך ולהגדרתם כ- OUTPUTS. אנו מיישמים סוגריים מרובעים יחד עם האינדקס כדי להגיע לכל אחד מהאלמנטים במערך.
אם אתה תוהה האם אפשר להשתמש בסיכה מס '2 כדי להצמיד מס' 5 ללא מערכים, התשובה היא כן, זה אפשרי. אבל בדוגמה זו זה לא נעשה כי לא עשינו זאת בצורה כזו. בסעיפים הבאים תוכלו לבטל את גישת המערך אם סיכות הפלט שנבחרו אינן בשורה.
קדימה, בואו נראה מה עושה גוש הקוד הבא:
void setup()
{
for(int i = 0 i
}
}
כאן הקוד ממשיך דרך כל אחד מ- LED להדליק אותם ברצף עם פער או עיכוב של 100 אלפיות השנייה.
for(int i = 0 i
delay(100)
}
השימוש בקוד שלעיל מציג כיצד היישום של לולאה יכול לשמש לנוע דרך הלולאה אפילו בסדר הפוך.
זה מתחיל מ for(int i = k_numLEDs - 1 i >= 0 i--){ מכיוון שמערכים אפסים באינדקס. אנחנו לא מתחילים מ
digitalWrite(kPinLeds[i], LOW)
delay(100)
}k_numLEDs - 1 כי זה יביא לחציית גימור המערך.
הקוד משתמש> = 0 כדי לבדוק שהאלמנט הראשון באינדקס 0 לא יפספס או יתעלם ממנו.
פרק 3
מה קלט
כך למדנו כיצד להפעיל דברים באמצעות ארדואינו. בפרק זה נדון כיצד לחוש את העולם האמיתי על ידי ממשק תשומות מפרמטרים חיצוניים.
3.1 שימוש בלחצני כפתור
כולנו יודעים מה זה לחצן כפתור ואיך זה עובד. זהו סוג של מתג או כפתור המחבר אות משלב מעגל אחד למשנהו ברגע שהוא במצב מדוכא ושובר את האות בעת שחרורו.
3.1.1 כפתור אחד ונורית LED
אנו נחבר את הארדואינו בלחיצת כפתור עם ארדואינו בהתאם לפרטים המוצגים לעיל ונלמד את העבודה והיישום הבסיסי של ההגדרה.
כפתור הלחיצה המצוין המכונה גם כפתור לחיצת מתג מיקרו כולל 4 פינים בסך הכל (2 זוגות בכל צד). כאשר דוחפים אותם, כל זוג סיכות מחובר פנימה ומאפשר חיבור או הולכה על פניהם.
בדוגמה זו אנו משתמשים רק בזוג אחד מהסיכות או המגעים הללו, הזוג השני אינו רלוונטי ולכן מתעלמים ממנו.
נמשיך להחיל את הקוד הבא ולבדוק אותו עובד!
k_LEDPins[4]
אולי תמצאו כאן כמה דברים שנראים חריגים. בואו נבין אותם בצורה חכמה.
const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
הדבר הראשון שאנחנו עושים זה לתקן את buttonPin כמו קֶלֶט. ובכן זה די בסיסי, אני יודע.
לאחר מכן אנו מקצים גָבוֹהַ אל ה קֶלֶט פִּין. אתה תוהה, איך ייתכן שאפשר לכתוב משהו בכניסה? בטח, זה עשוי להיות מעניין.
למעשה, הקצאת HIGH לכניסת Arduino מחליפה נגד נגד משיכה פנימי של 20k Ohm (LOW על סיכה זו מכבה אותו).
שאלה נוספת שעשויה להיות היא מהו נגד משיכה. סיקרתי פוסט מקיף על נגדי משיכה שאתה ללמוד את זה כאן .
בסדר, נמשיך, עכשיו בואו נסתכל על קוד הלולאה הראשי:
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
כשלוחצים על כפתור הלחיצה, הסיכה החוטית מתחברת לקרקע, מה שהופך a נָמוּך לסיכה ההיא. ובעוד במצב לא דחוס אותו סיכה מוחזק ב גָבוֹהַ או + 5 וולט באמצעות הנגד למשוך 20K פנימי.
כאן אנו רוצים שהארדואינו ידליק את ה- LED כאשר לוחצים על כפתור הלחיצה (LOW), לכן אנו כותבים HIGH עבור הפלט לכל תגובה של LOW מהלחצן, תוך כדי לחיצה עליו.
3.1.2 שני כפתורים ונורית LED
ובכן, ייתכן שאתה תוהה שניתן היה לבצע את הפעולה המוצגת לעיל גם ללא ארדואינו. אני מבין, עם זאת זוהי אבן דריכה כדי ללמוד כיצד ניתן להשתמש בכפתור עם ארדונו.
עד לנקודה זו למדנו כתיבת קודים עבור מתג ON (HIGH) או כיבוי (LOW) נורית.
עכשיו בואו נראה כיצד ניתן לשלוט על בהירות ה- LED עם ארדואינו.
ניתן לעשות זאת בשתי שיטות:
- על ידי הגבלת כמות הזרם ל- LED
- על ידי שימוש ב PWM או אפנון רוחב הדופק, שבו האספקה לד LED מופעלת / כיבה בקצב רצוי במהירות רבה, ומייצרת תאורה ממוצעת שעוצמתה תהיה תלויה ב- PWM.
בלוח Arduino ניתן להשיג תמיכה ב- PWM על פינים המסומנים בטילדה (~), שהם פינים 3, 4,5,9,10 ו- 11) ב -500 הרץ (500 פעמים בשנייה). המשתמש מסוגל לספק כל ערך בין 0 ל -255, כאשר 0 לא מתייחס ל- HIGH או no + 5V, ו- 255 אומר לארדואינו לקבל HIGH או + 5V כל הזמן. כדי להפעיל פקודות אלה יהיה עליכם לגשת ל- AnalogWrite () עם הערך הרצוי.
אתה יכול להניח ש- PWM יהיה x / 255 כאשר x הוא הערך הרצוי שברצונך לשלוח באמצעות void loop() .
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
הגדר את Arduino ופרמטרים אחרים כפי שמוצג לעיל.
analogWrite()
ייתכן שתמצא כאן שלוש שורות שזקוקות להסבר כלשהו.
const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}
השורה: ledBrightness = constrain(ledBrightness, 0, 255) ממחיש פונקציה ייחודית בתוך ארדואינו המכונה constrain ().
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)
פונקציה פנימית זו כוללת קוד הדומה לדברים הבאים:
הגבלת int (int int, int min, int max) ledBrightness = constrain(ledBrightness, 0, 255)
כל הקודים שנדונו לפני זה החלו עם בָּטֵל , שפירושו לא להחזיר דבר (בטל). ואילו הקוד הנ'ל מתחיל ב int , המציין שהוא מחזיר מספר שלם. נדון יותר בסעיפים המאוחרים יותר, כרגע רק זכרו שלמספר שלם אין חלקים חלקים.
נכון, כך משתמע מכך, הקוד: { מקצה את
if(value > max){
value = max
}
if(value
}
return value
}ledBrightness = constrain(ledBrightness, 0, 255).
השורה הבאה מעסיקה ledBrightness to be within the range of 0 and 255 לפקודות על Arduino ליישם PWM על הסיכה שנבחרה עם הערך הרצוי.
השורה הבאה יוצרת עיכוב של 20 אלפיות השנייה, זה כדי להבטיח שלא נתאים את האכלים מהר יותר מ- 50 הרץ או פי 50 בשנייה. הסיבה לכך היא שבני אדם יכולים להיות איטיים בהרבה מארדואינו. מכאן שאם העיכוב אינו מתבצע התוכנית עלולה לגרום לנו להרגיש שלחיצה על הכפתור הראשון כיבה את הנורית ולחיצה על הכפתור השני הפעילה אותה (נסה זאת בעצמך כדי לאשר).
3.2 פוטנציומטרים
בואו נתקדם ונלמד כיצד להשתמש פוטנציומטרים עם ארדואינו.
כדי לדעת כיצד עובד פוטנציומטר או סיר, אתה יכול לקרוא את זה מאמר .
חבר את הפרמטרים המוצגים לארדואינו שלך כפי שמוצג לעיל.
בסיר יהיו 3 מסופים. הטרמינאסל האמצעי יתחבר ל- ANALOG IN 0 בארדואינו. שני המסופים החיצוניים האחרים עשויים להיות מחוברים למסילות אספקה + 5 וולט ו -0 וולט.
בואו לתכנת ולבדוק את התוצאות:
analogWrite
תוכלו למצוא כמה דברים שעשויים להיראות חדשים לגמרי ואינם כלולים באף אחד מהקודים הקודמים שלנו.
- הקבוע
const int kPinPot = A0מוקצה כ- A0, כאשר A הוא קיצור הדרך לתיאור אחד מהסיכות האנלוגיות. עם זאת A0 מתייחס גם לסיכה מס '14, A1 לסיכה מס' 15 וכן הלאה, ואלו מאפשרים לך לשמש ככניסות / פלטים דיגיטליים למקרה שנגמר לך הסיכות לניסוי. אך זכור כי אינך יכול להשתמש בסיכות דיגיטליות כסיכות אנלוגיות.
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
} - השורה:
kPinPotמציג פונקציית פנים חדשה בארדואינו המכונה מַפָּה(). תכונה זו מכיילת מחדש מטווח נתון לאחר, המכונה מפה (ערך, fromLow, fromHigh, toLow, toHigh). זה עשוי להיות מכריע מאזledBrightness = map(sensorValue, 0, 1023, 0, 255)נותן ערך בטווח של 0-1023, אך analogWrite מסוגל לקבל ערך בין 0-255.
אתה עשוי לחשוב, מכיוון שניתן לשלוט על בהירות ה- LED באמצעות התנגדות משתנה, פשוט סיר יכול היה להספיק למטרה, מדוע השימוש בארדואינו. ובכן, שוב זה רק הבסיס, להראות כיצד ניתן להגדיר סיר עם ארדואינו.
אין בעיות, עכשיו נעשה משהו שאי אפשר לעשות בלי ארדואינו.
בניסוי זה נראה כיצד ניתן להשתמש בהתנגדות המשתנה של הסיר לבקרת המהירות המהירה או קצב הנורית.
הנה התוכנית:
analogueRead
3.2.3 הימנעות מעיכוב ()
הקוד שלמעלה נראה טוב, אך ה- LED אינו מסוגל לבדוק את ערך הסיר עד שהוא עובר כל מחזור מלא. לעיכובים ארוכים יותר התהליך הזה מתארך על המשתמש להמתין לראות את תגובת הסיר בזמן שהוא מזיז אותו. ניתן להימנע מעיכוב זה באמצעות תכנות חכם כלשהו, כך שהוא מאפשר למשתמש לבדוק את הערך ללא עיכובים מינימליים. הנה הקוד.
const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}
אז מה זה שונה בקוד שלעיל? זה השורה הבאה שעושה את ההבדל.
const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}
עד סעיף זה, דנו אודות המשתנה int. עם זאת, יתכנו עוד מספר משתני סוגים שאליהם אתה יכול לגשת. הרשימה תוכל לקרוא להלן:
נכון לעכשיו, זה יכול להיות רק קריטי לדעת כי לאחסון מספרים גדולים יחסית עבור int משתנה, אתה יכול להשתמש במונח ארוך או א int ארוך
כאן תוכלו לראות פונקציה מעניינת אחרת הנקראת מיליס ().
זה מייצר את פרק הזמן באלפיות השנייה שארדואינו עבד במהלך פעולתו מההתחלה (פעולה זו תתאפס ל -0 אחרי כל 50 יום). הנה זה חוזר הרבה כי אם הוא חזר int , ייתכן שספירה לתקופות ארוכות אינה אפשרית. האם תוכל לענות כמה זמן בדיוק? התשובה היא 32.767 שניות.
לכן במקום להשתמש ב- delay (), אנו בודקים אם המיליס (), וברגע שמספר המסוים של אלפית השנייה נפקד אנו משנים את ה- LED. כתוצאה מכך אנו שומרים את הזמן בו שינינו אותו לאחרונה פעם אחרונה משתנה, כך שהוא מאפשר לנו לבדוק אותו שוב בכל עת.
3.3 נוריות RGB
עד כה שיחקנו עם נורית צבע אחת. אמנם ניתן לשנות צבע LED על ידי החלפת ה- LED בצבע אחר, אך מה דעתך על שימוש בנורות RGB לשינוי צבעי לד בלי להחליף את נוריות הלדים?
נורית RGB היא בעצם נורית LED עם LED אדום, ירוק וכחול המוטמע וממוזג לנורת LED אחת. יש לה עופרת משותפת אחת שעוברת לקרקע או למעקה אספקה 0V בעוד ששלושת ההפניות האחרים מוזנים באותות חיוביים מגווני PWM ליישום המיועד. ערבוב צבעים .
אתה יכול לחבר את ההגדרה כמוצג להלן:
זה אולי נראה קצת מורכב, אבל למעשה זה העתק של עיצוב בקרת ה- LED הקודם שלנו באמצעות PWM.
הנה קוד לתוכנית תרגול:
long lastTime = 0
לאחר העלאת קוד זה, רק ראו כיצד התאמות הסיר יוצרות אפקט אור מעניין על ה- RGB, זה יכול להיות ממש כיף.
תגלה שכשכל 3 הסירים מועברים מיקומים מרביים, במקום צבע לבן תראה אדום. זאת מכיוון שצבע אדום הוא הבולט מבין שלושת הצבעים ולכן שולט במצב זה. עם זאת תוכלו להתנסות בפונקציה מַפָּה() , לפני ביצועו לחלק האדום של ה- LED, על מנת ליצור איזון הגיוני יותר.
אודיו עם ארדואינו
בחלק זה נלמד כיצד להוסיף צליל ומוסיקה בסיסיים להתקנת Arduino.
נראה כיצד להחליף אות לרמקול מחובר בתדר הרצוי.
ליתר דיוק, תנוסח תו אמצעי, שהוא תו תדר 440 הרץ.
לשם כך פשוט נשמיע תו א באמצע ונבצע אופטימיזציה של אות גל סינוס עם גל מרובע.
כמו כן, אנו מחשבים את משך הזמן בו הרמקול עשוי להישאר פועל על ידי תביעה לנוסחה:
timeDelay = שנייה אחת / 2 x טון תדר.
timeDelay = שנייה אחת / 2 x 440
timeDelay = 1136 מיקרו שניות
4.1 בוא נתחבר את לוח הארדואינו
4.2 הוספת הערה פשוטה
כבר דנו לגבי הפונקציה לְעַכֵּב() כאשר היחידה נמצאת באלפיות השנייה (שנייה / 1000), עם זאת תמצאו פונקציה נוספת const int kPinPot1 = A0 כאשר היחידה נמצאת במיקרו-שניות, (אלפיות השנייה / 1000).
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}
עבור ההתקנה הנוכחית אנו מתכנתים קוד להפעלה + כניסה 5V על הפין הנבחר המקושר לרמקול, בקצב של 440 פעימות לשנייה.
כזכור, בדיון האחרון קבענו את הערך 1136 מיקרו שניה לתו השמע המיועד.
אז הנה התוכנית לכך, שתאפשר לכם לשמוע תו שמע של 440 הרץ ברגע שתתכנתו את הארדואינו עם רמקול מחובר.
delayMicroseconds()
בעזרת היישום הנ'ל ניתן לרשום הערת שמע, מה שאומר שגם אנו יכולים ליצור מוזיקה לפי בחירתנו.
מהקוד אנו מבינים כי ארדואינו כולל כמה פונקציות משולבות אשר תורמות בנוסף ליצירת מוסיקה.
הראשון הוא טוֹן() שעובד עם 2 אלמנטים יחד עם אלמנט אופציונלי 3, שמוגדר כ- טון (סיכה, תדר, משך זמן). אוֹ טון (סיכה, תדר)
שניהם מיועדים לבצע בהתאמה לתקופת הזמן שהוקצתה על ידך.
בהיעדר פרק זמן, המוסיקה תמשיך להתנגן עד לשיחה טוֹן() מבוצע שוב, או עד שאתה מבצע לא אחד ().
זה צריך להיעשות באמצעות פונקציית השהיה למקרה שמנגן מוסיקה הוא הדבר היסודי היחיד שאתה מיישם.
משך הזמן עשוי להיות קריטי מכיוון שהוא מאפשר מתן זמן למשך כמה זמן המוסיקה מנוגנת, כך שתוכלו לעשות חופשיים לעשות דברים אחרים. ברגע שמשך הזמן חלף, המוזיקה נעצרת.
הפונקציה הבאה לא אחד () מטפל בפרמטר יחיד ועוצר את הטון שנבחר על סיכה שהוקצה מסוימת.
אזהרה משונה: בכל עת מתי טוֹן() הפונקציה מיושמת, פונקציית PWM בפין 3 ו- 11 תפסיק לפעול.
לכן בכל פעם שמשתמשים בתכנית מצורפת לרמקולים, דאג שלא להשתמש בסיכה המוזכרת לרמקולים, במקום זאת נסה סיכות אחרות לחיבור הרמקול.
בסדר אז הנה תוכנית ליישום מוסיקה ברמקול, אם כי לא מדובר במוזיקה אמיתית אלא בסולם הערה C.
const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}
בקוד הנ'ל אולי שמתם לב למשהו חדש וזהו #לְהַגדִיר .
מונח זה עובד כמו חיפוש והחלפה של הפקודה למחשב תוך כדי ביצוע הידור.
בכל פעם שהוא מוצא את הדבר הראשון לפני חלל, הוא מחליף אותו בחלק הנותר של הקו (שנקרא פקודות מאקרו).
אז בתוך הדוגמה הזו כשהמחשב רואה NOTE_E4 זה מחליף אותו במהירות בכמות 330.
לקבלת הערות והתאמה אישית נוספת, אתה יכול להתייחס לקובץ במקל ה- USB שלך מגרשים , שם ניתן למצוא את רוב התדרים להעדפתך.
4.4 מוסיקה עם פונקציות
הקוד שלמעלה נראה טוב, אבל נראה שיש לו הרבה חזרות, צריכה להיות שיטה כלשהי לקצר את החזרות האלה, נכון?
עד כה עבדנו עם שתי פונקציות חיוניות הכלולות בארדואינו. עכשיו זה הזמן שנוצר פונקציות משלנו.
כל פונקציה חייבת להתחיל בסוג המשתנה שאליו הוא עשוי לשייך. למשל הפונקציה בָּטֵל מתייחס לסוג שאינו מחזיר דבר ומכאן השם בטל. שים לב, כבר דנו ברשימת המשתנים בסעיפים הקודמים שלנו, ייתכן שתרצה להפנות אותם.
כתוצאה מכך, שם הפונקציה המסוים מקבל סוגריים פתוחים '(' ואחריו רשימה של פרמטרים המופרדים בפסיקים.
כל אחד מהפרמטרים רוכש את סוגו יחד עם שם, ולבסוף סגירה ')' מַאֲמָר מוּסְגָר.
ניתן ליישם פרמטרים אלה בתוך הפונקציה בצורה של משתנים.
בואו נראה דוגמה למטה בה אנו מפתחים פונקציה שנקראת ourTone () נועד למזג את טוֹן() עם לְעַכֵּב() שורות, באופן שהפונקציה מפסיקה לחזור עד שהפתק סיים להשמיע את הטון.
אנו מיישמים פונקציות אלה בקוד הקודם שלנו ומקבלים את התוכנית שלהלן, עיין בשורות האחרונות:
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
פונקציות יכולות להיות שימושיות ביותר בכדי להקל על ההבנה של תוכנית.
להלן דוגמה בה אנו מסוגלים לציין את בחירת הטון אותה אנו רוצים לנגן באמצעות שני מערכים. מערך אחד לשמירת התווים, השני לשמירת המקצבים.
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}
ניתן לראות בבירור בשורה הראשונה את ההקדמה של #לִכלוֹל הַצהָרָה. התפקיד של הצהרה זו הוא לאסוף את כל הקובץ בין הציטוטים ולהציב אותו במיקום #לִכלוֹל הַצהָרָה. על פי הכללים הסטנדרטיים אלה ממוקמים בקפדנות בתחילת התוכנית.
פרק 5
מדידת טמפרטורה
רק כזכור, זכרו במקום לכתוב לגמרי תוכניות גדולות, תמיד חכם לכתוב ולנתח חלקים קטנים של קודים, מה שעוזר במעקב אחר טעויות במהירות.
5.1 צג סידורי
עד כה, הקודים עליהם דנו לא נראים קלים יותר לאפשר פתרון בעיות מהיר. כאן ננסה להקל על הניטור ופתרון קל יותר של בעיה אפשרית.
ל- Arduino יש תכונה המאפשרת לו 'לדבר חזרה' עם המחשב. יתכן שתצפו כי pin0 ו- pin1 מסומנים כ- RX ו- TX אחד ליד השני. למעשה עוקבים אחר פינים אלה באמצעות IC נפרד בארדואינו שמשדרג אותם לקריאה על פני כבל ה- USB בזמן שהוא מחובר למחשב האישי.
החלק שלהלן מציג תוכנית מן המניין, אנא בצע זאת, נלמד לגבי הערכים החדשים בקוד לאחר מכן. קוד זה זהה לביטוי בסעיף 2.2, למעט העובדה שהוא כולל נתונים מיותרים המאפשרים לנו לזהות לשם מה הוא מקודד.
#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}
אתה יכול לזהות שני דברים חדשים כאן, שורה חדשה ב- להכין() פוּנקצִיָה.
const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
קו זה פשוט מבטא את הצורך בשימוש ב- סדרתי 1 קוד כדי לאכוף אותו עם 9600 באוד. (כאן סדרתי מתייחס ביטים נשלח בזה אחר זה, ובוד פירושו הקצב שבו הוא נשלח). ערך שידור זה וזה שנמצא בתוך הצג הסדרתי (נלמד זאת בהמשך) חייב להיות שווה, אחרת הנתונים בצג הסדרתי יראו זבל. 9600 להיות הסטנדרט הופך להיות נוח יותר לשימוש.
הערך החדש השני הוא כדלקמן
Serial.begin(9600)
כאן השורה השנייה מציעה שהדבר הבא שיוצא מהיציאה הטורית יתחיל בשורה הבאה. כך השורה השנייה שונה מקו האגרוף.
דבר נוסף שאתה יכול לראות זה ציטוטים ('). זה ידוע בתור מחרוזת, שתשמש רק קבועים כאן, מכיוון שדיון נוסף בנושא זה יכול להיות מורכב מדי ומעבר לתחום.
בסדר, כעת אנו יכולים להעלות את הקוד לעיל בארדואינו ולראות מה קורה.
מה, אופס נראה ששום דבר לא קרה, סיכת הארדואינו מס '13 נורית מהבהבת ועצרה, בעוד נורית ה- Tx נשארה מהבהבת.
ובכן, זה בגלל שחלון צג הסידורי עדיין לא קבוע.
עליך ללחוץ על התיבה Serial Monitor ב- IDE שלך כמוצג לעיל. אל תשכח לבדוק את קצב השידור הממוקם בפינה השמאלית התחתונה, כברירת מחדל הוא אמור להיות 9600, והוא יתאים לקוד. אם זה לא הקפד לבחור 9600.
הסרטון הבא מסביר כיצד הוא מתבצע.
https://youtu.be/ENg8CUyXm10עכשיו נתקדם ונלמד כיצד התכונה צג סידורי לעיל יכולה לסייע בעיבוד מדידת טמפרטורה באמצעות Arduino
נשתמש ב- IC TMP36 כחיישן הטמפרטורה, בעל טווח של -40 עד 150 מעלות צלזיוס.
ניתן לראות את ההתקנה למטה:
הקוד הבא יזם את מדידת הטמפרטורה על ידי קריאת הפלט מחיישן TMP36, ועל ידי שליחתם לפקח הסידורי של המזהה.
Serial.print('delayTime = ')
Serial.println(delayTime)
בואו נבין את הקוד מלמעלה.
const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
כאן תוכלו לראות שכללנו את סוג המשתנה לָצוּף.
זהו הסוג המשתנה היחיד שכולל אחסון הכל למעט מספרים שלמים (מספרים ללא חלקים עשרוניים או חלקים).
הדיוק ממשתנה צף יכול להיות עד 6 עד 7 ספרות.
הקוד הסמוך float temperatureC = getTemperatureC() הוא הפונקציה שלנו המחשבת וממירה באופן מתמטי את הפרש המתח שנחוש מחיישן TMP36 למעלות צלזיוס.
getTemperatureC()
בחלק הבא של הקודים, מאז המונח float getTemperatureC() מוקצה להחזיר דמות בין 1 ל 1023, יתאפשר לנו להעריך את המתח מהחיישן על ידי הכפלת הקריאה שלנו ב 5 ואז חלוקתו ב 1024.
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
החיישן TMP36 מוגדר לייצר 0.5V ב 0 מעלות צלזיוס, ולאחר מכן מייצר 10mV עבור כל עלייה אחת במעלות צלזיוס.
להלן הערכה שאנו יכולים ליצור באמצעות החישובים:
אתה יכול לשקול להיות הפונקציה הראשונה שלך שמחזירה ערך כלשהו (שים לב שכל הפונקציות שנותרו עד כה לא החזירו שום ערך מאז שהן מהסוג בָּטֵל ).
אתה יכול להבין שכדי לקבל ערך מפונקציה אתה פשוט צריך להוסיף לַחֲזוֹר ואחריו המספר הרצוי שתרצה להחזיר.
כשאנחנו אומרים לַחֲזוֹר פירוש הדבר שהפונקציה מחזירה תגובה או תשובה בכל פעם שהיא נקראת, אשר ניתן להחיל אותה על משתנה.
כאשר זה נשלח לצג הסידורי, הקריאה עוברת המרה לפרנהייט convertToF ().
analogIn()
פונקציה זו מרימה את טווח צלזיוס וממירה אותו לפרנהייט.
להמרת פרנהייט לצלזיוס אנו מיישמים את הנוסחה פרנהייט = 9 / 5 (צלזיוס) + 32.
5.3 ממשק LCD
עכשיו בואו נלמד כיצד לממשק או לחבר תצוגת אל סי די עם Arduino לקבלת תצוגה חזותית עבור הפלטים הנדרשים.
ביישום שלנו אנו מעסיקים LCD 84x48 גרפי, בעל 84 פיקסלים או נקודות אופקיות, ו 48 פיקסלים אנכיים. מכיוון שבקר ייעודי הופך להיות הכרחי עבור כל צגי ה- LCD, המכשיר הנוכחי משלב גם אחד בצורת בקר PCD8544.
במדריך זה נחבר את מודול ה- LCD שצוין לעיל עם ארדואינו וניישם שגרות מסוימות ליצירת הודעות טקסט בתצוגה.
באיור הבא תוכלו למצוא פרטים לגבי ממשק ה- LCD, יחד עם קטן וסת מתח 3.3V . רגולטור זה הכרחי מכיוון שה- LCD מוגדר לעבודה עם ספק 3.3V.
אתה יכול גם לראות 8 pinouts ממודול ה- LCD, את המפרט pinout ניתן ללמוד מהטבלה הבאה:
עכשיו בואו נראה איך נוכל לחבר את ה- LCD ואת הפרמטרים הרלוונטיים לארדואינו שלנו. ניתן לדמיין את הפרטים באיור המוצג להלן:
5.4 תקשורת ל LCD
למרות שניתן לכתוב קבוצות משוכללות לאינטראקציה עם LCD מארדוינו, אנו מעדיפים ללמוד כיצד לעשות זאת באמצעות ספריות.
ספריות כוללות מגוון קודים שניתן ליישם במהירות עבור תוכנית ארדואינו שנבחרה.
זה מאפשר למשתמש להתקשר לפונקציה ללא מאמץ מבלי לעבור עבודות קידוד מורכבות.
5.4.1 כיצד להתקין את הספרייה
לשם כך תצטרך ליצור ספריה בשם ספריות במחשב שלך Arduino IDE, כמוסבר כאן
5.4.2 יישום פעולות ה- LCD
בדיוק כמו הגישה הקודמת שלנו, נבדוק תחילה את כל הקוד ואז ננסה להבין את פרטי השורות הבודדות.
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
השורה כוללת את הקוד #include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}
הקוד #include מורה למחשב לאסוף את הקובץ שהוזכר ולהחליף את אלמנט #include בתוכן הקובץ במהלך הקומפילציה של התוכנית.
האלמנט # כלול יכול להיות בעל סוגריים זוויתיים המציינים חיפוש בספריית הספרייה, לחלופין הוא עשוי להיות בעל ציטוטים המציינים חיפוש בתוך אותה ספריה בה נמצאת התוכנית.
שורות הקוד הבאות מבטאות את פינות ה- LCD ואז אנו כותבים צורה חדשה של משתנה:
#include
כאן אנו מבטאים משתנה עם השם lcd בעל הסוג PCD8544 ומורה למחשב לאשר מחדש את הפינוטים שלו הקשורים ל- Arduino.
בתהליך זה אנו מתארים את המשתנה למחשב על ידי הוראה כיצד ממשק ה- pin clk, din, dc וה- reset מתבצע עם Arduino.
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
הקו void setup() מאתחל את פעולת ה- LCD. לאחר ביצוע פעולה זו, השורה הבאה אוכפת סמן בצד שמאל עליון של התצוגה. והשורה הבאה הבאה עושה מאמץ להדפיס את ההודעה 'שלום, עולם'.
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
זה נראה די זהה לטכניקה בה שלחנו הודעות על גבי המסך הטורי. ההבדל היחיד הוא השימוש בקוד lcd.init() במקום סריאל.דפוס.
בלוק הקוד הבא נקרא למעשה באופן חוזר ונשנה.
lcd.print
באמצעות שורה זו void loop() אנו מקבעים את הסמן לעמודה 0 השמאלית ביותר בשורה הראשונה, מעל צג ה- LCD.
{
lcd.setCursor(0,1)
lcd.print(millis())
}
בשורה הבאה יש קיצור דרך: lcd.setCursor(0,1)
אם אתה זוכר שעבדנו עם lcd.print(millis()) בקודים הקודמים שלנו היינו יכולים להחיל את אותו הדבר גם כאן באמצעות הקודים:
millis()
עם זאת בגלל העובדה שכאן לא מעורב פרקי זמן באלפיות השנייה, לכן אנו משיגים זאת פשוט על ידי שליחת long numMillis = millis() לתפקד ישירות אל
lcd.print(numMillis)millis() .
5.5 שילוב כל העניין
בסדר, עכשיו בואו נשלב את כל הקודים שלמדנו לעיל להכנת מעגל הטמפרטורה של LCD, ובואו נראה איך זה נראה:
lcd.print()
הכל נראה סטנדרטי בתוכנית שלעיל, למעט השימוש בפונקציה setCursor () . זה משמש ליישור הטקסט ככל האפשר סביב מרכז התצוגה.
גדול! וכל הכבוד, תיכנתת זה עתה את מחוון טמפרטורת ה- LCD הקטן שלך באמצעות Arduino.
יישומי Arduino מעשיים
מכיוון שבשלב זה סקרנו באופן מקיף את טכניקות התכנות השונות בפירוט, הגיע הזמן לנקוט בהן על ידי יישום מספר יישומים מעשיים שימושיים.
נתחיל בחיישנים ונראה כיצד ניתן להשתמש במכשירי חיישנים עם Arduino על ידי ביצוע מספר קודי דוגמה.
7.1 מבוא לחיישנים
במדריך זה נלמד לגבי המגוון הרחב של החיישנים שניתן להשתמש בהם עם Arduino. אלה עשויים לכלול התקנים כמו חיישן אור LDR, חיישן אפקט אולם מגנטי, חיישני הטיה, חיישן רטט, חיישן לחץ וכו '.
נתחיל בממשק של חיישן אור LDR עם Arduino, כפי שמוצג בתרשים הבא:
כפי שכולנו יודעים, LDR הוא מכשיר נגד תלוי אור שהתנגדותו תלויה בעוצמת האירוע הסביבתי על פניו.
עוצמת האור היא ביחס הפוך לקריאת ההתנגדות של ה- LDR.
כאן נלמד כיצד ניתן לשלב מאפיין זה עם Arduino לצורך ביצוע יישום שימושי:
ניתן לדמיין את קוד התוכנית השלם כמפורט להלן:
#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}
כל הפרמטרים המשמשים בקוד כבר נדונו בקורס שלנו שלמדנו עד כה. אתה יכול לבדוק את השורות על ידי הפניה לסעיפים הרלוונטיים.
הערכים נבחרו באופן אקראי, תוכלו לשנות בקלות לפי העדפותיכם.
חיישן הטיה
חיישן הטיה הוא מכשיר פשוט שניתן להשתמש בו כדי לזהות פעולת הטיה על כל אובייקט בו הוא מותקן. המכשיר מכיל בעצם כדור מתכתי שבתוך ההטיה מתגלגל על זוג מגעים הגורם להולכה על פני אותם מגעים. מגעים אלה המסתיימים כמובילים של מתג ההטיה, משמשים עם מעגל חיצוני לזיהוי ההולכה עקב פעולת הטיה והפעלת יישום הפלט הרצוי.
עכשיו בואו נראה איך א חיישן הטיה ניתן לחבר את המכשיר. התמונה למטה נותנת לנו מושג לגבי התצורה המלאה:
const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}
בדוגמא זו נורית ברירת המחדל של סיכה מס '13 משמשת כמחוון ההטיה.
ניתן לראות בבירור את הכללת הנגד המושך כאן, די דומה למה שעשינו בסעיף 3.1. לכן המונח LOW מציין כי פונקציית ההטיה אינה מופעלת.
7.4 ממסר מתג ריד (ממסר מופעל על ידי מגנט מיניאטורי)
עכשיו בואו נראה איך לחבר מתג ממסר או חיישן שדה מגנטי עם Arduino. ממסר קנה הוא סוג של מתג המפעיל או מוליך כאשר מביאים אליו שדה מגנטי או מגנט. בעיקרון יש לו זוג מגעים פרומגנטיים בתוך מארז זכוכית מיניאטורי אשר מצטרפים או יוצרים מגע עקב משיכה מגנטית בכל פעם שמגנט נמצא בסמיכות אליו. כאשר זה קורה מסופי המגעים מראים הולכה עקב סגירת המגעים.
גם כאן אנו משתמשים בסיכת LED 13 לציון התגובה. אתה יכול לחבר נורית חיצונית מהסיכה הזו במידת הצורך בהתאם להסברים הקודמים שלנו.
const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}
מונחי הקוד צריכים להיות מוכרים ומסבירים את עצמם.
7.5 חיישן רטט באמצעות מתמר Piezo
בתוכנית לדוגמא הבאה נראה כיצד א מתמר פייזו יכול לשמש כחיישן רטט להארת נורית דרך Arduino.
אלמנט piezo הוא למעשה מכשיר המייצר רטט או תנודה כאשר תדר מוחל על המסופים שלו. עם זאת, אותו פיזו יכול לשמש בתהליך ההפוך עבור יצירת פולסים חשמליים בתגובה לרטט המופעל על גופו. רטט זה יכול להיות בצורה של נקישה או מכה על פני הפיזו.
התקינו את הארדואינו ואלמנט הפיזו כמפורט באיור הבא
const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}
סף 100 מוצג רק כדי לוודא שהארדואינו מגיב רק לרטט האמיתי באמצעות דפיקות, ולא לרטטים קטנים אחרים כמו מצלילים חזקים, או קרניים.
הבחירה בסיכת A5 אינה חובה, באפשרותך לבחור כל קלט אנלוגי אחר לפי העדפתך ועל ידי התאמתו בקוד התוכנית.
שימוש במנוע סרוו עם Arduino
מנוע סרוו הוא סוג של מנוע DC הניתן לסיבוב בזוויות מדויקות בהתאם לדרישה של יישום מסוים. ניתן לעשות זאת על ידי החלת פקודה מחושבת על הכניסות הרלוונטיות של המנוע כדי לייצר זווית סיבוב או סיבוב מדויקת בטווח של 180 מעלות על המנוע.
בדרך כלל למנוע סרוו יש 3 חוטים או כניסות. החוטים החיוביים הם בדרך כלל בצבע אדום, החוט השלילי או הקרקע הוא שחור, אשר חוט הפקודה או חוט האיתות הם בדרך כלל בצבע לבן או צהוב.
Arduino מאפשר שליטה במנועי סרוו באמצעות שפת תמיכה מובנית שהופכת את השליטה לנוחה מאוד ואידיאלית עבור מנועי סרוו.
הדוגמה הבאה תציג לנו את תוכנית ההתקנה הבסיסית ליישום בקרת מנועי סרוו דרך Arduino:
הקוד ניתן להלן:
const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}
אנו יכולים לראות כמה ערכים חדשים כאן. כזה שמספר את החוט המצורף של הסרוו לאיזה סיכה הוא מוקצה. השני הוא הקוד המספק לסיכה ערך בין 0 ל -180, לקביעת זווית הסיבוב בסרוו.
סיכום
נושא הארדואינו יכול להיות ארוך לאין ערוך, ולכן מעבר לתחום מאמר זה. עם זאת, אני מקווה שהמדריך שלעיל בהחלט היה צריך לעזור לך ללמוד את היסודות של ארדואינו ולהבין פרמטרים חשובים באמצעות קודי היישום השונים לדוגמא.
אני מקווה שייתכן ויהיה מעודכן מידע נוסף מדי פעם כאן, בכל פעם שהוא זמין.
בינתיים תיהנו מקורס התכנות שלכם, Happy Arduinoing to you !!
קודם: מעגל מטר גלאי אלכוהול באמצעות מודול חיישן MQ-3 הבא: מעגל מזין כלבים מבוקר
