Como usar um módulo de relógio em tempo real com o Arduino

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


Neste tutorial, discutiremos o objetivo de obter a data e hora atuais no Arduino, o que é um relógio em tempo real, o que é um módulo RTC DS3231 e criaremos um projeto usando um módulo RTC DS3231, um 16 × 2 LCD I2C e um Arduino Uno.

Anúncio PCBWay

Por que acompanhar a data e a hora?

Manter o controle da data / hora atual de um Arduino tem muitos propósitos. Um uso para isso é para fins de gravação / registro. Por exemplo, uma estação meteorológica do Arduino precisa de carimbos de data e hora na gravação de dados climáticos. Outro exemplo é para um relógio ou calendário digital do Arduino. Os relógios baseados no Arduino usam o horário atual como um temporizador para lembretes ou para executar um comando agendado através dos pinos de E / S do Arduino. Dependendo do projeto, é muito útil ter uma maneira de obter a data e hora atuais.

Como obter a data e hora atuais em um Arduino

Existem várias maneiras de obter a data e hora atuais. Podemos obtê-lo de um Relógio em tempo real (RTC), uma Dispositivo GPSou um servidor de horário.

  1. Relógio em tempo real (RTC) – um relógio em tempo real ou RTC em resumo, é um circuito integrado que acompanha o tempo. Ele usa uma bateria de reserva para manter o tempo no caso em que a fonte de energia principal é removida.
  2. Dispositivo de posicionamento global (GPS) – Um dispositivo GPS se comunica com os satélites para determinar sua localização em qualquer lugar do mundo. Seus dados de GPS também contêm dados de tempo.
  3. Time Server– Um servidor de horas é um computador em uma rede que lê a hora de algum relógio de referência e a distribui para a rede. A fonte do relógio de um servidor de horas pode ser outro servidor de horas, um relógio atômico ou um relógio de rádio.

Um RTC é uma fonte muito popular e precisa de data e hora em um sistema incorporado como um Arduino, pois possui baixo consumo de energia.

Se você quiser aprender como se comunicar com um servidor de horário da Internet para obter a hora e a data atuais, leia Como acompanhar a data e a hora em um Arduino.

O módulo de relógio em tempo real DS3231

Figura 1: Módulo de relógio em tempo real DS3231

O módulo DS3231 RTC é um módulo de relógio em tempo real usando o DS3231 IC. O DS3231 IC é um RTC muito acessível e extremamente preciso com uma interface I2C. É muito preciso porque utiliza um oscilador de cristal com compensação de temperatura (TCXO) integrado com um cristal. Para acompanhar o tempo, mesmo que a fonte de energia principal seja removida, o DS3231 possui uma bateria de reserva montada na parte traseira do módulo. O chip alterna automaticamente entre as fontes de energia principal e de backup, quando necessário.

Leia Também  7 estratégias comprovadas para preencher sua agenda de coaching e terapia do cliente

O RTC controla dados de segundos, minutos, horas, dia, data, mês e ano. Também se ajusta automaticamente por meses com menos de 31 dias e também por anos bissextos. O relógio pode operar nos formatos 24H ou 12H (com AM / PM). Existem também dois alarmes da hora do dia programáveis ​​e também uma saída de onda quadrada programável. A comunicação com o RTC é feita através de uma interface I2C com um endereço padrão fixo de 0x68.

Além do chip RTC, este módulo em particular também possui um chip 24C32 EEPROM. Uma EEPROM é um tipo de dispositivo de armazenamento de dados em que você pode ler / gravar dados. O 24C32 possui 32 bytes de espaço disponível para armazenamento de dados. Ele compartilha o barramento I2C do módulo com o DS3231 e tem o endereço padrão de 0x57. Podemos alterar o endereço padrão da EEPROM conectando as pastilhas de solda indicadas por A0, A1e A2 como mostrado na Figura 2.

Figura 2: Combinações de bloco de solda de endereço EEPROM

Pinagem do módulo

Figura 3: Diagrama de pinagem do módulo DS3231
  • 32K – gera do chip DS3231 um oscilador de 32KHz muito preciso
  • SQW – emite um sinal de onda quadrada do chip DS3231. A frequência da onda quadrada pode ser alterada entre 1Hz, 4kHz, 8kHz ou 32kHz programaticamente. este pino também pode ser usado programado como uma saída de interrupção.
  • SCL – pino de entrada para I2C Serial Clock
  • SDA – pino de entrada / saída para dados seriais I2C
  • VCC – pino de entrada da fonte de alimentação para o módulo; pode haver qualquer voltagem de + 3.3V a + 5.5V DC
  • GND – Conexão do pino de aterramento
  • o SCL, SDA, VCCe GND pinos no lado direito do módulo são conectados internamente no lado esquerdo com a mesma etiqueta.

Projeto: Arduino Calendar Clock

Depois de aprender sobre a pontualidade e o DS3231 RTC, agora é hora de criar um projeto usando o DS3231 RTC. Para este projeto, criaremos um simples relógio de calendário do Arduino usando um módulo DS3231, um LCD I2C 16 × 2 e uma placa Arduino Uno.

Componentes Necessários

Diagrama de fiação

O diagrama de fiação do nosso projeto é mostrado na Figura 4. Como estamos usando o I2C, todos os dispositivos compartilham um barramento comum que consiste em apenas 4 fios.

diagrama de fiação do relógio do arduino-calendário
Figura 4: Diagrama de fiação

Arduino Sketch

Para facilitar o desenvolvimento do código do nosso projeto, usaremos bibliotecas e criaremos funções personalizadas para facilitar a leitura do código.

Bibliotecas

Nosso projeto incluirá as seguintes bibliotecas. Consulte a Figura 5 para verificar quais bibliotecas instalar usando o Library Manager interno do Arduino IDE.

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br
  • Wire.h biblioteca para a interface I2C (incluída no Arduino IDE)
  • LiquidCrystal_I2C.h biblioteca (de Frank de Brabander) para o módulo LCD I2C 16 × 2 (link GitHub)
  • RTClib.h biblioteca (de Adafruit) para o módulo DS3231 RTC (link do GitHub)
Figura 5: Gerenciador de bibliotecas

o Wire.h biblioteca e o protocolo I2C já foi discutido em artigos anteriores (aqui e aqui) e, portanto, não será abordado neste tutorial.

Para iniciar nosso esboço, adicione as bibliotecas mencionadas no código usando a palavra-chave #include. Também vamos inicializar dois objetos lcd() e rtc para ser usado para comunicação com o LCD e o DS3231, respectivamente.

#include                    // for I2C communication
#include       // for LCD
#include                  // for RTC

LiquidCrystal_I2C lcd(0x27, 16, 2); // create LCD with I2C address 0x27, 16 characters per line, 2 lines
RTC_DS3231 rtc;                     // create rtc for the DS3231 RTC module, address is fixed at 0x68

Funções personalizadas: updateRTC () e updateLCD ()

Para tornar nosso código mais fácil de gerenciar, criaremos duas funções personalizadas.

A primeira função que codificaremos é a função updateRTC(). Essa função será responsável por solicitar ao usuário a data e a hora e atualizar o relógio interno do RTC com os dados de entrada do usuário. Após receber a entrada do usuário, podemos atualizar o relógio interno do RTC usando a função rtc.adjust() de RTCLib.h biblioteca. o rtc.adjust() A função recebe um parâmetro com o tipo DataTime que ele usa para atualizar a hora e a data internas do rtc.

/*
   function to update RTC time using user input
*/
void updateRTC()
{
  
  lcd.clear();  // clear LCD display
  lcd.setCursor(0, 0);
  lcd.print("Edit Mode...");

  // ask user to enter new date and time
  const char txt[6][15] = { "year [4-digit]", "month [1~12]", "day [1~31]",
                            "hours [0~23]", "minutes [0~59]", "seconds [0~59]"};
  String str = "";
  long newDate[6];

  while (Serial.available()) {
    Serial.read();  // clear serial buffer
  }

  for (int i = 0; i < 6; i++) {

    Serial.print("Enter ");
    Serial.print(txt[i]);
    Serial.print(": ");

    while (!Serial.available()) {
      ; // wait for user input
    }

    str = Serial.readString();  // read user input
    newDate[i] = str.toInt();   // convert user input to number and save to array

    Serial.println(newDate[i]); // show user input
  }

  // update RTC
  rtc.adjust(DateTime(newDate[0], newDate[1], newDate[2], newDate[3], newDate[4], newDate[5]));
  Serial.println("RTC Updated!");
}

A segunda função personalizada que criaremos é a função updateLCD(). Esta função atualiza ou atualiza o texto exibido no LCD. Dentro dessa função, primeiro obteremos a hora e a data do RTC. Isso é feito chamando rtc.now() função incluída no RTCLib.h biblioteca.

A função rtc.now() em nosso código retorna um DateTime tipo de dados que contém a data e hora atuais do rtc. Em seguida, atribuímos os dados a diferentes variáveis ​​para formatação adicional no LCD. Depois de atribuir as variáveis, usamos as funções lcd.setCursor() e lcd.print() de LiquidCrystal_I2C.h para posicionar o cursor e exibir o texto, respectivamente, no LCD. O código abaixo mostra como essas funções se reúnem para obter a hora rtc, formatar o texto e exibi-lo no LCD.

/*
   function to update LCD text
*/
void updateLCD()
{

  /*
     create array to convert digit days to words:

     0 = Sunday    |   4 = Thursday
     1 = Monday    |   5 = Friday
     2 = Tuesday   |   6 = Saturday
     3 = Wednesday |
  */
  const char dayInWords[7][4] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};

  /*
     create array to convert digit months to words:

     0 = [no use]  |
     1 = January   |   6 = June
     2 = February  |   7 = July
     3 = March     |   8 = August
     4 = April     |   9 = September
     5 = May       |   10 = October
     6 = June      |   11 = November
     7 = July      |   12 = December
  */
  const char monthInWords[13][4] = {" ", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", 
                                         "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};

  // get time and date from RTC and save in variables
  DateTime rtcTime = rtc.now();

  int ss = rtcTime.second();
  int mm = rtcTime.minute();
  int hh = rtcTime.twelveHour();
  int DD = rtcTime.dayOfTheWeek();
  int dd = rtcTime.day();
  int MM = rtcTime.month();
  int yyyy = rtcTime.year();

  // move LCD cursor to upper-left position
  lcd.setCursor(0, 0);

  // print date in dd-MMM-yyyy format and day of week
  if (dd < 10) lcd.print("0");  // add preceeding '0' if number is less than 10
  lcd.print(dd);
  lcd.print("-");
  lcd.print(monthInWords[MM]);
  lcd.print("-");
  lcd.print(yyyy);

  lcd.print("  ");
  lcd.print(dayInWords[DD]);

  // move LCD cursor to lower-left position
  lcd.setCursor(0, 1);

  // print time in 12H format
  if (hh < 10) lcd.print("0");
  lcd.print(hh);
  lcd.print(':');

  if (mm < 10) lcd.print("0");
  lcd.print(mm);
  lcd.print(':');

  if (ss < 10) lcd.print("0");
  lcd.print(ss);

  if (rtcTime.isPM()) lcd.print(" PM"); // print AM/PM indication
  else lcd.print(" AM");
}

Funções padrão: setup () e loop ()

A última fase no preenchimento do nosso código para um relógio de calendário do Arduino é adicionar as funções padrão do Arduino setup() e loop().

Dentro setup(), inicializaremos a interface serial, o lcd e a rtc objetos. Para inicializar o serial com uma taxa de transmissão de 9600 bps, usaremos o código Serial.begin(9600);. Para o LCD, precisamos inicializar o objeto do LCD e ativar a luz de fundo da tela. Isso é alcançado pelos códigos lcd.init(); e lcd.backlight();. E, finalmente, adicionamos o código rtc.begin(); para inicializar o objeto rtc.

void setup()
{
  Serial.begin(9600); // initialize serial

  lcd.init();       // initialize lcd
  lcd.backlight();  // switch-on lcd backlight

  rtc.begin();       // initialize rtc
}

Para o loop() função, atualizaremos o texto exibido no LCD chamando updateLCD();. Também adicionaremos a capacidade de aceitar a entrada do usuário para atualizar o relógio interno do RTC. Se o usuário envia o char 'u' pelo monitor serial, significa que o usuário deseja modificar a hora e a data definidas do rtc. Se for esse o caso, chamamos a função updateRTC(); para manipular a entrada do usuário e atualizar o relógio interno do RTC.

void loop()
{
  updateLCD();  // update LCD text

  if (Serial.available()) {
    char input = Serial.read();
    if (input == 'u') updateRTC();  // update RTC time
  }
}

Nosso esboço agora está completo. Salve o esboço como arduino-rtc-tutorial.ino e faça o upload para o seu Arduino Uno.

Teste do Projeto

Após o upload do esboço, o Arduino Uno deve exibir a data e a hora no LCD, como mostra a Figura 6.

arduino-calendar-clock
Figura 6: Relógio do calendário do Arduino

Para alterar a data / hora, abra o Serial Monitor e envie a letra 'u'. E siga as instruções na tela para inserir a nova data e hora.

Figura 7: Monitor serial

Em resumo, um módulo RTC é uma maneira fácil e barata de adicionar capacidade de cronometragem a um projeto baseado em Arduino. Este tutorial apenas mostrou o recurso básico do módulo DS3231 RTC. E com mais ajustes, você pode encontrar muitos usos para este módulo.

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br