ASM51

pessoal estou montando uma matriz 5X7 usando o 4094 em cascata porem estou com dificuldade para montar o algoritimo eu so consigo mostrar uma letra e não consigo fazer correr o texto gostaria que me ajudassem estou usando C para programar
Valeu!!

o pino pra carregar os novos bits que chegaram fica sempre em H quando enviar os dados vc da um pulso negativo.
O algoritmo é simplizim.
Suponha o seguinte.
Uma palavra amor.
São 4 letras cada letra ocupa 5 bytes, entre uma letra e outra dois bytes em braco pra separação.
4X5 = 20 bytes + 6 bytes de semaração.
A 2 M 2 O 2 R
26 bytes.

Vc por exemplo vai girar da esquerda pra direita, mais facil pra vc entender.
Crie uma array de 26 bytes na ram.
Crie outra array de 5 bytes pra trabalhar em conjunto com o SPI out.

Mão na obra mole..

Do fim pro começo da array de 26 bytes com a palavra amor
eu pego os bytes
26,25,24,23,22
jogo na array do spi out e mando bala.
depois pego os bytes
25,24,23,22,21
jogo na array do spi out e mando bala.
..............................
5,4,3,2,1
jogo na array do spi out e manda bala
4,3,2,1 byte a zero
............................
3,2,1 2 bytes a zero
...........................
5 bytes a zero.
Entre um frame e outro vc pode fazer com 0,8 segundos que fica legal.

Abraços

fabim

olá fabim muito obrigado por me ajudar porem sem um exemplo não estou conseguindo assimilar direito se tiver jeito tem como colocar um exemplo?
Muito Obrigado.

Já fiz um projeto com o PIC assim.

O inconveniente desse uC, é que nao é possivel criar vetores com tamanho superior à 256 bytes, por isso, tive que separar a tabela ASCII em 2 partes : Uma de 'SPACE' até 'R', e outra de 'S' até '~'.

Esse programa a seguir escreve caracteres 5x7 em um display, sem animacao. A versao final, tem RELOGIO, TERMOMETRO, ANIMACAO VERTICAL E HORIZONTAL, CARACTERES_12x8 e comunicacao SERIAL, porém é uma versao comercial; se tiver interesse, podemos conversar.

Código: Selecionar todos

#include "C:\andre\pessoais\projetos particulares\painel de led\firmware\controled.h"
//
//
// Trocar cristal de 1.000.000 por 20MHz
//
//

void EscreveNoDisplay ( unsigned int8 modo )         ;
void PlotaColuna ( void )                            ;
unsigned int8 Inverte_bits ( unsigned int8 Palavra ) ;

unsigned int8 StringToDisplay[20] = "Star  "       ;
unsigned int8 TamanhoString       = 8              ;
unsigned int8 Debug, Debug2                        ;
unsigned int8 PonteiroChar   = 0                   ;
unsigned int8 PonteiroString = 0                   ;
unsigned int8 PortaB ;
unsigned int8 num ;
#define TAM_TEXT1          51
#define TAM_TEXT2          44
#define TAM_FONT_LIN       7
#define TAM_FONT_COL       5
/////////////////////////////////////////////////////////////////////////
//// Defines a 5x7 font
/////////////////////////////////////////////////////////////////////////
const BYTE TEXT1[TAM_TEXT1 * TAM_FONT_COL] ={
                         0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
                         0x00, 0x00, 0x5F, 0x00, 0x00, // !
                         0x00, 0x03, 0x00, 0x03, 0x00, // "
                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #
                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
                         0x43, 0x33, 0x08, 0x66, 0x61, // %
                         0x36, 0x49, 0x55, 0x22, 0x50, // &
                         0x00, 0x05, 0x03, 0x00, 0x00, // '
                         0x00, 0x1C, 0x22, 0x41, 0x00, // (
                         0x00, 0x41, 0x22, 0x1C, 0x00, // )
                         0x14, 0x08, 0x3E, 0x08, 0x14, // *
                         0x08, 0x08, 0x3E, 0x08, 0x08, // +
                         0x00, 0x50, 0x30, 0x00, 0x00, // ,
                         0x08, 0x08, 0x08, 0x08, 0x08, // -
                         0x00, 0x60, 0x60, 0x00, 0x00, // .
                         0x20, 0x10, 0x08, 0x04, 0x02, // /
                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
                         0x04, 0x02, 0x7F, 0x00, 0x00, // 1
                         0x42, 0x61, 0x51, 0x49, 0x46, // 2
                         0x22, 0x41, 0x49, 0x49, 0x36, // 3
                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4
                         0x27, 0x45, 0x45, 0x45, 0x39, // 5
                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6
                         0x01, 0x01, 0x71, 0x09, 0x07, // 7
                         0x36, 0x49, 0x49, 0x49, 0x36, // 8
                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9
                         0x00, 0x36, 0x36, 0x00, 0x00, // :
                         0x00, 0x56, 0x36, 0x00, 0x00, // ;
                         0x08, 0x14, 0x22, 0x41, 0x00, // <
                         0x14, 0x14, 0x14, 0x14, 0x14, // =
                         0x00, 0x41, 0x22, 0x14, 0x08, // >
                         0x02, 0x01, 0x51, 0x09, 0x06, // ?
                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @
                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A
                         0x7F, 0x49, 0x49, 0x49, 0x36, // B
                         0x3E, 0x41, 0x41, 0x41, 0x22, // C
                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D
                         0x7F, 0x49, 0x49, 0x49, 0x41, // E
                         0x7F, 0x09, 0x09, 0x09, 0x01, // F
                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G
                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H
                         0x00, 0x41, 0x7F, 0x41, 0x00, // I
                         0x30, 0x40, 0x40, 0x40, 0x3F, // J
                         0x7F, 0x08, 0x14, 0x22, 0x41, // K
                         0x7F, 0x40, 0x40, 0x40, 0x40, // L
                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N
                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O
                         0x7F, 0x09, 0x09, 0x09, 0x06, // P
                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
                         0x7F, 0x09, 0x09, 0x09, 0x76};// R

const BYTE TEXT2[TAM_TEXT2 * TAM_FONT_COL]={
                         0x26, 0x49, 0x49, 0x49, 0x32, // S
                         0x01, 0x01, 0x7F, 0x01, 0x01, // T
                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U
                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V
                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W
                         0x41, 0x22, 0x1C, 0x22, 0x41, // X
                         0x07, 0x08, 0x70, 0x08, 0x07, // Y
                         0x61, 0x51, 0x49, 0x45, 0x43, // Z
                         0x00, 0x7F, 0x41, 0x00, 0x00, // [
                         0x02, 0x04, 0x08, 0x10, 0x20, // \
                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]
                         0x04, 0x02, 0x01, 0x02, 0x04, // ^
                         0x40, 0x40, 0x40, 0x40, 0x40, // _
                         0x00, 0x01, 0x02, 0x04, 0x00, // `
                         0x20, 0x54, 0x54, 0x54, 0x78, // a
                         0x7F, 0x44, 0x44, 0x44, 0x38, // b
                         0x38, 0x44, 0x44, 0x44, 0x44, // c
                         0x38, 0x44, 0x44, 0x44, 0x7F, // d
                         0x38, 0x54, 0x54, 0x54, 0x18, // e
                         0x04, 0x04, 0x7E, 0x05, 0x05, // f
                         0x08, 0x54, 0x54, 0x54, 0x3C, // g
                         0x7F, 0x08, 0x04, 0x04, 0x78, // h
                         0x00, 0x44, 0x7D, 0x40, 0x00, // i
                         0x20, 0x40, 0x44, 0x3D, 0x00, // j
                         0x7F, 0x10, 0x28, 0x44, 0x00, // k
                         0x00, 0x41, 0x7F, 0x40, 0x00, // l
                         0x7C, 0x04, 0x78, 0x04, 0x78, // m
                         0x7C, 0x08, 0x04, 0x04, 0x78, // n
                         0x38, 0x44, 0x44, 0x44, 0x38, // o
                         0x7C, 0x14, 0x14, 0x14, 0x08, // p
                         0x08, 0x14, 0x14, 0x14, 0x7C, // q
                         0x00, 0x7C, 0x08, 0x04, 0x04, // r
                         0x48, 0x54, 0x54, 0x54, 0x20, // s
                         0x04, 0x04, 0x3F, 0x44, 0x44, // t
                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u
                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v
                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w
                         0x44, 0x28, 0x10, 0x28, 0x44, // x
                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y
                         0x44, 0x64, 0x54, 0x4C, 0x44, // z
                         0x00, 0x08, 0x36, 0x41, 0x41, // {
                         0x00, 0x00, 0x7F, 0x00, 0x00, // |
                         0x41, 0x41, 0x36, 0x08, 0x00, // }
                         0x02, 0x01, 0x02, 0x04, 0x02};// ~

/////////////////////////////////////////////////////////////////////////
#define TAM_FONT1        ( sizeof ( FONT1 ) / 5 )


#int_RDA
RDA_isr()
{

}

#int_TIMER0
TIMER0_isr()
{

}
////////////////////////////////////////////////////////////////////////
unsigned int8 Inverte_bits ( unsigned int8 Palavra )
{
unsigned int8 Resultado = 0 ;
if ( bit_test( Palavra , 0 ) ) Resultado |= BIT7 ;
if ( bit_test( Palavra , 1 ) ) Resultado |= BIT6 ;
if ( bit_test( Palavra , 2 ) ) Resultado |= BIT5 ;
if ( bit_test( Palavra , 3 ) ) Resultado |= BIT4 ;
if ( bit_test( Palavra , 4 ) ) Resultado |= BIT3 ;
if ( bit_test( Palavra , 5 ) ) Resultado |= BIT2 ;
if ( bit_test( Palavra , 6 ) ) Resultado |= BIT1 ;
if ( bit_test( Palavra , 7 ) ) Resultado |= BIT0 ;
return ( Resultado ) ;
}
////////////////////////////////////////////////////////////////////////
void PlotaColuna ( void )
{
if ( StringToDisplay [ PonteiroString ] >= 'S' )
   PortaB = ( TEXT2 [ ( ( ( StringToDisplay [ PonteiroString ] - 'S' ) * 5 ) + PonteiroChar ) ] ) ;
if ( StringToDisplay [ PonteiroString ] <= 'R' )
   PortaB = ( TEXT1 [ ( ( ( StringToDisplay [ PonteiroString ] - 'S' - TAM_TEXT1 ) * 5 ) + PonteiroChar ) ] ) ;
if ( ( PonteiroString == 0 ) & ( PonteiroChar == 0 ) )
   {
   output_bit ( DADOSERIAL , HIGH  )   ;
   }
PortaB = Inverte_bits( PortaB )    ;
output_b   ( PortaB  )             ;
output_bit ( CLOCK , HIGH  )       ;
delay_us   ( 1000 )                ;
output_bit ( CLOCK , LOW   )       ;
output_bit ( DADOSERIAL , LOW  )   ;
 }
////////////////////////////////////////////////////////////////////////
void EscreveNoDisplay ( unsigned int8 modo )
{
if ( modo == SEM_ANIMACAO )
   {
   PonteiroString = 0            ;
   while ( PonteiroString < TamanhoString )
      {
      PonteiroChar = 0           ;
      while ( PonteiroChar < 5 )
         {
         PlotaColuna()           ;
         PonteiroChar++          ;
         }
      PonteiroString++           ;
      }
   }
}
////////////////////////////////////////////////////////////////////////
void main( void )
{

   set_tris_a (0xFF) ; // ( BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1 | BIT0 ) = 0b11111111
   set_tris_b (0x80) ; // ( BIT7 |   0  |   0  |   0  |   0  |   0  |   0  |   0  ) = 0b10000000
   set_tris_c (0x02) ; // ( BIT7 |   0  |   0  |   0  | BIT3 | BIT2 | BIT1 | BIT0 ) = 0b00000010

   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
// setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
// setup_timer_1(T1_DISABLED);
// setup_timer_2(T2_DISABLED,0,1);
// enable_interrupts(INT_RDA);
// enable_interrupts(INT_TIMER0);
// enable_interrupts(GLOBAL);

   while(1)
   {
   EscreveNoDisplay( SEM_ANIMACAO );
   }
}

+++

/*
fiz este programa há alguns anos para acionar um display matriz de
leds que tem as seguintes características:

14 display de matriz de 5x7

1 idéia +- como ele é:

dipslay 1 ...................... display 14

0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 1 (decodificado por 74HC138)
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 2 (portanto ligados à suas saídas)
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 3 (lógico não diretamente)
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 4 (e sim com transistores)
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 5 (sinais de entrada do hc138=PORTB)
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 6
0 0 0 0 0 ...................... 0 0 0 0 0-- catodo comum 7
| | | | | | | | | |
| | | | | | | | | |
8 ci´shift register 74HC164 (ligados não diretamente e sim com unl2002)

Obs:
este programa foi de uso comercial, portanto me senti a vontade em
retirar as partes que não lhe são importantes

espero que [não] lhe seja [in]útil!!
abraço
*/



/* Programa para uControlador PIC16F876 controle de display matricial */
/* início 06/03/2001 V.0.0 simulação*/
//V 1.0 pic16f876A com display spider
#include <pic.h>
#include "tabela.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 dd RB1 //tem inversor 74HC04 no pino
#define ck RB0 //tem inversor 74HC04 no pino
#define clk164 ck=0;ck=1 //tem inversor 74HC04 no pino

//************************ 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
{
if (s&1) dd=0;
else dd=1;
s>>=1;
clk164;
}
}
/**********************************************************************/
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;
static void interrupt
timer1_int(void)
{
unsigned char j,lin,t,tmp,tr;
TMR1IF=0;
TMR1H=tm1h; //restaura 400Hz int
TMR1L=tm1l;
T1CON=0B00010101; //prescaler /2,osc. dis.,not sync.,interno fosc/4,timer on
PORTB=0b00011111; //apaga display
switch (lin)
{
case 0: for (j=0;j<14;j++) shift(lin6[j]); break;
case 1: for (j=0;j<14;j++) shift(lin0[j]); break;
case 2: for (j=0;j<14;j++) shift(lin1[j]); break;
case 3: for (j=0;j<14;j++) shift(lin2[j]); break;
case 4: for (j=0;j<14;j++) shift(lin3[j]); break;
case 5: for (j=0;j<14;j++) shift(lin4[j]); break;
case 6: for (j=0;j<14;j++) shift(lin5[j]); break;
}

tmp=lin;
tmp<<=5;
tmp=tmp^0xff;
tmp|=3;
PORTB=tmp;
lin++;
if (lin>6) lin=0;
dl--;
if (!t--) {RC7^=1;RC6^=1;}
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 ");
delay(0xff);
rl=1;
while(crl);
rl=0;
msgdsp(0,"me fortalece!");
delay(0xff);
rl=1;
while(crl);

}
}


//tabela.c
unsigned char const tabdisp[]={

0b00000,
0b00000,
0b00000,
0b00000, //spc
0b00000,
0b00000,
0b00000,

0b00100,
0b00100,
0b00100,
0b00100, //!
0b00100,
0b00000,
0b00100,

0b01010,
0b01010,
0b01010,
0b00000, //"
0b00000,
0b00000,
0b00000,

0b01010,
0b01010,
0b11111,
0b01010, //#
0b11111,
0b01010,
0b01010,

0b01111,
0b10100,
0b01100,
0b00110, //$
0b00101,
0b11110,
0b00100,

0b11000,
0b11001,
0b00010,
0b00100, //%
0b01000,
0b10011,
0b00011,

0b01100,
0b10001,
0b10100,
0b01000,
0b10101, //&
0b10010,
0b01101,

0b01100,
0b00100,
0b00000,
0b10000, //'
0b00000,
0b00000,
0b00000,

0b00010,
0b00100,
0b01000,
0b01000, //(
0b01000,
0b00100,
0b00010,

0b01000,
0b00100,
0b00010,
0b00010, //)
0b00010,
0b00100,
0b01000,

0b00000,
0b00100,
0b10101,
0b01110, //*
0b10101,
0b00100,
0b00000,

0b00000,
0b00100,
0b00100,
0b11111, //+
0b00100,
0b00100,
0b00000,

0b00000,
0b00000,
0b00000,
0b00000, //,
0b01100,
0b00100,
0b01000,

0b00000,
0b00000,
0b00000,
0b11111, //-
0b00000,
0b00000,
0b00000,

0b00000,
0b00000,
0b00000,
0b00000,
0b00000, //.
0b01100,
0b01100,

0b00000,
0b00001,
0b00010,
0b00100, // /
0b01000,
0b10000,
0b00000,

0b01110,
0b10001,
0b10011,
0b10101, //0
0b11001,
0b10001,
0b01110,

0b00100,
0b01100,
0b00100,
0b00100, //1
0b00100,
0b00100,
0b01110,

0b01110,
0b10001,
0b00001,
0b00010, //2
0b00100,
0b01000,
0b11111,

0b11111,
0b00010,
0b00100,
0b00010, //3
0b00001,
0b10001,
0b01110,

0b00010,
0b00110,
0b01010,
0b10010, //4
0b11111,
0b00010,
0b00010,

0b11111,
0b10000,
0b11110,
0b00001, //5
0b00001,
0b10001,
0b01110,


0b00110,
0b01000,
0b10000,
0b11110, //6
0b10001,
0b10001,
0b01110,

0b11111,
0b00001,
0b00001,
0b00010, //7
0b00100,
0b01000,
0b01000,

0b01110,
0b10001,
0b10001,
0b01110, //8
0b10001,
0b10001,
0b01110,

0b01110,
0b10001,
0b10001,
0b01111, //9
0b00001,
0b00010,
0b01100,

0b00000,
0b00000,
0b01100,
0b01100,
0b00000, //:
0b01100,
0b01100,

0b00000,
0b01100,
0b01100,
0b00000,
0b01100, //;
0b00100,
0b01000,

0b00010,
0b00100,
0b01000,
0b10000, //<
0b01000,
0b00100,
0b00010,

0b00000,
0b00000,
0b00000,
0b11111, //=
0b00000,
0b11111,
0b00000,

0b01000,
0b00100,
0b00010,
0b00001, //>
0b00010,
0b00100,
0b01000,

0b01110,
0b10001,
0b00001,
0b00010,
0b00100, //?
0b00000,
0b00100,

0b01110,
0b10001,
0b00001,
0b01101,
0b10101, //@
0b10101,
0b01110,

//***************************

0b00100,
0b01010,
0b10001,
0b11111, //A
0b10001,
0b10001,
0b10001,

0b11110,
0b10001,
0b10001,
0b11110, //B
0b10001,
0b10001,
0b11110,

0b01110,
0b10001,
0b10000,
0b10000, //C
0b10000,
0b10001,
0b01110,

0b11100,
0b10010,
0b10001,
0b10001, //D
0b10001,
0b10010,
0b11100,

0b11111,
0b10000,
0b10000,
0b11110, //E
0b10000,
0b10000,
0b11111,

0b11111,
0b10000,
0b10000,
0b11110, //F
0b10000,
0b10000,
0b10000,

0b01110,
0b10001,
0b10000,
0b10011,
0b10001, //G
0b10001,
0b01111,

0b10001,
0b10001,
0b10001,
0b11111, //H
0b10001,
0b10001,
0b10001,

0b01110,
0b00100,
0b00100,
0b00100, //I
0b00100,
0b00100,
0b01110,

0b01110,
0b00100,
0b00100,
0b00100, //J
0b00100,
0b10100,
0b01000,

0b10001,
0b10010,
0b10100,
0b11000, //K
0b10100,
0b10010,
0b10001,

0b10000,
0b10000,
0b10000,
0b10000, //L
0b10000,
0b10000,
0b11111,

0b10001,
0b11011,
0b10101,
0b10001, //M
0b10001,
0b10001,
0b10001,

0b10001,
0b11001,
0b10101,
0b10011, //N
0b10001,
0b10001,
0b10001,

0b01110,
0b10001,
0b10001,
0b10001, //O
0b10001,
0b10001,
0b01110,

0b11110,
0b10001,
0b10001,
0b11110, //P
0b10000,
0b10000,
0b10000,

0b01110,
0b10001,
0b10001,
0b10001, //Q
0b10101,
0b10010,
0b01101,

0b11110,
0b10001,
0b10001,
0b11110, //R
0b10100,
0b10010,
0b10001,

0b01111,
0b10000,
0b10000,
0b01110, //S
0b00001,
0b10001,
0b11110,

0b11111,
0b00100,
0b00100,
0b00100, //T
0b00100,
0b00100,
0b00100,

0b10001,
0b10001,
0b10001,
0b10001, //U
0b10001,
0b10001,
0b01110,

0b10001,
0b10001,
0b10001,
0b10001, //V
0b10001,
0b01010,
0b00100,

0b10001,
0b10001,
0b10001,
0b10001, //W
0b10101,
0b11011,
0b10001,

0b10001,
0b10001,
0b01010,
0b00100, //X
0b01010,
0b10001,
0b10001,

0b10001,
0b10001,
0b01010,
0b00100,
0b00100, //Y
0b00100,
0b00100,

0b11111,
0b00001,
0b00010,
0b00100, //Z
0b01000,
0b10000,
0b11111,

0b01110,
0b01000,
0b01000,
0b01000, //[
0b01000,
0b01000,
0b01110,

0b00000,
0b10000,
0b01000,
0b00100, // \
0b00010,
0b00001,
0b00000,

0b01110,
0b00010,
0b00010,
0b00010, //]
0b00010,
0b00010,
0b01110,

0b00100,
0b01010,
0b10001,
0b00000, //^
0b00000,
0b00000,
0b00000,

0b00000,
0b00000,
0b00000,
0b00000, //_
0b00000,
0b00000,
0b11111,

0b01000,
0b00100,
0b00010,
0b00000, //`
0b00000,
0b00000,
0b00000,


0b00000,
0b00000,
0b11110,
0b00001, //a
0b01111,
0b10001,
0b01111,

0b10000,
0b10000,
0b10110,
0b11001, //b
0b10001,
0b10001,
0b11110,

0b00000,
0b00000,
0b01110,
0b10000, //c
0b10000,
0b10001,
0b01110,

0b00001,
0b00001,
0b01101,
0b10011, //d
0b10001,
0b10001,
0b01111,

0b00000,
0b00000,
0b01110,
0b10001, //e
0b11111,
0b10000,
0b01110,

0b00110,
0b01001,
0b01000,
0b11100, //f
0b01000,
0b01000,
0b01000,

0b00000,
0b01111,
0b10001,
0b10001,
0b01111, //g
0b00001,
0b01110,

0b10000,
0b10000,
0b10000,
0b10110,
0b11001, //h
0b10001,
0b10001,

0b00100,
0b00000,
0b01100,
0b00100, //i
0b00100,
0b00100,
0b01110,

0b00010,
0b00000,
0b00110,
0b00010, //j
0b00010,
0b10010,
0b01100,

0b10000,
0b10000,
0b10010,
0b10100, //k
0b11000,
0b10100,
0b10010,

0b01100,
0b00100,
0b00100,
0b00100, //l
0b00100,
0b00100,
0b01110,

0b00000,
0b00000,
0b11010,
0b10101, //m
0b10101,
0b10001,
0b10001,

0b00000,
0b00000,
0b10110,
0b11001, //n
0b10001,
0b10001,
0b10001,

0b00000,
0b00000,
0b01110,
0b10001, //o
0b10001,
0b10001,
0b01110,

0b00000,
0b00000,
0b11110,
0b10001, //p
0b11110,
0b10000,
0b10000,

0b00000,
0b00000,
0b01101,
0b10011, //q
0b01111,
0b00001,
0b00001,

0b00000,
0b00000,
0b10110,
0b11001, //r
0b10000,
0b10000,
0b10000,

0b00000,
0b00000,
0b01110,
0b10001, //s
0b01110,
0b00001,
0b11110,

0b01000,
0b11100,
0b01000,
0b01000, //t
0b01000,
0b01001,
0b00110,

0b00000,
0b00000,
0b10001,
0b10001, //u
0b10001,
0b10011,
0b01101,

0b00000,
0b00000,
0b10001,
0b10001, //v
0b10001,
0b01010,
0b00100,

0b00000,
0b00000,
0b10001,
0b10001, //w
0b10101,
0b10101,
0b01010,

0b00000,
0b00000,
0b10001,
0b01010, //x
0b00100,
0b01010,
0b10001,

0b00000,
0b00000,
0b10001,
0b10001, //y
0b01110,
0b00001,
0b01110,

0b00000,
0b00000,
0b11111,
0b00010, //z
0b00100,
0b01000,
0b11111,


};

//fim tabela.c

lellis,

Gostei do modo como voce implementou o mapeamento das colunas.
Porém, fiquei muito curioso em saber porque voce conswguiu compilar com a variavel tabdisp[] ( que visivelmente possui + que 256 bytes ), enquanto que do modo como implementei, isso nao foi possível.

Voce usou o CCS ?

+++

Show de bola!

Valeu pelo codigo estou estudando ele para ver se consigo montar. gostaria se voce puder postar o circuito tambem
Obrigado

o circuito é exatamente o que voce propôs.....utiliza um shift-register.
No meu caso, usei o 74LS164 ao invéz do 4094.

+++

infelizmente acesso muito pouco este forum. (mas pelo menos 1 vez por dia)

O compilador se virou para mapear para mim. Compilei para um .asm para verificação. O texto .asm ficou grande e vai ocupar mui espaço aqui. Não sei como colocar ou se é possível postar um .zip aqui. Ou senão posso enviar-lhe o .asm e .hex (pra ti e quem tiver interesse) . Não uso ccs não. Uso outro que custou ~U$1600.

o código ocupou: 1418 words (17,3%) e 127 bytes (34,5%) do pic 16f876a
qdo tiver 1 tempo, vou carregar o .hex no mplab e ver o que ele faz.
abraços

lellis,

Tá explicado. Voce não usa o CCS.
Voce poderia passar o nome desse compilador que voce usou ?

Obrigado.