1 מושג מכשיר
מטרת פיתוח זה היא לאסוף נתונים מחיישנים מקומיים, לשלוח נתונים אלה לאינטרנט. המשתמש יוכל בכל מקום בעולם לצפות בנתונים המגיעים מהחיישנים ולהחליט מרחוק על הפעלת מפעילים מסוימים שימוקמו באופן מקומי, ליד החיישנים.
הפרויקט משתמש ארדואינו מודול UNO ו- WiFi ESP8266-01. נתונים יועברו לענן דרך שירות האינטרנט ThingSpeak.com, והמכשירים יופעלו באמצעות אפליקציית האנדרואיד שפותחה באמצעות MIT AppInventor.
IoT הוא מושג של רשת מחשבים של חפצים פיזיים ("דברים") המצוידים בטכנולוגיות מובנות ליצירת אינטראקציה זו עם זו או עם הסביבה החיצונית, תוך התייחסות לארגון רשתות כאלה כתופעה שיכולה לבנות מחדש תהליכים כלכליים וחברתיים, ולבטל את הצורך בהשתתפות אנושית מחלק מהפעולות והפעולות.
המוקד העיקרי של פרויקט IoT זה יהיה שירות ThingSpeak.com. מכשיר UNO / ESP-01 המקומי מקבל נתונים מחיישנים ונתונים על מצב מפעילים, שולח אותם לאינטרנט "הקלטה" דרך ערוץ סטטוס ThingSpeak.com ספציפי (ThingSpeak.com ערוץ סטטוס), אותו מכשיר מקומי מקבל נתונים, " קורא אותם מערוץ נתונים אחר - "ערוץ המכשירים המנהלים" (ערוצי מפעיל ThingSpeak.com).
הנתונים ייאספו באמצעות חיישן טמפרטורה ולחות יחסית, טמפרטורת הקרקע והלחות וחיישן אור הסביבה. נתונים אלה יישלחו לענן השירות ThingSpeak.
יהיו שני מכשירי מנהלים - זו משאבה חשמלית למים ומנורה. סטטוס ה- ON / OFF שלהם יישלח לענן. נתונים מחיישנים, למשל, יכולים להציג את המצב הנוכחי של חממה או חממה. המשתמש ישלוט במכשירים המנהלים באמצעות אפליקציית אנדרואיד.
2 רשימת הרכיבים הנדרשים
כל הקישורים מיועדים למטרות מידע בלבד.
2 נוריות LED (אדום וירוק)
1 x
- $3.00
מנורת 220 וולט
נגן 2 x 330 אוהם (משמש עם נוריות לד)
נגן 2 x 10 K אוהם (בשימוש עם DHT22 ו- LDR)
נגן 1 x 4K7 אוהם (בשימוש עם DS18B20)
טיפוס לחם
מגשרים
ספק כוח חיצוני לממסר 5 וולט DC
3 חלק מברזל
עכשיו אתה צריך לחבר את כל החיישנים, כפי שמוצג בתרשים.
הפיתרון האידיאלי יהיה להרכיב ולבדוק את הפרויקט בחלקים.
ברצף הבא:
1. התקן ובדק את כל החיישנים
2.התקן והגדר תצורה מינימלית של ESP-01
3. שנה את הגדרת ESP-01 לתצורה ולבדיקה הסופית
4. הגדר את ערוץ הסטטוס של ThingSpeak
5. התקן את קוד ThingSpeak על ארדואינו ובדוק את מצב החיישנים בענן
6. פיתוח הגרסה הראשונה של התוכנית ב- Android לבדיקת הודעות סטטוס מחיישנים
7. התקן מפעילים
8. הגדר ערוצי מפעילי ThingSpeak
9. התקן ובדוק קוד למכשירי ניהול בארduino
10. הפוך את הגרסה השנייה של התוכנית על אנדרואיד לכל מכלול המכשירים.
4 חיבור חיישן
הפרויקט משתמש בספריות שנכללות בתוכו. יש לבדוק את זמינותם. התצורה הראשונית של ספריות אלה היא כדלקמן:
// DS18B20
#include
# כלול
# הגדר את ONE_WIRE_BUS 5 // DS18B20 בסיכה D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int earthTemp = 0;
// DHT
# כלול "DHT.h"
# כלול
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;
// LDR (אור)
# הגדר ldrPIN 1
אור int = 0;
// לחות בקרקע
# הגדר אדמה humpin 0
int earthHum = 0;
כעת אנו מאתחלים את חיישנינו ומציגים אותם בטרמינל:
הגדרת ביטול ()
{
Serial.begin (9600);
DS18B20.begin ();
dht.begin ();
}
לולאה חלילה ()
{
חיישני קריאה ();
חיישנים לתצוגה ();
עיכוב (10000);
}
ולבסוף, נכתוב שתי פונקציות: האחת קוראת את הקריאות מהחיישנים, והשנייה מציגה אותן על המסך:
/ ********* קריאת ערך חיישנים ************* /
voens readensensors (void)
{
airTemp = dht.readTemperature ();
airHum = dht.readHumidity ();
DS18B20.requestTemperatures ();
earthTemp = DS18B20.getTempCByIndex (0); // חיישן 0 יתפוס את טמפרטורת האדמה בסלסיוס
earthHum = מפה (analogRead (undergroundHumPIN), 1023, 0, 0, 100);
אור = מפה (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> 100% אור
}
/ ********* ערך חיישני התצוגה ************* /
חיישנים ריקים (ריק)
{
Serial.print ("airTemp (oC):");
Serial.println (airTemp);
Serial.print ("airHum (%):");
Serial.println (airHum);
Serial.print ("earthTemp (oC):");
Serial.println (earthTemp);
Serial.print ("earthHum (%):");
Serial.println (earthHum);
Serial.print ("אור (%):");
Serial.println (קל);
Serial.println ("");
}התצלום מראה כיצד הנתונים מוצגים על המסך.
ניתן להוריד את קוד המקור מהמחבר.
4 תצורה בסיסית של ESP8266-01
הדרך המהירה ביותר "לדבר" עם המודול היא הפקודה AT. למעבד כבר יש מעבד פקודות AT. כברירת מחדל, המודול מגיע עם הגדרות מפעל של 115200 baud, עליך להגדיר 9600 baud בהגדרות.
ראשית, עליך לחבר את המודול, כמוצג בתמונה
( שימו לב שטרמינל ה- Tx של ה- ESP-01 מחובר למסוף ה- Tx של UNO, ממש כמו המסופי Rx מחוברים זה לזה. חיבור זה ישונה בהמשך. ).
ואז חבר UNO למחשב, פתח את ה- IDE והורד את הדוגמה שנמצאת. זהו קוד ריק כך שלא יתקיימו סכסוכים בין ESP-01 ל- UNO. קוד זה הועלה לארדוניו לפני שחיבר אליו את ה- ESP-01, כדי להיות בטוח שארדוניו לא ישתמש בסיכות ה- Tx וה- Rx לכל דבר אחר.
עכשיו אתה צריך לפתוח את IDE Serial Monitor, להגדיר את שיעור baud ל 115200 בהגדרות ולשלוח את הפקודה AT למסך IDE Serial Monitor. על ESP-01 לשלוח תשובה אישור
כעת עליך לשנות את קצב הנתונים במודול ESP-01. לשם כך, ב- IDE, תן את הפקודה
ב- + CIOBAUD = 9600יתכן כי ESP-01 יחזור להגדרות היצרן, יהיה עליך להשתמש בפקודה אחרת:
AT + UART_DEF = <הגבלה>, <מסדי נתונים>, <עצירות>, <זוגיות>, <בקרת זרימה>למשל 9600 baud / 8 סיביות נתונים / 1 סיביות עצירה וללא בקרת זוגיות ובקרת זרימה
AT + UART_DEF = 9600,8,1,0,0עכשיו שנה את קצב העברת הנתונים בהגדרות IDE ל 9600 ושלח את הפקודה AT, תגובת OK צריכה לבוא.
בשלב הבא עליך לעבור את המודול למצב STA כך שיוכל להתחבר לנקודת הגישה של הרשת שלך.
AT + CWMODE = 1כדי שהמודול יתחבר לרשת, הזן את הפקודה AT + CWJAP = "שם רשת", "רשת שם__1"איפה שם רשת הוא שם הרשת שלך, ו- network_name_1 - סיסמה לרשת שלך (הסיסמה ושם הרשת חייבים להיות במירכאות)
אם אתה רואה את התשובה WIFI GIF IP מחוברואז נוצר הקשר. אמת את כתובת ה- IP באמצעות הפקודה
ב- + CIFSRהכתובת שמופיעה בצג שלך, תוכל להשתמש בה בעתיד. לאחר הגדרת התצורה של המודול, תוכלו לחבר אותו לצמיתות, אך לשם כך עליכם לשנות את מעגל המיתוג שלו, כפי שמוצג באיור.
• ESP-01 RX (צהוב) -> UNO Pin D7
• ESP-01 TX (כתום) -> UNO Pin D6
• ESP-01 Ch-Pd (חום) -> Vcc (3.3V)
• איפוס ESP-01 (כחול) -> פין D8 של UNO
• ESP-01 Vcc (אדום) -> 3.3V
• ESP-01 Gnd (שחור) -> UNO GND
שים לב כי הספרייה תוכנה טורית משתמשת בסיכה של ה- UNO Pin D7 כמו tx וזה מתחבר לפלט של ESP-01 Rxואילו UNO פין D6 כמו rxמחובר ל- ESP-01 טקסס.
הזן קוד קטן על מנת לבדוק את החיבור והתצורה הנכונים של מודול ESP-01
# כלול
SoftwareSerial esp8266 (6.7); // Rx ==> פין 6; TX ==> Pin7
# הגדר מהירות 8266 9600
הגדרת ביטול ()
{
esp8266.begin (speed8266);
Serial.begin (speed8266);
Serial.println ("מבחן הגדרת ESP8266 - השתמש ב- coomands AT");
}
לולאה חלילה ()
{
while (esp8266.available ())
{
Serial.write (esp8266.read ());
}
בזמן (Serial.available ())
{
esp8266.write (Serial.read ());
}
} עכשיו כמה צוותי AT. ראה את התוצאות במוניטור הסידורי.
* AT =====> ESP8266 מחזיר אישור
* AT + RST =====> ESP8266 הפעל מחדש ומחזיר אישור
* AT + GMR =====> ESP8266 מחזיר גרסת AT; גרסת SDK; id; אוקיי
* ב- + CWMODE? => ESP8266 מחזיר את סוג המצב
* AT + CWLAP ===> ESP8266 מחזיר נקודות גישה קרובות
* AT + CIFSR ===> ESP8266 מחזיר IP המיועד
ניתן להוריד את קוד התוכנית בכתובת
6 חיבור חיישנים ו- ESP-01
לאחר שכל החיישנים מחוברים ונבדקים, כמו גם בדיקת מודול ESP-01, יש להכין את הנתונים לשליחה לאינטרנט.
7 ThingSpeak
אחד החלקים החשובים בפרויקט הוא פלטפורמת IoT הפתוחה, שתאפשר לכם לאסוף נתונים מחיישנים, לעבד אותם ולנתח אותם. לשם כך, עבור אל צור את חשבונך. בשלב הבא עליכם ליצור ערוץ בו יהיו 2 מפעילים, 5 חיישנים ושדה גיבוי אחד.
• שדה 1: מפעיל 1 (מכשיר 1)
• שדה 2: מפעיל 2 (מכשיר 2)
• שדה 3: טמפרטורת האוויר ב- oC (טמפרטורת האוויר במעלות צלזיוס)
• מוגש 4: לחות יחסית באוויר ב-% (לחות יחסית ב%)
• שדה 5: טמפרטורת קרקע ב- OC (טמפרטורת קרקע בגודל צלזיוס)
• שדה 6: לחות קרקע באחוזים (לחות אדמה ב%)
• שדה 7: בהירות ב% (תאורה ב%)
• שדה 8: חילוף
שדה 8 שמור להרחבה עתידית או לניפוי באגים. בפרויקט זה הוא משמש כמונה שגיאות תקשורת בין Arduino / ESP-01 ל- ThingSpeak.com.
לאחר שיצרתם את ערוץ הסטטוס, עליכם להקליט את המקשים, כמוצג בתמונה.
8 שליחת מצב חיישן לענן
כרגע יש לנו שירות ענן מוגדר והחיישנים שלנו אוספים נתונים באופן מקומי. עכשיו אתה צריך לקחת נתונים אלה ולשלוח אותם לענן באתר ThingSpeak.com.
על מנת לכתוב נתונים לערוץ ThingSpeak עליכם לשלוח מחרוזת GET. זה ייעשה בשלושה שלבים.
שלח את הפקודה "התחל cmd"
AT + CIPSTART = "TCP", "184.106.153.149", 80
אורך מחרוזת נוסף
ב- + CIPSEND = 116ולבסוף, מחרוזת GET שתכתוב את הנתונים שלנו בשדות ערוץ המצב השמורים.
קבל / עדכן? Api_key = your_saved_key_here & field1 = Pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = earthTemp & field6 = earthHum & field7 = light & field8 = spareשימו לב שאסור לנו לכתוב נתונים לערוץ יותר מפעם אחת תוך 16 שניות.
הקוד שהוגש יעשה את כל זה.
// שיחת דברים
String statusChWriteKey = "מפתח הכתב שלך כאן"; // מזהה ערוץ סטטוס: 385184
# כלול
SoftwareSerial EspSerial (6, 7); // Rx, Tx
# הגדר HARDWARE_RESET 8
// DS18B20
#include
# כלול
# הגדר את ONE_WIRE_BUS 5 // DS18B20 בסיכה D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int earthTemp = 0;
// DHT
# כלול "DHT.h"
# כלול
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;
// LDR (אור)
# הגדר ldrPIN 1
אור int = 0;
// לחות בקרקע
# הגדר אדמה humpin 0
int earthHum = 0;
// משתנים לשימוש עם טיימרים
writeTimingSeconds ארוך = 17; // ==> הגדר את זמן הדגימה בשניות לשליחת נתונים
startWriteTiming ארוך = 0;
long elapsedWriteTime = 0;
// משתנים לשימוש עם מפעילים
משאבה בוליאנית = 0;
מנורה בוליאנית = 0;
int חילוף = 0;
שגיאה בוליאנית;
הגדרת ביטול ()
{
Serial.begin (9600);
pinMode (HARDWARE_RESET, OUTPUT);
digitalWrite (HARDWARE_RESET, HIGH);
DS18B20.begin ();
dht.begin ();
EspSerial.begin (9600); // Comunicacao com Modulo WiFi
EspHardwareReset (); // אפס לעשות מודולו WiFi
startWriteTiming = מיליס (); // הפעלת "שעון התוכנית"
}
לולאה חלילה ()
{
התחל: // תווית
שגיאה = 0;
elapsedWriteTime = מיליס () - startWriteTiming;
אם (elapsedWriteTime> (writeTimingSeconds * 1000))
{
חיישני קריאה ();
writeThingSpeak ();
startWriteTiming = מיליס ();
}
אם (שגיאה == 1) // שלח שוב אם ההעברה לא הושלמה
{
Serial.println ("<<<< שגיאה >>>>");
עיכוב (2000);
להתחיל להתחיל; // עבור לתווית "התחל"
}
}
/ ********* קריאת ערך חיישנים ************* /
voens readensensors (void)
{
airTemp = dht.readTemperature ();
airHum = dht.readHumidity ();
DS18B20.requestTemperatures ();
earthTemp = DS18B20.getTempCByIndex (0); // חיישן 0 יתפוס את טמפרטורת האדמה בסלסיוס
אור = מפה (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> 100% אור
earthHum = מפה (analogRead (undergroundHumPIN), 1023, 0, 0, 100);
}
/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (void)
{
startThingSpeakCmd ();
// prepacao da string GET
מחרוזת getStr = "קבל / עדכן? Api_key =";
getStr + = statusChWriteKey;
getStr + = "& field1 =";
getStr + = מחרוזת (משאבה);
getStr + = "& field2 =";
getStr + = מחרוזת (מנורה);
getStr + = "& field3 =";
getStr + = מחרוזת (airTemp);
getStr + = "& field4 =";
getStr + = מחרוזת (airHum);
getStr + = "& field5 =";
getStr + = מחרוזת (earthTemp);
getStr + = "& field6 =";
getStr + = מחרוזת (earthHum);
getStr + = "& field7 =";
getStr + = מיתר (קל);
getStr + = "& field8 =";
getStr + = מחרוזת (חילוף);
getStr + = "\ r \ n \ r \ n";
sendThingSpeakGetCmd (getStr);
}
/ ********* איפוס ESP ************* /
void EspHardwareReset (בטל)
{
Serial.println ("מאפס .......");
digitalWrite (HARDWARE_RESET, LOW);
עיכוב (500);
digitalWrite (HARDWARE_RESET, HIGH);
עיכוב (8000); // Tempo necessário para começar a ler
Serial.println ("אפס");
}
/ ********* התחל לתקשר עם ThingSpeak ************* /
void startThingSpeakCmd (void)
{
EspSerial.flush (); // limpa o buffer antes de começar a gravar
מחרוזת cmd = "AT + CIPSTART = \" TCP \ ", \" ";
cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
cmd + = "\", 80 ";
EspSerial.println (cmd);
Serial.print ("enviado ==> התחל cmd:");
Serial.println (cmd);
אם (EspSerial.find ("שגיאה"))
{
Serial.println ("שגיאת AT + CIPSTART");
לחזור
}
}
/ ********* שלח cmd GET ל- ThingSpeak ************* /
מחרוזת sendThingSpeakGetCmd (מחרוזת getStr)
{
מחרוזת cmd = "AT + CIPSEND =";
cmd + = מחרוזת (getStr.length ());
EspSerial.println (cmd);
Serial.print ("enviado ==> ס"מ רוחב:");
Serial.println (cmd);
אם (EspSerial.find ((char *) ">")
{
EspSerial.print (getStr);
Serial.print ("enviado ==> getStr:");
Serial.println (getStr);
עיכוב (500); // tempo para מעבד o GET, sem este עיכוב apresenta עסוק בלי próximo comando
מחרוזת messageBody = "";
בזמן (EspSerial.available ())
{
קו מחרוזת = EspSerial.readStringUntil ('\ n');
if (line.length () == 1)
{// תוכן בפועל מתחיל אחרי שורה ריקה (שיש לה אורך 1)
messageBody = EspSerial.readStringUntil ('\ n');
}
}
Serial.print ("MessageBody קיבל:");
Serial.println (messageBody);
להחזיר הודעה גוף;
}
אחר
{
EspSerial.println ("AT + CIPCLOSE"); // משתמש התראה
Serial.println ("שגיאת CIPEND ESP8266: Resending"); // שלח שוב ...
חילוף = חילוף + 1;
שגיאה = 1;
להחזיר "שגיאה";
}
}
אתה יכול לראות את ההתקדמות במוניטור הסידורי.
ניתן להוריד את קוד המקור בכתובת
אפליקציית אנדרואיד 9 - חלק ראשון
ראשית עליך ליצור ממשק משתמש. התמונה מציגה את האלמנטים העיקריים הגלויים והבלתי נראים.
לאחר מכן, עליך ליצור בלוקים. פריטי התפריט תואמים למספרי המסך.
1 משתני מדינה שצריך להכריז עליהם כגלובלי
2 כל שתי שניות (תלוי בשעון 1) נקרא נוהל "קרא ארדואינו"
הנוהל מחזיר את ערך המשתנים שצריך להציג על המסך. במקרה זה, ערך המצב (0 ו- 1) עבור המפעילים מומרים ל" ON "ו-" OFF "לתפיסה טובה יותר.
ערכים אלה (סטטוס) יוצגו ב"קיצורי הדרך "המתאימים.
3 שגרת readArduino תקרא למעשה את ערוץ הסטטוס ב- ThingSpeak. לכן, עליכם לקבוע את כתובת האתר שתישלח ל- Thingspeak. לשם כך יש להכריז ולשלב 3 משתנים גלובליים כדי ליצור את כתובת האתר שתישלח ל- ThingSpeak. יש לשלוח GET לרכיב אינטרנט הנקרא "ArduFarmBotStatusCh"
4 טקסט שהתקבל מהפקודה הקודמת יגיע בפורמט JSon. יש לעבד טקסט זה כך שכל שדה ייקרא ואוחסן במשתנה הגלובלי המתאים.
5 הדבר האחרון שצריך לעשות הוא לקרוא להליך "אזעקה", אשר ינתח את מצבם של שני חיישני קרקע. אם הטמפרטורה נמוכה מדי (במקרה שלנו 10oC), יש להציג הודעה. אותו דבר לגבי לחות אם הוא מתחת ל 60%.
שימו לב שהגדרנו טיימר אחר (Clock2), שתוכנתנו שהוא יפעל כל שנייה. זה נחוץ רק כדי "לעבור" את צבע טקסט ההודעה (מלבן לאדום). ההודעה תבהב.
ניתן להוריד את קוד היישום בכתובת
10 חיבור מפעילים
פקודות להפעלת וכיבוי המשאבה והמנורה יתקבלו מרחוק. הפלט של ארדוניו יפעיל את הממסר ואת הלד, תוך כדי ביצוע פקודות אלה. בתמונה נראה כיצד יש לחבר את המפעילים. שימו לב שפלט ממסר GND לא מחובר לפלט GNDUNO. בדרך זו תהיה פחות הפרעות כוח כאשר הממסר פועל.
11 תצורה של מפעילי הערוץ (ערוצי מפעילים)
כל הפעולות חוזרות על ההליך להגדרת תצורת ערוץ הסטטוס. יש צורך ליצור שני ערוצים לכל אחד מהמכשירים. עבור כל ערוץ, כתוב את מקשי מזהה הערוץ, הקריאה והכתיבה. נכתוב רק בשדה הראשון של כל ערוץ. לדוגמא:
מזהה ערוץ 375598 ==> LED אדום (משאבה)
◦ שדה 1 = 0 ==> משאבה OFF
◦ שדה 1 = 1 ==> משאבה ON
2. ערוץ מזהה 375599 ==> LED ירוק (מנורה)
◦ שדה 1 = 0 ==> מנורה כבויה
◦ שדה 1 = 1 ==> מנורה דולקת
11 טעינה ובדיקת מפעילי קוד בארדוניו.
כששלחנו נתונים לענן, "כתבנו" נתונים אלה לערוץ ThingSpeak. ערוץ סטטוס, "משדר" (העלאת) נתונים אלה. כעת עלינו "לקרוא" את הנתונים מערוץ מפעיל, "לקבל" (להוריד) נתונים אלה.
לשם כך, שלח מחרוזת GET והליך זה מורכב משלושה שלבים.
"התחל cmd"
AT + CIPSTART = "TCP", "184.106.153.149", 80אורך קו
ב- + CIPSEND = 36והמחרוזת GET עצמה
GET / ערוצים / 375598 / שדות / 1 / אחרוןהערוצים "יקראו" כל 10 שניות
לאחר שליחת ה- GET, עלינו לקבל את התגובה מ- ThingSpeak. התשובה חייבת להיות 0 או 1, עבור כל ערוץ. אם ישנם ערכים אחרים, אנו פשוט מתעלמים מהם.
ההבדל העיקרי בין חלק זה לחלק הקודם הוא רק בפונקציה readThingSpeak (מחרוזת ערוץID)
להלן הקוד המבצע את הפעולות המתוארות.
// שיחת דברים
String canalID1 = "999999"; // מפעיל 1
String canalID2 = "999999"; // מפעיל 2
# כלול
SoftwareSerial EspSerial (6, 7); // Rx, Tx
# הגדר HARDWARE_RESET 8
// משתנים לשימוש עם טיימרים
readTimingSeconds ארוך = 10; // ==> הגדר את זמן הדגימה בשניות לקבלת נתונים
startReadTiming ארוך = 0;
long elapsedReadTime = 0;
// ממסרים
#define ACTUATOR1 10 // LED אדום ==> משאבה
#define ACTUATOR2 12 // LED ירוק ==> מנורה
משאבה בוליאנית = 0;
מנורה בוליאנית = 0;
int חילוף = 0;
שגיאה בוליאנית;
הגדרת ביטול ()
{
Serial.begin (9600);
pinMode (ACTUATOR1, OUTPUT);
pinMode (ACTUATOR2, OUTPUT);
pinMode (HARDWARE_RESET, OUTPUT);
digitalWrite (ACTUATOR1, HIGH); // o módulo relé é ativo em LOW
digitalWrite (ACTUATOR2, HIGH); // o módulo relé é ativo em LOW
digitalWrite (HARDWARE_RESET, HIGH);
EspSerial.begin (9600); // Comunicacao com Modulo WiFi
EspHardwareReset (); // אפס לעשות מודולו WiFi
startReadTiming = מילי (); // הפעלת "שעון התוכנית"
}
לולאה חלילה ()
{
התחל: // תווית
שגיאה = 0;
elapsedReadTime = מיליס () - startReadTiming;
אם (elapsedReadTime> (readTimingSeconds * 1000))
{
פקודה int = readThingSpeak (canalID1);
אם (פקודה! = 9) משאבה = פקודה;
עיכוב (5000);
command = readThingSpeak (canalID2);
אם (פקודה! = 9) מנורה = פקודה;
פעולות ();
startReadTiming = מילי ();
}
אם (שגיאה == 1) // שלח שוב אם ההעברה לא הושלמה
{
Serial.println ("<<<< שגיאה >>>>");
עיכוב (2000);
להתחיל להתחיל; // עבור לתווית "התחל"
}
}
/ ********* בצע פעולות המבוססות על פקודות ThingSpeak ************* /
פעולות בטלות (בטלות)
{
Serial.print ("משאבה:");
Serial.println (משאבה);
Serial.print ("מנורה:");
Serial.println (מנורה);
אם (משאבה == 1) digitalWrite (ACTUATOR1, LOW);
digitalwrite אחר (ACTUATOR1, HIGH);
אם (מנורה == 1) digitalWrite (ACTUATOR2, LOW);
digitalwrite אחר (ACTUATOR2, HIGH);
}
/ ********* קרא את הפקודה על מפעילים מ- ThingSpeak ************* /
int readThingSpeak (ערוץ מחרוזת)
{
startThingSpeakCmd ();
פקודה int;
// prepacao da string GET
String getStr = "GET / ערוצים /";
getStr + = channelID;
getStr + = "/ שדות / 1 / אחרון";
getStr + = "\ r \ n";
מחרוזת messageDown = sendThingSpeakGetCmd (getStr);
אם (messageDown [5] == 49)
{
command = messageDown [7] -48;
Serial.print ("הפקודה קיבלה:");
Serial.println (פקודה);
}
פקודה אחרת = 9;
פקודת השיבה;
}
/ ********* איפוס ESP ************* /
void EspHardwareReset (בטל)
{
Serial.println ("מאפס .......");
digitalWrite (HARDWARE_RESET, LOW);
עיכוב (500);
digitalWrite (HARDWARE_RESET, HIGH);
עיכוב (8000); // Tempo necessário para começar a ler
Serial.println ("אפס");
}
/ ********* התחל לתקשר עם ThingSpeak ************* /
void startThingSpeakCmd (void)
{
EspSerial.flush (); // limpa o buffer antes de começar a gravar
מחרוזת cmd = "AT + CIPSTART = \" TCP \ ", \" ";
cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
cmd + = "\", 80 ";
EspSerial.println (cmd);
Serial.print ("enviado ==> התחל cmd:");
Serial.println (cmd);
אם (EspSerial.find ("שגיאה"))
{
Serial.println ("שגיאת AT + CIPSTART");
לחזור
}
}
/ ********* שלח cmd GET ל- ThingSpeak ************* /
מחרוזת sendThingSpeakGetCmd (מחרוזת getStr)
{
מחרוזת cmd = "AT + CIPSEND =";
cmd + = מחרוזת (getStr.length ());
EspSerial.println (cmd);
Serial.print ("enviado ==> ס"מ רוחב:");
Serial.println (cmd);
אם (EspSerial.find ((char *) ">")
{
EspSerial.print (getStr);
Serial.print ("enviado ==> getStr:");
Serial.println (getStr);
עיכוב (500); // tempo para מעבד o GET, sem este עיכוב apresenta עסוק בלי próximo comando
מחרוזת messageBody = "";
בזמן (EspSerial.available ())
{
קו מחרוזת = EspSerial.readStringUntil ('\ n');
if (line.length () == 1)
{// תוכן בפועל מתחיל אחרי שורה ריקה (שיש לה אורך 1)
messageBody = EspSerial.readStringUntil ('\ n');
}
}
Serial.print ("MessageBody קיבל:");
Serial.println (messageBody);
להחזיר הודעה גוף;
}
אחר
{
EspSerial.println ("AT + CIPCLOSE"); // משתמש התראה
Serial.println ("שגיאת CIPEND ESP8266: Resending"); // שלח שוב ...
חילוף = חילוף + 1;
שגיאה = 1;
להחזיר "שגיאה";
}
} תוכלו להוריד אותו בכתובת
12 שליחת פקודות למכשירים
בשלב זה יש לנו ערוץ מפעיל מוגדר שמשנה את הערך של שדה 1 לכל מכשיר. עלינו לוודא שהמכשירים עובדים על הפקודות כראוי. בסוף הפרויקט ישמש יישום אנדרואיד לשם כך, אך ניתן לעשות זאת גם באמצעות דפדפן.
הפעל את המשאבה (נורית LED אדומה)
https://api.thingspeak.com/update?api_key=Saved_channel_key_1&field1=1משאבה כבויה (נורית LED אדומה כבויה)
https://api.thingspeak.com/update?api_key= Channel_key_1 נשמר & field1 = 0הדלק את המנורה (נורית LED דולקת)
https://api.thingspeak.com/update?api_key= Channel_key_2 נשמר & field1 = 1כבה את המנורה (נורית LED ירוקה)
https://api.thingspeak.com/update?api_key= Channel_key_2 נשמר & field1 = 014 סיום תוכנית אנדרואיד
בחלק הקודם הייתה תוכנית פשוטה ש"קריאה "את הנתונים מהערוץ והציגה אותם על המסך. כעת עלינו להפוך את התוכנית "לרשום" את הפקודות בערוץ מפעיל, כך שניתן לקרוא את הפקודות על ידי הבקר והמנורה עם המשאבה פועלת בהתאם.
כך שהמשתמש יכול לשלוח פקודות, לאפליקציה יהיו שני כפתורים לכל מכשיר. אם זה מופעל, כחול; אם הוא כבוי, אדום.
על ידי לחיצה על הכפתורים ביישום, תוכלו לראות את התוצאה במוניטור הסידורי.
ניתן להוריד את הקוד בכתובת
15 הרכבה סופית
בשלב זה, קיימת אפליקציית אנדרואיד שהושלמה במלואה, חלק "ברזל" שהורכב במלואו, אך בבקר אין קוד שכל הזמן היה קורא את הנתונים ושולח פקודות לענן. אתה רק צריך לשלב את כל שברי הקוד שנכתבו קודם לכן, כמובן שלקוד יש אפשרויות אימות נוספות (לדוגמה, אם ESP-01 קופא). לשם כך, מעת לעת, לפני כל פקודת קריאה או כתיבה, נשלחת פקודת AT.ואם התשובה אישור לא הגיעה מהמודול, אז המודול מופעל מחדש בכוח באופן תכנותי.
ניתן להוריד את קוד הפרויקט המלא בכתובת
בכתובת תוכלו לקבל עדכונים לקבצי התוכנית.
אתה יכול גם לקרוא הערות בקישור למקור, אם משהו לא ברור.