Ir ao conteúdo
  • Cadastre-se
Tarcisio Zewe Duarte

Arduino Display matricial de led 5x7, com registrador 74HC595 Microcontroladores

Recommended Posts

Bom dia pessoal, estou tendo um problema em um código que estou desenvolvendo para um contador de display matricial de leds, com cinco displays 5x7 para contar de 0 à 999. Um breve resumo do programa: Ele pega a função “millis” , divide por 1000, e depois grava este valor na variavel inteira “numero”. depois ele executa um laço “for”, onde pega esta variavel, divide por outra variavel inteira “fator”, e divide o resultado desta operação por “BASE”, a qual foi definida no inicio do programa por como sendo 10, e atribui este resultado a uma variável denominada “valor”. E ainda dentro deste laço “for”, ele compara por meio da condição “if” numero correpondente aos cinco digitos do display, e chama uma função para que transfere em um array do tipo “byte” chamado “led”, o caractere correspondente, dos caracteres correspondentes gravados no array do tipo “char matriz”. Despois uma outra função é chamada para pegar cada array “led” e transferir para o um array maior do tipo char 40x7 denominado “máscara” , com a sua devida posição de acordo com a contagem, e por último uma função é chamada para enviar os dados deste ultimo array 40x7 para cinco circuitos integrados 74HC595 registradores de deslocamento, os quais mandam a informação de suas saidas para as colunas dos cinco displays 5x7. Esta mesma função gera ainda os pulsos de clock e reset para um circuito integrado 4017, o qal faz a contagem das linhas e completa a multiplexagem dos display. Ao compilar este código, ele compila normalmente e não aparece nenhum erro. só que os cinco displays simplesmente não acendem. Não se trata de um problema de hardware, pois testei os cinco displays em um outro programa e eles funcionaram normalmente, igualmente com os circuitos integrados 74HC595. Ja o circuito integrado 4017 retirei de um outo circuito que havia montado e também esta funcionando normalmente. Abaixo segue em anexo o código, se alguem tiver tempo de analisar e me ajudar, agradeço:

#define ZERO {B01110000,B10001000,B10011000,B10101000,B11001000,B10001000,B01110000}
#define UM {B00100000,B01100000,B00100000,B00100000,B00100000,B00100000,B01110000}
#define DOIS {B01110000,B10001000,B00001000,B00010000,B00100000,B01000000,B11111000}
#define TRES {B01110000,B10001000,B00001000,B01110000,B00001000,B10001000,B01110000}
#define QUATRO {B00010000,B00110000,B01010000,B10010000,B11111000,B00010000,B00010000}
#define CINCO {B11111000,B10000000,B11110000,B00001000,B00001000,B10001000,B01110000}
#define SEIS {B00110000,B01000000,B10000000,B11110000,B10001000,B10001000,B01110000}
#define SETE {B11111000,B00001000,B00001000,B00010000,B00100000,B00100000,B00100000}
#define OITO {B01110000,B10001000,B10001000,B01110000,B10001000,B10001000,B01110000}
#define NOVE {B01110000,B10001000,B10001000,B01111000,B00001000,B00010000,B01100000}
#define ESPACO {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}

int latchPin = 10;
int clockPin = 13;
int dataPin = 11;
int clock = 9;
int Reset = 8;

const int numCaracteres = 10;
char matriz[numCaracteres][7][8] = {ZERO, UM, DOIS, TRES, QUATRO, CINCO, SEIS, SETE, OITO, NOVE};
byte led0[8][7];
byte led1[8][7] = {ESPACO};
byte led2[8][7];
byte led3[8][7] = {ESPACO};
byte led4[8][7];// columns x rows
char mascara[40][7];
int num_digitos = 3;
int BASE = 10;

void setup() {
Serial.begin(9600);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(Reset, OUTPUT);
digitalWrite(Reset, HIGH);
digitalWrite(Reset, LOW);
}

void loop() {

int numero = millis() / 1000;

int fator = 1;
for (int digito = num_digitos - 1; digito >= 0; digito = digito - 1)
{
int valor = (numero / fator) % BASE;

Serial.println(valor);

if (digito == 2) {
selecionaMatriz_2(valor);
}
if (digito == 1) {
selecionaMatriz_1(valor);
}
if (digito == 0) {
selecionaMatriz_0(valor);
}
fator = fator * BASE;
}

alocaDigito ();

for (int i = 0; i < 2000; i++)
{
escreveMatriz();
}
}
void selecionaMatriz_2(int pos)
{
Serial.println(pos);
for (int i = 0; i <= 7; i++)
{
for (int j = 0; j <= 6; j++)
{
led0[j] = matriz[pos][j];
}
}
}

void selecionaMatriz_1(int pos)
{
for (int i = 0; i <= 7; i++)
{
for (int j = 0; j <= 6; j++)
{
led2[j] = matriz[pos][j];
}
}
}

void selecionaMatriz_0(int pos)
{
for (int i = 0; i <= 7; i++)
{
for (int j = 0; j <= 6; j++)
{
led4[j] = matriz[pos][j];
}
}
}

void alocaDigito () {
for (int j = 0; j <= 6; j++) {
for (int i = 0; i <= 7; i++) {
mascara[j] = led0[j];
}
}
for (int j = 0; j <= 6; j++) {
for (int i = 8; i <= 15; i++) {
mascara[j] = led1[i - 8][j];
}
}
for (int j = 0; j <= 6; j++) {
for (int i = 16; i <= 23; i++) {
mascara[j] = led2[i - 16][j];
}
}
for (int j = 0; j <= 6; j++) {
for (int i = 24; i <= 31; i++) {
mascara[j] = led3[i - 24][j];
}
}
for (int j = 0; j <= 6; j++) {
for (int i = 32; i <= 39; i++) {
mascara[j] = led4[i - 32][j];
}
}
}

void escreveMatriz()
{
for (int m = 0; m <= 6; m++) {
for (int n = 0; n <= 39; n++) {
mascara[n][m] = ~mascara[n][m];
}
}
for (int linha = 0; linha <= 6; linha++) {
digitalWrite(clock, LOW);
digitalWrite(latchPin, LOW);
for (int coluna = 0; coluna <= 39; coluna++) {
digitalWrite(clockPin, LOW);
if (mascara[coluna][linha] == 1) {
digitalWrite(dataPin, HIGH);
}
else {
digitalWrite(dataPin, LOW);
}
digitalWrite(clockPin, HIGH);
}
digitalWrite(clockPin, LOW);
digitalWrite(latchPin, HIGH);
digitalWrite(clock, HIGH);
if (linha == 6) {
digitalWrite(Reset, HIGH);
digitalWrite(Reset, LOW);
}
}
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

uffff... quase perdi o fôlego pra ler. ... kk

Vou te ajudar de forma indireta. Baixe o anexo. Tem o projeto completo com fonte e simulação do proteus. Só falta você achar ruim porque não tem o .pcb né...

É em c e pro pic mas facim adaptar pra virtualmente qualquer mc.

Use o .hex ... ou melhor o .cof pra rodar no proteus. Fiz há muitos (e muitos) anos pra um amigo de outro forum.

 

Inspire-se no fonte mas principalmente na mensagem subliminar do Fonte.

Pode não lhe ser totalmente inútil

@Tarcisio Zewe Duarte

matrizdeleds.zip

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

pode também,tentar usar o MAX7219,conforme Isadora Ferraz me indicou.

Fica bem simples o Hardware código,apenas vai ter que usar uma parte do SPI do micro.

Eu também ia fazer por Varredura,mas deixei esta técnica para desenvolver uma saída VGA.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

 

Obrigado por sua ajuda Isadora Ferraz, mas encontrei uma solução mais acertada aqui:

 

 

 

adicionado 5 minutos depois

@Isadora Ferraz Não gosto de usar bibliotecas, prefiro fazer o código na raça! O código fica bem mais extenso, mas consigo visualizar e entender o que esta acontecendo. Diferente de uma biblioteca, em que você pega um código escrito por outra pessoa, e simplesmente usa, sem saber do que se trata. Funcionar pode até funcionar, facilitar pode até facilitar, mas de quê adianta se você não entende bolhufas do que está acontecendo? Pra mim biblioteca e coisa de preguiçoso, que tem preguiça até de piscar o olho, e não deveria nem ter saido da barriga da própria mãe de tanta preguiça! kkkkkkkkkkk

Compartilhar este post


Link para o post
Compartilhar em outros sites

É... seu monstrinho que você encontrou e entendeu - e não criou -  ficou ´um pouco´ maior que o meu, que também tem zero de lib pronta, mas o importante é que fez ´uma criança´ feliz kk. Sem ofensa... apenas no sentido profissional ok?

Só não sei o espaço e recurso do mc que ele vai ocupar.

 

E que legal que compartilhou sua solução. É este o espírito do forum.

Sucessos...

Compartilhar este post


Link para o post
Compartilhar em outros sites

t

adicionado 3 minutos depois

Também não curto muito hexadecimal,  não é preconceito contra este sistema numérico, em alguns casos ele até é muito bom, mas neste caso ele é uma "M", pois  o binário cai melhor para ele, permitindo uma vizualização dos caractéres. Mas sei que você como muitos tem fetiches, desejos e paixões pelo código hexadeciamal,kkkkkkkk

  • Confuso 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

hmmmm..

13 horas atrás, Tarcisio Zewe Duarte disse:

fetiches, desejos e paixões pelo código hexadeciama

...mas se estiver falando disso

Em 28/09/2018 às 16:08, Isadora Ferraz disse:

Use o .hex ...

... acho que tem alguém meio confuso por aqui.

 

E que pena que preferiu não manter seu fonte. Pensando bem, era quase o mesmo tamanho. Pra "reduzir o tamanho" era só fazer assim ó...

(pra quem tem preguiça - tipo eu - de baixar anexo)

-matrizdeleds.c






/* Programa para uControlador PIC16F876 controle de display alfanumérico */
/* início 06/03/2004 V.0.0 simulação*/
//V 1.0 pic16f876A com display spider
#include <pic.h>
#include    "tabela1.c"
//#include    "i2c876.asm"
#define tm1h        0xf9    //int timer1 300Hz
#define tm1l        0x7e
//#define tm1h        0xfb    //int timer1 400Hz
//#define tm1l        0x1e
//#define tm1h        0xf6    //int timer1 200Hz
//#define tm1l        0x3c

#define SH   RC0
#define DS   RC1
#define ST   RC2

#define CLK SH=0;asm("nop");asm("nop");SH=1
#define STCLK ST=0;asm("nop");asm("nop");ST=1

//************************ configuração ***********************
// proteção do código,4Mhz,powerup,lowvoltagedis,debdis,flaswritedis,wathdogdis,brownoureseten
__CONFIG(PROTECT & XT & PWRTEN & LVPDIS & DEBUGDIS & WDTDIS & BOREN);
unsigned char bank1 lin0[14];
unsigned char bank1 lin1[14];
unsigned char bank1 lin2[14];
unsigned char bank1 lin3[14];
unsigned char bank2 lin4[14];
unsigned char bank2 lin5[14];
unsigned char bank2 lin6[14];

void shift(unsigned char s)
{
unsigned char k;
for (k=0;k<6;k++) //padrão de 6 bits
 {
 DS=s;
 s>>=1;
 CLK;
 }
STCLK;
}
/**********************************************************************/
void rolabit()
{
unsigned char i;
for (i=0;i<14;i++)
    {
    lin6[i]<<=1;
    lin5[i]<<=1;
    lin4[i]<<=1;
    lin3[i]<<=1;
    lin2[i]<<=1;
    lin1[i]<<=1;
    lin0[i]<<=1;
    }
for (i=0;i<13;i++)
    {
    if (lin6[i]&0b1000000) lin6[i+1]|=1;
    if (lin5[i]&0b1000000) lin5[i+1]|=1;
    if (lin4[i]&0b1000000) lin4[i+1]|=1;
    if (lin3[i]&0b1000000) lin3[i+1]|=1;
    if (lin2[i]&0b1000000) lin2[i+1]|=1;
    if (lin1[i]&0b1000000) lin1[i+1]|=1;
    if (lin0[i]&0b1000000) lin0[i+1]|=1;
    }
}
/**********************************************************************/
//interrupção timer1: tratamento dos displays, leds e teclado
static bit rl;
unsigned char dl,crl,lin,tr;
static void interrupt
timer1_int(void)
{
unsigned char j;
TMR1IF=0;
TMR1H=tm1h;  //restaura 400Hz int
TMR1L=tm1l;
T1CON=0B00010101;  //prescaler /2,osc. dis.,not sync.,interno fosc/4,timer on
PORTB=0b11111111; //apaga display
switch (lin)
            {
             case 0: for (j=0;j<14;j++) shift(lin0[j]); break;
             case 1: for (j=0;j<14;j++) shift(lin1[j]); break;
             case 2: for (j=0;j<14;j++) shift(lin2[j]); break;
             case 3: for (j=0;j<14;j++) shift(lin3[j]); break;
             case 4: for (j=0;j<14;j++) shift(lin4[j]); break;
             case 5: for (j=0;j<14;j++) shift(lin5[j]); break;
             case 6: for (j=0;j<14;j++) shift(lin6[j]); break;
            }
PORTB=~(1<<lin);
lin++;
if (lin>6) lin=0;
dl--;
if (rl&&!tr--)
            {
            rolabit();
            crl--;
            }
}
/**********************************************************************/
void putchar(unsigned char c,unsigned int dado)
{
c=13-c; //posição na coluna
dado-=32;   //retira 1º ascii (spc)
dado+=dado*6; //de 6 em 6 bits
    lin6[c]=tabdisp[dado];
    lin5[c]=tabdisp[dado+1];
    lin4[c]=tabdisp[dado+2];
    lin3[c]=tabdisp[dado+3];
    lin2[c]=tabdisp[dado+4];
    lin1[c]=tabdisp[dado+5];
    lin0[c]=tabdisp[dado+6];

}
/**********************************************************************/
void msgdsp(unsigned char col,const char * s)
{
    while(*s)
        putchar(col++,*s++);
}
/**********************************************************************/
void delay(unsigned char d)
{
dl=d;
while(dl);
}
/**********************************************************************/
/***************INICIO DO PROGRAMA PRINCIPAL***************************/
/**********************************************************************/
main()

{
TRISA=0xff;
TRISB=TRISC=0;
PORTB=0xff;
//ADCON1=0b10000000;  //formato do resultado AD xxxxxxBBBBBBBBBB - AAAAA - bits à direita
T1CON=0B00010101;  // prescaler /2 timer1 on
TMR1H=tm1h;   // int. 400Hz
TMR1L=tm1l;
TMR1IF=0;   //zera flag timer1
TMR1IE=1;   //hab. int. timer1
PEIE=1;

//SMP=1;  //I2C slew rate control disabled
//SSPM3=1;//I2C master mode in hardware
//SSPEN=1;//enable SSP module
//SSPADD=0xa;//set I2C clock rate to 100kHz

GIE=1;

for (;;)
{
rl=0;
msgdsp(0,"**TUDO POSSO**");
delay(0xff);
rl=1;
while(crl);
rl=0;
msgdsp(0,"NAQUELE QUE ME");
delay(0xff);
rl=1;
while(crl);
rl=0;
msgdsp(0,"**FORTALECE!**");
delay(0xff);
rl=1;
while(crl);

}
}

-tabela.c






unsigned char const tabdisp[]={

0b000000,
0b000000,
0b000000,
0b000000,   //spc
0b000000,
0b000000,
0b000000,

0b001000,
0b001000,
0b001000,
0b001000,   //!
0b001000,
0b000000,
0b001000,

0b010100,
0b010100,
0b010100,
0b000000,   //"
0b000000,
0b000000,
0b000000,

0b010100,
0b010100,
0b111110,
0b010100,   //#
0b111110,
0b010100,
0b010100,

0b011110,
0b101000,
0b011000,
0b001100,   //$
0b001010,
0b111100,
0b001000,

0b110000,
0b110010,
0b000100,
0b001000,   //%
0b010000,
0b100110,
0b000110,

0b011000,
0b100010,
0b101000,
0b010000,
0b101010,   //&
0b100100,
0b011010,

0b011000,
0b001000,
0b000000,
0b100000,   //'
0b000000,
0b000000,
0b000000,

0b000100,
0b001000,
0b010000,
0b010000,   //(
0b010000,
0b001000,
0b000100,

0b010000,
0b001000,
0b000100,
0b000100,   //)
0b000100,
0b001000,
0b010000,

0b000000,
0b001000,
0b101010,
0b011100,   //*
0b101010,
0b001000,
0b000000,

0b000000,
0b001000,
0b001000,
0b111110,   //+
0b001000,
0b001000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,   //,
0b011000,
0b001000,
0b010000,

0b000000,
0b000000,
0b000000,
0b111110,   //-
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,
0b000000,   //.
0b011000,
0b011000,

0b000000,
0b000010,
0b000100,
0b001000,   // /
0b010000,
0b100000,
0b000000,

0b011100,
0b100010,
0b100110,
0b101010,   //0
0b110010,
0b100010,
0b011100,

0b001000,
0b011000,
0b001000,
0b001000,   //1
0b001000,
0b001000,
0b011100,

0b011100,
0b100010,
0b000010,
0b000100,   //2
0b001000,
0b010000,
0b111111,

0b111110,
0b000100,
0b001000,
0b000100,   //3
0b000010,
0b100010,
0b011100,

0b000100,
0b001100,
0b010100,
0b100100,   //4
0b111110,
0b000100,
0b000100,

0b111110,
0b100000,
0b111100,
0b000010,   //5
0b000010,
0b100010,
0b011100,


0b001100,
0b010000,
0b100000,
0b111100,   //6
0b100010,
0b100010,
0b011100,

0b111110,
0b000010,
0b000010,
0b000100,   //7
0b001000,
0b010000,
0b010000,

0b011100,
0b100010,
0b100010,
0b011100,   //8
0b100010,
0b100010,
0b011100,

0b011100,
0b100010,
0b100010,
0b011110,   //9
0b000010,
0b000100,
0b011000,

0b000000,
0b000000,
0b011000,
0b011000,
0b000000,   //:
0b011000,
0b011000,

0b000000,
0b011000,
0b011000,
0b000000,
0b011000,   //;
0b001000,
0b010000,

0b000100,
0b001000,
0b010000,
0b100000,   //<
0b010000,
0b001000,
0b000100,

0b000000,
0b000000,
0b000000,
0b111110,   //=
0b000000,
0b111110,
0b000000,

0b010000,
0b001000,
0b000100,
0b000010,   //>
0b000100,
0b001000,
0b010000,

0b011100,
0b100010,
0b000010,
0b000100,
0b001000,   //?
0b000000,
0b001000,

0b011100,
0b100010,
0b000010,
0b011010,
0b101010,   //@
0b101010,
0b011100,    
//***************************

0b011100,
0b100010,
0b100010,
0b100010,   //A
0b111110,
0b100010,
0b100010,

0b111100,
0b100010,
0b100010,
0b111100,  //B     
0b100010,
0b100010,
0b111100,

0b011100,
0b100010,
0b100000,
0b100000, //C
0b100000,
0b100010,
0b011100,

0b111000,
0b100100,
0b100010,
0b100010,   //D
0b100010,
0b100100,
0b111000,                       

0b111110,
0b100000,
0b100000,
0b111100,   //E
0b100000,
0b100000,
0b111110,

0b111110,
0b100000,
0b100000,
0b111100,   //F
0b100000,
0b100000,
0b100000,

0b011100,
0b100010,
0b100000,
0b100110,
0b100010,   //G
0b100010,
0b011110,

0b100010,
0b100010,
0b100010,
0b111110,            //H  
0b100010,
0b100010,
0b100010,

0b011100,
0b001000,
0b001000,
0b001000,   //I
0b001000,
0b001000,
0b011100,

0b011100,
0b001000,
0b001000,
0b001000,   //J
0b001000,
0b101000,
0b010000,

0b100010,
0b100100,
0b101000,
0b110000,   //K
0b101000,
0b100100,
0b100010,

0b100000,
0b100000,
0b100000,
0b100000,   //L
0b100000,
0b100000,
0b111110,

0b100010,
0b110110,
0b101010,
0b100010,   //M
0b100010,
0b100010,
0b100010,

0b100010,
0b110010,
0b101010,
0b100110,   //N
0b100010,
0b100010,
0b100010,

0b011100,
0b100010,
0b100010,
0b100010,   //O
0b100010,
0b100010,
0b011100,

0b111100,
0b100010,
0b100010,
0b111100,            //P  
0b100000,
0b100000,
0b100000,

0b011100,
0b100010,
0b100010,
0b100010,   //Q
0b101010,
0b100100,
0b011010,

0b111100,
0b100010,
0b100010,
0b111100,   //R
0b101000,
0b100100,
0b100010,

0b011110,
0b100000,
0b100000,
0b011100,   //S
0b000010,
0b100010,
0b111100,

0b111110,
0b001000,
0b001000,
0b001000,   //T
0b001000,
0b001000,
0b001000,

0b100010,
0b100010,
0b100010,
0b100010,   //U
0b100010,
0b100010,
0b011100,

0b100010,
0b100010,
0b100010,
0b100010,   //V
0b100010,
0b010100,
0b001000,

0b100010,
0b100010,
0b100010,
0b100010,   //W
0b101010,
0b110110,
0b100010,

0b100010,
0b100010,
0b010100,
0b001000,   //X
0b010100,
0b100010,
0b100010,

0b100010,
0b100010,
0b010100,
0b001000,
0b001000,   //Y
0b001000,
0b001000,

0b111110,
0b000010,
0b000100,
0b001000,   //Z
0b010000,
0b100000,
0b111110,

0b011100,
0b010000,
0b010000,
0b010000,   //[
0b010000,
0b010000,
0b011100,

0b000000,
0b100000,
0b010000,
0b001000,   // \
0b000100,
0b000010,
0b000000,

0b011100,
0b000100,
0b000100,
0b000100,   //]
0b000100,
0b000100,
0b011100,

0b001000,
0b010100,
0b100010,
0b000000,   //^
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,   //_
0b000000,
0b000000,
0b111110,

0b010000,
0b001000,
0b000100,
0b000000,   //`
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b011100,
0b000010,   //a
0b011110,
0b100010,
0b011110,

0b100000,
0b100000,
0b101100,
0b110010,   //b
0b100010,
0b100010,
0b111100,

0b000000,
0b000000,
0b011100,
0b100000,   //c
0b100000,
0b100010,
0b011100,

0b000010,
0b000010,
0b011010,
0b100110,   //d
0b100010,
0b100010,
0b011110,

0b000000,
0b000000,
0b011100,
0b100010,   //e
0b111110,
0b100000,
0b011100,

0b001100,
0b010010,
0b010000,
0b111000,   //f
0b010000,
0b010000,
0b010000,


0b000000,
0b011110,
0b100010,
0b100010,
0b011110,   //g
0b000010,
0b011100,

0b100000,
0b100000,
0b100000,
0b101100,
0b110010,   //h
0b100010,
0b100010,

0b001000,
0b000000,
0b011000,
0b001000,      //i
0b001000,
0b001000,
0b011100,

0b000100,
0b000000,
0b001100,
0b000100,   //j
0b000100,
0b100100,
0b011000,

0b100000,
0b100000,
0b100100,
0b101000,   //k
0b110000,
0b101000,
0b100100,

0b011000,
0b001000,
0b001000,
0b001000,   //l
0b001000,
0b001000,
0b011100,

0b000000,
0b000000,
0b110100,
0b101010,   //m
0b101010,
0b100010,
0b100010,

0b000000,
0b000000,
0b101100,
0b110010,   //n
0b100010,
0b100010,
0b100010,

0b000000,
0b000000,
0b011100,
0b100010,   //o
0b100010,
0b100010,
0b011100,

0b000000,
0b000000,
0b111100,
0b100010,   //p
0b111100,
0b100000,
0b100000,

0b000000,
0b000000,
0b011010,
0b100110,   //q
0b011110,
0b000010,
0b000010,

0b000000,
0b000000,
0b101100,
0b110010,   //r
0b100000,
0b100000,
0b100000,

0b000000,
0b000000,
0b011100,
0b100000,   //s
0b011100,
0b000010,
0b111100,

0b010000,
0b111000,
0b010000,
0b010000,   //t
0b010000,
0b010010,
0b001100,

0b000000,
0b000000,
0b100010,
0b100010,   //u
0b100010,
0b100110,
0b011010,

0b000000,
0b000000,
0b100010,
0b100010,   //v
0b100010,
0b010100,
0b001000,

0b000000,
0b000000,
0b100010,
0b100010,   //w
0b101010,
0b101010,
0b010100,

0b000000,
0b000000,
0b100010,
0b010100,   //x
0b001000,
0b010100,
0b100010,

0b000000,
0b000000,
0b100010,
0b100010,   //y
0b011100,
0b000010,
0b011100,

0b000000,
0b000000,
0b111110,
0b000100,   //z
0b001000,
0b010000,
0b111110,

      };

...

Mas se percebeste o que temos em comum...

19 horas atrás, Tarcisio Zewe Duarte disse:

Não gosto de usar bibliotecas, prefiro fazer o código na raça!

..., já tá de... "bom tamanho".

abç

Compartilhar este post


Link para o post
Compartilhar em outros sites
1 hora atrás, Isadora Ferraz disse:

hmmmm..

...mas se estiver falando disso

... acho que tem alguém meio confuso por aqui.

 

E que pena que preferiu não manter seu fonte. Pensando bem, era quase o mesmo tamanho. Pra "reduzir o tamanho" era só fazer assim ó...

(pra quem tem preguiça - tipo eu - de baixar anexo)

-matrizdeleds.c

 

  Mostrar conteúdo oculto

 

 

 

 

 

 

 

 


/* Programa para uControlador PIC16F876 controle de display alfanumérico */
/* início 06/03/2004 V.0.0 simulação*/
//V 1.0 pic16f876A com display spider
#include <pic.h>
#include    "tabela1.c"
//#include    "i2c876.asm"
#define tm1h        0xf9    //int timer1 300Hz
#define tm1l        0x7e
//#define tm1h        0xfb    //int timer1 400Hz
//#define tm1l        0x1e
//#define tm1h        0xf6    //int timer1 200Hz
//#define tm1l        0x3c

#define SH   RC0
#define DS   RC1
#define ST   RC2

#define CLK SH=0;asm("nop");asm("nop");SH=1
#define STCLK ST=0;asm("nop");asm("nop");ST=1

//************************ configuração ***********************
// proteção do código,4Mhz,powerup,lowvoltagedis,debdis,flaswritedis,wathdogdis,brownoureseten
__CONFIG(PROTECT & XT & PWRTEN & LVPDIS & DEBUGDIS & WDTDIS & BOREN);
unsigned char bank1 lin0[14];
unsigned char bank1 lin1[14];
unsigned char bank1 lin2[14];
unsigned char bank1 lin3[14];
unsigned char bank2 lin4[14];
unsigned char bank2 lin5[14];
unsigned char bank2 lin6[14];

void shift(unsigned char s)
{
unsigned char k;
for (k=0;k<6;k++) //padrão de 6 bits
 {
 DS=s;
 s>>=1;
 CLK;
 }
STCLK;
}
/**********************************************************************/
void rolabit()
{
unsigned char i;
for (i=0;i<14;i++)
    {
    lin6[i]<<=1;
    lin5[i]<<=1;
    lin4[i]<<=1;
    lin3[i]<<=1;
    lin2[i]<<=1;
    lin1[i]<<=1;
    lin0[i]<<=1;
    }
for (i=0;i<13;i++)
    {
    if (lin6[i]&0b1000000) lin6[i+1]|=1;
    if (lin5[i]&0b1000000) lin5[i+1]|=1;
    if (lin4[i]&0b1000000) lin4[i+1]|=1;
    if (lin3[i]&0b1000000) lin3[i+1]|=1;
    if (lin2[i]&0b1000000) lin2[i+1]|=1;
    if (lin1[i]&0b1000000) lin1[i+1]|=1;
    if (lin0[i]&0b1000000) lin0[i+1]|=1;
    }
}
/**********************************************************************/
//interrupção timer1: tratamento dos displays, leds e teclado
static bit rl;
unsigned char dl,crl,lin,tr;
static void interrupt
timer1_int(void)
{
unsigned char j;
TMR1IF=0;
TMR1H=tm1h;  //restaura 400Hz int
TMR1L=tm1l;
T1CON=0B00010101;  //prescaler /2,osc. dis.,not sync.,interno fosc/4,timer on
PORTB=0b11111111; //apaga display
switch (lin)
            {
             case 0: for (j=0;j<14;j++) shift(lin0[j]); break;
             case 1: for (j=0;j<14;j++) shift(lin1[j]); break;
             case 2: for (j=0;j<14;j++) shift(lin2[j]); break;
             case 3: for (j=0;j<14;j++) shift(lin3[j]); break;
             case 4: for (j=0;j<14;j++) shift(lin4[j]); break;
             case 5: for (j=0;j<14;j++) shift(lin5[j]); break;
             case 6: for (j=0;j<14;j++) shift(lin6[j]); break;
            }
PORTB=~(1<<lin);
lin++;
if (lin>6) lin=0;
dl--;
if (rl&&!tr--)
            {
            rolabit();
            crl--;
            }
}
/**********************************************************************/
void putchar(unsigned char c,unsigned int dado)
{
c=13-c; //posição na coluna
dado-=32;   //retira 1º ascii (spc)
dado+=dado*6; //de 6 em 6 bits
    lin6[c]=tabdisp[dado];
    lin5[c]=tabdisp[dado+1];
    lin4[c]=tabdisp[dado+2];
    lin3[c]=tabdisp[dado+3];
    lin2[c]=tabdisp[dado+4];
    lin1[c]=tabdisp[dado+5];
    lin0[c]=tabdisp[dado+6];

}
/**********************************************************************/
void msgdsp(unsigned char col,const char * s)
{
    while(*s)
        putchar(col++,*s++);
}
/**********************************************************************/
void delay(unsigned char d)
{
dl=d;
while(dl);
}
/**********************************************************************/
/***************INICIO DO PROGRAMA PRINCIPAL***************************/
/**********************************************************************/
main()

{
TRISA=0xff;
TRISB=TRISC=0;
PORTB=0xff;
//ADCON1=0b10000000;  //formato do resultado AD xxxxxxBBBBBBBBBB - AAAAA - bits à direita
T1CON=0B00010101;  // prescaler /2 timer1 on
TMR1H=tm1h;   // int. 400Hz
TMR1L=tm1l;
TMR1IF=0;   //zera flag timer1
TMR1IE=1;   //hab. int. timer1
PEIE=1;

//SMP=1;  //I2C slew rate control disabled
//SSPM3=1;//I2C master mode in hardware
//SSPEN=1;//enable SSP module
//SSPADD=0xa;//set I2C clock rate to 100kHz

GIE=1;

for (;;)
{
rl=0;
msgdsp(0,"**TUDO POSSO**");
delay(0xff);
rl=1;
while(crl);
rl=0;
msgdsp(0,"NAQUELE QUE ME");
delay(0xff);
rl=1;
while(crl);
rl=0;
msgdsp(0,"**FORTALECE!**");
delay(0xff);
rl=1;
while(crl);

}
}

 

 

-tabela.c

 

  Mostrar conteúdo oculto

 

 

 

 

 

 

 

 


unsigned char const tabdisp[]={

0b000000,
0b000000,
0b000000,
0b000000,   //spc
0b000000,
0b000000,
0b000000,

0b001000,
0b001000,
0b001000,
0b001000,   //!
0b001000,
0b000000,
0b001000,

0b010100,
0b010100,
0b010100,
0b000000,   //"
0b000000,
0b000000,
0b000000,

0b010100,
0b010100,
0b111110,
0b010100,   //#
0b111110,
0b010100,
0b010100,

0b011110,
0b101000,
0b011000,
0b001100,   //$
0b001010,
0b111100,
0b001000,

0b110000,
0b110010,
0b000100,
0b001000,   //%
0b010000,
0b100110,
0b000110,

0b011000,
0b100010,
0b101000,
0b010000,
0b101010,   //&
0b100100,
0b011010,

0b011000,
0b001000,
0b000000,
0b100000,   //'
0b000000,
0b000000,
0b000000,

0b000100,
0b001000,
0b010000,
0b010000,   //(
0b010000,
0b001000,
0b000100,

0b010000,
0b001000,
0b000100,
0b000100,   //)
0b000100,
0b001000,
0b010000,

0b000000,
0b001000,
0b101010,
0b011100,   //*
0b101010,
0b001000,
0b000000,

0b000000,
0b001000,
0b001000,
0b111110,   //+
0b001000,
0b001000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,   //,
0b011000,
0b001000,
0b010000,

0b000000,
0b000000,
0b000000,
0b111110,   //-
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,
0b000000,   //.
0b011000,
0b011000,

0b000000,
0b000010,
0b000100,
0b001000,   // /
0b010000,
0b100000,
0b000000,

0b011100,
0b100010,
0b100110,
0b101010,   //0
0b110010,
0b100010,
0b011100,

0b001000,
0b011000,
0b001000,
0b001000,   //1
0b001000,
0b001000,
0b011100,

0b011100,
0b100010,
0b000010,
0b000100,   //2
0b001000,
0b010000,
0b111111,

0b111110,
0b000100,
0b001000,
0b000100,   //3
0b000010,
0b100010,
0b011100,

0b000100,
0b001100,
0b010100,
0b100100,   //4
0b111110,
0b000100,
0b000100,

0b111110,
0b100000,
0b111100,
0b000010,   //5
0b000010,
0b100010,
0b011100,


0b001100,
0b010000,
0b100000,
0b111100,   //6
0b100010,
0b100010,
0b011100,

0b111110,
0b000010,
0b000010,
0b000100,   //7
0b001000,
0b010000,
0b010000,

0b011100,
0b100010,
0b100010,
0b011100,   //8
0b100010,
0b100010,
0b011100,

0b011100,
0b100010,
0b100010,
0b011110,   //9
0b000010,
0b000100,
0b011000,

0b000000,
0b000000,
0b011000,
0b011000,
0b000000,   //:
0b011000,
0b011000,

0b000000,
0b011000,
0b011000,
0b000000,
0b011000,   //;
0b001000,
0b010000,

0b000100,
0b001000,
0b010000,
0b100000,   //<
0b010000,
0b001000,
0b000100,

0b000000,
0b000000,
0b000000,
0b111110,   //=
0b000000,
0b111110,
0b000000,

0b010000,
0b001000,
0b000100,
0b000010,   //>
0b000100,
0b001000,
0b010000,

0b011100,
0b100010,
0b000010,
0b000100,
0b001000,   //?
0b000000,
0b001000,

0b011100,
0b100010,
0b000010,
0b011010,
0b101010,   //@
0b101010,
0b011100,    
//***************************

0b011100,
0b100010,
0b100010,
0b100010,   //A
0b111110,
0b100010,
0b100010,

0b111100,
0b100010,
0b100010,
0b111100,  //B     
0b100010,
0b100010,
0b111100,

0b011100,
0b100010,
0b100000,
0b100000, //C
0b100000,
0b100010,
0b011100,

0b111000,
0b100100,
0b100010,
0b100010,   //D
0b100010,
0b100100,
0b111000,                       

0b111110,
0b100000,
0b100000,
0b111100,   //E
0b100000,
0b100000,
0b111110,

0b111110,
0b100000,
0b100000,
0b111100,   //F
0b100000,
0b100000,
0b100000,

0b011100,
0b100010,
0b100000,
0b100110,
0b100010,   //G
0b100010,
0b011110,

0b100010,
0b100010,
0b100010,
0b111110,            //H  
0b100010,
0b100010,
0b100010,

0b011100,
0b001000,
0b001000,
0b001000,   //I
0b001000,
0b001000,
0b011100,

0b011100,
0b001000,
0b001000,
0b001000,   //J
0b001000,
0b101000,
0b010000,

0b100010,
0b100100,
0b101000,
0b110000,   //K
0b101000,
0b100100,
0b100010,

0b100000,
0b100000,
0b100000,
0b100000,   //L
0b100000,
0b100000,
0b111110,

0b100010,
0b110110,
0b101010,
0b100010,   //M
0b100010,
0b100010,
0b100010,

0b100010,
0b110010,
0b101010,
0b100110,   //N
0b100010,
0b100010,
0b100010,

0b011100,
0b100010,
0b100010,
0b100010,   //O
0b100010,
0b100010,
0b011100,

0b111100,
0b100010,
0b100010,
0b111100,            //P  
0b100000,
0b100000,
0b100000,

0b011100,
0b100010,
0b100010,
0b100010,   //Q
0b101010,
0b100100,
0b011010,

0b111100,
0b100010,
0b100010,
0b111100,   //R
0b101000,
0b100100,
0b100010,

0b011110,
0b100000,
0b100000,
0b011100,   //S
0b000010,
0b100010,
0b111100,

0b111110,
0b001000,
0b001000,
0b001000,   //T
0b001000,
0b001000,
0b001000,

0b100010,
0b100010,
0b100010,
0b100010,   //U
0b100010,
0b100010,
0b011100,

0b100010,
0b100010,
0b100010,
0b100010,   //V
0b100010,
0b010100,
0b001000,

0b100010,
0b100010,
0b100010,
0b100010,   //W
0b101010,
0b110110,
0b100010,

0b100010,
0b100010,
0b010100,
0b001000,   //X
0b010100,
0b100010,
0b100010,

0b100010,
0b100010,
0b010100,
0b001000,
0b001000,   //Y
0b001000,
0b001000,

0b111110,
0b000010,
0b000100,
0b001000,   //Z
0b010000,
0b100000,
0b111110,

0b011100,
0b010000,
0b010000,
0b010000,   //[
0b010000,
0b010000,
0b011100,

0b000000,
0b100000,
0b010000,
0b001000,   // \
0b000100,
0b000010,
0b000000,

0b011100,
0b000100,
0b000100,
0b000100,   //]
0b000100,
0b000100,
0b011100,

0b001000,
0b010100,
0b100010,
0b000000,   //^
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b000000,
0b000000,   //_
0b000000,
0b000000,
0b111110,

0b010000,
0b001000,
0b000100,
0b000000,   //`
0b000000,
0b000000,
0b000000,

0b000000,
0b000000,
0b011100,
0b000010,   //a
0b011110,
0b100010,
0b011110,

0b100000,
0b100000,
0b101100,
0b110010,   //b
0b100010,
0b100010,
0b111100,

0b000000,
0b000000,
0b011100,
0b100000,   //c
0b100000,
0b100010,
0b011100,

0b000010,
0b000010,
0b011010,
0b100110,   //d
0b100010,
0b100010,
0b011110,

0b000000,
0b000000,
0b011100,
0b100010,   //e
0b111110,
0b100000,
0b011100,

0b001100,
0b010010,
0b010000,
0b111000,   //f
0b010000,
0b010000,
0b010000,


0b000000,
0b011110,
0b100010,
0b100010,
0b011110,   //g
0b000010,
0b011100,

0b100000,
0b100000,
0b100000,
0b101100,
0b110010,   //h
0b100010,
0b100010,

0b001000,
0b000000,
0b011000,
0b001000,      //i
0b001000,
0b001000,
0b011100,

0b000100,
0b000000,
0b001100,
0b000100,   //j
0b000100,
0b100100,
0b011000,

0b100000,
0b100000,
0b100100,
0b101000,   //k
0b110000,
0b101000,
0b100100,

0b011000,
0b001000,
0b001000,
0b001000,   //l
0b001000,
0b001000,
0b011100,

0b000000,
0b000000,
0b110100,
0b101010,   //m
0b101010,
0b100010,
0b100010,

0b000000,
0b000000,
0b101100,
0b110010,   //n
0b100010,
0b100010,
0b100010,

0b000000,
0b000000,
0b011100,
0b100010,   //o
0b100010,
0b100010,
0b011100,

0b000000,
0b000000,
0b111100,
0b100010,   //p
0b111100,
0b100000,
0b100000,

0b000000,
0b000000,
0b011010,
0b100110,   //q
0b011110,
0b000010,
0b000010,

0b000000,
0b000000,
0b101100,
0b110010,   //r
0b100000,
0b100000,
0b100000,

0b000000,
0b000000,
0b011100,
0b100000,   //s
0b011100,
0b000010,
0b111100,

0b010000,
0b111000,
0b010000,
0b010000,   //t
0b010000,
0b010010,
0b001100,

0b000000,
0b000000,
0b100010,
0b100010,   //u
0b100010,
0b100110,
0b011010,

0b000000,
0b000000,
0b100010,
0b100010,   //v
0b100010,
0b010100,
0b001000,

0b000000,
0b000000,
0b100010,
0b100010,   //w
0b101010,
0b101010,
0b010100,

0b000000,
0b000000,
0b100010,
0b010100,   //x
0b001000,
0b010100,
0b100010,

0b000000,
0b000000,
0b100010,
0b100010,   //y
0b011100,
0b000010,
0b011100,

0b000000,
0b000000,
0b111110,
0b000100,   //z
0b001000,
0b010000,
0b111110,

      };

 

 

...

Mas se percebeste o que temos em comum...

..., já tá de... "bom tamanho".

abç

Você quem está confundindo... kkkkkkk

Não me referi ao arquivo .hex que é compilado para enviar ao microcontrolador ou ao Arduino, e sim ao "sistema numérico hexadecimal" mesmo, tipo 0x000... utilizado para representar números...

Compartilhar este post


Link para o post
Compartilhar em outros sites

De boa... é que foi a única conexão que vi. De fato o binário é mais entendível bit a bit pra quem, como nós, gosta de escovar bits. Pra mc de 8 bits, de boa. De 16.. tá.. vai tamém. Mas de 32 ou + ... começa a ficar estranho.

A propósito, alguns compiladores estranhamente não têm a representação binária no seu sistema, sabia? Pra contornar, veja isso (pra pirar o cabeção de ... um certo amigo kk)

//************macros pra escrita de constantes em forma de bits caso o compilador não tenha*********/
#define B8__(x) ((x&0x0000000fLU)?1:0) \
+((x&0x000000f0LU)?2:0) \
+((x&0x00000f00LU)?4:0) \
+((x&0x0000f000LU)?8:0) \
+((x&0x000f0000LU)?16:0) \
+((x&0x00f00000LU)?32:0) \
+((x&0x0f000000LU)?64:0) \
+((x&0xf0000000LU)?128:0)
#define HEX__(n) 0x##n##LU
#define b8(d) ((unsigned char)B8__(HEX__(d)))
/* for upto 16-bit binary constants, MSB first */
#define b16(dmsb,dlsb) (((unsigned short)b8(dmsb)<< \
+ b8(dlsb))
/* for upto 32-bit binary constants, MSB first */
#define b32(dmsb,db2,db3,dlsb) (((unsigned long)b8(dmsb)<<24) \
+ ((unsigned long)b8(db2)<<16) \
+ ((unsigned long)b8(db3)<< \
+ b8(dlsb))
/* Sample usage:
b8(01010101) = 85
b16(10101010,01010101) = 43605
b32(10000000,11111111,10101010,01010101) = 2164238933
*/

Pode não vos ser totalmente inútil... A não ser pro Paulão kk

 

abç

 

 

  • Haha 2

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 22/10/2018 às 11:46, Isadora Ferraz disse:

Pode não vos ser totalmente inútil... A não ser pro Paulão kk

 

Sabia que ia sobrar para mim .... mas já joguei no lixo kkkk

 

Paulo

  • Triste 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

De fato,  o hexadecimal tem sua utilidade  em algumas aplicações,   como por exemplo na escolha de palheta de cores,  e compilação,  mas em outros casos como neste de geração de caracteres,  seja matricial ou sete segmentos,  o hexadecimal é uma M! Ele pode até deixar o côdigo bem mais magrinho,  mas você não tem muita visualização do que está acontecendo na verdade!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações 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

×