מסך OLED בגודל של 0.91" - חלק א'

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

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

רכיבים:

• מסך OLED בגודל 0.91"
• לוח ארדואינו
• מטריצה 
• שבעה חוטים 

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

• את חיבור ה GND במסך ה OLED - נחבר ל GND בלוח הארדואינו. 
• את חיבור ה VCC / VIN במסך ה OLED - נחבר ל 5V בלוח הארדואינו. 
• את חיבור ה CLK במסך ה OLED - נחבר ליציאה מספר 10 בלוח הארדואינו. 
• את חיבור ה MOSI / DATA במסך ה OLED - נחבר ליציאה מספר 9 בלוח הארדואינו. 
• את חיבור ה RES / RST במסך ה OLED - נחבר ליציאה מספר 13 בלוח הארדואינו. 
• את חיבור ה DC במסך ה OLED - נחבר ליציאה מספר 11 בלוח הארדואינו. 
• את חיבור ה CS במסך ה OLED - נחבר ליציאה מספר 12 בלוח הארדואינו. 

אחרי שחיברתם הכל, לפני שאתם פותחים את תכנת הארדואינו, הורידו את הספרייה הנכונה מכאן >>>

חלצו את הספריה לכתובת הנכונה - אצלי זה נמצא כאן: 

C:\Program Files (x86)\Arduino\libraries

רק לאחר מכן, פתחו את תכנת הארדואינו (ואם היא היתה פתוחה - סגרו ופתחו שנית). היכנסו לקובץ >>> דוגמאות וחפשו את הספריה שזה עתה הורדתם וחילצתם - Adafruit SSD 1306. בחרו בדוגמא ssd1306_128x32_spi. 

העלו את הדוגמא ללוח הארדואינו וזהו! זה אמור להתחיל לעבוד!



ואם תרצו לכתוב בעברית?

תאלצו לחכות לחלק ב'...

איך בונים פצצת ארדואינו?

ראשית - ננמיך צפיות: מי שהגיע לעמוד הזה בכדי לבנות פצצה אמיתית - הגיע לעמוד הלא נכון...

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

למה זה טוב?

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

רכיבים:

• שני לוחות ארדואינו
• 3 נורות 
• זמזם פשוט
• מקלדת לארדואינו 4X4
• מסך LCD - עם ארבעה חיבורים 
• חוטים 
• מטריצה 
• מגנט (הסבר בהמשך)
• נגדים 220Ω, 1KΩ, 100Ω
• מקווה שזהו... 

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

הסבר על הנורות: 

הנורה הירוקה - מהבהבת במהלך הספירה לאחור

הנורה האדומה - מהבהבת במקרה של "פיצוץ". 

הנורה הכחלחלה - נותנת אווירה. במקום הנורה הזאת, השתמשתי במנורת לבה קטנה. ממליץ לכם להתחיל עם נורת לד פשוטה שאחר כך ניתן להחליף בנורות אחרות ופירוטכניקה לפי ראות עיניכם (והתקציב שלכם..). נורת הלבה נקראת בקוד UV. כרגע בגלל השימוש בריליי ונורת לבה - היא מוגדרת על LOW. תצטרכו לשנות את כל ה LOW ל HIGH אם תשמשו בנורת לד רגילה. 

המגנט: 

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

המסך: 

את מסך ה LCD תצטרכו לחבר על פי ההוראות הבאות: 

1. את ה VCC במסך ה LCD נחבר ל 5V בלוח הארדואינו. 
2. את ה GND במסך ה LCD נחבר ל GND בלוח הארדואינו. 
3. את ה SDA במסך ה LCD נחבר ל A4 בלוח הארדואינו. (אם אתם לא בטוחים והסימון אצלכם על המסך שונה - לא יקרה כלום אם תנסו להחליף בין A4 ל A5. שימו לב רק לאתחל את הארדואינו לאחר ההחלפה). 
4. את ה SCL במסך ה LCD נחבר ל A5 בלוח הארדואינו.

אל תשכחו להוריד את הספריה הנכונה במנהל הספריות!!

נגדים: 

נגד בהתנגדות של 220Ω ישמש לנורות 

נגד בהתנגדות של 100Ω ישמש לזמזם

נגד בהתנגדות של 1KΩ ישמש למגנט

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

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

#include <Keypad.h> #include <Tone.h> #define pound 10 Tone tone1; #include <Wire.h> #include <hd44780.h> #include <hd44780ioClass/hd44780_I2Cexp.h> hd44780_I2Cexp lcd; int hours = 3; // start hours int minutes = 0; //start min int seconds = 0; //start seconds int led = 11; int uv = 4; int blackcut = 7; int zam = 10; int led2 = 5; int key = 12; void setup() { Serial.begin(9600); lcd.begin(20, 4); tone1.begin(10); pinMode(blackcut, INPUT); pinMode(led, OUTPUT); pinMode(led2, OUTPUT); pinMode(uv, OUTPUT); pinMode(zam, OUTPUT); pinMode(key, INPUT); lcd.backlight(); lcd.setCursor(5,0); lcd.print("Hello!"); delay(2000); } void loop() { if(0==0){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Time to explosion"); delay(3000); while (hours > 0 || minutes > 0|| seconds >= 0) { lcd.setCursor(4, 1); (hours < 10) ? lcd.print("0") : NULL; lcd.print(hours); lcd.print(":"); (minutes < 10) ? lcd.print("0") : NULL; lcd.print(minutes); lcd.print(":"); (seconds < 10) ? lcd.print("0") : NULL; lcd.print(seconds); lcd.display(); stepDown(); if(digitalRead(blackcut) == LOW){ delay(70); digitalWrite(led2, LOW); digitalWrite(zam, HIGH); delay(5); digitalWrite(zam, LOW); digitalWrite(led2, HIGH); digitalWrite(uv, LOW); delay(60); } else{ digitalWrite(zam, HIGH); delay(10); digitalWrite(zam, LOW); delay(490); digitalWrite(led2, HIGH); digitalWrite(uv, LOW); delay(500); digitalWrite(led2, LOW); } if(digitalRead(key) == HIGH){ tone1.play(NOTE_E6, 200); lcd.setCursor(0,0); lcd.print("__BOMB UNARMED__"); for(;;){} }}}} void stepDown() { if (seconds > 0) { seconds -= 1; } else { if (minutes > 0) { seconds = 59; minutes -= 1; } else { if (hours > 0) { seconds = 59; minutes = 59; hours -= 1; } else { trigger(); } } } } void trigger() { for(;;){ lcd.clear(); lcd.setCursor(0,1); lcd.print("______BOOM______"); tone1.play(NOTE_A2, 90); delay(100); digitalWrite(led, HIGH); tone1.play(NOTE_B2, 30); delay(100); digitalWrite(led, LOW); tone1.play(NOTE_C2, 60); delay(100); tone1.play(NOTE_A2, 50); delay(100); } }

שימו לב שהשורות האלו בקוד:


int hours = 3; // start hours int minutes = 0; //start min int seconds = 0; //start seconds

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

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

#include <Keypad.h> char* password = "7593"; int position = 0; const byte ROWS = 4; const byte COLS = 4; char keys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'} }; byte rowPins[ROWS] = { 9, 8, 7, 6 }; byte colPins[COLS] = { 5, 4, 3, 2 }; Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); int GreenpinUnlock = 12; void setup() { pinMode(GreenpinUnlock, OUTPUT); LockedPosition(true); } void loop() { char key = keypad.getKey(); if (key == '*') { position = 0; LockedPosition(1); } if (key == password[position]) { position ++; } if (position == 4) { LockedPosition(0); } delay(100); } void LockedPosition(int locked) { if (locked==1) { digitalWrite(GreenpinUnlock, LOW); } else { digitalWrite(GreenpinUnlock, HIGH); } }

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

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

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

והנה סרט הוידאו:


בהצלחה!!

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

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

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

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

נתחיל?

רכיבים:

• לוח ארדואינו
• מטריצה
• המון חוטים 
• ארבעה נגדים משתנים LDR
• שני מנועי סרוו פשוטים
• שני פוטנציומטרים 
• ארבעה נגדים 1KΩ
• לוח סולארי (לא חובה לצורך ההתנסות הראשונית)
• כמה חלקי פלסטיק או קרטון ביצוע (הסבר מיד) 

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

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

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

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

עדכון: את החלקים תוכלו להוריד מכאן. אנא הדפיסו את המחזיק של המנוע סרוו בגודל של 105-110%. 

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

עכשיו התפניתי קצת להרכיב את החיבורים: 

כמה הערות קריטיות לחיבורים: 

1. הקפידו לחבר את החיישן הימני העליון ליציאה מספר A3 בלוח הארדואינו ואת החיישן השמאלי העליון ליציאה מספר A5 בלוח הארדואינו ובקיצור - הצמדו לתרשים מבחינת הכיוונים. 
2. לחיישן / "הנגד המשתנה", כמו כל נגד, אין צדדים - כלומר, לא חשוב האם את הרגל הזאת תחברו ל 5V או את השניה. 
3. שימו לב לחבר את מנוע הסרוו התחתון ליציאה מספר 9 בלוח הארדואינו ואת המנוע שיושב עליו ליציאה מספר 10 בלוח הארדואינו, כמו בתרשים. 
4. גם בפוטנציומטרים אין משמעות לימין ושמאל, העיקר שהרגל האמצעית תעביר את הסיגנל אלא אם כן אתם משתמשים בפוטנציומטרים מיוחדים (כמו זה שאני השתמשתי בו לדוגמא) ואז הכל אפשרי - תעקבו אחר הכיתוב שעל הפוטנציומטר. 

  אם הרכבתם הכל נכון זה אמור להראות בערך כך...

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

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

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

#include <Servo.h> Servo horizontal; int servoh = 90; Servo vertical; int servov = 90; int ldrlt = 0; int ldrrt = 1; int ldrld = 2; int ldrrd = 3; void setup() { Serial.begin(9600); horizontal.attach(9); vertical.attach(10); } void loop() { int lt = analogRead(ldrlt); // top left int rt = analogRead(ldrrt); // top right int ld = analogRead(ldrld); // down left int rd = analogRead(ldrrd); // down right int dtime = analogRead(4)/20; int tol = analogRead(5)/4; int avt = (lt + rt) / 2; int avd = (ld + rd) / 2; int avl = (lt + ld) / 2; int avr = (rt + rd) / 2; int dvert = avt - avd; int dhoriz = avl - avr; if (-1*tol > dvert || dvert > tol) { if (avt > avd) { servov = ++servov; if (servov > 180) { servov = 180; } } else if (avt < avd) { servov= --servov; if (servov < 0) { servov = 0; } } vertical.write(servov); } if (-1*tol > dhoriz || dhoriz > tol) { if (avl > avr) { servoh = --servoh; if (servoh < 0) { servoh = 0; } } else if (avl < avr) { servoh = ++servoh; if (servoh > 180) { servoh = 180; } } else if (avl == avr) { // nothing } horizontal.write(servoh); } delay(dtime); }

(קרדיט לקוד ולתרשים)

והנה המערכת בניסוי כלים: 

פתרון "תקלה" ברכיב RFID

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

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

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

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

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

כאן אתם יכולים לראות את החיבורים הישירים בין רכיב ה RFID ובין לוח הארדואינו, ללא המרת המתח. 

כמו שאתם רואים - בחיבור ה 3.3V, בחיבור ה GND ובחיבור ה RST - לא נגענו. החיבורים שעברו שינוי הם ארבעת החיבורים האחרים שעברו המרת מתח. על כל חיבור הוספנו שני נגדים: נגד של 1KΩ בין החיבור מהארדואינו ובין לוח ה RFID ונגד בערך של 2.2KΩ שמחבר את הרכיב ל GND וכדי לא להסתרבל מדי עם המילים - מציע להסתכל על התרשים. סיכומו של עניין - המתח שמגיע מלוח הארדואינו יורד ל 3.3V והלוחות ה"פגומים" (ככה הארדואינו טען...) חזרו לחיים ועובדים היטב. 

בהצלחה! 

חיישן הטיה / Tilt sensor

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

רכיבים:

• ארדואינו 
• מטריצה
• נורת LED
• נגד 220
• כמה חוטים 

את חיבור ה VCC בחיישן ה Tilt - מחברים ל 5V בארדואינו.

את חיבור ה GND (⏚) בחיישן ה Tilt - מחברים ל GND בארדואינו.

את חיבור ה D0 בחיישן ה Tilt - מחברים ליציאה מספר 2 בארדואינו.

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

void setup() { pinMode(2, INPUT); pinMode(13, OUTPUT); } void loop() { if ( digitalRead(2) == HIGH){ digitalWrite(13, HIGH); delay(200); }else{ digitalWrite(13, LOW); delay(200) ; }}

כעת, הנורה אמורה להגיב להטיה של החיישן. עובד? 

ינשוף / מד אלכוהול בנשיפה

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

נתחיל? 

רכיבים: 

• לוח ארדואינו
• חיישן אלכוהול מסוג MQ-3
• מסך LCD עם ארבעה חיבורים
• כמה חוטים

הערה: העדפתי לקנות את ה MQ-3 שמגיע כבר עם מודול וארבעה חיבורים מאשר לקנות רק את החיישן עצמו. המחיר של החיישן עצמו הוא כ - 4 ש"ח ויחד עם המודול שלו - מחירו כ 5 ש"ח אבל הפער בין המוצרים שווה בהחלט את תוספת השקל... 

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

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

1. את ה VCC במסך ה LCD נחבר ל 5V בלוח הארדואינו. 
2. את ה GND במסך ה LCD נחבר ל GND בלוח הארדואינו. 
3. את ה SDA במסך ה LCD נחבר ל A4 בלוח הארדואינו. (אם אתם לא בטוחים והסימון אצלכם על המסך שונה - לא יקרה כלום אם תנסו להחליף בין A4 ל A5. שימו לב רק לאתחל את הארדואינו לאחר ההחלפה). 
4. את ה SCL במסך ה LCD נחבר ל A5 בלוח הארדואינו. 
5. את חיבור ה A0 בחיישן ה MQ-3 נחבר ל A0 בלוח הארדואינו. 
6. את חיבור ה D0 בחיישן ה MQ-3 נחבר ליציאה מספר 2 בלוח הארדואינו. 
7. את חיבור GND בחיישן ה MQ-3 נחבר ל GND בלוח הארדואינו. 
8. את חיבור ה VCC בחיישן ה MQ-3 נחבר ל VCC בלוח הארדואינו. 

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

#include <Wire.h> #include <hd44780.h> #include <hd44780ioClass/hd44780_I2Cexp.h> hd44780_I2Cexp lcd; int gas_din=2; int gas_ain=A0; int led_pin=13; int ad_value; void setup() { pinMode(led_pin,OUTPUT); pinMode(gas_din,INPUT); pinMode(gas_ain,INPUT); Serial.begin(9600); lcd.begin(16, 2); lcd.print("Hello, World!"); delay(1000); } void loop() { lcd.clear(); ad_value=analogRead(gas_ain); if(digitalRead(gas_din)==LOW) { Serial.println("Gas leakage"); lcd.print("Gas leakage"); } else { Serial.println("Gas not leak"); lcd.print("Gas not leak"); } if(ad_value>500) { digitalWrite(led_pin,HIGH); delay(10); digitalWrite(led_pin,LOW); delay(10); } Serial.println(ad_value); lcd.setCursor(0, 1); lcd.print(ad_value); delay(500); }


והנה החיישן בניסוי כלים ראשון:

עכשיו נשאר לערוך התאמה קטנה של של החיישן לפורים - הכותב אינו מעודד שתייה חריפה משום סוג אולם לכבוד פורים, הוספתי תוספת היתולית קטנה לקוד: כאשר רמת האלכוהול נמוכה - המסך יכתוב LOW בתוספת סמיילי עצוב :-(
כאשר רמת האלכוהול גבוהה - המסך יראה NICE בתוספת סמיילי שמח :-)

הנה הקוד "המתוקן":

#include <Wire.h> #include <hd44780.h> #include <hd44780ioClass/hd44780_I2Cexp.h> hd44780_I2Cexp lcd; int gas_din=2; int gas_ain=A0; int led_pin=13; int ad_value; void setup() { pinMode(led_pin,OUTPUT); pinMode(gas_din,INPUT); pinMode(gas_ain,INPUT); Serial.begin(9600); lcd.begin(16, 2); lcd.print("Hello, World!"); delay(1000); } void loop() { lcd.clear(); ad_value=analogRead(gas_ain); if(digitalRead(gas_din)==LOW) { Serial.println("Gas leakage"); lcd.print("Gas leakage"); } else { Serial.println("Gas not leak"); lcd.print("Gas not leak"); } if(ad_value>600) { digitalWrite(led_pin,HIGH); delay(10); digitalWrite(led_pin,LOW); delay(10); lcd.setCursor(6, 1); lcd.print("NICE :-)"); } else{ lcd.setCursor(6, 1); lcd.print("LOW :-("); } Serial.println(ad_value); lcd.setCursor(0, 1); lcd.print(ad_value); delay(500); }

פורים שמח!

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

פוריM שMח!

Cura - Enable Retraction

בתכנת Cura ישנה אפשרות להגדיר למדפסת ה Ultimaker אפשרות של Retraction, כלומר, שהמדפסת תוכל גם להחזיר את חומר ההדפסה לאחור. מה היתרון של הפעולה הזאת? 

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

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

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

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

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

בשבוע שעבר, אחרי שטוביה ביקש ממני אינספור פעמים להדפיס לו את המודל, הדפסתי לו את המודל והפעם באמצעות Ultimaker 3. בהגדרות ההדפסה של Cura, דאגתי כמובן לאשר את האפשרות של Enable Retraction. את המודל הדפסתי בגודל קטן יותר והנה התוצאה: 

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

אז למה ב Cura זו אופציה? לא כדאי תמיד להשתמש בזה? 

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

מכשיר מעקב GPS

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

בתכל'ס, כל הנסיונות לשדר מיקום ב SMS הביאו לתוצאה בערך כזאת:

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

איפה הבעיה? 

ניסיתי לעלות רמה ולמרות הכישלון הצורב לנסות לשדר את המיקום בתקשורת סלולרית באמצעות אפליקציית Blynk. גם זה לא עבד והאפליקציה לא הראתה מיקום. הפעם זה היה מוזר אפילו יותר מכיוון שהשתמשתי בקוד מוכן של Blynk שעבר התאמות קלות מאד. כאשר כמעט התייאשתי - פגשתי ברשת את ihsan yurtbaşı (תודה רבה!!). ihsan עזר לי להבין שהארדואינו לא יכול לבצע יותר מפעולה אחת בו זמנית (טוב, את זה כולם יודעים...) ולכן במקרה של שימוש בשני רכיבי תקשורת - לדוגמא שימוש בתקשורת לוויינית ושימוש בתקשורת סלולרית - לא מספיק להבין שהארדואינו יבצע את הפעולות אחת אחרי השניה אלא להגדיר לארדואינו התחלת והפסקת ביצוע.

בעזרת פקודת listen או end מגדירים לארדואינו להתחיל "להקשיב" לרכיב ה GPS או לרכיב התקשורת הסלולרית או מגדירים לו "לסיים את ההקשבה" ולעבור הלאה. זה קצת מוזר אבל אם לא "סיימנו להקשיב" לתקשורת הסלולרית, הארדואינו לא יעבור הלאה לקריאת ה GPS. הוא כביכול ימשיך לרוץ הלאה ב Loop אבל לא באמת יבצע פקודות שקשורות לרכיב התקשורת השני. 

אז אחרי העזרה הענקית שקיבלתי מ ihsan (שוב תודה רבה!!) הכל היה הרבה יותר פשוט. מוכנים להתחיל?

רכיבים: 

• לוח ארדואינו אונו
• מטריצה וכמה חוטים 
• רכיב GPS מסוג Neo-6M או Neo-7M
• רכיב תקשורת סלולרית מסוג Sim800L
• כרטיס Sim
• אנטנת GPS

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

כמה הערות לתרשים: 

1. כאשר חיברתי את ה Neo-6M ל 5V - רכיב התקשורת הסלולרית לא הצליח לקבל מספיק מתח כדי לעבוד. אולי אצלכם זה יהיה שונה אבל גיליתי שהוא מסתדר מצוין עם 3.3V אז הבעיה נפתרה.. 
2. בתרשים ציירתי סוללה של 9V, בפועל השתמשתי ב"מטען נייד" (Power bank) של 5000mA. עבד מעולה והחזיק את המערכת ליותר מ 24 שעות של תקשורת סלולרית ברצף!
3. Neo-6M: 
1. החוט האדום - VCC
2. החוט השחור - GND
3. החוט הסגול - RX
4. החוט הצהוב - TX

כעת, לפני הקוד, נוריד את אפליקציית Blynk ונתקין אותה (כי רק איתה נוכל להשלים את הקוד ולמלא את מה שחסר). לאחר ההתקנה נפתח את התכנה וניצור משתמש חדש על ידי לחיצה על Create New Account.

נכניס מייל וסיסמא ונלחץ על Sign Up:

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

במסך העריכה לחצו על + כדי להוסיף רכיבים לפרויקט. בחרו באפשרות של הוספת מפה (Map):

אחרי שהוספתם את המפה לתרשים תצטרכו להגדיר למפה חיבור וירטואלי V4:

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

השלב הבא יהיה להגדיר את ה APN שלכם. אם רכשתם כרטיס Sim יעודי עבור הפרויקט הזה, אני ממליץ להכניס אותו למכשיר טלפון "אמיתי" כדי להגדיר את כל ההגדרות הנכונות. חברת הסלולר שלכם אמורה לשלוח SMS של הגדרות תקשורת שיותקנו על גבי כרטיס ה Sim. ההגדרות ישמרו על הכרטיס גם לאחר שתעבירו את הכרטיס לרכיב Sim800L.

אם אתם משתמשים בכרטיס של הטלפון שלכם - תוכלו לבצע מיד את השלב הבא:

פתחו את ההגדרות של מכשיר הטלפון שלכם וחפשו את פרטי ה APN שלכם. אצלי זה נמצא תחת הגדרות>>> כרטיסי SIM & רשתות סלולריות>>> GOLAN T>>> שמות של נקודות גישה >>> פרטי APN. אצלכם זה יכול להופיע כמובן בתפריט שונה בהתאם למכשיר הסלולר שברשותכם אולם זה פחות או יותר הכיוון. בסופו של דבר אתם אמורים לראות את פרטי ה APN, במקרה שלי: internet.golantelecom.net.il

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

(אם ממש ממש נתקעתם ולא מצאתם את ה APN שלכם - תוכלו להתקשר לספק הסלולר שלכם ולשאול אותו מה ה APN שלכם). 

אחרי שעדכנתם את ה APN שלכם ואת ה auth שלכם, אתם יכולים להעלות את הקוד לארדואינו:

#define BLYNK_PRINT Serial #define TINY_GSM_MODEM_SIM800 #include <TinyGsmClient.h> #include <BlynkSimpleSIM800.h> #include <TinyGPS++.h> char auth[] = "YOUR auth"; char apn[] = "YOUR apn"; char user[] = ""; char pass[] = ""; #include <SoftwareSerial.h> static const int RXPin2 = 2, TXPin2 = 3; SoftwareSerial SerialAT(RXPin2, TXPin2); // RX, TX static const int RXPin = 4, TXPin = 5; static const uint32_t GPSBaud = 9600; SoftwareSerial ne06mgps(RXPin, TXPin); TinyGPSPlus gps; WidgetMap myMap(V4); TinyGsm modem(SerialAT); void setup() { Serial.begin(9600); delay(10); ne06mgps.begin(9600); delay(10); SerialAT.begin(38400); delay(10); SerialAT.listen(); delay(100); Serial.println("SERVERA BAGLANILIYOR"); Blynk.begin(auth, modem, apn, user, pass); Blynk.virtualWrite(V3,"SISTEM BAGLANILIYOR"); SerialAT.end(); delay(3000); } void loop() { ne06mgps.listen(); while (ne06mgps.available() > 0) if (gps.encode(ne06mgps.read())) konumgonder(); Serial.println("gpsencode okundu"); delay(10); } void konumgonder() { if (gps.location.isValid()) { float enlem = (gps.location.lat()); float boylam = (gps.location.lng()); Serial.print("ENLEM: "); Serial.println(enlem, 6); Serial.print("BOYLAM: "); Serial.println(boylam, 6); ne06mgps.end(); SerialAT.listen(); Blynk.virtualWrite(V3,"KONUM BULUNDU"); Blynk.virtualWrite(V1, gps.location.lat() ,6); Blynk.virtualWrite(V2, gps.location.lng(), 6); myMap.location(1, gps.location.lat(), gps.location.lng(), "KONUM"); Blynk.virtualWrite(V5, gps.speed.kmph()); SerialAT.end(); }else{ ne06mgps.end(); SerialAT.listen(); Serial.println("baglanamadi"); Blynk.virtualWrite(V3,"KONUM ARANIYOR"); delay(1000); Blynk.virtualWrite(V3,"BEKLEYİNİZ"); delay(1000); SerialAT.end();} }


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

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

מה אפשר לעשות עם זה?

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

ולסיום - תודה שוב ל ihsan שבלעדיו היינו תקועים כנראה עוד המון המון זמן... תודה!!

בהצלחה!

שליטה על steadicam - תיעוד פרויקט...

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

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

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

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

אז מה עושים?

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

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

(מסומן בעיגול: הרגל שנשברה)

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

עוד בדיקות אחרונות - וה steadicam עובד!

יצירת קובץ STL מסריקת CT - חלק ב'

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

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

אבל אין המון ברירה, אז נשתמש בה צעד אחר צעד...

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

לאחר ההתקנה, נפתח את התכנה, נמחק את הקוביה המיותרת במרכז התכנה ונבצע import לקובץ שלנו:

דפדפו לתיקייה הנכונה, בחרו בקובץ שלכם ואל תשכחו ללחוץ בסוף על Import:

תנשמו עמוק:

Zoom in / Zoom out - מבצעים באמצעות גלילת העכבר.
שינוי זווית ההסתכלות - משנים באמצעות לחיצה על Ctrl ותוך כדי על המספרים 1 או 3 שב numpad, כלומר, במקלדת הימנית של המספרים.

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

בשלב הבא, נעבור למצב עריכה כדי לטפל במודל שלנו:

כאשר אנחנו במצב עריכה, נלחץ לחיצה אחת בעזרת לחצן ימני בעכבר על אזור גדול במודל אותו אנו רוצים להשאיר. לאחר מכן נלחץ על Ctrl L על מנת לבחור את מה שעליו לחצנו. המטרה שלנו היא לבחור את רוב המודל, ללא השאריות והדברים המיותרים:

כעת, נלחץ על Ctrl I על מנת להפוך בחירה, כלומר, לבחור בכל הדברים המיותרים והלא חשובים...

ולסיום נלחץ על Delete כדי להסיר את החלקים הלא רצויים.

לאחר שהסרנו את כל החלקיקים הלא רצויים, נחזור למצב Object Mode ונראה מה יצא לנו עד כאן:

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

בחלונית ה Repeat נזין ערך בין 20 ל 50 בערך. השאיפה שלנו היא להזין ערך נמוך יחסית כדי לפגוע כמה שפחות בדיוק של המודל:

כעת, אפשר לייצא את הקובץ:

והקובץ מוכן להדפסה...

(בתמונה: הקובץ בתכנת Cura עם תמיכות אוטומטיות של התכנה).

בהצלחה!!