PIC Aproveitando rotina 7 segmentos

[vtrx]

Preciso de ideias para aproveitar uma rotina para display de 7 segmentos(4 dígitos) para utilizar como um contador de tempo.

A rotina apresenta no Display um numero int entre 0 e 9999.

Fiz um esboço onde 200 representa 02:00 e vai diminuindo a contagem em 1.

Então quando for 199 ficará 159(01:59),99 fica 59(00:59) etc.

Fico comparando os valores para ajustar.

Deve existir um meio mais eficaz,creio eu.

Alguma ideia para não reinventar a roda?

Modulo utilizado.

https://www.curtocircuito.com.br/modulo-display-7-seg-4-dig-tm1637.html

[.if]

10 horas atrás, vtrx disse:

um meio mais eficaz,creio eu.

Em 03/05/2022 às 07:32, vtrx disse:

porque não vejo o código.

Perco o amigo mas não perco a oportunidade kk.. brinc .. claro.. Usando a bola de cristal de quinta (feira), vejamos...

É quase bem simples, amigo: basta segmentar/fatorar/decompor sua variável p.ex. 'seg' com valor máximo de 5999 segundos ou seja 99:59... quase cem minutos. Algo como:
 

segundo=seg%60; //de 0 a 59
minuto=seg/60; //de 0 a 99

 

Pra colocar no display 7 seg individual é o mesmo princípio da decomposição:

(considerei o argumento da função como index pra uma tabela com o desenho do dígito)
 

display3(minuto/10); //de 0 a 9
display2(minuto%10); //de 0 a 9
display1(segundo/10);
display0(segundo%10);

 

Tenta e me conta, ok? e conta comigo  1...2...3...4  (antes de responder àquele amiguinho do outro post que tentamos ajudar )

[vtrx]

Não sei como vou 'separar' os dígitos pois a rotina aceita como argumento um Int,mas postando a rotina talvez entenda a sua ideia,lembrando que o modulo usa uma comunicação parecida com I2C.

const char segmentMap[] = {
    0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, // 0-7
    0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71, // 8-9, A-F
    0x00
};
unsigned int Tempo=0;
#include <TM1637.H>
  ...
  void main()
{
 ...
   InitTM1637(2);
   Tempo = 200;
   tm1637DisplayDecimal(Tempo,1);
  ...
  }

 

//TM1637.H

#define CLK PIN_A0
#define DIO PIN_A1

void InitTM1637(char brightness);
void start(void);
void ask(void);
void stop(void);
void writeByte(unsigned char oneByte);
void tm1637DisplayDecimal(int v, int displaySeparator);
//
//-----------------------------------------------------------------------------
void InitTM1637(char brightness)
{
   start();
   writeByte(0x87 + brightness);
   ask();
   stop();
}
//-----------------------------------------------------------------------------
void start(void)
{
   output_high(clk);
   output_high(dio);
   Delay_us(2); 
   output_low(dio);
}
//-----------------------------------------------------------------------------
void ask(void)
 {
  output_low(clk);
  Delay_us(5);
  // while (dio); // We're cheating here and not actually reading back the response.
  output_high(clk);
  Delay_us(2);
  output_low(clk);
 }
//-----------------------------------------------------------------------------
void stop(void)
{
   output_low(clk);
   Delay_us(2);
   output_low(dio);
   Delay_us(2);
   output_high(clk);
   Delay_us(2);
   output_high(dio);
}
//-----------------------------------------------------------------------------
void writeByte(unsigned char oneByte)
{
   unsigned char i;
   
   for(i=0; i<8; i++)
     {
      output_low(clk);
      if(oneByte & 0x01)
         {
          output_high(dio);
         }
      else
         {
          output_low(dio);
         }
      Delay_us(3);
      oneByte = oneByte >> 1;
      output_high(clk);
      Delay_us(3); 
     }
}
//-----------------------------------------------------------------------------
void tm1637DisplayDecimal(int v, int displaySeparator)
{
    unsigned char digitArr[4];
    
    for (int i = 0; i < 4; ++i) {
        digitArr[i] = segmentMap[v % 10];
        if (i == 2 && displaySeparator) {
            digitArr[i] |= 1 << 7;
        }
        v /= 10;
    }
    start();
    writeByte(0x40);
    ask();
    Stop();
    Start();
    writeByte(0xc0);
    ask();
    for (int i = 0; i < 4; ++i) {
        writeByte(digitArr[3 - i]);
        ask();
    }
    Stop();
}

O legal da rotina é que voce não precisa preencher os espaço,ela preenche com zeros(0)automaticamente,1=0001.

[.if]

Numa rápida análise me parece que a função writeByte(digitArr[x]) é a que efetivamente imprime os desenhos no display e digitArr[ ] é a matriz indexável. Assim sendo, suponho que basta indexá-la com os meus dados decompostos la de cima. Algo como
 

digitArr[3]=minuto/10;
digitArr[2]=minuto%10;
digitArr[1]=segundo/10;
digitArr[0]=segundo%10;

 

e rodar a função

 

 

2 horas atrás, vtrx disse:

testar a noite.

 

#include <stdio.h>
unsigned int seg, segundo, minuto;
int main() {
    // Write C code here
    seg=5999;
    while (seg-->5990)
    {
        minuto=seg/60;
        segundo=seg%60;
        printf("%d",minuto/10);
        printf("%d:",minuto%10);
        printf("%d",segundo/10);
        printf("%d\n",segundo%10);
        sleep(1);
    }
    
    printf("\nBooooom!");
    
    return 0;
}

Testei o conceito em https://www.programiz.com/c-programming/online-compiler/

[vtrx]

Só vou poder testar a noite.

Vou ver também se consigo fazer um circuito no Proteus porque vou acabar quebrando algum terminal do micro de tanto tirar e por.