ჩვენ ვუერთებთ წყლის მრიცხველს ჭკვიან სახლს

ოდესღაც სახლის ავტომატიზაციის სისტემები, ან როგორც მათ ხშირად უწოდებდნენ „ჭკვიან სახლს“, საშინლად ძვირი ღირდა და მხოლოდ მდიდრებს შეეძლოთ მათი შეძენა. დღეს ბაზარზე შეგიძლიათ იპოვოთ საკმაოდ იაფი კომპლექტები სენსორებით, ღილაკებით/გადამრთველებით და ამძრავებით განათების, სოკეტების, ვენტილაციის, წყალმომარაგების და სხვა მომხმარებლების სამართავად. და ყველაზე მახინჯ წვრილმან ადამიანსაც კი შეუძლია ჩაერთოს სილამაზეში და ააწყოს მოწყობილობები ჭკვიანი სახლისთვის იაფად.

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

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

ჭრილის ქვემოთ არის ESP8266-ზე დაფუძნებული მოწყობილობის ჩემი ვერსია, რომელიც ითვლის იმპულსებს წყლის მრიცხველებიდან და აგზავნის კითხვას MQTT-ის საშუალებით ჭკვიანი სახლის სერვერზე. ჩვენ დავპროგრამებთ მიკროპითონში uasyncio ბიბლიოთეკის გამოყენებით. firmware-ის შექმნისას რამდენიმე საინტერესო სირთულეს წავაწყდი, რომლებზეც ასევე განვიხილავ ამ სტატიაში. წადი!

სქემა

მთელი მიკროსქემის გული არის მოდული ESP8266 მიკროკონტროლერზე. ESP-12 თავდაპირველად იყო დაგეგმილი, მაგრამ ჩემი დეფექტური აღმოჩნდა. ჩვენ უნდა დავკმაყოფილდეთ ESP-07 მოდულით, რომელიც ხელმისაწვდომი იყო. საბედნიეროდ, ისინი ერთნაირია როგორც ქინძისთავებით, ასევე ფუნქციონალურობით, განსხვავება მხოლოდ ანტენაშია - ESP-12-ს აქვს ჩაშენებული, ხოლო ESP-07-ს აქვს გარე. თუმცა, WiFi ანტენის გარეშეც, ჩემს აბაზანაში სიგნალი ჩვეულებრივ მიიღება.

სტანდარტული მოდულის გაყვანილობა:

• გადატვირთვის ღილაკი ამოსაყვანი და კონდენსატორით (თუმცა ორივე უკვე მოდულის შიგნითაა)
• ჩართვის სიგნალი (CH_PD) იკვებება დენი
• GPIO15 გაყვანილია მიწაზე. ეს მხოლოდ დასაწყისშია საჭირო, მაგრამ მე მაინც არაფერი მაქვს ამ ფეხზე დასამაგრებელი, აღარ მჭირდება

მოდულის პროგრამული უზრუნველყოფის რეჟიმში გადასასვლელად, საჭიროა GPIO2-ის მოკლე ჩართვა მიწაზე და უფრო მოსახერხებელი რომ იყოს, მე მივაწოდე ჩატვირთვის ღილაკი. ნორმალურ მდგომარეობაში, ეს ქინძისთავი გამოყვანილია ძალაში.

GPIO2 ხაზის მდგომარეობა მოწმდება მხოლოდ მუშაობის დასაწყისში - დენის გამოყენებისას ან გადატვირთვისთანავე. ასე რომ, მოდული ან ჩაიტვირთება ჩვეულებისამებრ, ან გადადის firmware რეჟიმში. ჩატვირთვის შემდეგ, ეს პინი შეიძლება გამოყენებულ იქნას როგორც ჩვეულებრივი GPIO. კარგი, რადგან იქ უკვე არის ღილაკი, შეგიძლიათ დაურთოთ მას რაიმე სასარგებლო ფუნქცია.

პროგრამირებისთვის და გამართვისთვის გამოვიყენებ UART-ს, რომელიც გამოდის სავარცხელზე. საჭიროების შემთხვევაში, მე უბრალოდ ვუერთებ იქ USB-UART ადაპტერს. თქვენ უბრალოდ უნდა გახსოვდეთ, რომ მოდული იკვებება 3.3 ვ. თუ დაგავიწყდათ ადაპტერის ამ ძაბვაზე გადართვა და 5 ვ მიწოდება, მოდული დიდი ალბათობით დაიწვება.

სააბაზანოში დენის პრობლემა არ მაქვს - გასასვლელი მრიცხველებიდან დაახლოებით ერთ მეტრზეა, ამიტომ ვიკვებ 220 ვოლტით. დენის წყაროდ მექნება პატარა ბლოკი HLK-PM03 ტენსტარ რობოტის მიერ. პირადად მე მიჭირს ანალოგური და დენის ელექტრონიკა, მაგრამ აქ არის მზა დენის წყარო პატარა საქმეში.

ოპერაციული რეჟიმების სიგნალიზაციისთვის, მე მივაწოდე LED, რომელიც დაკავშირებულია GPIO2-თან. თუმცა, მე არ გავხსნიდი, რადგან... ESP-07 მოდულს უკვე აქვს LED და ის ასევე დაკავშირებულია GPIO2-თან. ოღონდ დაფაზე იყოს, იმ შემთხვევაში, თუ მსურს ამ LED-ის გამოყვანა კეისზე.

გადავიდეთ ყველაზე საინტერესო ნაწილზე. წყლის მრიცხველებს არ აქვთ ლოგიკა, მათ ვერ მოსთხოვთ მიმდინარე მაჩვენებლებს. ერთადერთი, რაც ჩვენთვის ხელმისაწვდომია, არის იმპულსები - ლერწმის გადამრთველის კონტაქტების დახურვა ყოველ ლიტრზე. ჩემი რიდის გადამრთველი გამომავალი დაკავშირებულია GPIO12/GPIO13-თან. მე ჩავრთავ ამოსაწევ რეზისტორის პროგრამულად მოდულის შიგნით.

თავიდან დამავიწყდა R8 და R9 რეზისტორების მიწოდება და დაფის ჩემს ვერსიას არ აქვს ისინი. მაგრამ რადგან მე უკვე ვდებ დიაგრამას, რომ ყველამ ნახოს, ღირს ამ უგულებელყოფის გამოსწორება. რეზისტორები საჭიროა იმისათვის, რომ არ დაიწვას პორტი, თუ პროგრამული უზრუნველყოფა გაფუჭდა და დააყენებს პინს ერთზე, ხოლო ლერწმის გადამრთველი ამ ხაზს მიწასთან აშორებს (რეზისტორით მაქსიმუმ 3.3V/1000Ohm = 3.3mA შემოვა).

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

ამიტომ, მე გადავწყვიტე მრიცხველის დაზოგვის მნიშვნელობების დანერგვა მეხსიერების ჩიპში, რომელიც დაკავშირებულია I2C-ით. მე არ მაქვს რაიმე განსაკუთრებული მოთხოვნები ფლეშ მეხსიერების ზომაზე - თქვენ მხოლოდ უნდა შეინახოთ 2 ნომერი (ლიტრის რაოდენობა ცხელი და ცივი წყლის მრიცხველების მიხედვით). ყველაზე პატარა მოდულიც კი გამოდგება. მაგრამ ყურადღება უნდა მიაქციოთ ჩაწერის ციკლების რაოდენობას. მოდულების უმეტესობისთვის ეს არის 100 ათასი ციკლი, ზოგისთვის მილიონამდე.

როგორც ჩანს, მილიონი ბევრია. მაგრამ ჩემს ბინაში ცხოვრების 4 წლის განმავლობაში მე მოვიხმარე 500 კუბურ მეტრზე ცოტა მეტი წყალი, ეს არის 500 ათასი ლიტრი! და 500 ათასი ჩანაწერი ფლეშში. და ეს მხოლოდ ცივი წყალია. თქვენ, რა თქმა უნდა, შეგიძლიათ ჩიპის გადაყიდვა ყოველ რამდენიმე წელიწადში, მაგრამ აღმოჩნდა, რომ არსებობს FRAM ჩიპები. პროგრამირების თვალსაზრისით, ეს არის იგივე I2C EEPROM, მხოლოდ გადაწერის ციკლების ძალიან დიდი რაოდენობით (ასობით მილიონი). უბრალოდ, ასეთი მიკროსქემებით მაინც ვერ მოვდივარ მაღაზიაში, ასე რომ, ჯერჯერობით ჩვეულებრივი 24LC512 დადგება.

ბეჭდური მიკროსქემის დაფა

თავდაპირველად დაფის გაკეთება სახლში ვგეგმავდი. ამიტომ, დაფა შეიქმნა როგორც ცალმხრივი. მაგრამ მას შემდეგ, რაც ერთი საათი გავატარე ლაზერული რკინით და გამაჯანსაღებელი ნიღბით (ეს რატომღაც არ არის comme il faut მის გარეშე), მაინც გადავწყვიტე დაფები შემეკვეთა ჩინელებისგან.

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

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

ასე გამოვიდა

საცხოვრებელი

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

მე უკვე აღვნიშნე, რომ Boot ღილაკი შეიძლება გამოყენებულ იქნას როგორც ზოგადი დანიშნულების ღილაკი - ასე რომ, ჩვენ გამოვაჩენთ მას წინა პანელზე. ამისათვის მე დავხატე სპეციალური "ჭა", სადაც ღილაკი ცხოვრობს.

კორპუსის შიგნით არის ასევე საკინძები, რომლებზეც დაფა დამონტაჟებულია და დამაგრებულია ერთი M3 ხრახნით (დაფაზე მეტი ადგილი არ იყო)

დისპლეი შევარჩიე უკვე ქეისის პირველი ნიმუშის ვერსიის დაბეჭდვისას. სტანდარტული ორხაზიანი მკითხველი ამ შემთხვევაში არ ჯდებოდა, მაგრამ ბოლოში იყო OLED დისპლეი SSD1306 128×32. ცოტა პატარაა, მაგრამ არ მიწევს ყოველდღე მზერა - ეს ჩემთვის ზედმეტია.

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

მოწყობილობა აწყობილია. დისპლეის მოდული ცხელ წებოთი არის დამაგრებული სნოტზე

საბოლოო შედეგი შეგიძლიათ ნახოთ KDPV-ზე

ფირმა

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

როგორც ჩანს, ყველაფერი მარტივია, მაგრამ არც ისე მარტივი - მოწყობილობას აქვს რამდენიმე დამოუკიდებელი ფუნქცია:

• მომხმარებელი აჭერს ღილაკს და უყურებს ეკრანს
• ლიტრი მონიშნეთ და განაახლეთ მნიშვნელობები ფლეშ მეხსიერებაში
• მოდული აკონტროლებს WiFi სიგნალს და საჭიროების შემთხვევაში ხელახლა აკავშირებს
• ისე, მოციმციმე ნათურის გარეშე შეუძლებელია

თქვენ არ შეგიძლიათ ვივარაუდოთ, რომ ერთი ფუნქცია არ მუშაობდა, თუ მეორე რაიმე მიზეზით დაბლოკილია. მე უკვე ვივსე კაქტუსებით სხვა პროექტებში და ახლა მაინც ვხედავ ხარვეზებს სტილში: „კიდევ ერთი ლიტრი გამოვტოვე, რადგან ეკრანი იმ მომენტში ახლდებოდა“ ან „მომხმარებელი ვერაფერს აკეთებს, სანამ მოდული უერთდება. Ვაი - ფაი." რა თქმა უნდა, ზოგიერთი რამ შეიძლება გაკეთდეს შეფერხებების საშუალებით, მაგრამ შეიძლება შეგექმნათ შეზღუდვები ხანგრძლივობის, ზარების ჩადგმის ან ცვლადების არაატომური ცვლილებების შესახებ. ისე, კოდი, რომელიც ყველაფერს აკეთებს, სწრაფად იქცევა მუშად.

В უფრო სერიოზული პროექტი გამოვიყენე კლასიკური პრევენციული მულტიტასკინგი და FreeRTOS, მაგრამ ამ შემთხვევაში მოდელი ბევრად უფრო შესაფერისი აღმოჩნდა კორუტინები და uasync ბიბლიოთეკები . უფრო მეტიც, პითონის კორუტინის დანერგვა უბრალოდ გასაოცარია - ყველაფერი კეთდება მარტივად და მოხერხებულად პროგრამისტისთვის. უბრალოდ დაწერე შენი საკუთარი ლოგიკა, უბრალოდ მითხარი რომელ ადგილებში შეგიძლია გადახვიდე ნაკადებს შორის.

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

#####################################
# 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-ს (მნიშვნელობის_შენახვა) - ასე ხდება აღდგენა დენის გათიშვის შემდეგ.

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

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

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

25მმ-ის შეფერხებაა საჭირო კონტაქტის აბრუნვის გასაფილტრად და ამავდროულად ის არეგულირებს რამდენად ხშირად იღვიძებს დავალება (როდესაც ეს ამოცანა სძინავს, სხვა ამოცანები გაშვებულია). ყოველ 25ms-ში ფუნქცია იღვიძებს, ამოწმებს ქინძისთავს და თუ ლერწმის გადამრთველი კონტაქტები დახურულია, მაშინ კიდევ ერთი ლიტრი გავიდა მრიცხველში და ეს უნდა დამუშავდეს.

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

        self._value_storage.write(self._value)

შემდეგი ლიტრის დამუშავება ტრივიალურია - მრიცხველი უბრალოდ იზრდება. კარგი იქნებოდა ახალი მნიშვნელობის ფლეშ დრაივზე ჩაწერა.

მოხერხებულობისთვის მოწოდებულია „აქსესორები“.

    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 დროშას. ამ ფუნქციის მთავარი ის არის, რომ ზარის კოდი შეიძლება დაიძინოს ამ ფუნქციის გამოძახებისას და დაიძინოს ახალი მნიშვნელობის მიღებამდე.

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

სამწუხაროდ (თუ საბედნიეროდ?) ჩემი მოწყობილობა აქტიურია, მან თავად უნდა გაგზავნოს შეტყობინებები MQTT პროტოკოლით და ჩაწეროს მონაცემები EEPROM-ში. და აქ მოქმედებს შეზღუდვები - თქვენ არ შეგიძლიათ მეხსიერების გამოყოფა შეფერხებებში და გამოიყენოთ დიდი დასტა, რაც ნიშნავს, რომ შეგიძლიათ დაივიწყოთ შეტყობინებების გაგზავნა ქსელში. არსებობს buns როგორიცაა micropython.schedule(), რომელიც საშუალებას გაძლევთ გაუშვათ გარკვეული ფუნქცია "რაც შეიძლება მალე", მაგრამ ჩნდება კითხვა, "რა აზრი აქვს?" რა მოხდება, თუ ჩვენ ახლავე ვაგზავნით რაიმე სახის შეტყობინებას და შემდეგ მოდის შეფერხება და აფუჭებს ცვლადების მნიშვნელობებს. ან, მაგალითად, ახალი მრიცხველის მნიშვნელობა მოვიდა სერვერიდან, როცა ჯერ არ გვქონდა ჩაწერილი ძველი. ზოგადად, თქვენ უნდა დაბლოკოთ სინქრონიზაცია ან სხვაგვარად გამოხვიდეთ მისგან.

და დროდადრო RuntimeError: დაგეგმეთ სტეკის სრული ავარია და ვინ იცის რატომ?

აშკარა გამოკითხვით და uasync-ით, ამ შემთხვევაში რაღაცნაირად უფრო ლამაზი და სანდო გამოდის

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)

პითონში ძნელია უშუალოდ ბაიტებთან მუშაობა, მაგრამ ეს არის ბაიტი, რომელიც იწერება მეხსიერებაში. მთელ რიცხვებსა და ბაიტებს შორის კონვერტაციის შემოღობვა მომიწია 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.txt ვინახავ. ეს საშუალებას გაძლევთ შეცვალოთ კოდი პარამეტრების მიუხედავად, ასევე დააწკაპუნოთ რამდენიმე იდენტური მოწყობილობა სხვადასხვა პარამეტრით.

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

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

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

საბაზო კლასი 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)

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

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

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)

აი რაზეც ვსაუბრობდი - რა მარტივი და მოსახერხებელია ეს კორუტინებით. ეს პატარა ფუნქცია აღწერს მომხმარებლის მთელ გამოცდილებას. კორუტინი უბრალოდ ელოდება ღილაკის დაჭერას და ირთვება ეკრანი 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 თავად) ფლეშ დრაივზე და შემდეგ შეხვიდეთ მას პროგრამიდან, როგორც ჩვეულებრივი ფაილი. იქ ასევე ავტვირთე mqtt_as, uasyncio, ssd1306 და კოლექციების ბიბლიოთეკები, რომლებსაც ვიყენებდი (გამოიყენებოდა mqtt_as-ში).

ჩვენ ვაწარმოებთ მას და... ვიღებთ MemoryError-ს. უფრო მეტიც, რაც უფრო ვცდილობდი გამეგო, სად გაჟონა ზუსტად მეხსიერება, რაც უფრო მეტ გამართვის პრინტს ვათავსებდი, მით უფრო ადრე ჩნდებოდა ეს შეცდომა. Google-ის მოკლე ძიებამ მიმიყვანა იმის გაგებამდე, რომ მიკროკონტროლერს აქვს, პრინციპში, მხოლოდ 30 კბ მეხსიერება, რომელშიც 65 კბ კოდი (ბიბლიოთეკების ჩათვლით) უბრალოდ ვერ ჯდება.

მაგრამ არის გამოსავალი. გამოდის, რომ micropython არ ახორციელებს კოდს პირდაპირ .py ფაილიდან - ეს ფაილი ჯერ კომპილირებულია. უფრო მეტიც, ის შედგენილია უშუალოდ მიკროკონტროლერზე, გადაიქცევა ბაიტეკოდად, რომელიც შემდეგ ინახება მეხსიერებაში. ისე, რომ კომპილერმა იმუშაოს, თქვენ ასევე გჭირდებათ ოპერატიული მეხსიერება.

ხრიკი არის მიკროკონტროლერის გადარჩენა რესურსზე ინტენსიური კომპილაციისგან. თქვენ შეგიძლიათ შეადგინოთ ფაილები დიდ კომპიუტერზე და ატვირთოთ მზა ბაიტეკოდი მიკროკონტროლერში. ამისათვის თქვენ უნდა ჩამოტვირთოთ micropython firmware და build mpy-cross უტილიტა.

მე არ დამიწერია Makefile, მაგრამ ხელით გავიარე და შევადგინე ყველა საჭირო ფაილი (ბიბლიოთეკების ჩათვლით) მსგავსი რამ

mpy-cross water_counter.py

რჩება მხოლოდ ფაილების ატვირთვა .mpy გაფართოებით, არ დაგავიწყდეთ ჯერ შესაბამისი .py წაშალოთ მოწყობილობის ფაილური სისტემიდან.

მე გავაკეთე ყველა განვითარება პროგრამაში (IDE?) ESPlorer. ეს საშუალებას გაძლევთ ატვირთოთ სკრიპტები მიკროკონტროლერზე და დაუყოვნებლივ შეასრულოთ ისინი. ჩემს შემთხვევაში, ყველა ობიექტის მთელი ლოგიკა და შექმნა მდებარეობს water_counter.py (.mpy) ფაილში. მაგრამ იმისათვის, რომ ეს ყველაფერი ავტომატურად დაიწყოს, თავიდანვე უნდა იყოს ფაილი სახელად main.py. უფრო მეტიც, ის უნდა იყოს ზუსტად .py და არა წინასწარ შედგენილი .mpy. აქ არის მისი ტრივიალური შინაარსი

import water_counter

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

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

ალგორითმი ასეთია:

• ჩამოტვირთეთ და დააინსტალირეთ ESP გახსენით SDK. ეს ნივთი აწყობს შემდგენელს და ბიბლიოთეკებს პროგრამებისთვის ESP8266-ისთვის. აწყობილია პროექტის მთავარ გვერდზე ინსტრუქციის მიხედვით (მე ავირჩიე STANDALONE=კი პარამეტრი)
• Download მიკროპითონის ჯიშები
• მოათავსეთ საჭირო ბიბლიოთეკები პორტებში/esp8266/მოდულებში მიკროპითონის ხის შიგნით
• ჩვენ ვაწყობთ firmware-ს ფაილში მოცემული ინსტრუქციის მიხედვით ports/esp8266/README.md
• ჩვენ ვტვირთავთ პროგრამულ უზრუნველყოფას მიკროკონტროლერზე (ამას ვაკეთებ Windows-ზე ESP8266Flasher პროგრამების ან Python esptool-ის გამოყენებით)

ესე იგი, ახლა 'იმპორტი ssd1306' ამოიღებს კოდს პირდაპირ firmware-დან და RAM ამისთვის არ მოიხმარება. ამ ხრიკით მე ავტვირთე მხოლოდ ბიბლიოთეკის კოდი firmware-ში, ხოლო ძირითადი პროგრამის კოდი შესრულებულია ფაილური სისტემიდან. ეს საშუალებას გაძლევთ მარტივად შეცვალოთ პროგრამა პროგრამული უზრუნველყოფის ხელახალი კომპილაციის გარეშე. ამ დროისთვის მაქვს დაახლოებით 8.5 კბ თავისუფალი ოპერატიული მეხსიერება. ეს საშუალებას მოგვცემს მომავალში განვახორციელოთ საკმაოდ ბევრი განსხვავებული სასარგებლო ფუნქცია. კარგად, თუ საერთოდ არ არის საკმარისი მეხსიერება, მაშინ შეგიძლიათ დააყენოთ ძირითადი პროგრამა firmware-ში.

რა უნდა გავაკეთოთ ახლა ამაზე?

ოკ, აპარატურა შედუღებულია, ფირმვერი აწერია, ყუთი დაბეჭდილია, მოწყობილობა კედელზეა მიკრული და ხალისით აციმციმებს. მაგრამ ჯერ-ჯერობით ეს ყველაფერი შავი ყუთია (სიტყვასიტყვით და გადატანითი მნიშვნელობით) და ის ჯერ კიდევ მცირეა. დროა რაღაც გავაკეთოთ MQTT შეტყობინებებით, რომლებიც იგზავნება სერვერზე.

ჩემი "ჭკვიანი სახლი" ტრიალებს მაჟორდომოს სისტემა. MQTT მოდული ან გამოდის ყუთიდან, ან ადვილად ინსტალირებულია დანამატების ბაზრიდან - არ მახსოვს საიდან მივიღე. MQTT არ არის თვითკმარი რამ - საჭიროა ე.წ. ბროკერი - სერვერი, რომელიც იღებს, ახარისხებს და აგზავნის MQTT შეტყობინებებს კლიენტებზე. მე ვიყენებ mosquitto-ს, რომელიც (მაჟორდომოს მსგავსად) მუშაობს იმავე ნეტბუქზე.

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

ეს მნიშვნელობები ახლა შეიძლება დაკავშირებული იყოს სისტემის ობიექტებთან, მათი გამოყენება შესაძლებელია ავტომატიზაციის სკრიპტებში და დაექვემდებაროს სხვადასხვა ანალიზს - ეს ყველაფერი სცილდება ამ სტატიის ფარგლებს. მე შემიძლია ვურჩიო majordomo სისტემა ნებისმიერ მსურველს არხი Electronics In Lens — მეგობარი ასევე აშენებს ჭკვიან სახლს და აშკარად საუბრობს სისტემის დაყენებაზე.

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

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

ამ გრაფიკიდან გავიგე, რომ ტუალეტში წასასვლელად საჭიროა 6-7 ლიტრი წყალი, შხაპის მისაღებად 20-30 ლიტრი, ჭურჭლის რეცხვა დაახლოებით 20 ლიტრი, აბაზანის მისაღებად კი 160 ლიტრი. ჩემი ოჯახი დღეში სადღაც 500-600 ლიტრს მოიხმარს.

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

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

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

ჯერჯერობით მხოლოდ ერთი კვირის მონაცემები მაქვს. ერთ თვეში ეს გრაფიკი უფრო საჩვენებელი იქნება - თითოეულ დღეს ექნება ცალკე სვეტი. სურათი ოდნავ გაფუჭებულია იმ მნიშვნელობების კორექტირებით, რომლებსაც ხელით ვწერ (ყველაზე დიდი სვეტი). და ჯერ არ არის ნათელი, არასწორად დავაყენე პირველივე მნიშვნელობები, თითქმის კუბიკზე ნაკლები, თუ ეს არის შეცდომა firmware-ში და ყველა ლიტრი არ იყო დათვლილი. მეტი დრო სჭირდება.

თავად გრაფიკებს მაინც სჭირდება რაღაც მაგია, გათეთრება, შეღებვა. შესაძლოა, მე ასევე ავაშენებ მეხსიერების მოხმარების გრაფიკს გამართვის მიზნით - იმ შემთხვევაში, თუ იქ რაღაც გაჟონავს. ალბათ როგორმე გამოვაჩენ პერიოდებს, როცა ინტერნეტი არ იყო. ჯერჯერობით ეს ყველაფერი იდეების დონეზეა.

დასკვნა

დღეს ჩემი ბინა ცოტა უფრო ჭკვიანი გახდა. ასეთი პატარა მოწყობილობით უფრო მოსახერხებელი იქნება სახლში წყლის მოხმარების მონიტორინგი. თუ ადრე ვბრაზდებოდი „ისევ, ერთ თვეში ბევრ წყალს ვხმარობდით“, ახლა შემიძლია ამ მოხმარების წყაროს პოვნა.

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

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

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

როგორც ყოველთვის, მე ღია ვარ კონსტრუქციული კრიტიკისთვის.

კოდის კოდი
ჩართვა და დაფა
ქეისის მოდელი

წყარო: www.habr.com