MicroPython: Como programar um relógio de tempo real (RTC) em ESP8266 e ESP32

Um relógio em tempo real (RTC) é um relógio de computador para marcar a hora e é um dos recursos mais populares do microcontrolador. Microcontroladores sem RTC integrado requerem um chip RTC externo para manter o tempo. Normalmente, microcontroladores de segmento médio a topo de linha possuem um RTC integrado porque a manutenção do tempo é necessária para vários aplicativos embarcados.

Os RTCs contam segundos, minutos, horas, dias, meses e anos. Eles também podem ser usados ​​para a data atual e para medir intervalos de tempo.

O módulo de máquina do MicroPython fornece uma classe RTC que configura e usa uma porta integrada com suporte para RTC. MicroPython também fornece um módulo “ntptime” que sincroniza o tempo com a ajuda de uma fonte de relógio ou servidor.

Neste artigo, exploraremos o módulo RTC do MicroPython e aprenderemos como definir e obter a hora no ESP8266 e ESP32.

Módulo de máquina
MicroPython consiste em vários módulos específicos de hardware. O módulo da máquina é o mais importante porque gerencia as funcionalidades básicas de hardware e os periféricos de hardware integrados das portas suportadas.

O módulo possui diversas classes para controlar a entrada/saída digital, sinais de saída de dispositivos externos, modulação por largura de pulso, conversão analógico para digital, periféricos ADC, UART, SPI, I2C, I2S, temporizador, RTC, temporizador watchdog e cartão SD .

Classe RTC
O módulo de máquina do MicroPython para a classe RTC é usado para configurar e gerenciar o relógio em tempo real das portas suportadas. Ele é importado em um script MicroPython usando esta instrução:

da importação da máquina rtc

Alternativamente, a classe RTC é importada automaticamente quando o módulo da máquina é importado da seguinte forma:

máquina de importação

Após a importação do módulo, você deve instanciar um objeto da classe RTC com a ajuda do método construtor. O método construtor da classe RTC possui este protótipo:

classe máquina.RTC(id=0,…)

O construtor usa o parâmetro “id”, que identifica o RTC integrado (caso haja vários RTCs na porta suportada). Se houver apenas um, não é necessário passar o id como argumento. Os demais parâmetros do método construtor usado para definir a hora no RTC são opcionais.

Este é um exemplo válido de instanciação de um objeto RTC:

rtc = máquina.RTC

A classe RTC fornece estes métodos para manter as configurações de data e hora…

RTC.init(datahora): usado para inicializar o objeto RTC. Leva a data e hora atual como argumento. O tempo dos dados é passado como uma tupla de 8 com este formato: (ano, mês, dia (, hora (, minuto (, segundo (, microssegundo (, tzinfo)))))). A tupla deve ter os elementos ano, mês e dia. Os demais são opcionais e podem ou não ser aprovados dependendo da aplicação.

RTC.datetime((datetimetuple)): usado para obter ou definir a data e hora do RTC.

  • Se chamado sem argumentos, este método retorna a data e hora atual mantida pelo RTC na forma de uma tupla de 8.
  • Se usado para definir a data e hora, o método usa uma tupla de 8 como argumento.

A tupla deve seguir este formato: (ano, mês, dia, dia da semana, horas, minutos, segundos, subsegundos). Dependendo da porta, os subsegundos na tupla podem ser milissegundos ou microssegundos.

RTC.deinit : redefine o horário do RTC para 1º de janeiro de 2015 e reinicia o RTC.

RTC.agora : obtém a data e hora atual do RTC, que é retornada como uma tupla de 8.

A classe RTC fornece estes métodos para definir as configurações de alarme…

RTC.alarm(id, hora, *, repetição=Falso): usado para definir o alarme no RTC. O id deve ser passado como argumento se houver vários RTCs integrados em uma porta; caso contrário, não há necessidade. A hora pode ser passada como o valor de milissegundos ou como a tupla data-hora. Se o tempo passar em milissegundos, o alarme poderá ser repetido definindo o argumento da palavra-chave repetir como Verdadeiro. Os milissegundos são contados a partir da data e hora atual do RTC.

RTC.alarm_left(alarm_id=0): retorna o número de milissegundos do alarme.

RTC.cancel(alarm_id=0): usado para cancelar um alarme em execução.

A classe RTC fornece estes métodos para configurar uma interrupção…

RTC.irq(*, gatilho, manipulador=Nenhum, wake=machine.IDLE): cria um objeto de interrupção que é acionado pelo alarme RTC. São necessários três parâmetros: trigger, handler e wake. O gatilho é sempre definido como RTC.ALARM0. O manipulador é uma função de retorno de chamada executada como uma rotina de serviço de interrupção. O wake especifica o modo de suspensão a partir do qual a interrupção RTC pode ativar a porta.

Sincronização de horário usando ntptime
A hora no RTC nem sempre precisa ser definida manualmente. MicroPython fornece o módulo ntptime, que é útil para sincronizar a hora, manter o padrão UTC e fornecer uma hora precisa. O módulo é baseado no Network Time Protocol (NTP).

O protocolo NTP sincroniza a hora RTC de um computador/controlador com um servidor ou fonte de relógio remota. O módulo facilita uma calibração precisa do tempo RTC. Porém, a placa deve estar conectada à internet via Ethernet ou WiFi para ingressar no servidor NTP.

O módulo é importado em um script MicroPython usando esta instrução:

importar ntptime

O módulo fornece esses métodos…

ntptime.settime : usado para sincronizar a hora local mantida pelo RTC ou uma fonte de relógio interna com a hora padrão UTC. Alguns módulos MicroPython ntptime específicos de porta permitem que o método settime receba dois argumentos, fuso horário e servidor. O módulo ntptime do firmware oficial do MicroPython não aceita nenhum argumento. A época do padrão UTC é 1º de janeiro de 1970 00:00:00. O servidor host usado pelo módulo MicroPython ntptime é “pool.ntp.org”

ntptime.time : retorna o número de segundos decorridos desde a época UTC. O valor retornado é um número inteiro.

Novamente, certifique-se de que a placa esteja conectada à Internet via Ethernet ou WiFi para acessar o servidor NTP.

RTC em ESP8266 e ESP32
ESP8266 e ESP32 possuem RTCs integrados únicos. Abaixo está um exemplo válido de instanciação de um objeto RTC, configuração da hora e recuperação da data e hora atual no ESP8266 e ESP32.

RTC em ESP8266 e ESP32
ESP8266 e ESP32 possuem RTCs integrados únicos. Abaixo está um exemplo válido de instanciação de um objeto RTC, configuração da hora e recuperação da data e hora atual no ESP8266 e ESP32.

da importação de máquina RTC
rtc = RTC
rtc.datetime((2022, 7, 25, 1, 1, 30, 42, 0)) # definir data e hora
print(rtc.datetime ) # obtém data e hora

Aqui está um exemplo válido de configuração do horário RTC usando o servidor NTP no ESP8266 e ESP32:

da importação de máquina RTC
rede de importação
importar ntptime
estação = rede.WLAN(rede.STA_IF)
estação.active(Verdadeiro)
station.connect(ssid, password) #replace pelo seu SSID e senha do WiFi
rtc = RTC
ntptime.settime
imprimir(rtc.datetime )

Exibindo a hora local usando o módulo ESP8266
A hora retornada pelo servidor NTP é a hora UTC. Para alterar a hora, converta o carimbo de data/hora UTC para o carimbo de data/hora local. Como MicroPython é um subconjunto do Python, ele não possui uma função ou método direto para converter o horário UTC para outro fuso horário. Portanto, é necessário utilizar o módulo de tempo do firmware MicroPython.

Para este projeto, exibiremos o UTC e a hora local com a ajuda do MicroPython e ESP8266.

Componentes necessários

1. ESP8266/ESP32 x1
2. Computador/laptop x1
3. Cabo USB (para conectar a placa ESP a um computador) x1

Conexões de circuito
Não há conexões de circuito para este projeto. Basta conectar o ESP8266/ESP32 ao seu computador usando o cabo USB. Além disso, certifique-se de que o uPyCraft IDE ou Thonny IDE esteja instalado em seu computador e carregue o firmware MicroPython para o ESP8266/ESP32 (saiba como aqui).

Em seguida, inicie o IDE uPyCraft. Selecione a porta de comunicação serial navegando em Ferramentas->Serial e selecione a placa navegando em Ferramentas->placa. Após fazer upload do firmware MicroPython, você deverá ter boot.py na guia do dispositivo.

Crie um novo arquivo navegando em Arquivo->Novo e salve o arquivo como main.py. Copie o script abaixo para main.py. Clique no botão 'Baixar e Executar' para executar o script.

Script MicroPython

Como funciona o projeto
ESP8266 se conecta ao servidor NTP e obtém a hora UTC, que é usada para definir a data e hora RTC. A hora UTC é então convertida para a hora local (IST neste caso) usando funções do módulo de hora. A hora local é impressa pelo console. Finalmente, o RTC é atualizado com a hora local.

O código
O script MicroPython importa a classe RTC dos módulos de máquina, rede, ntptime e tempo. A seguir, um objeto da classe WLAN do módulo de rede é instanciado.

A função definida pelo usuário, connect , é definida para conectar-se ao WiFi. A função desconectar é definida para desconectar o ESP8266/ESP32 do WiFi. Para entender essas funções, confira Como conectar ESP8266 e ESP32 com WiFi.

O ESP8266/ESP32 se conecta ao WiFi chamando a função connect . Você deve passar o SSID e a chave/senha de rede do seu WiFi pessoal como argumentos.

Um objeto da classe RTC é instanciado usando o método machine.RTC . A hora UTC atual é definida para o RTC ESP8266/ESP32 chamando ntptime.settime . O horário UTC definido no RTC ESP8266/ESP32 é recuperado em uma tupla e exibido no console.

Para converter UTC para a hora local, use o módulo de tempo do MicroPython (saiba mais aqui). MicroPython é um subconjunto do módulo de tempo padrão do Python e contém algumas funções aplicáveis ​​a aplicativos incorporados.

A hora UTC é obtida em segundos a partir da época UTC chamando o método ntptime.time . A hora UTC atual é armazenada em uma variável seg. A diferença horária do fuso horário é armazenada na variável timezone_hour. Você pode alterar o valor da diferença horária do fuso horário em horas, de acordo com seu país ou fuso horário.

Veja como:

  • A diferença de fuso horário é convertida em um valor em segundos e armazenada na variável timezone_sec.
  • A hora local em segundos é obtida adicionando a diferença horária do fuso horário em segundos à hora UTC obtida do RTC.
  • A data e hora local é então obtida passando os segundos atualizados como argumento para o método time.localtime .
  • A hora retornada por time.localtime é armazenada em uma tupla.
  • A tupla é usada para exibir a hora local no console. A tupla é então reformatada e usada para atualizar a data e hora do RTC para a hora local.
  • Por último, desconecte o ESP8266/ESP32 do WiFi chamando a função desconectar .

Resultados

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.