שיעור מספר 8 / ליצן קטן שלי - אולי תרקוד איתי?... / לנגן בקלות עם ארדואינו

השבוע נלמד לעבוד עם זמזם. הרעיון הוא פשוט: קובעים את התדירות שבה יעבוד הזמזם ואת משך הזמן שהזמזם יתנגן. התוצאה תלויה כמובן בתווים שתנגנו, בסדר שלהם ובמקצב השיר.

מוכנים? 

רכיבים: 

• לוח ארדואינו
• מטריצה
• נגד 100𝛀 (גם נגד 330𝛀 יעבוד כאן אבל ינגן חלש יותר)
• Buzzer (משהו שעושה באזז..)  - בעברית הוא כנראה יקרא "זמזם"
• כמה חוטים.. 

תחילה נבנה את המעגל: 

ירי לייזרים מהחלל החיצון / רמקול ופוטנציומטר

תמיד תהיתם איך מייצרים את הקולות המשונים של יריות הלייזר בחלל החיצון? האמת שאין לי תשובה מוסמכת אבל יש לי כיוון לפתרון...

מתחילים?

רכיבים:

• לוח ארדואינו
• מטריצה
• רמקול 8𝛀
• נגד 4.7K𝛀
• פוטנציומטר 
• שלושה חוטים 

מרכיבים את המעגל על פי התרשים הבא: 

ומעלים את הקוד הבא (נמצא גם בדוגמאות המובנות של הארדואינו): 

void setup() { Serial.begin(9600); } void loop() { int sensorReading = analogRead(A0); Serial.println(sensorReading); int thisPitch = map(sensorReading, 400, 1000, 120, 1500); tone(9, thisPitch, 10); delay(1); }


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

תהנו!

מנועי סרוו עם ג'ויסטיק

איך שולטים על מנועי סרוו בעזרת ג'ויסטיק?

רכיבים: 

• לוח ארדואינו
• מטריצה
• זוג מנועי סרוו
• ג'ויסטיק
• 12 חוטים או יותר.. 

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

• את ה vcc/ 5V - נחבר ל 5V
• את ה GND - נחבר ל GND
• את ה SEL - נשאיר ללא חיבור
• את שני החיבורים הנותרים - נחבר ל A0 ו A1 (חיבור אחד נותן ציר X וחיבור אחד נותן ציר Y. לחיבורים יש שמות שונים על פי היצרנים השונים. אם חיברתם וגיליתם שציר ה X בג'ויסטיק שלכם שולט על ציר ה Y ולהפך - תמיד תוכלו לתקן ולהפוך חזרה). 

ואחרי שסיימנו להרכיב - נעלה את הקוד: 

#include <Servo.h> int ServoHorizontalPin = 3; int ServoVerticalPin = 4; int HorizontalPotPin = A0; int VerticalPotPin = A1; int ServoH_Min = 0; int ServoH_Max = 180; int ServoV_Min = 0; int ServoV_Max = 180; Servo HorizontalServo; Servo VerticalServo; int HorizontalPotValue; int HorizontalServoPosition; int VerticalPotValue; int VerticalServoPosition; void setup() { HorizontalServo.attach(ServoHorizontalPin); VerticalServo.attach(ServoVerticalPin); } void loop() { HorizontalPotValue = analogRead(HorizontalPotPin); VerticalPotValue = analogRead(VerticalPotPin); HorizontalServoPosition = map(HorizontalPotValue, 0, 1023, ServoH_Min , ServoH_Max); VerticalServoPosition = map(VerticalPotValue, 0, 1023, ServoH_Min , ServoH_Max); HorizontalServo.write(HorizontalServoPosition); VerticalServo.write(VerticalServoPosition); delay(20); }

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

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

הוספתי למעגל אלקטרומגנט וכפתור לשליטה על פי התרשים הבא:

רכיבים נוספים:

• אלקטרומגנט
• לחצן
• נגד 10K𝞨
• חוטים נוספים

כמובן שהיה צורך להתאים את הקוד ולהוסיף לו את הלחצן ואת האלקטרומגנט:

#include <Servo.h> int ServoHorizontalPin = 3; int ServoVerticalPin = 4; int HorizontalPotPin = A0; int VerticalPotPin = A1; int ServoH_Min = 0; int ServoH_Max = 180; int ServoV_Min = 0; int ServoV_Max = 180; int button = 10; Servo HorizontalServo; Servo VerticalServo; int HorizontalPotValue; int HorizontalServoPosition; int VerticalPotValue; int VerticalServoPosition; void setup() { HorizontalServo.attach(ServoHorizontalPin); VerticalServo.attach(ServoVerticalPin); pinMode(button, INPUT); pinMode(12,OUTPUT); } void loop() { if(digitalRead(button) == HIGH){ digitalWrite(12,HIGH); } else{ digitalWrite(12,LOW); } HorizontalPotValue = analogRead(HorizontalPotPin); VerticalPotValue = analogRead(VerticalPotPin); HorizontalServoPosition = map(HorizontalPotValue, 0, 1023, ServoH_Min , ServoH_Max); VerticalServoPosition = map(VerticalPotValue, 0, 1023, ServoH_Min , ServoH_Max); HorizontalServo.write(HorizontalServoPosition); VerticalServo.write(VerticalServoPosition); delay(20); }



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

הפתרון היה כמובן - להפסיק "לחלטר" ולהדפיס משהו תואם...

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

את הקבצים לאחר העריכה - תוכלו להוריד מכאן >>>

ההדפסה בעיצומה....

ואחרי כמה שיופים, הברגות והתאמות - התוצאה לפניכם:

ארדואינו ופרוססינג (Arduino & Processing) - פינג פונג

את הארדואינו אנחנו מכירים הרבה זמן. היום, ננסה להכיר את הפרוססינג. אז אם כבר הורדתם את הפרוססינג - אנחנו יכולים להתחיל לעבוד!

רכיבים:

• לוח ארדואינו
• מטריצה
• פוטנציומטר
• שלושה חוטים לחיבור. 

נתחיל? 

תחילה נבנה את המעגל: 

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

void setup() { pinMode(0,INPUT); Serial.begin(9600); } void loop() { int reading = analogRead(0); Serial.println(reading); delay(50); }

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

וליתר ביטחון למי ששכח:

בדוגמא הזאת, המחשב שלי הקצה לטובת הארדואינו את COM4. נזכור את זה לטובת ה Processing.

ועכשיו לקוד של הפרוססינג:

1. הורידו את התיקייה מכאן >>>
2. הקליקו על הקובץ pong.

אם הכל היה עד כאן בסדר - אתם אמורים לקבל את המסך הזה: 

כעת, בשורה מספר 4 - הזינו את מספר הפורט / הפתחה שלכם (זוכרים??).

ו... כמעט סיימנו:

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

• הכנסו ל Sketch
• Import Library
• Add Library

בחלון שיפתח לכם, חפשו את הספריה Minim והתקינו אותה:

ומה נשאר?

לחצו על כפתור ה Run (למעלה משמאל) והתחילו לשחק!!

בהצלחה!!

קרדיט ל instructables

הורדת פרוססינג (processing)

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

איך מורידים?

1. נכנסים לחלון ההורדות של התכנה בקישור הזה. שימו לב שהתכנה היא חינמית ואם תרצו לתרום להמשך פיתוח התכנה לחצו כאן. 
2. בחרו במערכת ההפעלה הנכונה. 
3. ההורדה של ה processing עשויה לקחת כמה דקות (115MB). 
4. בסיום ההורדה, חלצו את התיקייה והעבירו אותה אל תיקיית ה program files או למקום מסודר אחר במחשב. אגב, זה יעבוד היטב גם בלי להעביר אותה אבל כדאי להיות מסודרים ולהעביר את התיקייה למקום בו נמצאות התוכניות שלנו. 
5. מומלץ ליצור קיצור דרך לקובץ processing שבתוך התיקייה ולהעביר את קיצור הדרך אל שולחן העבודה. 

זהו, אין צורך בהתקנה ואנחנו יכולים להתחיל לעבוד! בהצלחה!! 

שליטה על מנועי DC

מנועי DC הם מנועים פשוטים בעלי שני חיבורים: פלוס (+) ומינוס (-). כדי לשלוט בהם בצורה מתוחכמת באמצעות הארדואינו אנו צריכים להשתמש בדרייבר (Driver) מיוחד שיעביר את המתח למנועים על פי הקוד שמריץ הארדואינו.

בשלב ראשון לקחתי את הדרייבר והלחמתי אליו חיבורים. בתמונות ניתן לראות את הדרייבר לפני ההלחמות ואת הדרייבר לאחר ההלחמות.

חיברתי את הדרייבר לכל החיבורים וכמובן לשני המנועים. אבל אז התחילו הבעיות:

1. המנועים לא הסתובבו כראוי. המנועים לא הסתובבו בצורה חופפת ולעיתים אחד המנועים "פספס" כמה סיבובים או עשה רק חצי מהפעולה. 
2. גרוע יותר - התחיל לעלות ריח שרוף מהדרייבר מכיוון חיבור ה VCC. על פי ההגיון ניסיתי להוריד מתח שנכנס לדרייבר מכיוון הארדואינו (ל 3.3V במקום 5V) ולשנות את המתח שנכנס לדרייבר עבור המנועים (הורדתי מ 9V לכיוון ה 4.5V). היתה אכן קורלציה בין המתח ובין העישון של הרכיב אולם לא הצלחתי להביא את הרכיב לעבודה סדירה על פי הקוד. 

אז מה עושים? 

לקחתי דרייבר מקביל של חברת Sparkfun וקיוויתי לטוב... 

מוכנים? 

רשימת רכיבים: 

• לוח ארדואינו
• מטריצה
• חוטים (הרבה...)
• שני מנועי DC
• מקור מתח חיצוני (שנאי, סוללה של 9V)
• דרייבר של sparkfun
• מלחם, בדיל ומשחת הלחמה (לצערי זה השלב הראשון ואי אפשר להמשיך בלעדיו) 

מתחילים להרכיב על פי התרשים הבא:

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

אחרי שהכל מורכב, מעלים את הקוד הבא:


//motor A connected between A01 and A02 //motor B connected between B01 and B02 int STBY = 10; //standby //Motor A int PWMA = 3; //Speed control int AIN1 = 9; //Direction int AIN2 = 8; //Direction //Motor B int PWMB = 5; //Speed control int BIN1 = 11; //Direction int BIN2 = 12; //Direction void setup(){ pinMode(STBY, OUTPUT); pinMode(PWMA, OUTPUT); pinMode(AIN1, OUTPUT); pinMode(AIN2, OUTPUT); pinMode(PWMB, OUTPUT); pinMode(BIN1, OUTPUT); pinMode(BIN2, OUTPUT); } void loop(){ move(1, 255, 1); //motor 1, full speed, left move(2, 255, 1); //motor 2, full speed, left delay(1000); //go for 1 second stop(); //stop delay(250); //hold for 250ms until move again move(1, 128, 0); //motor 1, half speed, right move(2, 128, 0); //motor 2, half speed, right delay(1000); stop(); delay(250); } void move(int motor, int speed, int direction){ //Move specific motor at speed and direction //motor: 0 for B 1 for A //speed: 0 is off, and 255 is full speed //direction: 0 clockwise, 1 counter-clockwise digitalWrite(STBY, HIGH); //disable standby boolean inPin1 = LOW; boolean inPin2 = HIGH; if(direction == 1){ inPin1 = HIGH; inPin2 = LOW; } if(motor == 1){ digitalWrite(AIN1, inPin1); digitalWrite(AIN2, inPin2); analogWrite(PWMA, speed); }else{ digitalWrite(BIN1, inPin1); digitalWrite(BIN2, inPin2); analogWrite(PWMB, speed); } } void stop(){ //enable standby digitalWrite(STBY, LOW); }

אתם אמורים לקבל תוצאה בערך כזאת:

בהצלחה!

פריזינג - הורדה ותחילת עבודה

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

אז איך מתחילים?

תחילה יש להוריד את התכנה מכאן >>>

(התכנה נכתבה ללא מטרות רווח ואם תרצו לתרום כדי לתת יכולת למפתחים לעדכן ולשדרג - לחצו כאן>>> )

בחרו במערכת ההפעלה שלכם (אני מניח שגם אתם משתמשים ב windows? ) וההורדה תתחיל באופן אוטומטי. חכו לסיום ההורדה (כאן זה השלב ללכת לשתות כוס או שתיים של מים. בכל זאת מדובר ב 182 MB...).

לאחר שההורדה ירדה, צריך לחלץ את הקבצים (בכל מחשב זה קצת שונה. ממליץ להעזר בהורים אם הסתבכתם). את התיקייה המחולצת כדאי להעתיק למיקום הבא:

C:\Program Files (x86)\fritzing.0.9.3b.64.pc

זהו.

אין צורך להתקין את ה Fritzing על המחשב. חפשו את קובץ היישום של Fritzing כמו בתמונה:

המלצה: בשלב הזה כדאי ללחוץ קליק ימני על הקובץ וליצור קיצור דרך:

העתיקו את קיצור הדרך והדביקו אותו על שולחן העבודה.

כעת ניתן להתחיל:

לחצו על קיצור הדרך ויפתח לכם המסך:

לחצו על לשונית ה Breadboard ותתחילו לעבוד!!

1. השתמשו בגלגלת העכבר בכדי להתרחק או להתקרב (Zoom in/ Zoom out). 
2. גררו רכיבים ממחסן הרכיבים מימין אל לוח העבודה. 
3. נסו ליצור חוטים שמחברים בין הרכיבים ובין הלוח. 
4. קליק ימני על החוט יפתח לכם אופציה לשינוי הצבעים.
5. ובכלל - לחיצה על הרכיב תפתח לכם אפשרות מצד ימין למטה לשינוי פרטים, גדלים, סוגים ועוד. 

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

1. שנו את נורת הלד לנורה ירוקה.
2. הוציאו את המתח לנורה מיציאה מספר 7. 
3. החליפו את נגד ה 220 ohm לנגד 330. 
4. הקטינו את המטריצה. 

בהצלחה!!!

מנוע סרוו - תנועה אוטומטית

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

רכיבים: 

• מנוע סרוו 
• לוח ארדואינו
• חוטים לחיבור

תחילה נבנה את המעגל בקלי קלות (אם נוח לכם - אתם יכולים להיעזר במטריצה): 

ולאחר שסיימנו, נעלה את הקוד: 

#include <Servo.h> Servo ServoMotor; void setup() { ServoMotor.attach(9); } void loop() { ServoMotor.write(180); delay(1000); ServoMotor.write(0); delay(1000); }


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

נסו לשנות את הקוד כך שסדר הפעולות יהיה כמו של מגבי רכב בגשם שהולך ומתחזק:

1. המנוע יעבור מ 0 מעלות ל 180
2. יחכה עשירית השניה
3. יחזור חזרה למקומו. 
4. ימתין שניה. 
5. פעולות 1-4 יחזרו על עצמם 5 פעמים
6. המנוע יעבור מ 0 מעלות ל 180
7. המנוע ימתין עשירית השניה. 
8. המנוע יחזור למקום. 
9. המנוע ימתין עשירית השניה. 
10. פעולות 6-9 יתבצעו 5 פעמים. 

ואם יש חלקים בקוד שלכם שנראים בערך כך: 

ServoMotor.write(180); delay(100); ServoMotor.write(0); delay(1000); ServoMotor.write(180); delay(100); ServoMotor.write(0); delay(1000); ServoMotor.write(180); delay(100); ServoMotor.write(0); delay(1000); ServoMotor.write(180); delay(100); ServoMotor.write(0); delay(1000); ServoMotor.write(180); delay(100); ServoMotor.write(0); delay(1000);

זה עשוי לעבוד אבל מאד מסורבל. תוכלו להסתכל כאן איך משתמשים בלולאת for בשביל לכתוב את הקוד "נקי יותר" וכך הוא גם יהיה הרבה יותר קל לעריכה ושינויים.

(אלון הרס לי את המשימה וכתב את הקוד הבא. שימו לב כמה הקוד נוח לשינוי ועריכה!


#include <Servo.h> Servo ServoMotor; void setup() { ServoMotor.attach(9); } void loop() { for (int i=0; i<5; i++){ ServoMotor.write(180); delay(450); ServoMotor.write(0); delay(2000); } for (int i=0; i<5; i++){ ServoMotor.write(0); delay(450); ServoMotor.write(180); delay(450); } }

תודה אלון!)


בהצלחה!!

מנוע סרוו עם פוטנציומטר

ניתן לשלוט על מנוע הסרוו (servo) באמצעות תקשורת סריאלית כמו שהדגמנו כאן אבל עכשיו ננסה לשלוט על מנוע הסרוו באמצעות פוטנציומטר.

הפוטנציומטר הוא נגד משתנה, כלומר, עוצמת ההתנגדות משתנה על פי סיבוב הפוטנציומטר. נשים לב! הפוטנציומטר במקרה הזה לא מווסת את המתח שמגיע למנוע הסרוו! מנוע הסרוו מקבל תמיד 5V מהארדואינו. הנגד המשתנה מעביר מתח משתנה (כתלות בהתנגדות) אל הארדואינו. הארדואינו קורא את המתח המשתנה כנתונים ומתרגם אותם לתנועת מנוע הסרוו.

רכיבים:

• לוח ארדואינו
• מטריצה
• מנוע סרוו
• פוטנציומטר
• שמונה חוטים פחות או יותר.. 

בונים את המעגל על פי התרשים הבא: 

נעלה את הקוד הבא: 

#include <Servo.h> Servo myservo; int potpin = 0; int val; void setup() { myservo.attach(9); } void loop() { val = analogRead(potpin); val = map(val, 0, 1023, 0, 179); myservo.write(val); delay(15); }


יש לכם רעיון לישומים של זה?

בינתיים הצלחתי לחשוב על כמה רעיונות כמו למשל תחרות גולף לזרועות רובוטיות, אבל אני בטוח שיכולים להיות עוד שימושים רבים ומגוונים...

כמה משימות קטנטנות, לוודא שהבנו:

1. נניח שיציאה דיגיטלית מספר 9 כבר תפוסה עם משהו אחר. תוכלו להעביר את מנוע הסרוו כך שיהיה מחובר ליציאה מספר 10? 
2. ואם הכניסה A0 שאליה חיברתם את הפוטנציומטר תפוסה? תוכלו להעביר את הפוטנציומטר לכניסה אנלוגית A2? 
3. תוכלו לשנות את טווח התנועה של מנוע הסרוו? כלומר, שמקצה הסיבוב של הפוטנציומטר ועד לסוף הסיבוב יעבור מנוע הסרוו רק 90 מעלות במקום 180 מעלות? 

שליטה על מנוע סרוו

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

רכיבים:

• מנוע סרוו
• שלושה חוטים 
• לוח ארדואינו

תחילה נבנה את המעגל: 

החיבורים הם פשוטים מאד: 

• את החוט האדום (VCC) נחבר ל 5V בארדואינו
• את החוט השחור (GND) נחבר ל GND בארדואינו
• את החוט הלבן / הצבעוני (תלוי בגרסת מנוע הסרוו..) - נחבר ליציאה מספר 9 בארדואינו. 

אם סיימנו לחבר - אפשר להעלות את הקוד: 

#include <Servo.h> Servo servo1; long num; void setup() { servo1.attach(9); Serial.begin(9600); Serial.print("Enter Position = "); } void loop() { while(Serial.available()>0) { num= Serial.parseInt(); Serial.print(num); Serial.println(" degree"); Serial.print("Enter Position = "); } servo1.write(num); delay(15); }


לאחר שהעלינו את הקוד - לא אמור לקרות דבר. כעת, פתחו את המסך הסיריאלי - והקלידו מספר בין 0 ל 180 ואחריו ENTER.

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

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

חיישן טמפרטורה ומסך סיריאלי משודרג...

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

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

נתחיל? 

רכיבים: 

• לוח ארדואינו
• מטריצה
• שלושה חוטי חיבור
• חיישן טמפרטורה אנלוגי מסוג TMP 36GZ

תחילה, נרכיב את המעגל ולפני כן אזהרה: 

העמידו את חיישן הטמפרטורה כאשר הכיתוב נמצא מולכם ואילו הצד הקמור של החיישן פונה כלפי חוץ. כאשר החיישן במצב זה, הרגל השמאלית שלו - צריכה לקבל את ה 5V ואילו הרגל הימנית - מתחברת ל GND. אם תהפכו את היוצרות, תקבלו חיישן חם מאד ואולי אפילו תגרמו לו להישרף.

כעת נעלה את הקוד על הארדואינו: 

void setup() { Serial.begin(9600); } void loop() { float t = analogRead(A0) / 2.046; t=t-32; t=t*5/9; Serial.print("<div style='font-size: 0.2em'> Temperature</div> "); Serial.print(t); Serial.println(" °C"); }

שימו לב! השורה הזאת:

 Serial.print("<div style='font-size: 0.2em'> Temperature</div>");

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

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

ועכשיו צריך להתקין את המסך הסיריאלי מחנות האפליקציות של גוגל כרום:

1. בחנות האינטרנט של כרום חפשו "serial projector". (או בקישור הזה)
2. התקינו את התוסף למחשב. 
3. כדי לפתוח את המסך הסיריאלי - לחצו על "אפליקציות" בחלק העליון של החלון של גוגל כרום. 

בחרו באפליקציה "serial projector":

אם הכל בסדר עד לכאן, הטמפרטורה תוצג לכם בחלון הסיריאלי:

שימו לב!

כאשר המסך הסיריאלי עובד - לא ניתן להעלות קוד לארדואינו. כדי לשפץ את הקוד - סגרו את המסך הסיריאלי, העלו את הקוד ורק לאחר מכן פתחו את המסך הסיריאלי.

בהצלחה!

משימות:

1. הגדירו שהמחשב יכתוב "טמפרטורה" בעברית ולא Temperture.

2. שנו את גודל הטקסט של הטמפרטורה.

בהצלחה!