זהו פוסט ראשון בסדרה שתעסוק ביצירת חיישנים ומתגים המחוברים כולם לרשת פרטית שלכם.
בסדרת הפוסטים הזאת אראה כיצד להכין חיישנים אלחוטיים במחיר נמוך ולחבר אותם לעולם של ה"אינטרנט של הדברים" הפרטי שלכם.
הנתונים מהחיישנים יזרמו כולם ל"ענן" פרטי עם שליטה מוחלטת בו. בנוסף אראה כיצד להשתמש בכלים יעודיים כדי לנהל ולנתח את הנתונים מהחיישנים.
כמובן הכל בסגנון "עשה זאת בעצמך" ועל טהרת הקוד הפתוח, בנוסף נדע כיצד לאסוף את המידע מכל הדברים, לאחסן אותו ונראה מה ניתן לעשות עם המידע הזה וכיצד ניתן לבצע פעולות על סמך המידע.
בנוסף נראה כיצד "להחכים" את המערכת בכך שנחבר תסריטים כמענה לתרחישים שונים על מנת לבצע אוטומציה של פעולות שונות – "בית חכם"(לדוגמה יש מישהו בחדר וחיישן האור מזהה רמת אור נמוכה – אז המערכת תדע להדליק את האור!)
המבנה הכללי של מערכת :
יחידת הקצה/החיישן : מיקרו בקר כלשהו – במקרה שלנו זה יהיה ארדואינו עם משדר רדיו או ESP8266 שמחובר ב- WIFI לרשת הביתית – אליו מחוברים חיישנים או מתגים שונים.
במקרים בהם יהיה שימוש בתקשורת רדיו (לא WIFI) המערכת תכלול גם gateway שיקשר בין הרשת של יחידות הקצה לרשת הביתית/אינטרנט.
בקר ראשי – Controller – מרכז את המידע מכל החיישנים וממנו מתבצעת השליטה והבקרה, שולח ומקבל פרמטרים לחיישנים ברשת, עוקב אחר הנתונים העדכניים ביותר שמדווחים על ידי חיישנים וגם בדרך כלל מספק ממשק משתמש לשליטה על כל הרשת ומריץ לוחות זמנים מוגדרים מראש או תסריטים.
כפרוייקט ראשון אראה כיצד יצרתי מערכת השקייה לגינה ביתית יחד עם מספר חיישנים המפוזרים בגינה שמעבירים לבקר הראשי את הנתונים שעל פיהם הוא מעריך האם להפעיל את מערכת ההשקייה.
נתחיל עם הבקר הראשי (מספר 3 במבנה הכללי)- הוא ישמש אותנו בכל הפרוייקטים ואליו יתחברו כל החיישנים. ישנם מספר תוכנות בקר ראשי נפוצות שיושבות על על מספר אפשרויות חומרה, כאן נעשה שמוש ב Domoticz שזו מערכת ניהול בית חכם המאפשרת שליטה ובקרה על חיישנים ומתגים שונים. החומרה שמצאתי הכי מתאימה לדעתי להרצת Domoticz זה Raspberry Pi. יש מבחר של לוחות פיי:
ו-Domoticz יכול לרוץ בצורה חלקה אפילו על Raspberry pi B הגירסה הישנה עם 512MB זכרון RAM ,וזה הלוח שאני מריץ עליו(אחד משני הלוחות התחתונים בתמונה).
ספק כוח מיקרו USB שנותן 2A.(כל ספק מקורי של סמרטפון סביר).
התקנה:
מורידים אימג' מכאן(זה בעצם מערכת הפעלה שלמה של Raspbian הכוללת כבר את Domoticz)
לאחר ההורדה מחלצים את הקובץ , מפרמטים את כרטיס הSD עם FAT32 ומתקינים את האימג' בעזרת התוכנית – win32diskimager.
מחברים את הרספברי לראוטר עם כבל הרשת ולמטען ואחרי ההדלקה נחכה כ 2 דקות ונלך לממשק הניהול בראוטר הביתי ע"מ לראות באיזה כתובת IP הרספברי נמצא.
נתחבר ל http://raspberryIP:8080 ונקבל את ממשק הניהול:
זהו – יצרנו את הבקר הראשי.
יחידת קצה WIFI שנבנה תהיה ללא צורך בGATEWAY (במובן מסויים הראוטר הבייתי הוא בעצם GATEWAY).
לצורך פשטות נשתמש בלוח NODEMCU אותו ניתן לרכוש לדוגמה כאן.
שוב לצורך פשטות נוריד ל NODEMCU קושחה(firmware) בשם ESP EASY.
נחלץ את הקבצים ונפעיל את הסקריפט הבא:
flash.cmd
יש לבחור בפורט המתאים,בנפח האחסון במודול ובגירסת הקושחה.
לאחר מכן יופיע ראוטר חדש ברשימת נקודות ה WIFI הזמינות : esp_0 יש להתחבר אליו ולפתוח דפדפן שאוטומטית יוביל אותנו לדף הגדרות שם נזין SSID וסיסמה של הראוטר הביתי.
מודול עקיבה בזמן אמת עבור חפצים/אנשים/בעלי חיים/מכוניות.
הפרויקט שמוצג כאן הוא לצורך "בדיקת היתכנות" של מודול עקיבה GPS באמצעות שרת WEB. כל מה שמוצג כאן הוא על אחריות המשתמש ואין לאתר או למחבר הפוסט שום אחריות למוצג כאן כולל לכל נזק שייגרם. המשך הקריאה על אחריותכם בלבד!
כמו כן במדריך זה אין כל התייחסות לנושא אבטחת מידע וסייבר. הוא לצורך "בדיקת היתכנות" בלבד (POC) קבצי השרת פגיעים וכל מי שירצה יהיה לו גישה אליהם.כמו כן התקשורת בין החבילה לשרת ובין הלקוח לשרת לא מוצפנת וזמינה לכל. בחלק הבא תהיה התייחסות גם לנושא זה.
1.היחידה אחריה נעקוב (להלן החבילה) תהיה מורכבת מ:
בקר (ארדואינו)
מודול GPS ע"מ לדעת מיקום (SIM808)
מודול GSM לצורך התקשרות עם שרת WEB ע"מ לדווח לו את המיקום.(SIM808)
2.היישום בענן/שרת אינטרנט יהיה מורכב מקובץ PHP שאליו החבילה תדווח על מיקומה ,המיקום ישמר ולקוח שירצה מידע על מיקום החבילה יקבל זאת בצורת JSON.
3.הלקוח זה דף HTML עם מפות של גוגל שמתעדכן כל כמה שניות ע"י JSON עם פרטי מיקום החבילה אותו הוא מבקש מהשרת/ענן.
בציור:
שלב 1 – החבילה מזהה מיקום באמצעות GPS.
שלב 2 – החבילה מדווחת מיקום לשרת.
שלב 3 – לקוח מבקש מידע על המיקום של החבילה מהשרת , מקבל אותו ומציג אותו ע"ג מפה.
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:
בפוסט הזה ארחיב כיצד לתקשר עם ארדואינו ב WIFI באמצעות ה TL-WR703N .
רכיבים:
ארדואינו כלשהו עם מתאם USB כלשהו (זה יכול להיות UNO R3 או פרו מיני עם מתאם מבוסס ftdi או cp2102 או pl2303 וכו') כל ה USB TO TTL הנפוצים נתמכים.
ראוטר TL-WR703N .
קוד מאוד פשוט לצורך בדיקת תקשורת אותו יש להעביר לארדואינו :
XHTML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
voidsetup(){
Serial.begin(9600);//setupSeriallibraryat9600bps
}
//thelooproutinerunsoverandoveragainforever:
voidloop(){
Stringcontent="";
charcharacter;
while(Serial.available()){
character=Serial.read();
content.concat(character);
delay(10);
}
if(content=="miki"){
Serial.print(content);
{
}
הקוד פשוט קורא מהפורט הסיריאלי ובמידה והמחרוזת היא "miki" הוא מדפיס את הקלט לפורט הסיריאלי כך שהקוד יאפשר לנו לבדוק קישוריות דו כיוונית.
אני אחבר ארדואינו אונו R3 לראוטר.
יש להוריד להתקין Putty בשדה הכתובת לשים את כתובת הIP של הראוטר:
לאחר שנקבל מסך טרמינל בשם המשתמש נקיש root ואת הסיסמה שהגדרנו:
+
לפני שחיברנו את הארדואינו לראוטר דרך USB נריץ את הפקודות הבאות (נעבור לתיקיית dev):
XHTML
1
cd/dev
רשימה של כל קבצי המודולים המחוברים למכונת לינוקס :
XHTML
1
ls
(רשימה של כל קבצי המודולים המחוברים למכונת לינוקס )
תפתח בפנינו רשימה ונשים לב שאותה פקודת ls אחרי הכנסת הארדואינו תתן רשימה עם מודול אחד נוסף וכך נוכל לדעת את המבואה הסריאלית אליה אנו אמורים להאזין ולשלוח פקודות ע"מ לדבר עם הארדואינו:
נריץ את הפקודה הבאה (יש בעיה של auto reset עם הארדואינו, יש הרבה חומר על הנושא בפורומים שונים זה הסיכום שהגעתי מנבירה בפורומים וחקירה למידע נוסף):
לאחר מכן נריץ את הפקודה (תאזין על פורט ttyACM0 ושזה יהיה ברקע – "&") :
XHTML
1
cat/dev/ttyACM0&
ולאחריה (כתוב לפורט הנ"ל את הקלט "miki" ותתעלם מתו שורה חדשה):
XHTML
1
echo-n"miki">/dev/ttyACM0
נראה שכל פעם שנכתוב את פקודת ה "echo" נקבל את הפלט "miki" כל קלט אחר לא יודפס:
זהו אנחנו יכולים לדבר עם ארדואינו בצורה טורית ניתן ליעל את התהליך עם שפה שכבר מותקנת בראוטר ששמה – Lua כך שיהיה אפשר לגשת לכתובת בדפדפן ולהעביר מסרים לארדואינו (תדליק לד) או לקבל מסרים מהארדואינו (מה הטמפרטורה בחדר) הרחבה על כך בפוסטים הבאים.
את המעגל יצרתי באמצעות תוכנה מאוד שימושית ופופולרית בשם – fritzing שלא ארחיב עליה כאן רק אצרף את הקובץ לצורך הדפסת המעגל.
יש 2 ספריות נפוצות לארדואינו לצורך עבודה עם המודול הזה – rf24 ו mirf.
אני מצאתי את הספרייה rf24 מתאימה יותר לצורך של רשת מודולים אל אף שהיא יותר מורכבת מאשר ספריית ה mirf כמו כן ישנה ספרייה מעולה (אם כי קצת מורכבת) לצורך רשת מודולים שמבוססת על ספריית ה rf24 בשם – rf24network .
אני אדלג על הסבר לספריית rf24 ואקפוץ ישר לעניינים – rf24network.
להלן סכימת החיבור בין הארדואינו לבין רכיב ה nrf24l01 :
סכמת חיבור ארדואינו ל NRF24L01
סיגנל
ארדואינו
NRF24L01
GND
GND
1
VCC
3.3V
2
CE
9
3
CSN
10
4
SCK
13
5
MOSI
11
6
MISO
12
7
סכמת חיבור ארדואינו ל NRF24L01
כלומר אם יש בארדואינו פרו 13 יציאות דיגיטליות ו7 יציאות אנלוגיות אחרי חיבור למודול האלחוטי נשארנו עם 8 יציאות דיגיטליות ו7 אנלוגיות.(שזה דיי מספיק למודול אחד – יכולת שליטה על עד 8 אלמנטים וחיבור של עד 7 חיישנים ).
כלומר אני צריך לתכנן מעגל לחיבור מודול האלחוט לארדואינו וחשיפה של 8 פינים דיגיטליים ו 7 אנלוגיים כמו כן עלי להמיר את 5V שמגיע מהארדואינו למודול האלחוט (VCC) מ5V ל 3.3V.
כמו כן עלי לחשוף גם את הפין ה RST לצורך העברת הקוד לארדואינו ואת פין ה RAW לצורך חיבור למקור מתח חיצוני לדוגמה סוללה.
את המעגל יצרתי באמצעות שיטת ה – tuner transfer שלא כאן המקום להרחיב.
השתמשתי בארדואינו פרו 5V ולא ב-3.3V בגלל שההבדל בעלות זה כמעט דולר אך הדבר הצריך ממני להוסיף למעגל ממיר מתח ל3.3 בגלל שזה מה שמקבל מודול ה- nrf24l01 (כמעט 10 ממירי מתח וקבלים עלו לי קצת מעל 2 דולר כך שעדיין יוצא יותר זול).
המעגלים (לוח הארדואינו המודפס שבתמונות לא קשור לפרויקט):
הלוחות אחרי הדפסה
הלוחות אחרי הדפסה
אחרי חומצה
אחרי חומצה
במהלך החומצה
אחרי הלחמה ללא קבלים
הוספת קבלים
node module
מודולים סופיים לפני העתקת הסקיצה
מודול סופי
אפרט קצת על מבנה רשת העלים.
היישום הרשת היה קצת שונה מהיישום של מחבר הספרייה 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 הם בעצם כתובת האב:
בסיס האב הראשי – 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:
//nRF24L01(+)radioattachedusingGettingStartedboardRF24radio(9,10);//NetworkusesthatradioRF24Networknetwork(radio);//Addressofournodeconstuint16_tthis_node=021;//Addressoftheothernodeconstuint16_tbase_node=00;uint16_tother_node;booleanis_queue=false;//Structureofmessagecharbits[8];structa_message{uint16_taddressTo;chardigital1To8;intA1;intA2;intA3;intA4;intA5;chartypeOfMsg;uint16_taddressFrom;};voidgetBits(charc){for(inti=7;i>=0;--i){bits[i]=(c&(1<<i))?'1':'0';}}voidsetup(){Serial.begin(57600);Serial.print(this_node);Serial.println(" Node Started");SPI.begin();radio.begin();network.begin(/*channel*/90,/*nodeaddress*/this_node);}voidloop(void){//Pumpthenetworkregularlynetwork.update();a_messagemessage;//Isthereanythingreadyforus?while(network.available()){//Ifso,grabitandprintitoutdelay(200);RF24NetworkHeaderheader;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){inttmpAddress;tmpAddress=message.addressTo/64;other_node=tmpAddress*64+this_node%64;}else{inttmpAddress;tmpAddress=message.addressTo/8;other_node=tmpAddress*8+this_node%8;}RF24NetworkHeaderheader2(/*tonode*/other_node);a_messagenextMsg=message;Serial.print("Sending to node ");Serial.println(other_node);boolok=network.write(header2,&nextMsg,sizeof(nextMsg));if(ok)Serial.println("ok");elseSerial.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 מוגבלים היכולת לשרשר מודולים מאפשרת להרחיב את טווח השידור והקליטה של הרשת ולהתגבר על המגבלה הזאת.
רעיון "האינטרנט של דברים" מאוד מרתק – להפוך את הכל (!) לזמין ברשת .
האפשרות שכל הדברים הסובבים אותנו יהיו זמינים ברשת ופריסת חיישנים שונים סביבנו שגם הם זמינים לרשת זה בעצם רוב הדרך לכוון של "בית חכם".
מה צריך כדי ליצור את "האינטרנט של הדברים" הפרטי שלי ובנוסף "להחכים" את הבית שלי ? מה העלות והמורכבות של הדברים?
הייתי רוצה פתרון קטן , זול וקל ליישום.
אני חקרתי במשך הזמן על האופציות הזמינות לפתרון שכולל את כל הפרמטרים שמניתי. בפוסט הזה ובסדרת הפוסטים שיבואו אכתוב על הנושא מתוך ניסיון שלי.
יש לי ניסיון בפיתוח לארדואינו שזה בעצם מיקרו בקר מאוד פופולרי שניתן לתכנות בצורה יחסית פשוטה בסביבת פיתוח זמינה להורדה ובקוד פתוח.
כלומר באמצעות הארדואינו ניתן לשלוט בכל דבר ואם נחבר אליו חיישנים מסוגים שונים נוכל גם "לחוש את הסביבה". דיי מוקדם התברר שזאת תהיה הפלטפורמה עליה אתבסס כפתרון למודול שיתחבר לכל דבר אותו נרצה ברשת או כמודול שיקשר בין הרשת לסוגים שונים של חיישנים.
אך כמיקרו בקר בלבד חסרה החוליה שתקשר בינו לבין מודולים אחרים ובניהם לרשת האינטרנט לכן חיפשתי פתרון פשוט ליישום והכי חשוב כמה שיותר זול בהנחה שככל שמודול כזה(אקרא לו מעכשיו NODE או עלה) יהיה זול יותר אחבר אותו ליותר דברים וכך להפוך כמה שיותר דברים לחכמים וזמינים ברשת.
התצורות היותר פופולריות היום של ארדואינו:
ישנם הרבה מודולים עם אפשרויות תקשורת בהם שקלתי להשתמש :
מיני מחשב 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 למחשב.
המודול הסופי יהיה כמובן מבוסס על ארדואינו ערום יותר כמו הפרו.