תיבת מכתבים מחוברת מופעלת באמצעות סולארית: 12 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

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

לאחר שקראתי את המדריך הזה (+ הרבה אחרים), ומאחר ותיבת המכתבים שלי לא נמצאת ליד ביתי, רציתי לעורר אותי בעבודות של Open Green Energy כדי לחבר את תיבת המכתבים שלי לשרת Domoticz שלי.

מטרות

• קבל ייעוץ מטלגרם כאשר מכתבים מגיעים;
• קבל ייעוץ מטלגרם כאשר מגיעה חבילה;
• בדוק אם האותיות / החבילות נאספו.

האילוץ העיקרי שלי

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

הייתי צריך למצוא פתרון אחר: אנרגיה סולארית הייתה פתרון טוב!

ה- BOM

• Raspberry Pi (לארח חלקים של MQTT ו- Domoticz - לא מפורט כאן)
• חשבון טלגרם בוט
• Lolin D1 mini (או Wemos …)
• מחבר בלוק מסוף לברגים
• לוח טעינת סוללות ליתיום TP4056
• פאנל סולארי פוטו -וולטאי 6V 2W
• סוללת Li-Ion 18650
• מחזיק סוללות ליתיום
• לוח PCB DIY הלחמת אבזם אבקה מודפס
• סרוו אנלוגי SG90
• 3 מתגי קנים (אחד לאותיות, אחד לחבילה ואחד לקופה)
• מגנטים
• כמה חוטים
• ארגז עץ: מכיוון שלא קיבלתי מדפסת תלת מימד, הבנתי את הבית הקטן שלי עם עץ לקלוט חלקי אלקטרוניקה …
• כבל אתרנט חלופי

• לוח פריצה של מחבר אתרנט RJ45

• J-B Weld
• כמה מסבים לכדור
• ברגים, אגוזים, מכונות כביסה

שלב 1: תוכנית גלובלית

ציורים יפים תמיד טובים יותר מנאומים ארוכים;-)

אבל כמה הסברים אודות MQTT, Domoticz ו- Telegram יתקבלו בברכה תמיד!

MQTT (Message Queuing Telemetry Transport), הוא פרוטוקול העברת הודעות, המשמש לשליחת נתונים בין מכשירים ומערכות אחרות בעולם ה- IoT (Internet of Things).

מבלי להיכנס ליותר מדי פרטים, פעולתו מבוססת על עקרון הלקוחות המתחברים לשרת. ב- MQTT, הלקוחות נקראים Subscriber או Publisher, והשרת נקרא Broker.

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

חלק הברוקר נעשה על ידי Mosquitto, המותקן ב- Raspberry Pi (שלב 3).

אודות דומוטיקז:

כפי שמתואר בדף המקור, Domoticz היא "מערכת אוטומציה ביתית", המאפשרת לך לשלוט במכשירים שונים ולקבל קלט מפרוטוקולים שונים: MQTT הוא אחד הפרוטוקולים הנתמכים …

ברגע שהמידע מגיע אליו (שלב 4), אתה יכול להגדיר אירועים: במקרה של תיבת המכתבים, בחרתי לשלוח הודעת טלגרם (שלב 5).

לבסוף, לקוח הטלגרם מוגדר בטלפון שלי (וגם באשתי! - שלב 6): המטרה הסופית מושגת …

שלב 2: סכמטי / חיווט

מילה אחת על האנלוגי נקרא:

קודם כל שמתי לב לאחר כמה מחקרים ש- Lolin mini D1 (כמו ה- Wemos הישן), בנה מחלק מתח עבור סיכה A0 (בהתחשב ב -220 KΩ עבור R1 ו- 100 KΩ עבור R2 - ראה מימין לגליון הנתונים המקושר), ומאפשר 3.2 וולט כמתח הכניסה האנלוגי המרבי.

בהתחשב במתח היציאה המרבי מהסוללה הוא 4, 2v (מוגבל על ידי לוח הטעינה), ותיאורטית, אתה רק צריך להוסיף מעבד חיצוני (בסדרה עם R1) כדי להגדיל את טווח מתח הכניסה המרבי. לאחר מכן, אם תוסיף 100K בסדרה עם R1, תהיה לך התוצאה הבאה:

Vin * R1/(R1+R2) = Vout

4, 2 * 320K/(320K+100K) = 3, 2

במעגל שלי בחרתי להיות מסוגל להתאים את ערכו, לכן העדפתי להשתמש בנגד מתכוונן במעגל שלי: אולי זה יהיה חסר תועלת עבורך, אך במצבי, הגדרתי את ערכו כ- 10KΩ שיהיה ערך קוהרנטי ב- Domoticz…

שים לב שלפין A0 יש רזולוציה של 10 סיביות: המשמעות היא שבשרטוט שלך, הקריאה האנלוגית שלך תחזיר ערך בין 0 ל- 1024.

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

שלב 3: ניהול כוח

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

• סוללת Li-Ion 18650 של 4000mAh;
• פאנל סולארי שיכול לספק 6V / 2W;
• לוח טעינה של סוללת ליתיום TP4056.

כדי לבחור את הפאנל הסולארי המתאים ביותר, הסתכלתי על כמה דוגמאות, כולל זו: בדוגמה זו נעשה שימוש בפאנל סולארי של 5.5V / 0.66W, וכנראה שהוא מספיק למטרה. במקרה שלי, וכפי ש- ESP8266 חייב להישאר דולק במהלך היום וחייב להיות מסוגל להפעיל מנוע סרוו כדי לשמור על הבית מול השמש, בחרתי בדגם פאנל סולארי חזק יותר (6V / 2W) - זה גם מאפשר לי לצפות לתקופות חורף אפלות וימים מעוננים;-)

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

• בידיעה כי הדוור עבר רק בין השעות 7: 00-20: 00, ESP ממוקם ב- DeepSleep כל שאר הלילה;
• הגורם אינו עובר בין שבת בצהריים לשני בבוקר: ה- ESP ממוקם גם במצב DeepSleep במהלך תקופה זו.
• לתקופה שבין 7 בבוקר ל -20 בערב, וכדי לצמצם את צריכת החשמל, אני פשוט משבית את ממשק הרשת של ה- ESP: הרשת מופעלת מחדש רק עם הגעת חבילה או מכתב, מספיק זמן לשלוח את המידע אל אין צורך להזהיר מיידית את Domoticz.השניות הנוספות הנוספות הדרושות להפעלה מחדש של ממשק הרשת אינן מזיקות!

ערך כלשהו לגבי הצריכה במצבים שונים שבהם אני משתמש עבור ה- Lolin - תסתכל על גליון הנתונים, p18:

• במצב רגיל (עם RF עבודה) צריכת החשמל יכולה לעלות ל 170mA! היות ותיבת הדואר שלי נמצאת במרחק של כ -50 מטרים מהבית שלי (ובגבול האות WIFI …) אני מניח שהעוצמה המשמשת לשמירה על החיבור היא בשיא המקסימום שלו …
• במודם-שינה, צריכת החשמל יורדת ל -15mA. אך כפי שאתה יכול לראות בגיליון הנתונים, הוא לא עצר לחלוטין את המודם, מכיוון ש- ESP "שומר על חיבור Wi-Fi ללא העברת נתונים".
• בשינה עמוקה, הכוח יורד ל 20uA.

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

WiFi.disconnect ();

עיכוב (1000); WiFi.mode (WIFI_OFF); עיכוב (1000); WiFi.forceSleepBegin (); עיכוב (1);

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

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

שלב 4: התקנת מגנטים ושדות קשרים

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

כדי לתקן את מגע הקנה בחור שלו, השתמשתי במעט ריתוך J-B.

עבור החבילה והתפוקה, פיסת קלטת קטנה, מעט מסור, והמטרה מושגת!

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

שלב 5: התחבר לבית הקטן שלי

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

אתה יכול להשתמש בדגם הזה או, כמוני, להשתמש במגן ישן של Arduino Ethernet שתלוי במגירות שלי: הוא לא סבל, הוא היה אמיץ מול המסור, מותו היה מהיר ^^

רק מילה אחת על מגן ה- Ethernet של Arduino: אל תצפה שיהיו לי 8 מנהלי התקנים נפרדים … כבלים משויכים לשניים בתוך המגן … זה שיגע אותי יותר מדי זמן !!!

שלב 6: בבית…

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

שלב 7: תן לזה לפטיפון …

המטרה היא לשמור אותו מול השמש …

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

עד עכשיו השתמשתי בסרוו SG90 (מומנט: 1.8 ק"ג/ס"מ ב -4.8 וולט).

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

הזמנתי עוד אחד (מומנט MG995: 9.4 קג"מ/ס"מ ב -4.8 וולט), גם הוא לא יקר במיוחד, אבל עם הילוכים ממתכת.

זה יהיה הדבר הבא לעשות כשקיבלתי אותו: אני סומך על תיבת הדואר המחוברת שלי שיודיע לי על הגעתו!

שלב 8: כמה בדיקות

כמה הערות:

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

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

• אבל, עם MG 995:

  • זווית הסיבוב הכוללת אינה זהה (רחבה יותר): הייתי צריך להשתמש בפונקציה נוספת כדי להקטין אותה (Servo_Delta ()).
  • צריך שלב DC/DC כדי לספק מספיק מתח לסרוו … להמשך …

/*

- TEST עם SG90: אין צורך נוסף, הוא יכול לעבוד עם מתח OUT שמגיע מבקר הסוללה - ל- MG 995: - השתמש בפונקציית Servo_Delta () … - יש צורך בהגברת DC/DC כדי לספק מספיק מתח לסרוו … המשך: */ #include bool Logs = true; סרוו מיסרבו; #הגדר PIN_SERVO D2 // מיקום סרוו עבור: 7h, 8h, 9h, 10h, 11h, 12h, 13h, 14h, 15h, 16h, 17h, 18h, 19h, 20h, 21h // int Arr_Servo_Pos = {177, 173, 163, 148, 133, 118, 100, 80, 61, 41, 28, 15, 2, 2, 2}; int Arr_Servo_Pos = {180, 175, 165, 150, 135, 120, 102, 82, 63, 43, 30, 15, 0, 0, 0}; int ישן; int pos; int i; הגדרת void () {Serial.begin (115200); } לולאת חלל () {עבור (i = 7; i <= 22; i ++) {old = i; if (i == 7) {if (Logs) Serial.println ("Positionne le servo pour 7 Heure"); myservo.attach (PIN_SERVO); for (int index = Arr_Servo_Pos [(sizeof (Arr_Servo_Pos) / sizeof (Arr_Servo_Pos [0])) -1]; אינדקס 7 && i = Arr_Servo_Pos [i-7]; אינדקס-) {אם (יומנים) Serial.println (אינדקס); if (Logs) Serial.print ("ערך מותאם:"); if (יומנים) Serial.println (Servo_Delta (אינדקס)); עיכוב (200); //myservo.write(Servo_Delta(index)); myservo.write (אינדקס); } עיכוב (15); myservo.write (Arr_Servo_Pos [i-7]); // כתוב שוב את הערך האחרון כדי להימנע מתנועות קשות כאשר datach myservo.detach (); }}} עיכוב (2000); }} int Servo_Delta (int int) {int Temp_val; Temp_val = (ערך*0.80) +9; החזר Temp_val; }

שלב 9: הבית הקטן

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

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

אתה יכול לראות את "הווילונות היפים" … זה מה שקורה כשאתה מבקש מאשתך לעשות את העבודה ^^

שלב 10: הסקיצה

בעיצומו … אבל נראה שהוא יציב

אני עדיין עובד על הקוד: מכיוון שזו לא גרסה סופית, הערותיכם / עצותיכם יתקבלו בברכה;-)

כמה הערות:

• הם הרבה עיכובים () בקוד: זה כדי למנוע התרסקות רבה של הלולין, במיוחד בעת עצירת רשת מתחילה …
• לא מצאתי דרך קלה ואמינה להשיג את אזימוט השמש: בגלל זה תיקנתי את ערך הסרופו לפי מה שראיתי … יש לך דרך טובה (ופשוטה) להשיג אותו, מעניין אותי! מסלול ללמוד כאן, גם אם אני מעדיף ממשק API מקוון נותן לי את האזימוט ישירות על פי התאריך, השעה והמיקום הגיאוגרפי …
• אודות טכניקת השינה: מכיוון שה- Lolin הוא מעבד Tensilica של 32 סיביות, הערך המרבי שלו עבור מספר שלם ללא סימן של 32 סיביות הוא 4294967295… אם כן, הוא נותן בערך 71 דקות לכל מרווח השינה העמוקה. לכן אני עושה שינה L'ESP פעמים רבות במשך כ -60 דקות …

עריכה - 2018-10-08:

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

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

• בגליון הנתונים של Lolin, פלט D4 כבר מחובר ל- BUILTIN_LED …
• בגיליון הנתונים ESP8266ex, אנו לומדים שפלט D4 משמש כמשדר UART 1/U 1 TXD (משדר מקלט אסינכרוני אוניברסלי). מצוין גם ש- UART1 זה משמש להדפסת יומן רישום.

על ידי קריאת המידע הזה הבנתי שפלט D4 אינו רעיון טוב, במיוחד לנהל מנוע סרוו!

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

//****************************************

תאריך יצירה: 08/תאריך התאריך: 08/גירסה: 0.9.4 גרסה IDE Arduino: 1.8.6 מהירות העלאה: 921600 Type de carte dans l'IDE: "LOLIN (WEMOS) D1 R2 & mini" מבנה גוף: LOLIN (WEMOS) D1 R2 & mini (https://www.amazon.fr/gp/product/B01ELFAF1S/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1) פונקציית פינים ESP-8266 אזור ניצול פינים ------- -------------------------------------------------- ------------------------------------ TX TXD TXD RX RXD RXD A0 קלט אנלוגי, מקסימום 3.3V קלט A0 מתח המתח D0 IO GPIO16 Connecté à RST (pour le deep.sleep) D1 IO, SCL GPIO5 D2 IO, SDA GPIO4 Servo moteur D3 IO, 10k Pull-up GPIO0 D4 IO, 10k pull-up, BUILTIN_LED GPIO2 D5 IO, SCK GPIO14 Reed relève D6 IO, MISO GPIO12 Reed lettre D7 IO, MOSI GPIO13 Reed colis D8 IO, 10k pull-down, SS GPIO15 G ground GND 5V 5V-3V3 3.3V 3.3V RST Reset RST Connecté à D0 (pour le deep deep).sleep) *************************************/ #include bool Logs = true; // wifi const char* ssid = "LOL"; const char* password = "LOL"; IPAddress ip (192, 168, 000, 000); IPAddress dns (192, 168, 000, 000); שער IPAddress (192, 168, 000, 000); רשת המשנה IPAddress (255, 255, 000, 000); לקוח WiFiClient; // סרוו #כלול #הגדר PIN_SERVO D2 סרוו myservo; // מיקום סרוו עבור: 7h, 8h, 9h, 10h, 11h, 12h, 13h, 14h, 15h, 16h, 17h, 18h, 19h, 20h, 21h int Arr_Servo_Pos = {179, 175, 165, 150, 135, 120, 102, 82, 63, 43, 30, 15, 1, 1, 1}; // קנים #הגדר PIN_SWITCH_OUT D5 בתים Old_Switch_State_OUT; בייט Switch_State_OUT; #הגדר PIN_SWITCH_IN_PARCEL D6 בתים Old_Switch_State_IN_PARCEL; בייט Switch_State_IN_PARCEL; #הגדר PIN_SWITCH_IN_LETTER D7 בתים Old_Switch_State_IN_LETTER; בייט Switch_State_IN_LETTER; מתג ארוך לא חתום PressTime; const unsigned long DEBOUCE_TIME = 200; // אנלוגי #הגדר PIN_ANALOG A0 // MQTT #include const char* MQTT_Server_IP = "כתובת MQTT שלך"; const int MQTT_Server_Port =; int IDX_Letter_Box =; int IDX_Parcel_Box =; int IDX_Letter_Box_Battery =; PubSubClient ClientMQTT (לקוח); char MQTT_Message_Buff [70]; מחרוזת MQTT_Pub_String; // מתח צף vcc; // NTP #include time_t tnow; int Old_Time = 0; int Int_Heures = 0; int Int_Minutes = 0; int Int_Sleep_Duration = 63; הגדרת חלל () {Serial.begin (115200); רשת (נכון); pinMode (PIN_SWITCH_OUT, INPUT_PULLUP); Old_Switch_State_OUT = digitalRead (PIN_SWITCH_OUT); pinMode (PIN_SWITCH_IN_LETTER, INPUT_PULLUP); Old_Switch_State_IN_LETTER = digitalRead (PIN_SWITCH_IN_LETTER); pinMode (PIN_SWITCH_IN_PARCEL, INPUT_PULLUP); Old_Switch_State_IN_PARCEL = digitalRead (PIN_SWITCH_IN_PARCEL); SendBatteryLevel (); רשת (שקר); // ערכת NTP tnow = time (nullptr); Int_Heures = מחרוזת (ctime (& tnow)). מחרוזת משנה (11, 13).toInt (); Int_Minutes = String (ctime (& tnow)). מחרוזת משנה (14, 16).toInt (); // נרדמת ללילה אם (! ((Int_Heures> = 7) && (Int_Heures <= 20))) {Serial.print ("Sleep pour la nuit ("); Serial.print (Int_Sleep_Duration - Int_Minutes); Serial. println ("דקות)"); שינה (Int_Sleep_Duration - Int_Minutes); }} לולאת void () {// NTP set tnow = time (nullptr); Int_Heures = מחרוזת (ctime (& tnow)). מחרוזת משנה (11, 13).toInt (); Int_Minutes = String (ctime (& tnow)). מחרוזת משנה (14, 16).toInt (); //Serial.println(String(ctime(&tnow))); //Serial.println ("Heure:" + מחרוזת (ctime (& tnow)). מחרוזת משנה (11, 13)); //Serial.println (מחרוזת (ctime (& tnow)). מחרוזת משנה (11, 13).toInt ()); // ניהול סרוו אם (Old_Time! = Int_Heures) {Old_Time = Int_Heures; if (Int_Heures == 7) {if (Logs) Serial.println ("Positionne le servo pour 7 Heure"); myservo.attach (PIN_SERVO); for (int index = Arr_Servo_Pos [(sizeof (Arr_Servo_Pos) / sizeof (Arr_Servo_Pos [0])) -1]; index 7 && Int_Heures = Arr_Servo_Pos [Int_Heures-7]; אינדקס-) {אם (יומנים) Serial.println (אינדקס); עיכוב (200); myservo.write (אינדקס); } עיכוב (15); myservo.write (Arr_Servo_Pos [Int_Heures-7]); // כתוב שוב את הערך האחרון כדי להימנע מתנועות קשות כאשר תנתק את myservo.detach (); } רשת (נכון); SendBatteryLevel (); רשת (שקר); }}}} // נרדמת אם שבת לאחר השעה 13 אם ((מחרוזת (ctime (& tnow)). מחרוזת משנה (0, 3) == "שבת") && (Int_Heures> = 13)) {if (יומני) Serial.print ("Sleep pour le samedi aprés midi ("); if (Logs) Serial.print (Int_Sleep_Duration - Int_Minutes); if (Logs) Serial.println ("דקות" "); שינה (Int_Sleep_Duration - Int_Minutes); } // נרדמת אם יום ראשון אם (מחרוזת (ctime (& tnow)). מחרוזת משנה (0, 3) == "שמש") {אם (יומנים) Serial.print ("Sleep pour le dimanche ("); if (Logs) Serial.print (Int_Sleep_Duration - Int_Minutes); אם (Logs) Serial.println ("דקות" "); שינה (Int_Sleep_Duration - Int_Minutes); } // ניהול קנים Switch_State_OUT = digitalRead (PIN_SWITCH_OUT); if (Switch_State_OUT! = Old_Switch_State_OUT) {if (millis () - switchPressTime> = DEBOUCE_TIME) {switchPressTime = millis (); if (Switch_State_OUT == HIGH) {Serial.println ("שליחות רלוונטית!"); רשת (נכון); עיכוב (5000); MQTT_Pubilsh (IDX_Letter_Box, 0, "0"); עיכוב (5000); MQTT_Pubilsh (IDX_Parcel_Box, 0, "0"); עיכוב (5000); רשת (שקר); }} Old_Switch_State_OUT = Switch_State_OUT; } Switch_State_IN_LETTER = digitalRead (PIN_SWITCH_IN_LETTER); if (Switch_State_IN_LETTER! = Old_Switch_State_IN_LETTER) {if (millis () - switchPressTime> = DEBOUCE_TIME) {switchPressTime = millis (); if (Switch_State_IN_LETTER == HIGH) {Serial.println ("שליח מגיע!"); רשת (נכון); עיכוב (5000); MQTT_Pubilsh (IDX_Letter_Box, 1, "Courrier"); עיכוב (5000); רשת (שקר); }} Old_Switch_State_IN_LETTER = Switch_State_IN_LETTER; } Switch_State_IN_PARCEL = digitalRead (PIN_SWITCH_IN_PARCEL); if (Switch_State_IN_PARCEL! = Old_Switch_State_IN_PARCEL) {if (millis () - switchPressTime> = DEBOUCE_TIME) {switchPressTime = millis (); if (Switch_State_IN_PARCEL == HIGH) {Serial.println ("colis arrivé!"); רשת (נכון); עיכוב (5000); MQTT_Pubilsh (IDX_Parcel_Box, 1, "Colis"); עיכוב (5000); רשת (שקר); }} Old_Switch_State_IN_PARCEL = Switch_State_IN_PARCEL; }} void SendBatteryLevel () {עיכוב (5000); vcc = analogRead (PIN_ANALOG) /10.24; if (Logs) Serial.println ("\ tTension relevant:" + מחרוזת (vcc, 0)); MQTT_Pubilsh (IDX_Letter_Box_Battery, 0, String (vcc, 0)); עיכוב (5000); } שינה חללה (int Min_Duration) {ESP.deepSleep (Min_Duration * 60e6); } רשת void (bool UpDown) {if (UpDown) {Serial.print ("התחלת רשת"); WiFi.forceSleepWake (); עיכוב (1); // init WIFI WiFi.config (ip, dns, gateway, subnet); WiFi.begin (ssid, סיסמא); בעוד (WiFi.status ()! = WL_CONNECTED) {עיכוב (500); Serial.print ("."); } עיכוב (5000); Serial.println ("."); Serial.print ("\ tConnected - כתובת IP:"); Serial.println (WiFi.localIP ()); // init MQTT ClientMQTT.setServer (MQTT_Server_IP, MQTT_Server_Port); // Init NTP Serial.print ("\ tTime Synch."); configTime (0, 0," fr.pool.ntp.org "); setenv (" TZ "," CET-1CEST, M3.5.0, M10.5.0/3 ", 0); while (time (nullptr) <= 100000) {Serial.print ("."); עיכוב (100);} Serial.println (".");} אחר {Serial.println ("עצירת רשת"); WiFi.disconnect (); עיכוב (1000); WiFi.mode (WIFI_OFF); עיכוב (1000); WiFi.forceSleepBegin (); עיכוב (1);}} חיבור ריק מחדש () {while (! ClientMQTT.connected ()) {Serial.print (" / t ניסיון לחיבור MQTT … "); // ניסיון להתחבר אם (ClientMQTT.connect (" ESP8266ClientBAL ")) {Serial.println (" מחובר ");} אחר {Serial.print (" נכשל, rc = "); סידורי.print (ClientMQTT.state ()); Serial.println ("נסה שוב בעוד 5 שניות"); // המתן 5 שניות לפני השהיית ניסיון חוזר (5000);}}} void MQTT_Pubilsh (int Int_IDX, int N_Value, String S_Value) {if (! ClientMQTT.connected ()) התחבר מחדש (); vcc = analogRead (PIN_ANALOG) /10.24; Serial.println ("\ t שלח מידע ל- MQTT …"); MQTT_Pub_String = "{" idx / ":" + מחרוזת (Int_IDX) + ", \" סוללה / ":" + מחרוזת (vcc, 0) + ", \" nvalue / ":" + N_Value + ", \" svalue / ": \" " + S_Value +" / "}"; MQTT_Pub_String.toCharArray (MQTT_Message_Buff, MQTT_Pub_String.length ()+1); ClientMQTT.publish ("domoticz/in", MQTT_Message_Buff); ClientMQTT.disconnect (); }

שלב 11: Domoticz

בדומוטיקז:

לשימוש כללי:

• צור שני "דמה (לא עושה כלום, השתמש במתגים וירטואליים)":

  1. הראשון לאותיות…
  2. השני לחבילה…
• עבור כל אחד מהם, התאם אישית הודעות;
• כמובן, עליך להתקין את אסימון ה- Tegegram שלך.

אופציונלי:

תוכל להוסיף "חיישן שירות" כדי לפקח על רמת הטעינה של הסוללה.

עצות: כאן תוכל למצוא הרבה סמלים מותאמים אישית בחינם …

שלב 12: סיכום

מקווה שהמדריך הזה יעזור לך:

• האם ליצור תיבת מכתבים מחוברת משלך;
• או סתם לתת לך כמה רעיונות לפרויקטים שלך!

אם יש לך רעיונות לשיפורים, אני מקשיב!

נ.ב: סליחה על האנגלית שלי, תרגום גוגל עוזר לי מאוד אבל כנראה שזה לא מושלם;-)