Calendário de Contagem Regressiva

Atualmente estou cursando o 7º período do Curso de Sistemas da Informação e já estou quase no fim do curso e porque não fazer um sistema de contagem regressiva para contar os dias até a formatura.

1º Passo- Os Monitores de 4 dígitos de 7 segmentos

O ponto de partida óbvio é familiarizar-se com os monitores de 7 segmentos de 4 dígitos.  Além da imagem do dispositivo físico, acima você também pode ver também o pin-out e o esquema para a unidade. Programar um Arduino para caracteres de exibição individuais é bastante simples, no entanto, obter palavras ou números inteiros para exibir ao mesmo tempo é onde fica interessante. Como qualquer exibição de 7 segmentos, números e alguns caracteres podem ser exibidos ativando diferentes combinações de segmentos com letras; a torção com uma unidade de 4 dígitos de 4 dígitos é que todos os segmentos individuais de cada dígito são amarrados juntos, o que cada dígito tem apenas ' s próprio cátodo comum ou anodo para controlar separadamente. Na realidade, a única maneira de fazer com que essas unidades exibam uma palavra ou um número ainda é um dígito por vez; no entanto, os dígitos são ligados e desligados tão rápido que também o olho humano parece estar ligado o tempo todo.

2º Passo - Entendendo (e Usando) Portas do Arduino

Para evitar ter que usar milhares de comandos "digitalWrite" para ligar e desligar todas as combinações que eu precisaria, decidi me familiarizar com o uso de portas na plataforma Arduino. Com este comando (ex: PORTA = B01110101;) oito pinos de E / S digitais podem ser ligados e desligados simultaneamente com um 1 sendo equivalente a escrever um "HIGH" para esse pino e um 0 sendo o mesmo que escrever um "LOW" para o pino. Cada porta corresponde a 8 pinos no Arduino e pode ser escrita em binário (como eu usei) ou hexadecimal. Um exemplo fácil de ver são as portas F e K no Arduino Mega mostradas na pinagem acima, com o PORTF correspondendo aos pinos analógicos A0-A7 e PORTK correspondendo aos pinos analógicos A8-A15. Muitas graças à comunidade Adafruit por seu trabalho em ESTE pinagem espetacular!

3º Passo - Montagem

Embora difícil de ver nas imagens acima, eu decidi que o layout mais lógico para a programação que estava por vir era dividir cada um dos 7-segmentos de 4 dígitos em metade superior e inferior e então atribuir cada metade a uma porta específica. Isso permitiria que eu facilmente analisasse o número necessário e, em seguida, ativasse os segmentos apropriados com uma saída binária para a porta em questão. Usar a versão hexadecimal do comando port teria feito com que cada comando (na verdade, o array 2D que o comando está chamando) fosse mais curto, mas parecia mais fácil ver as combinações alta / baixa ao dispor o código versus ter que converter essas mesmas combinações em hexadecimal. mesmo que o código seja mais compacto a longo prazo. Para ajudar no processo, criei um gráfico para mostrar quais dígitos / segmentos estavam conectados a qual atribuição de porta.

4º Passo - O código - CountUpDownTimer

Depois de várias tentativas fracassadas de executar uma série de loops for aninhados para controlar o tempo e as exibições, comecei a analisar o processamento paralelo conforme se aplica ao Arduino. Eventualmente me deparei com uma biblioteca preexistente chamada "CountUpDownTimer" que está disponível AQUI no Arduino Playgound. Esta biblioteca executa o tempo para você em segundo plano, permitindo que você chame horas, minutos e segundos quando necessário. Esses valores são então passados ​​como parâmetros para uma matriz que ativa os segmentos apropriados para exibir o número correspondente. A única complicação (além de criar o array - mais sobre isso) foi que eu tive que modificar a biblioteca para adicionar o método "ShowDays" que não fazia parte do código original.

 #include <CountUpDownTimer.h>  
 CountUpDownTimer T (DOWN, HIGH); // Cria o objeto timer  
 void setup () {  
 // Configurando todos os pinos digitais como saídas  
  para (int i = 3; i <= 53; i ++)  
  pinMode (i, OUTPUT);  
 // Configurando todos os pinos analógicos como saídas   
  para (int a = A0; a <= A15; a ++)  
  pinMode (a, OUTPUT);   
 T.SetTimer (52,07,17,00); // (dias, horas, minutos, segundos)  
 T.StartTimer ();   
 }  
 void loop () {  
 T. Timer ();  
 int stepDelay = 50;  
 long sm = T.ShowMinutes ();  
 long sh = T.ShowHours ();  
 sd longo = T.ShowDays ();  
   para (int c = 0; c <4; c ++) {  
    PORTB = upperArray [sm] [c];  
    PORTL = lowerArray [sm] [c];  
    PORTA = upperArray [sh] [c];  
    PORTC = lowerArray [sh] [c];  
    PORTF = upperArray [sd] [c];  
    PORTK = lowerArray [sd] [c];  
    delayMicroseconds (stepDelay);  
   }  
 }  

5º Passo - O Código - Matriz 2D

Os valores para acionar as portas foram colocados em uma matriz 2D separada que é dividida em duas metades, uma para a parte superior da tela e outra para a parte inferior. As atribuições de portas baseiam-se nos pinos da tela, com cada coluna representando o dígito correspondente. A chave aqui é aplicar as combinações adequadas de altos e baixos aos segmentos individuais e ao catodo comum adequado para cada dígito sucessivo. O array 2D tem 270 linhas de comprimento para representar todo o ano letivo e quatro colunas de largura para os quatro dígitos em cada tela. Embora as horas e minutos nunca chamem a maioria da matriz, parece mais fácil usar a mesma estrutura para orientar essas exibições em comparação a uma matriz personalizada para cada seção. As primeiras linhas da metade superior e inferior são mostradas abaixo.

 byte upperArray [270] [4]  
  {B00011111, B00111011, B00111101, B00111111}, // 00u  
  {B00011111, B00111011, B00111101, B00100111}, // 01u  
  {B00011111, B00111011, B00111101, B00110111}, // 02u  
  {B00011111, B00111011, B00111101, B00110111}, // 03u  
  {B00011111, B00111011, B00111101, B00101111}, // 04u  
  {B00011111, B00111011, B00111101, B00111110}, // 05u  
  {B00011111, B00111011, B00111101, B00111110}, // 06u  
  {B00011111, B00111011, B00111101, B00110111}, // 07u  
  {B00011111, B00111011, B00111101, B00111111}, // 08u  
  {B00011111, B00111011, B00111101, B00111111}, // 09u  
  {B00011111, B00111011, B00100101, B00111111}, // 10u  

 byte lowerArray [270] [4] {  
  {B00110101, B00110101, B00110101, B00110100}, // 00  
  {B00110101, B00110101, B00110101, B00000100}, // 01  
  {B00110101, B00110101, B00110101, B00110010}, // 02  
  {B00110101, B00110101, B00110101, B00010110}, // 03  
  {B00110101, B00110101, B00110101, B00000110}, // 04  
  {B00110101, B00110101, B00110101, B00010110}, // 05  
  {B00110101, B00110101, B00110101, B00110110}, // 06  
  {B00110101, B00110101, B00110101, B00000100}, // 07  
  {B00110101, B00110101, B00110101, B00110110}, // 08  
  {B00110101, B00110101, B00110101, B00010110}, // 09  
  {B00110101, B00110101, B00000101, B00110100}, // 10   

6º Passo - A tela LCD - Um pensamento posterior.

Inicialmente, não pretendia incluir a tela LCD exibindo estatisticamente a data / hora da conclusão da contagem regressiva; no entanto, quando comprei a base para o projeto, havia um espaço aberto aproximadamente do tamanho de uma pequena placa de ensaio, portanto, parece uma adição lógica ao projeto. O monitor é um monitor branco-em-azul monocromático padrão de 16x2 que também veio de um kit Elegoo. Além da fiação adcional para as linhas de dados e controle, as modulações de código eram simples; Eu adicionei as funções do pré-processador, incluindo a biblioteca e definindo os pinos que estavam sendo usados ​​para cada conexão necessária, bem como o código para exibir a mensagem estática na configuração void, de modo que fosse executada apenas uma vez e não afetasse o tempo da configuração. contador. Ambas as modificações são mostradas abaixo:

 #include <LiquidCrystal.h>  
 const int rs = 17, en = 16, d4 = 21, d5 = 20, d6 = 19, d7 = 18; <br> LiquidCrystal lcd (rs, en, d4, d5, d6, d7);  

 lcd.begin (16, 2); <br> lcd.setCursor (0, 0);  
 lcd.print ("Contagem regressiva termina:");  
 lcd.setCursor (0, 1);  
 lcd.print ("30/05/19 às 15:10");  

7º Passo - Conclusão - Problemas e Lições

As seções problemáticas deste projeto foram de longe as tediosas. Primeiro, no lado do hardware, estava fazendo a fiação parecer perfeita para as mais de 40 linhas de dados que eram necessárias; Em seguida, foi criada a matriz 2D que contém as combinações alta e baixa necessárias para exibir os números apropriados. Uma pequena modificação de hardware que tive que fazer foi ajustar o tamanho dos resistores limitadores de corrente que eu estava usando no quarto dígito de cada tela; devido ao momento (e assumir a persistência da visão), esse dígito sempre parecia um pouco mais brilhante do que os outros, então eu aumentei esse valor até que a aparência de todos os quatro dígitos parecesse uniforme. Tenho certeza de que provavelmente há uma maneira mais elegante de conseguir isso com algum tipo de compartilhamento de tempo ou multiplexação.