פרוססינג

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

https://processing.org/download/

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

void setup(){

}

void draw(){

}

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

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

הנה דוגמה לשתי תוכנות טיפוסיות בפרוססינג:

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

ממשק שליטה בארדואינו

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

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

זה מה שקורה בצד של המחשב בתוכנת הפרוססינג:

וזה מה שקורה בצד של הארדואינו :

לחיצה על 13 מדליקה אור אדום, 12 מדליקה אור ירוק וששניהם לחוצים יש אור צהוב.

בנוסף שלוחצים על הכפתור בג’ויסטיק פין מספר 2 הופך לירוק.

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

קוד

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

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

משחק פונג

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

והנה הקוד

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

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

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

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

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

קצר

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

הקטע הזה חשוב מאוד ולא ממש ברור למתחילים. הרי הפלוס אמור ללכת למינוס אז מה הבעיה? הבעיה היא שלפי חוק אוהם זרם שווה מתח חלקי התנגדות i=v/r . בטריה של 9 וולט עם התנגדות אפסית במעגל תיתן לנו זרם אינסופי או לפחות את הזרם הגבוה ביותר שהבטריה יכולה לספק.

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

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

רכיבים חמים אש

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

ישנה גם האפשרות שלא קראנו את גליון הנתונים שלו וחיברנו לא נכון. חיפוש בגוגל של:

tsop ir receiver connection מוצא את התמונות הבאות:

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

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

חיבור קבל הפוך

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

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

בבטריות אצורה אנרגיה

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

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

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

חיבור ממסרים

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

מכות שריטות וחתכים

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

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

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

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

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

יש גם חיבורים חיצוניים לכל הרכיבים – למסך יש חיבורי I2C לתקשורת וחיבור מתח, יש חיבורים ללוח מקשים לרמקול למיקרופון ולבטריה.

החיבור המעניין שנוסף הוא אפשרות לתכנת את הבקר ושם יש את החיבורים RX,TX,RESET,3.3V,GND. ככה אפשר לשנות את התוכנה שנמצאת עליו עם כל מתכנת UART או עם ארדואינו אונו, ובנוסף לעשות דיבאגינג.

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

#include "Adafruit_FONA.h"
#include <Keypad.h>
#include <Wire.h>
#include <SoftwareSerial.h>
#include "ssd1306.h"
#define FONA_RX 2
#define FONA_TX 3
#define FONA_RST 4
SoftwareSerial fonaSS = SoftwareSerial(FONA_TX, FONA_RX);
SoftwareSerial *fonaSerial = &fonaSS;
Adafruit_FONA fona = Adafruit_FONA(FONA_RST);
const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#', 'D'}
};

int counter = 0;
char number[11];
byte rowPins[ROWS] = {5, 6, 7, 8}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {9, 10, 11, 12}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){
  fonaSerial->begin(9600);
  if (! fona.begin(*fonaSerial)) {
    while (1);
  }
Wire.begin();
ssd1306_128x64_i2c_init();
ssd1306_fillScreen(0x00);
ssd1306_setFixedFont(ssd1306xled_font6x8);
ssd1306_printFixedN (8, 8, "ARDUPHONE", STYLE_BOLD, FONT_SIZE_2X);
}

void loop(){
  char key = keypad.getKey();
  if (key){ // if press any key
    if (key == 'A' ){ 
    fona.pickUp(); // answer phone
   }
  else if(key == 'B'){ // make a call
    counter = 0; // initialize counter array
    fona.callPhone(number);
  }
  else if(key == 'C'){ // clear display and initialize counter
    ssd1306_fillScreen(0x00);
    ssd1306_printFixedN (8, 8, "ARDUPHONE", STYLE_BOLD, FONT_SIZE_2X);
    counter = 0;
    for(int i=0;i<11;i++){
      number[i] = ' ';
    }
  }
else if(key == 'D'){ // hang up phone
fona.hangUp();
}
  else{
    number[counter] = key; // put the key in number
    ssd1306_printFixedN (0, 50, number, STYLE_NORMAL, FONT_SIZE_2X);
    counter = counter + 1; // go up counter
    delay(500); // delay for buttons
  }
 }
}

יש בעולם שלושה סוגים של הלחמות – הלחמות יפות, הלחמות מכוערות והלחמות כל כך מגוחכות שזה מצחיק. ההלחמה פה שייכת לסוג השלישי:

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

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

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

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

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

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

שם הפרויקט: צמיד לאיתות על התקפי אפילפסיה

יוצרת הפרויקט: בת-ציון מצגר

תחום הפרויקט: ארדואינו

דרגת קושי: בינוני

תיאור הפרויקט:

פרויקט גמר להנדסאי אלקטרוניקה

צמיד אפילפסיה

נחמה בת-ציון מצגר

תשע”ח – 2018

מנחים: מר מוטי מאיר ומר גאורגי שרייבמן

תוכן עניינים – 2

תודות – 3

תקציר הפרויקט – 4

הצעת פרויקט – 5

תרשים מלבנים – 6

שרטוטים חשמליים -8

הסברי רכיבים חשמליים – 11

מיקרו-בקר (ארדואינו ננו)-11

מד תאוצה -12

משדר / מקלט בתדר רדיו – 15

ממיר לוגי – 16

תצוגת LCD –16

פרוטוקולי תקשורת

19- i²c

26 – UART

תיעוד הבניה – 28

התוכנה – 37

מדידות – 43

סיכום ומסקנות – 44

תודות

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

לאבי, שחינך אותי לאהבת ידע. לאמי, שלמדה אותי ללמוד.

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

לצוות החינוכי והלימודי בסמינר “אופק” על העידוד והעזרה לאורך כל הדרך.

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

תקציר הפרויקט

מבוא:

אפילפסיה (Epilepsy ) המכונה גם כפיון או “מחלת הנפילה” היא הפרעה נוירולוגית כרונית, הנגרמת מפעילות חשמלית לא תקינה בתאי העצב במוח בנוירונים ומובילה לפרכוסים ולעוויתות התקפים.

על-פי מידע שאסף מרכז המחקר והמידע של הכנסת מארבע קופות החולים, נכון לינואר-פברואר 2017 יש בישראל 81,597 מבוטחים שאובחנו כחולי אפילפסיה, נתון התואם את הערכת משרד הבריאות, לפיה שכיחות המחלה באוכלוסייה עומדת על כ-1%. בהינתן שמספר החולים באפילפסיה בישראל עומד על 81,597 אזי מדובר על בין 9 ל-10 חולים ל-1,000 נפש באוכלוסייה.

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

הצגת פרויקט:

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

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

1. יש צורך בהשגחה צמודה שפוגעת בעצמאות של המטופל.
2. בזמן שינה אין אפשרות להשגיח על החולה.

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

בשביל זה אשתמש בארדואינו אונו וחיישן תאוצה ב-3 צירים BMI160 לזהות תנועת חזקות. במקרה שיזוהה התקף תשלח הודעה לצג.

חזון: פיתוח חיישנים שיאתרו 100% מההתקפים בהתאמה אישית.

הצעת פרויקט:

צמיד לזיהוי התקפי אפילפסיה

תיאור הפרויקט

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

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

הפרויקט יכיל את הרכיבים הבאים:

צמיד:

מיקרו-בקר (ארדואינו ננו)

משדר / מקלט בתדר רדיו

מד תאוצה

מקור אנרגיה – סוללה (li-po 3v-4.2v)

תחנה:

מיקרו בקר (ארדואינו אונו)

משדר / מקלט בתדר רדיו

תצוגת LCD

תרשים מלבנים

הסבר תרשים מלבנים

מכשיר למטופל:

מכשיר מעוצב בצורת צמיד שמתלבש על היד של חולה. הרכיב כולל:

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

חיישן תאוצה- מזהה תנועות חזקות שהן המאפיין העיקרי של התקפי אפילפסיה.

משדר/מקלט בתדר רדיו- משדר את הנתונים לתחנה.

תחנה:

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

ארדואינו אונו – לעיבוד הנתונים.

משדר/מקלט בתדר רדיו – קולט את הנתונים מהצמיד.

צג LCD – מציג התרעה בזמן של התקף, כולל משך הזמן והנחיות לקריאה לעזרה ראשונה.

שרטוטים חשמליים

צמיד:

תחנה:

הסבר סרטוט חשמלי

בתחנה ה-HC11 מחובר לרגל D0 שהיא רגל עם תמיכה חומרתית לתקשורת טורית. וה-LCD מחובר ל-A5 ו-A4 שהם רגליים עם תמיכה חומרתית ל- I²C.

בצמיד ה-HC11 מחובר לרגלים D6 ו-D7 שהם הרגלים עם תמיכה חומרתית לתקשורת טורית. ה-BMI צורך מתח של 3.3v ולכן הוא מחובר לממיר לוגי . ל-tx1 ו-rx1 של הצד של 3.3v. tx2 מחובר, כרגל פסיקה.

וה-tx1 וה-1rx של הצד של ה-5v מחוברים ל-A5 ו-A4 שהם רגליים עם תמיכה חומרתית ל- I²C. tx2 מחובר לרגל 2 שמוגדרת כרגל פסיקה.

הסברי רכיבים

מיקרו-בקר (ארדואינו ננו)

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

הכרטיס ארדואינו אונו הינו מיקרו-בקר מבוסס מעבד Atmel ATmega328 . הארדואינו אונו בעל 20 רגליים דיגיטליות של קלט/פלט. מתוכם ניתן להשתמש ב-6 כפלט PWM .לכרטיס זה יש 6 רגליים אנלוגיות ו- 1 ports serial. כמו כן לכרטיס יש את כל הנדרש לתמיכה מלאה במיקרו-בקר כלומר: כניסת USB ,מייצב מתח. מפרט הכרטיס

• מיקרו-בקר: ATmega 328p
• מתח הפעלה: V5
• מתח כניסה מומלץ: 7v-12v
• מתח כניסה אפשרי: 6v-20v
• 20 רגליים דיגיטליות לקלט/פלט
• 6 רגליים לקלט אנלוגי
• זרם DC לרגל דיגיטלית של קלט/פלט: 40mA
• זרם DC לרגל דיגיטלית של 3.3 V: 50mA
• זיכרון פלאש KB32
• זיכרון KB: SRAM 2
• זיכרון KB: EPROM 1
• מהירות שעון: 16mhz

בכרטיס קיימים מספר רגליים של מתח:

• VIN – חיבור למתח חיצוני
• הדק בעל V5 מהמייצב שעל הכרטיס
• הדק בעל V3.3 מהמיצב שעל הכרטיס
• הדק אדמה

הכרטיס תומך במספר סוגי תקשורת לדוגמא:

• Serial – לדוגמא שימוש בהתקן Bluetooth וב- serial monitor
• TWI – לדוגמא לחיבור חיישנים

לכרטיס יש פסיקות בפינים 2,3

מד תאוצה

מד תאוצה הוא חיישן המשמש למדידת תאוצה קוויות. כלומר, במנוחה, גם כשאינו נע ונמצא על פני השטח של כדור הארץ ימדוד תאוצה של כ-m/s²‏ 9.81 (מטר לשנייה בריבוע) בכיוון מטה, כתאוצת g בכוח הכובד.

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

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

בפרויקט אני משתמשת בחיישן 160BMI של חברת BOSTCH המורכב משלוש מדי תאוצה ושלושה ג’רוסקופים מסוג MEMS (ראשי תיבות של: Micro Electro Mechanical System , תרגום: “מערכת מיקרו אלקטרו מכנית”)

MEMS היא משפחה של טכנולוגיות, חומרים ומעגלים משולבים ברמות מיקרו וננו (NEMS), המכילות רכיבים ומערכות אלקטרוניות, מכניות, אופטיות (MOEMS) ביולוגיות, (BioMEMS) ופיזיקליות אחרות, כולם ממוזערות המאפשרות מגוון רחב מאוד של יישומים מתקדמים וחדשנים.

מאפיינים עיקריים:

• צריכת זרם נמוכה: 925μA
• מתח פעולה:  – 1.71V-3.6V
• מחסנית FIFO של 1024 בייט
• 2 הדקים עבור פסיקות חיצוניות שאפשר לתכנת לסוגים שונים של תנועה כמו יש תנועה/ אין תנועה וכו’

דיאגרמת מלבנים של החיישן:

הסבר תרשים מלבנים:

Accel- מד תאוצה בשלושה צירים

Gyro – ג’ירוסקופ בשלושה צירים

ADC – ממיר מאנלוג לדיגיטל

Digital signal conditioning- נרמול ערכים

Select- מרבב שבוחר בין מידע גולמי למידע מנורמל

Sensor time and sensortime register- קובע קצב דגימה

Fifo engine- מחסנית – first in first out שומר את המידע עד שהמעבד יתפנה אליו

Interrupt engine- פסיקות

Step counter – מונה צעדים

Primary digital interface- ממשקי תקשורת

איך מזהים תאוצה?

שלושת ה-MEMS נותנים את זווית הסטיה.

הערכים מחושבים לפי

Acc_x = 1g*sin(Ɵ)*cos(Ψ)

Acc_y = -1g*cos(Ɵ)*sin(Ψ)

Acc_z = 1g*cos(Ɵ)

הערך בררת-מחדל של כח g הוא 2±

בערך ברירת מחדל של הפסיקה shok() יש 0 – שנועל את הפסיקה אחרי פעם אחת.

shok() מפעילה פסיקה של low-g/high g

הערך המינימלי נקבע לפי רגיסטר /int-lowing כפול הערך לפי הטווח של כח g לפי ערכי ברירת מחדל במקרה שלנו זה יוצא:

7.81 mg*192=1.499G

HC11

משדר/מקלט בתדר רדיו

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

הרכיב משתמש בתקשורת UART ומשדר בטווח של 433.3MHZ – 473.3MHZ , אפשר להגדיר כמה ערוצים, כל אחד ברוחב של 400Khz, ויש 100 ערוצים בסך הכל. עוצמת השידור המקסימלית 20dBm (100mW), ומרחק התקשורת הוא 1000m בחלל פתוח.

לרכיב 6 רגליים:

• VCC- קבלת מתח
• GND – אדמה
• input UART – RXD
• output UART – TXD
• SET – רגל בקרה
• ANT- אנטנה

ה-default mode הוא FU3 . בmode זה קצב ההעברה הוא מקסימלי, והוא כולל התאמה אוטומטית לקצב השידור בארדואינו.

קצב ברירת מחדל של השידור הוא 9.6 Kbps

ערוץ ברירת המחדל הוא 001 וקצב העבודה הוא 433.3MHz

ממיר לוגי:

סרטוט חשמלי:

לרכיב יש 3 מצבים:

1. שני צידי הקו נמצאים במצב של ‘1’. במקרה זה לכל צד יש את רמת המתח שלו כי ה- MOSFET לא מוליך.

2. כאשר צד 1 (הצד של ה 3.3v) נמצא ב- ‘0’ . במקרה זה הMOSFET מוליך (הדיודה בנתק) ונקבל על הקווים של צד 2 (הצד של 5v) ‘0’.

3. כאשר כאשר צד 2 (הצד של ה 5v) נמצא ב ‘0’ . במקרה זה ה-MOSFET לא מוליך. אבל הדיודה נכנסת להולכה. מפל המתח על הדיודה הוא כ- 0.7v שעדיין מוגדר כ ‘0’. לכן נקבל על הקווים של צד 1 ‘0’.משדר / מקלט רדיו

תצוגת LCD

LCD – LIQUID CRYSTAL DISPLAY – תצוגת גביש נוזלי שמורכבת מתמיסות אורגניות במצב נוזלי שמשנות את תכונותיהן האופטיות בהשפעת שדה חשמלי. ישנם כמה סוגים של תצוגות LCD :

1 .תאורה טבעית- צג אשר חייב להיות מואר מבחוץ על מנת לראות את התצוגה.

2 .תאורה מלאכותית- ה- LCD מואר ע”י נורה פנימית קבועה שמחוברת אליו.

3 .תאורה אחורית- ה- LCD מואר ע”י משטח פלורסנטי המותקן מאחוריו

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

מאפיינים:

• צריכת זרם נמוכה ביותר (nA).
• משקל קל.
• אורך חיים גבוה.
• ניתן לייצור בצורות שונות.

תצוגת LCD שרטוט ותמונה

תיאור מפורט של רגלי ה:LCD

• VSS – רגל אדמת המעגל
• VDD- רגל המחוברת למתח ההזנה של 5V.
• RS – רגל זו תפקידה לבחור באחד משני האוגרים. כאשר מספקים לרגל זו ‘0’ האוגר ישמש כאוגר הוראות וכאשר נספק ברגל זו ‘1’ אוגר זה ישמש כאוגר הנתונים, משמש להפרדה בין תהליך תכנות התצוגה 1=RS , ותהליך כתיבה לתצוגה
• W/R – תפקיד רגל זו הוא לקבוע האם יכתבו או יקראו נתונים. כאשר מספקים ‘1’ לרגל זו הנתונים המאוכסנים ב- RAM של התג”נ יקראו. כאשר מספקים ‘0’, יכתבו נתונים ל-RAM של התג”נ.
• E – רגל אפשור הרכיב. ב-‘0’ הרכיב לא יאופשר. ב-‘1’ הרכיב יאופשר.
• רגליים DB0 – DB7 – זהו פס נתונים של התצוגה ברוחב של 8 סיביות. תפקיד פס הנתונים הוא העברת נתונים או פקודות אל התג”נ מהמיקרו בקר ולהיפך.

Register Instruction- אוגר הוראות אוגר זה תפקידו לאכסן הוראות הקובעות את אופן הפעולה של התג”נ הוראות אלה יכולות להיות: הזזת סמן, ניקוי התצוגה, כיבוי תצוגה, הדלקת התצוגה וכו’.

Register Data- אוגר הנתונים אוגר זה הינו אוגר זמני אשר בו מאכסנים את כל הנתונים שאותם רוצים להציג על התצוגה. כדי להציג נתון שולחים את התו של ב ASCII

הרכיב PCF8574 מתאם LCD

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

הרכיב PCF8574 הוא דו כיווני. כלומר, אפשר גם לשדר לו מידע (בגודל byte ) טורי שיופיע במפתח המקבילי (P0-P-7 ) ולהפך אפשר גם לקרוא את המידע שנמצא במפתח המקבילי (P0-P-7 ).

לרכיב PCF8574 יש 3 הדקי כתובת A2 , A1 , A0 . כלומר, ניתן ליצור 8 כתובות שונות.

התקשורת עם הרכיב נעשית באמצעות פרוטוקול I2C.

פרוטוקולי תקשורת

I²C

משמש לתקשורת בין הארדואינו ל-BMI160 ל-LCD

התקן נועד לאפשר תקשורת טורית בין במחשב (Master) ובין מספר Slaves .

המטרה של הפרוטוקול היא לספק “הסכם מסגרת”, כלומר, הפרוטוקול מסדיר את אופן התקשורת בין שני משתמשים (Master and Slave). הפרוטוקול לא מתייחס ל- DATA אלא רק מגדיר מתי ואיך יש לשדר את ה- DATA. (סיבית אחת בכל מחזור שעון , 8 סיביות מידע בין שני אישורים).

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

• • • 1. קו הנתונים SDA – Serial Data)).
      2. קו דופק השעון – SCL ( (Serial Clock.

ניתן לחבר על זוג החוטים עד 128 התקנים (Slaves) שונים ובמקביל.

חיבור של מספר רכיבי SLAVE אל MASTER

לכל רכיב/מודול/חיישן יש כתובת ייחודית משלו.

ה- Master בשלב ראשון מוציא את הכתובת הייחודית של רכיב מסוים, רכיב שמזהה שזו הכתובת שלו, ‘מאשר’ את זיהוי הכתובת והוא זה שיתקשר עם Master .

כל שאר הרכיבים נשארים במצב של ‘נתק’ מהקווים.

דופק השעון שעל קו SCL מיוצר רק ע”י ה- Master והוא זה שקובע את קצב העברת הנתונים.

בקו SDA מעבירים בצורה טורית את הכתובות ואת הנתונים שבין ה-Master וה- Slaves.

כאשר אין תקשורת, שני הקווים SDA ו- SCL נמצאים במצב של ‘1’ קבוע, ולכן ניתן לשנות את קו המידע SDA רק כאשר קו השעון SCL נמצא בנמוך.

המידע על ה- SDA צריך להיות יציב בזמן שקו השעון SCL נמצא בגבוה.

אם יש שינוי על קו המידע SDA בזמן שקו השעון SCL גבוה אז :

-מעבר מ- HIGH ל- LOW פירושו START

-מעבר מ- LOW ל- HIGH פירושו STOP ,

.STOP במקום repeated START ,SDA ניתן לשים על קו המידע

מצב המתנה- ה- Slave יכול להוריד את ה- SCL, ל- LOW ובכך ליצור מצב של WAIT ל- Master.

Ack:

כל מילה חייבת להסתיים בביט תשיעי של Ack) .Acknowledgement)

השעון של ה- Ack מיוצר ע”י ה- Master.

בזמן Ack המשדר שם מתח-צף על ה- SDA , והמקלט שם LOW על ה- SDA.

כאשר ה- Slave לא משדר Ack על כתובתו (כי הוא לא יכול, למשל) הוא שם מתח-צף על ה- SDA בשביל לשחרר את הקו ל- Master אשר בוחר עם לחדש את ההתקשרות עם הרכיב הנוכחי אם לא. כאשר ה- Slave משדר Ack על כתובתו, אך שם-לב במהלך המשך ההתקשרות כי הוא לא יכול להמשיך לקלוט מידע. אז הוא משדר Not-Ack בביט התשיעי של המילה הבאה. אח”כ הוא שם מתח-צף על ה- SDA בשביל לשחרר את הקו ל- Master אשר בוחר עם לחדש את ההתקשרות עם הרכיב הנוכחי אם לא.

אם המשדר של ה- Master מעורב בתהליך ההתקשרות, אזי בסוף המידע ה- Master לא שולח Ack למשדר של ה- Slave בביט התשיעי של המילה הבאה. ה- Slave שם מתח-צף על ה- SDA בשביל לשחרר את הקו ל- Master אשר בוחר אם לחדש את ההתקשרות עם הרכיב הנוכחי אם לאו.

השלבים ביצירת תקשורת ע”י Master:

שלב 1:

פעולת Start – הורדת קו SDA ל ‘0’ כאשר קו SCL עדיין נמצא במצב ‘1’ קבוע.

הדק של התקן:

שלב 2:

ה Master משדר על קו ה SDA 7 סיביות של כתובת (סיבית הMSB נשלחת ראשונה) + סיבית שמינית המודיעה לרכיב, האם ה Master רוצה לכתוב מידע לרכיב (‘0’) או לקרוא מידע מהרכיב (‘1’).

שלב 3:

הרכיב שזו כתובתו, מגיב ב ‘אישור’, כלומר ב Acknowledge .

ה Acknowledge מתבטא בהורדת קו SDA ל ‘0’ למשך דופק שעון אחד.

אם אין Acknowledge , ה Master יסיים את התקשורת בפעולת stop .

שלב 4:

בעקבות Acknowledge , המעבד כותב (או קורא) נתונים בגודל Byte (8 סיביות) לרכיב.

אחרי כל שידור בין ה Master ובין Slave יש לקבל Acknowledge.

שלב 5:

שלב סיום התקשורת – פעולת Stop מתבצעת על ידי העלאת קו SDA ל ‘1’ כאשר קו SCL במצב ‘1’.

ישנם סוגים סונים של תקשורת:

1. ה- Master הוא המשדר לאורך כל ההתקשרות והוא כותב ל- Slave .

1. ה- Master יוזם את ההתקשרות בשביל לקרוא מה- Slave.
2. ה- Master יוזם את ההתקשרות בשביל לקרוא ולכתוב ל- Slave. (שילוב של 1 ו-2) .

תקשורת טורית UART

משמש לתקשורת בין הארדואינו ננו ל ארדואינו אונו, הUART יכול לשדר ולקלוט מידע בו זמנית. כלומר, לעבוד ב Full-Duplex .

התקשורת היא ‘אסינכרונית’ (Asynchronic) כלומר שהמשדר יכול לשדר בכל עת והמקלט חייב להיות מוכן תמיד לקבלת מידע מהמשדר. זאת ללא הודעה מוקדמת וללא תלות ב ‘שעון’.

פרוטוקול התקשורת (הנוהל להעברת נתונים)

כאשר ה UART משדר ‘תו’ , פרוטוקול התקשורת שה UART מבצע הוא כמוראה באיור הבא:

שלב א – ה UART משדר . START BIT =0 = התחלת שידור. הסבר: כאשר אין העברת מידע המצב בקו השידור הוא ‘1’. ברגע שהUART מתחיל לשדר, הוא מוריר את הקו ל ‘0’. הירידה מ ‘1’ ל ‘0’ מאפשרת למקלט להסתנכרן על התחלת השידור.

שלב ב’ – ה- UART משדר את 8 סיביות המידע ( הסיבית הראשונה היא סיבית ה LSB)

שלב ג’ – ה- UART משדר STOP BIT אחד או שניים. (STOP BIT = 1)

לכל סיבית מוקצה ‘זמן סיבית’ ( BIT TIME ) שהוא קבוע ומוסכם מראש. זמן הסיבית נקבע ע”י ה- Baud Rate (קצב העברת הסיביות בקו). כלומר, כמות הסיביות העוברות בקו בשנייה אחת. ( (Bits per second. הקצב המקובל הוא 2400, 4800 ,9600 , 14400, 19200, 38400, 57600 , 115200 ביטים \ לשניה. אולם קצב ההעברה יכול להיות גם כל קצב אחר שנבחר.

כאמור, לאדואינו UNO יש רכיב UART מובנה בתוך המיקרובקר. הדק 0 של הארדואינו משמש כקו התקשורת הטורית לקליטה – RXD . והדק 1 משמש כקו התקשורת הטורית לשידור – TXD .

לארדואינו יש חוצץ (buffer ) של 64 בתים לאחסון המידע שנקלט בתקשורת הטורית.

הפונקציה () Serial.available מחזירה את מספר התווים שנקלטו בחוצץ.

תיעוד הבניה

5 בנובמבר

קיבלתי את חיישן הbmi  ותרגלתי קריאת נתונים ועבודה עם הספריה של החיישן

void loop() {

int16_t ax, ay, az; //scaled accelerometer values

// read accelerometer measurements from device, scaled to the configured range

BMI160.getAcceleration(&ax, &ay, &az);

// display tab-separated accelerometer x/y/z values

Serial.print("a:\t");

Serial.print((float)ax/16384.0);

Serial.print("\t");

Serial.print((float)ay/16384.0);

Serial.print("\t");

Serial.print((float)az/16384.0);

Serial.println();

delay(500);

}

ה-bmi וארדואינו על המטריצה:

14 בנובמבר

כתבתי תוכנית שמזהה כוחות ג’י בעוצמה חזקה.

בעיה: צריך לנטרל את ההשפעה של כח הכבידה של כדור הארץ

הערה: לא הצלחתי לפתור את הבעיה הזאת

if(interrupt){

if(BMI160.getIntShockStatus())

{

if(BMI160.getXNegShockDetected()&&absgx<20)

{

num++;

}

if(BMI160.getXPosShockDetected()&&absgx<20)

{

num++;

}

if(BMI160.getYNegShockDetected()&&absgy<20)

{

num++;

}

if(BMI160.getYPosShockDetected()&&absgy<20)

{

num++;

}

if(BMI160.getZNegShockDetected()&&absgz<20)

{

num++;

}

if(BMI160.getZPosShockDetected()&&absgz<20)

{

num++;

}

}

interrupt=false;

}

20 בנובמבר

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

אתחולים של הפסיקה shock()

BMI160.attachInterrupt(shock);

BMI160.setIntShockEnabled(true);

ובלולאה זה נראה כך:

void shock() {

interrupt = true;

}

בעיה: הפונקציה מפעילה את ה- interrupt  פעם אחת ואז ‘נתקעת’

27 בנובמבר

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

פתרון: לאתחל בערך אחר.

BMI160.setInterruptLatch(BMI160InterruptLatchMode(BMI160_LATCH_MODE_10_MS));

הרכבנו את ה-LCD והצמיד

25 בדצמבר

חיברנו את המשדר/מקלט HC11 ובדקנו שהתקשורת עובדת.

1 בינואר

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

התוכנית:

#include <Wire.h>
void setup()
{
Wire.begin();

Serial.begin(9600);

while (!Serial);             // Leonardo: wait for serial monitor

Serial.println("\nI2C Scanner");

}

void loop()

{

byte error, address;

int nDevices;

Serial.println("Scanning...");

nDevices = 0;

for(address = 1; address < 127; address++ )

{

// The i2c_scanner uses the return value of

// the Write.endTransmisstion to see if

// a device did acknowledge to the address.

Wire.beginTransmission(address);

error = Wire.endTransmission();

if (error == 0)

{

Serial.print("I2C device found at address 0x");

if (address<16)

Serial.print("0");

Serial.print(address,HEX);

Serial.println("  !");
nDevices++;

}

else if (error==4)

{

Serial.print("Unknown error at address 0x");

if (address<16)

Serial.print("0");

Serial.println(address,HEX);

}

}

if (nDevices == 0)

Serial.println("No I2C devices found\n");

else

Serial.println("done\n");


delay(5000);  // wait 5 seconds for next scan

}

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

void loop()

{

if (millis() - tmpTime > 5000 ) {

delay(100);

lcd.clear();

tmpTime = millis();

while (Serial.available() > 0) {

lcd.write(Serial.read());

tmpTime = millis();

}

}

4 באפריל

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

צמיד:

if (ifEpilepsy(false)) {

counter = 0;

Serial.println("1");

}

בתחנה:

void loop()

{

while (Serial.available() > 0) {

  if ( Serial.parseInt() == 1) {

    epilepsy=true;

    if(call == false){

      lcd.clear();

      lcd.print("epilepsy");

      counter++;

      if (counter == 1)

        tmpTime = millis();

      }

   }

}

if(epilepsy){

  lcd.setCursor(0, 1);

  lcd.print((millis()-tmpTime)/1000);

}

if (millis() - tmpTime > 30 * 1000 ) {

  if(counter > 3){

     if(call==false){

       lcd.clear();

       lcd.print("Call 101");

      call = true;

  }

}

  else{

  lcd.clear();

   epilepsy=false;

  }

 }

}

10 במאי

שיניתי את הקוד כך שאם ההתקף נגמר הטיימר על השעון נגמר ויש כיתוב “epilepsy is over”

וכן הוספתי את הקוד ל-buzzer

התוכנה

התוכנה בצד של התחנה:

הסבר:

יש 2 דגלים – ‘epilepsy’ בודק אם התחיל התקף אפילפסיה, כלומר אם התקבלה התרעה מהצמיד

ו-“call” שבודק אם עברו שלושים שניות מתחילת ההתקף, סיטואציה התחייבת הזעקת עזרה ראשונה.

בלולאה התוכנה בודקת כל הזמן אם יש תקשורת טורית ואם כן אם מגיע ‘1’ – מעדכן את הדגל של ‘epilepsy’ לאמת. אם אנחנו לא במצב של call מדפיס epilepsy על הצג ומפעיל אזעקה ומעלה את המונה. אם זו הפעם הראשונה – שומרת את השעה במשתנה עזר.

אם ‘epilepsy’ באחד לוגי, התוכנה מדפיסה את השניות על המסך

אחרי שלושים שניות, אם המונה שווה לשלוש ומעלה, מציבים ב-‘call’ אחד לוגי, מודפס על המסך “Call 101”

אם לא, מודפס “epilepsy is over”

הקוד:

#include <Wire.h>// I2C כולל את הספריה לתקשורת  

#include <LiquidCrystal_I2C.h>// כולל את הספריה של הצג

const int BUZZER = 8;//משתנה סטאטי בוזר 

// Set the LCD address to 0x27 for a 16 chars and 2 line display

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup()

{

lcd.begin();//מפעיל את הצג

lcd.backlight();//מדליק את האור האחורי

// Initialize the serial port at a speed of 9600 baud

Serial.begin(9600);

pinMode(BUZZER, OUTPUT);//קובע את רגל 8 לפלט

digitalWrite(BUZZER, LOW);//שם אפס לוגי ברגל 8

}

unsigned long tmpTime ;

int counter = 0;

boolean epilepsy = false;

boolean call = false;

void loop()

{

while (Serial.available() > 0) {//כל עוד יש קריאה ספרתית

if ( Serial.parseInt() == 1) {//אם זוהה מספר ברצף של הקלט

epilepsy=true;

if(call == false){

lcd.clear();//מנקה את הצג

lcd.print("epilepsy");//מדפיס 'אפילפסיה' על הצג

counter++;

if (counter == 1)//אם זו הפעם הראשונה, שם במשתנה עזר את השעה

tmpTime = millis();

}

}

}

if(epilepsy){

lcd.setCursor(0, 1);//מסדר את השורות בצג

lcd.print((millis()-tmpTime)/1000);//מדפיס את השניות

}

if (millis() - tmpTime > 30 * 1000 ) {//אם עברו פחות משלושים שניות

if(counter > 3){//אם היו יותר משלוש התרעות

if(call==false){

lcd.clear();//נקה את הצג

lcd.print("Call 101");

digitalWrite(BUZZER, HIGH);//הפעל את הצפצפה

call = true;

}

}

else{

lcd.clear();

lcd.print("epilepsy is over");

epilepsy=false;

}

}

}

התוכנה בצד של הצמיד:

הסבר:

בהתחלה מופעלת הפסיקה ()shock שמייצרת פסיקה עבור תנועה חזקה.

יש דגל interrupt שעולה ל-1 כל פעם שהפסיקה מופעלת. בלולאה, כל פעם ש- interrupt =1 מופעלת הפונקציה ifEpilepsy כך שתעדכן את הזמן הנוכחי ותעלה את ה- counter. אחר כך ifEpilepsy מופעלת כך שתבדוק אם עברו שש שניות. אם כן, היא מחזירה אמת והלולאה תשדר ‘1’. אם לא, היא מאפסת ה- counter.

#include <BMI160.h>//כולל את הספריה של המד תאוצה

#include <BMI160Gen.h>// כולל את הספריה של המד תאוצה

#include <BMI160Gen.h>

#include <Wire.h>//I2C כולל את הספריה לתקשורת 

const int bmi160_i2c_addr = 0x69;//קובע את כתובת המד תאוצה

const int bmi160_select_pin = 10;

const int bmi160_interrupt_pin = 2;//קובע את רגל שתיים לפסיקות מהמד תאוצה

int16_t tr = 0, num = 0;

unsigned long startMillis; //some global variables available anywhere in the program

unsigned long currentMillis;

const unsigned long period = 1000;

void setup() {

Serial.begin(9600); // initialize Serial communication

// initialize device

Serial.println("Initializing IMU device...");

Wire.begin();

BMI160.begin(BMI160GenClass::I2C_MODE, bmi160_i2c_addr, bmi160_interrupt_pin);

uint8_t dev_id = BMI160.getDeviceID();

Serial.print("DEVICE ID: ");

Serial.println(dev_id, HEX);

BMI160.attachInterrupt(shock); //קישור הפסיקה לפונקציה

BMI160.setIntShockEnabled(true);//הפעלת הפסיקה

BMI160.setInterruptLatch(BMI160InterruptLatchMode(BMI160_LATCH_MODE_10_MS));//הגדרת זמן הפסיקה

startMillis = millis();

Serial.println("Initializing IMU device...done.");

Serial.println(BMI160.getIntShockEnabled());

}

boolean interrupt = false;

int counter = 0;

void shock() {

interrupt = true;

}

unsigned long epilepsyLoop;

boolean ifEpilepsy(boolean firstTime) {//פונקציה בוליאנית שמקבלת משתנה בוליאני

if (firstTime)

epilepsyLoop = millis();

if (millis() - epilepsyLoop <= 6000) {//בודק אם עברו 6 שניות

if (counter > 2)

return true;

}

else

counter = 0;

return false;

}

void loop() {

if (interrupt) {

counter++;

if (counter == 1)

ifEpilepsy(true);

interrupt = false;

}

if (ifEpilepsy(false)) {

counter = 0;

Serial.println("1");

}

}

מדידות

בדקתי את המתח המסופק מהסוללה.

ואחרי המייצב מתח

המייצב מספק מתח יציב אם כי לא בדיוק את ה-3.3v שהוא אמור לספק.

סיכום ומסקנות

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

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

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

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

הייתי רוצה של-buzzer יהיו 2 צפצופים שונים שיבדילו בין התחלה התקף לבין התקף ארוך שדורש הזעקת עזרה ראשונה.

שם הפרויקט: מד מרחק עצמאי

יוצר הפרויקט: רועי שימרון

רכיבים:

– מודול מד מרחק HC-SR04
– מסך Nokia 5110
– כבלים
– 3 נגדים של קילו אוהם
– מטריצה
– רספברי פי

תיאור הפרויקט:

אלה החיבורים של הרספברי פיי אל המסך והחיישן והמסך

כדי להפעיל את הפרויקט, יש להוריד את קובץ הזיפ הבא, לחלץ אותו ולהעביר אל הפיי.

קוד לפרויקט

הקוד שיש להריץ הוא Image.py. במידה ויש שגיאות, סביר להניח שזו תוצאה של ספריות חסרות על הפיי, אפשר להוריד ספריות באופן הבא:

Terminal -> sudo apt-get install (name)

בנוסף, חשוב מאוד להפעיל את ה-SPI של הרספברי. הפעלה זו היא דרך raspiconfig בטרמינל או דרך ההגדרות בממשק המשתמש.
לאחר ההכנות הנ”ל, כדי להריץ את הקוד צריך ללחוץ על הכפתור הירוק של פליי בעורך של הקוד.
הקוד עצמו מפורט מאוד, מלא בהערות שמסבירות את התהליך. יש שימוש עיקרי בשני קבצים: Image הראשי ו- Dis המשני.
הראשון מציג תמונה על המסך והשני מחשב מרחק בעזרת החיישן.
בהצלחה

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

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

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

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

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

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

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

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

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

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

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

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

• זכרון הבזק – הוא נקרא גם זכרון FLASH ותפקידו להחזיק את התוכנה שהמשתמש כותב. הזכרון הזה הוא בלתי נדיף כלומר המידע נשאר עליו גם כשמכבים את הארדואינו, לארדואינו אונו יש 32KB של זכרון הבזק שמתוכם 1K שמורים לתוכנת BOOTLOADER . תוכנה זו רצה ברקע ומחכה לפקודת העלאה בכל זמן נתון ולכן אפשר למחוק ולעלות קוד חדש בכל רגע נתון אל הארדואינו. זכרון ההבזק של ארדואינו משמש מעין דיסק קשיח למרות שהוא עובד בטכנולוגיה שונה. אם ננסה להעלות קוד גדול מ-32KB הארדואינו יראה שגיאה ולא יעלה את הקוד.
• זיכרון דינמי – זהו זכרון RAM ופה קורה כל האקשן. כל המשתנים של התוכנה נמצאים פה והם מתווספים ונמחקים באופן דינמי לפי מה שכתוב בתוכנה. בארדואינו אונו יש לנו 2KB של זכרון דינמי וצריך להיזהר לא לצרוך יותר מהכמות הזאת. הקומפיילר לא יכול לדעת מראש איזה משתנים יתווספו לזכרון לכן הוא נותן להעלות את הסקיצה בכל מקרה אבל אם נצרוך יותר מידי הוא יתנהג בצורה לא צפויה ויקרוס. הזכרון הדינמי הוא נדיף ונמחק ברגע שמכבים את הארדואינו. זכרון RAM הוא המהיר ביותר מבין כל הסוגים וגם היקר ביותר לכן הוא קטן יחסית.
• זכרון EEPROM – עוד זכרון פנימי קטן שמשמש בעיקר לשמירת הגדרות תצורה שנשמרות בצורה בלתי נדיפה גם כשמכבים את הארדואינו. הטכנולוגיה שלו דומה מאוד לזכרון הבזק אבל השימוש בו שונה, אפשר לכתוב ולקרוא ממנו בכל עת מתוך התוכנה שכתבנו. בארדואינו אונו יש לנו 1KB מהזכרון הזה.

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

כשמכניסים קוד אל סביבת הפיתוח ולוחצים על כפתור בצע אימות מתבצעת קומפילציה וישנו חישוב שמראה בכמה זכרון אנחנו משתמשים. אפשר לראות בתחתית הקובץ שרק הספריה עצמה של GSM לוקחת 30% מזכרון FLASH ו-38% מזכרון RAM , וזה עוד לפני שכתבנו קוד להשתמש בספריה. הספריות שאנשים כותבים לארדואינו חלקן קלות משקל וחלקן כבדות ונראה בהמשך שהן לא חקוקות בסלע ואפשר לשנות את הספריות וגם לכתוב ספריות משלנו לפי הצורך.

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

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

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

char message[6] = "hello";

כאן אנחנו מקצים מראש 6 תווים למשתנה שנקרא message המקום מוקצה בזכרון וזוהי השיטה הנפוצה בשפת תכנות C עליה מבוססת שפת תכנות ארדואינו. הסיבה שאנחנו מקצים שישה תווים ולא חמישה היא שמחרוזת חייבת להסתיים בסימן 0\ שאומר למחשב שהיא הסתיימה דבר שקורא אוטומטית ואנחנו חייבים לשמר לתו הזה זכרון.

בשפת ארדואינו אפשר להשתמש בטיפוס String בצורה הבאה:

String x = "Hello world";

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

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

const int button = 2;

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

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

Serial.begin(9600);

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

שמירת מידע בזכרון FLASH

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

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

#include <avr/pgmspace.h>

const byte x[] PROGMEM = {34,78,12,89};

void setup() {
  Serial.begin(9600);
  
  Serial.println(pgm_read_byte(x));
  Serial.println(pgm_read_byte(x+1));
  Serial.println(pgm_read_byte(x+2));
  Serial.println(pgm_read_byte(x+3));
}

void loop() {

}

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

#include <avr/pgmspace.h>

const char text[] PROGMEM = "Once upon a time, a man and his wife had the good fortune to have a goose which laid a golden egg every day.
Lucky though they were, they soon began to think they were not getting rich fast enough.They imagined that if the bird is able to lay
golden eggs, its insides must be made of gold. And they thought that if they could get all that precious metal at once,
they would get mighty rich very soon. So the man and his wife decided to kill the bird.";

void setup() {
  Serial.begin(9600);
  
  for(int i=0;i<450;i++){
    char c = pgm_read_byte(text+i);
    Serial.print(c);
    delay(200);
  }

}

void loop() {}

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

int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}

קריאה וכתיבה אל EEPROM

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

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

בדוגמה הבאה אנחנו צורבים את המספר הסידורי ואת הגרסה:

#include <EEPROM.h> // include eeprom library
char serialNumber[22] = {'I','D',':','1','5','4','3','7','1','4',' ','V','E','R','S','I','O','N',':','1','.','3'}; // create char array
void setup() {
 for (int i = 0; i < 22; i++){ 
 EEPROM.write(i, serialNumber[i]); // write each char to eeprom memory
 }
}

void loop() {}

הזכרון EEPROM מתחיל מ-0 ונגמר ב- 499 בארדואינו אונו, כלומר יש לנו 500 בייט שאפשר לצרוב עליו. תו הוא בייט אחד אז אנחנו צורבים 22 בייט, כאמור int הוא 2 בייט, float הוא 4 בייט אז צריך לשים לב איפה אנחנו נמצאים בזכרון.  במקרה הזה צורבים לזכרון פעם אחת ואז אפשר להכניס לסקיצה אחרת אפשרות לקרוא את המספר הסידורי והגרסה:

#include <EEPROM.h>
char x[22]; // create char array x
void setup() {
 Serial.begin(9600);
 for (int i = 0; i < 22; i++){
    x[i] = EEPROM.read(i); // put in the array eeprom content
 }

 for (int i = 0; i < 22; i++){
   Serial.print (x[i]); // print to screen to verify
 }
}

void loop() {}

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

#include <EEPROM.h> // include eeprom library
int currentScore = 0; // current score of player
int highestScore;
void setup() {
 byte high = EEPROM.read(0); // read the first byte
 byte low = EEPROM.read(1); // read the second byte
 highestScore = word(high,low); // create word type
 }

void loop() { // during the game 
 if (currentScore > highestScore){ // if player passes highest score
 EEPROM.write(0,highByte(currentScore)); // write first byte to eeprom
 EEPROM.write(1,lowByte(currentScore)); // write second byte to eeprom
 }
 }

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

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

void setup(){
for (int i = 0; i < 500; i++) {
     EEPROM.write(i, 0);
   }
}
void loop(){}

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

רכיבים:

1 ארדואינו אונו

1 מודול מקליט קול ISD1760

1 רמקול קטן 0.5W 8Ω

1 בטריה 9V

1 מחזיק בטריה 9V

תיאור הפרויקט:

התוכי חוזר אחרי כל מה שאומרים לו ממש נודניק קטן.

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

SCK --> digital pin 13
* MISO --> digital pin 12
* MOSI --> digital pin 11
* SS --> digital pin 10

המודול עובד על מתח 2.5V עד 5.5V אז חשוב לא לתת לו יותר מזה, אני מספקת לו 5 וולט מארדואינו.

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

הנה קוד לתפעול המודול דרך ארדואינו , צריך לשלוח תו מחלון תקשורת טורית. R מקליט ו- Y מנגן את ההקלטה.

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

#include <ISD1700.h>

ISD1700 chip(10); // Initialize chipcorder with
                  // SS at Arduino's digital pin 10

void setup()
{
  Serial.begin(9600);
  Serial.println("Sketch is starting up");
}

void loop()
{
  char c;
  
  if(Serial.available())
  {
    /* Power Up */
    chip.pu();
    c = Serial.read();
    switch(c)
    {
       case 'A':
         Serial.println(chip.rd_apc(), BIN);
         break;         
       case 'Y':
         chip.play();
         break;
       case 'P':
         chip.stop();
         break;
       case 'E':
         chip.erase();
         break;
       case 'R':
         chip.rec();
         break;
       case 'F':
         chip.fwd();
         break;
       case 'Z':
         chip.g_erase();
         break;
       case 'I':
         Serial.println(chip.devid(), BIN);
         break;
    }
    Serial.print("Status---> ");
    Serial.print(chip.CMD_ERR()? "CMD_ERR ": " ");
    Serial.print(chip.PU()? "PU ": " ");
    Serial.print(chip.RDY()? "RDY ": "Not_RDY");
    Serial.println();
    delay(1000);
  }
}

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

קוד להפעלת התוכי המדבר

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

שתי הערות לשים לב:

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

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

הפעם נעבוד עם דוחף לדים MAX7221 וארדואינו וניצור מטריצה עם 64 לדים.

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

אלה הרגליים שלו:

שלושת רגלי התקשורת הם DIN, LOAD, CLK ומתחברות לארדואינו בצורה הבאה –

DIN > פין 12 בארדואינו

CLK > פין 11 בארדואינו

LOAD > פין 10 בארדואינו

+V > הוא מקור המתח של 5V ואם נרצה להדליק יותר מכמה נורות הוא צריך גם לספק מספיק זרם לפחות 2 אמפר. כל נורה לוקחת בערך 20mA אז אפשר לחשב.

GND> צריך להיות משותף עם ארדואינו

ISET > פה שמים נגד אחד ששומר על הנורות הערך שלו צריך להיות פחות או יותר 20K, אפשר לחבר שני 10K בטור.

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

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

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

שימו לב לחיבור של הנורות כי זה יכול קצת לבלבל בהתחלה. הפלוס של העמודות מחובר ביחד והמינוס של השורות מחובר ביחד.

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

#include "LedControl.h"
LedControl lc=LedControl(12,11,10,1);
void setup(){
    lc.setLed(0,0,0,true); // turn first row first column on
    delay(1000);
    lc.setLed(0,1,0,true); // turn second row first column on
    delay(1000);
    lc.setLed(0,0,1,true); // turn first row second column on
    delay(1000);
}
void loop(){}

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

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

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

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

#include "LedControl.h"

LedControl lc=LedControl(12,11,10,1);

void setup() {
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,8);
  /* and clear the display */
  lc.clearDisplay(0);
  for (int i=0;i<8;i++){
    lc.setRow(0,i,B11111111);
    delay(1000);
    lc.clearDisplay(0);
  }
  for (int i=0;i<8;i++){
    lc.setColumn(0,i,B11111111);
    delay(1000);
    lc.clearDisplay(0);
  }
}

void loop() {
// put your main code here, to run repeatedly:

}

כמו שאפשר לראות לספרייה יש פונקציות מוכנות להדלקת שורות ועמודות.

עכשיו נעשה קצת אנימציות:

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

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

RFID היא טכנולוגיה לזיהוי על ידי תדר רדיו קצר. שני השחקנים העיקריים הם קורא (Reader) ותג זיהוי (tag).

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

לכל תג יש זכרון של לפחות 1KB ובתוכו החלק החשוב ביותר הוא ה-ID שהוא מה שמזהה את התג מתגים אחרים.

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

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

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

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

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

/*
 * 
 * All the resources for this project: http://randomnerdtutorials.com/
 * Modified by Rui Santos
 * 
 * Created by FILIPEFLOP
 * 
 */
 
#include <SPI.h>
#include <MFRC522.h>
 
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
 
void setup() 
{
 Serial.begin(9600); // Initiate a serial communication
 SPI.begin(); // Initiate SPI bus
 mfrc522.PCD_Init(); // Initiate MFRC522
 Serial.println("Approximate your card to the reader...");
 Serial.println();

}
void loop() 
{
 // Look for new cards
 if ( ! mfrc522.PICC_IsNewCardPresent()) 
 {
 return;
 }
 // Select one of the cards
 if ( ! mfrc522.PICC_ReadCardSerial()) 
 {
 return;
 }
 //Show UID on serial monitor
 Serial.print("UID tag :");
 String content= "";
 byte letter;
 for (byte i = 0; i < mfrc522.uid.size; i++) 
 {
 Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
 Serial.print(mfrc522.uid.uidByte[i], HEX);
 content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
 content.concat(String(mfrc522.uid.uidByte[i], HEX));
 }
 Serial.println();
 Serial.print("Message : ");
 content.toUpperCase();
 if (content.substring(1) == "BD 31 15 2B") //change here the UID of the card/cards that you want to give access
 {
 Serial.println("Authorized access");
 Serial.println();
 delay(3000);
 }
 
 else {
 Serial.println(" Access denied");
 delay(3000);
 }
}

עכשיו פותחים חלון תקשורת טורית ובודקים מה המספר הייחודי של התג, ואז מחליפים אותו במקום BD 31 15 2B. ברגע שאנחנו יודעים את מספר התג אפשר לעשות מה שרוצים – להדליק נורות להשמיע זמזום וגם לפתוח מנעול חשמלי.

#include <SPI.h>
#include <MFRC522.h>
 
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
 
void setup() 
{
 Serial.begin(9600); // Initiate a serial communication
 SPI.begin(); // Initiate SPI bus
 mfrc522.PCD_Init(); // Initiate MFRC522
 Serial.println("Approximate your card to the reader...");
 Serial.println();
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);

}
void loop() 
{
 // Look for new cards
 if ( ! mfrc522.PICC_IsNewCardPresent()) 
 {
 return;
 }
 // Select one of the cards
 if ( ! mfrc522.PICC_ReadCardSerial()) 
 {
 return;
 }
 //Show UID on serial monitor
 Serial.print("UID tag :");
 String content= "";
 byte letter;
 for (byte i = 0; i < mfrc522.uid.size; i++) 
 {
 Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
 Serial.print(mfrc522.uid.uidByte[i], HEX);
 content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
 content.concat(String(mfrc522.uid.uidByte[i], HEX));
 }
 Serial.println();
 Serial.print("Message : ");
 content.toUpperCase();
 if (content.substring(1) == "CC 54 62 A3") //change here the UID of the card/cards that you want to give access
 {
 Serial.println("Authorized access");
 Serial.println();

digitalWrite(3, HIGH);
 tone(4, 300, 500);
 delay(100);
 tone(4, 3000, 500);
 delay(2000);
 digitalWrite(3, LOW);
 }
 
 else {
 Serial.println(" Access denied");
 digitalWrite(2, HIGH);
 tone(4, 3000, 500);
 delay(100);
 tone(4, 300, 500);
 delay(2000);
 digitalWrite(2, LOW);
 
 }
}

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

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

תיאור הפרויקט:

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

רכיבים:

• 1 ארדואינו אונו
• 4 מיקרו סרוו SG90
• חיישן אולטראסוני
• זמזם 5V
• 4 בטריות AA
• מחזיק 4 בטריות
• קבצי הדפסת תלת מימד
• PLA בצבע האהוב עליכם
• מדפסת תלת מימד
• מברג פיליפס

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

ניתן למצוא שם גם את החמוד שאני הדפסתי והכנתי להנאתכם.

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

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

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

RX/TX

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

אם אנחנו רק רוצים שארדואינו ישלח מידע לארדואינו אחר אנחנו מחברים את הדק TX בארדואינו שמשדר אל הדק RX בארדואינו שמקבל את המידע. TX זה קיצור של TRANSMIT ו-RX קיצור של RECEIVE.

כמה דברים צריכים לקרות שזה יעבוד:

• קודם כל האפס(GND) שלהם חייב להיות משותף
• שניהם צריכים כמובן להיות מחוברים למקור מתח. אפשר לחבר אחד מהם למחשב ואז להעביר 5V לשני כמו בתמונה, או לחבר את שניהם למחשב.
• קצב העברת הנתונים שתכף נדבר עליו חייב להיות זהה בשניהם
• כשמעלים קוד לארדואינו המחשב משתמש בהדקים 0 ו-1 אז צריך לעשות את החיבורים רק אחרי גמר העלאת הקוד אחרת הוא לא יעלה.
• שניהם צריכים לעבוד באותו מתח לוגי. ארדואינו אונו עובד על 5V אז אין בעיה אבל יש הרבה בקרים שעובדים על 3.3V ובמקרה הזה נהיה חייבים להשוות את רמות המתח ויש כל מיני דרכים לעשות את זה.

עכשיו לקוד. הארדואינו המשדר מידע

void setup() { 
 Serial.begin(9600);
}

void loop() {
 
 Serial.write(1);
 delay(5000);
 Serial.write(0);
 delay(5000);
}

כל חמש שניות הוא שולח בייט שונה פעם 0 ופעם 1. Serial.write היא פונקציה שונה במקצת מ-Serial.print והיא מיועדת לשליחת בייטים בצורה יותר גולמית. זה לא ממש משנה באיזה משתמשים אבל רצוי מאוד לקרוא על ההבדלים ביניהם.

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

void setup() {
 Serial.begin(9600);
 pinMode(13, OUTPUT);
}

void loop() {
 if (Serial.available() > 0){
   int x = Serial.read();
   if (x == 1){
     digitalWrite(13, HIGH);
   }
  else{
   digitalWrite(13, LOW);
   }
 }
}

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

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

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

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

void setup() { 
 Serial.begin(9600);
 pinMode(13, OUTPUT);
 Serial.write(1);
}

void loop() {
 if (Serial.available() > 0){
   int x = Serial.read();
   if (x == 1){
     digitalWrite(13, HIGH);
     Serial.write(1);
   }
   else{
     digitalWrite(13, LOW);
     Serial.write(0);
   }
 }
 delay(1000);
}

והארדואינו השני עונה לו:

void setup() {
 Serial.begin(9600);
 pinMode(13, OUTPUT);
}

void loop() {
 if (Serial.available() > 0){
   int x = Serial.read();
   if (x == 1){
     digitalWrite(13, HIGH);
     Serial.write(0);
   }
   else{
     digitalWrite(13, LOW);
     Serial.write(1);
   }
 }
 delay(1000);
}

יאה ונאה…

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

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

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

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

#include <SoftwareSerial.h>
 SoftwareSerial port1(6, 7); // RX, TX
 int zero = 0;
 void setup() {
   port1.begin(150000);
   pinMode(13, OUTPUT);
   port1.write(1);
 }

void loop() {
 if (port1.available() > 0){
   int x = port1.read();
   if (x == 1){
     digitalWrite(13, HIGH);
     port1.write(1);
   }
   else{
     digitalWrite(13, LOW);
     port1.write(zero);
   }
 }
 delay(1000);
 }

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

#include <SoftwareSerial.h>
SoftwareSerial port2(6, 7); // RX, TX
int zero = 0;
void setup() {
 port2.begin(150000);
 pinMode(13, OUTPUT);
}

void loop() {
 if (port2.available() > 0){
   int x = port2.read();
   if (x == 1){
     digitalWrite(13, HIGH);
     port2.write(zero);
   }
 else{
   digitalWrite(13, LOW);
   port2.write(1);
   }
 }
 delay(1000);
}

וכמובן נחליף את החיבורים בשני הארדואינו ל-6 ו-7 . יש באג קטן בספרייה שבו צריך להצהיר על 0 כמשתנה int אז גם את זה עשינו. לגבי המהירות אני הצלחתי ליישם את זה גם עם 150000bps אבל זה בגלל שמעבירים בייט גולמי אחד, אם ננסה להעביר משהו יותר ארוך זה יקרוס ונצטרך להוריד את המהירות לאיזור 50000bps.

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

SoftwareSerial port1(2, 3);

SoftwareSerial port2(4, 5);

SoftwareSerial port3(6, 7);

זה מאוד נוח לעבוד עם הספריה הזאת אבל מנסיון אני אומר צפו לבעיות אם יש הרבה חיבורים שונים. יש שני דברים שחסרים לי מאוד בארדואינו אונו ואחד מהם זה UART נוסף. השני זה חיבורים נוספים של 5V על הלוח.

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

I2C

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

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

קודם כל צריך לזכור שב-I2C וגם SPI החיבורים הולכים אחד לשני כלומר A4 ל-A4 ו-A5 ל-A5 שלא כמו בתקשורת טורית רגילה.

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

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

#include <Wire.h>
void setup() {
 Wire.begin(); 
}
void loop() {
 Wire.beginTransmission(1); // talk to device number 1
 Wire.write(1); // send the number 1
 Wire.endTransmission(); 
 delay(5000);
 Wire.beginTransmission(1); 
 Wire.write(0);
 Wire.endTransmission();
 delay(5000);
}

אפשר כאן לראות שאנחנו מתחילים תקשורת עם רכיב מספר 1 שזה מספר שרירותי מ-0 עד 255. ברוב הדוגמאות המספר יופיע בצורה של HEX נגיד 0x27. פה יש לנו שליטה על ה-SLAVE אז אפשר להכניס איזה מספר שאנחנו רוצים רק לזכור לתת אותו לבקר השני.

הבקר שיוצר תקשורת שולח בייט שווה ערך למספר 1 , מחכה 5 שניות ואז שולח אפס.

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

#include <Wire.h>
int x;
void setup() {
 pinMode(13, OUTPUT);
 Wire.begin(1); 
 Wire.onReceive(receiveEvent); 
}

void loop() {
 if (x == 1) {
   digitalWrite(13, HIGH);
 }
 else{
   digitalWrite(13, LOW);
 } 
}


void receiveEvent() {
 while ( Wire.available()) { 
   x = Wire.read(); 
 }
}

בתקשורת RX/TX רגילה התזמון הוא אסינכרוני אז לא חייבים פונקציה כמו פה.

כל מי שמכיר את פרוטוקול I2C ישאל איפה נגדי ה-PULLUP המפורסמים לא צריך אותם? התשובה היא שהם קיימים בתוך ההדקים A4, A5 והספריה כבר מדליקה אותם בשבילנו.

ככה אפשר לתקשר עם בקרים שונים בתיאוריה עד 255 בקרים כשכולם מחוברים במקביל אל הדקים A4, A5 או SDA,SCL לחילופין.

אם רוצים ליצור תקשורת דו כיוונית כלומר שה-slave ישלח מידע חזרה אז מי שצריך לנהל את זה הוא ה-Master ולבקש מידע חזרה כמו בדוגמה הבאה באתר ארדואינו.

כמו שנאמר בתקשורת I2C ו-SPI הכל צריך להיות מתוזמן נכון עם פונקציות שמחכות ברקע.

SPI

התקשורת השלישית שניישם היא SPI .

יש לפחות שלושה חוטים שצריכים להיות מחוברים בתקשורת SPI:

• (MOSI) : פין 11
• (MISO) : פין 12
• (SCK) : פין 13

פין 10 הוא זה שבוחר את ה-Slave ויש צורך להשתמש בו כשמחברים יותר מרכיב אחד.

שימו לב לשישיית המחברים מצד ימין. הם נקראים ICSP ( In Circuit Serial Programming) והם נותנים אפשרות לתכנת את הארדואינו בפרוטוקול SPI. אפשר להשתמש בהם לתקשר עם ארדואינו אחר למעשה זה לא ממש משנה כי הם מחוברים במקביל לפינים 11,12,13 כך שבכל מקרה לא נצליח ככה לחסוך את ההדקים לשימוש אחר.

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

זה הקוד של הארדואינו המשדר:

#include <SPI.h>

void setup (void) {
 digitalWrite(SS, HIGH); // disable Slave Select
 SPI.begin ();
 SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
 char c;
 digitalWrite(SS, LOW); // enable Slave Select
 // send test string
 for (const char * p = "Hello, world!\r" ; c = *p; p++) {
   SPI.transfer (c);
   Serial.print(c);
 }
 digitalWrite(SS, HIGH); // disable Slave Select
 delay(1000);
}

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

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
 Serial.begin (115200);
 pinMode(MISO, OUTPUT); // have to send on master in so it set as output
 SPCR |= _BV(SPE); // turn on SPI in slave mode
 indx = 0; // buffer empty
 process = false;
 SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) {
 byte c = SPDR; // read byte from SPI Data Register
 if (indx < sizeof buff) {
   buff [indx++] = c; // save data in the next index in the array buff
   if (c == '\r') //check for the end of the word
     process = true;
 }
}

void loop (void) {
 if (process) {
   process = false; //reset the process
   Serial.println (buff); //print the array on serial monitor
   indx= 0; //reset button to zero
 }
}

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

הקוד נלקח ושופצר מהקישור הבא שמוסבר בו בפירוט איך עובד פרוטוקול SPI.

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

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

אין דבר טוב יותר מלקום בשישי בבוקר ולבנות טלפון עם ארדואינו

המטרה: לבנות טלפון סלולרי תוך 4 שעות עם ארדואינו

הרכיבים:

• ארדואינו פרו מיני 3.3V
• מודול סלולרי sim800
• מיקרופון אלקטרט
• לוח מקשים
• רמקול קטן 8Ω
• מסך OLED
• בטריה נטענת 3.7V

דרגת הקושי: קשה

התוצאה: כשלון חרוץ

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

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

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

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

והנה דוגמה למודול קטן בהרבה כמעט ללא רכיבים:

לפני הכנת הפרויקט צריך להחליט אם רוצים שהטלפון יהיה נייד או נייח כי זה מה שיקבע את רמת המתח שניתן למערכת, אם הוא נייד זה הגיוני להשתמש בבטריה נטענת ליתיום יון או ליתיום פולימר 3.7V עם לפחות 2000mAh . למה כל כך הרבה זרם? כי מודול סלולרי צורך הרבה זרם כשהוא מתחבר לרשת לעשות שיחה.

יש מודולים שאפשר לתת להם 5V מארדואינו אבל גם אז לא נוכל להשתמש בארדואינו שמקור המתח שלו הוא כבל USB (המחשב יכול לספק רק 500mA) מהמחשב אלא מקור מתח חיצוני כמו ספק כח 5V 2A .

בכל מקרה אני עובד פה עם המודול האדום למעלה וצריך לתת לו 3.5V-4.2V עם זרם של 2 אמפר. אפשר לעשות את זה עם ספק כח שמורד למתח הזה או ישירות עם בטריה 3.7V.

בעיה נוספת היא שמתח הלוגיקה(TX/RX) של SIM800 הוא 2.8V בעוד שארדואינו אונו עובד על 5V. אפשר לפתור את זה די בקלות עם נגדים מחלקי מתח לכל החיבורים בין המודול לארדואינו או עם ממיר מתח לוגי.

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

שימו לב לכל החיבורים. יש פה מקור מתח אחד של 3.7V.

לגבי המודול הוא פועל ברשת 2G ונבדק לעבוד כמו שצריך עם סלקום וגולן, אורנג’ גם אמור לעבוד אבל לא בדקתי.  מומלץ לקנות סים PRE-PAID שאפשר להשיג בכל פיצוציה ולמלא אותו בדקות.

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

אנטנה – יש אנטנה יעודית או שאפשר להלחים חוט בשקע NET.

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

כדי לשלוט בכל ההגדרות שלו דרך תוכנה הייתי ממליץ קודם כל על פקודות AT, ואפשר לעשות את זה עם ספריית aspen sim800 ולהשתמש בדוגמה bidirectional serial. את הספרייה אפשר להוריד מתוך מאגר הספריות דרך סביבת הפיתוח של ארדואינו.

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

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

fona.callPhone(“0530000000”); – מתקשר למספר

fona.pickUp(); – עונה לשיחה

fona.hangUp(); – ניתוק שיחה

fona.sendSMS(“0538888888”, “Hello”); – שליחת סמס

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

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

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

בלוח המקשים צריך להיות את כל המספרים + עוד כמה מקשים להוציא שיחה ולקבל שיחה. אני משתמש בכפתור A לענות לשיחה, כפתור B להתקשר למספר וכפתור C לנקות את המסך.

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

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

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

זה הקוד הבסיסי ביותר להפעלה של הטלפון:

#include "Adafruit_FONA.h"
#include <SoftwareSerial.h>
#include <Keypad.h>
#include <Wire.h>
#include <SeeedOLED.h>

#define FONA_RX 2
#define FONA_TX 3
#define FONA_RST 4

SoftwareSerial fonaSS = SoftwareSerial(FONA_TX, FONA_RX);
SoftwareSerial *fonaSerial = &fonaSS;
Adafruit_FONA fona = Adafruit_FONA(FONA_RST);
const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
 {'1','2','3','A'},
 {'4','5','6','B'},
 {'7','8','9','C'},
 {'*','0','#', 'D'}
};

int counter = 0;
char number[10];
byte rowPins[ROWS] = {5, 6, 7, 8}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {9, 10, 11, 12}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){
 fonaSerial->begin(9600);
 if (! fona.begin(*fonaSerial)) {
 while (1);
}
 Wire.begin(); 
 SeeedOled.init(); 
 SeeedOled.clearDisplay(); 
 SeeedOled.setNormalDisplay(); 
 SeeedOled.setPageMode(); 
 SeeedOled.setTextXY(0,0); 
 SeeedOled.putString("ready...");
}
 
void loop(){
 char key = keypad.getKey();
 if (key){
   if (key == 'A' ){
     fona.pickUp();
   }
   if(key == 'B'){
     counter = 0;
     SeeedOled.putString("dial");
     fona.callPhone(number);
   }
   if(key == 'C'){
     SeeedOled.clearDisplay();
     counter = 0;
   }
 else{
   number[counter] = key;
   SeeedOled.setTextXY(0,0);
   SeeedOled.putString(number);
   counter = counter + 1;
   delay(500);
   }
 }
}

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

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

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

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

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

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

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

סוגי משלוח:

• דואר רגיל – זהו משלוח של שגר ושכח. אתה שולח חבילה ומקווה שהיא תגיע, אם היא לא הגיעה אפשר להכריז עליה כאבודה לכן אני לא משתמש בסוג המשלוח הזה. המחיר של משלוח רגיל מתחיל משני שקל! ועולה לפי המשקל.
• דואר 24 – הדואר הזה מגיע די מהר ליעדו (24 שעות?? לא תמיד) אבל עוד פעם אין עליו רישום. עדיף כבר לשלם עוד כמה שקלים ולשלוח בדואר רשום. כרגע אני לא שולח איתו אבל יכול להיות שבהמשך אשקול לעבוד איתו.
• דואר רשום – זה הסוג המועדף על רוב החברות בארץ כי יש אפשרות לבדוק איפה החבילה. הוא מתחיל מ-13 שקל ועולה לפי המשקל של החבילה. מספר המעקב שאתם מקבלים הוא לא בזמן אמת כלומר אם חבילה יצאה מתל אביב ביום מסוים ואחרי חמישה ימים היא נמצאית בסינון חבילות בירושלים שתבדקו את המספר הוא יגיד “החבילה יצאה מתל אביב”. רק שזה יגיע לשלב של המסירה הסטטוס ישתנה.
• דואר רשום מהיר – השיטה הזאת היא מצוינת החבילה מגיעה מהר מאוד לכל חלקי הארץ ויש עליה מעקב בזמן אמת. הבעיה: אפשר לשלוח רק חבילות עד 50 גרם. אני אוטומטית שולח ברשום מהיר כל חבילה שאפשר לשלוח כדי לפנק את הלקוח זה יוצא רק שני שקל יותר מדואר רשום.
• דואר אקספרס – גולת הכותרת של דואר ישראל והגאווה הלאומית. המשלוח מגיע באותו יום אם נשלח עד 10 בבוקר ויום למחרת אם נשלח מאוחר יותר. המשלוח מתחיל מ-49 שקל ויש עליו מעקב בזמן אמת. באיזה שעה בדיוק הוא מגיע? רק השד יודע, בדרך כלל אחה”צ. אם אתם רואים במעקב המשלוח “שליח יצא לדרך” זה אומר שבשעות הקרובות הוא יגיע ואפשר להתחיל לחגוג. האם דואר אקספרס עומד בזמני ההגעה שהוא מבטיח? הייתי אומר ב- 80% מהמקרים שזה מכובד מאוד.

טיפים והערות:

• משלוחים שיוצאים אליכם ביום ראשון נוטים להגיע במהירות מפתיעה. אני לא יודע אם זה בגלל דוורים מלאי מרץ או סתם מזל אבל קרה לי כבר שהגיעו ביום שלישי! ככל שממשיך השבוע הדואר מוריד הילוך, חבילה שיוצאת בשלישי תגיע בדרך כלל ביום ראשון או שני שבוע הבא. הימים הבעייתיים הם רביעי וחמישי – קרה כבר שהוצאתי בחמישי והחבילה הגיעה ביום ראשון עשרה ימים אחרי. כל זה עומד עדיין בזמני דואר ישראל שמתחייבים ל-7 ימי עסקים כך שאין למי להתלונן.
• “חבילה גדולה” (שזה בשביל הדואר כל מה שגדול ממכתב) תגיע ברוב המקרים לאיזשהו סופר או פיצוציה באזור מגוריכם. בהתחלה זלזלתי ברעיון הזה אבל הוא לא רע בעיקר אם זה מגיע לסופר קרוב ולא למקום מרוחק.
• לפני שהולכים לדואר תעשו לעצמכם טובה ותקבעו תור מתוך האפליקציה של דואר ישראל.  את התור עדיף לקבוע לפחות ארבע שעות מראש אחרת זה כבר לא יתן לכם להזמין. לאחר שקבעתם תור אתם יכולים לבוא עד 10 דקות לפני התור ו-10 דקות אחרי התור אחרת הוא לא נחשב. הרעיון הזה היה מדהים כל עוד לא הרבה הכירו אותו ואני חגגתי עליו תקופה כשעקפתי את כל הפראיירים, אבל לאחרונה רוב האנשים עלו על השיטה והיא פחות אפקטיבית.
• ימים מסוכנים: ה-15 לחודש וה-28 לחודש הם ימים מסוכנים ביותר ולכן אסור להגיע בשום פנים לסניף הדואר. הסיבה- הבטחת הכנסה, קצבאות ארוכות טווח ודמי אבטלה. בימים האלו הדואר הומה אדם ויש שם בלאגן מוחלט, תעשו לעצמכם טובה ואל תבואו לסניף, אני כבר למדתי לעקוף את המערכת ואני מוציא משלוחים גם בימים האלה.
• אפשר לעשות שירות חדש בדואר ישראל של כתובת דואר וירטואלית עם שירות box2go. זהו שירות שבו החבילה מגיעה ללוקרים של תחנת דלק פז/yellow ואתם מקבלים מסרון לאסוף אותה. זה עולה 9 שקל לכל חבילה וכל מה שצריך לעשות זה להרשם באתר ואז לתת לחנות השולחת את הכתובת הוירטואלית במקום את זאת של הבית שלכם. נשמע מעניין.
• כתובת של עסק או מגורים בארץ היא המלצה בלבד. להרבה עסקים אין כתובות מדויקות או שיש אבל הדוור לא מכיר אותם, לכן תמיד לשים מספר טלפון סלולרי על החבילה ששולחים או כשעושים את הקנייה. מספר טלפון הוא הרבה יותר חשוב היום מכתובת.
• כתובת של בית מגורים או עסק קוראים משמאל לימין ככה: רחוב צ’וקומוקו 25/4 זה אומר: רחוב צ’וקומוקו מספר 25 דירה 4. ולא צ’וקומוקו מספר 4 דירה 25. זה ברור אבל יש אנשים שלא יודעים את זה.
• כתובת הנמען צריכה להיות תמיד על גב המעטפה וכתובת השולח מקדימה.
• שירות לקוחות: למעשה אין דבר כזה בדואר ישראל אז עדיף לא לנסות. לבלוע את הצפרדע ולהמשיך הלאה.

סיכום:

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

יש טכנולוגיה או נושא חדש שאנחנו לא מכירים. איך ללמוד אותו?

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

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

נעבור על שיטות הלמידה מהטובה ביותר ועד לשטחית:

• למידה פורמלית: זוהי למידה רשמית במוסד אקדמי מסוים והיא הטובה ביותר לדעתי. תכנית הלימודים מכריחה את התלמיד לעסוק בחומר ולבצע תרגילים ומבחנים כדי להוכיח את הידיעה. בשנים האחרונות יש פלטפורמות אונליין שכביכול מאיימות על האוניברסיטאות והמכללות אבל אני חושב שאין תחליף ללימוד מעמיק ומקצועי ממוסד אקדמי. כבונוס אתם גם מקבלים תעודה או תואר שבלעדיו יהיה לכם קשה למצוא עבודה. החסרון הוא שלא לכולם יש את הציונים המתאימים או נמצאים בגיל המתאים. בנוסף הידע הוא ממסדי לכן הרבה רעיונות חדשים מגיעים דווקא מחוץ לאוניברסיטה.
•   קריאה ויישום פרקטי: השיטה האהובה עליי ביותר היא קריאה של ספרים ויישום פרקטי של החומר הנלמד וכל זאת בצורה עצמאית. השיטה הזאת דורשת משמעת עצמית וסקרנות שאין לרוב האנשים לכן היא לא ממש פופולרית. קריאה של טקסט כתוב היא משהו שנעלם מן העולם אבל היא פעילות אקטיבית בניגוד לצפייה בסרט שהיא פעילות פסיבית. השיטה הזאת מצוינת למי שיש לו ריכוז גבוה ומסוגל לקרוא ספר(שזה לצערי מעט מאוד אנשים היום). את הספר קוראים פעם אחת ולאט בצורה מעמיקה ואז אפשר להתחיל לתרגל את הידע עם פרויקטים. יש חשיבות גם לתיאוריה וגם לפרקטיקה, אבל בסופו של דבר התרגול המעשי הוא החשוב ביותר. מומלץ בחום לקרוא ספר ממשי ולא דרך האינטרנט, באינטרנט וגם בקובץ PDF הקריאה פחות מעמיקה. המכשול פה בנוסף לחוסר הריכוז הוא שרוב הספרים הם באנגלית לכן מי שלא בקיא באנגלית תהיה לו בעיה.
• צפייה בסרטים ביוטיוב או פלטפורמה אחרת: זאת האפשרות הפופולרית ביותר אצל חבר’ה צעירים אבל בהחלט לא הטובה ביותר ללימוד מעמיק של חומר. היא טובה מאוד כדי לראות חיבורים פיזיים של משהו וגם כדי לקבל מושג כללי על נושא חדש אבל אני לא משתמש בה ללמידה רצינית. אם בחרתם ללמוד דברים דרך סרטונים ביוטיוב אז תדעו שזה יביא אתכם לרמה נמוכה עד בינונית כלשהי אבל לא יותר מזה. זה קל נורא, פשוט לוחצים על כפתור ואז מקשיבים למישהו מסביר ורואים מה הוא עושה. הלמידה היא למידה פסיבית לכן החומר לא נתפס במוח, יוצרי הסרטונים הם בדרך כלל חובבנים שלא יודעים להסביר או פוסחים על פרטים חשובים. זה לא דורש הרבה אנרגיה והחוק אומר שכמה שנשקיע יותר אנרגיה במשהו התוצאות יהיו טובות יותר, לכן אנרגיה נמוכה  = תועלת נמוכה.
• למידה מאתרים באינטרנט: אתרים כמו insructables וגם בלוגים אחרים היא משהו שהרבה אנשים משתמשים בו בהתחלה כדי להבין משהו מסוים. זה נחמד כדי ליצור פרויקט מסוים (שבדרך כלל לא עובד כי הכותב החובבן שכח להזכיר איזה פרט ) ובאמת הרבה אנשים מצליחים לשחזר משם את הפרויקטים אבל למידה של החומר? ממש לא.

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

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

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

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

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

שם הפרויקט: שלושה רובוטים קטנים ונחמדים

יוצר הפרויקט: רונית יער

דרגת קושי: קל

רכיבים:

• ארדואינו נאנו
• מנועי סרוו
• הדפסות תלת מימד

תיאור הפרויקט: 

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

שם הפרויקט: סרט לד שמגיב למוזיקה

יוצר הפרויקט: דולב פרל

דרגת קושי: בינוני

רכיבים:

• ארדואינו נאנו
• חיישן קול
• פס לדים צבעוני RGB

סרטון הדגמה:

שם הפרויקט: המתופף

דרגת קושי: קל

רכיבים:

• 1 ארדואינו אונו
• 2 מיקרו סרוו
• קובץ תלת מימד

תיאור:

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

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

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

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

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

אז שלום לימור ולהתראות אדהפרוט על כל הרגעים היפים ההנאה והלימוד.

“שלום רובי” (באנגלית HELLO RUBY) הוא ספר ילדים נפלא על ילדה סקרנית שלוקחת את הצעדים הראשונים שלה בתכנות מחשבים מבלי לשים לב. בדמיון שלה היא מחפשת אחר חמשת אבני החן שאבא שלה החביא והשאיר רק רמזים ספורים למצוא אותן, בדרכה היא פוגשת את החברים החדשים שלה שעוזרים לה במסעה.

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

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

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

אני מתכנתת, סופרת ילדים ומאיירת מהלסינקי, פינלנד. ב-2014 העליתי קמפיין ל-קיקסטארטר לספר הילדים שכתבתי “שלום רובי”.

זה היה אמור להיות מעין פרויקט אמנותי שנתמך על ידי קהילת רובי (רובי היא שפת תכנות) שאוהבת את הנושא… אבל להפתעתי תוך כמה שעות הפרויקט עבר בהרבה את הסכום המבוקש של 10 אלפים דולר. בסך הכל מימון פרויקט הקיקסטארטר הגיע ל-380 אלף דולר!

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

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

>>> קראתי את הספר הראשון שלך Adventures in Coding והתרשמתי ממנו מאוד – את מתחילה לספר על הדמויות הראשיות ומשם ממשיכה לקשור הכל ביחד עם עקרונות של מחשוב ותכנות. מאיפה בא לך הרעיון להסתכל על תכנות מנקודת מבטם של ילדים ולהציג את זה בתור סיפור?

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

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

>>> במה הספר השני שלך עוסק ומתי הוא יהיה בחנויות?

הספר השני “Journey Inside the Computer” הוא על מחשבים. מה זה מחשב? איך הוא עובד? הוא פורסם בפינלנד ועוד כמה מדינות לפני שנה אבל באוקטובר הקרוב הוא יהיה זמין גם באנגלית. הספר השלישי שעוסק באינטרנט פורסם בפינלנד, ועכשיו אני עובדת על הספר הרביעי שעוסק בבינה מלאכותית.

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

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

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

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

>>> טכנולוגיה כרגע נמצאית בכל מקום – עם מחשבים אנחנו משלמים חשבונות, מנווטים במרחב ומתקשרים עם חברים… בעתיד אולי אפילו נצביע באמצעות מחשב. מעט אנשים מבינים איך עובד המחשב ואפילו מעט יותר כותבים את התוכנות שרצות עליו. זה מדאיג אותך?

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

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

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

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

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

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

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

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

>>> בפסנתר הצלילים הגבוהים נחשבים לנשיים והצלילים הנמוכים לגבריים. את חושבת שאפשר להשתמש במטפורה הזו גם בשפות תכנות? לדוגמא שפת תכנות C תמיד היתה נראית לי גברית, יש שפות תכנות מסודרות ויש מבולגנות. ולסיום, האם זו שאלה רטורית לשאול מהי שפת התכנות האהובה עלייך 🙂 ?

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

הספר “שלום רובי” לא תורגם עדיין לשפה העברית. כדי להוציא אותו בעברית יש לפנות להוצאת ספרים שתסכים לתרגם ולהוציא אותו לאור, מי שמעוניין לעזור יכול לפנות להוצאה לאור ולהפנות אותם אל האתר של הסופרת.