Olá pessoal.
No processo de reparo, surgiu a tarefa de fazer uma troca de passagem. Obviamente, eu queria fazê-lo da maneira mais simples e conveniente, adicionando funções básicas de controle do telefone. Eu escolhi a tecnologia mais simples e conveniente para isso (é claro, na minha opinião) - MicroPython, e comecei a fazê-lo. Peguei a placa final no esp8266 e aloquei uma hora de tempo livre para isso. Mas, como acontece com projetos não muito populares e não executados, a tarefa se arrastou um pouco.
Como se viu, o design que achei mais conveniente, não funciona. Eu tive que gastar algum tempo analisando isso, além disso, decidi descrever todo o processo com detalhes suficientes. O volume do artigo começou a aumentar rapidamente, então decidi dividi-lo em partes e jogar fora todos os detalhes desnecessários na minha opinião.
A primeira parte consiste em três partes:
- Considerações teóricas sobre a seleção do meio mais simples para o desenvolvimento de uma chave de passagem,
- Lançamento prático do firmware básico selecionado no equipamento selecionado, armadilhas,
- Desenvolvimento de Firmware
Escolhendo o ambiente de desenvolvimento mais fácil
Para uma casa inteligente como “faça você mesmo se tiver um minuto de tempo livre”, além dos itens clássicos (por exemplo, estabilidade), a lista de requisitos obrigatórios de equipamentos também adiciona facilidade de desenvolvimento, instalação e suporte. Os dispositivos são necessários para conectar facilmente os sensores ou dispositivos de controle necessários a eles. Que havia maneiras fáceis e convenientes de se comunicar com todo o sistema. É necessário garantir a facilidade de escrever firmware neste dispositivo, levando em consideração que o dispositivo pode estar localizado onde será difícil acessá-lo. E, claro, a facilidade de desenvolvimento, isso é especialmente crítico para DIY, quando, por exemplo, 2 anos depois de trabalhar sem falhas de todo o sistema
de repente, quero adicionar alguns ajustes ao firmware. Para fazer essas correções, você precisa se lembrar de como esse sistema funciona, que às vezes pode levar mais tempo que o próprio ajuste.
Considere um exemplo banal: você precisa fazer uma troca simples com a capacidade de controlá-la, inclusive de um PC. Nos últimos tempos, essa tarefa era bastante complicada, era necessário usar algum tipo de microcontrolador (os mais populares eram avr ou pic) e escrever firmware, como regra, é necessário ler a documentação. Se você quiser fazer tudo imediatamente, precisará criar uma placa onde colocar AC / DC, um microcontrolador e uma interface de comunicação. Após LUT (ou pedir placas de circuito impresso), solde tudo, compre um programador e firmware flash. Depois de 2-3 anos, se necessário, para consertar alguma coisa, procure todo o equipamento e aprenda tudo do zero ...
Para simplificar esse processo, soluções prontas começaram a aparecer no mercado. A solução mais bem-sucedida é o Arduino. Esta solução é fornecida pelo IDE, o gerenciador de inicialização com a função de atualização, que permite trabalhar com o dispositivo exclusivamente através da interface padrão sem o uso de programadores. Torna possível fazer firmware, tendo apenas
uma compreensão muito superficial de como tudo está organizado lá. Um conjunto de módulos externos permite conectar dispositivos sem um ferro de soldar. De qualquer maneira, para fazer edições, você precisa instalar o software Arduino, armazenar o firmware em algum lugar.
Nosso comutador passará a ser grande o suficiente, conterá uma placa Arduino + módulo de relé AC / DC +. E se você precisar fazer ajustes, precisará se lembrar dolorosamente de onde está o código e instalar novamente o software Arduino.
Para poupar a necessidade de compilar o código fonte (ou seja, instalar software adicional e armazená-lo), a solução mais lógica parece ser usar intérpretes ou compilar diretamente o código no próprio microcontrolador. Felizmente, surgiram projetos que permitem que isso seja feito. Por exemplo, NodeMCU, o interpretador de idioma lua para o microcontrolador esp8266: o próprio firmware possui suporte interno para o sistema de arquivos, o que permite carregar / ler scripts para / do dispositivo. Outro projeto bastante sério é o Micropython, uma versão simplificada do python que é especificamente projetada para microcontroladores. Será discutido.
O MicroPython é uma implementação de uma das linguagens de programação python mais populares da atualidade. Ele suporta um grande número de arquiteturas e SoC (bare-arm, CC3200, esp8266, esp32, nRF, pic16bit, stm32). O projeto está em desenvolvimento ativo e possui um grande número de módulos adicionais.
O microprocessador esp8266 é muito adequado como peça de hardware, devido ao fato de os módulos de switch wifi orçamento construídos nele serem vendidos no mercado. Eles contêm tudo o que precisamos: AC / DC, um microcontrolador com uma interface de comunicação interna (wifi). Disponível sob a marca Sonoff. Os microprocessadores esp8266 não contêm memória, são soldados separadamente e podem ter um tamanho diferente. Para o Sonoff Basic, eles colocam módulos de 1Mb.
Iniciando o firmware básico no esp8266. Sonoff Basic.
Na ausência de armadilhas, seria possível prosseguir imediatamente para a programação em python. Infelizmente, porém, há vários problemas que precisam ser resolvidos. Para programar e modificar o firmware, era muito fácil e simples. Obviamente, estamos interessados em fazer isso via wifi, sem usar dispositivos adicionais, exceto um laptop.
A primeira armadilha, é claro, é o firmware básico que está registrado em sua placa. Se você comprou uma placa de depuração, provavelmente encontrará o NodeMCU nela, se Sonoff Basic, em seguida, firmware proprietário. Para preparar esta placa para si mesmo, você precisa anotar o firmware necessário lá. Em alguns microcontroladores, é necessário comprar
um programador especial, no nosso caso, tivemos sorte, você só precisa obter um conversor USB <-> UART. Se você trabalha com microcontroladores, ele será útil mais de uma vez, e o preço geralmente está na faixa de US $ 3.
Não existe um pente para o Sonoff Basic que permita a conexão via UART, e precisamos disso para programar o dispositivo. Para programar simplesmente o dispositivo, não é necessário pegar o ferro de soldar nas mãos, basta inclinar os contatos e anotar o firmware. Considerando que o trabalho adicional será via wifi, não precisaremos mais desses contatos. Mas implementamos um interruptor na passagem, o que significa que precisamos de solda,
pelo menos três pernas.
Para o Sonoff Basic, há apenas 1 conector GPIO gratuito e 2 conectores RX, TX. Considerando que precisamos do RX, TX uma vez (para atualizar o firmware), no futuro eles poderão ser reprogramados para GPIO, graças ao esp8266 isso pode ser feito. Mas, neste caso, precisamos abandonar a depuração via UART, felizmente já planejamos fazer isso, pois a depuração via wifi, do ponto de vista da conveniência, é muito mais simples.
Como a versão do MicroPython pode mudar no processo, estamos interessados em depurar o método de atualização via wifi. OTA vem em socorro. OTA é um firmware que permite reprogramar um dispositivo. Funciona simplesmente. Depois de ligar o dispositivo, o firmware determina se ele precisa ser reprogramado, se necessário, inicia um
O atualizador wifi, se não, inicia o firmware do usuário. A implementação pode ser diferente, o firmware pode sobrescrever-se ou gravar em uma área livre de memória. Você também pode determinar se deseja executar o programa de cópia de maneiras diferentes. Por exemplo, considere o cxumma do firmware personalizado se ele não convergir,
então forçosamente vá para o piscar. Você pode ler dados do GPIO ou gravar informações sobre a necessidade de iniciar a atualização em outro lugar.
Como um atualizador, o projeto MicroPython refere-se ao projeto yaota8266. Yaota8266 afirma estar piscando o dispositivo e assinando cada pacote. Deve-se notar que a chave pública está incorporada no próprio firmware, e é por isso que não faz sentido fazer o upload do firmware já montado, pois é necessário costurar sua chave lá.
Não há função para modificar a chave privada na imagem montada; portanto, no nosso caso, é mais fácil montar o firmware você mesmo. Uma característica interessante é que a função de verificação de assinatura é, mas é comentada no código, ou seja, de fato, temos dificuldades sem ganhos de segurança. A versão básica do yaota8266 não vai,
Felizmente, existem garfos no github que resolvem esse problema, além de adicionar a capacidade de determinar se o flash deve ser feito com base na gravação na área RTC, o que torna possível alternar o MicroPython para o modo de carregador de inicialização.
Mesmo depois de incluir todas as correções, nosso firmware OTA gravará com erros, mas funcionará com êxito nas placas de depuração do NodeMCU. Isso ocorre devido a tempos limite. Ao atualizar a partir da máquina host, os pacotes UDP são enviados e é esperada uma resposta se a gravação no flash demorar mais que o normal, ocorrer o tempo limite e o pacote for enviado novamente. O benefício é fácil de corrigir,
apenas aumentando os tempos limite no código ota-client.
O pacote OTA + MicroPython no Sonoff também tem curiosidades interessantes. Uma delas está relacionada ao fato de que as funções padrão para trabalhar com o SPI Flash no esp-sdk operam em blocos de 4k e esse tamanho de bloco foi escolhido para implementar o sistema de arquivos FAT. Por sua vez, devido ao fato de o SPI Flash ser de apenas 1Mb, dos quais ~ 300Kb é firmware OTA, ~ 500Kb é firmware MicroPython, menos de 200Kb permanecem no sistema de arquivos, ou seja, menos de 50 blocos. No entanto, a biblioteca selecionada que implementa o fatfs não pode criar FS onde há menos de 50 blocos.Existem várias maneiras de resolver o problema: reduza o tamanho do bloco (o FAT permite definir 512), corrija a biblioteca FatFs, use o SPI FS (esperando que não exista essa esquisitice). Peguei o caminho de reduzir o bloco para 512.
Microcontroladores usam SPI Flash - essa é a memória NOR e / ou NAND. A notabilidade dessa memória é que não há conceito de "escrever dados". Você só pode redefinir o valor (em 0xff) ou definir os bits desejados para "0". O SPI Flash geralmente é uma memória NOR, tem a função de redefinir qualquer byte para 0xff, enquanto o NAND pode ser redefinido apenas por blocos. I.e. se o tamanho mínimo do bloco de redefinição for 4k, para escrever
1 byte de memória, é necessário ler o bloco inteiro, redefini-lo para 0xFF e depois gravar o bloco, definindo o byte desejado no valor desejado. Os fabricantes do SPI Flash têm aproximadamente o mesmo conjunto de APIs para o trabalho, mas, como a prática demonstrou, o comando para gravar um byte do SPI Flash pode ser diferente. Em algum lugar, ele será redefinido automaticamente antes de gravar em 0xFF, em outro lugar.
Se você alterar a seção FAT para 512 bytes, há uma chance de obter um sistema danificado se um SPI Flash específico não suportar redefinição automática de bytes durante a gravação. E foi exatamente essa lembrança que me deparei no Sonoff Basic. Há rumores de que eles costumavam instalar o Winbond 25q80bv lá, mas agora o PUYA 25q80h, que possui um bloco de limpeza mínimo de 256 bytes. Solução parece
simples, você só precisa apagar duas páginas onde será gravado antes de escrever o bloco FAT, mas a implementação é complicada pelo fato de o sdk-esp suportar apenas a exclusão em blocos de 4k. Como escrever para o FAT será muito raro para nossa troca,
somente ao atualizar os scripts de firmware, você pode seguir o caminho errado e atualizar o bloco de 512 bytes em blocos de 4k. A documentação desta memória diz que a memória pode suportar 100.000 ciclos de reescrita, ou seja, uma evasão semelhante do problema nos reduzirá esse valor em 4 vezes, ou seja, até 25.000.
O MicroPython possui um console por padrão, é chamado REPL e funciona através da porta COM. Não estamos muito felizes com esse estado de coisas, pois queremos nos comunicar com o dispositivo via wifi. Felizmente no MicroPython, o WebRepl também é padrão, mas não é iniciado automaticamente. Você pode registrar a execução automática no boot.py, mas decidi executá-lo diretamente do _boot.py, o arquivo do sistema, que é costurado no próprio arquivo de firmware.
Após a primeira inicialização, nosso firmware criará um sistema de arquivos, iniciará o webrepl e criará um ponto de acesso. Você pode conectar-se a ele e prescrever os parâmetros para conectar-se à sua rede local ou, como eu fiz, configurar a rede usando a porta com, após a qual somente o wifi deve ser usado.
Para trabalhos de avaliação, você pode usar o cliente webrepl escrito em javascript. O cliente pode ser iniciado em um navegador na página correspondente do projeto. Outra opção é usar o projeto mpfshell, pois fornece funções mais convenientes para trabalhar com o dispositivo.
Portanto, depois de superar todas essas armadilhas, você pode ir diretamente para a programação do switch.
Desenvolvimento de Firmware
Para desenvolver o firmware, precisamos ter uma idéia aproximada de como o GPIO funciona. Em geral, isso pode ser entendido puramente intuitivamente:
- Se definirmos o modo de saída (OUT), a perna produzirá GND ou Vcc.
- Se definirmos o modo de entrada (IN), a perna "oscila no ar"; nesse caso, o microcontrolador pode emitir qualquer coisa
- Para que o microcontrolador não produza nada, a perna pode ser puxada para o valor desejado usando o microcontrolador embutido
resistores de pull-up PULL_UP ou PULL_DOWN.
Você também precisa ter uma idéia do que são interrupções: no nosso caso, este é o código que precisa ser executado se ocorrer algum tipo de evento: um botão foi pressionado / liberado ou uma mensagem veio da rede local de que o dispositivo deve ser desligado / ligado.
Para começar, vamos escrever um programa simples de switch (não de passagem) em Python.
from machine import Pin class SW: def __init__(self, portin, portout): self.pin = Pin(portin , Pin.PULL_UP)
Eu nomeei esse arquivo switch.py e pedi que ele fosse executado no boot.py:
from switch import sw
Após iniciar o firmware, obtive um objeto sw; se eu executar sw.change (), ocorrerá uma troca de programa.
mudar para outra posição. Quando um pino livre está em curto para Vcc no microcontrolador
o relé liga ou desliga, respectivamente.
O próximo passo será o lançamento do cliente MQTT e a capacidade de alternar o comutador do telefone.