GPS – מיקום של דברים בזמן אמת

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

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

1.היחידה אחריה נעקוב (להלן החבילה) תהיה מורכבת מ:

  • בקר (ארדואינו)
  • מודול GPS ע"מ לדעת מיקום (SIM808)
  • מודול GSM לצורך התקשרות עם שרת WEB ע"מ לדווח לו את המיקום.(SIM808)

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

3.הלקוח זה דף HTML עם מפות של גוגל שמתעדכן כל כמה שניות ע"י JSON עם פרטי מיקום החבילה אותו הוא מבקש מהשרת/ענן.

gps-tracker

בציור:

שלב 1 – החבילה מזהה מיקום באמצעות GPS.

שלב 2 – החבילה מדווחת מיקום לשרת.

שלב 3 – לקוח מבקש מידע על המיקום של החבילה מהשרת , מקבל אותו ומציג אותו ע"ג מפה.

רכיבים:

  1. מגן SIM808
  2. ארדואינו אונו
  3. כבל לארדואינו
  4. סוללה להטענת טלפון נייד(אופציונאלי).

shield

sim808-arduino

בנוסף יש צורך בשרת שיכול להריץ PHP ושזמין מהאינטרנט (לא יכוסה במדריך זה).

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

הקוד:

/**
 *
 * GPS Adapted From Adafruit_FONA lib:
 * Copyright: 2015 Adafruit
 * Author: Todd Treece
 * Licence: MIT
 * Adapted by https://iot.org.il
 **/
 
#include "Adafruit_FONA.h" //lib for the sim808 shield
#include <string.h>
#include <SoftwareSerial.h> //for communicating with sim808

#define FONA_RX 8
#define FONA_TX 7
#define FONA_RST 4

SoftwareSerial fonaSS = SoftwareSerial(FONA_TX, FONA_RX);
SoftwareSerial *fonaSerial = &fonaSS;

Adafruit_FONA fona = Adafruit_FONA(FONA_RST);

int Powerkey = 9;//pin for powering the SIM808
boolean gprson = false;
boolean gpson = false;
void power(void)
{
 //digitalWrite(Powerkey, LOW); 
 //delay(1000); // wait for 1 second
 digitalWrite(Powerkey, HIGH);
}
void flushSerial() {
 while (Serial.available())
 Serial.read();
}
void setup() {
 
 pinMode(Powerkey, OUTPUT); // initialize the digital pin as an output. 
 power(); //power on the sim808 or power down the sim808
 while (! Serial);
 Serial.begin(115200);
 Serial.println(F("Initializing sim808... (May take a few seconds)"));

 fonaSerial->begin(4800);
 if (! fona.begin(*fonaSerial)) {
 Serial.println(F("Couldn't find sim808"));
 while(1);
 }
 Serial.println(F("sim808 is OK")); 
 while(!gpson){
 delay(1000);
 Serial.println(F("Enabling GPS..."));
 if (!fona.enableGPS(true))
 Serial.println(F("GPS OK..."));
 gpson = true;
 }
 while(!gpson){
 delay(1000);
 fona.enableGPRS(false);
 Serial.println(F("Enabling GPRS"));
 if (!fona.enableGPRS(true))
 Serial.println(F("Failed to turn GPRS on"));
 else
 gprson = true;
 }
}

void loop() {
 delay(4000);
 if(!gprson){
 fona.enableGPRS(false);
 Serial.println(F("Enabling GPRS"));
 if (!fona.enableGPRS(true))
 Serial.println(F("Failed to turn GPRS on"));
 else
 gprson = true;
 }
 float latitude, longitude;
 boolean gps_success = fona.getGPS(&latitude, &longitude);
 if (gps_success)
 {
 Serial.print("GPS lat:");
 Serial.println(latitude, 6);
 Serial.print("GPS long:");
 Serial.println(longitude, 6);
 uint16_t statuscode;
 int16_t length;
 char url[100]="http://ivardi.com/gps/report.php?latitude=";
 char lati[10];
 dtostrf(latitude,1,6,lati);
 Serial.println(lati);
 char longi[10];
 dtostrf(longitude,1,6,longi);
 strcat(url, lati);
 strcat(url, "&");
 strcat(url, "longitude=");
 strcat(url, longi);
 flushSerial();
 Serial.println(url);
 if (!fona.HTTP_GET_start(url,&statuscode, (uint16_t *)&length))
 {
 Serial.println("Failed!");
 }
 while (length > 0) 
 {
 while (fona.available()) 
 {
 char c = fona.read();
 #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
 loop_until_bit_is_set(UCSR0A, UDRE0); // Wait until data register empty. 
 UDR0 = c;
 #else
 Serial.write(c);
 #endif
 length--;
 if (! length) {};
 }
 }
 fona.HTTP_POST_end();
 } 
 else 
 {
 Serial.println("Waiting for GPS fix...");
 }
 }

רכיב ה SIM808 מתקשר עם הארדואינו בממשק סיריאלי – UART – וע"י פקודות AT. היצרן של הרכיב מספק קובץ מפורט איזה פקודות AT מפעילות את האופציות השונות , לדוגמה פקודות לשליחת SMS , להוצאת שיחה וכו'.

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

כמו כן נעשה שימוש בסיפריה – SoftwareSerial על מנת שנוכל לדבג את התוכנית בערוץ UART החומרתי.

בנוסף בסיפריה ישנו קובץ בשם Adafruit_fona.cpp שם נצטרך לשנות את שם הAPN לאחד שיתאים למפעיל הסלולארי שעם הסים שלו אנו משתמשים.

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

החבילה מבצעת

"GET" request

לשרת עם הפרמטרים של – latitude ו longitude , הקובץ בשרת בשם report.php מקבל את הבקשה ויוצר קובץ JSON עם הערכים הללו.
דף HTML עם מפה של גוגל מוטמעת בו פונה בAJAX כל כמה שניות לשרת בבקשה לספק לו את קובץ ה JSON שהשרת יצר,ואחרי שהוא מקבל את הקובץ הוא מציג את המיקום על גבי המפה שלצורך זה יש לקבל מגוגל KEY ולהוסיף אותו בקובץ tracker.html בשורה 15:

<script type="text/javascript" src="https://maps.googleapis.com/maps/api/js?v=3&key=getYourownKey"></script>

tracker-map
כל הקבצים שבפרוייקט מצורפים:

gps

מודול המוח

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

המחיר של המוצר הזה היום ברשת הוא באזור 22-25 דולר וכולל חיבור לרשת חוטית וUSB בנוסף ליכולת WIFI.

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

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

brain module

 

כמה נתונים טכניים:

IMAG2328

מעבד: RT5350@360MHz

זיכרון RAM:16MB

FLASH: 4MB

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

המודול יכול בעצם לעשות כל מה שעשה ה- tlwr703n ושפרטתי בפוסטים הקודמים.

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

מספר פרויקטים המבוססים על המודול הזה בהתהוות:

חיישן זיהום/גז עם קישוריות לאינטרנט:

IMAG2782

'מוח' לפלטפורמה של רובוט עם מצלמת רשת :

IMAG2783

 

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

פירוט על המודול והפרויקטים המבוססים עליו יהיו בפוסטים הבאים.

מערכת השקייה וגינון חכמה

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

כבר קיימים כמה פרוייקטים של גינון חכם ברשת , להלן כמה:

gardenbot

OpenSprinkler

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

IMAG2178

 

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

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

IMAG2183

 

IMAG2186

בפוסטים הבאים ארחיב על מודול שיחובר לארדואינו ויוכל לשלוט על עד 6 מגופים…

TL-WR703N OpenWrt Arduino

tl-wr703n_arduino

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

רכיבים:

  • ארדואינו כלשהו עם מתאם USB כלשהו (זה יכול להיות UNO R3 או פרו מיני עם מתאם מבוסס ftdi או cp2102 או pl2303 וכו') כל ה USB TO TTL  הנפוצים נתמכים.
  • ראוטר TL-WR703N .

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

void setup() { 
Serial.begin(9600); // set up Serial library at 9600 bps 
}

// the loop routine runs over and over again forever:
void loop() {

 String content = "";
 char character;

 while(Serial.available()) {
 character = Serial.read();
 content.concat(character);
 delay (10);
 }
if (content == "miki") {
 Serial.print(content);
 { 
 }
 

 

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

אני אחבר ארדואינו אונו R3 לראוטר.

יש להוריד להתקין Putty   בשדה הכתובת לשים את כתובת הIP של הראוטר:

putty

 

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

putty2+

לפני שחיברנו את הארדואינו לראוטר דרך USB נריץ את הפקודות הבאות  (נעבור לתיקיית dev):

cd /dev

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

ls

(רשימה של כל קבצי המודולים המחוברים למכונת לינוקס )

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

putty3

נריץ את הפקודה הבאה (יש בעיה של auto reset עם הארדואינו, יש הרבה חומר על הנושא בפורומים שונים זה הסיכום שהגעתי מנבירה בפורומים וחקירה למידע נוסף):

stty -F /dev/ttyACM0 cs8 9600 ignbrk -brkint -icrnl -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts -hupcl

לאחר מכן נריץ את הפקודה (תאזין על פורט ttyACM0 ושזה יהיה ברקע – "&") :

cat /dev/ttyACM0 &

ולאחריה (כתוב לפורט הנ"ל את הקלט "miki" ותתעלם מתו שורה חדשה):

echo -n "miki" > /dev/ttyACM0

נראה שכל פעם שנכתוב את פקודת ה "echo" נקבל את הפלט "miki" כל קלט אחר לא יודפס:

putty5

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

TL-WR703N OpenWrt

TL-WR703N

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

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

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

Atheros AR7240 CPU (400Mhz)
Atheros AR9331 Chipset (integrated wireless)
802.11 b/g/n 150Mbps (130Mbps real)
wireless power output 20dBm – 100mW
4 MB flash memory
32 MB RAM
USB 2.0 port (High-Speed only, use an external High-Speed hub for Full/Low-Speed devices)
Powered via micro-USB socket
5.7cm x 5.7cm x 1.8cm

 TL-WR703N TL-WR703N

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

במדריך זה אראה איך אני התקנתי OpenWrt וקינפגתי את הראוטר כ WIFI client .

במדריכים העוקבים אראה כיצד "לדבר" עם ארדואינו ולשדר ממצלמת ווב שידור חי…

מצרכים:

  1. כבל רשת .
  2. ראוטר TL-WR703N כ – 20-25$ באתרים הסינים הרגילים.

ישנו אתר נחמד המציע להורדה חבילה של OpenWrt המתאימה לצ'יפ של הראוטר וכוללת את כל החבילות תוכנה שצריך ע"מ לעשות את מה שמניתי (שידור ממצלמה דיבור עם ארדואינו וכו')  להורדת החבילה.

לאחר ההורדה יש לפתוח את הכיווץ לתוך תיקיה מתאימה.

יש לחבר את הראוטר לחשמל ולכבל רשת שמחובר למחשב ולגשת לכתובת http://192.168.1.1 .

הראוטר הנ"ל מיועד לשוק הסיני וכל ה UI שלו הוא סיני ולכן אצרף פה תמונות ע"מ להמשיך את ההסבר.

נתחבר כדי לגשת לממשק האינטרנט, ברירת המחדל – משתמש:admin  הסיסמה היא: admin.

יש ללחוץ על "系统工具" (כלי מערכת):

chin1

 

לאחר מכן יש ללחוץ על "软件升级" (עדכון קושחה) :

chin2

ולבחור את הקובץ שחילצנו מהתיקיה המתאימה:

chin3

יש ללחוץ על הכפתור "浏览…" שזה BROWSE… לאחר מכן יש ללחוץ על "升 级" (שידרוג) ולאשר:

chin4

ניתן לתוכנה להטען…………….

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

openwrt1

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

שדרוג OpenWRT
שדרוג שכבר קיימת מערכת OpenWRT זה פשוט יותר יחסית.

כניסה רגילה כדי לגשת לממשק האינטרנט ( ששמו Luci)
בחירה בטאב "system"
לאחר מכן בחר "Backup / Flash Firmware"

Upgrade

נלחץ על "Choose File"  ונבחר את הקובץ "openwrt-ar71xx-generic-tl-wr703n-v1-squashfs-sysupgrade.bin" מהחבילה שפרסנו ונלחץ "Flash image".

זהו המערכת מוכנה.

קינפוג הראוטר כ WIFI client

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

הגדרת הנתב יש לבחור בכרטיסייה "network" בחלק העליון , ולאחר מכן בחר באפשרות " Wifi " וללחוץ על "scan":

wifi1

נמצא את הראוטר שלנו ונלחץ על "Join Network":

wifi2

נזין את הסיסמה של WPA (בהנחה שיש WPA/WPA2 ) , ותחת " Create / Assign firewall-zone " – בחר " LAN" לאחר מכן לחץ על "Submit":
wifi3

יש ללחוץ לאחר מכן על "Save & Apply" ונמתין עד שההגדרות יתפסו:

wifi5

תחת הלשונית " network" בחלק העליון , נבחר " interfaces"  שימו לב לכתובת ה-IP של החיבור שכרגע יצרנו .

wifi6

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

הרבה ראוטרים בייתים טווח הכתובות שלהם הוא *.192.168.1 שהראוטר עצמו הוא 192.168.1.1.

חשוב להגדיר את את הכתובת של ה – TL-WR703N כאשר הוא בחיבור קווי כחלק מטווח כתובות שונה מהטווח של הראוטר הבייתי שגם נתן כתובת לחיבור החדש שיצרנו ע"מ לחבר את ה TL-WR703N אלחוטית כ CLIENT לראוטר הביתי.

אני שיניתי ידנית את הכתובת של ה TL-WR703N כאשר הוא מחובר קווית מ 192.168.1.1 ל 192.168.0.1 והכתובת שלו כאשר הוא מחובר אלחוטית לראוטר הביתי נשארה 192.168.1.124.

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

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

המדריך הזה נכתב בעיקר ע"פ האתר הזה :

madox.net

בית חכם חלק שני – מודול העלה

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

הבקר של המודול יהיה חיקוי של ארדואינו פרו והרכיב האלחוטי שבו יהיה nrf24l01 .

IMAG1866

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

יש 2 ספריות נפוצות לארדואינו לצורך עבודה עם המודול הזה – rf24 ו mirf.

אני מצאתי את הספרייה rf24  מתאימה יותר לצורך של רשת מודולים אל אף שהיא יותר מורכבת  מאשר ספריית ה mirf כמו כן ישנה ספרייה מעולה (אם כי קצת מורכבת) לצורך רשת מודולים שמבוססת על ספריית ה rf24  בשם – rf24network .

אני אדלג על הסבר לספריית rf24 ואקפוץ ישר לעניינים – rf24network.

להלן סכימת החיבור בין הארדואינו לבין רכיב ה nrf24l01 :

24L01

סכמת חיבור ארדואינו ל NRF24L01

סיגנלארדואינוNRF24L01
GNDGND1
VCC3.3V2
CE93
CSN104
SCK135
MOSI116
MISO127
סכמת חיבור ארדואינו ל NRF24L01

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

כלומר אני צריך לתכנן מעגל לחיבור מודול האלחוט לארדואינו וחשיפה של 8 פינים דיגיטליים ו 7 אנלוגיים כמו כן עלי להמיר את 5V שמגיע מהארדואינו למודול האלחוט (VCC) מ5V ל 3.3V.

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

sketch-iotv1

 

את המעגל יצרתי באמצעות שיטת ה – tuner transfer שלא כאן המקום להרחיב.

השתמשתי בארדואינו פרו 5V ולא ב-3.3V בגלל שההבדל בעלות זה כמעט דולר אך הדבר הצריך ממני להוסיף למעגל ממיר מתח ל3.3 בגלל שזה מה שמקבל מודול ה- nrf24l01 (כמעט 10 ממירי מתח וקבלים עלו לי קצת מעל 2 דולר כך שעדיין יוצא יותר זול).

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

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

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

ישנו בסיס ראשי בכתובת 00 (כתובות העלים הם בפורמט uint16_t unsigned 16-bit integer) והיות ויש אפשרות ל6 צינורות (PIPES) תקשורת לכל מודול nrf24l01 לפי ה – DATASHEET,  אז כל עלה בסיס יכול לתקשר עם 5 בנים (sibling)  ועם האבא שלו, הבסיס הראשי היות והוא אב לכולם ואין לו אב משלו יש לו אפשרות להתחבר ל 6 בנים אך כדי לשמור על הקוד פשוט ושכל עלה ראשי יהיה עם אותם המאפיינים אז גם העלה הראשי ביותר יכול לתקשר רק עם 5 בנים.

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

הקוד שלי הוא עד הרמה השלישית, כלומר 5 בחזקת 3  כלומר 1+25+125+5 עלים = עד 151 נקודות מודולים ברשת ! יכולתי להוסיף עוד 'דור' לרשת ואז היה אפשרות ליותר מפי חמש אך 151 מודולים זה דיי והותר לרשת ביתית.

להלן סכמה של המודולים והכתובות שלהם – נשים לב שהספרות הכי ימניות במספר uint16_t הם בעצם כתובת האב:

topologu

בסיס האב הראשי – 00 יהיה בעל קישוריות לאינטרנט (wired / wifi) והוא יהיה אחראי על חשיפת כל רשת החיישנים ומודולי השליטה לרשת האינטרנט.

לבסיס האב הראשי 5 ילדים – 01,02,03,04,05 הוא יכול לתקשר רק איתם והם איתו. האחים לא מדברים בינהם – 01 לא יכול לתקשר עם 02, אלא רק עם האב שלו (00) ועם חמשת ילדיו – 011,021,031,041,051 ,כלומר אם בסיס 00 מעוניין להעביר פקודה לעלה 011 או לקרוא מידע מעלה 011 התעבורה צריכה להיות דרך עלה 01 שהוא האב של 011 והבן של 00 וכן על זה הדרך…

ואם נתרגם למספרים רגילים אז מודול 0 מדבר עם מודולים 1-5 ומודול 1 מדבר עם אביו(0) ועם מודולים 9,17,25,33,41(כפולות של 8).

מודול 2 מדבר עם אביו(0) ועם ילדיו שהם 10,18,26,34,42 (גם כן כפולות של 8) וכן הלאה.

חשבתי בהתחלה לשמור את כתובת העלים ב EEPROM אך לשם הפשטות הכנסתי לכל עלה את הכתובת שלו בתוך קוד המקור (hard coded).

אני מצרף כאן קוד מקור למודול הבסיס וקוד מקור לכל מודולי העלים כרגע הכל זה רישומים ל serial consule אין עדיין חיישנים או relays:

קוד הבסיס:

/*
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * https://iot.org.il
 * Internet Of Things Implement by Arduino Pro and nrf24l01 
 * using RF24Network 
 *
 * Base NODE - main node with eventually internet gateway always with address 00
 * By Vardi Michael.
 * Adapt from Maniacbug - http://maniacbug.wordpress.com
 */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI>

// nRF24L01(+) radio attached using Getting Started board 
RF24 radio(9,10);
// Network uses that radio
RF24Network network(radio);
// Address of our node
const uint16_t this_node = 00;
// Address of the other node
uint16_t other_node;
// Structure of message
char bits[8];
struct a_message//structure of message(need to be less than 32 bytes)
{
  uint16_t addressTo; //where the message destination
  char digital1To8; // char with take 2 bytes - 8 bits so we can put inside one char 8 digital pins status...
  int A1;//sensor number 1
  int A2;//sensor number 2
  int A3;//sensor number 3
  int A4;//sensor number 4
  int A5;//sensor number 5
  char typeOfMsg;//is it sensor reading or digital command
  uint16_t addressFrom;//original origin of the message.
};

String getValue(String data, char separator, int index)
 {
 int found = 0;
 int strIndex[] = {0, -1};
 int maxIndex = data.length()-1;
 for(int i=0; i<=maxIndex && found<=index; i++)  {  if(data.charAt(i)==separator || i==maxIndex)  {  found++;  strIndex[0] = strIndex[1]+1;  strIndex[1] = (i == maxIndex) ? i+1 : i;  }  }  return found>index ? data.substring(strIndex[0], strIndex[1]) : "";
 }

void getBits(char c){
    for (int i = 7; i >= 0; --i)
    {
        bits[i]=(c & (1 << i)) ? '1' : '0';     } } void setup(void) {   Serial.begin(57600);   Serial.println("Base Node Started");   SPI.begin();   radio.begin();   network.begin(/*channel*/ 90, /*node address*/ this_node); } void loop(void) { 		// Pump the network regularly 		network.update(); 		String content = ""; 		char character;                 // Is there anything ready for us?                 while ( network.available() )                          {                                   // If so, grab it and print it out                                   RF24NetworkHeader header;                                   a_message message;                                   network.read(header,&message,sizeof(message));                                   Serial.print(message.addressFrom);                                   Serial.print(";"+message.A1);                                   Serial.print(";"+message.A2);                                   Serial.print(";"+message.A3);                                   Serial.print(";"+message.A4);                                   Serial.print(";"+message.A5);                                   Serial.println(";"+message.typeOfMsg);//+";"+message.A2+";");//+message.A3+";"+message.A4+";"+message.A5+";");//+";"+message.A2+";"+message.A3+";"+message.A4+";"+message.A5+";"+message.typeOfMsg);                        } 		while(Serial.available()) 			{ 				character = Serial.read(); 				content.concat(character); 				delay (1); 			}                  		if (content != "") 			{                             if(content !="ack")                             { 				a_message message = { getValue(content,';',0).toInt(), getValue(content,';',1).charAt(0),getValue(content,';',2).toInt(),getValue(content,';',3).toInt(),getValue(content,';',4).toInt(),getValue(content,';',5).toInt(),getValue(content,';',6).toInt(), getValue(content,';',7).charAt(0),getValue(content,';',8).toInt()}; 				 				if(message.addressTo>5)
                                    {
                                      if(message.addressTo>45)
                                           other_node = message.addressTo % 64;
                                      else
                                           other_node = message.addressTo % 8;
                                    }
                                 else  
                                     other_node = message.addressTo;

				RF24NetworkHeader header(/*to node*/ other_node);
                                Serial.print("Sending to node ");
                                Serial.println(other_node);
				bool ok = network.write(header,&message,sizeof(message));
				if (ok)
					Serial.println("ok");
				else
					Serial.println("failed");
                            }
                            else{
                                a_message message = { getValue(content,';',0).toInt(),'a',0,0,0,0,0,getValue(content,';',7).charAt(0),getValue(content,';',7).toInt()};

				if(message.addressTo>5)
                                    {
                                      if(message.addressTo>45)
                                           other_node = message.addressTo % 64;
                                      else
                                           other_node = message.addressTo % 8;
                                    }
                                 else  
                                     other_node = message.addressTo;

				RF24NetworkHeader header(/*to node*/ other_node);
                                Serial.print("Sending to node ");
                                Serial.println(other_node);
				bool ok = network.write(header,&message,sizeof(message));
				if (ok)
					Serial.println("ok");
				else
					Serial.println("failed");
                            }
			}
}

להלן קוד המקור של העלים(כאן זה דוגמה לעלה מספר 01 כלומר 1):

/*
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * https://iot.org.il
 * Internet Of Things Implement by Arduino Pro and nrf24l01 
 * using RF24Network 
 *
 * Leaf NODE - Leaf node  with hardcoded address.
 * By Vardi Michael.
 * Adapt from Maniacbug - http://maniacbug.wordpress.com
 */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI>
// nRF24L01(+) radio attached using Getting Started board RF24 radio(9,10); // Network uses that radio RF24Network network(radio); // Address of our node const uint16_t this_node = 021; // Address of the other node const uint16_t base_node =00; uint16_t other_node; boolean is_queue=false; // Structure of message char bits[8]; struct a_message { uint16_t addressTo; char digital1To8; int A1; int A2; int A3; int A4; int A5; char typeOfMsg; uint16_t addressFrom; }; void getBits(char c){ for (int i = 7; i >= 0; --i) { bits[i]=(c & (1 << i)) ? '1' : '0'; } } void setup() { Serial.begin(57600); Serial.print(this_node); Serial.println(" Node Started"); SPI.begin(); radio.begin(); network.begin(/*channel*/ 90, /*node address*/ this_node); } void loop(void) { // Pump the network regularly network.update(); a_message message; // Is there anything ready for us? while ( network.available() ) { // If so, grab it and print it out delay(200); RF24NetworkHeader header; network.peek(header); network.read(header,&message,sizeof(message)); is_queue=true; } network.update(); if(is_queue) { if(message.addressTo==this_node&&message.addressFrom==base_node) { Serial.print("Received packet from "); Serial.print(message.addressFrom); Serial.print(";"); Serial.print(message.digital1To8); Serial.print(";"); Serial.print(message.A1); Serial.print(";"); Serial.print(message.A2); Serial.print(";"); Serial.print(message.A3); Serial.print(";"); Serial.print(message.A4); Serial.print(";"); Serial.print(message.A5); Serial.print(";"); Serial.print(message.typeOfMsg+";"); Serial.println(message.addressTo); } else { if(message.addressTo>45) { int tmpAddress; tmpAddress = message.addressTo / 64; other_node=tmpAddress*64+this_node%64; } else{ int tmpAddress; tmpAddress = message.addressTo / 8; other_node=tmpAddress*8+this_node%8; } RF24NetworkHeader header2(/*to node*/ other_node); a_message nextMsg = message; Serial.print("Sending to node "); Serial.println(other_node); bool ok = network.write(header2,&nextMsg,sizeof(nextMsg)); if (ok) Serial.println("ok"); else Serial.println("failed"); } is_queue=false; } } 

לצורך ניסוי ניקח 3 מודולים.

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

מודול שני יהיה עלה שהוא בן ל 00 עם הכתובת 01.(יש לשנות את הכתובת של המודול בקוד מקור המצורף ל 01 במקום 021).

מודול שלישי הוא בן ל מודול שני 01 הוא יהיה 021 שזה המספר 17.

נפתח 3 מופעים של ה ARDUINO IDE לכל מודול נזהה באיזה פורט הוא מאזין (כמובן שיש לחבר לPRO MINI כבל תקשורת ע"מ שיוכל לתקשר טורית דרך ה USB עם המחשב וזה לא יכוסה פה) ונפתח בכל מופע את הSERIAL MONITOR ונאזין על הפורט הרלוונטי.

נקבל במודול הבסיס את ההודעה הבאה:

Base Node Started

ובמודולי העלה נקבל :

17 Node Started

או

1 Node Started

בהתאמה.

במוניטור הסיריאלי של נקודת הבסיס נזין את השדר הבא:

17;a;2;2;2;2;2;s;00

השדר:

17 – כתובת היעד

a – תו שמורכב משני בייטים כלומר 8 סיביות שיכולות לייצג מצב של 8 יציאות דיגיטליות וכך לבזבז פחות מקום בשדר.

2 – איזשהו קריאה של חיישן לדגמה

s – הודעה שהשדר הוא מסוג קריאת חיישן ולא פקודה כשלהיא ליציאה דיגיטלית

00 – כתובת מקור השדר.

ונראה שבעלה 01 התקבל השדר אך היות וזה לא מיועד אליו אלא הוא משמש כאן רק כ"תיבת ממסר" הוא מעביר את המסר לעלה המתאים שזה 021(17).

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

קובץ פריטזינג וPDF מצורפים:

node

בית חכם – מבוא

רעיון "האינטרנט של דברים" מאוד מרתק – להפוך את הכל (!) לזמין ברשת .

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

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

הייתי רוצה פתרון קטן , זול וקל ליישום.

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

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

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

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

התצורות היותר פופולריות היום של ארדואינו:

ard2

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

IMAG1736

  • מיני מחשב X86 עם מערכת הפעלה XP/linux .
  • Raspberry PI.
  • ראוטר נייד או כל ראוטר שאפשר להתקין עליו קושחה כמו OPENWRT.
  • כרטיסי הרחבה של ארדואינו לרשת .
  • Bluetooth.

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

+nRF24L01 הוא  שבב  בעל צריכת חשמל נמוכה שמשדר בצורה אלחוטית בתדר 2.4GHz מחברת Nordic Semiconductor הוא משתמש בפרוטוקול SPI, ויש לו טווח תיאורי של כ -50 מטר פחות או יותר, תלוי אם הסביבה בין המשדרים נקייה ממכשולים/קירות ורוחב הפס הוא מספיק לצורך שידור נתוני חיישן וכו'.

כמובן שהעלה הראשי במערכת (base node) יכלול גם רכיב שיאפשר קישוריות לרשת כמו WIFI.

היום חיקוי של ארדואינו מיני פרו 5V ניתן לרכישה בEBAY בפחות מ-3$ והרכיב תקשורת כ- 1.2$ – בעצם מודול שישמש כבסיס ל- NODE ב 4$ כולל משלוח(!) אני לא חושב שכרגע ניתן לנצח את המחיר הזה(אפילו קניה רק של הצ'יפ עצמו – ATMEGA328P-PU בלבד יותר יקרה מהחיקוי לפרו) .

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

IMAG1744 IMAG1742 IMAG1738

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

ההמשך בפוסט הבא…