Повезивање водомера на паметну кућу

Некада су системи кућне аутоматизације или „паметна кућа“ како су их често називали били страшно скупи и само су богати могли да их приуште. Данас на тржишту можете пронаћи прилично јефтине комплете са сензорима, дугмадима/прекидачима и актуаторима за контролу осветљења, утичница, вентилације, водоснабдевања и других потрошача. А чак и најискваренији „уради сам“ може се укључити у лепоту и саставити уређаје за паметни дом по јефтиној цени.

Типично, предложени уређаји су или сензори или актуатори. Они олакшавају имплементацију сценарија попут „када се активира сензор покрета, упали светла“ или „прекидач близу излаза гаси светла у целом стану“. Али ствари некако нису ишле са телеметријом. У најбољем случају, то је графикон температуре и влажности или тренутне снаге на одређеној утичници.

Недавно сам инсталирао водомјере са импулсним излазом. За сваки литар који прође кроз мерач, прекидач се активира и затвара контакт. Једино што преостаје јесте да се ухватите за жице и покушате да извучете корист од тога. На пример, анализирајте потрошњу воде по сату и дану у недељи. Па, ако у стану постоји неколико подизача воде, онда је згодније видети све тренутне индикаторе на једном екрану него да се пењете у тешко доступне нише помоћу батеријске лампе.

Испод реза је моја верзија уређаја заснованог на ЕСП8266, који броји импулсе са водомера и шаље очитавања преко МКТТ-а на сервер паметне куће. Програмираћемо у микропитону користећи уасинцио библиотеку. Приликом креирања фирмвера, наишао сам на неколико занимљивих потешкоћа, о којима ћу такође говорити у овом чланку. Иди!

Схема

Срце читавог кола је модул на микроконтролеру ЕСП8266. Првобитно је планиран ЕСП-12, али се показало да је мој неисправан. Морали смо бити задовољни модулом ЕСП-07, који је био доступан. На срећу, исти су и по пиновима и по функционалности, једина разлика је у антени - ЕСП-12 има уграђену, док ЕСП-07 има екстерну. Међутим, чак и без ВиФи антене, сигнал у мом купатилу се нормално прима.

Стандардно ожичење модула:

• дугме за ресетовање са повлачењем и кондензатором (иако су оба већ унутар модула)
• Сигнал за омогућавање (ЦХ_ПД) се повлачи на напајање
• ГПИО15 је повучен на земљу. Ово је потребно само на почетку, али још увек немам шта да причврстим за ову ногу; више ми не треба

Да бисте модул пребацили у режим фирмвера, потребно је да кратко спојите ГПИО2 на масу, а да би било згодније, обезбедио сам дугме за покретање. У нормалном стању, овај пин се повлачи на напајање.

Стање ГПИО2 линије се проверава само на почетку рада - када се укључи напајање или одмах након ресетовања. Дакле, модул се или покреће као и обично или иде у режим фирмвера. Када се учита, овај пин се може користити као обичан ГПИО. Па, пошто тамо већ постоји дугме, можете му приложити неку корисну функцију.

За програмирање и отклањање грешака користићу УАРТ, који се излази на чешаљ. Када је потребно, једноставно прикључим УСБ-УАРТ адаптер тамо. Само треба да запамтите да се модул напаја од 3.3В. Ако заборавите да пребаците адаптер на овај напон и напајате 5В, модул ће највероватније прегорети.

Немам проблема са струјом у купатилу - утичница се налази на око метар од бројила, тако да ћу се напајати на 220В. Као извор напајања имаћу мали блок ХЛК-ПМ03 од Тенстар Робот. Ја лично тешко подносим аналогну и енергетску електронику, али ево готовог напајања у малом кућишту.

Да сигнализирам режиме рада, обезбедио сам ЛЕД повезану на ГПИО2. Међутим, нисам га одлемио, јер... ЕСП-07 модул већ има ЛЕД, а такође је повезан на ГПИО2. Али нека буде на плочи, у случају да желим да избацим ову ЛЕД диоду на кућиште.

Пређимо на најзанимљивији део. Водомери немају логику, не можете од њих тражити тренутна очитавања. Једино што нам је доступно су импулси - затварање контаката реед прекидача на сваки литар. Моји излази реед прекидача су повезани на ГПИО12/ГПИО13. Програмски ћу омогућити пулл-уп отпорник унутар модула.

У почетку сам заборавио да обезбедим отпорнике Р8 и Р9 и моја верзија плоче их нема. Али пошто већ постављам дијаграм да га сви виде, вреди исправити овај превид. Отпорници су потребни да не би спалили порт ако фирмвер поквари и постави пин на један, а реед прекидач скрати ову линију на масу (са отпорником ће тећи максимално 3.3В/1000Охм = 3.3мА).

Време је да размислимо шта да радимо ако нестане струје. Прва опција је да на почетку затражите почетне вредности бројача од сервера. Али то би захтевало значајну компликацију протокола размене. Штавише, перформансе уређаја у овом случају зависе од стања сервера. Ако се сервер није покренуо након што је напајање искључено (или покренуто касније), водомер не би могао да захтева почетне вредности и не би радио исправно.

Због тога сам одлучио да имплементирам чување вредности бројача у меморијском чипу повезаном преко И2Ц. Немам посебне захтеве за величину флеш меморије - потребно је да сачувате само 2 броја (број литара према мерилима топле и хладне воде). Чак ће и најмањи модул моћи. Али морате обратити пажњу на број циклуса снимања. За већину модула ово је 100 хиљада циклуса, за неке и до милион.

Чини се да је милион много. Али за 4 године живота у свом стану, потрошио сам нешто више од 500 кубних метара воде, то је 500 хиљада литара! И 500 хиљада записа у фласху. А то је само хладна вода. Можете, наравно, поново лемити чип сваких неколико година, али испоставило се да постоје ФРАМ чипови. Са програмске тачке гледишта, ово је исти И2Ц ЕЕПРОМ, само са веома великим бројем циклуса поновног писања (стотине милиона). Само још увек не могу да дођем до продавнице са таквим микро круговима, па ће за сада стајати уобичајени 24ЛЦ512.

Штампана плоча

У почетку сам планирао да направим плочу код куће. Стога је табла дизајнирана као једнострана. Али након сат времена са ласерским гвожђем и маском за лемљење (без тога некако није цомме ил фаут), ипак сам одлучио да наручим плоче од Кинеза.

Скоро пре него што сам наручио плочу, схватио сам да поред чипа флеш меморије могу да повежем још нешто корисно са И2Ц магистралом, као што је екран. Још увек је питање шта тачно да се објави, али то треба да се усмери на плочу. Па, пошто сам хтео да наручим плоче из фабрике, није било сврхе да се ограничавам на једнострану плочу, тако да су И2Ц линије једине на задњој страни плоче.

Постојао је и један велики проблем са једносмерним ожичењем. Јер Плоча је нацртана као једнострана, па је планирано да се на једној страни поставе стазе и СМД компоненте, а на другу излазне компоненте, конектори и напајање. Када сам добио плоче месец дана касније, заборавио сам на првобитни план и залемио све компоненте на предњој страни. И тек када је дошло до лемљења напајања, испоставило се да су плус и минус обрнути. Морао сам да се бавим фармом са скакачима. На горњој слици сам већ променио ожичење, али се земља преноси са једног дела плоче на други преко пинова дугмета Боот (иако би било могуће нацртати стазу на другом слоју).

Испало је овако

Корпус

Следећи корак је тело. Ако имате 3Д штампач, то није проблем. Нисам се превише мучио - само сам нацртао кутију праве величине и направио изрезе на правим местима. Поклопац је причвршћен за тело помоћу малих вијака за самопрезивање.

Већ сам поменуо да дугме за покретање може да се користи као дугме опште намене - тако да ћемо га приказати на предњој плочи. Да бих то урадио, нацртао сам посебан „бунар“ где дугме живи.

Унутар кућишта се налазе и клинови на које је постављена плоча и причвршћена једним М3 завртњем (није било више простора на плочи)

Одабрао сам екран већ када сам одштампао прву пробну верзију кућишта. Стандардни дворедни читач се није уклапао у ово кућиште, али на дну је био ОЛЕД екран ССД1306 128×32. Мало је мали, али не морам да буљим у њега сваки дан - превише је за мене.

Схвативши на овај начин и како ће жице бити изведене од њега, одлучио сам да залепим екран у средину кућишта. Ергономија је, наравно, испод нивоа - дугме је на врху, екран је на дну. Али већ сам рекао да је идеја за причвршћивање екрана дошла прекасно и да сам био превише лењ да поново повежем плочу да бих померио дугме.

Уређај је састављен. Модул дисплеја је залепљен на шмрк врућим лепком

Крајњи резултат се може видети на КДПВ

Фирмваре

Пређимо на софтверски део. За мале занате као што је овај, заиста волим да користим Питхон (мицропитхон) - испоставља се да је код веома компактан и разумљив. На срећу, нема потребе да се спуштате на ниво регистра да бисте истиснули микросекунде – све се може урадити из Пајтона.

Чини се да је све једноставно, али не баш једноставно - уређај има неколико независних функција:

• Корисник притисне дугме и погледа у екран
• Литри означите и ажурирајте вредности у флеш меморији
• Модул прати ВиФи сигнал и поново се повезује ако је потребно
• Па, без трепћуће сијалице је немогуће

Не можете претпоставити да једна функција није радила ако је друга из неког разлога заглављена. Већ сам се наситио кактуса у другим пројектима и сада још увек видим грешке у стилу „пропустио још један литар јер се екран у том тренутку ажурирао“ или „корисник не може ништа да уради док се модул повезује на Ви-фи." Наравно, неке ствари се могу урадити путем прекида, али можете наићи на ограничења у трајању, угнежђењу позива или неатомским променама променљивих. Па, код који све ради брзо се претвара у кашу.

В озбиљнији пројекат Користио сам класични превентивни мултитаскинг и ФрееРТОС, али у овом случају модел се показао много прикладнијим корутине и уасинц библиотеке . Штавише, Питхон имплементација корутина је једноставно невероватна - све се ради једноставно и згодно за програмера. Само напишите своју логику, само ми реците на која места можете да прелазите између токова.

Предлажем да се као изборни предмет проучавају разлике између превентивног и такмичарског мултитаскинга. Сада коначно пређимо на код.

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

Сваким бројачем рукује инстанца класе Цоунтер. Пре свега, почетна вредност бројача се одузима од ЕЕПРОМ-а (вредност_складишта) - тако се остварује опоравак након нестанка струје.

Пин се иницијализује са уграђеним повлачењем до напајања: ако је реед прекидач затворен, линија је нула, ако је линија отворена, повлачи се до извора напајања и контролер очитава један.

Овде се такође покреће посебан задатак, који ће испитати пин. Сваки бројач ће покренути свој задатак. Ево њеног кода

    """ 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 мс, а истовремено регулише колико често се задатак буди (док овај задатак спава, други задаци су покренути). Сваких 25мс функција се буди, проверава пин и ако су контакти реед прекидача затворени, онда је још један литар прошао кроз мерач и то треба обрадити.

    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

Па, хајде сада да искористимо предности Питхон-а и библиотеке уасинц и направимо цоунтер објекат на чекање (како можемо ово превести на руски? Онај који можете очекивати?)

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

        return self.value()

    __iter__ = __await__  

Ово је тако згодна функција која чека док се вредност бројача не ажурира - функција се с времена на време буди и проверава заставицу _валуе_цхангед. Добра ствар у вези са овом функцијом је то што позивни код може заспати док позива ову функцију и спавати док се не прими нова вредност.

Шта је са прекидима?Да, у овом тренутку можете да ме тролујете, рекавши да сте сами рекли о прекидима, али у стварности сте направили глупу анкету. Заправо, прекиди су прва ствар коју сам покушао. У ЕСП8266 можете организовати ивични прекид, па чак и написати руковалац за овај прекид у Питхон-у. У овом прекиду, вредност променљиве може да се ажурира. Вероватно би ово било довољно да је бројач подређени уређај - онај који чека док се од њега не затражи ова вредност.

Нажалост (или на срећу?) мој уређај је активан, мора сам да шаље поруке преко МКТТ протокола и уписује податке у ЕЕПРОМ. И ту на сцену ступају ограничења – не можете додијелити меморију у прекидима и користити велики стек, што значи да можете заборавити на слање порука преко мреже. Постоје колачи попут мицропитхон.сцхедуле() који вам омогућавају да покренете неку функцију „што је пре могуће“, али поставља се питање „у чему је поента?“ Шта ако тренутно шаљемо неку врсту поруке, а онда дође прекид и поквари вредности променљивих. Или, на пример, нова вредност бројача је стигла са сервера док стару још нисмо записали. Уопштено говорећи, морате блокирати синхронизацију или некако другачије изаћи из ње.

И с времена на време РунтимеЕррор: закажите пуне падове стека и ко зна зашто?

Уз експлицитно поллинг и уасинц, у овом случају некако испада лепше и поузданије

Донео сам рад са ЕЕПРОМ-ом у мали разред

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)

У Питхон-у је тешко радити директно са бајтовима, али бајтови се записују у меморију. Морао сам да оградим конверзију између целог броја и бајтова користећи уструцт библиотеку.

Да не бих сваки пут преносио И2Ц објекат и адресу меморијске ћелије, све сам умотао у мали и згодан класик

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)

Сам И2Ц објекат се креира са овим параметрима

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

Дошли смо до најзанимљивијег дела – имплементације комуникације са сервером преко МКТТ-а. Па, нема потребе за имплементацијом самог протокола – нашао сам га на интернету готова асинхрона имплементација. Ово је оно што ћемо користити.

Све најзанимљивије ствари сакупљене су у класи ЦоунтерМКТТЦлиент, која се заснива на библиотеци МКТТЦлиент. Кренимо од периферије

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

За подешавање радних параметара библиотеке мктт_ас користи се велики речник различитих подешавања - цонфиг. Већина подразумеваних подешавања је у реду за нас, али многа подешавања морају бити експлицитно подешена. Да не бих писао подешавања директно у коду, чувам их у текстуалној датотеци цонфиг.ткт. Ово вам омогућава да промените код без обзира на подешавања, као и да закивате неколико идентичних уређаја са различитим параметрима.

Последњи блок кода покреће неколико корутина које служе различитим функцијама система. На пример, ево корутине која сервисира бројаче

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

Корутина чека у петљи на нову вредност бројача и, чим се појави, шаље поруку преко МКТТ протокола. Први део кода шаље почетну вредност чак и ако вода не тече кроз бројач.

Основна класа МКТТЦлиент служи сама себи, покреће ВиФи везу и поново се повезује када се веза изгуби. Када дође до промена у стању ВиФи везе, библиотека нас обавештава позивом вифи_цоннецтион_хандлер

    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)

Функција је поштено копирана из примера. У овом случају, он броји број прекида (интернет_оутагес) и њихово трајање. Када се веза успостави, серверу се шаље време мировања.

Иначе, последње спавање је потребно само да би функција била асинхрона – у библиотеци се позива преко чекања, а могу се позвати само функције чије тело садржи још један аваит.

Поред повезивања на ВиФи, потребно је да успоставите и везу са МКТТ брокером (сервером). Библиотека то такође ради, а ми имамо прилику да урадимо нешто корисно када се веза успостави

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

Толико текста, а ЛЕД диода још нисмо трепнули. Ево

    # 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 секунди. Ако је потребно, овде се могу имплементирати други режими трептања.

Али ЛЕД је само мажење. Такође смо циљали на приказ.

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

Нешто ми се догодило у сећању

Дакле, сав код је ту. Уплоадовао сам датотеке користећи ампи услужни програм - он вам омогућава да их отпремите на интерни (онај у самом ЕСП-07) флеш диск и затим му приступите из програма као обичне датотеке. Тамо сам такође отпремио мктт_ас, уасинцио, ссд1306 и библиотеке колекција које сам користио (користи се унутар мктт_ас).

Покрећемо и... Добијамо МемориЕррор. Штавише, што сам више покушавао да разумем где тачно меморија цури, што сам више отисака за отклањање грешака постављао, то се ова грешка раније појављивала. Кратка претрага у Гуглу довела ме је до схватања да микроконтролер у принципу има само 30 кБ меморије, у које 65 кБ кода (укључујући библиотеке) једноставно не може да стане.

Али постоји излаз. Испоставило се да мицропитхон не извршава код директно из .пи датотеке – ова датотека се прво компајлира. Штавише, компајлира се директно на микроконтролеру, претвара се у бајткод, који се затим чува у меморији. Па, да би компајлер радио, потребна вам је и одређена количина РАМ-а.

Трик је да сачувате микроконтролер од компилације која захтева много ресурса. Можете саставити датотеке на великом рачунару и учитати готов бајт код у микроконтролер. Да бисте то урадили, потребно је да преузмете микропитхон фирмвер и направите га мпи-цросс услужни програм.

Нисам написао Макефиле, већ сам ручно прошао и компајлирао све потребне датотеке (укључујући библиотеке) нешто овако

mpy-cross water_counter.py

Остаје само да отпремите датотеке са екстензијом .мпи, не заборављајући да прво избришете одговарајући .пи из система датотека уређаја.

Урадио сам сав развој у програму (ИДЕ?) ЕСПлорер. Омогућава вам да отпремите скрипте у микроконтролер и одмах их извршите. У мом случају, сва логика и креирање свих објеката налази се у датотеци ватер_цоунтер.пи (.мпи). Али да би се све ово покренуло аутоматски, на почетку мора да постоји и датотека која се зове маин.пи. Штавише, требало би да буде тачно .пи, а не унапред компајлиран .мпи. Ево његовог тривијалног садржаја

import water_counter

Покрећемо га - све ради. Али слободна меморија је алармантно мала - око 1 кб. Још увек имам планове да проширим функционалност уређаја, а овај килобајт ми очигледно није довољан. Али показало се да и за овај случај постоји излаз.

Ево у чему је ствар. Иако су датотеке компајлиране у бајт код и налазе се у интерном систему датотека, у стварности се и даље учитавају у РАМ и одатле извршавају. Али испоставило се да мицропитхон може да изврши бајткод директно из флеш меморије, али за то морате да га уградите директно у фирмвер. Није тешко, иако је на мом нетбоок-у требало доста времена (само тамо сам имао Линук).

Algoritam je sledeći:

• Преузети и инсталирати ЕСП Опен СДК. Ова ствар саставља компајлер и библиотеке за програме за ЕСП8266. Састављено према упутствима на главној страници пројекта (одабрао сам поставку СТАНДАЛОНЕ=иес)
• Довнлоад мицропитхон сортс
• Поставите потребне библиотеке у портове/есп8266/модулес унутар стабла мицропитхон-а
• Састављамо фирмвер према упутствима у датотеци портс/есп8266/РЕАДМЕ.мд
• Учитавамо фирмвер у микроконтролер (ово радим на Виндовс-у користећи ЕСП8266Фласхер програме или Питхон есптоол)

То је то, сада ће 'импорт ссд1306' подићи код директно из фирмвера и РАМ се неће трошити за ово. Овим триком сам уплоадовао само код библиотеке у фирмвер, док се главни програмски код извршава из система датотека. Ово вам омогућава да лако измените програм без поновног компајлирања фирмвера. Тренутно имам око 8.5 кб слободне РАМ меморије. Ово ће нам омогућити да имплементирамо доста различитих корисних функционалности у будућности. Па, ако уопште нема довољно меморије, онда можете угурати главни програм у фирмвер.

Па шта сад да радимо поводом тога?

Ок, хардвер је залемљен, фирмвер је написан, кутија је одштампана, уређај закачен на зид и весело трепће сијалица. Али за сада је све то црна кутија (буквално и фигуративно) и још увек је од мале користи. Време је да се нешто уради са МКТТ порукама које се шаљу на сервер.

Мој „паметни дом“ се окреће Мајордомо систем. МКТТ модул или излази из кутије, или се лако инсталира са тржишта додатака - не сећам се одакле сам га добио. МКТТ није самодовољна ствар - потребан вам је тзв. брокер - сервер који прима, сортира и прослеђује МКТТ поруке клијентима. Користим москуитто, који (као мајордомо) ради на истом нетбоок-у.

Након што уређај барем једном пошаље поруку, вредност ће се одмах појавити на листи.

Ове вредности се сада могу повезати са системским објектима, могу се користити у скриптама за аутоматизацију и подвргнути разним анализама - све то је ван оквира овог чланка. Могу препоручити мајордомо систем свима који су заинтересовани канал Елецтроницс Ин Ленс — пријатељ такође гради паметну кућу и јасно говори о постављању система.

Показаћу вам само неколико графикона. Ово је једноставан графикон дневних вредности

Види се да скоро нико није користио воду ноћу. Пар пута је неко отишао у тоалет, а чини се да филтер реверзне осмозе усисава пар литара за ноћ. Ујутру се потрошња значајно повећава. Обично користим воду из бојлера, али онда сам хтео да се окупам и привремено прешао на градску топлу воду - то је такође јасно видљиво на доњем графикону.

Из овог графикона сам сазнао да је за одлазак у тоалет потребно 6-7 литара воде, за туширање је потребно 20-30 литара, за прање судова око 20 литара, а за купање 160 литара. Моја породица троши негде око 500-600 литара дневно.

За оне који су посебно радознали, можете погледати записе за сваку појединачну вредност

Одавде сам сазнао да када је славина отворена, вода тече брзином од приближно 1 литар у 5 с.

Али у овом облику статистике вероватно нису баш згодне за гледање. Мајордомо такође има могућност да прегледа графиконе потрошње по дану, недељи и месецу. Ево, на пример, графикон потрошње у шипкама

За сада имам податке само за недељу дана. За месец дана овај графикон ће бити индикативнији - сваки дан ће имати засебну колону. Слика је мало покварена подешавањем вредности које уносим ручно (највећа колона). И још није јасно да ли сам погрешно поставио прве вредности, скоро коцку мање, или је ово грешка у фирмверу и нису пребројани сви литри. Потребно ми је још времена.

Самим графовима је још потребна магија, бељење, фарбање. Можда ћу такође направити графикон потрошње меморије за потребе отклањања грешака - у случају да тамо нешто цури. Можда ћу некако приказати периоде када није било интернета. За сада је све ово на нивоу идеја.

Закључак

Данас је мој стан постао мало паметнији. Са тако малим уређајем биће ми згодније да пратим потрошњу воде у кући. Ако сам раније био огорчен на „опет смо потрошили много воде за месец дана“, сада могу да пронађем извор ове потрошње.

Некима ће можда бити чудно гледати очитавања на екрану ако је метар удаљен од самог мерача. Али у не тако далекој будућности планирам да се преселим у други стан, где ће бити неколико водостаја, а сами бројила ће се највероватније налазити на подесту. Дакле, уређај за даљинско читање ће бити веома користан.

Такође планирам да проширим функционалност уређаја. Већ гледам моторизоване вентиле. Сада, да пребацим котао на градску воду, треба да завртим 3 славине у тешко доступној ниши. Било би много згодније то учинити једним дугметом са одговарајућом индикацијом. Па, наравно, вреди применити заштиту од цурења.

У чланку сам описао своју верзију уређаја заснованог на ЕСП8266. По мом мишљењу, дошао сам до веома интересантне верзије микропитхон фирмвера користећи корутине - једноставно и лепо. Покушао сам да опишем многе нијансе и недостатке на које сам наишао током кампање. Можда сам све исувише детаљно описао; лично, као читаоцу, лакше је да прескочим непотребне ствари него да касније размишљам шта је остало недоречено.

Као и увек, отворен сам за конструктивну критику.

Извор
Коло и плоча
Модел кућишта

Извор: ввв.хабр.цом