Matriz Led's - C/ texto rolante

Lucasfonoli · 4 de março de 2011

Estou fazendo o firmware pra um PIC controlador geral para uma matriz de leds que vou fazer. Mas estou com duvidas relativas a algumas operações com matriz

Na parte lógica, eu pensei em fazer um array jagged triplo, onde o primeiro parametro determina o caracter e os outros 2 ( C[][j]) determina uma matriz de 0's e 1's onde representaria o desenho dos caracteres. a partir daí, eu iria sobrescrever essas matrizes em outra matriz, bidimencional com largura definida e comprimento inderinido, formando uma frase com essas letras...

daí com a frase pronta, já desenhada para passar as informações para os microcontroladores secundários executarem nas linhas e colunas dos leds

a duvida é justamente quanto a sobrescrever uma matriz em outra de forma direta... não serve so fazer: X[][] = C[1][][];... porque as letras vão uma ao lado da outra, e nao no mesmo lugar... eu até faz fiz um trecho de programa pra isso, mas acho que tem outros jeitos mais faceis que demorem menos ciclos para serem realizadas...

ta aqui o trecho do programa: (nao coloquei a parte onde ele coleta e identifica o caracter, mas a variavel "m" define a largura das letras)

short C[50][10][], X[10][];

int caracter;

int i, j, j2;

void main

{

For (j<=m, j++)

{

For (i<=10, i++)

{

X[j2] = C[caracter][j];

}

i = 0;

j2++;

}

j=0;

}

Mais uma ultima duvida. Eu posso igualar uma coluna inteira de X a outra de C? como por exemplo: X[][j2] = C[caracter][][j];

.if · 4 de março de 2011

pra rolar letra de ponto em ponto me lembro que ralei pracarái. Se eu achar meus fontes que faziam isso, quem sabe teremos uma luz

Mas veja isso. Pode não lhe ser totalmente inútil...

voce deve PRIMEIRO definir seu hw. Veja uma forma que usei há alguns anos com um pic e uns 4017. O projeto da foto foi com um pic18 há muitos anos, mas o fonte... talvez ainda exista... talvez. preguiça de procurar muito menos hoje.... Salve a foto e abra-a com o 7-zip (o windows não abre como zip. troque a extensão). . A imagem do fundo é de um carinha daqui mesmo. De repente ele vendo, te ajude.

De novo, projeto no zip NÃO É O DA FOTO e sim com um pic16f e 4017 como disse.

sucessos

bom carnaval. e cuidado com trios "elétricos"!!!

vtrx · 4 de março de 2011

para os microcontroladores secundários

voce precisa,no mínimo ,de um 16F628,uma Eeprom 24CXX,ShiftRegister como o 74HC595,drivers como o ULN2803.

O deslocamento exite N opções de se fazer.

Fiz um programinha,ha algum tempo,para auxiliar a montar os caracteres 8X8.

Ta desatualizado mas deve ajudar em algo.

http://www.4shared.com/file/pi09bjMi/montador.html

Lucasfonoli · 4 de março de 2011

valeu a ajuda, mas infelizmente nao consegui localizar o tal arquivo zip...

nao entendi a parte do hw, o que é esse hw?

quanto a parte da rolagem do texto, ja estou com as ideias na cabeça e ja sei como fazer, o que estou com problemas agora foi justamente o que perguntei no topico, que é a questao de sobreescrever matriz sobre pedaço de outra...

dai com a matriz frase pronta (preferencialmente usando menos ciclos, otimizando o codigo que coloquei la em cima), eu dividiria a matriz de leds em pedaços... vamos supor uma 8x8. Daí o codigo, ja implementando rolagem com seleção de velocidade seria + ou - assim:

pra as colunas é só ir trocando o sinal entre elas, em sequencia, com uns 5ms, o que geraria uma imagem a 25fps

pra as linhas, fazia + ou - assim

int i, z, y, w, k

short X[8][];

For (true)

{

For (i <= z, i++) /*o z determina quantas vezes ele vai rodar o for antes de

{ a frase andar 1 pixel. Se for z=4, ele roda o for 5 vezes e assim

anda 1 pixel a cada 200ms.*/

y = w; /*enquanto w ainda for 0, a matriz so mostra as colunas de 0 a 7, mas

k = y + 7; se fizer w = 1, agora a matriz mostra as colunas de 1 a 8... */

For (y<=k, y++)

{

PortB = X[][y];

delay 5ms;

}

w++;

i = 0;

}

qual a diferença, na pratica, do 16f84a (que tava querendo usar, porque ja tenho ideia de como é) e o 16f628-a? pra que servirá o shiftregister 74hc595? e o uln2803 é pra evitar usar microcontroladores para cada segmento da matriz?

vtrx · 4 de março de 2011

valeu a ajuda, mas infelizmente nao consegui localizar o tal arquivo zip...

Não entendí.

qual a diferença, na pratica, do 16f84a (que tava querendo usar, porque ja tenho ideia de como é) e o 16f628-a?

voce pode usar o 16F84,a diferença é melhor ler no datasheet(disse o mínimo porque o 84 é caso raro de achar).

pra que servirá o shiftregister 74hc595?

Para fazer a varredura.

uln2803 é pra evitar usar microcontroladores para cada segmento da matriz

São os Buffer,ou drivers se preferir.

Da uma analisada neste esqumea.

Não é nescessário usar o PIC do esquema.

Lucasfonoli · 4 de março de 2011

ah, agora eu lembrei desses uln... tava esquecido, mas lembro que uma vez usei pra evitar usar um transistor em cada linha, pra aumentar o sinal... ja que a saida do pic mal guenta 1 led, imagina 8 leds em paralelo...

quanto ao 74hc595 acho bem interressante, ja que fazer uma simples varredura com pic seria disperdício de função... mas nao sei como eles funcionam... é só jogar um sinal como "clock" e ele muda a saida a cada sinal do clock?

vtrx · 5 de março de 2011

...é só jogar um sinal como "clock" e ele muda a saida a cada sinal do clock?

Mais ou menos isso,da uma olhada no datasheet dele.

Lucasfonoli · 5 de março de 2011

valeu galera, vocês estão me ajudando muito. Vou procurar os datasheet e topicos e materias relacionadas a cada componente desse separadamente...

Mas ainda estou com a duvida do inicio do topico, sobre uma maneira otimizada de sobreescrever uma matriz em cima da outra, apenas dizendo a partir de que coluna ela sera sobreescrever (como, por exemplo, mandar o programa sobreescrever as 10 colunas de uma matriz C sobre as colunas de 30 a 40 de uma matriz X)

test man*~ · 5 de março de 2011

Cara, andei mexendo com isso um tempo atrás... Montei um painel na simulação tomando como exemplos os links que segue no tópico abaixo.

http://forum.clubedohardware.com.br/matriz-leds-resistor/775415

Na prática montei apenas com 1x5x7 dot matrix para testar, estou com 620 LEDs daqueles de ônibus (consegui um painel estragado, mas os leds estavam OK e são show de bola), pretendo montar uma bacana mais pra frente. Estou começando a mexer com CLPs da Rockwell e estou meio parado com os PICs.

Lucasfonoli · 6 de março de 2011

eu tava analisando aqui: Se eu usar apenas uma varredura para 80 colunas, pela propriedade do PWM, o duty cicle de cada led vai ser de apenas 1,25%... então para eu atingir a tensão ideal para um bom brilho dos leds, eu deveria trabalhar com uns 80v se quisesse gerar pelo menos 1v final pra cada led, certo? então o ideal não seria trabalhar com varredura múltipla, com as linhas divididas em segmentos de, por exemplo 8 leds cada? aumentando o duty cicle para 12,5% (apesar de necessitar de bem mais terminais, mas há possibilidade de implementar uns shift registers nas linhas também)

Lucasfonoli · 10 de março de 2011

alguel que ja fez uma matriz dessa, colocou quantos volts nos leds?

.if · 10 de março de 2011

oi. não sei se vou conseguir explicar com [poucas] palavras. Por partes: tá vendo aquela foto naquele meu post? então. clique com o botão direito do mouse nela. clique em "salvar imagem como". depois mude sua extensão para .zip e abra com o 7-zip (www.7-zip.org). Também pode testar com winrar ou winzip

Não entendi sua dúvida mas vejamos...

Olhando a parte prática da coisa, sugiro que faça uma varredura vertical via interrupção para limitar em 8 linhas. Para compor as n colunas entra em ação o famigerado 74595. No fonte abaixo foi usado 14 74hc164 e 7 linhas. Era de uma sucata de matriz de leds. Talvez voce não entenda de imediato mas fica registrado pra posteridade pois deu o que fazer pra eu achar nos meus backups. Mas foi muito menos trabalhoso do que elaborar isto do zero há alguns anos atrás.

Se eu forçar um pouco meu único e último neurônio e só olhando no fonte posso até visualizar o hw (circuto). Mas transformá-lo em texto... esquece

#define ck RB0
#define clk164 ck=0;ck=1

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() //para deslocar a mensagem
{
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) //aqui está a varredura de uma linha de 112 leds por vez
{
case 0: for (j=0;j<14;j++) shift(lin6[j]); break; //cada shift desloca 8 bits
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; //só 7 linhas
dl--;//usado na função delay
if (!t--) {RC7^=1;RC6^=1;}
if (rl&&!tr--) //o flag rl permite deslocar a mensagem
{
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++);
}
#define dd   RB1

e também a tabela de caracteres

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,

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

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,
0b10000,
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,

};
unsigned char const tabdispm[]={

note que não tem nenhuma operação complexa de matriz

voce, .....é.... voce mesmo que está lendo este tróço, faça bom uso

sucessos!

vtrx · 10 de março de 2011

Percebí que a quantidade de downloads do utilitário que fiz ,a um bom tempo atrás,esta crescendo.

Então resolví atualiza-lo.

Agora ele tanto pode gerar um arquivo com os bytes em binário dos caracteres que voce montar como tambem poderá salvar esses bytes em formato pronto para compiladores C.

Lembrando que ele gera caracteres em 8X8.

Amanhão troco o link do arquivo.

Lucasfonoli · 12 de março de 2011

eu consegui abrir o arquivo zip que ta nessa foto, mas não consegui entender muita coisa do seu codigo não. Não sei porque mas achei ele meio confuso, talvez por não estar muito familiarizado com algumas coisas que usou lá...

Mas eu estou com algumas duvidas referentes ao 74HC595, que são de extrema importancia para sequer entender os codigos. Provavelmente só falta isso para eu terminar essa parte inicial do meu código...

vejam se é +/- assim mesmo: (ao invés de usar o nome dos pinos do pic, vou colocar o nome dos pinos do 74hc595)

Pra jogar um sinal 0011

CLK=0;CLK=1;

DS=1;

CLK=0;CLK=1;

DS=0;

CP=0;CP=1;

vtrx · 13 de março de 2011

Para ajudar a quem interessar e como é de costume,sempre faço utilitários para meus projetos.

O utilitário que estava no link acima,foi atualizado e estou verificando a existencia de algum bug inicial.

Agora voce pode montar sua tabela ou caracteres (8X8),visualizá-los,editálos e por fim gravar em formato C,ASM ou hex,sendo que em hex voce pode gravar direto numa Eeprom,caso use um micro com pouca memória ou use uma Eeprom no seu projeto.

Os arquivos .c ou .asm voce vai juntar ao seu código.

Vai tambem a tabela completa de caracteres do ZX Spectrum que acho muito bem feita para 8X8.

Lucasfonoli · 13 de março de 2011

mas ainda estou com a duvida em relação so shift register... e só posso proseguir no desenvolvimento do resto do programa (a parte de coleta de dados do teclado pelo protocolo ps2) dps de fazer essa parte basica dos 74HC595

.if · 14 de março de 2011

"Pra jogar um sinal 0011

CLK=0;CLK=1;

DS=1;

CLK=0;CLK=1;

DS=0;

CP=0;CP=1; "

Está no caminho certo. porém prefira programar o DS PRIMEIRO

DS=1;

CLK=0;CLK=1;

DS=0;

CLK=0;CLK=1;

CP=0;CP=1;

Mas que tal evoluirmos um pouco e shiftarmos 8 bits?

#define DS RB0

#define CLK RB1

#define CP RB2

void shift(unsigned char s)

{

unsigned char k;

for (k=0;k<8;k++) //8 bits=1 byte...se não sabia...voce precisa de outro tipo de ajuda

{

DS=s;//o bit ...

CLK=0;CLK=1;//..através do pulso de clock...

s>>=1;//...desloca 8 vezes e...

}

CP=0;CP=1;//...depois trava as saídas

}

Naqueles fontes tem isso mas lhe deve ter passado desapercebido. Também tem o acionamento completo da matriz de leds. No entanto, no momento devem lhe parecer muito complexos. Guarde e aguarde para momentos futuros quando estiver mais maduro (mas nem tanto a ponto de apodrecer como eu. rs)

sucessos!

Lucasfonoli · 14 de março de 2011

O acionamento completo da matriz de leds não me preocupa muito não, já estou com muita coisa pronta, apenas estava com algumas duvidas pequenas, detalhes, principalmente por nunca ter usado um shift antes... Mas já fiz os codigos gerais para a matriz, inclusive com os efeitos de movimentos e piscar das palavras, com velocidades diferentes.

Eu estranhei um pouco nesse código a parte do >>=, que não consegui lembrar desse operador lógico...

Uma outra duvida referente ao shifht:

Se eu quiser, por exemplo, apenas andar o sinal pelos pinos, que será necessário na multiplexacão da matriz, posso fazer da seguinte maneira?:

DS=1;

CLK=0;CLK=1;

CP=0;CP=1;

Delay 5ms;

DS=0;

CLK=0;CLK=1;

CP=0;CP=1;

Delay 5ms;

CLK=0;CLK=1;

CP=0;CP=1;

Delay 5ms;

dai ele variaria de 100 --> 010 --> 001?

.if · 14 de março de 2011

sim amigo. Mas depois que voce entender a função shitf() as portas vão se abrir pois desta maneira que está fazendo não é nada versátil.

Não que não quero responder pois custa-me pouco, mas nada melhor do que voce fazer um teste prático que tal? pode simular primeiro.

Aquele operador >>=1 (deslocamento) é a essência da coisa. Não o confunda com o deslocamento do hw pois ele é feito na memória do pic e não no circuito

obs: corrigi a função

sucessos

Lucasfonoli · 14 de março de 2011

ah, agora que percebi que era uma função específica para o shift.. agradeço muito a sua ajuda. Vou fazer alguns testes aqui no proteus. Mas tem um detalhe que me surgiu. Já que ele já coloca variável inteira no shift, ja fazendo o deslocamento e tal, ou terei que inverter a variável antes é? tipo, fazer 00110000 o que é 00001100??

quanto ao metodo que estava fazendo, eu nao tinha intencao de usar assim, era so pra ser algo mais pratico de digitar pra tirar minha duvida, mas já tinha feito uma implementação com blocos For, apenas sem usar essa função específica para o shift

.if · 14 de março de 2011

não precisa inverter. é só questão de ordenar os bits na saída de maneira apropriada, né.

Ou seja os leds. Neste caso quem vai primeiro é o bit0. Se fizer questão que seja o bit7 primeiro também dá. Há de fazer mínima mudança na função. Mas acho que não é o caso.

abç

vtrx · 14 de março de 2011

Lucas,não sei a quanto andas seu código,mas faça sua lógica de varredura dos Leds da esquerda para direita,como nas tvs,que é o mais comum e de fácil lógica de programação.

A tabela de caracteres do ZXSpectrum é orientada neste sentido.

Exemplo;

.if · 15 de março de 2011

pois eu sugiro que faça de cima pra baixo (ou vice versa) pois o duty cicle (tempo em que o led vai permanecer aceso) pode ser de 16% (100/6linhas => 6 linhas de leds) em contraste com os menos de 1% (100/+de100colunas) no caso da horizontal. Além de poder fazer com uma interrupção de uns 400Hz deixando o loop principal livre por + tempo. Mas isso é só pra quem quem quer fugir do lugar comum. Não esqueça que existe uma varredura e uma varredura.

Oh... dúvida cruel... rs

abç

vtrx · 15 de março de 2011

Veja,como no vídeo,a lógica é cada coluna um pino do 74HC595 sendo deslocado para direita,igual a varredura do monitor que voce esta vendo e igual aos esquemas encontrados.

A maioria de mapa de bits esta orientado assim,inclusive o utilitario que vou passar no link.

Pega o primeiro byte,da saída por um port,todos os Leds ficaram acesos com esse byte,mas apenas a coluna 1 estará habilitada,depois vai o segundo byte do caractere no port todo mas apenas a coluna 2 vai estar ativada e assim por diante com um caractere ou uma frase.