დაკავშირებული Letterbox Solar Powered: 12 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

მეორე იბლისთვის მე აღწერს ჩემს ნამუშევრებს ჩემი დაკავშირებული წერილების შესახებ.

ამ ინსტრუქციის (+ მრავალი სხვა) წაკითხვის შემდეგ და რადგანაც ჩემი წერილების ყუთი ჩემს სახლთან ახლოს არ არის, მინდოდა შთაგონებული გამხდარიყო ღია მწვანე ენერგიის ნამუშევრები ჩემი წერილების ყუთში ჩემს Domoticz სერვერთან დასაკავშირებლად.

მიზნები

• გაუგზავნეთ შეტყობინება Telegram- ს, როდესაც წერილები მოდის;
• Telegram- მა გირჩიათ ამანათის მოსვლისას;
• შეამოწმეთ თუ არა ასოები / ამანათები აღებული.

ჩემი მთავარი შეზღუდვა

საფოსტო ყუთი შედარებით შორსაა სახლიდან და შეუძლებელი იყო ელექტრო კაბელის გაყვანა იქამდე, რომ რაიმე მიეწოდებინა.

მე უნდა მომეძებნა სხვა გამოსავალი: მზის ენერგია კარგი გამოსავალი იყო!

BOM

• Raspberry Pi (MQTT და Domoticz ნაწილების მასპინძლობისთვის - აქ არ არის გავრცელებული)
• Telegram Bot ანგარიში
• Lolin D1 mini (ან Wemos…)
• დანამატიანი ხრახნიანი ტერმინალის ბლოკის კონექტორი
• TP4056 ლითიუმის ბატარეის დატენვის დაფა
• 6V 2W ფოტოელექტრონული მზის პანელი
• ბატარეა Li-Ion 18650
• Li-Ion ბატარეის დამჭერი
• PCB წვრილმანი Soldering Copper Prototype Printed Circuit Board
• ანალოგი Servo SG90
• 3 ლერწმის გადამრთველი (ერთი ასოებისთვის, ერთი ამანათისთვის და ერთი გამოსასვლელად)
• მაგნიტები
• ზოგიერთი მავთული
• ხის კრატი: რადგან არ მქონია 3D პრინტერი, მივხვდი, რომ ჩემი პატარა სახლი ხისგან ელექტრონიკის ნაწილების მისაღებად…
• სათადარიგო Ethernet კაბელი

• RJ45 Ethernet კონექტორი გარღვევის დაფა

• J-B Weld
• ზოგიერთი ბურთი საკისრები
• ხრახნები, თხილი, საყელურები

ნაბიჯი 1: გლობალური სქემა

ლამაზი ნახატები ყოველთვის უკეთესია ვიდრე გრძელი გამოსვლები;-)

MQTT, Domoticz და Telegram– ის შესახებ რამდენიმე ახსნა ყოველთვის მისასალმებელია!

MQTT (Message Queuing Telemetry Transport), არის შეტყობინებების პროტოკოლი, რომელიც გამოიყენება მონაცემთა გაგზავნის მოწყობილობებსა და სხვა სისტემებს შორის IoT სამყაროში (ნივთების ინტერნეტი).

ზედმეტი დეტალების შესვლის გარეშე, მისი მოქმედება ემყარება სერვერთან დაკავშირების კლიენტების პრინციპს. MQTT– ში კლიენტებს ეწოდება აბონენტი ან გამომცემელი, ხოლო სერვერს ჰქვია ბროკერი.

ამ ინსტრუქციაში, მე ვიყენებ მხოლოდ ერთ გამომცემელს, ლოლინს, რომელიც მიწერილია ჩემს საფოსტო ყუთში: როდესაც წერილები ან ამანათი გამოვლენილია წერილების ყუთში დაყენებული ლერწმის კონტაქტების საშუალებით (ნაბიჯი 1 შემეტებულად), ის უგზავნის MQTT შეტყობინებას WIFI- ზე ბროკერს (ნაბიჯი 2).

საბროკერო ნაწილი კეთდება Mosquitto– ს მიერ, რომელიც დაყენებულია Raspberry Pi– ზე (ნაბიჯი 3).

დომოციცის შესახებ:

როგორც აღწერილია საწყის გვერდზე, Domoticz არის "სახლის ავტომატიზაციის სისტემა", რომელიც საშუალებას გაძლევთ გააკონტროლოთ სხვადასხვა მოწყობილობები და მიიღოთ ინფორმაცია სხვადასხვა პროტოკოლიდან: MQTT არის ერთ -ერთი მხარდაჭერილი პროტოკოლი…

როგორც კი მას მიაღწევს ინფორმაცია (ნაბიჯი 4), თქვენ შეგიძლიათ განსაზღვროთ მოვლენები: წერილების შემთხვევაში მე ავირჩიე Telegram შეტყობინების გაგზავნა (ნაბიჯი 5).

დაბოლოს, Telegram კლიენტი კონფიგურირებულია ჩემს ტელეფონზე (და ჩემი ცოლისაც! - ნაბიჯი 6): საბოლოო მიზანი მიღწეულია…

ნაბიჯი 2: შემატებითი / გაყვანილობა

ერთი სიტყვა ანალოგის შესახებ წაიკითხეთ:

უპირველეს ყოვლისა, მე შევამჩნიე რამდენიმე კვლევის შემდეგ, რომ Lolin mini D1 (როგორც ძველი Wemos), ჩაშენებულია ძაბვის გამყოფი პინ A0– ში (მხედველობაშია 220KΩ R1– ისთვის და 100KΩ R2– სთვის - იხილეთ მონაცემების ფურცლის მარჯვნივ), რაც იძლევა 3.2 ვოლტს. როგორც მაქსიმალური ანალოგური შეყვანის ძაბვა.

ბატარეის მაქსიმალური გამომავალი ძაბვის გათვალისწინებით არის 4, 2 ვ (შეზღუდულია დატენვის დაფით) და თეორიულად, თქვენ მხოლოდ გარე რეზერვუარის დამატება (R1 სერიით), რომ გაზარდოთ მაქსიმალური შეყვანის ძაბვის დიაპაზონი. შემდეგ, თუ დაამატებთ 100K სერიას R1– ით, გექნებათ ეს შედეგი:

Vin * R1/(R1+R2) = Vout

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

ჩემს წრეში, მე ავირჩიე, რომ შემეძლოს მისი მნიშვნელობის მორგება, ამიტომაც მირჩევნია გამოვიყენო რეგულირებადი რეზისტორი ჩემს წრედში: შესაძლოა ეს თქვენთვის უსარგებლო იყოს, მაგრამ ჩემს სიტუაციაში, მე მის მნიშვნელობას ვადგენ დაახლოებით 10KΩ თანმიმდევრული მნიშვნელობა დომოტიცში…

გაითვალისწინეთ, რომ A0 პინს აქვს 10 ბიტიანი გარჩევადობა: ეს ნიშნავს, რომ თქვენს ესკიზში თქვენი ანალოგური კითხვა დააბრუნებს მნიშვნელობას 0 -დან 1024 -მდე.

რამდენადაც მინდა პროცენტული მნიშვნელობა გავუგზავნო დომოციცს, ანალოგური წაკითხვის შედეგი უნდა გავყო 10, 24 -ზე.

ნაბიჯი 3: ენერგიის მართვა

რა თქმა უნდა, მინდა, რომ წერილების ყუთი იყოს ავტონომიური. ჩემი მიზნის მისაღწევად, მე ვიყენებ ამ ელემენტებს:

• Li-Ion 18650 ბატარეა 4000 mAh;
• მზის პანელი, რომელსაც შეუძლია უზრუნველყოს 6V / 2W;
• TP4056 ლითიუმის ბატარეის დატენვის დაფა.

ყველაზე შესაფერისი მზის პანელის ასარჩევად, მე გადავხედე რამდენიმე მაგალითს, მათ შორის ერთს: ამ მაგალითში, 5.5V / 0.66W მზის პანელი გამოიყენება და ალბათ საკმარისია ამ მიზნისთვის. ჩემს შემთხვევაში, და რადგან ESP8266 უნდა დარჩეს ჩართული დღის განმავლობაში და უნდა შეეძლოს სერვო ძრავის გაშვება, რომ სახლი მზისკენ იყოს მიმართული, მე ავირჩიე უფრო მძლავრი მზის პანელის მოდელი (6V / 2W) - ის ასევე მაძლევს საშუალებას ზამთრის ბნელი პერიოდებისა და მოღრუბლული დღეების მოსალოდნელი;-)

ასევე, და ენერგიის ხარჯვის მაქსიმალურად შესამცირებლად, მე შევარჩიე შემდეგი სცენარები:

• იცის, რომ ფოსტალიონმა გაიარა მხოლოდ დილის 7 საათიდან საღამოს 8 საათამდე, ESP მოთავსებულია ღრმა ძილში ღამით;
• ფაქტორი არ გადის შაბათს შუადღესა და ორშაბათს დილით: ESP ასევე მოთავსებულია DeepSleep რეჟიმში ამ პერიოდში.
• დილის 7 საათიდან საღამოს 8 საათამდე, და ენერგიის მოხმარების შესამცირებლად, მე უბრალოდ გამორთავს ESP ქსელის ინტერფეისს: ქსელის გადატვირთვა ხდება მხოლოდ ამანათის ან წერილის ჩამოსვლისას, საკმარისი დრო ინფორმაციის გაგზავნისთვის Domoticz. მე არ მჭირდება დაუყოვნებლივ გაფრთხილება და რამდენიმე დამატებითი წამი, რაც საჭიროა ქსელის ინტერფეისის გადატვირთვისთვის, არ არის მავნე!

ზოგიერთი მნიშვნელობა მოხმარების შესახებ სხვადასხვა რეჟიმში, რომელსაც მე ვიყენებ ლოლინისთვის - შეხედეთ მონაცემთა ცხრილს, გვ 18:

• ნორმალურ რეჟიმში (RF– ით მუშაობისას), ენერგიის მოხმარება შეიძლება გაიზარდოს 170 mA– მდე! ვინაიდან ჩემი საფოსტო ყუთი ჩემი სახლიდან დაახლოებით 50 მეტრშია (და WIFI სიგნალის ზღვარზე …) მე ვთვლი, რომ კავშირის შესანარჩუნებლად გამოყენებული ძალა მისი მაქსიმალურია…
• მოდემის ძილში, ენერგიის მოხმარება მცირდება 15 mA– მდე. როგორც ხედავთ მონაცემთა ცხრილში, მან ბოლომდე არ შეაჩერა მოდემი, რადგან ESP "ინარჩუნებს Wi-Fi კავშირს მონაცემთა გადაცემის გარეშე".
• ღრმა ძილში, ენერგია მცირდება 20uA– მდე.

დარწმუნებული უნდა ვიყო, რომ wifi არ რჩება ზედმეტად აქტიური, მე მირჩევნია მისი გამორთვა შემდეგი ბრძანებებით. გაითვალისწინეთ ბევრი () ზარის დაგვიანება … მათ გარეშე, ESP- ის ავარია:

WiFi. გათიშვა ();

დაგვიანება (1000); WiFi.mode (WIFI_OFF); დაგვიანება (1000); WiFi.forceSleepBegin (); დაგვიანება (1);

საერთო ჯამში, რამოდენიმე დღის მუშაობის შემდეგ, როგორც ჩანს, ის მუშაობს და განსაკუთრებით სწორად იტვირთება:

• ეს მაძლევს საშუალებას გავუშვა სერვომოტორი ყოველ საათში, რათა სახლი მზისკენ განვათავსო;
• მე ასევე შემიძლია ნება მივცე ჩემს თავს, რომ ყოველ საათში ხელახლა გავააქტიურო ქსელის ინტერფეისი, რათა დომიციცში გავგზავნო ბატარეის დატენვის დონე.

ნაბიჯი 4: მაგნიტების და ლერწმის კონტაქტების დაყენება

როგორც ყოველთვის, მე ჩემი პროქსონი გამოვიყენე რიდის ადგილის შესაქმნელად ხის ნაჭერში.

ლერწმის კონტაქტის დასაფიქსირებლად მის ხვრელში, მე გამოვიყენე ცოტა J-B შედუღება.

ამანათისა და გამოყვანისთვის, პატარა ფირზე ნაჭერი, ცოტა ხერხი და მიზანი მიღწეულია!

ჩემი საფოსტო ყუთის უპირატესობა ის არის, რომ ის არის მეტალი, რაც აადვილებს მაგნიტების პოზიციონირებას ისე, რომ ის სწორად ურთიერთქმედებს ლერწმის კონტაქტებთან.

ნაბიჯი 5: დაუკავშირდით ჩემს პატარა სახლს

იმისთვის, რომ მარტივად შემეძლოს დაკავშირება და გათიშვა კაბელიდან, რომელიც მიდის ლერწმის კონტაქტებზე წერილებიდან სახლამდე, მე ავირჩიე Ethernet კონექტორის გამოყენება.

თქვენ შეგიძლიათ გამოიყენოთ ეს მოდელი ან, ჩემს მსგავსად, გამოიყენოთ ძველი Arduino Ethernet ფარი, რომელიც ჩემს უჯრაშია ჩამოკიდებული: ის არ განიცდიდა, ის მამაცი იყო ხერხის წინ, მისი სიკვდილი სწრაფი იყო ^^

მხოლოდ ერთი სიტყვა Arduino Ethernet ფარის შესახებ: ნუ ელოდებით, რომ გყავთ 8 ცალკეული დრაივერი … კაბელები ფარის შიგნით 2 წყვილია … ამან ძალიან დიდხანს გამაგიჟა !!!

ნაბიჯი 6: სახლში…

საკმარისი ადგილია ბატარეის დამჭერის დასაფიქსირებლად, სერვოსა და RJ45 ქალის კონექტორის დასაფიქსირებლად.

ნაბიჯი 7: მიეცით ის მოსახვევი…

მისი მიზანია მზისკენ…

იმისათვის, რომ შემობრუნების უნარი შემეძლოს, მე გამოვიყენე გრძელი ხრახნი, როგორც ღერძი, რამდენიმე თხილით და ორი ბურთულიანი საკისრებით …

აქამდე ვიყენებდი SG90 სერვო (ბრუნვის მომენტი: 1.8 კგ/სმ 4.8 ვ -ზე).

სახლის დასაბრუნებლად (და მისი რამდენიმე გრამი) საკმარისია. მეორეს მხრივ, მე არ ვარ დარწმუნებული, რომ მისი პლასტიკური გადაცემათა კოლოფი დიდხანს უძლებს ქარის ხშირ აფეთქებებს, რაც ჩემს რეგიონშია.

მე შევუკვეთე კიდევ ერთი (MG995 ბრუნვის მომენტი: 9.4 კგ/სმ 4.8 ვ -ზე), არც თუ ისე ძვირი, მაგრამ ლითონის გადაცემებით.

ეს იქნება შემდეგი, რაც უნდა გავაკეთო, როდესაც მივიღებ მას: მე ვენდობი ჩემს დაკავშირებულ წერილებს, რომ შემატყობინოს მისი ჩამოსვლის შესახებ!

ნაბიჯი 8: ზოგიერთი ტესტი

რამდენიმე შენიშვნა:

ეს ესკიზი მხოლოდ დღის საათების ცვლილების იმიტირებისთვისაა, რაც საშუალებას მომცემს გავაკონტროლო სერვოს პოზიცია.

• SG90– ით: დამატებითი საჭიროებების გარეშე, მას შეუძლია იმუშაოს OUT ძაბვით, რომელიც მოდის ბატარეის კონტროლერისგან.

• მაგრამ, MG 995– ით:

  • ბრუნვის მთლიანი კუთხე არ არის იგივე (უფრო ფართო): მე უნდა გამოვიყენო დამატებითი ფუნქცია მის შესამცირებლად (Servo_Delta ()).
  • საჭიროა DC/DC გაძლიერება, რათა უზრუნველყოს საკმარისი ძაბვა სერვოზე … გაგრძელება…

/*

- ტესტირება SG90– ით: დამატებითი მოთხოვნილებების გარეშე, მას შეუძლია იმუშაოს OUT ძაბვასთან, რომელიც მოდის ბატარეის კონტროლერისგან - MG 995 – ისთვის: - გამოიყენეთ Servo_Delta () ფუნქცია… გაგრძელდება: */ #მოიცავს 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 setup () {Serial.begin (115200); } void loop () {for (i = 7; i <= 22; i ++) {old = i; if (i == 7) {if (ჟურნალები) 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]; ინდექსი-) {if (Logs) Serial.println (ინდექსი); if (ჟურნალები) 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 Temp_val; Temp_val = (მნიშვნელობა*0.80) +9; დაბრუნება Temp_val; }

ნაბიჯი 9: პატარა სახლი

როგორც უკვე გითხარით, მე არ მაქვს 3D პრინტერი. ამიტომ გადავწყვიტე გამოვიყენო ძველი ბოსტნეულის კრატი …

შესაძლოა ეს დიდხანს არ გაგრძელდეს, მაგრამ იმ დროისთვის მე მექნება დრო, რომ განვიხილო სხვა გამოსავალი (ან მეგობარი, რომელიც ფლობს 3D პრინტერს): ხის დასაცავად, ყველგან ბევრი ლაქი დავამატე…

თქვენ შეგიძლიათ ნახოთ "ლამაზი ფარდები" … ეს ხდება მაშინ, როდესაც თქვენ სთხოვთ თქვენს მეუღლეს სამუშაოს შესრულება ^^

ნაბიჯი 10: ესკიზი

მიმდინარეობს … მაგრამ როგორც ჩანს სტაბილურია

მე ჯერ კიდევ ვმუშაობ კოდზე: რადგან ეს არ არის საბოლოო ვერსია, თქვენი კომენტარები / რჩევები მისასალმებელია;-)

რამდენიმე შენიშვნა:

• მათ აქვთ მრავალი შეფერხება () კოდში: ეს არის ლოლინის ბევრი ავარიის თავიდან ასაცილებლად, განსაკუთრებით დაწყებული ქსელის გაჩერებისას …
• მე არ ვიპოვე მზის აზიმუტის მიღების მარტივი და საიმედო გზა: ამიტომაც დავაფიქსირე servo მნიშვნელობა იმის გათვალისწინებით, რაც მე დავინახე … მე მაქვს კარგი (და მარტივი) გზა ამის მისაღებად, მაინტერესებს! შესაძლოა ბილიკი სასწავლებლად, თუნდაც მე მირჩევნია ონლაინ API მომცეს აზიმუტი უშუალოდ თარიღის, საათის და გეოგრაფიული მდებარეობის მიხედვით…
• ძილის ტექნიკის შესახებ: ვინაიდან ლოლინი არის 32 ბიტიანი ტენსილიკის პროცესორი, მისი მაქსიმალური მნიშვნელობა 32 ბიტიანი ხელმოუწერელი მთლიანი რიცხვისთვის არის 4294967295… შემდეგ, ეს იძლევა მაქსიმალურ 71 წუთს ღრმა ძილის ინტერვალისთვის. ამიტომაც ბევრჯერ მეძინება დაახლოებით 60 წუთის განმავლობაში …

რედაქტირება - 2018-10-08:

აღმოვაჩინე, რომ სერვოზე ბევრი უხეში მოძრაობაა, განსაკუთრებით მიმაგრებამდე (), დაშორებამდე () და ყოველ ჯერზე, როდესაც ლოლინი იღვიძებს ღრმა ძილიდან ().

ცოტა მეტი მონაცემების შესწავლისას მივხვდი ორ რამეს:

• ლოლინის მონაცემთა ფურცელზე, D4 გამომავალი უკვე დაკავშირებულია BUILTIN_LED…
• ESP8266ex მონაცემთა ცხრილში ჩვენ ვიგებთ, რომ D4 გამომავალი გამოიყენება როგორც UART 1/U 1 TXD (უნივერსალური ასინქრონული მიმღების გადამცემი). ასევე მითითებულია, რომ ეს UART1 გამოიყენება ჟურნალის დასაბეჭდად.

ამ ინფორმაციის წაკითხვით მივხვდი, რომ D4 გამომავალი არ იყო კარგი იდეა, განსაკუთრებით სერვო ძრავის მართვისთვის!

ამრიგად, ახლა გამომავალი, რომელიც გამოიყენება სერვომოტორის გასაკონტროლებლად არის D2, შესაბამისად ქვემოთ განახლებულია კოდი შესაბამისად.

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

თარიღი création: 08/თარიღი mise en prod: 08/ვერსია: 0.9.4 ვერსია IDE Arduino: 1.8.6 ატვირთვის სიჩქარე: 921600 ტიპი de carte dans l'IDE: "LOLIN (WEMOS) D1 R2 & mini" Carte physique Employéee: LOLIN (WEMOS) D1 R2 & mini (https://www.amazon.fr/gp/product/B01ELFAF1S/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1) Pin ფუნქცია ESP-8266 Pin გამოყენების ლოკალი ------- ------------------------------------------------------ ------------------------------------ TX TXD TXD RX RXD RXD A0 ანალოგური შეყვანა, მაქს 3.3 ვ შეყვანა A0 Tension d'alimentaion 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_5D GPIO2, SCK GPIO14 Reed relève D6 IO, MISO GPIO12 Reed lettre D7 IO, MOSI GPIO13 Reed colis D8 IO, 10k pull-down, SS GPIO15 Ground GND 5V 5V-3V3 3.3V 3.3V 3.3V RST Reset RST Connecté à D0 (pour le deep. ძილი) **************************************; // wifi const char* ssid = "LOL"; const char* პაროლი = "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 Servo 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; ხელმოუწერელი ხანგრძლივი switchPressTime; const ხელმოუწერელი გრძელი DEBOUCE_TIME = 200; // ანალოგი #განსაზღვრეთ PIN_ANALOG A0 // MQTT #inconste 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; // დაძაბულობის float vcc; // NTP #მოიცავს დროს int Old_Time = 0; int Int_Heures = 0; int Int_Minutes = 0; int Int_Sleep_Duration = 63; void setup () {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 = დრო (nullptr); Int_Heures = String (ctime (& tnow)). Substring (11, 13).toInt (); Int_Minutes = String (ctime (& tnow)). Substring (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 loop () {// NTP კომპლექტი tnow = დრო (nullptr); Int_Heures = String (ctime (& tnow)). Substring (11, 13).toInt (); Int_Minutes = String (ctime (& tnow)). Substring (14, 16).toInt (); // სერიული.პრინტლნ (სიმებიანი (დრო (და ახლა)))); //Serial.println ("Heure:" + String (ctime (& tnow)). ქვესტრიქონი (11, 13)); //Serial.println (სიმებიანი (ctime (& tnow)). ქვესტრიქონიანი (11, 13).toInt ()); // სერვო მენეჯმენტი if (Old_Time! = Int_Heures) {Old_Time = Int_Heures; if (Int_Heures == 7) {if (ჟურნალები) 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]; index-) {if (Logs) Serial.println (ინდექსი); დაგვიანება (200); myservo.write (ინდექსი); } დაგვიანებით (15); myservo.write (Arr_Servo_Pos [Int_Heures-7]); // კვლავ დაწერეთ ბოლო მნიშვნელობა, რათა თავიდან აიცილოთ მკვეთრი მოძრაობები myservo.detach () გამოყოფისას; } ქსელი (ჭეშმარიტი); SendBatteryLevel (); ქსელი (ყალბი); }}} // ღრმა ძილი, თუ შაბათი 13 საათის შემდეგ "Sleep pour le samedi aprés midi ("); თუ (ჟურნალი) Serial.print (Int_Sleep_Duration - Int_Minutes); ძილი (Int_Sleep_Duration - Int_Minutes); } // ღრმად ჩაძინება კვირა დღეს Serial.print (Int_Sleep_Duration - Int_Minutes); if (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 ("courrier relevé!"); ქსელი (ჭეშმარიტი); დაგვიანება (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); თუ (Switch_State_IN_LETTER! = Old_Switch_State_IN_LETTER) {if (millis () - switchPressTime> = DEBOUCE_TIME) {switchPressTime = millis (); if (Switch_State_IN_LETTER == HIGH) {Serial.println ("courrier ჩამოვიდა!"); ქსელი (ჭეშმარიტი); დაგვიანება (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); თუ (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 (ჟურნალები) Serial.println ("\ tTension relevée:" + სიმებიანი (vcc, 0)); MQTT_Pubilsh (IDX_Letter_Box_Battery, 0, სიმებიანი (vcc, 0)); დაგვიანება (5000); } ბათილი ძილი (int Min_Duration) {ESP.deepSleep (Min_Duration * 60e6); } void network (bool UpDown) {if (UpDown) {Serial.print ("ქსელის დაწყება"); WiFi.forceSleepWake (); დაგვიანება (1); // init WIFI WiFi.config (ip, dns, gateway, subnet); WiFi.begin (ssid, პაროლი); while (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); // Nit Serial.print ("\ t დროის სინქრონიზაცია"); configTime (0, 0," fr.pool.ntp.org "); setenv (" TZ "," CET-1CEST, M3.5.0, M10.5.0/3 ", 0); ხოლო (დრო (nullptr) <= 100000) {Serial.print ("."); დაგვიანებით (100);} Serial.println (".");} Else {Serial.println ("ქსელის გაჩერება."); WiFi.disconnect (); დაგვიანებით (1000); WiFi.mode (WIFI_OFF); დაყოვნება (1000); WiFi.forceSleepBegin (); შეფერხება (1);}} void ხელახლა დაკავშირება () {while (! ClientMQTT.connected ()) {Serial.print (" / t მცდელობა MQTT კავშირის … "); // დაკავშირების მცდელობა if (ClientMQTT.connect (" ESP8266ClientBAL ")) {Serial.println (" დაკავშირებულია ");} სხვა {Serial.print (" ვერ მოხერხდა, rc = "); სერიული print {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.disonnect (); }

ნაბიჯი 11: დომოტიცი

დომოციცში:

ზოგადი გამოყენებისთვის:

• შექმენით ორი "Dummy (არაფერს აკეთებს, გამოიყენეთ ვირტუალური გადამრთველებისთვის)":

  1. პირველი ასოებისთვის …
  2. მეორე ამანათისთვის…
• თითოეული მათგანისთვის პერსონალიზირებულია შეტყობინებები;
• რა თქმა უნდა, თქვენ უნდა დააყენოთ Tegegram ნიშანი.

სურვილისამებრ:

თქვენ შეგიძლიათ დაამატოთ "სასარგებლო სენსორი" ბატარეის დატენვის დონის გასაკონტროლებლად.

რჩევები: აქ შეგიძლიათ იპოვოთ ბევრი უფასო პერსონალური ხატი…

ნაბიჯი 12: დასკვნა

ვიმედოვნებ, რომ ეს ინსტრუქცია დაგეხმარებათ:

• გააკეთოთ თუ არა თქვენი საკუთარი დაკავშირებული letterlbox;
• ან უბრალოდ მოგაწოდოთ იდეები თქვენი პროექტებისთვის!

თუ თქვენ გაქვთ იდეები გაუმჯობესების მიზნით, მე ვუსმენ!

PS: ბოდიში ჩემი ინგლისურისთვის, Google თარგმანი ძალიან მეხმარება, მაგრამ ალბათ არ არის სრულყოფილი;-)