ພວກເຮົາເຊື່ອມຕໍ່ເຄື່ອງວັດແທກນ້ໍາກັບເຮືອນ smart

ເມື່ອກ່ອນ, ລະບົບອັດຕະໂນມັດໃນເຮືອນ, ຫຼື "ເຮືອນອັດສະລິຍະ" ຍ້ອນວ່າພວກເຂົາຖືກເອີ້ນເລື້ອຍໆ, ມີລາຄາແພງຫຼາຍແລະມີພຽງແຕ່ຄົນຮັ່ງມີເທົ່ານັ້ນທີ່ສາມາດຈ່າຍໃຫ້ເຂົາເຈົ້າ. ໃນມື້ນີ້ຢູ່ໃນຕະຫຼາດທ່ານສາມາດຊອກຫາຊຸດລາຄາຖືກທີ່ມີເຊັນເຊີ, ປຸ່ມ / ສະຫຼັບແລະຕົວກະຕຸ້ນສໍາລັບການຄວບຄຸມແສງສະຫວ່າງ, ເຕົ້າສຽບ, ລະບາຍອາກາດ, ການສະຫນອງນ້ໍາແລະຜູ້ບໍລິໂພກອື່ນໆ. ແລະແມ້ແຕ່ຄົນ DIY ທີ່ມີຄວາມໂກດແຄ້ນທີ່ສຸດກໍ່ສາມາດມີສ່ວນຮ່ວມໃນຄວາມງາມແລະປະກອບອຸປະກອນສໍາລັບເຮືອນ smart ໃນລາຄາທີ່ບໍ່ແພງ.

ໂດຍປົກກະຕິ, ອຸປະກອນທີ່ສະເຫນີແມ່ນເຊັນເຊີຫຼືຕົວກະຕຸ້ນ. ພວກເຂົາເຮັດໃຫ້ມັນງ່າຍຕໍ່ການປະຕິບັດສະຖານະການເຊັ່ນ: "ເມື່ອເຊັນເຊີການເຄື່ອນໄຫວຖືກກະຕຸ້ນ, ເປີດໄຟ" ຫຼື "ປຸ່ມທີ່ຢູ່ໃກ້ກັບທາງອອກຈະປິດໄຟໃນອາພາດເມັນທັງຫມົດ." ແຕ່ຢ່າງໃດກໍ່ຕາມສິ່ງທີ່ບໍ່ໄດ້ຜົນກັບ telemetry. ດີທີ່ສຸດ, ມັນເປັນເສັ້ນສະແດງຂອງອຸນຫະພູມແລະຄວາມຊຸ່ມຊື່ນ, ຫຼືພະລັງງານທັນທີຢູ່ທີ່ເຕົ້າສຽບສະເພາະ.

ຂ້ອຍບໍ່ດົນມານີ້ໄດ້ຕິດຕັ້ງເຄື່ອງວັດແທກນ້ໍາທີ່ມີຜົນອອກຂອງກໍາມະຈອນ. ສໍາລັບທຸກໆລິດທີ່ຜ່ານເຄື່ອງວັດແທກ, ສະຫວິດ reed ຖືກເປີດໃຊ້ແລະປິດການຕິດຕໍ່. ສິ່ງດຽວທີ່ເຫລືອທີ່ຈະເຮັດແມ່ນການຍຶດຕິດກັບສາຍໄຟແລະພະຍາຍາມໄດ້ຮັບຜົນປະໂຫຍດຈາກມັນ. ສໍາລັບຕົວຢ່າງ, ວິເຄາະການບໍລິໂພກນ້ໍາໂດຍຊົ່ວໂມງແລະມື້ຂອງອາທິດ. ດີ, ຖ້າມີຜູ້ເພີ່ມນ້ໍາຫຼາຍຢູ່ໃນອາພາດເມັນ, ມັນສະດວກກວ່າທີ່ຈະເຫັນຕົວຊີ້ວັດໃນປະຈຸບັນທັງຫມົດໃນຫນ້າຈໍດຽວກ່ວາການປີນເຂົ້າໄປໃນ niches ທີ່ຍາກທີ່ຈະເຂົ້າເຖິງດ້ວຍໄຟສາຍ.

ຂ້າງລຸ່ມນີ້ການຕັດແມ່ນອຸປະກອນລຸ້ນຂອງຂ້ອຍໂດຍອີງໃສ່ ESP8266, ເຊິ່ງນັບ pulses ຈາກເຄື່ອງວັດແທກນ້ໍາແລະສົ່ງການອ່ານຜ່ານ MQTT ໄປຫາເຄື່ອງແມ່ຂ່າຍເຮືອນ smart. ພວກເຮົາຈະດໍາເນີນໂຄງການໃນ micropython ໂດຍໃຊ້ຫ້ອງສະຫມຸດ uasyncio. ເມື່ອສ້າງເຟີມແວ, ຂ້ອຍພົບຄວາມຫຍຸ້ງຍາກທີ່ຫນ້າສົນໃຈຫຼາຍ, ເຊິ່ງຂ້ອຍຈະສົນທະນາໃນບົດຄວາມນີ້. ໄປ!

ໂຄງການ

ຫົວໃຈຂອງວົງຈອນທັງຫມົດແມ່ນໂມດູນຢູ່ໃນ microcontroller ESP8266. ESP-12 ໄດ້ຖືກວາງແຜນໄວ້ໃນຕອນຕົ້ນ, ແຕ່ລະເບີດຝັງດິນປະກົດວ່າມີຂໍ້ບົກພ່ອງ. ພວກເຮົາຕ້ອງມີຄວາມພໍໃຈກັບໂມດູນ ESP-07, ເຊິ່ງສາມາດໃຊ້ໄດ້. ໂຊກດີ, ພວກມັນຄືກັນທັງສອງດ້ານຂອງ pins ແລະການເຮັດວຽກ, ຄວາມແຕກຕ່າງພຽງແຕ່ຢູ່ໃນເສົາອາກາດ - ESP-12 ມີຕົວເຊື່ອມຕໍ່, ໃນຂະນະທີ່ ESP-07 ມີພາຍນອກ. ຢ່າງໃດກໍຕາມ, ເຖິງແມ່ນວ່າບໍ່ມີເສົາອາກາດ WiFi, ສັນຍານໃນຫ້ອງນ້ໍາຂອງຂ້ອຍໄດ້ຮັບຕາມປົກກະຕິ.

ສາຍໄຟໂມດູນມາດຕະຖານ:

• ປຸ່ມຣີເຊັດດ້ວຍການດຶງຂຶ້ນແລະຕົວເກັບປະຈຸ (ເຖິງແມ່ນວ່າທັງສອງແມ່ນຢູ່ໃນໂມດູນແລ້ວ)
• ສັນຍານເປີດໃຊ້ງານ (CH_PD) ຖືກດຶງຂຶ້ນເພື່ອເປີດໄຟ
• GPIO15 ຖືກດຶງກັບພື້ນດິນ. ນີ້ແມ່ນຕ້ອງການພຽງແຕ່ໃນຕອນເລີ່ມຕົ້ນ, ແຕ່ຂ້ອຍບໍ່ມີຫຍັງທີ່ຈະຕິດກັບຂານີ້; ຂ້ອຍບໍ່ຕ້ອງການມັນອີກຕໍ່ໄປ

ເພື່ອເຮັດໃຫ້ໂມດູນເຂົ້າໄປໃນໂຫມດເຟີມແວ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ວົງຈອນສັ້ນ GPIO2 ກັບດິນ, ແລະເພື່ອເຮັດໃຫ້ມັນສະດວກກວ່າ, ຂ້າພະເຈົ້າໄດ້ໃຫ້ປຸ່ມ Boot. ໃນສະພາບປົກກະຕິ, pin ນີ້ຖືກດຶງກັບພະລັງງານ.

ສະຖານະຂອງສາຍ GPIO2 ໄດ້ຖືກກວດກາພຽງແຕ່ໃນຕອນເລີ່ມຕົ້ນຂອງການດໍາເນີນງານ - ເມື່ອພະລັງງານຖືກນໍາໃຊ້ຫຼືທັນທີຫຼັງຈາກການຕັ້ງໃຫມ່. ດັ່ງນັ້ນໂມດູນຈະເປີດເຄື່ອງປົກກະຕິຫຼືເຂົ້າໄປໃນໂຫມດເຟີມແວ. ເມື່ອໂຫລດແລ້ວ, PIN ນີ້ສາມາດຖືກນໍາໃຊ້ເປັນ GPIO ປົກກະຕິ. ດີ, ເນື່ອງຈາກວ່າມີປຸ່ມຢູ່ແລ້ວ, ທ່ານສາມາດຕິດບາງຫນ້າທີ່ທີ່ເປັນປະໂຫຍດກັບມັນ.

ສໍາລັບການຂຽນໂປລແກລມແລະການດີບັກ, ຂ້ອຍຈະໃຊ້ UART, ເຊິ່ງແມ່ນຜົນຜະລິດໄປຫາ comb. ເມື່ອມີຄວາມຈໍາເປັນ, ຂ້າພະເຈົ້າພຽງແຕ່ເຊື່ອມຕໍ່ອະແດບເຕີ USB-UART ຢູ່ທີ່ນັ້ນ. ທ່ານພຽງແຕ່ຕ້ອງການທີ່ຈະຈື່ຈໍາວ່າໂມດູນແມ່ນຂັບເຄື່ອນໂດຍ 3.3V. ຖ້າທ່ານລືມສະຫຼັບອະແດບເຕີກັບແຮງດັນນີ້ແລະສະຫນອງ 5V, ໂມດູນຈະເຜົາໄຫມ້ຫຼາຍທີ່ສຸດ.

ຂ້ອຍບໍ່ມີບັນຫາກັບໄຟຟ້າໃນຫ້ອງນ້ໍາ - ປ່ຽງແມ່ນຕັ້ງຢູ່ປະມານຫນຶ່ງແມັດຈາກແມັດ, ດັ່ງນັ້ນຂ້ອຍຈະໃຊ້ພະລັງງານ 220V. ໃນຖານະເປັນແຫຼ່ງພະລັງງານຂ້າພະເຈົ້າຈະມີຂະຫນາດນ້ອຍ ບລັອກ HLK-PM03 ໂດຍ Tenstar Robot. ສ່ວນບຸກຄົນ, ຂ້າພະເຈົ້າມີຄວາມຫຍຸ້ງຍາກກັບອຸປະກອນເອເລັກໂຕຣນິກການປຽບທຽບແລະພະລັງງານ, ແຕ່ນີ້ແມ່ນການສະຫນອງພະລັງງານທີ່ກຽມພ້ອມໃນກໍລະນີຂະຫນາດນ້ອຍ.

ເພື່ອສັນຍານຮູບແບບການເຮັດວຽກ, ຂ້າພະເຈົ້າໄດ້ໃຫ້ LED ທີ່ເຊື່ອມຕໍ່ກັບ GPIO2. ຢ່າງໃດກໍຕາມ, ຂ້າພະເຈົ້າບໍ່ໄດ້ຍົກເລີກມັນ, ເພາະວ່າ ... ໂມດູນ ESP-07 ມີໄຟ LED ແລ້ວ, ແລະມັນຍັງເຊື່ອມຕໍ່ກັບ GPIO2. ແຕ່ໃຫ້ມັນຢູ່ໃນກະດານ, ໃນກໍລະນີທີ່ຂ້ອຍຕ້ອງການອອກ LED ນີ້ໃຫ້ກັບກໍລະນີ.

ຂໍໃຫ້ກ້າວໄປສູ່ສ່ວນທີ່ຫນ້າສົນໃຈທີ່ສຸດ. ເຄື່ອງວັດນ້ໍາບໍ່ມີເຫດຜົນ; ທ່ານບໍ່ສາມາດຂໍໃຫ້ພວກເຂົາອ່ານປະຈຸບັນ. ສິ່ງດຽວທີ່ມີຢູ່ກັບພວກເຮົາແມ່ນ impulses - ປິດການຕິດຕໍ່ຂອງ reed switch ທຸກລິດ. ຜົນຜະລິດສະວິດ Reed ຂອງຂ້ອຍແມ່ນເຊື່ອມຕໍ່ກັບ GPIO12/GPIO13. ຂ້ອຍຈະເປີດໃຊ້ຕົວຕ້ານທານແບບດຶງຂຶ້ນດ້ວຍໂປຣແກຣມພາຍໃນໂມດູນ.

ໃນເບື້ອງຕົ້ນ, ຂ້າພະເຈົ້າລືມສະຫນອງຕົວຕ້ານທານ R8 ແລະ R9 ແລະກະດານສະບັບຂອງຂ້ອຍບໍ່ມີພວກມັນ. ແຕ່ຍ້ອນວ່າຂ້ອຍໄດ້ຂຽນແຜນວາດໃຫ້ທຸກຄົນເບິ່ງແລ້ວ, ມັນສົມຄວນທີ່ຈະແກ້ໄຂການກວດການີ້. Resistors ແມ່ນຈໍາເປັນເພື່ອບໍ່ໃຫ້ໄຟໄຫມ້ພອດຖ້າເຟີມແວຜິດປົກກະຕິແລະຕັ້ງ pin ເປັນຫນຶ່ງ, ແລະ reed ປ່ຽນສາຍນີ້ກັບດິນ (ກັບ resistor ສູງສຸດຂອງ 3.3V / 1000Ohm = 3.3mA ຈະໄຫຼ).

ມັນເຖິງເວລາທີ່ຈະຄິດກ່ຽວກັບສິ່ງທີ່ຕ້ອງເຮັດຖ້າໄຟຟ້າຫມົດ. ທາງເລືອກທໍາອິດແມ່ນການຮ້ອງຂໍມູນຄ່າ counter ເບື້ອງຕົ້ນຈາກເຄື່ອງແມ່ຂ່າຍໃນຕອນເລີ່ມຕົ້ນ. ແຕ່ນີ້ຈະຮຽກຮ້ອງໃຫ້ມີຄວາມສັບສົນທີ່ສໍາຄັນຂອງອະນຸສັນຍາການແລກປ່ຽນ. ຍິ່ງໄປກວ່ານັ້ນ, ການປະຕິບັດຂອງອຸປະກອນໃນກໍລະນີນີ້ແມ່ນຂຶ້ນກັບສະຖານະຂອງເຄື່ອງແມ່ຂ່າຍ. ຖ້າເຄື່ອງແມ່ຂ່າຍບໍ່ເລີ່ມຕົ້ນຫຼັງຈາກປິດໄຟ (ຫຼືເລີ່ມຕົ້ນໃນພາຍຫຼັງ), ເຄື່ອງວັດແທກນ້ໍາຈະບໍ່ສາມາດຮ້ອງຂໍຄ່າເບື້ອງຕົ້ນແລະຈະເຮັດວຽກບໍ່ຖືກຕ້ອງ.

ດັ່ງນັ້ນ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈປະຕິບັດການປະຫຍັດຄ່າ counter ໃນຊິບຫນ່ວຍຄວາມຈໍາທີ່ເຊື່ອມຕໍ່ຜ່ານ I2C. ຂ້າ​ພະ​ເຈົ້າ​ບໍ່​ມີ​ຄວາມ​ຕ້ອງ​ການ​ພິ​ເສດ​ສໍາ​ລັບ​ຂະ​ຫນາດ​ຂອງ​ຫນ່ວຍ​ຄວາມ​ຈໍາ flash - ທ່ານ​ພຽງ​ແຕ່​ຕ້ອງ​ການ​ທີ່​ຈະ​ປະ​ຢັດ 2 ຕົວ​ເລກ (ຈໍາ​ນວນ​ຂອງ​ລິດ​ຕາມ​ເຄື່ອງ​ວັດ​ນ​້​ໍ​າ​ຮ້ອນ​ແລະ​ເຢັນ​)​. ເຖິງແມ່ນວ່າໂມດູນຂະຫນາດນ້ອຍທີ່ສຸດຈະເຮັດ. ແຕ່ທ່ານຈໍາເປັນຕ້ອງເອົາໃຈໃສ່ກັບຈໍານວນຂອງຮອບວຽນການບັນທຶກ. ສໍາລັບໂມດູນສ່ວນໃຫຍ່ນີ້ແມ່ນ 100 ພັນຮອບ, ສໍາລັບບາງເຖິງລ້ານ.

ມັນເບິ່ງຄືວ່າເປັນລ້ານແມ່ນຫຼາຍ. ແຕ່​ໃນ​ໄລຍະ 4 ປີ​ທີ່​ຢູ່​ໃນ​ອາ​ພາດ​ເມັນ​ຂອງ​ຂ້າ​ພະ​ເຈົ້າ, ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ໃຊ້​ນ້ຳ​ຫຼາຍ​ກວ່າ 500 ແມັດ​ກ້ອນ, ນັ້ນ​ແມ່ນ 500 ພັນ​ລິດ! ແລະ 500 ພັນບັນທຶກໃນ flash. ແລະນັ້ນແມ່ນພຽງແຕ່ນ້ໍາເຢັນ. ແນ່ນອນ, ເຈົ້າສາມາດຂາຍຊິບໄດ້ທຸກໆສອງສາມປີ, ແຕ່ມັນປາກົດວ່າມີຊິບ FRAM. ຈາກມຸມເບິ່ງການຂຽນໂປລແກລມ, ນີ້ແມ່ນ I2C EEPROM ດຽວກັນ, ພຽງແຕ່ມີຈໍານວນຮອບການຂຽນຄືນໃຫມ່ຫຼາຍ (ຫຼາຍຮ້ອຍລ້ານ). ມັນເປັນພຽງແຕ່ວ່າຂ້ອຍຍັງບໍ່ສາມາດໄປຮ້ານໄດ້ດ້ວຍ microcircuits ດັ່ງກ່າວ, ດັ່ງນັ້ນໃນປັດຈຸບັນ 24LC512 ປົກກະຕິຈະຢືນຢູ່.

ແຜ່ນວົງຈອນພິມ

ໃນເບື້ອງຕົ້ນ, ຂ້າພະເຈົ້າໄດ້ວາງແຜນທີ່ຈະເຮັດໃຫ້ກະດານຢູ່ເຮືອນ. ດັ່ງນັ້ນ, ກະດານໄດ້ຖືກອອກແບບເປັນດ້ານດຽວ. ແຕ່ຫຼັງຈາກໃຊ້ເວລາຫນຶ່ງຊົ່ວໂມງກັບເຫລໍກເລເຊີແລະຫນ້າກາກ solder (ມັນບໍ່ເປັນຫຍັງມັນບໍ່ມີມັນ), ຂ້ອຍຍັງຕັດສິນໃຈສັ່ງກະດານຈາກຈີນ.

ເກືອບກ່ອນທີ່ຈະສັ່ງກະດານ, ຂ້ອຍຮູ້ວ່ານອກເຫນືອຈາກຊິບຫນ່ວຍຄວາມຈໍາ flash, ຂ້ອຍສາມາດເຊື່ອມຕໍ່ສິ່ງອື່ນທີ່ເປັນປະໂຫຍດກັບລົດເມ I2C, ເຊັ່ນ: ຈໍສະແດງຜົນ. ສິ່ງທີ່ແນ່ນອນທີ່ຈະອອກໄປຫາມັນຍັງເປັນຄໍາຖາມ, ແຕ່ມັນຈໍາເປັນຕ້ອງຖືກນໍາໄປຢູ່ໃນກະດານ. ແລ້ວ, ນັບຕັ້ງແຕ່ຂ້ອຍຈະສັ່ງກະດານຈາກໂຮງງານ, ມັນບໍ່ມີຈຸດໃດທີ່ຈະຈໍາກັດຕົວເອງກັບກະດານດ້ານດຽວ, ດັ່ງນັ້ນສາຍ I2C ມີພຽງແຕ່ຢູ່ດ້ານຫລັງຂອງກະດານ.

ຍັງມີບັນຫາໃຫຍ່ອັນໜຶ່ງກັບສາຍໄຟທາງດຽວ. ເນື່ອງຈາກວ່າ ກະດານໄດ້ຖືກແຕ້ມເປັນດ້ານຫນຶ່ງ, ດັ່ງນັ້ນການຕິດຕາມແລະອົງປະກອບ SMD ໄດ້ຖືກວາງແຜນທີ່ຈະວາງໄວ້ຂ້າງຫນຶ່ງ, ແລະອົງປະກອບຜົນຜະລິດ, ຕົວເຊື່ອມຕໍ່ແລະການສະຫນອງພະລັງງານຢູ່ໃນອີກດ້ານຫນຶ່ງ. ເມື່ອຂ້າພະເຈົ້າໄດ້ຮັບກະດານຫນຶ່ງເດືອນຕໍ່ມາ, ຂ້າພະເຈົ້າລືມກ່ຽວກັບແຜນການຕົ້ນສະບັບແລະ soldered ອົງປະກອບທັງຫມົດຢູ່ດ້ານຫນ້າ. ແລະພຽງແຕ່ໃນເວລາທີ່ມັນມາກັບ soldering ການສະຫນອງພະລັງງານ, ມັນໄດ້ຫັນອອກວ່າບວກແລະລົບໄດ້ຖືກສາຍໃນທາງກັບກັນ. ຂ້າ ພະ ເຈົ້າ ໄດ້ ກະ ສິ ກໍາ ກັບ jumpers. ໃນຮູບຂ້າງເທິງ, ຂ້າພະເຈົ້າໄດ້ປ່ຽນສາຍໄຟແລ້ວ, ແຕ່ດິນໄດ້ຖືກໂອນຈາກພາກສ່ວນຫນຶ່ງຂອງກະດານໄປຫາອີກດ້ານຫນຶ່ງໂດຍຜ່ານ pins ຂອງປຸ່ມ Boot (ເຖິງແມ່ນວ່າມັນຈະເປັນໄປໄດ້ທີ່ຈະແຕ້ມເສັ້ນທາງໃນຊັ້ນທີສອງ).

ມັນໄດ້ຫັນອອກເຊັ່ນນີ້

ທີ່ຢູ່ອາໄສ

ຂັ້ນຕອນຕໍ່ໄປແມ່ນຮ່າງກາຍ. ຖ້າທ່ານມີເຄື່ອງພິມ 3D, ນີ້ບໍ່ແມ່ນບັນຫາ. ຂ້າ​ພະ​ເຈົ້າ​ບໍ່​ໄດ້​ເບື່ອ​ຫຼາຍ​ເກີນ​ໄປ - ຂ້າ​ພະ​ເຈົ້າ​ພຽງ​ແຕ່​ແຕ້ມ​ກ່ອງ​ຂະ​ຫນາດ​ທີ່​ເຫມາະ​ສົມ​ແລະ​ເຮັດ​ໃຫ້​ການ​ຕັດ​ອອກ​ໃນ​ບ່ອນ​ທີ່​ເຫມາະ​ສົມ​. ການປົກຫຸ້ມຂອງແມ່ນຕິດກັບຮ່າງກາຍດ້ວຍ screws ແຕະຕົນເອງຂະຫນາດນ້ອຍ.

ຂ້ອຍໄດ້ກ່າວມາແລ້ວວ່າປຸ່ມ Boot ສາມາດຖືກນໍາໃຊ້ເປັນປຸ່ມທີ່ມີຈຸດປະສົງທົ່ວໄປ - ດັ່ງນັ້ນພວກເຮົາຈະສະແດງມັນຢູ່ໃນແຖບດ້ານຫນ້າ. ເພື່ອເຮັດສິ່ງນີ້, ຂ້າພະເຈົ້າໄດ້ແຕ້ມ "ດີ" ພິເສດທີ່ປຸ່ມຢູ່.

ພາຍໃນກໍລະນີຍັງມີ studs ທີ່ກະດານໄດ້ຖືກຕິດຕັ້ງແລະຮັບປະກັນດ້ວຍ screw M3 ດຽວ (ບໍ່ມີພື້ນທີ່ເພີ່ມເຕີມໃນກະດານ)

ຂ້ອຍເລືອກຈໍສະແດງຜົນແລ້ວເມື່ອຂ້ອຍພິມຕົວຢ່າງທໍາອິດຂອງກໍລະນີ. ເຄື່ອງອ່ານສອງແຖວມາດຕະຖານບໍ່ເຫມາະສົມກັບກໍລະນີນີ້, ແຕ່ຢູ່ດ້ານລຸ່ມມີຈໍສະແດງຜົນ OLED SSD1306 128 × 32. ມັນນ້ອຍ, ແຕ່ຂ້ອຍບໍ່ຈໍາເປັນຕ້ອງເບິ່ງມັນທຸກໆມື້ - ມັນຫຼາຍເກີນໄປສໍາລັບຂ້ອຍ.

ການຄິດອອກທາງນີ້ແລະວ່າສາຍໄຟຈະຖືກສົ່ງຈາກມັນແນວໃດ, ຂ້ອຍໄດ້ຕັດສິນໃຈຕິດຈໍສະແດງຜົນຢູ່ເຄິ່ງກາງຂອງກໍລະນີ. Ergonomics, ແນ່ນອນ, ແມ່ນຢູ່ຂ້າງລຸ່ມ - ປຸ່ມຢູ່ເທິງ, ຈໍສະແດງຜົນແມ່ນຢູ່ດ້ານລຸ່ມ. ແຕ່ຂ້ອຍເວົ້າແລ້ວວ່າຄວາມຄິດທີ່ຈະຕິດຈໍສະແດງຜົນມາຊ້າເກີນໄປແລະຂ້ອຍກໍ່ຂີ້ກຽດເກີນໄປທີ່ຈະ rewire ກະດານເພື່ອຍ້າຍປຸ່ມ.

ອຸປະກອນໄດ້ຖືກປະກອບ. ໂມດູນຈໍສະແດງຜົນແມ່ນຕິດກັບ snot ດ້ວຍກາວຮ້ອນ

ຜົນໄດ້ຮັບສຸດທ້າຍສາມາດເຫັນໄດ້ໃນ KDPV

Firmware

ໃຫ້ຍ້າຍໄປຫາພາກສ່ວນຊອບແວ. ສໍາລັບເຄື່ອງຫັດຖະກໍາຂະຫນາດນ້ອຍເຊັ່ນນີ້, ຂ້ອຍມັກໃຊ້ Python (micropython) - ລະຫັດ turns ອອກຈະຫນາແຫນ້ນຫຼາຍແລະເຂົ້າໃຈໄດ້. ໂຊກດີ, ບໍ່ຈໍາເປັນຕ້ອງລົງໄປຫາລະດັບການລົງທະບຽນເພື່ອບີບ microseconds - ທຸກສິ່ງທຸກຢ່າງສາມາດເຮັດໄດ້ຈາກ Python.

ມັນເບິ່ງຄືວ່າທຸກສິ່ງທຸກຢ່າງແມ່ນງ່າຍດາຍ, ແຕ່ບໍ່ແມ່ນງ່າຍດາຍຫຼາຍ - ອຸປະກອນມີຫນ້າທີ່ເອກະລາດຫຼາຍ:

• ຜູ້ໃຊ້ກົດປຸ່ມແລະເບິ່ງຈໍສະແດງຜົນ
• ລິດຫມາຍຕິກແລະປັບປຸງຄ່າໃນຫນ່ວຍຄວາມຈໍາ flash
• ໂມດູນຈະຕິດຕາມສັນຍານ WiFi ແລະເຊື່ອມຕໍ່ຄືນໃໝ່ຖ້າຈໍາເປັນ
• ແລ້ວ, ຖ້າບໍ່ມີຫລອດໄຟກະພິບ, ມັນເປັນໄປບໍ່ໄດ້

ທ່ານ​ບໍ່​ສາ​ມາດ​ສົມ​ມຸດ​ວ່າ​ຫນຶ່ງ​ຫນ້າ​ທີ່​ບໍ່​ໄດ້​ເຮັດ​ວຽກ​ຖ້າ​ຫາກ​ວ່າ​ອີກ​ຫນຶ່ງ​ແມ່ນ stuck ສໍາ​ລັບ​ເຫດ​ຜົນ​ບາງ​ຢ່າງ​. ຂ້ອຍເຄີຍມີ cacti ຂອງຂ້ອຍຢູ່ໃນໂຄງການອື່ນໆແລ້ວແລະຕອນນີ້ຂ້ອຍຍັງເຫັນຄວາມບົກຜ່ອງໃນແບບຂອງ "ພາດໄປອີກລິດຫນຶ່ງເພາະວ່າຈໍສະແດງຜົນກໍາລັງປັບປຸງໃນຂະນະນັ້ນ" ຫຼື "ຜູ້ໃຊ້ບໍ່ສາມາດເຮັດຫຍັງໄດ້ໃນຂະນະທີ່ໂມດູນກໍາລັງເຊື່ອມຕໍ່ກັບ. WiFi.” ແນ່ນອນ, ບາງສິ່ງບາງຢ່າງສາມາດເຮັດໄດ້ໂດຍຜ່ານການຂັດຂວາງ, ແຕ່ທ່ານອາດຈະເຂົ້າໄປໃນຂໍ້ຈໍາກັດກ່ຽວກັບໄລຍະເວລາ, ຮັງຂອງການໂທ, ຫຼືການປ່ຽນແປງທີ່ບໍ່ແມ່ນປະລໍາມະນູກັບຕົວແປ. ດີ, ລະຫັດທີ່ເຮັດທຸກຢ່າງຢ່າງໄວວາປ່ຽນເປັນ mush.

В ໂຄງການທີ່ຮ້າຍແຮງກວ່າເກົ່າ ຂ້ອຍໃຊ້ multitasking preemptive classic ແລະ FreeRTOS, ແຕ່ໃນກໍລະນີນີ້ຕົວແບບໄດ້ກາຍມາເປັນທີ່ເຫມາະສົມຫຼາຍ. coroutines ແລະ uasync libraries . ຍິ່ງໄປກວ່ານັ້ນ, ການປະຕິບັດ Python ຂອງ coroutines ແມ່ນພຽງແຕ່ເຮັດໃຫ້ປະລາດ - ທຸກສິ່ງທຸກຢ່າງແມ່ນເຮັດຢ່າງງ່າຍດາຍແລະສະດວກສໍາລັບຜູ້ຂຽນໂປລແກລມ. ພຽງແຕ່ຂຽນເຫດຜົນຂອງທ່ານເອງ, ພຽງແຕ່ບອກຂ້ອຍວ່າບ່ອນໃດທີ່ທ່ານສາມາດປ່ຽນລະຫວ່າງສາຍນ້ໍາ.

ຂ້ອຍຂໍແນະ ນຳ ໃຫ້ສຶກສາຄວາມແຕກຕ່າງລະຫວ່າງວຽກທີ່ເຮັດລ່ວງໜ້າ ແລະ ການແຂ່ງຂັນຫຼາຍໜ້າເປັນວິຊາທາງເລືອກ. ດຽວນີ້, ສຸດທ້າຍໃຫ້ກ້າວໄປສູ່ລະຫັດ.

#####################################
# Counter class - implements a single water counter on specified pin
#####################################
class Counter():
    debounce_ms = const(25)
    
    def __init__(self, pin_num, value_storage):
        self._value_storage = value_storage
        
        self._value = self._value_storage.read()
        self._value_changed = False

        self._pin = Pin(pin_num, Pin.IN, Pin.PULL_UP)

        loop = asyncio.get_event_loop()
        loop.create_task(self._switchcheck())  # Thread runs forever

ແຕ່ລະ counter ແມ່ນຈັດການໂດຍຕົວຢ່າງຂອງ Counter class. ກ່ອນອື່ນ ໝົດ, ມູນຄ່າ counter ເບື້ອງຕົ້ນແມ່ນຫັກອອກຈາກ EEPROM (value_storage) - ນີ້ແມ່ນວິທີການຟື້ນຟູຫຼັງຈາກຄວາມລົ້ມເຫຼວຂອງພະລັງງານຖືກປະຕິບັດ.

pin ໄດ້ຖືກເລີ່ມຕົ້ນດ້ວຍຕົວດຶງຂຶ້ນເພື່ອສະຫນອງພະລັງງານ: ຖ້າປິດ reed, ສາຍແມ່ນສູນ, ຖ້າສາຍແມ່ນເປີດ, ມັນຖືກດຶງຂຶ້ນໄປຫາການສະຫນອງພະລັງງານແລະຕົວຄວບຄຸມອ່ານຫນຶ່ງ.

ວຽກງານແຍກຕ່າງຫາກຍັງຖືກເປີດຕົວຢູ່ທີ່ນີ້, ເຊິ່ງຈະສໍາຫຼວດ pin. ແຕ່ລະ counter ຈະດໍາເນີນວຽກງານຂອງຕົນເອງ. ນີ້ແມ່ນລະຫັດຂອງນາງ

    """ Poll pin and advance value when another litre passed """
    async def _switchcheck(self):
        last_checked_pin_state = self._pin.value()  # Get initial state

        # Poll for a pin change
        while True:
            state = self._pin.value()
            if state != last_checked_pin_state:
                # State has changed: act on it now.
                last_checked_pin_state = state
                if state == 0:
                    self._another_litre_passed()

            # Ignore further state changes until switch has settled
            await asyncio.sleep_ms(Counter.debounce_ms)

ຄວາມລ່າຊ້າຂອງ 25ms ແມ່ນຈໍາເປັນເພື່ອການກັ່ນຕອງການຕິດຕໍ່ bounce, ແລະໃນເວລາດຽວກັນມັນຄວບຄຸມວ່າວຽກງານທີ່ຕື່ນນອນເລື້ອຍໆ (ໃນຂະນະທີ່ວຽກງານນີ້ກໍາລັງນອນ, ວຽກອື່ນໆກໍາລັງເຮັດວຽກຢູ່). ທຸກໆ 25ms ຟັງຊັນຕື່ນຂຶ້ນ, ກວດເບິ່ງ pin ແລະຖ້າ reed switch contacts ປິດ, ຫຼັງຈາກນັ້ນອີກລິດໄດ້ຜ່ານແມັດແລະນີ້ຕ້ອງໄດ້ຮັບການປຸງແຕ່ງ.

    def _another_litre_passed(self):
        self._value += 1
        self._value_changed = True

        self._value_storage.write(self._value)

ການປຸງແຕ່ງລິດຕໍ່ໄປແມ່ນເປັນເລື່ອງເລັກໆນ້ອຍໆ - ຕົວຕ້ານທານພຽງແຕ່ເພີ່ມຂຶ້ນ. ດີ, ມັນຈະເປັນການດີທີ່ຈະຂຽນຄ່າໃຫມ່ໃສ່ flash drive.

ເພື່ອຄວາມສະດວກໃນການນໍາໃຊ້, "ອຸປະກອນເສີມ" ແມ່ນສະຫນອງໃຫ້

    def value(self):
        self._value_changed = False
        return self._value

    def set_value(self, value):
        self._value = value
        self._value_changed = False

ແລ້ວ, ຕອນນີ້ໃຫ້ພວກເຮົາໃຊ້ປະໂຫຍດຈາກຄວາມດີໃຈຂອງ Python ແລະຫ້ອງສະຫມຸດ uasync ແລະສ້າງວັດຖຸທີ່ລໍຖ້າໄດ້ (ພວກເຮົາຈະແປເປັນພາສາລັດເຊຍໄດ້ແນວໃດ? ສິ່ງທີ່ທ່ານຄາດຫວັງ?)

    def __await__(self):
        while not self._value_changed:
            yield from asyncio.sleep(0)

        return self.value()

    __iter__ = __await__  

ນີ້ແມ່ນຫນ້າທີ່ສະດວກທີ່ລໍຖ້າຈົນກ່ວາການນັບຄ່າຖືກປັບປຸງ - ຟັງຊັນຕື່ນຂຶ້ນເປັນບາງຄັ້ງຄາວແລະກວດເບິ່ງທຸງ _value_changed. ສິ່ງທີ່ເຢັນກ່ຽວກັບຟັງຊັນນີ້ແມ່ນວ່າລະຫັດການໂທສາມາດນອນຫລັບໃນຂະນະທີ່ໂທຫາຟັງຊັນນີ້ແລະນອນຈົນກ່ວາໄດ້ຮັບຄ່າໃຫມ່.

ແມ່ນຫຍັງກ່ຽວກັບການຂັດຂວາງ?ແມ່ນແລ້ວ, ໃນຈຸດນີ້, ທ່ານສາມາດ troll ຂ້ອຍ, ໂດຍເວົ້າວ່າຕົວເຈົ້າເອງເວົ້າກ່ຽວກັບການຂັດຂວາງ, ແຕ່ໃນຄວາມເປັນຈິງແລ້ວເຈົ້າໄດ້ເຮັດແບບສໍາຫຼວດ pin stupid. ຕົວຈິງແລ້ວການຂັດຂວາງແມ່ນສິ່ງທໍາອິດທີ່ຂ້ອຍພະຍາຍາມ. ໃນ ESP8266, ທ່ານສາມາດຈັດວາງ edge interrupt, ແລະແມ້ກະທັ້ງຂຽນຕົວຈັດການສໍາລັບການຂັດຂວາງນີ້ໃນ Python. ໃນການຂັດຂວາງນີ້, ມູນຄ່າຂອງຕົວແປສາມາດປັບປຸງໄດ້. ອາດຈະເປັນ, ນີ້ຈະເປັນການພຽງພໍຖ້າຫາກວ່າ counter ເປັນອຸປະກອນສໍາລອງ - ຫນຶ່ງທີ່ລໍຖ້າຈົນກ່ວາມັນໄດ້ຖືກຮ້ອງຂໍໃຫ້ມີຄ່ານີ້.

ແຕ່ຫນ້າເສຍດາຍ (ຫຼືໂຊກດີ?) ອຸປະກອນຂອງຂ້ອຍເຮັດວຽກຢູ່, ມັນຕ້ອງສົ່ງຂໍ້ຄວາມຜ່ານໂປໂຕຄອນ MQTT ແລະຂຽນຂໍ້ມູນໄປຫາ EEPROM. ແລະໃນທີ່ນີ້ຂໍ້ຈໍາກັດເຂົ້າມາ - ທ່ານບໍ່ສາມາດຈັດສັນຫນ່ວຍຄວາມຈໍາໃນການຂັດຂວາງແລະໃຊ້ stack ໃຫຍ່, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານສາມາດລືມກ່ຽວກັບການສົ່ງຂໍ້ຄວາມຜ່ານເຄືອຂ່າຍ. ມີ buns ເຊັ່ນ micropython.schedule() ທີ່ອະນຸຍາດໃຫ້ທ່ານສາມາດດໍາເນີນການບາງຫນ້າທີ່ "ໄວເທົ່າທີ່ເປັນໄປໄດ້," ແຕ່ຄໍາຖາມທີ່ເກີດຂື້ນ, "ແມ່ນຫຍັງຄືຈຸດ?" ຈະເປັນແນວໃດຖ້າຫາກວ່າພວກເຮົາກໍາລັງສົ່ງຂໍ້ຄວາມບາງປະເພດໃນປັດຈຸບັນ, ແລະຫຼັງຈາກນັ້ນການຂັດຂວາງເຂົ້າມາແລະ spoils ມູນຄ່າຂອງຕົວແປ. ຫຼືຕົວຢ່າງ, ຄ່າ counter ໃໝ່ມາຮອດຈາກເຊີບເວີໃນຂະນະທີ່ພວກເຮົາຍັງບໍ່ໄດ້ຂຽນລົງອັນເກົ່າ. ໂດຍທົ່ວໄປ, ທ່ານຈໍາເປັນຕ້ອງປິດການ synchronization ຫຼືອອກຈາກມັນບາງຢ່າງທີ່ແຕກຕ່າງກັນ.

ແລະບາງຄັ້ງ RuntimeError: ກໍານົດເວລາ stack crash ເຕັມແລະໃຜຮູ້ວ່າເປັນຫຍັງ?

ດ້ວຍການລົງຄະແນນສຽງທີ່ຊັດເຈນແລະ uasync, ໃນກໍລະນີດັ່ງກ່າວນີ້ somehow turns out ງາມແລະເຊື່ອຖືໄດ້

ຂ້າພະເຈົ້າໄດ້ນໍາເອົາການເຮັດວຽກກັບ EEPROM ໄປຫາຫ້ອງຮຽນຂະຫນາດນ້ອຍ

class EEPROM():
    i2c_addr = const(80)

    def __init__(self, i2c):
        self.i2c = i2c
        self.i2c_buf = bytearray(4) # Avoid creation/destruction of the buffer on each call


    def read(self, eeprom_addr):
        self.i2c.readfrom_mem_into(self.i2c_addr, eeprom_addr, self.i2c_buf, addrsize=16)
        return ustruct.unpack_from("<I", self.i2c_buf)[0]    
        
    
    def write(self, eeprom_addr, value):
        ustruct.pack_into("<I", self.i2c_buf, 0, value)
        self.i2c.writeto_mem(self.i2c_addr, eeprom_addr, self.i2c_buf, addrsize=16)

ໃນ Python, ມັນເປັນການຍາກທີ່ຈະເຮັດວຽກໂດຍກົງກັບ bytes, ແຕ່ວ່າມັນແມ່ນ bytes ທີ່ຖືກຂຽນໄວ້ໃນຫນ່ວຍຄວາມຈໍາ. ຂ້ອຍຕ້ອງຮົ້ວການແປງລະຫວ່າງຈໍານວນເຕັມແລະ bytes ໂດຍໃຊ້ຫ້ອງສະຫມຸດ ustruct.

ເພື່ອບໍ່ໃຫ້ໂອນວັດຖຸ I2C ແລະທີ່ຢູ່ຂອງເຊນຫນ່ວຍຄວາມຈໍາທຸກຄັ້ງ, ຂ້າພະເຈົ້າໄດ້ຫໍ່ມັນທັງຫມົດໃນແບບຄລາສສິກຂະຫນາດນ້ອຍແລະສະດວກ.

class EEPROMValue():
    def __init__(self, i2c, eeprom_addr):
        self._eeprom = EEPROM(i2c)
        self._eeprom_addr = eeprom_addr
        

    def read(self):
        return self._eeprom.read(self._eeprom_addr)


    def write(self, value):
        self._eeprom.write(self._eeprom_addr, value)

ວັດຖຸ I2C ຕົວຂອງມັນເອງຖືກສ້າງຂື້ນດ້ວຍຕົວກໍານົດການເຫຼົ່ານີ້

i2c = I2C(freq=400000, scl=Pin(5), sda=Pin(4))

ພວກເຮົາມາຮອດສ່ວນທີ່ຫນ້າສົນໃຈທີ່ສຸດ - ການປະຕິບັດການສື່ສານກັບເຄື່ອງແມ່ຂ່າຍຜ່ານ MQTT. ດີ, ບໍ່ຈໍາເປັນຕ້ອງປະຕິບັດໂປໂຕຄອນຕົວມັນເອງ - ຂ້ອຍພົບມັນຢູ່ໃນອິນເຕີເນັດ ການປະຕິບັດ asynchronous ທີ່ກຽມພ້ອມ. ນີ້ແມ່ນສິ່ງທີ່ພວກເຮົາຈະໃຊ້.

ສິ່ງທີ່ຫນ້າສົນໃຈຫຼາຍທີ່ສຸດແມ່ນລວບລວມຢູ່ໃນຫ້ອງຮຽນ CounterMQTTClient, ເຊິ່ງອີງໃສ່ຫ້ອງສະຫມຸດ MQTTClient. ໃຫ້ເລີ່ມຕົ້ນຈາກ periphery ໄດ້

#####################################
# Class handles both counters and sends their status to MQTT
#####################################
class CounterMQTTClient(MQTTClient):

    blue_led = Pin(2, Pin.OUT, value = 1)
    button = Pin(0, Pin.IN)

    hot_counter = Counter(12, EEPROMValue(i2c, EEPROM_ADDR_HOT_VALUE))
    cold_counter = Counter(13, EEPROMValue(i2c, EEPROM_ADDR_COLD_VALUE))

ທີ່ນີ້ທ່ານສາມາດສ້າງແລະກໍາຫນົດຄ່າ pins bulb ແສງສະຫວ່າງແລະປຸ່ມ, ເຊັ່ນດຽວກັນກັບວັດຖຸເຄື່ອງວັດນ້ໍາເຢັນແລະຮ້ອນ.

ດ້ວຍການເລີ່ມຕົ້ນ, ບໍ່ແມ່ນທຸກສິ່ງທຸກຢ່າງແມ່ນເປັນເລື່ອງເລັກນ້ອຍ

    def __init__(self):
        self.internet_outage = True
        self.internet_outages = 0
        self.internet_outage_start = ticks_ms()

        with open("config.txt") as config_file:
            config['ssid'] = config_file.readline().rstrip()
            config['wifi_pw'] = config_file.readline().rstrip()
            config['server'] = config_file.readline().rstrip()
            config['client_id'] = config_file.readline().rstrip()
            self._mqtt_cold_water_theme = config_file.readline().rstrip()
            self._mqtt_hot_water_theme = config_file.readline().rstrip()
            self._mqtt_debug_water_theme = config_file.readline().rstrip()

        config['subs_cb'] = self.mqtt_msg_handler
        config['wifi_coro'] = self.wifi_connection_handler
        config['connect_coro'] = self.mqtt_connection_handler
        config['clean'] = False
        config['clean_init'] = False
        super().__init__(config)

        loop = asyncio.get_event_loop()
        loop.create_task(self._heartbeat())
        loop.create_task(self._counter_coro(self.cold_counter, self._mqtt_cold_water_theme))
        loop.create_task(self._counter_coro(self.hot_counter, self._mqtt_hot_water_theme))
        loop.create_task(self._display_coro())

ເພື່ອກໍານົດພາລາມິເຕີການດໍາເນີນງານຂອງຫ້ອງສະຫມຸດ mqtt_as, ວັດຈະນານຸກົມຂະຫນາດໃຫຍ່ຂອງການຕັ້ງຄ່າທີ່ແຕກຕ່າງກັນຖືກນໍາໃຊ້ - config . ສ່ວນໃຫຍ່ຂອງການຕັ້ງຄ່າເລີ່ມຕົ້ນແມ່ນດີສໍາລັບພວກເຮົາ, ແຕ່ການຕັ້ງຄ່າຈໍານວນຫຼາຍຈໍາເປັນຕ້ອງໄດ້ກໍານົດຢ່າງຈະແຈ້ງ. ເພື່ອບໍ່ໃຫ້ຂຽນການຕັ້ງຄ່າໂດຍກົງໃນລະຫັດ, ຂ້ອຍເກັບໄວ້ໃນໄຟລ໌ຂໍ້ຄວາມ config.txt. ນີ້ອະນຸຍາດໃຫ້ທ່ານສາມາດປ່ຽນລະຫັດໂດຍບໍ່ສົນເລື່ອງຂອງການຕັ້ງຄ່າ, ເຊັ່ນດຽວກັນກັບ rivet ຫຼາຍອຸປະກອນທີ່ຄ້າຍຄືກັນກັບຕົວກໍານົດການທີ່ແຕກຕ່າງກັນ.

ບລັອກສຸດທ້າຍຂອງລະຫັດເລີ່ມຕົ້ນ coroutines ຫຼາຍເພື່ອຮັບໃຊ້ຫນ້າທີ່ຕ່າງໆຂອງລະບົບ. ຕົວຢ່າງ, ນີ້ແມ່ນ coroutine ທີ່ບໍລິການ counters

    async def _counter_coro(self, counter, topic):
        # Publish initial value
        value = counter.value()
        await self.publish(topic, str(value))

        # Publish each new value
        while True:
            value = await counter
            await self.publish_msg(topic, str(value))

coroutine ລໍຖ້າຢູ່ໃນ loop ສໍາລັບມູນຄ່າ counter ໃຫມ່ແລະ, ທັນທີທີ່ມັນປາກົດ, ສົ່ງຂໍ້ຄວາມຜ່ານ MQTT protocol. ຊິ້ນສ່ວນທໍາອິດຂອງລະຫັດສົ່ງມູນຄ່າເບື້ອງຕົ້ນເຖິງແມ່ນວ່າບໍ່ມີນ້ໍາໄຫຼຜ່ານເຄົາເຕີ.

ຫ້ອງຮຽນພື້ນຖານ MQTTClient ໃຫ້ບໍລິການຕົວມັນເອງ, ເລີ່ມການເຊື່ອມຕໍ່ WiFi ແລະເຊື່ອມຕໍ່ຄືນໃຫມ່ເມື່ອການເຊື່ອມຕໍ່ຫາຍໄປ. ເມື່ອມີການປ່ຽນແປງສະຖານະຂອງການເຊື່ອມຕໍ່ WiFi, ຫ້ອງສະໝຸດຈະແຈ້ງໃຫ້ພວກເຮົາຮູ້ໂດຍການໂທຫາ wifi_connection_handler.

    async def wifi_connection_handler(self, state):
        self.internet_outage = not state
        if state:
            self.dprint('WiFi is up.')
            duration = ticks_diff(ticks_ms(), self.internet_outage_start) // 1000
            await self.publish_debug_msg('ReconnectedAfter', duration)
        else:
            self.internet_outages += 1
            self.internet_outage_start = ticks_ms()
            self.dprint('WiFi is down.')
            
        await asyncio.sleep(0)

ຟັງຊັນຖືກຄັດລອກຢ່າງຊື່ສັດຈາກຕົວຢ່າງ. ໃນກໍລະນີນີ້, ມັນນັບຈໍານວນການຢຸດ (internet_outages) ແລະໄລຍະເວລາຂອງພວກເຂົາ. ເມື່ອການເຊື່ອມຕໍ່ຖືກຟື້ນຟູ, ເວລາຫວ່າງຖືກສົ່ງໄປຫາເຄື່ອງແມ່ຂ່າຍ.

ໂດຍວິທີທາງການ, ການນອນສຸດທ້າຍແມ່ນຈໍາເປັນພຽງແຕ່ເພື່ອເຮັດໃຫ້ຟັງຊັນບໍ່ກົງກັນ - ໃນຫ້ອງສະຫມຸດມັນຖືກເອີ້ນຜ່ານທາງລໍຖ້າ, ແລະພຽງແຕ່ຫນ້າທີ່ຂອງຮ່າງກາຍມີຕົວລໍຖ້າອື່ນສາມາດເອີ້ນໄດ້.

ນອກເຫນືອຈາກການເຊື່ອມຕໍ່ WiFi, ທ່ານຍັງຈໍາເປັນຕ້ອງສ້າງການເຊື່ອມຕໍ່ກັບນາຍຫນ້າ MQTT (ເຄື່ອງແມ່ຂ່າຍ). ຫ້ອງສະຫມຸດເຮັດເຊັ່ນດຽວກັນ, ແລະພວກເຮົາໄດ້ຮັບໂອກາດທີ່ຈະເຮັດບາງສິ່ງບາງຢ່າງທີ່ເປັນປະໂຫຍດໃນເວລາທີ່ການເຊື່ອມຕໍ່ໄດ້ຖືກສ້າງຕັ້ງຂຶ້ນ

    async def mqtt_connection_handler(self, client):
        await client.subscribe(self._mqtt_cold_water_theme)
        await client.subscribe(self._mqtt_hot_water_theme)

ໃນທີ່ນີ້ພວກເຮົາຈອງຂໍ້ຄວາມຈໍານວນຫນຶ່ງ - ເຄື່ອງແມ່ຂ່າຍໃນປັດຈຸບັນມີຄວາມສາມາດທີ່ຈະກໍານົດຄ່າຕ້ານທານໃນປະຈຸບັນໂດຍການສົ່ງຂໍ້ຄວາມທີ່ສອດຄ້ອງກັນ.

    def mqtt_msg_handler(self, topic, msg):
        topicstr = str(topic, 'utf8')
        self.dprint("Received MQTT message topic={}, msg={}".format(topicstr, msg))

        if topicstr == self._mqtt_cold_water_theme:
            self.cold_counter.set_value(int(msg))

        if topicstr == self._mqtt_hot_water_theme:
            self.hot_counter.set_value(int(msg))

ຟັງຊັນນີ້ປະມວນຜົນຂໍ້ຄວາມທີ່ເຂົ້າມາ, ແລະຂຶ້ນກັບຫົວຂໍ້ (ຫົວຂໍ້ຂໍ້ຄວາມ), ຄ່າຂອງຫນຶ່ງໃນຕົວນັບຈະຖືກປັບປຸງ.

ສອງສາມຫນ້າທີ່ຜູ້ຊ່ວຍ

    # Publish a message if WiFi and broker is up, else discard
    async def publish_msg(self, topic, msg):
        self.dprint("Publishing message on topic {}: {}".format(topic, msg))
        if not self.internet_outage:
            await self.publish(topic, msg)
        else:
            self.dprint("Message was not published - no internet connection")

ຟັງຊັນນີ້ສົ່ງຂໍ້ຄວາມຖ້າການເຊື່ອມຕໍ່ຖືກສ້າງຕັ້ງຂຶ້ນ. ຖ້າບໍ່ມີການເຊື່ອມຕໍ່, ຂໍ້ຄວາມຈະຖືກລະເລີຍ.

ແລະນີ້ແມ່ນພຽງແຕ່ຫນ້າທີ່ສະດວກທີ່ສ້າງແລະສົ່ງຂໍ້ຄວາມ debugging.

    async def publish_debug_msg(self, subtopic, msg):
        await self.publish_msg("{}/{}".format(self._mqtt_debug_water_theme, subtopic), str(msg))

ຂໍ້ຄວາມຫຼາຍ, ແລະພວກເຮົາຍັງບໍ່ໄດ້ກະພິບ LED ເທື່ອ. ທີ່ນີ້

    # Blink flash LED if WiFi down
    async def _heartbeat(self):
        while True:
            if self.internet_outage:
                self.blue_led(not self.blue_led()) # Fast blinking if no connection
                await asyncio.sleep_ms(200) 
            else:
                self.blue_led(0) # Rare blinking when connected
                await asyncio.sleep_ms(50)
                self.blue_led(1)
                await asyncio.sleep_ms(5000)

ຂ້ອຍໄດ້ໃຫ້ 2 ໂໝດກະພິບ. ຖ້າການເຊື່ອມຕໍ່ຖືກສູນເສຍ (ຫຼືມັນພຽງແຕ່ຖືກສ້າງຕັ້ງຂຶ້ນ), ອຸປະກອນຈະກະພິບຢ່າງໄວວາ. ຖ້າການເຊື່ອມຕໍ່ຖືກສ້າງຕັ້ງຂຶ້ນ, ອຸປະກອນຈະກະພິບທຸກໆ 5 ວິນາທີ. ຖ້າຈໍາເປັນ, ຮູບແບບກະພິບອື່ນໆສາມາດຖືກປະຕິບັດຢູ່ທີ່ນີ້.

ແຕ່ LED ແມ່ນພຽງແຕ່ pampering. ພວກເຮົາຍັງແນໃສ່ການສະແດງ.

    async def _display_coro(self):
        display = SSD1306_I2C(128,32, i2c)
    
        while True:
            display.poweron()
            display.fill(0)
            display.text("COLD: {:.3f}".format(self.cold_counter.value() / 1000), 16, 4)
            display.text("HOT:  {:.3f}".format(self.hot_counter.value() / 1000), 16, 20)
            display.show()
            await asyncio.sleep(3)
            display.poweroff()

            while self.button():
                await asyncio.sleep_ms(20)

ນີ້ແມ່ນສິ່ງທີ່ຂ້ອຍເວົ້າກ່ຽວກັບ - ວິທີທີ່ງ່າຍດາຍແລະສະດວກສະບາຍກັບ coroutines. ຟັງຊັນນ້ອຍໆນີ້ອະທິບາຍປະສົບການຂອງຜູ້ໃຊ້ທັງໝົດ. coroutine ພຽງ​ແຕ່​ລໍ​ຖ້າ​ໃຫ້​ປຸ່ມ​ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ກົດ​ດັນ​ແລະ​ເປີດ​ຫນ້າ​ຈໍ​ສໍາ​ລັບ 3 ວິ​ນາ​ທີ​. ຈໍສະແດງຜົນສະແດງໃຫ້ເຫັນການອ່ານແມັດໃນປະຈຸບັນ.

ຍັງ​ມີ​ບາງ​ສິ່ງ​ເລັກ​ນ້ອຍ​ຍັງ​ເຫຼືອ​. ນີ້ແມ່ນຫນ້າທີ່ (re) ເລີ່ມຕົ້ນວິສາຫະກິດທັງຫມົດນີ້. loop ຕົ້ນຕໍພຽງແຕ່ສົ່ງຂໍ້ມູນ debugging ຕ່າງໆຫນຶ່ງຄັ້ງຕໍ່ນາທີ. ໂດຍທົ່ວໄປ, ຂ້າພະເຈົ້າອ້າງວ່າມັນເປັນ - ຂ້ອຍບໍ່ຄິດວ່າມີຄວາມຈໍາເປັນທີ່ຈະສະແດງຄວາມຄິດເຫັນຫຼາຍເກີນໄປ

   async def main(self):
        while True:
            try:
                await self._connect_to_WiFi()
                await self._run_main_loop()
                    
            except Exception as e:
                self.dprint('Global communication failure: ', e)
                await asyncio.sleep(20)

    async def _connect_to_WiFi(self):
        self.dprint('Connecting to WiFi and MQTT')
        sta_if = network.WLAN(network.STA_IF)
        sta_if.connect(config['ssid'], config['wifi_pw'])
        
        conn = False
        while not conn:
            await self.connect()
            conn = True

        self.dprint('Connected!')
        self.internet_outage = False

    async def _run_main_loop(self):
        # Loop forever
        mins = 0
        while True:
            gc.collect()  # For RAM stats.
            mem_free = gc.mem_free()
            mem_alloc = gc.mem_alloc()

            try:
                await self.publish_debug_msg("Uptime", mins)
                await self.publish_debug_msg("Repubs", self.REPUB_COUNT)
                await self.publish_debug_msg("Outages", self.internet_outages)
                await self.publish_debug_msg("MemFree", mem_free)
                await self.publish_debug_msg("MemAlloc", mem_alloc)
            except Exception as e:
                self.dprint("Exception occurred: ", e)
            mins += 1

            await asyncio.sleep(60)

ດີ, ສອງສາມການຕັ້ງຄ່າແລະຄ່າຄົງທີ່ເພີ່ມເຕີມເພື່ອເຮັດສໍາເລັດຄໍາອະທິບາຍ

#####################################
# Constants and configuration
#####################################


config['keepalive'] = 60
config['clean'] = False
config['will'] = ('/ESP/Wemos/Water/LastWill', 'Goodbye cruel world!', False, 0)

MQTTClient.DEBUG = True

EEPROM_ADDR_HOT_VALUE = const(0)
EEPROM_ADDR_COLD_VALUE = const(4)

ມັນທັງຫມົດເລີ່ມຕົ້ນແບບນີ້

client = CounterMQTTClient()
loop = asyncio.get_event_loop()
loop.run_until_complete(client.main())

ບາງສິ່ງບາງຢ່າງເກີດຂຶ້ນກັບຄວາມຊົງຈໍາຂອງຂ້ອຍ

ດັ່ງນັ້ນ, ລະຫັດທັງຫມົດຢູ່ທີ່ນັ້ນ. ຂ້ອຍອັບໂຫລດໄຟລ໌ໂດຍໃຊ້ ampy utility - ມັນຊ່ວຍໃຫ້ທ່ານສາມາດອັບໂຫລດພວກມັນໃສ່ພາຍໃນ (ຫນຶ່ງໃນ ESP-07 ຕົວຂອງມັນເອງ) flash drive ແລະຫຼັງຈາກນັ້ນເຂົ້າເຖິງມັນຈາກໂຄງການເປັນໄຟລ໌ປົກກະຕິ. ຢູ່ທີ່ນັ້ນຂ້ອຍຍັງໄດ້ອັບໂຫລດ mqtt_as, uasyncio, ssd1306 ແລະຫ້ອງສະຫມຸດການເກັບກໍາທີ່ຂ້ອຍໃຊ້ (ໃຊ້ພາຍໃນ mqtt_as).

ພວກເຮົາເປີດຕົວແລະ ... ພວກເຮົາໄດ້ຮັບ MemoryError. ຍິ່ງໄປກວ່ານັ້ນ, ຫຼາຍຂ້າພະເຈົ້າພະຍາຍາມເຂົ້າໃຈບ່ອນທີ່ຄວາມຊົງຈໍາໄດ້ຮົ່ວໄຫລ, ການພິມ debug ຫຼາຍຂ້າພະເຈົ້າໄດ້ວາງໄວ້, ຄວາມຜິດພາດນີ້ປາກົດຂຶ້ນກ່ອນຫນ້ານີ້. ການຄົ້ນຫາ Google ສັ້ນໆເຮັດໃຫ້ຂ້ອຍເຂົ້າໃຈວ່າ microcontroller ມີ, ໃນຫຼັກການ, ພຽງແຕ່ 30 kB ຂອງຫນ່ວຍຄວາມຈໍາ, ເຊິ່ງ 65 kB ຂອງລະຫັດ (ລວມທັງຫ້ອງສະຫມຸດ) ພຽງແຕ່ບໍ່ສາມາດເຫມາະ.

ແຕ່ມີທາງອອກ. ມັນປະກົດວ່າ micropython ບໍ່ປະຕິບັດລະຫັດໂດຍກົງຈາກໄຟລ໌ .py - ໄຟລ໌ນີ້ຖືກລວບລວມກ່ອນ. ຍິ່ງໄປກວ່ານັ້ນ, ມັນຖືກລວບລວມໂດຍກົງໃນ microcontroller, ກາຍເປັນ bytecode, ເຊິ່ງຖືກເກັບໄວ້ໃນຫນ່ວຍຄວາມຈໍາ. ດີ, ເພື່ອໃຫ້ compiler ເຮັດວຽກ, ທ່ານກໍ່ຕ້ອງການ RAM ຈໍານວນທີ່ແນ່ນອນ.

ເຄັດລັບແມ່ນເພື່ອຊ່ວຍປະຢັດ microcontroller ຈາກການລວບລວມຊັບພະຍາກອນຫຼາຍ. ທ່ານສາມາດລວບລວມໄຟລ໌ໃນຄອມພິວເຕີຂະຫນາດໃຫຍ່ແລະອັບໂຫລດ bytecode ພ້ອມທີ່ຈະເຮັດແລ້ວເຂົ້າໄປໃນ microcontroller. ເພື່ອເຮັດສິ່ງນີ້, ທ່ານຈໍາເປັນຕ້ອງໄດ້ດາວໂຫລດ firmware micropython ແລະສ້າງ mpy-cross utility.

ຂ້ອຍບໍ່ໄດ້ຂຽນ Makefile, ແຕ່ຕົນເອງໄດ້ຜ່ານແລະລວບລວມໄຟລ໌ທີ່ຈໍາເປັນທັງຫມົດ (ລວມທັງຫ້ອງສະຫມຸດ) ບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້.

mpy-cross water_counter.py

ສິ່ງທີ່ຍັງເຫຼືອແມ່ນການອັບໂຫລດໄຟລ໌ທີ່ມີນາມສະກຸນ .mpy, ຢ່າລືມລຶບ .py ທີ່ສອດຄ້ອງກັນອອກຈາກລະບົບໄຟລ໌ຂອງອຸປະກອນກ່ອນ.

ຂ້າພະເຈົ້າໄດ້ພັດທະນາທັງຫມົດໃນໂຄງການ (IDE?) ESPlorer. ມັນອະນຸຍາດໃຫ້ທ່ານສາມາດອັບໂຫລດ scripts ກັບ microcontroller ແລະດໍາເນີນການໃຫ້ເຂົາເຈົ້າທັນທີ. ໃນກໍລະນີຂອງຂ້ອຍ, ເຫດຜົນທັງຫມົດແລະການສ້າງວັດຖຸທັງຫມົດແມ່ນຢູ່ໃນໄຟລ໌ water_counter.py (.mpy). ແຕ່ເພື່ອໃຫ້ທັງໝົດນີ້ເລີ່ມອັດຕະໂນມັດ, ຕ້ອງມີໄຟລ໌ທີ່ເອີ້ນວ່າ main.py ໃນຕອນເລີ່ມຕົ້ນ. ຍິ່ງໄປກວ່ານັ້ນ, ມັນຄວນຈະເປັນ .py ຢ່າງແທ້ຈິງ, ແລະບໍ່ແມ່ນການລວບລວມກ່ອນ .mpy. ນີ້ແມ່ນເນື້ອໃນເລັກນ້ອຍຂອງມັນ

import water_counter

ພວກເຮົາເປີດຕົວມັນ - ທຸກສິ່ງທຸກຢ່າງເຮັດວຽກ. ແຕ່ຄວາມຊົງຈໍາທີ່ບໍ່ເສຍຄ່າແມ່ນມີຂະຫນາດນ້ອຍທີ່ຫນ້າຕົກໃຈ - ປະມານ 1kb. ຂ້ອຍຍັງມີແຜນທີ່ຈະຂະຫຍາຍການເຮັດວຽກຂອງອຸປະກອນ, ແລະກິໂລໄບນີ້ຢ່າງຊັດເຈນບໍ່ພຽງພໍສໍາລັບຂ້ອຍ. ແຕ່ມັນໄດ້ຫັນອອກວ່າມີທາງອອກສໍາລັບກໍລະນີນີ້ຄືກັນ.

ນີ້ແມ່ນສິ່ງທີ່. ເຖິງແມ່ນວ່າໄຟລ໌ຖືກລວບລວມເຂົ້າໄປໃນ bytecode ແລະອາໄສຢູ່ໃນລະບົບໄຟລ໌ພາຍໃນ, ໃນຄວາມເປັນຈິງພວກມັນຍັງຖືກໂຫລດເຂົ້າໄປໃນ RAM ແລະຖືກປະຕິບັດຈາກບ່ອນນັ້ນ. ແຕ່ມັນປາກົດວ່າ micropython ສາມາດປະຕິບັດ bytecode ໂດຍກົງຈາກຫນ່ວຍຄວາມຈໍາ flash, ແຕ່ສໍາລັບການນີ້, ທ່ານຈໍາເປັນຕ້ອງສ້າງມັນໂດຍກົງໃນ firmware. ມັນບໍ່ຍາກ, ເຖິງແມ່ນວ່າມັນໃຊ້ເວລາຂ້ອນຂ້າງຢູ່ໃນ netbook ຂອງຂ້ອຍ (ພຽງແຕ່ຂ້ອຍມີ Linux).

ສູດການຄິດໄລ່ມີດັ່ງນີ້:

• ດາວໂຫລດແລະຕິດຕັ້ງ ESP ເປີດ SDK. ສິ່ງນີ້ປະກອບ compiler ແລະຫ້ອງສະຫມຸດສໍາລັບໂຄງການສໍາລັບ ESP8266. ປະ​ກອບ​ຕາມ​ຄໍາ​ແນະ​ນໍາ​ໃນ​ຫນ້າ​ຕົ້ນ​ຕໍ​ຂອງ​ໂຄງ​ການ (ຂ້າ​ພະ​ເຈົ້າ​ເລືອກ​ເອົາ​ການ​ຕັ້ງ​ຄ່າ STANDALONE = ແມ່ນ​ແລ້ວ​)
• ດາວໂຫລດ micropython ປະເພດ
• ວາງຫ້ອງສະຫມຸດທີ່ຕ້ອງການຢູ່ໃນພອດ / esp8266 / ໂມດູນພາຍໃນຕົ້ນໄມ້ micropython
• ພວກເຮົາປະກອບເຟີມແວຕາມຄໍາແນະນໍາໃນໄຟລ໌ ports/esp8266/README.md
• ພວກເຮົາອັບໂຫລດເຟີມແວໃສ່ microcontroller (ຂ້ອຍເຮັດສິ່ງນີ້ໃນ Windows ໂດຍໃຊ້ໂປຣແກຣມ ESP8266Flasher ຫຼື Python esptool)

ນັ້ນແມ່ນ, ຕອນນີ້ 'ນໍາເຂົ້າ ssd1306' ຈະຍົກລະຫັດໂດຍກົງຈາກເຟີມແວແລະ RAM ຈະບໍ່ຖືກບໍລິໂພກສໍາລັບການນີ້. ດ້ວຍ trick ນີ້, ຂ້າພະເຈົ້າໄດ້ອັບໂຫລດພຽງແຕ່ລະຫັດຫ້ອງສະຫມຸດເຂົ້າໄປໃນ firmware, ໃນຂະນະທີ່ລະຫັດໂຄງການຕົ້ນຕໍຖືກປະຕິບັດຈາກລະບົບໄຟລ໌. ນີ້ອະນຸຍາດໃຫ້ທ່ານສາມາດດັດແປງໂຄງການໄດ້ຢ່າງງ່າຍດາຍໂດຍບໍ່ມີການ recompiling firmware. ໃນປັດຈຸບັນຂ້າພະເຈົ້າມີປະມານ 8.5kb ຂອງ RAM ຟຣີ. ນີ້ຈະຊ່ວຍໃຫ້ພວກເຮົາປະຕິບັດຫນ້າທີ່ທີ່ເປັນປະໂຫຍດທີ່ແຕກຕ່າງກັນຫຼາຍໃນອະນາຄົດ. ດີ, ຖ້າບໍ່ມີຫນ່ວຍຄວາມຈໍາພຽງພໍ, ຫຼັງຈາກນັ້ນທ່ານສາມາດຍູ້ໂຄງການຕົ້ນຕໍເຂົ້າໄປໃນ firmware.

ດັ່ງນັ້ນພວກເຮົາຄວນເຮັດແນວໃດກ່ຽວກັບມັນໃນປັດຈຸບັນ?

ຕົກລົງ, ຮາດແວຖືກ soldered, ເຟີມແວຖືກຂຽນ, ກ່ອງຖືກພິມອອກ, ອຸປະກອນຖືກຕິດຢູ່ເທິງຝາແລະກະພິບດອກໄຟຢ່າງມີຄວາມສຸກ. ແຕ່ສໍາລັບໃນປັດຈຸບັນມັນເປັນກ່ອງສີດໍາທັງຫມົດ (ຕົວຫນັງສືແລະຕົວເລກ) ແລະມັນຍັງໃຊ້ຫນ້ອຍ. ມັນເປັນເວລາທີ່ຈະເຮັດບາງສິ່ງບາງຢ່າງກັບຂໍ້ຄວາມ MQTT ທີ່ຖືກສົ່ງໄປຫາເຄື່ອງແມ່ຂ່າຍ.

"ເຮືອນອັດສະລິຍະ" ຂອງຂ້ອຍກຳລັງໝູນວຽນຢູ່ ລະບົບ Majordomo. ໂມດູນ MQTT ອອກມາຈາກກ່ອງ, ຫຼືຖືກຕິດຕັ້ງໄດ້ງ່າຍຈາກຕະຫຼາດ add-on - ຂ້ອຍບໍ່ຈື່ວ່າຂ້ອຍໄດ້ມາຈາກໃສ. MQTT ບໍ່ແມ່ນສິ່ງທີ່ຕົນເອງພຽງພໍ - ທ່ານຕ້ອງການອັນທີ່ເອີ້ນວ່າ. ນາຍໜ້າ - ເຊີບເວີທີ່ໄດ້ຮັບ, ຈັດຮຽງ ແລະສົ່ງຕໍ່ຂໍ້ຄວາມ MQTT ໃຫ້ກັບລູກຄ້າ. ຂ້ອຍໃຊ້ຢາຍຸງ, ເຊິ່ງ (ເຊັ່ນ majordomo) ແລ່ນຢູ່ໃນ netbook ດຽວກັນ.

ຫຼັງຈາກອຸປະກອນສົ່ງຂໍ້ຄວາມຢ່າງຫນ້ອຍຫນຶ່ງຄັ້ງ, ມູນຄ່າຈະປາກົດໃນບັນຊີລາຍຊື່ທັນທີ.

ໃນປັດຈຸບັນມູນຄ່າເຫຼົ່ານີ້ສາມາດເຊື່ອມໂຍງກັບວັດຖຸຂອງລະບົບ, ພວກເຂົາສາມາດຖືກນໍາໃຊ້ໃນ scripts ອັດຕະໂນມັດແລະຂຶ້ນກັບການວິເຄາະຕ່າງໆ - ທັງຫມົດແມ່ນເກີນຂອບເຂດຂອງບົດຄວາມນີ້. ຂ້ອຍສາມາດແນະນໍາລະບົບ majordomo ໃຫ້ທຸກຄົນທີ່ສົນໃຈ channel Electronics In Lens — ເພື່ອນ​ກໍ່​ສ້າງ​ເຮືອນ​ອັດ​ສະ​ລິ​ຍະ ແລະ​ເວົ້າ​ຢ່າງ​ຈະ​ແຈ້ງ​ກ່ຽວ​ກັບ​ການ​ຕັ້ງ​ລະ​ບົບ.

ຂ້າພະເຈົ້າພຽງແຕ່ຈະສະແດງໃຫ້ທ່ານເຫັນສອງສາມເສັ້ນ. ນີ້ແມ່ນເສັ້ນສະແດງທີ່ງ່າຍດາຍຂອງມູນຄ່າປະຈໍາວັນ

ສາມາດເຫັນໄດ້ວ່າເກືອບບໍ່ມີໃຜໃຊ້ນ້ໍາໃນຕອນກາງຄືນ. ສອງສາມເທື່ອມີຄົນໄປຫ້ອງນ້ໍາ, ແລະເບິ່ງຄືວ່າການກັ່ນຕອງ osmosis ດ້ານຫລັງດູດສອງສາມລິດຕໍ່ຄືນ. ໃນຕອນເຊົ້າ, ການບໍລິໂພກເພີ່ມຂຶ້ນຢ່າງຫຼວງຫຼາຍ. ປົກກະຕິແລ້ວຂ້ອຍໃຊ້ນ້ໍາຈາກຫມໍ້ຫຸງຕົ້ມ, ແຕ່ຫຼັງຈາກນັ້ນຂ້ອຍຢາກອາບນ້ໍາແລະປ່ຽນເປັນນ້ໍາຮ້ອນໃນເມືອງຊົ່ວຄາວ - ນີ້ແມ່ນເຫັນໄດ້ຊັດເຈນຢູ່ໃນເສັ້ນສະແດງດ້ານລຸ່ມ.

ຈາກຕາຕະລາງນີ້ຂ້ອຍໄດ້ຮຽນຮູ້ວ່າການໄປຫ້ອງນ້ໍາຕ້ອງການນ້ໍາ 6-7 ລິດ, ການອາບນ້ໍາຕ້ອງການ 20-30 ລິດ, ການລ້າງຖ້ວຍຕ້ອງການປະມານ 20 ລິດ, ການອາບນ້ໍາຕ້ອງການ 160 ລິດ. ຄອບຄົວຂອງຂ້ອຍບໍລິໂພກປະມານ 500-600 ລິດຕໍ່ມື້.

ສໍາລັບຜູ້ທີ່ຢາກຮູ້ຢາກເຫັນໂດຍສະເພາະ, ທ່ານສາມາດເບິ່ງບັນທຶກສໍາລັບມູນຄ່າແຕ່ລະຄົນ

ຈາກທີ່ນີ້ຂ້ອຍໄດ້ຮຽນຮູ້ວ່າເມື່ອທໍ່ເປີດ, ນ້ໍາຈະໄຫຼດ້ວຍຄວາມໄວປະມານ 1 ລິດຕໍ່ 5 ວິນາທີ.

ແຕ່ໃນຮູບແບບນີ້, ສະຖິຕິອາດຈະບໍ່ສະດວກຫຼາຍທີ່ຈະເບິ່ງ. Majordomo ຍັງມີຄວາມສາມາດໃນການເບິ່ງຕາຕະລາງການບໍລິໂພກໃນມື້, ອາທິດແລະເດືອນ. ທີ່ນີ້, ສໍາລັບການຍົກຕົວຢ່າງ, ແມ່ນເສັ້ນສະແດງການບໍລິໂພກໃນແຖບ

ມາຮອດປະຈຸບັນຂ້າພະເຈົ້າມີຂໍ້ມູນພຽງແຕ່ຫນຶ່ງອາທິດເທົ່ານັ້ນ. ໃນເດືອນຫນຶ່ງ, ເສັ້ນສະແດງນີ້ຈະເປັນຕົວຊີ້ບອກຫຼາຍ - ໃນແຕ່ລະມື້ຈະມີຖັນແຍກຕ່າງຫາກ. ຮູບພາບແມ່ນ spoiled ເລັກນ້ອຍໂດຍການປັບຕົວກັບຄ່າທີ່ຂ້ອຍໃສ່ດ້ວຍຕົນເອງ (ຖັນທີ່ໃຫຍ່ທີ່ສຸດ). ແລະມັນຍັງບໍ່ທັນເປັນທີ່ຊັດເຈນວ່າຂ້ອຍຕັ້ງຄ່າທໍາອິດບໍ່ຖືກຕ້ອງ, ເກືອບ cube ຫນ້ອຍ, ຫຼືວ່ານີ້ແມ່ນຂໍ້ບົກພ່ອງໃນ firmware ແລະບໍ່ແມ່ນທັງຫມົດລິດຖືກນັບ. ຕ້ອງການເວລາເພີ່ມເຕີມ.

ເສັ້ນສະແດງຕົວເອງຍັງຕ້ອງການ magic, whitewashing, painting. ບາງທີຂ້ອຍຍັງຈະສ້າງເສັ້ນສະແດງການບໍລິໂພກຫນ່ວຍຄວາມຈໍາສໍາລັບຈຸດປະສົງ debugging - ໃນກໍລະນີທີ່ມີບາງສິ່ງບາງຢ່າງຮົ່ວໄຫຼ. ບາງທີຂ້ອຍຈະສະແດງບາງຊ່ວງເວລາທີ່ບໍ່ມີອິນເຕີເນັດ. ສໍາລັບໃນປັດຈຸບັນ, ທັງຫມົດນີ້ແມ່ນຢູ່ໃນລະດັບຂອງແນວຄວາມຄິດ.

ສະຫລຸບ

ມື້ນີ້ອາພາດເມັນຂອງຂ້ອຍໄດ້ກາຍເປັນທີ່ສະຫລາດກວ່າເລັກນ້ອຍ. ດ້ວຍອຸປະກອນຂະຫນາດນ້ອຍດັ່ງກ່າວ, ມັນຈະສະດວກກວ່າສໍາລັບຂ້ອຍໃນການຕິດຕາມການບໍລິໂພກນ້ໍາໃນເຮືອນ. ຖ້າກ່ອນຫນ້ານັ້ນຂ້ອຍໃຈຮ້າຍ "ອີກເທື່ອຫນຶ່ງ, ພວກເຮົາບໍລິໂພກນ້ໍາຫຼາຍໃນເດືອນ," ຕອນນີ້ຂ້ອຍສາມາດຊອກຫາແຫຼ່ງຂອງການບໍລິໂພກນີ້.

ບາງ​ຄົນ​ອາດ​ຈະ​ເຫັນ​ວ່າ​ມັນ​ແປກ​ທີ່​ຈະ​ເບິ່ງ​ການ​ອ່ານ​ໃນ​ຫນ້າ​ຈໍ​ຖ້າ​ຫາກ​ວ່າ​ມັນ​ເປັນ​ແມັດ​ຫ່າງ​ຈາກ​ແມັດ​ຕົວ​ມັນ​ເອງ. ແຕ່ໃນອະນາຄົດບໍ່ໄກຫຼາຍ, ຂ້ອຍວາງແຜນທີ່ຈະຍ້າຍໄປອາພາດເມັນອື່ນ, ບ່ອນທີ່ຈະມີນ້ໍາຖ້ວມຫຼາຍ, ແລະແມັດຂອງຕົວເອງສ່ວນຫຼາຍແມ່ນຕັ້ງຢູ່ເທິງຫນ້າດິນ. ດັ່ງນັ້ນອຸປະກອນການອ່ານຫ່າງໄກສອກຫຼີກຈະເປັນປະໂຫຍດຫຼາຍ.

ຂ້ອຍຍັງວາງແຜນທີ່ຈະຂະຫຍາຍການເຮັດວຽກຂອງອຸປະກອນ. ຂ້ອຍກຳລັງເບິ່ງປ່ຽງມໍເຕີແລ້ວ. ດຽວນີ້, ເພື່ອປ່ຽນຫມໍ້ຫຸງຕົ້ມເປັນນ້ໍາໃນເມືອງ, ຂ້ອຍຈໍາເປັນຕ້ອງຫັນ 3 ທໍ່ຢູ່ໃນບ່ອນທີ່ຍາກທີ່ຈະເຂົ້າເຖິງ. ມັນຈະສະດວກກວ່າທີ່ຈະເຮັດສິ່ງນີ້ດ້ວຍປຸ່ມດຽວທີ່ມີຕົວຊີ້ບອກທີ່ສອດຄ້ອງກັນ. ດີ, ແນ່ນອນ, ມັນຄຸ້ມຄ່າທີ່ຈະປະຕິບັດການປ້ອງກັນການຮົ່ວໄຫຼ.

ໃນບົດຄວາມຂ້າພະເຈົ້າໄດ້ອະທິບາຍສະບັບຂອງຂ້າພະເຈົ້າຂອງອຸປະກອນໂດຍອີງໃສ່ ESP8266. ໃນຄວາມຄິດເຫັນຂອງຂ້ອຍ, ຂ້ອຍໄດ້ມາກັບສະບັບທີ່ຫນ້າສົນໃຈຫຼາຍຂອງ firmware micropython ໂດຍໃຊ້ coroutines - ງ່າຍດາຍແລະງາມ. ຂ້າ​ພະ​ເຈົ້າ​ພະ​ຍາ​ຍາມ​ອະ​ທິ​ບາຍ​ຫຼາຍ nuances ແລະ​ຂໍ້​ບົກ​ຜ່ອງ​ທີ່​ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ພົບ​ໃນ​ລະ​ຫວ່າງ​ການ​ໂຄ​ສະ​ນາ. ບາງທີຂ້ອຍໄດ້ອະທິບາຍທຸກຢ່າງໃນລາຍລະອຽດຫຼາຍເກີນໄປ; ໂດຍສ່ວນຕົວແລ້ວ, ໃນຖານະຜູ້ອ່ານ, ມັນງ່າຍກວ່າສໍາລັບຂ້ອຍທີ່ຈະຂ້າມສິ່ງທີ່ບໍ່ຈໍາເປັນກວ່າທີ່ຈະຄິດກ່ຽວກັບສິ່ງທີ່ຖືກປະໄວ້ໂດຍບໍ່ໄດ້ເວົ້າ.

ໃນຖານະເປັນສະເຫມີ, ຂ້າພະເຈົ້າເປີດໃຫ້ຄໍາວິຈານທີ່ສ້າງສັນ.

ລະຫັດແຫຼ່ງຂໍ້ມູນ
ວົງຈອນແລະກະດານ
ຕົວແບບກໍລະນີ

ແຫຼ່ງຂໍ້ມູນ: www.habr.com