Ir ao conteúdo
Regras do Clube do Hardware

Números grandes display lcd

keven.i3

Por keven.i3
em Microcontroladores

 Compartilhar

Posts recomendados

keven.i3
 

keven.i3

Postado
Postado

Oi amigos, criei o tópico com a intenção de além de poder concluir meu projetinho, poder ajudar várias pessoas que também estão atras disso.

 

FG7T52WGJHVKYW2.MEDIUM.jpg

 

Andei pesquisando na internet e achei um projeto de um relógio que utiliza essas fontes.( está em anexo ), utiliza um 16f628a, porém não possui o arquivo do proteus para simular. tentei utilizar a biblioteca porém não tive sucesso, se alguém estiver com vontade de dar uma analisada nos arquivos, ou possuir uma biblioteca que possibilite isso.. agradeço antecipadamente

 

16f628alargelcd.zip

aphawk
 

aphawk

Postado
Postado

@keven.i3,

Eu fiz isso, mas em linguagem Basic, para a linha Atmega. Se voce quiser posso postar o programa fonte em Basic.

O truque é apenas criar 8 novos simbolos gráficos, usando a Ram interna do LCD reservada para isso. Aí, voce cria uma tabela indicando quais simbolos serão usados nas duas linhas e tres colunas ( total de 6 para cada caractere ), e pronto.

Paulo

  • Curtir 1
keven.i3
 

keven.i3

Postado
  • Autor
Postado

 @aphawk

como posiciona-los na tela? manualmente?  já criei os characteres espececiais:

const char Linha_0[] = {0x9F,0x9F,0x9F,0x9F,0x9F,0x9F,0x9F,0x9F,0x9F,0x9F,0x9F};void Ex_LCD_0(char Ex_x, char Ex_y)     {     char f;     lcd_send_byte(0,0x40);     for (f = 0; f<=10; f++) lcd_send_byte(1,Linha_0[f]);     lcd_gotoxy(Ex_x, Ex_y); lcd_putc(0);     }     const char Linha_1[] = {0x5F,0x5F,0x5F,0x40,0x40,0x40,0x40,0x40};void Ex_LCD_1(char Ex_x, char Ex_y)     {     char f;     lcd_send_byte(0,0x48);     for (f = 0; f<=7; f++) lcd_send_byte(1,Linha_1[f]);     lcd_gotoxy(Ex_x, Ex_y); lcd_putc(1);     }     const char Linha_2[] = {0x40,0x40,0x40,0x40,0x40,0x5F,0x5F,0x5F};void Ex_LCD_2(char Ex_x, char Ex_y)     {     char f;     lcd_send_byte(0,0x50);     for (f = 0; f<=7; f++) lcd_send_byte(1,Linha_2[f]);     lcd_gotoxy(Ex_x, Ex_y); lcd_putc(2);     }     const char Linha_3[] = {0x9F,0x9F,0x80,0x80,0x80,0x80,0x9F,0x9F};void Ex_LCD_3(char Ex_x, char Ex_y)     {     char f;     lcd_send_byte(0,0x58);     for (f = 0; f<=7; f++) lcd_send_byte(1,Linha_3[f]);     lcd_gotoxy(Ex_x, Ex_y); lcd_putc(3);     }

e para mandar a tela:

Ex_LCD_0(5,1);Ex_LCD_0(5,2);Ex_LCD_1(4,1);Ex_LCD_2(4,2);Ex_LCD_2(6,2);

mas ainda não vi uma forma de organizar isso na tela para cada número, por exemplo se eu for pegar o valor de uma variável:

printf(lcd_putc,"%lu", X);

por exemplo, tem alguma ideia para me auxiliar?

 

 

grato até o momento

aphawk
 

aphawk

Postado
Postado

@keven.i3,

 

Eu criei uma tabela, com 6 valores para cada numeral; os primeiros 3 são os caracteres que formam a linha de cima, e os próximos tres são os caracteres da linha de baixo. Na verdade eu só tenho 4 posições possiveis para escrever os caracteres. Chamando a posição de N, onde N vai de 1 a 4, eu criei uma outra tabela que me dá a coluna inicial X a ser escrito o caracter, e essa posição é a mesma para as duas linhas.

 

Assim, sabendo a coluna X, pesquiso a minha tabela com os seis caracteres, e escrevo os tres primeiros na linha 1 e posições X, X+1 e X+2 ; desço para a segunda linha e pego os outros tres caracteres e escrevo também nas posições X, X+1 e X+2 .

 

Os dois pontos são fixos, o que eu fiz de diferente foi a cada meio segundo eu apagava esses dois pontos e depois acendia de novo, ficava piscando, indicando os segundos.

 

Desculpe não poder ajudar com o código em C, não entendo nada dessa linguagem.

 

Espere um pouco que logo aparece alguém para te ajudar na linguagem!

 

Paulo

MatheusLPS
 

MatheusLPS

Postado
Postado

@keven.i3

 

Já estou finalizando um exemplo aqui para você de acordo com a ideia do colega Paulo.

 

EDIT:

 

Desculpe a demora.

 

Veja que por padrão, os controladores HD44780 suportam no máximo 8 caracteres custom na memória. Só que o Proteus só pode estar com BUG pois só consigo criar 7 caracteres extras.

 

Por isso demorei para postar aqui. Estava lendo o datasheet do HD44780 par me certificar do limite de 8. Só posso por a culpa no Proteus. Não tem como eu testar em um LCD na placa agora. Se não eu já tinha tirado a dúvida.

 

Bom, outra coisa. Vou te mostrar abaixo como ficou o resultado no Proteus da fonte grande. Diga-se de passagem, ficou feio. Muito feio. Mas isso é do modelo usado do Proteus. Ele utiliza um LCD com a linha muito deparada da linha de baixo. Dessa forma, acredito que na prática ficará bom.

 

Resultado:

 

R6jJVYQ.png

 

Código:

 

#include <18F2550.h> #fuses NOMCLR,XT,NOWDT,NOPROTECT,NOLVP,NODEBUG #use delay(clock=4000000) #define use_portb_lcd TRUE#include <lcd.c> void lcd_load_custom_chars(void);void escreve_numero(int8 *numero, linha); int8 num_1[]={   2, 5, 1,   3, 5, 3}; int8 num_2[6]={   2, 4, 5,   5, 3, 3}; int8 num_3[6]={   2, 4, 5,   3, 3, 5}; int8 num_4[6]={   5, 3, 5,   1, 1, 5}; int8 num_5[6]={   5, 4, 2,   3, 3, 5}; int8 num_6[6]={   5, 4, 2,   5, 3, 5}; int8 num_7[6]={   2, 2, 5,   1, 1, 5}; int8 num_8[6]={   5, 4, 5,   5, 3, 5}; int8 num_9[6]={   5, 4, 5,   3, 3, 5}; int8 num_0[6]={   5, 2, 5,   5, 3, 5}; void escreve_numero(int8 *numero, int8 linha){   int8 j;   int8 k;   int8 aux= 0;      for (k=1;k<=2;k++)   {      for (j=0;J<=2;j++)      {         lcd_gotoxy(linha + j,k);            lcd_putc(numero[aux]);         aux++;      }   }     } void main(void)                                                       {   int8 linha;      lcd_init();   lcd_load_custom_chars();   delay_ms (50);      linha= 1;      escreve_numero(num_0,linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_1, linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_2, linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_3, linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_4, linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_5, linha);   delay_ms(1000);      linha+= 4;   escreve_numero(num_6, linha);   delay_ms(1000);      linha+= 4;   escreve_numero(num_7, linha);   delay_ms(1000);   linha+= 4;   escreve_numero(num_8, linha);   delay_ms(1000);      linha+= 4;   escreve_numero(num_9, linha);   delay_ms(1000);         while (TRUE)                                                          {      }} const int8 lcd_custom_chars[]={    0b00011111,    //2 em cima (0)          0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,    //nada (1)   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000      0b00011111,    //3 em cima (2)   0b00011111,   0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,    //3 em baixo (3)   0b00000000,   0b00000000,   0b00000000,   0b00011111,   0b00011111,   0b00011111,   0b00000000,      0b00011111,    //2 em cima e 2 em baixo (4)   0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00011111,   0b00011111,   0b00000000,      0b00011111,    //completo  (5)   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00000000,      0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000};      void lcd_load_custom_chars(void){   int8 i;   int8 teste;      // Escolher o contador apontando para o endereço 0 da CGRAM   lcd_send_byte(0, 0x40);       // Mandar os caracteres custom para a CGRAM   // Suporta no máximo 8 caracteres. Ver o datasheet do controlador HD44780   // para mais detalhes   for(i= 0; i < sizeof(lcd_custom_chars); i++)   {      lcd_send_byte(1, lcd_custom_chars[i]);   }      // Consifura o endereço novamente para a DDRAM   lcd_send_byte(0, 0x80);}

 

Falou

  • Curtir 1
keven.i3
 

keven.i3

Postado
  • Autor
Postado

@aphawk valeu pela ajuda ,grato mesmo

@MatheusLPS cara simplesmente fantástico, valeu, se puder me explicar como  funciona a rotina escreve_numero, que não entendi muito bem e porque o linha+=4;

mas de qualquer forma valeu até agora, só quero entender, para eu poder fazer as adaptações, grato

 

 

escreve_numero(num_6, linha);
   delay_ms(1000);   
   linha+= 4;

MatheusLPS
 

MatheusLPS

Postado
Postado

@keven.i3

 

O linha+=4; serve para escrever os numeros um do lado do outro no exemplo que postei.

 

você pode omitir essa linha.

 

Veja que a funcao exige dois valores:

 

escreve_numero(num_6, linha);

 

O numero que você deseja e a linha na qual o numero deverá aparecer.

 

Falou

  • Curtir 1
keven.i3
 

keven.i3

Postado
  • Autor
Postado

@MatheusLPS

ah agora sim entendi, cara agora eu to estudando como usar isto para printar uma variavel, você tem alguma ideia? eu tava pensando em pegar por exemplo:

1230 fazer algum tipo de conta matématica para separar os 4 números e escrever, você tem alguma ideia mais simples? e por exemplo ali

escreve_numero(num_1, linha);
se eu quiser fazer por exemplo: escreve_numero(num_VARIAVELX, LINHA);como posso fazer para o número ser definido por uma variável?

ESQUEMA PARA TRANSFORMAR UM NUMERO EM 4:

 

n1= rpm/1000;n2= rpm - (n1*1000) /100;n3= rpm - (n1*1000) - (n2*100) / 10;n4= rpm - (n1*1000) - (n2*100) - (n3*10);

Só preciso saber como substituir o número por uma variável.

valeu cara de verdade

MatheusLPS
 

MatheusLPS

Postado
Postado

@keven.i3

 

Estou viajando e não estou com o compilador em mãos. Mas vou te passar uma ideia e você desenvolve ela.

 

Imaginei em um primeiro momento algo do tipo:

 

Considerando que você já separou os algarismos em n1, n2, n3 e n4:

 

Crie uma funcao do tipo:

void alguma_funcao(int nx, int linha){    switch nx:    {        case 1:        {            escreve_numero(num_1, linha);            break;        }                case 2:        {            escreve_numero(num_2, linha);            break;        }                case 3:        {            escreve_numero(num_3, linha);            break;        }    }}

Depois em alguma parte do seu código você chama ela assim:

alguma_funcao(n1, linha);linha = proxima_linha;alguma_funcao(n2, linha);linha = proxima_linha;alguma_funcao(n3, linha);linha = proxima_linha;alguma_funcao(n4, linha);

Falou

  • 10 meses depois...
cesarlg
 

cesarlg

Postado
Postado

ola pessial. Venho seguindo os passos indicados no topico,, porém sem êxito. Minha variavel q assume valor de até 9999 numa int16 e desmembrei cada digito como o keven citou. Ate aqui td bem. O problema vem em corelacionar os digitos com programação q Matheuslp passou. Nao consigo relacionar n1 com num-1.. ou nao entendi bem.. tem como alguém dar uma esplicacao detalhada? Obrigado

MatheusLPS
 

MatheusLPS

Postado
Postado

@cesarlg

Tentou usar o código que passei logo antes do seu post? está bem direto.

Me mostre um programa básico onde vi pega um número qualquer e desmembra ele.

Depois de desmembrado é só jogar na função criada como mostrei.

Falou

cesarlg
 

cesarlg

Postado
Postado

@MatheusLPS

Montei aqui e a principio da um monte de erros, mas na vdd ainda nao entendi a ideia da coisa, apesar de ver q é simples <desculpa>

vou postar o codigo, para você ir me guiando se puder.. aguardo  e obrigado novamente

Em Tempos .... mudei um pouco a linha de raciocinio, no proteus funciona. me parece lento, mas codigo acredito q poderia ficar mais compacto e alem do mais teria como colocar mais um digito (nº1) para alcancar rpm até 19999 ( se tiver como) 


#include <16F877a.h>            //O PIC utilizado, obrigatório!
 
#FUSES NOWDT                    //Sem Watch dog, evitando reset
#FUSES XT                       //Crystal de oscilação igual a 4mhz
#FUSES PUT                      //Tempo de início do PIC
#FUSES NOPROTECT                //Codigo sem proteção de leitura, software livre!
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
 
#use delay(clock=4000000)     
#include <lcd.c>
 
int16 pulso_total;
int16 pulsos;
int16 rpm;
int8 aux;
int8 escreve_numero;
int16 n1, n2, n3, n4;
int nx;
int8 linha;
 
 
 
#int_TIMER1              
void temp1s(void)        
{  
    nx++;
   if(nx>1){nx = 1;}
   aux++;
   if (aux == 1)
   {   
      pulso_total = pulsos ;
      pulsos = 0;
      aux = 0;
      rpm =  pulso_total * 60 *2; 
      
      n1= (rpm / 1000);
      n2= (rpm - (n1 * 1000))/ 100;
      n3= (rpm - (n1 * 1000) - (n2 * 100))/ 10;
      n4= (rpm - (n1 * 1000) - (n2 * 100) - (n3 * 10));      
   }      
   set_timer1 (3036);      
}
 
#int_ccp1
void trata_pulsos(void)
{
 
   pulsos++;
}
 
void lcd_load_custom_chars(void);
void escreve_numero(int8 *numero, linha);
 
int8 num_1[]=
{
   2, 5, 1,
   3, 5, 3 
};
 
int8 num_2[6]=
{
   2, 4, 5,
   5, 3, 3
};
 
int8 num_3[6]=
{
   2, 4, 5,
   3, 3, 5
};
 
int8 num_4[6]=
{
   5, 3, 5,
   1, 1, 5
};
 
int8 num_5[6]=
{
   5, 4, 2,
   3, 3, 5
};
 
int8 num_6[6]=
{
   5, 4, 2,
   5, 3, 5
};
 
int8 num_7[6]=
{
   2, 2, 5,
   1, 1, 5
};
 
int8 num_8[6]=
{
   5, 4, 5,
   5, 3, 5
};
 
int8 num_9[6]=
{
   5, 4, 5,
   3, 3, 5
};
 
int8 num_0[6]=
{
   5, 2, 5,
   5, 3, 5
};
 
void escreve_numero(int8 *numero, int8 linha)
{
   int8 j;
   int8 k;
   int8 aux= 0;
   
   for (k=1;k<=2;k++)
   {
      for (j=0;J<=2;j++)
      {
         lcd_gotoxy(linha + j,k);   
         lcd_putc(numero[aux]);
         aux++;
      }
   }     
}
 
void main(void)                                                       
{
   lcd_init();
   setup_ccp1(CCP_CAPTURE_RE);   
   setup_timer_1 (T1_INTERNAL | T1_DIV_BY_8);   //Configuração do Timer1 para clock interno = 1E6 dividido por 8
   enable_interrupts(INT_CCP1);
   enable_interrupts(INT_TIMER1);               //Habilita interrupção timer1
   enable_interrupts(global);                   //habilita interrupcão global 
   set_timer1 (3036);                           //Preload do Timer1  
   
   lcd_load_custom_chars();
   delay_ms (50);   
   linha= 1;
        
   while (TRUE)                                                       
   {
    switch(nx)
    {
        case 1:
        {
            if (n1 == 0){escreve_numero(num_0, 1);}
            if (n1 == 1){escreve_numero(num_1, 1);}
            if (n1 == 2){escreve_numero(num_2, 1);}
            if (n1 == 3){escreve_numero(num_3, 1);}
            if (n1 == 4){escreve_numero(num_4, 1);}
            if (n1 == 5){escreve_numero(num_5, 1);}
            if (n1 == 6){escreve_numero(num_6, 1);}
            if (n1 == 7){escreve_numero(num_7, 1);}
            if (n1 == 8){escreve_numero(num_8, 1);}
            if (n1 == 9){escreve_numero(num_9, 1);}
          
        }
        
        case 2:
        {
            if (n2 == 0){escreve_numero(num_0, 5);}
            if (n2 == 1){escreve_numero(num_1, 5);}
            if (n2 == 2){escreve_numero(num_2, 5);}
            if (n2 == 3){escreve_numero(num_3, 5);}
            if (n2 == 4){escreve_numero(num_4, 5);}
            if (n2 == 5){escreve_numero(num_5, 5);}
            if (n2 == 6){escreve_numero(num_6, 5);}
            if (n2 == 7){escreve_numero(num_7, 5);}
            if (n2 == 8){escreve_numero(num_8, 5);}
            if (n2 == 9){escreve_numero(num_9, 5);}
            
        }
        
        case 3:
        {
            if (n3 == 0){escreve_numero(num_0, 9);}
            if (n3 == 1){escreve_numero(num_1, 9);}
            if (n3 == 2){escreve_numero(num_2, 9);}
            if (n3 == 3){escreve_numero(num_3, 9);}
            if (n3 == 4){escreve_numero(num_4, 9);}
            if (n3 == 5){escreve_numero(num_5, 9);}
            if (n3 == 6){escreve_numero(num_6, 9);}
            if (n3 == 7){escreve_numero(num_7, 9);}
            if (n3 == 8){escreve_numero(num_8, 9);}
            if (n3 == 9){escreve_numero(num_9, 9);}
            
        }
        case 4:
        {
            if (n4 == 0){escreve_numero(num_0, 13);}
            if (n4 == 1){escreve_numero(num_1, 13);}
            if (n4 == 2){escreve_numero(num_2, 13);}
            if (n4 == 3){escreve_numero(num_3, 13);}
            if (n4 == 4){escreve_numero(num_4, 13);}
            if (n4 == 5){escreve_numero(num_5, 13);}
            if (n4 == 6){escreve_numero(num_6, 13);}
            if (n4 == 7){escreve_numero(num_7, 13);}
            if (n4 == 8){escreve_numero(num_8, 13);}
            if (n4 == 9){escreve_numero(num_9, 13);}
          
        }
      
    }
}
 
   }
 
 
const int8 lcd_custom_chars[]=
{ 
   0b00011111,    //2 em cima (0)       
   0b00011111,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   
   0b00000000,    //nada (1)
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000
   
   0b00011111,    //3 em cima (2)
   0b00011111,
   0b00011111,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   
   0b00000000,    //3 em baixo (3)
   0b00000000,
   0b00000000,
   0b00000000,
   0b00011111,
   0b00011111,
   0b00011111,
   0b00000000,
   
   0b00011111,    //2 em cima e 2 em baixo (4)
   0b00011111,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00011111,
   0b00011111,
   0b00000000,
   
   0b00011111,    //completo  (5)
   0b00011111,
   0b00011111,
   0b00011111,
   0b00011111,
   0b00011111,
   0b00011111,
   0b00000000,
   
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000,
   0b00000000
};   
   
void lcd_load_custom_chars(void) // copiadooo
{
   int8 i;
   lcd_send_byte(0, 0x40); 
   for(i= 0; i < sizeof(lcd_custom_chars); i++)
   {
      lcd_send_byte(1, lcd_custom_chars);
   }   
    lcd_send_byte(0, 0x80);
}

  • Curtir 1
cesarlg
 

cesarlg

Postado
Postado

No post anterior eu repostei o codigo q ta funcionando. To achando muito lento a resposta .Outro ponto é pela questao de ficar a escala afetada alterei ficando assim

 if (aux == 2)   {         pulso_total = pulsos ;      pulsos = 0;      aux = 0;      rpm = pulso_total * 60 ;

mesmo assim a cada hz a mais na tela salta de 60 em 60.. alguma opiniao?

acho q tem q mudar o set timer , mas nao tenho certeza, diminuindo o tempo de captura, se sim o q altero? valeu

cesarlg
 

cesarlg

Postado
Postado

Magina, nao precisa pedir desculpa @keven.i3 . @aphawk  obrigado pela disposicao..

Realmente ainda nao finalizei  o projeto, veja ele esta funcional, mas dois problemas  q preciso corrigir mas nao com relação aos "caracteres maiores" e sim haver com a aquisicao de dados e e exposicao..

1. a leitura esta um pouco lenta em virtude de usar a base de tempo de 1seg, para depois fazer os calculos..

2. precisao do resultado, pois pego o HZ e na formula multiplico por 60, ou seja, tenho do RPM "degraus" muitos grandes. nao sei qual o metodo para melhorar isso.. tentei mudar o timer , mas mesmo assim la na formula tenho q compensar para mostrar o valor.

gostaria de opinioes. valeww

  • Curtir 1
keven.i3
 

keven.i3

Postado
  • Autor
Postado

@cesarlg beleza, vou te dar a ideia do negócio

// Variaveis big numbers long n1=0; long n2=0; long n3=0; long n4=0;   void lcd_load_custom_chars(void);void escreve_numero(int8 *numero, linha);int8 num_1[]={   2, 5, 1,   3, 5, 3}; int8 num_2[6]={   2, 4, 5,   5, 3, 3}; int8 num_3[6]={   2, 4, 5,   3, 3, 5}; int8 num_4[6]={   5, 3, 5,   1, 1, 5}; int8 num_5[6]={   5, 4, 2,   3, 3, 5}; int8 num_6[6]={   5, 4, 2,   5, 3, 5}; int8 num_7[6]={   2, 2, 5,   1, 1, 5}; int8 num_8[6]={   5, 4, 5,   5, 3, 5}; int8 num_9[6]={   5, 4, 5,   3, 3, 5}; int8 num_0[6]={   5, 2, 5,   5, 3, 5}; void escreve_numero(int8 *numero, int8 linha){   int8 j;   int8 k;   int8 aux= 0;      for (k=1;k<=2;k++)   {      for (j=0;J<=2;j++)      {         lcd_gotoxy(linha + j,k);            lcd_putc(numero[aux]);         aux++;      }   }     } void numeros(void){n1= rpm/1000;n2= (rpm - (n1*1000)) /100;n3= (rpm - (n1*1000) - (n2*100)) / 10;n4= (rpm - (n1*1000) - (n2*100) - (n3*10));}void escreve_1(int n1, int linha){switch (n1)    {        case 1:        {            escreve_numero(num_1, linha);            break;        }                case 2:        {            escreve_numero(num_2, linha);            break;        }                case 3:        {            escreve_numero(num_3, linha);            break;        }        case 4:        {            escreve_numero(num_4, linha);            break;        }        case 5:        {            escreve_numero(num_5, linha);            break;        }        case 6:        {            escreve_numero(num_6, linha);            break;        }        case 7:        {            escreve_numero(num_7, linha);            break;        }        case 8:        {            escreve_numero(num_8, linha);            break;        }        case 9:        {            escreve_numero(num_9, linha);            break;        }        case 0:        {            escreve_numero(num_0, linha);            break;        }                        }}    void escreve_3(int n3, int linha){switch (n3)    {        case 1:        {            escreve_numero(num_1, linha);            break;        }                case 2:        {            escreve_numero(num_2, linha);            break;        }                case 3:        {            escreve_numero(num_3, linha);            break;        }        case 4:        {            escreve_numero(num_4, linha);            break;        }        case 5:        {            escreve_numero(num_5, linha);            break;        }        case 6:        {            escreve_numero(num_6, linha);            break;        }        case 7:        {            escreve_numero(num_7, linha);            break;        }        case 8:        {            escreve_numero(num_8, linha);            break;        }        case 9:        {            escreve_numero(num_9, linha);            break;        }        case 0:        {            escreve_numero(num_0, linha);            break;        }                        }}void escreve_2(int n2, int linha){switch (n2)    {        case 1:        {            escreve_numero(num_1, linha);            break;        }                case 2:        {            escreve_numero(num_2, linha);            break;        }                case 3:        {            escreve_numero(num_3, linha);            break;        }        case 4:        {            escreve_numero(num_4, linha);            break;        }        case 5:        {            escreve_numero(num_5, linha);            break;        }        case 6:        {            escreve_numero(num_6, linha);            break;        }        case 7:        {            escreve_numero(num_7, linha);            break;        }        case 8:        {            escreve_numero(num_8, linha);            break;        }        case 9:        {            escreve_numero(num_9, linha);            break;        }        case 0:        {            escreve_numero(num_0, linha);            break;        }                        }}void escreve_4(int n4, int linha){switch (n4)    {        case 1:        {            escreve_numero(num_1, linha);            break;        }                case 2:        {            escreve_numero(num_2, linha);            break;        }                case 3:        {            escreve_numero(num_3, linha);            break;        }        case 4:        {            escreve_numero(num_4, linha);            break;        }        case 5:        {            escreve_numero(num_5, linha);            break;        }        case 6:        {            escreve_numero(num_6, linha);            break;        }        case 7:        {            escreve_numero(num_7, linha);            break;        }        case 8:        {            escreve_numero(num_8, linha);            break;        }        case 9:        {            escreve_numero(num_9, linha);            break;        }        case 0:        {            escreve_numero(num_0, linha);            break;        }                        }}
  //rotina para o main while(true) para escrever na tela.   linha=3;              // aqui você decide a coluna que começa   escreve_1(n1, linha);      linha+= 4;         escreve_2(n2, linha);      linha+= 4;        escreve_3(n3, linha);      linha+= 4;         escreve_4(n4, linha);
// CARACTERES E ROTINAconst int8 lcd_custom_chars[]={    0b00011111,    //2 em cima (0)          0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,    //nada (1)   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000      0b00011111,    //3 em cima (2)   0b00011111,   0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,    //3 em baixo (3)   0b00000000,   0b00000000,   0b00000000,   0b00011111,   0b00011111,   0b00011111,   0b00000000,      0b00011111,    //2 em cima e 2 em baixo (4)   0b00011111,   0b00000000,   0b00000000,   0b00000000,   0b00011111,   0b00011111,   0b00000000,      0b00011111,    //completo  (5)   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00011111,   0b00000000,      0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,      0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000};      void lcd_load_custom_chars(void){   int8 i;   int8 teste;      // Escolher o contador apontando para o endereço 0 da CGRAM   lcd_send_byte(0, 0x40);       // Mandar os caracteres custom para a CGRAM   // Suporta no máximo 8 caracteres. Ver o datasheet do controlador HD44780   // para mais detalhes   for(i= 0; i < sizeof(lcd_custom_chars); i++)   {      lcd_send_byte(1, lcd_custom_chars[i]);   }      // Consifura o endereço novamente para a DDRAM   lcd_send_byte(0, 0x80);}

caso tu não entenda o código , da o toque ai que te explico melhor, fiz este programa para mostrar rpm na tela também, valeu

  • Curtir 1
cesarlg
 

cesarlg

Postado
Postado

legal. entendi a ideia sim.. vou tentar implementar com essa sua linha de raciocinio. agora e qt a falta de "precisao ", até com relação ao tratamento do dado de leitura e formula p mostrar nesse codigo, aquele do meu ultimo post#?

valewsww

Visitante
Este tópico está impedido de receber novas respostas.
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

Ebook grátis: Aprenda a ler resistores e capacitores!

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!