យើងភ្ជាប់ម៉ែត្រទឹកទៅនឹងផ្ទះឆ្លាតវៃ

ម្តងនេះ ប្រព័ន្ធស្វ័យប្រវត្តិកម្មតាមផ្ទះ ឬ "ផ្ទះឆ្លាត" ដូចដែលគេហៅជាញឹកញាប់ មានតម្លៃថ្លៃណាស់ ហើយមានតែអ្នកមានទេដែលអាចទិញវាបាន។ សព្វថ្ងៃនេះនៅលើទីផ្សារ អ្នកអាចរកឃើញឧបករណ៍ដែលមានតម្លៃថោកសមរម្យជាមួយនឹងឧបករណ៍ចាប់សញ្ញា ប៊ូតុង/កុងតាក់ និងឧបករណ៍ចាប់សញ្ញាសម្រាប់ត្រួតពិនិត្យពន្លឺ រន្ធ ខ្យល់ ការផ្គត់ផ្គង់ទឹក និងអ្នកប្រើប្រាស់ផ្សេងទៀត។ ហើយសូម្បីតែមនុស្ស DIY ដ៏ច្រលំបំផុតក៏អាចចូលរួមក្នុងភាពស្រស់ស្អាត និងប្រមូលផ្តុំឧបករណ៍សម្រាប់ផ្ទះឆ្លាតវៃក្នុងតម្លៃសមរម្យ។

ជាធម្មតា ឧបករណ៍ដែលបានស្នើឡើងគឺជាឧបករណ៍ចាប់សញ្ញា ឬឧបករណ៍ចាប់សញ្ញា។ ពួកគេធ្វើឱ្យមានភាពងាយស្រួលក្នុងការអនុវត្តសេណារីយ៉ូដូចជា "នៅពេលដែលឧបករណ៍ចាប់សញ្ញាចលនាត្រូវបានកេះ បើកភ្លើង" ឬ "កុងតាក់នៅជិតច្រកចេញនឹងបិទភ្លើងនៅក្នុងផ្ទះល្វែងទាំងមូល"។ ប៉ុន្តែ​អ្វី​ៗ​មិន​ដំណើរការ​ជាមួយ​នឹង​តេឡេម៉ែត្រ​ទេ។ ល្អបំផុត វាជាក្រាហ្វនៃសីតុណ្ហភាព និងសំណើម ឬថាមពលភ្លាមៗនៅព្រីជាក់លាក់។

ថ្មីៗនេះខ្ញុំបានដំឡើងម៉ែត្រទឹកជាមួយនឹងទិន្នផលជីពចរ។ សម្រាប់រាល់លីត្រដែលឆ្លងកាត់ម៉ែត្រ កុងតាក់ Reed ត្រូវបានធ្វើឱ្យសកម្ម និងបិទទំនាក់ទំនង។ រឿងតែមួយគត់ដែលត្រូវធ្វើគឺការតោងខ្សែភ្លើងហើយព្យាយាមទទួលបានអត្ថប្រយោជន៍ពីវា។ ឧទាហរណ៍ វិភាគការប្រើប្រាស់ទឹកតាមម៉ោង និងថ្ងៃនៃសប្តាហ៍។ ជាការប្រសើរណាស់ ប្រសិនបើមានអ្នកឡើងទឹកជាច្រើននៅក្នុងអាផាតមិន នោះវាងាយស្រួលជាងក្នុងការមើលសូចនាករបច្ចុប្បន្នទាំងអស់នៅលើអេក្រង់តែមួយ ជាជាងការឡើងចូលទៅក្នុងកន្លែងពិបាកទៅដល់ដោយប្រើពិល។

ខាងក្រោមការកាត់នេះគឺជាកំណែឧបករណ៍របស់ខ្ញុំដោយផ្អែកលើ ESP8266 ដែលរាប់ជីពចរពីម៉ែត្រទឹក និងផ្ញើការអានតាមរយៈ MQTT ទៅម៉ាស៊ីនមេផ្ទះឆ្លាតវៃ។ យើងនឹងសរសេរកម្មវិធីជា micropython ដោយប្រើបណ្ណាល័យ uasyncio ។ នៅពេលបង្កើតកម្មវិធីបង្កប់ ខ្ញុំបានជួបប្រទះការលំបាកគួរឱ្យចាប់អារម្មណ៍ជាច្រើន ដែលខ្ញុំនឹងពិភាក្សានៅក្នុងអត្ថបទនេះផងដែរ។ ទៅ!

គម្រោងនេះ

បេះដូងនៃសៀគ្វីទាំងមូលគឺជាម៉ូឌុលនៅលើ microcontroller ESP8266 ។ ESP-12 ត្រូវ​បាន​គេ​គ្រោង​ទុក​ពី​ដំបូង ប៉ុន្តែ​មីន​បាន​ប្រែ​ទៅ​ជា​មាន​បញ្ហា។ យើងត្រូវតែពេញចិត្តជាមួយនឹងម៉ូឌុល ESP-07 ដែលអាចប្រើបាន។ ជាសំណាងល្អ ពួកវាដូចគ្នាទាំងផ្នែកម្ជុល និងមុខងារ ភាពខុសគ្នាតែមួយគត់គឺនៅក្នុងអង់តែន - ESP-12 មានភ្ជាប់មកជាមួយមួយ ខណៈ ESP-07 មានផ្នែកខាងក្រៅ។ ទោះយ៉ាងណាក៏ដោយ ទោះបីជាមិនមានអង់តែនវ៉ាយហ្វាយក៏ដោយ ក៏សញ្ញានៅក្នុងបន្ទប់ទឹករបស់ខ្ញុំត្រូវបានទទួលជាធម្មតា។

ខ្សែភ្លើងម៉ូឌុលស្តង់ដារ៖

• ប៊ូតុងកំណត់ឡើងវិញជាមួយនឹងការទាញឡើងនិង capacitor (ទោះបីជាទាំងពីរមាននៅក្នុងម៉ូឌុលរួចហើយ)
• សញ្ញាបើក (CH_PD) ត្រូវបានទាញឡើងដើម្បីថាមពល
• GPIO15 ត្រូវបានទាញទៅដី។ នេះគ្រាន់តែជាការចាំបាច់នៅពេលចាប់ផ្តើមប៉ុណ្ណោះ ប៉ុន្តែខ្ញុំនៅតែមិនមានអ្វីជាប់នឹងជើងនេះទេ ខ្ញុំលែងត្រូវការវាទៀតហើយ

ដើម្បីដាក់ម៉ូឌុលចូលទៅក្នុងរបៀបកម្មវិធីបង្កប់ អ្នកត្រូវកាត់សៀគ្វីខ្លី GPIO2 ទៅដី ហើយដើម្បីឱ្យវាកាន់តែងាយស្រួល ខ្ញុំបានផ្ដល់ប៊ូតុងចាប់ផ្ដើម។ នៅក្នុងស្ថានភាពធម្មតា ម្ជុលនេះត្រូវបានទាញទៅថាមពល។

ស្ថានភាពនៃខ្សែ GPIO2 ត្រូវបានពិនិត្យតែនៅពេលចាប់ផ្តើមប្រតិបត្តិការ - នៅពេលដែលថាមពលត្រូវបានអនុវត្ត ឬភ្លាមៗបន្ទាប់ពីការកំណត់ឡើងវិញ។ ដូច្នេះ ម៉ូឌុលចាប់ផ្ដើមដូចធម្មតា ឬចូលទៅក្នុងរបៀបកម្មវិធីបង្កប់។ នៅពេលដែលបានផ្ទុក ម្ជុលនេះអាចត្រូវបានប្រើជា GPIO ធម្មតា។ ជាការប្រសើរណាស់ ដោយសារមានប៊ូតុងនៅទីនោះរួចហើយ អ្នកអាចភ្ជាប់មុខងារមានប្រយោជន៍មួយចំនួនទៅវា។

សម្រាប់ការសរសេរកម្មវិធី និងការបំបាត់កំហុស ខ្ញុំនឹងប្រើ UART ដែលជាលទ្ធផលទៅជាសិតសក់។ នៅពេលចាំបាច់ ខ្ញុំគ្រាន់តែភ្ជាប់អាដាប់ទ័រ USB-UART នៅទីនោះ។ អ្នកគ្រាន់តែត្រូវចាំថាម៉ូឌុលនេះត្រូវបានបំពាក់ដោយ 3.3V ។ ប្រសិនបើអ្នកភ្លេចប្តូរអាដាប់ទ័រទៅវ៉ុលនេះ និងផ្គត់ផ្គង់ 5V នោះម៉ូឌុលទំនងជានឹងឆេះ។

ខ្ញុំមិនមានបញ្ហាជាមួយអគ្គីសនីនៅក្នុងបន្ទប់ទឹកទេ - ព្រីមានទីតាំងនៅប្រហែលមួយម៉ែត្រពីម៉ែត្រដូច្នេះខ្ញុំនឹងត្រូវបានបំពាក់ដោយ 220V ។ ក្នុងនាមជាប្រភពថាមពលខ្ញុំនឹងមានតូចមួយ ប្លុក HLK-PM03 ដោយ Tenstar Robot ។ ដោយផ្ទាល់ខ្ញុំមានការលំបាកជាមួយឧបករណ៍អេឡិចត្រូនិកអាណាឡូកនិងថាមពលប៉ុន្តែនៅទីនេះគឺជាការផ្គត់ផ្គង់ថាមពលដែលត្រៀមរួចជាស្រេចនៅក្នុងករណីតូចមួយ។

ដើម្បីផ្តល់សញ្ញារបៀបប្រតិបត្តិការ ខ្ញុំបានផ្ដល់ LED ដែលភ្ជាប់ទៅ GPIO2។ ទោះ​ជា​យ៉ាង​ណា​ក៏​ដោយ ខ្ញុំ​មិន​បាន​ដោះ​ស្រាយ​ទេ ព្រោះ... ម៉ូឌុល ESP-07 មាន LED រួចហើយ ហើយវាក៏ត្រូវបានភ្ជាប់ទៅ GPIO2 ផងដែរ។ ប៉ុន្តែអនុញ្ញាតឱ្យវានៅលើក្តារក្នុងករណីដែលខ្ញុំចង់បញ្ចេញ LED នេះទៅករណី។

ចូរបន្តទៅផ្នែកដែលគួរឱ្យចាប់អារម្មណ៍បំផុត។ ម៉ែត្រទឹកមិនមានតក្កវិជ្ជាទេ អ្នកមិនអាចសុំឱ្យពួកគេអានបច្ចុប្បន្នបានទេ។ រឿងតែមួយគត់ដែលមានសម្រាប់យើងគឺការជំរុញ - បិទទំនាក់ទំនងនៃកុងតាក់ Reed រៀងរាល់លីត្រ។ ទិន្នផលកុងតាក់ Reed របស់ខ្ញុំត្រូវបានភ្ជាប់ទៅ GPIO12/GPIO13។ ខ្ញុំនឹងបើកដំណើរការ resistor ទាញឡើងតាមកម្មវិធីនៅខាងក្នុងម៉ូឌុល។

ដំបូង​ឡើយ ខ្ញុំ​ភ្លេច​ផ្តល់​ឧបករណ៍​ទប់ទល់ R8 និង R9 ហើយ​ក្តារ​បន្ទះ​របស់​ខ្ញុំ​មិន​មាន​វា​ទេ។ ប៉ុន្តែ ដោយសារ​ខ្ញុំ​បាន​បង្ហោះ​ដ្យាក្រាម​ឲ្យ​អ្នក​រាល់​គ្នា​មើល​រួច​ហើយ វា​គួរ​តែ​កែ​តម្រូវ​ការ​ត្រួត​ពិនិត្យ​នេះ។ Resistors គឺចាំបាច់ដើម្បីកុំឱ្យឆេះច្រក ប្រសិនបើកម្មវិធីបង្កប់មានបញ្ហា ហើយកំណត់ម្ជុលទៅមួយ ហើយ Reed switch កាត់ខ្សែនេះទៅដី (ជាមួយនឹង resistor អតិបរមា 3.3V/1000Ohm = 3.3mA នឹងហូរ)។

វាដល់ពេលដែលត្រូវគិតអំពីអ្វីដែលត្រូវធ្វើប្រសិនបើអគ្គិសនីរលត់។ ជម្រើសដំបូងគឺត្រូវស្នើសុំតម្លៃរាប់ដំបូងពីម៉ាស៊ីនមេនៅពេលចាប់ផ្តើម។ ប៉ុន្តែនេះនឹងតម្រូវឱ្យមានភាពស្មុគស្មាញយ៉ាងសំខាន់នៃពិធីការប្តូរប្រាក់។ លើសពីនេះទៅទៀត ដំណើរការរបស់ឧបករណ៍ក្នុងករណីនេះគឺអាស្រ័យលើស្ថានភាពរបស់ម៉ាស៊ីនមេ។ ប្រសិនបើម៉ាស៊ីនមេមិនបានចាប់ផ្តើមបន្ទាប់ពីការបិទថាមពល (ឬចាប់ផ្តើមនៅពេលក្រោយ) នោះម៉ែត្រទឹកនឹងមិនអាចស្នើសុំតម្លៃដំបូងបានទេ ហើយនឹងមិនដំណើរការត្រឹមត្រូវ។

ដូច្នេះហើយ ខ្ញុំបានសម្រេចចិត្តអនុវត្តការសន្សំតម្លៃរាប់ក្នុងបន្ទះឈីបអង្គចងចាំដែលភ្ជាប់តាមរយៈ I2C ។ ខ្ញុំមិនមានតម្រូវការពិសេសណាមួយសម្រាប់ទំហំនៃអង្គចងចាំពន្លឺទេ - អ្នកគ្រាន់តែត្រូវរក្សាទុកលេខ 2 ប៉ុណ្ណោះ (ចំនួនលីត្រយោងទៅតាមម៉ែត្រទឹកក្តៅនិងត្រជាក់) ។ សូម្បីតែម៉ូឌុលតូចបំផុតនឹងធ្វើ។ ប៉ុន្តែអ្នកត្រូវយកចិត្តទុកដាក់លើចំនួនវដ្តនៃការថត។ សម្រាប់ម៉ូឌុលភាគច្រើននេះគឺ 100 ពាន់វដ្តសម្រាប់មួយចំនួនរហូតដល់មួយលាន។

វាហាក់ដូចជាថាមួយលានគឺច្រើន។ ប៉ុន្តែក្នុងអំឡុងពេល 4 ឆ្នាំនៃការរស់នៅក្នុងផ្ទះល្វែងរបស់ខ្ញុំខ្ញុំបានប្រើប្រាស់ទឹកច្រើនជាង 500 ម៉ែត្រគូបគឺ 500 ពាន់លីត្រ! និង 500 ពាន់កំណត់ត្រានៅក្នុងពន្លឺ។ ហើយនោះគ្រាន់តែជាទឹកត្រជាក់ប៉ុណ្ណោះ។ ជា​ការ​ពិត​ណាស់ អ្នក​អាច​លក់​បន្ទះ​ឈីប​ជា​រៀង​រាល់​ពីរ​ឆ្នាំ​ម្តង ប៉ុន្តែ​វា​ប្រែ​ថា​មាន​បន្ទះ​ឈីប FRAM។ តាមទស្សនៈនៃការសរសេរកម្មវិធី នេះគឺជា I2C EEPROM ដូចគ្នា តែជាមួយនឹងចំនួនដ៏ច្រើននៃវដ្តនៃការសរសេរឡើងវិញ (រាប់រយលាន)។ វាគ្រាន់តែថាខ្ញុំនៅតែមិនអាចទៅដល់ហាងជាមួយនឹងមីក្រូសៀគ្វីបែបនេះ ដូច្នេះសម្រាប់ពេលនេះ 24LC512 ធម្មតានឹងឈរ។

បន្ទះសៀគ្វីដែលបានបោះពុម្ព

ដំបូង​ឡើយ ខ្ញុំ​មាន​គម្រោង​ធ្វើ​ក្តារ​នៅ​ផ្ទះ។ ដូច្នេះបន្ទះក្តារត្រូវបានរចនាជាផ្នែកម្ខាង។ ប៉ុន្តែបន្ទាប់ពីចំណាយពេលមួយម៉ោងជាមួយដែកឡាស៊ែរ និងរបាំងដែក (វាមិនអីទេបើគ្មានវា) ខ្ញុំនៅតែសម្រេចចិត្តបញ្ជាក្តារបន្ទះពីជនជាតិចិន។

ស្ទើរតែមុនពេលបញ្ជាទិញក្តារ ខ្ញុំបានដឹងថា បន្ថែមពីលើបន្ទះឈីបអង្គចងចាំពន្លឺ ខ្ញុំអាចភ្ជាប់អ្វីផ្សេងទៀតដែលមានប្រយោជន៍ទៅនឹងឡានក្រុង I2C ដូចជាអេក្រង់ជាដើម។ អ្វី​ដែល​ត្រូវ​ចេញ​ទៅ​វា​ពិត​ប្រាកដ​នៅ​តែ​ជា​សំណួរ ប៉ុន្តែ​វា​ត្រូវ​តែ​ត្រូវ​បាន​បញ្ជូន​ទៅ​លើ​ក្តារ។ ជាការប្រសើរណាស់ ចាប់តាំងពីខ្ញុំនឹងបញ្ជាទិញក្តារពីរោងចក្រ វាគ្មានចំណុចណាមួយក្នុងការកំណត់ខ្លួនខ្ញុំចំពោះក្តារតែមួយទេ ដូច្នេះខ្សែ I2C គឺមានតែមួយគត់នៅផ្នែកខាងក្រោយនៃក្តារ។

វាក៏មានបញ្ហាធំមួយផងដែរជាមួយនឹងខ្សែភ្លើងមួយផ្លូវ។ ដោយសារតែ បន្ទះត្រូវបានគូរជាផ្នែកម្ខាង ដូច្នេះផ្លូវដែក និងសមាសធាតុ SMD ត្រូវបានគេគ្រោងនឹងដាក់នៅម្ខាង ហើយសមាសធាតុទិន្នផល ឧបករណ៍ភ្ជាប់ និងការផ្គត់ផ្គង់ថាមពលនៅម្ខាងទៀត។ នៅពេលខ្ញុំទទួលបានក្តារបន្ទះមួយខែក្រោយមក ខ្ញុំភ្លេចអំពីផែនការដើម ហើយបានលក់គ្រឿងបន្លាស់ទាំងអស់នៅផ្នែកខាងមុខ។ ហើយមានតែនៅពេលដែលវាមកដល់ការបិទការផ្គត់ផ្គង់ថាមពលវាប្រែថាបូកនិងដកត្រូវបានខ្សែបញ្ច្រាស។ ខ្ញុំត្រូវធ្វើស្រែជាមួយអ្នកលោត។ នៅក្នុងរូបភាពខាងលើ ខ្ញុំបានផ្លាស់ប្តូរខ្សែភ្លើងរួចហើយ ប៉ុន្តែដីត្រូវបានផ្ទេរពីផ្នែកមួយនៃក្តារទៅមួយទៀតតាមរយៈម្ជុលនៃប៊ូតុងប៊ូត (ទោះបីជាវាអាចគូរផ្លូវនៅលើស្រទាប់ទីពីរក៏ដោយ) ។

វាប្រែចេញដូចនេះ

ផ្ទះ

ជំហានបន្ទាប់គឺរាងកាយ។ ប្រសិនបើអ្នកមានម៉ាស៊ីនបោះពុម្ព 3D នេះមិនមែនជាបញ្ហាទេ។ ខ្ញុំ​មិន​រំខាន​ខ្លាំង​ពេក​ទេ - ខ្ញុំ​គ្រាន់​តែ​គូរ​ប្រអប់​ដែល​មាន​ទំហំ​ត្រឹមត្រូវ ហើយ​ធ្វើ​ការ​កាត់​នៅ​កន្លែង​ដែល​ត្រឹមត្រូវ។ គម្របត្រូវបានភ្ជាប់ទៅតួជាមួយនឹងវីសដាប់ខ្លួនតូចៗ។

ខ្ញុំបាននិយាយរួចហើយថាប៊ូតុងចាប់ផ្ដើមអាចប្រើជាប៊ូតុងគោលបំណងទូទៅ - ដូច្នេះយើងនឹងបង្ហាញវានៅលើបន្ទះខាងមុខ។ ដើម្បីធ្វើដូចនេះខ្ញុំបានគូរ "អណ្តូង" ពិសេសមួយដែលប៊ូតុងរស់នៅ។

នៅខាងក្នុងស្រោមក៏មានទ្រនាប់ផងដែរ ដែលបន្ទះត្រូវបានដំឡើង និងធានាដោយវីស M3 តែមួយ (មិនមានកន្លែងទំនេរនៅលើក្តារទៀតទេ)

ខ្ញុំបានជ្រើសរើសការបង្ហាញរួចហើយ នៅពេលខ្ញុំបោះពុម្ពកំណែគំរូដំបូងនៃករណី។ ឧបករណ៍អានពីរជួរស្តង់ដារមិនសមនឹងករណីនេះទេប៉ុន្តែនៅខាងក្រោមមានអេក្រង់ OLED SSD1306 128 × 32 ។ វា​តូច​បន្តិច ប៉ុន្តែ​ខ្ញុំ​មិន​ចាំ​បាច់​មើល​វា​រាល់​ថ្ងៃ​ទេ—វា​ច្រើន​ពេក​សម្រាប់​ខ្ញុំ។

ដោយដឹងពីវិធីនេះ និងថាតើខ្សែភ្លើងនឹងត្រូវបញ្ជូនចេញពីវាដោយរបៀបណា ខ្ញុំបានសម្រេចចិត្តបិទអេក្រង់នៅចំកណ្តាលករណី។ ជាការពិតណាស់ ergonomics គឺទាបជាងតម្លៃ - ប៊ូតុងគឺនៅលើកំពូលការបង្ហាញគឺនៅខាងក្រោម។ ប៉ុន្តែខ្ញុំបាននិយាយរួចហើយថាគំនិតដើម្បីភ្ជាប់អេក្រង់បានមកយឺតពេក ហើយខ្ញុំខ្ជិលក្នុងការភ្ជាប់បន្ទះឡើងវិញដើម្បីផ្លាស់ទីប៊ូតុង។

ឧបករណ៍ត្រូវបានប្រមូលផ្តុំ។ ម៉ូឌុលបង្ហាញត្រូវបានស្អិតជាប់ជាមួយ snot ជាមួយកាវក្តៅ

លទ្ធផលចុងក្រោយអាចមើលឃើញនៅលើ KDPV

កម្មវិធីបង្កប់។

ចូរបន្តទៅផ្នែកកម្មវិធី។ សម្រាប់សិប្បកម្មតូចៗបែបនេះ ខ្ញុំពិតជាចូលចិត្តប្រើ Python (មីក្រូភីថុន) - កូដប្រែជាបង្រួម និងអាចយល់បាន។ ជាសំណាងល្អ មិនចាំបាច់ចុះដល់កម្រិតចុះឈ្មោះ ដើម្បីច្របាច់ចេញមីក្រូវិនាទីនោះទេ - អ្វីគ្រប់យ៉ាងអាចធ្វើបានពី Python ។

វាហាក់ដូចជាអ្វីៗទាំងអស់គឺសាមញ្ញ ប៉ុន្តែមិនសាមញ្ញទេ - ឧបករណ៍មានមុខងារឯករាជ្យជាច្រើន៖

• អ្នក​ប្រើ​ចុច​ប៊ូតុង ហើយ​មើល​អេក្រង់
• លីត្រ គូស និងធ្វើបច្ចុប្បន្នភាពតម្លៃនៅក្នុងអង្គចងចាំពន្លឺ
• ម៉ូឌុលត្រួតពិនិត្យសញ្ញា WiFi ហើយភ្ជាប់ឡើងវិញប្រសិនបើចាំបាច់
• ជាការប្រសើរណាស់ បើគ្មានអំពូលភ្លឹបភ្លែតៗ វាមិនអាចទៅរួចទេ

អ្នកមិនអាចសន្មត់ថាមុខងារមួយមិនដំណើរការទេ ប្រសិនបើមុខងារមួយទៀតជាប់គាំងដោយសារហេតុផលមួយចំនួន។ ខ្ញុំបានបំពេញ cacti របស់ខ្ញុំរួចហើយនៅក្នុងគម្រោងផ្សេងទៀត ហើយឥឡូវនេះខ្ញុំនៅតែឃើញភាពមិនប្រក្រតីនៅក្នុងរចនាប័ទ្មនៃ "ខកខានមួយលីត្រទៀតព្រោះអេក្រង់កំពុងធ្វើបច្ចុប្បន្នភាពនៅពេលនោះ" ឬ "អ្នកប្រើប្រាស់មិនអាចធ្វើអ្វីបានខណៈពេលដែលម៉ូឌុលកំពុងភ្ជាប់ទៅ ប្រព័ន្ធ Wifi។" ជាការពិតណាស់ រឿងមួយចំនួនអាចត្រូវបានធ្វើតាមរយៈការរំខាន ប៉ុន្តែអ្នកអាចឈានដល់ដែនកំណត់លើរយៈពេល ការដាក់ការហៅទូរសព្ទ ឬការផ្លាស់ប្តូរដែលមិនមែនជាអាតូមិកចំពោះអថេរ។ ជាការប្រសើរណាស់, កូដដែលធ្វើអ្វីគ្រប់យ៉ាងយ៉ាងឆាប់រហ័សប្រែទៅជា mush ។

В គម្រោងធ្ងន់ធ្ងរជាងនេះ។ ខ្ញុំ​បាន​ប្រើ​ការ​ធ្វើ​កិច្ចការ​ច្រើន​ជាមុន​បែប​បុរាណ និង FreeRTOS ប៉ុន្តែ​នៅ​ក្នុង​ករណី​នេះ គំរូ​បាន​ក្លាយ​ទៅ​ជា​សមរម្យ​ជាង បណ្ណាល័យ coroutines និង uasync . លើសពីនេះទៅទៀត ការអនុវត្ត 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 ។ ជាដំបូង តម្លៃរាប់ដំបូងត្រូវបានដកចេញពី EEPROM (value_storage) - នេះជារបៀបដែលការស្ដារឡើងវិញបន្ទាប់ពីការដាច់ចរន្តអគ្គិសនីត្រូវបានអនុវត្ត។

ម្ជុលត្រូវបានចាប់ផ្តើមដោយភ្ជាប់មកជាមួយការទាញឡើងទៅកាន់ការផ្គត់ផ្គង់ថាមពល៖ ប្រសិនបើកុងតាក់ Reed ត្រូវបានបិទ នោះខ្សែគឺសូន្យ ប្រសិនបើខ្សែរបើក វាត្រូវបានទាញឡើងទៅការផ្គត់ផ្គង់ថាមពល ហើយឧបករណ៍បញ្ជាអានមួយ។

កិច្ចការដាច់ដោយឡែកមួយក៏ត្រូវបានដាក់ឱ្យដំណើរការនៅទីនេះផងដែរ ដែលនឹងធ្វើការស្ទង់មតិម្ជុល។ បញ្ជរនីមួយៗនឹងដំណើរការភារកិច្ចរបស់ខ្លួន។ នេះគឺជាលេខកូដរបស់នាង

    """ 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 គឺត្រូវការជាចាំបាច់ ដើម្បីត្រងការលោតទំនាក់ទំនង ហើយក្នុងពេលតែមួយវាគ្រប់គ្រងថាតើភារកិច្ចភ្ញាក់ពីដំណេកញឹកញាប់ប៉ុណ្ណា (ខណៈពេលដែលកិច្ចការនេះកំពុងដេក កិច្ចការផ្សេងទៀតកំពុងដំណើរការ)។ រាល់ 25ms មុខងារភ្ញាក់ឡើង ពិនិត្យម្ជុល ហើយប្រសិនបើទំនាក់ទំនងកុងតាក់ Reed ត្រូវបានបិទ នោះលីត្រមួយទៀតបានឆ្លងកាត់ម៉ែត្រ ហើយនេះត្រូវតែដំណើរការ។

    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 ខ្ញុំដោយនិយាយថាអ្នកផ្ទាល់និយាយអំពីការរំខាន ប៉ុន្តែតាមពិតអ្នកបានធ្វើការបោះឆ្នោតម្ជុលដ៏ឆោតល្ងង់។ តាមពិតការរំខានគឺជារឿងដំបូងដែលខ្ញុំបានព្យាយាម។ នៅក្នុង ESP8266 អ្នកអាចរៀបចំ edge interrupt ហើយថែមទាំងសរសេរ handler សម្រាប់ការរំខាននេះនៅក្នុង Python។ នៅក្នុងការរំខាននេះ តម្លៃនៃអថេរអាចត្រូវបានធ្វើបច្ចុប្បន្នភាព។ ប្រហែលជា នេះនឹងគ្រប់គ្រាន់ប្រសិនបើបញ្ជរគឺជាឧបករណ៍ទាសករ - មួយដែលរង់ចាំរហូតដល់វាត្រូវបានស្នើសុំតម្លៃនេះ។

ជាអកុសល (ឬជាសំណាងល្អ?) ឧបករណ៍របស់ខ្ញុំសកម្ម វាត្រូវតែផ្ញើសារដោយខ្លួនឯងតាមរយៈពិធីការ MQTT ហើយសរសេរទិន្នន័យទៅ EEPROM ។ ហើយនៅទីនេះការរឹតបន្តឹងបានចូលជាធរមាន - អ្នកមិនអាចបែងចែកអង្គចងចាំក្នុងការរំខាន និងប្រើជង់ធំ ដែលមានន័យថាអ្នកអាចភ្លេចអំពីការផ្ញើសារតាមបណ្តាញ។ មាន buns ដូចជា micropython.schedule() ដែលអនុញ្ញាតឱ្យអ្នកដំណើរការមុខងារមួយចំនួន "ឱ្យបានឆាប់តាមដែលអាចធ្វើទៅបាន" ប៉ុន្តែសំណួរកើតឡើង "តើអ្វីទៅជាចំណុច?" ចុះ​បើ​យើង​កំពុង​ផ្ញើ​សារ​មួយ​ចំនួន​នៅ​ពេល​នេះ ហើយ​បន្ទាប់​មក​មាន​ការ​រំខាន​មួយ​ចូល​មក​ហើយ​បំផ្លាញ​តម្លៃ​នៃ​អថេរ។ ឬឧទាហរណ៍ តម្លៃបញ្ជរថ្មីបានមកដល់ពីម៉ាស៊ីនមេ ខណៈពេលដែលយើងមិនទាន់បានកត់ត្រាតម្លៃចាស់។ ជាទូទៅ អ្នកត្រូវរារាំងការធ្វើសមកាលកម្ម ឬចេញពីវាដោយវិធីផ្សេងគ្នា។

ហើយពីពេលមួយទៅពេលមួយ RuntimeError: កាលវិភាគជង់គាំងពេញលេញ ហើយអ្នកណាដឹងមូលហេតុ?

ជាមួយនឹងការស្ទង់មតិច្បាស់លាស់ និងដែលync ក្នុងករណីនេះវាប្រែចេញកាន់តែស្រស់ស្អាត និងគួរឱ្យទុកចិត្ត

ខ្ញុំបាននាំយកការងារជាមួយ 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 វាពិបាកក្នុងការធ្វើការដោយផ្ទាល់ជាមួយបៃ ប៉ុន្តែវាគឺជាបៃដែលត្រូវបានសរសេរទៅអង្គចងចាំ។ ខ្ញុំត្រូវបិទបាំងការបំប្លែងរវាងចំនួនគត់ និងបៃដោយប្រើបណ្ណាល័យ 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 ។ ជាការប្រសើរណាស់, មិនចាំបាច់អនុវត្តពិធីការដោយខ្លួនឯងទេ - ខ្ញុំបានរកឃើញវានៅលើអ៊ីនធឺណិត ការអនុវត្តអសមកាលដែលត្រៀមរួចជាស្រេច. នេះជាអ្វីដែលយើងនឹងប្រើ។

អ្វីដែលគួរឱ្យចាប់អារម្មណ៍បំផុតទាំងអស់ត្រូវបានប្រមូលនៅក្នុងថ្នាក់ CounterMQTTClient ដែលផ្អែកលើបណ្ណាល័យ MQTTClient ។ ចូរចាប់ផ្តើមពីបរិវេណ

#####################################
# 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))

នៅទីនេះអ្នកអាចបង្កើត និងកំណត់រចនាសម្ព័ន្ធម្ជុល និងប៊ូតុងអំពូល ព្រមទាំងវត្ថុម៉ែត្រទឹកត្រជាក់ និងក្តៅ។

ជា​មួយ​នឹង​ការ​ចាប់​ផ្តើ​ម​, មិន​មែន​អ្វី​គ្រប់​យ៉ាង​គឺ​ជា​រឿង​តូច​ដូច្នេះ​

    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 ជាច្រើន ដើម្បីបម្រើមុខងារផ្សេងៗនៃប្រព័ន្ធ។ ជាឧទាហរណ៍ ខាងក្រោមនេះជាទម្លាប់ដែលរាប់បញ្ចូលសេវាកម្ម

    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 រង់ចាំនៅក្នុងរង្វិលជុំសម្រាប់តម្លៃរាប់ថ្មី ហើយភ្លាមៗនៅពេលដែលវាលេចឡើង ផ្ញើសារតាមរយៈពិធីការ MQTT ។ បំណែកដំបូងនៃលេខកូដផ្ញើតម្លៃដំបូងទោះបីជាគ្មានទឹកហូរតាមបញ្ជរក៏ដោយ។

ថ្នាក់មូលដ្ឋាន MQTTClient បម្រើដោយខ្លួនវា ផ្តួចផ្តើមការតភ្ជាប់វ៉ាយហ្វាយ និងភ្ជាប់ឡើងវិញនៅពេលដែលការតភ្ជាប់ត្រូវបានបាត់បង់។ នៅពេលដែលមានការផ្លាស់ប្តូរនៅក្នុងស្ថានភាពនៃការតភ្ជាប់វ៉ាយហ្វាយ បណ្ណាល័យជូនដំណឹងយើងដោយការហៅទូរស័ព្ទទៅ 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")

មុខងារនេះផ្ញើសារប្រសិនបើការតភ្ជាប់ត្រូវបានបង្កើតឡើង។ ប្រសិនបើមិនមានការតភ្ជាប់ទេ សារមិនត្រូវបានអើពើ។

ហើយនេះគ្រាន់តែជាមុខងារងាយស្រួលដែលបង្កើត និងផ្ញើសារបំបាត់កំហុសប៉ុណ្ណោះ។

    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 គឺគ្រាន់តែជាការលួងលោមប៉ុណ្ណោះ។ យើង​ក៏​មាន​គោល​បំណង​លើ​ការ​បង្ហាញ​ដែរ។

    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 ។ មុខងារតិចតួចនេះពិពណ៌នាអំពីបទពិសោធន៍អ្នកប្រើប្រាស់ ENTIRE ។ Coroutine គ្រាន់តែរង់ចាំឱ្យប៊ូតុងត្រូវបានចុចហើយបើកការបង្ហាញរយៈពេល 3 វិនាទី។ ការបង្ហាញបង្ហាញពីការអានម៉ែត្របច្ចុប្បន្ន។

នៅ​មាន​រឿង​តូច​ៗ​មួយ​ចំនួន​ទៀត​នៅ​សល់។ នេះគឺជាមុខងារដែល (ឡើងវិញ) ចាប់ផ្តើមសហគ្រាសទាំងមូលនេះ។ រង្វិលជុំចម្បងគ្រាន់តែផ្ញើព័ត៌មានបំបាត់កំហុសផ្សេងៗម្តងក្នុងមួយនាទី។ ជាទូទៅខ្ញុំដកស្រង់វាដូចដែលវាគឺជា - ខ្ញុំគិតថាមិនចាំបាច់ធ្វើអត្ថាធិប្បាយច្រើនពេកទេ។

   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 - វាអនុញ្ញាតឱ្យអ្នកផ្ទុកពួកវាទៅខាងក្នុង (មួយនៅក្នុង ESP-07 ខ្លួនវា) flash drive ហើយបន្ទាប់មកចូលប្រើវាពីកម្មវិធីជាឯកសារធម្មតា។ នៅទីនោះខ្ញុំក៏បានបង្ហោះ mqtt_as, uasyncio, ssd1306 និងបណ្ណាល័យប្រមូលដែលខ្ញុំបានប្រើ (ប្រើនៅខាងក្នុង mqtt_as)។

យើងបើកដំណើរការ ហើយ... យើងទទួលបាន MemoryError។ ជាងនេះទៅទៀត ពេលដែលខ្ញុំព្យាយាមយល់កាន់តែច្បាស់ពីកន្លែងដែលអង្គចងចាំបានលេចធ្លាយ ការបោះពុម្ពបំបាត់កំហុសកាន់តែច្រើន ដែលខ្ញុំបានដាក់ កំហុសនេះបានលេចឡើងមុននេះ។ ការស្វែងរកតាម Google ខ្លីៗនាំឱ្យខ្ញុំយល់ថា ជាគោលការណ៍ microcontroller មានអង្គចងចាំត្រឹមតែ 30 kB ដែលក្នុងនោះ 65 kB នៃកូដ (រួមទាំងបណ្ណាល័យ) មិនអាចសមបាន។

ប៉ុន្តែមានផ្លូវចេញ។ វាបង្ហាញថា micropython មិនប្រតិបត្តិកូដដោយផ្ទាល់ពីឯកសារ .py ទេ - ឯកសារនេះត្រូវបានចងក្រងជាមុនសិន។ លើសពីនេះទៅទៀតវាត្រូវបានចងក្រងដោយផ្ទាល់នៅលើ microcontroller ប្រែទៅជា bytecode ដែលបន្ទាប់មកត្រូវបានរក្សាទុកក្នុងអង្គចងចាំ។ ជាការប្រសើរណាស់ ដើម្បីឱ្យកម្មវិធីចងក្រងដំណើរការ អ្នកក៏ត្រូវការ RAM ចំនួនជាក់លាក់ផងដែរ។

ល្បិចគឺដើម្បីរក្សាទុក microcontroller ពីការចងក្រងដែលពឹងផ្អែកលើធនធាន។ អ្នកអាចចងក្រងឯកសារនៅលើកុំព្យូទ័រធំមួយ ហើយផ្ទុកឡើងនូវ bytecode ដែលត្រៀមរួចជាស្រេចទៅក្នុង microcontroller ។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវទាញយកកម្មវិធីបង្កប់ micropython និងបង្កើត mpy-cross utility.

ខ្ញុំមិនបានសរសេរ Makefile ទេ ប៉ុន្តែបានឆ្លងកាត់ និងចងក្រងឯកសារចាំបាច់ទាំងអស់ (រួមទាំងបណ្ណាល័យ) ដោយដៃ។

mpy-cross water_counter.py

អ្វីដែលនៅសេសសល់គឺការបង្ហោះឯកសារដែលមានផ្នែកបន្ថែម .mpy ដោយមិនភ្លេចលុប .py ដែលត្រូវគ្នាជាមុនពីប្រព័ន្ធឯកសាររបស់ឧបករណ៍។

ខ្ញុំបានធ្វើការអភិវឌ្ឍន៍ទាំងអស់នៅក្នុងកម្មវិធី (IDE?) ESPlorer ។ វាអនុញ្ញាតឱ្យអ្នកបញ្ចូលស្គ្រីបទៅ microcontroller ហើយប្រតិបត្តិពួកវាភ្លាមៗ។ ក្នុងករណីរបស់ខ្ញុំ តក្កវិជ្ជា និងការបង្កើតវត្ថុទាំងអស់មានទីតាំងនៅក្នុងឯកសារ water_counter.py (.mpy)។ ប៉ុន្តែដើម្បីឱ្យអ្វីៗទាំងអស់នេះចាប់ផ្តើមដោយស្វ័យប្រវត្តិ វាត្រូវតែមានឯកសារមួយឈ្មោះថា main.py នៅពេលចាប់ផ្តើម។ លើស​ពី​នេះ​ទៅ​ទៀត វា​គួរ​តែ​ជា .py ហើយ​មិន​បាន​ចងក្រង​ជា​មុន .mpy ។ នេះ​ជា​ខ្លឹមសារ​មិន​សូវ​សំខាន់​របស់​វា។

import water_counter

យើងបើកដំណើរការវា - អ្វីៗដំណើរការ។ ប៉ុន្តែអង្គចងចាំឥតគិតថ្លៃគឺតូចគួរឱ្យព្រួយបារម្ភ - ប្រហែល 1kb ។ ខ្ញុំនៅតែមានគម្រោងពង្រីកមុខងាររបស់ឧបករណ៍ ហើយគីឡូបៃនេះច្បាស់ជាមិនគ្រប់គ្រាន់សម្រាប់ខ្ញុំទេ។ ប៉ុន្តែវាបានប្រែក្លាយថាមានផ្លូវចេញសម្រាប់ករណីនេះផងដែរ។

នេះជារឿង។ ទោះបីជាឯកសារត្រូវបានចងក្រងជា bytecode ហើយរស់នៅលើប្រព័ន្ធឯកសារខាងក្នុងក៏ដោយ តាមពិតពួកវានៅតែត្រូវបានផ្ទុកទៅក្នុង RAM និងប្រតិបត្តិពីទីនោះ។ ប៉ុន្តែវាប្រែថា micropython អាចប្រតិបត្តិ bytecode ដោយផ្ទាល់ពី flash memory ប៉ុន្តែសម្រាប់វាអ្នកត្រូវបង្កើតវាដោយផ្ទាល់ទៅក្នុងកម្មវិធីបង្កប់។ វាមិនពិបាកទេ ទោះបីជាវាចំណាយពេលខ្លះនៅលើ netbook របស់ខ្ញុំ (មានតែនៅទីនោះដែលខ្ញុំធ្លាប់មានលីនុច)។

ក្បួនដោះស្រាយមានដូចខាងក្រោម៖

• ទាញយកនិងដំឡើង ESP បើក SDK. រឿងនេះប្រមូលផ្តុំអ្នកចងក្រង និងបណ្ណាល័យសម្រាប់កម្មវិធីសម្រាប់ ESP8266។ ប្រមូលផ្តុំដោយយោងតាមការណែនាំនៅលើទំព័រមេនៃគម្រោង (ខ្ញុំបានជ្រើសរើសការកំណត់ STANDALONE=yes)
• ទាញយក ប្រភេទ micropython
• ដាក់បណ្ណាល័យដែលត្រូវការនៅក្នុង ports/esp8266/modules នៅខាងក្នុង micropython tree
• យើងប្រមូលផ្តុំកម្មវិធីបង្កប់តាមការណែនាំនៅក្នុងឯកសារ ports/esp8266/README.md
• យើងផ្ទុកកម្មវិធីបង្កប់ទៅ microcontroller (ខ្ញុំធ្វើវានៅលើ Windows ដោយប្រើកម្មវិធី ESP8266Flasher ឬ Python esptool)

នោះហើយជាវា ឥឡូវនេះ 'នាំចូល ssd1306' នឹងលើកកូដដោយផ្ទាល់ពីកម្មវិធីបង្កប់ ហើយ RAM នឹងមិនប្រើប្រាស់សម្រាប់រឿងនេះទេ។ ជាមួយនឹងល្បិចនេះ ខ្ញុំបានបង្ហោះតែកូដបណ្ណាល័យទៅក្នុងកម្មវិធីបង្កប់ ខណៈពេលដែលកូដកម្មវិធីសំខាន់ត្រូវបានប្រតិបត្តិចេញពីប្រព័ន្ធឯកសារ។ នេះអនុញ្ញាតឱ្យអ្នកកែប្រែកម្មវិធីបានយ៉ាងងាយស្រួលដោយមិនចាំបាច់ចងក្រងកម្មវិធីបង្កប់ឡើងវិញ។ នៅពេលនេះខ្ញុំមាន RAM ឥតគិតថ្លៃប្រហែល 8.5kb ។ វានឹងអនុញ្ញាតឱ្យយើងអនុវត្តមុខងារមានប្រយោជន៍ផ្សេងៗគ្នាជាច្រើននាពេលអនាគត។ ជាការប្រសើរណាស់, ប្រសិនបើមិនមានអង្គចងចាំគ្រប់គ្រាន់ទេនោះអ្នកអាចរុញកម្មវិធីសំខាន់ទៅក្នុងកម្មវិធីបង្កប់។

ដូច្នេះតើយើងគួរធ្វើអ្វីឥឡូវនេះ?

ជាការប្រសើរណាស់, គ្រឿងត្រូវបាន soldered, កម្មវិធីបង្កប់ត្រូវបានសរសេរ, ប្រអប់ត្រូវបានបោះពុម្ព, ឧបករណ៍ត្រូវបានជាប់គាំងនៅលើជញ្ជាំងនិងដោយរីករាយមួយភ្លឹបភ្លែត។ ប៉ុន្តែសម្រាប់ពេលនេះ វាជាប្រអប់ខ្មៅទាំងអស់ (តាមន័យត្រង់ និងន័យធៀប) ហើយវានៅតែប្រើប្រាស់តិចតួច។ វាដល់ពេលហើយដើម្បីធ្វើអ្វីមួយជាមួយនឹងសារ MQTT ដែលត្រូវបានផ្ញើទៅកាន់ម៉ាស៊ីនមេ។

"ផ្ទះឆ្លាត" របស់ខ្ញុំកំពុងដំណើរការ ប្រព័ន្ធ Majordomo. ម៉ូឌុល MQTT ចេញមកក្រៅប្រអប់ ឬត្រូវបានដំឡើងយ៉ាងងាយស្រួលពីទីផ្សារកម្មវិធីបន្ថែម - ខ្ញុំមិនចាំថាខ្ញុំយកវាមកពីណាទេ។ MQTT មិនមែនជារបស់ដែលគ្រប់គ្រាន់ដោយខ្លួនឯងទេ - អ្នកត្រូវការអ្វីដែលគេហៅថា។ ឈ្មួញកណ្តាល - ម៉ាស៊ីនមេដែលទទួល តម្រៀប និងបញ្ជូនសារ MQTT ទៅកាន់អតិថិជន។ ខ្ញុំប្រើមូស ដែល (ដូចជា majordomo) ដំណើរការលើ netbook ដូចគ្នា។

បន្ទាប់ពីឧបករណ៍ផ្ញើសារយ៉ាងហោចណាស់ម្តង តម្លៃនឹងបង្ហាញភ្លាមៗនៅក្នុងបញ្ជី។

ឥឡូវនេះតម្លៃទាំងនេះអាចត្រូវបានផ្សារភ្ជាប់ជាមួយនឹងវត្ថុប្រព័ន្ធ ពួកវាអាចត្រូវបានប្រើនៅក្នុងស្គ្រីបស្វ័យប្រវត្តិកម្ម និងទទួលរងនូវការវិភាគផ្សេងៗ - ទាំងអស់នេះហួសពីវិសាលភាពនៃអត្ថបទនេះ។ ខ្ញុំអាចណែនាំប្រព័ន្ធ majordomo ដល់អ្នកដែលចាប់អារម្មណ៍ channel Electronics In Lens - មិត្តម្នាក់ក៏កំពុងសាងសង់ផ្ទះឆ្លាតវៃ ហើយនិយាយយ៉ាងច្បាស់អំពីការដំឡើងប្រព័ន្ធ។

ខ្ញុំនឹងបង្ហាញអ្នកនូវក្រាហ្វពីរបី។ នេះគឺជាក្រាហ្វដ៏សាមញ្ញនៃតម្លៃប្រចាំថ្ងៃ

វាអាចត្រូវបានគេមើលឃើញថាស្ទើរតែគ្មាននរណាម្នាក់បានប្រើទឹកនៅពេលយប់។ ពីរបីដងមាននរណាម្នាក់ទៅបង្គន់ ហើយវាហាក់ដូចជាថាតម្រង osmosis បញ្ច្រាសបូមបានពីរបីលីត្រក្នុងមួយយប់។ នៅពេលព្រឹកការប្រើប្រាស់កើនឡើងយ៉ាងខ្លាំង។ ជាធម្មតាខ្ញុំប្រើទឹកពីឡចំហាយ ប៉ុន្តែបន្ទាប់មកខ្ញុំចង់ងូតទឹក ហើយប្តូរទៅទឹកក្តៅក្នុងទីក្រុងជាបណ្តោះអាសន្ន - នេះក៏អាចមើលឃើញយ៉ាងច្បាស់នៅក្នុងក្រាហ្វខាងក្រោមផងដែរ។

ពីក្រាហ្វនេះខ្ញុំបានដឹងថាការទៅបង្គន់ត្រូវការទឹក 6-7 លីត្រការងូតទឹកត្រូវការ 20-30 លីត្រការលាងចានត្រូវការប្រហែល 20 លីត្រហើយការងូតទឹកត្រូវការ 160 លីត្រ។ គ្រួសាររបស់ខ្ញុំប្រើប្រាស់កន្លែងណាមួយប្រហែល 500-600 លីត្រក្នុងមួយថ្ងៃ។

សម្រាប់អ្នកដែលចង់ដឹងចង់ឃើញជាពិសេសអ្នកអាចមើលកំណត់ត្រាសម្រាប់តម្លៃបុគ្គលនីមួយៗ

ពីទីនេះខ្ញុំបានដឹងថានៅពេលដែលម៉ាស៊ីនបើក ទឹកហូរក្នុងល្បឿនប្រហែល 1 លីត្រក្នុង 5 វិនាទី។

ប៉ុន្តែនៅក្នុងទម្រង់នេះ ស្ថិតិប្រហែលជាមិនងាយស្រួលមើលទេ។ Majordomo ក៏មានលទ្ធភាពមើលតារាងការប្រើប្រាស់តាមថ្ងៃ សប្តាហ៍ និងខែផងដែរ។ ជាឧទាហរណ៍ នៅទីនេះគឺជាក្រាហ្វការប្រើប្រាស់នៅក្នុងរបារ

មក​ទល់​ពេល​នេះ ខ្ញុំ​មាន​ទិន្នន័យ​តែ​មួយ​សប្ដាហ៍​ប៉ុណ្ណោះ។ ក្នុង​មួយ​ខែ ក្រាហ្វ​នេះ​នឹង​មាន​ការ​បង្ហាញ​កាន់​តែ​ច្រើន - រាល់​ថ្ងៃ​នឹង​មាន​ជួរ​ឈរ​ដាច់​ដោយ​ឡែក។ រូបភាពនេះត្រូវបានបង្ខូចបន្តិចដោយការលៃតម្រូវទៅនឹងតម្លៃដែលខ្ញុំបញ្ចូលដោយដៃ (ជួរឈរធំបំផុត) ។ ហើយវាមិនទាន់ច្បាស់នៅឡើយទេថាតើខ្ញុំបានកំណត់តម្លៃដំបូងមិនត្រឹមត្រូវ ស្ទើរតែមួយគូបតិច ឬថាតើនេះជាកំហុសនៅក្នុងកម្មវិធីបង្កប់ ហើយមិនមែនគ្រប់លីត្រត្រូវបានរាប់នោះទេ។ ត្រូវការពេលវេលាបន្ថែម។

ក្រាហ្វខ្លួនឯងនៅតែត្រូវការវេទមន្តខ្លះ ការលាងជម្រះការលាបពណ៌។ ប្រហែលជាខ្ញុំក៏នឹងបង្កើតក្រាហ្វនៃការប្រើប្រាស់អង្គចងចាំសម្រាប់គោលបំណងបំបាត់កំហុសផងដែរ - ក្នុងករណីមានអ្វីមួយលេចធ្លាយនៅទីនោះ។ ប្រហែលជាខ្ញុំនឹងបង្ហាញរយៈពេលដែលមិនមានអ៊ីនធឺណិត។ សម្រាប់ពេលនេះ ទាំងអស់នេះគឺនៅកម្រិតនៃគំនិត។

សេចក្តីសន្និដ្ឋាន

សព្វ​ថ្ងៃ​នេះ ផ្ទះ​ល្វែង​របស់​ខ្ញុំ​បាន​ក្លាយ​ជា​មនុស្ស​ឆ្លាត​ជាង​មុន​បន្តិច។ ជាមួយនឹងឧបករណ៍តូចបែបនេះ វានឹងកាន់តែងាយស្រួលសម្រាប់ខ្ញុំក្នុងការត្រួតពិនិត្យការប្រើប្រាស់ទឹកនៅក្នុងផ្ទះ។ ប្រសិនបើមុននេះខ្ញុំខឹងនឹង "ម្តងទៀត យើងប្រើប្រាស់ទឹកច្រើនក្នុងមួយខែ" ឥឡូវនេះខ្ញុំអាចរកឃើញប្រភពនៃការប្រើប្រាស់នេះ។

អ្នក​ខ្លះ​អាច​នឹង​ឃើញ​ថា​វា​ចម្លែក​ក្នុង​ការ​មើល​ការ​អាន​នៅ​លើ​អេក្រង់​ប្រសិន​បើ​វា​នៅ​ចម្ងាយ​មួយ​ម៉ែត្រ​ពី​ម៉ែត្រ។ ប៉ុន្តែនៅពេលអនាគតមិនឆ្ងាយប៉ុន្មានទេ ខ្ញុំមានគម្រោងផ្លាស់ទៅអាផាតមិនមួយទៀត ដែលនឹងមានអ្នកលើកទឹកជាច្រើន ហើយម៉ែត្រខ្លួនឯងទំនងជាស្ថិតនៅលើការចុះចត។ ដូច្នេះឧបករណ៍អានពីចម្ងាយនឹងមានប្រយោជន៍ខ្លាំងណាស់។

ខ្ញុំក៏មានគម្រោងពង្រីកមុខងាររបស់ឧបករណ៍ផងដែរ។ ខ្ញុំកំពុងមើលវ៉ាល់ម៉ូតូរួចហើយ។ ឥឡូវ​នេះ ដើម្បី​ប្តូរ​ឡចំហាយ​ទៅ​ទឹក​ទីក្រុង ខ្ញុំ​ត្រូវ​បើក​ម៉ាស៊ីន ៣ ក្នុង​កន្លែង​ពិបាក​ទៅ​ដល់។ វានឹងកាន់តែងាយស្រួលក្នុងការធ្វើវាដោយប្រើប៊ូតុងមួយជាមួយនឹងការចង្អុលបង្ហាញដែលត្រូវគ្នា។ ជាការពិតណាស់ វាមានតម្លៃអនុវត្តការការពារប្រឆាំងនឹងការលេចធ្លាយ។

នៅក្នុងអត្ថបទខ្ញុំបានពណ៌នាអំពីកំណែឧបករណ៍របស់ខ្ញុំដោយផ្អែកលើ ESP8266។ តាមគំនិតរបស់ខ្ញុំ ខ្ញុំបានភ្ជាប់មកជាមួយកំណែគួរឱ្យចាប់អារម្មណ៍នៃកម្មវិធីបង្កប់ micropython ដោយប្រើ coroutines - សាមញ្ញ និងស្រស់ស្អាត។ ខ្ញុំបានព្យាយាមពិពណ៌នាអំពីចំណុចខ្វះខាត និងចំណុចខ្វះខាតជាច្រើនដែលខ្ញុំបានជួបប្រទះក្នុងអំឡុងពេលយុទ្ធនាការនេះ។ ប្រហែលជាខ្ញុំបានពណ៌នាអ្វីៗគ្រប់យ៉ាងយ៉ាងលម្អិតពេកហើយ ដោយផ្ទាល់ ក្នុងនាមជាអ្នកអាន វាងាយស្រួលសម្រាប់ខ្ញុំក្នុងការរំលងអ្វីដែលមិនចាំបាច់ ជាជាងការគិតនៅពេលក្រោយនូវអ្វីដែលមិនបាននិយាយ។

ដូចរាល់ដង ខ្ញុំបើកចំហរចំពោះការរិះគន់ក្នុងន័យស្ថាបនា។

ប្រភព
សៀគ្វីនិងបន្ទះ
គំរូករណី

ប្រភព: www.habr.com