Módulo Display Serial - Primeiro Contato

This tutorial is not available in English

Introdução

Alguns equipamentos eletrônicos precisam exibir informações para o usuário em um formato que seja legível, sendo números ou letras. Uma das formas mais simples para a apresentação de dados no formato de números é o uso do display de 7 segmentos. Entretanto, quanto maior a escala do valor que será exibido, mais complicado tende a ser a conexão elétrica dos displays, e mais complexa é a lógica para controlá-los.

Nesse tutorial você irá aprender de maneira simples a fazer um timer utilizando o Display Serial. E que tal iniciar essa contagem a partir de um pulso externo, como um timer?

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Módulo Display Serial

R$ 33,25 no PIX

Fonte Chaveada 12V 1A

R$ 14,15 no PIX

Buzzer Passivo 5V - Pacote com 5 unidades

R$ 8,45 no PIX

Chave Momentânea (PushButton) - Pacote com 10 unidades

R$ 2,85 no PIX

Resistor 10kΩ - Pacote com 10 unidades

R$ 0,71 no PIX

Protoboard 400 Pontos

R$ 6,55 no PIX

WorkPlate 400 - Preta

R$ 14,15 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Jumper Premium 10cm Macho-Fêmea - 40 Unidades

R$ 8,55 no PIX

Conceitos Teóricos

Display 7 Segmentos

Os displays de 7 segmentos possuem 7 LEDs que são identificados por letras, de "A" a "G", e o ponto decimal como "DP" (Decimal Point), que também é um LED, conforme ilustrado na figura ao lado. A princípio isso pode não parecer um problema para controlar um único display de 7 segmentos através de placas da plataforma Arduino, já que eles utilizam apenas 8 portas digitais de sua placa. Além disso, é possível reduzir a quantidade de portas pela metade ao utilizar conversores BCD, como o Circuito Integrado 4511.

Entretanto, caso você precise exibir um valor com a escala decimal na casa dos milhares, mesmo utilizando conversores BCD, uma placa Arduino UNO não será o bastante.

Pensando nisso, a Robocore criou o Módulo Display Serial, no intuito de reduzir o uso de pinos do seu microcontrolador. Onde antes eram necessários 8 pinos para um único display, com esse módulo apenas 2 pinos digitais fazem a comunicação, podendo controlar até 10 displays interligados.

Projeto Timer Básico

Inicialmente vamos apenas realizar a exibição de contagem de 0 a 99, que é reiniciada ao chegar no valor final. Deste modo podemos entender melhor o seu funcionamento e os comandos da biblioteca.

Circuito

O módulo Display Serial possui 5 pinos, sendo eles: 12V e GND, para a alimentação do módulo; SCK (Slave Clock) e DI (Data Input), os pinos responsáveis pela entrada de dados; e também o pino OE (Output Enable), para o controle do brilho dos segmentos.

Atenção: é indispensável o uso de uma fonte 12 V.

Monte o circuito conforme a figura abaixo. Lembrando que estamos usando o pino "Vin" devido à alimentação do display ser a mesma da BlackBoard, já que o uso de uma fonte de alimentação de 12 V é indispensável para esse módulo.

Programação

Biblioteca

Neste tutorial faremos com que o Módulo Display Serial conte até 99. Após isso, a contagem é zerada e iniciada novamente. Para começarmos, é necessário que você baixe e instale a biblioteca do Display Serial.

Download da Biblioteca "SerialDisplay"

Caso tenha dificuldade ao realizar esse procedimento, siga os passos do tutorial Adicionando Bibliotecas na IDE Arduino.

Código

Com a biblioteca adicionada e o circuito montado, carregue o código abaixo para a placa.

/*******************************************************************************
* Display Serial : Timer Basico (v1.0)
* 
* Contador de 0 a 99 usando dois displays.
*
* Copyright 2019 RoboCore.
* Escrito por Matheus Cassioli (26/06/2019).
* Atualizado por Giovanni de Castro (16/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

#include <SerialDisplay.h> //Inclui a biblioteca Display Serial

SerialDisplay displays(4, 5, 2); // Dados, clock, numero de modulos

byte count1 = 0; // Definicao da variavel do primeiro contador
byte count2 = 0; // Definicao de variavel do segundo contador

void setup() {
  displays.Off(0); // Comando para iniciar a execucao do codigo com os displays apagados
}

void loop() {
  if (count1 < 10) { // Se o contador 1 for menor que 10, executa
    displays.Print(count1, 2); // E impresso no display 2 o algarismo contido em contador 1
    displays.Print(count2, 1); // E impresso no display 1 o algarismo contido em contador 2
    // Display 2 responsavel por imprimir o valor das unidades
    // Display 1 responsavel por imprimir o valor das dezenas
    count1++; // Incrementa no contador 1
    delay(1000); // Intervalo de tempo de 1 segundo
  } else { // Senao
    count1 = 0; // Zera contador 1
    count2++; // Incrementa no contador 2
    if (count2 > 9) { // Se contador 2 for maior que 9
      count2 = 0; // Zera contador 2
    }
  }
}

Entendendo o Código

Primeiramente incluímos a biblioteca instalada anteriormente (SerialDisplay.h) ao código. Então, criamos o objeto displays com os pinos 4 e 5 da BlackBoard como data e clock do módulo, respectivamente, através do comando SerialDisplay displays(4, 5, 2), que também define a quantidade de módulos que serão controlados, neste caso 2. Também definimos as variáveis dos contadores, count1 e count2 como zero, inicialmente.

#include <SerialDisplay.h> //Inclui a biblioteca Display Serial

SerialDisplay displays(4, 5, 2); // Dados, clock, numero de modulos

byte count1 = 0; // Definicao da variavel do primeiro contador
byte count2 = 0; // Definicao de variavel do segundo contador

Posteriormente, na configuração do código, com o comando displays.Off(0), fazemos com que os displays se iniciem desligados.

No looping do código, inserimos uma lógica "if" ( if (count1<10)), para que, se a variável do contador 1 (count1) for menor que 10, seu valor seja impresso no display 2, assim como o valor do contador 2 (count2) no display 1. Em seguida, a variável do contador 1 é incrementada em uma unidade e pausamos o código de 1 segundo.

if (count1 < 10) { // Se o contador 1 for menor que 10, executa
  displays.Print(count1, 2); // E impresso no display 2 o algarismo contido em contador 1
  displays.Print(count2, 1); // E impresso no display 1 o algarismo contido em contador 2
  // Display 2 responsavel por imprimir o valor das unidades
  // Display 1 responsavel por imprimir o valor das dezenas
  count1++; // Incrementa no contador 1
  delay(1000); // Intervalo de tempo de 1 segundo
}

Usamos o comando "else" para executar uma rotina, caso o laço "if" anterior não seja mais verdadeiro, ou seja, caso a variável count1 seja igual a 10. Com isso, realizamos dentro do laço "else" a incrementação na casa das dezenas, onde o contador 1 é zerado, por ter alcançado o valor 10, e o contador 2 é incrementado.

else { // Senao
  count1 = 0; // Zera contador 1
  count2++; // Incrementa no contador 2
}

Por fim, precisamos zerar nossos contadores assim que o total chegar a 99, ou seja, quando o contador 2 for maior que 9. Caso essa condição (if (count2 > 9)) seja verdadeira, o valor da variável do contador 2 é zerado, reiniciando a contagem do código.

if (count2 > 9) { // Se contador 2 for maior que 9
  count2 = 0; // Zera contador 2
}

O Que Deve Acontecer

Assim que energizamos a placa, a contagem de 00 a 99 segundos é iniciada. Então, quando atingir 99 segundos, a contagem é reiniciada.

Resultado Final

Atenção: o tempo do GIF foi alterado para que ele tenha uma curta duração, porém o seu código vai resultar em uma contagem com intervalos de um segundo.

Projeto Timer por Disparo

Agora que já fizemos uma programação básica com nosso Display Serial, que tal montarmos um timer usando um disparador e um buzzer para sinalizar que atingiu o tempo programado?

Circuito

Siga o esquema de ligação abaixo, atentando-se às conexões do botão e à polaridade do buzzer.

No circuito elétrico acima, note que usamos um resistor conectado no botão e no pino de entrada da BlackBoard. O mesmo leva o nome de resistor de pull-down, responsável para que não haja um curto-circuito na placa. Enquanto o botão não é pressionado na entrada (pino 7), a leitura se mantém em nível baixo, e então, quando o botão é pressionado, a entrada vai para nível alto.

Código

O código abaixo é o mesmo do projeto anterior, porém acrescentando entradas e saídas, assim como algumas lógicas para o funcionamento do contador a partir de um acionamento.

/*******************************************************************************
* Display Serial : Timer por Disparo (v1.0)
*
* Contador com inicio por disparo e buzzer para indicar o tempo esgotado.
*
* Copyright 2019 RoboCore.
* Escrito por Matheus Cassioli (26/06/2019).
* Atualizado por Giovanni de Castro (16/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

#include <SerialDisplay.h> // Inclui a biblioteca Display Serial

SerialDisplay displays(4, 5, 2); // Dados, clock, numero de modulos
byte count1 = 0; // Definicao da variavel do primeiro contador
byte count2 = 0; // Definicao de variavel do segundo contador

const int PINO_BOTAO = 7; // Pino definido para o botao disparador
const int PINO_BUZZER = 8; // Pino definido para o buzzer

const int TEMPO_DESEJADO = 30; // Declaracao da variavel do cronometro em segundos
// Essa variavel deve ser alterada de acordo com o intervalo de tempo desejado

void setup() {
  pinMode(PINO_BOTAO, INPUT); // Pino conectado ao botao configurado como entrada
  pinMode(PINO_BUZZER, OUTPUT); // Pino conectado ao buzzer configurado como saida

  displays.Off(0); // Comando para zerar as informacoes contidas nos displays
}

void loop() {
  if (digitalRead(PINO_BOTAO)) { // Debounce garantindo que o botao esta realmente pressionado e que o pulso nao foi um ruido
    
    delay(30); // Filtra ruidos abaixo de 30 milissegundos

    if (digitalRead(PINO_BOTAO)) { // Se o pino botao realmente foi acionado

      count1 = 0; // Zera contador 1
      count2 = 0; // Zera contador 2
      int tempo = 0; // Variavel tempo, usada na funcao while

      while (tempo < TEMPO_DESEJADO + 1)  { // Enquanto o tempo for menor que o tempo desejado somado em uma unidade

        if (count1 < 10) { // Se o contador 1 for menor que 10, executa
          displays.Print(count1, 2); // E impresso no display 2 o algarismo contido em contador 1
          displays.Print(count2, 1); // E impresso no display 1 o algarismo contido em contador 2
          // Display 2 responsavel por imprimir o valor das unidades
          // Display 1 responsavel por imprimir o valor das dezenas

          count1++; // Incrementa no contador 1
          tempo++; // Incrementa na variavel tempo

          delay(1000); // Intervalo de tempo de 1 segundo

        } else { // Senao
          count1 = 0; // Zera contador 1
          count2++; // Incrementa no contador 2
          if (count2 > 9) { // Se contador 2 for menor que 9
            count2 = 0; // Zera contador 2
          }
        }

        if (tempo == TEMPO_DESEJADO + 1) { // Se a variavel tempo for igual a variavel TEMPO_DESEJADO somada em uma unidade

          digitalWrite(PINO_BUZZER, HIGH); // Liga o buzzer
          delay (1000); // Espera de um 1 segundo
          digitalWrite(PINO_BUZZER, LOW); // Desliga o buzzer

          displays.Off(0); // Comando para zerar as informacoes contidas nos displays
        }
      }
    }
  }
}

Entendendo o Código

Primeiramente, foram definidos os pinos do microcontrolador onde estão conectados o botão e o buzzer, através das variáveis PINO_BOTAO e PINO_BUZZER, respectivamente. Ainda nas declarações globais, declaramos a variável TEMPO_DESEJADO, que será responsável por controlar o fim da contagem de tempo. Em seguida, na configuração do programa, os pinos do buzzer e do botão são configurados como entrada e saída, ou seja, na entrada, o botão que é responsável pelo acionamento do contador, e na saída, o buzzer que irá disparar assim que a contagem atingir o valor determinado.

const int PINO_BOTAO = 7; // Pino definido para o botao disparador
const int PINO_BUZZER = 8; // Pino definido para o buzzer

pinMode(PINO_BOTAO, INPUT); // Pino conectado ao botao configurado como entrada
pinMode(PINO_BUZZER, OUTPUT); // Pino conectado ao buzzer configurado como saida

No loop do programa, a princípio, temos a leitura do botão. Para isso é necessário o uso do debounce na leitura, pois ele é utilizado para termos certeza que o botão foi pressionado.

Debounce é um estrutura de código que é utilizada como um filtro de ruídos. Ela é baseada em um breve intervalo de tempo (30 milissegundos, por exemplo) entre laços "if". Deste modo, é garantido que a leitura feita pelo microcontrolador não se trata de um ruído elétrico, e sim que o botão pressionado intencionalmente.

if (digitalRead(PINO_BOTAO)) { // Debounce garantindo que o botao esta realmente pressionado e que o pulso nao foi um ruido
  delay(30); // Filtra ruidos abaixo de 30 milissegundos
  if (digitalRead(PINO_BOTAO)) { // Se o pino botao realmente foi acionado
  }
}

Caso o botão tenha sido pressionado, zeramos os contadores e criamos a variável tempo com o valor 0, e que será incrementada juntamente com o contador 1. A variável tempo é utilizada em um laço "while", que garante que a lógica de contagem de 0 a 99 seja executada enquanto essa variável for menor que o valor definido pela variável TEMPO_DESEJADO, somada em uma unidade. Note que neste novo código, juntamente com a incrementação da variável do contador 1, também incrementamos em uma unidade a variável tempo através do comando tempo++.

count1 = 0; // Zera contador 1
count2 = 0; // Zera contador 2
int tempo = 0; // Variavel tempo, usada na funcao while

while (tempo < TEMPO_DESEJADO + 1)  { // Enquanto o tempo for menor que o tempo desejado somado em uma unidade

  if (count1 < 10) { // Se o contador 1 for menor que 10, executa
    displays.Print(count1, 2); // E impresso no display 2 o algarismo contido em contador 1
    displays.Print(count2, 1); // E impresso no display 1 o algarismo contido em contador 2
    // Display 2 responsavel por imprimir o valor das unidades
    // Display 1 responsavel por imprimir o valor das dezenas

    count1++; // Incrementa no contador 1
    tempo++; // Incrementa na variavel tempo

    delay(1000); // Intervalo de tempo de 1 segundo
}

Por fim, inserimos a condição if( tempo == TEMPO_DESEJADO + 1 ), que verifica se a contagem de tempo pela variável tempo está igual ao valor definido pela variável TEMPO_DESEJADO, somada em uma unidade. Caso essa condição seja verdadeira, o buzzer é acionado por um segundo, indicando o fim da contagem.

if (tempo == TEMPO_DESEJADO + 1) { // Se a variavel tempo for igual a variavel TEMPO_DESEJADO somada em uma unidade
  digitalWrite(PINO_BUZZER, HIGH); // Liga o buzzer
  delay (1000); // Espera de um 1 segundo
  digitalWrite(PINO_BUZZER, LOW); // Desliga o buzzer

  displays.Off(0); // Comando para zerar as informacoes contidas nos displays
}

Vale lembrar que, caso você queira alterar o tempo do disparo, terá que alterar o valor da variável TEMPO_DESEJADO de acordo com o intervalo em segundos que você quer controlar.

O Que Deve Acontecer

Ao carregar o programa para a placa, os displays ficarão desligados. Assim que dermos um pulso no pushbutton, o timer iniciará a contagem. Assim que essa contagem chegar a 30, o buzzer irá acionar por 1 segundo. Abaixo usamos um LED para indicar que o buzzer foi acionado. Vale lembrar que, para o desenvolvimento destes GIFs, diminuímos o intervalo de contagem.

Resultado Final

Comments

To make comments you must be logged in. Login.

You are not registered yet? Register Now!

filiperhodes
date

Sent 2022-09-28 23:34:09

Pessoal, boa noite.
Modulo antigo e engavetado ha anos.
A maior dificuldade pelo que entendi é simplesmente usar os displays para mostrarem numeros com mais de um digito de forma facil e simples.
Se uma variavel tem um valor maior que 9, como dar display em dois modulos 3 ou mais deste valor ?
Vocês poderiam facilitar a vida do cliente, principalmente os mais novatos,  e colocar um sketch exemplo como fazer isso.
Ou seja, desmembrar um valor em digitos para variaveis distintas, podendo assim usar os modulos para vlr mais de 1 digito.
É resolver uma limitação da biblioteca ou mesmo do modulo.

Giovanni5

Sent 2022-09-29 14:49:42
filiperhodes

A função "Print()" da biblioteca pode ser usada somente com um número de até 10 dígitos (um para cada módulo da linha, que pode ser de no máximo 10 módulos em série), ou seja, para exibir um número de 3 dígitos por exemplo, basta usar o comando <displays.Print(123)>, por exemplo para 3 módulos interligados. Esta é uma maneira simples de exibir números extensos. Entretanto, se a linha tiver mais módulos do que dígitos no número, os últimos displays da linha ficaram desligados. Neste caso, é recomendada uma "formatação" na exibição, como feito no exemplo deste tutorial.

Pops

Sent 2021-08-26 15:06:57

Acredito que o mal entendido está em vocês acharem que quero um sketch personalizado ou preciso me aperfeiçoar! Os displays são itens insignificantes no meu projeto. Eu comprei 4 displays e só queria fazê-los funcionar, porém isso não consta dos exemplos. Finalmente percebi que o código descrito como exemplo é prolixo, confuso e pouco prático para mais displays. Abandonei a lógica proposta e parti do zero, criando um sketch simples, intuitivo e prático para a inclusão de mais displays. Enfim, consegui resolver, infelizmente sem a ajuda de vocês. Cancelo agora minha inscrição na loja!

Pops

Sent 2021-08-25 19:24:13

A lógica para  2 módulos eu entendi ! São justamente essas "condições" que você cita que não estou conseguindo aplicar.  Mas tudo bem, percebi que você também não consegue. Desculpe o incômodo, só pedi ajuda pois imaginei que, como criaram o produto, seria correto colocar exemplos de seu funcionamento até o limite de módulos possível. Percebi também que, pelas respostas a outras perguntas nos comentários, você, Giovanni, não é muito chegado em resolver os problemas dos clientes. Uma pena, pois difere das demais empresas do ramo.

Francois

Sent 2021-08-26 12:54:17
Pops

@Pops, sentimos pelo seu descontentamento mas parece que houve um mal-entendido. Esse tutorial, assim como diversos outros, é sobre projetos básicos usando um produto, para entender como usá-lo de uma forma mais prática. Nesse caso, temos o módulo Display Serial para exibir uma contagem.

Francois

Sent 2021-08-26 12:54:30
Pops

Infelizmente não desenvolvemos códigos personalizados. Contudo, sempre tentamos ajudar no direcionamento, como fez o @Giovanni5 anteriormente. Levamos em consideração todos os comentários que são feitos para melhorar os tutorias, mas, claro, não é possível atender todas as necessidades. Os tutoriais possuem seções que explicam os códigos, justamente para dar uma base para outros projetos. Entendemos que, uma vez entendida a explicação, essa base possa ser usada em conjunto com outros conhecimentos adquiridos (em programação, eletrônica, etc) para criar outras soluções. Essa é a cultura maker.

Francois

Sent 2021-08-26 12:54:45
Pops

Se você julgar interessante, podemos recomendar diversos sites que podem ser úteis para aperfeiçoar os conhecimentos em programação. Eles são indicados para todos programadores de todos os níveis.

Pops

Sent 2021-08-25 11:15:46

Na realidade, estou precisando apenas do loop para fazer funcionar os 4 módulos. Montei o sketch, mas travei na lógica e não estou conseguindo usar todos os módulos que comprei. Infelizmente não encontro dicas em outro local, pois eles são criação de vocês. Obrigado.

Giovanni5

Sent 2021-08-25 12:17:31
Pops

A lógica utilizada neste tutorial verifica os valores dos contadores das unidades e das dezenas, e quando um dos contadores alcança o seu limite máximo, (no caso se eles forem maior ou igual a 10 (>= 10)), o contador seguinte é incrementado. Você pode aproveitar essa lógica para implementar os contadores das centenas e dos milhares para os 4 displays, porém será necessário criar as condições para isso. Outra opção, talvez mais simples, é através da incrementação de um único contador, e a exibição direta do valor do contador para todos os displays (comando <displays.Print(1000)>, por exemplo).

Giovanni5

Sent 2021-08-25 12:18:24
Pops

Esta segunda opção tende a felicitar a lógica do código, mas não permite a customização de exibição dos displays, como é feito no código de exemplo.

Pops

Sent 2021-08-24 20:14:14

Estou tentando fazer o cronometro com 4 módulos, porém não estou conseguindo adaptar o exemplo dado de 2  de módulos. Vocês poderiam mostrar o sketch para os 4 módulos. Obrigado!

Giovanni5

Sent 2021-08-25 08:26:27
Pops

Infelizmente não temos um código de cronômetro com 4 displays para disponibilizar, mas agradecemos pela sugestão, iremos avaliar a possibilidade de desenvolver um tutorial para isso. De toda forma, a lógica de um cronômetro de 2 displays não deve ser muito diferente da lógica para um cronômetro de 4 displays, já que em ambos os casos é necessário implementar um contador. Como o sue projeto possui mais displays, serão necessárias mais condições de código para que o valor seja exibido da maneira que deseja, porém você pode aproveitar as condições já usadas no código deste tutorial como base.

godoi_2000
date

Sent 2021-03-28 01:42:57

Boa noite pessoal, adquiri recente 4 modulos do display serial, preciso escrever o valor de uma entrada analogica de 0 -1023 avarialndo de acordo com potenciomento, alguém tem algum exemplo e como escreve valores decimais?

Giovanni5

Sent 2021-03-29 08:04:37
godoi_2000

Infelizmente não temos um exemplo específico sobre essa aplicação, porém é possível desenvolvê-la usando a função "print()" da biblioteca do módulo (https://github.com/RoboCore/SerialDisplay), basicamente como se estivesse exibindo os valores no monitor serial.

cassio.setubal
date

Sent 2020-12-14 14:56:21

Boa tarde! Comprei 4 módulos de display serial, percebi que um deles fica piscando, pensei que fosse a programação e resolvi mudar a ordem dos módulos, mas o mesmo módulo continua a piscar, acendendo os segmentos e o ponto que deveriam ficar apagados. Como devo proceder?

Giovanni5

Sent 2020-12-14 15:18:13
cassio.setubal

Encaminhe um e-mail para suporte@robocore.net, com o número do seu pedido, uma foto em boa resolução da parte de trás do módulo (onde os componentes estão soldados), e um vídeo demonstrando o componente mencionado, para que possamos entender o que está acontecendo, e se há algum problema visível.

cassio.setubal
date

Sent 2020-12-14 10:20:04

Consegui fazer a contagem regressiva com 2 módulos, porém a contagem não encerra em 00. Qual será o erro?
#include <SerialDisplay.h> 

SerialDisplay displays(4, 5, 2);

byte count1 = 5;
byte count2 = 9; 

void setup() {
  displays.Off(0); 
}

void loop() {
  if (count2 >= 1) { 
    displays.Print(count1, 1);
    displays.Print(count2, 2);
    
    count2--; 
    delay(1000); 
  } 
  
  else { 
    displays.Print(count1, 1);
    displays.Print(count2, 2);
    if (count1 > 0) {
      count1--;
      count2 = 9;
      delay(10

Giovanni5

Sent 2020-12-14 10:42:54
cassio.setubal

Como você pode ver, o campo de comentários não é o melhor lugar para compartilhar códigos, por conta da sua limitação de caracteres. Para isso, nós recomendamos o "Fórum" (https://www.robocore.net/modules.php?name=Forums), que não possui limitação de caracteres, e que você pode, depois de postar a publicação, compartilhar o link para que nós e outros usuários tenham acesso ao código completo. Em relação ao erro do seu programa, isso deve estar atrelado à-lógica usada, e você terá que implementar uma condição que verifica se os dois contadores são iguais à zero para a exibição.

cassio.setubal
date

Sent 2020-12-12 19:58:25

Como faço pra fazer uma contagem regressiva e utilizando 4 módulos?

Giovanni5

Sent 2020-12-14 09:37:54
cassio.setubal

Para isso você deve usar uma lógica bem parecida com a utilizada neste tutorial, porém inversamente, decrementando os contadores a cada segundo. Além disso, você também terá de incluir mais 2 contadores ao código, e ajustar a lógica para que eles funcionem em conjunto.

Stoski
date

Sent 2020-08-13 22:13:44

Essa biblioteca funciona com ESP32?

Giovanni5

Sent 2020-08-14 08:33:27
Stoski

Sim, a biblioteca do módulo Display Serial é compatível com placas ESP32.