Como eu faço uma matriz rolante

charlesfrances · 4 de setembro de 2013

:peço uma ajuda gostaria de entender como eu faço uma matriz rolante eu tenho o código completo funcionando,sem erros! simulado no proteus

o que estou tentando dizer é que eu quero primeiro entender o código e depois expandir! peço um pouco da experiência e paciência de vocês

com 2 shift register na linha e coluna ,crei que esse é um assunto que já vem sendo tratado

a muito tempo no clube do hardware ,acredito que alguém possa me ajudar!

Deus abençoe a todos!

ricardospimentel · 4 de setembro de 2013

A gente pode sim te dar uma força. Para isso, poste o teu código entre

 e depois teu circuito também.

Essa montagem seria para hobby?

charlesfrances · 4 de setembro de 2013

Sim amigo! sim ´só fiz curso e fico juntando certificado ainda naõ tive a felicidade

de fazer uma faculdade mesmo tendo terminado o ensino médio...

#fuses INTRC_IO,MCLR // Oscilador interno, MCLR activo
#fuses NOPUT,NOBROWNOUT // Sin Brownout reset ni Power up timer
#use fast_io(all) // A configuração da porta é só o começo

#use delay(clock=8M). // Velocidad del oscilador interno 8 MHz

#define Load PIN_B0. // Load (STCP ambos integrados) B0
#define Clk PIN_B1 // Clock (SHCP ambos integrados) B1
#define dClm PIN_B2 // Data para las columnas (DS integrado 1) BC2
#define dLin PIN_B3 . // Data para las lineas (DS integrado 2) B3

char Memoria[96]: // 96 Bytes para la memoria (0 - 95)
char Visor[8]: // 8 para el visor (8 columnas)

int1 flag; // Flags de control
int1 flag2;
int indx; / // Indice donde almacenará las nuevas columnas.
int line;. // Linea que a mostrar.
int time; . // Variables para el control de
int ptime; . // la velocidad de desplazamiento.
int t;. // Variable auxiliar.

void CargaMem(char Ascii);
void GuardaClm(char c);

#int_rtcc
void isr(){
int Mul=128; // Cada vez que ocurre la interrupcion
if(++line>7)Line=0; // selecciona la siguiente linea, si se pasa de 7 vuelve a 0.

if(++ptime>5){ // Suma 1 a ptime. Si se pasa de 20
ptime=0; // lo pone en 0 y suma 1 a time.
if(++time>200){ // Si se pasa de 200
time=0; // lo pone en 0
Flag=true: // y activa el flag.
}
}

for(t=0;t<8;t++){ // Bucle 0 - 7 (Lineas)

output_bit(dLin,!!(Visor[Line]&Mul)); // dLin es seteado con el valor
// del bit de la fila actual.
if (Line==t)output_high(dClm); // Si Line es igual a t
// activa el bit correspondiente
else output_low(dClm); // a la columna, sino lo desactiva.

output_low(Clk); . //
output_high(Clk); // Rota el contenido interno del 74HC595.

Mul>>=1; // Divide la mascara que compara con Visor[] (128,64,32...)
}
output_low(Load);.
output_high(Load);// El contenido interno del integrado pasa a las salidas.

}
void main().{
int k;
set_tris_a(0x00);
set_tris_b(0x00);
for (k=0;k<8;k++){
Visor[k]=0;.
}
for (k=0;k<96;k++){
Memoria[k]=0;
} // Limpia la memoria y el visor

flag=true; // Activo el flag para que cargue la memoria

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); // Configuración del Timer0
enable_interrupts(int_rtcc); // Interrupcion por Timer0
enable_interrupts(global); // Interrupciones globales

do{
if (Flag){ // Si el flag está activado
flag2=true; // Activa el flag2

for (k=0;k<8;k++){ // Pasa el contenido de las primeras 8
visor[k]=Memoria[k]; // columnas en memoria al visor
}

for (k=0;k<95;k++){ // Rota el contenido de toda la memoria
Memoria[k]=Memoria[k+1];// a la izquierda 1=1+1, 2=2+1, n=n+1...

if (Memoria[k]!=0){Flag2=false;} // Si hay alguna columna que no
// esté vacía desactiva el flag2
}
Memoria[95]=0; // Limpia la ultima columna de la memoria

if (Flag2){ // Si flag2 está activo
indx=7; // a partir de la columna 7
CargaMem("PICROBOT"); // escribe PICROBOT
}
Flag=false; // Desactiva el flag

}
}while (true); // Bucle infinito

}

void GuardaClm(char c){
if (indx<94){
Memoria[indx]=c; // Guarda la columna en la ubicación actual de memoria
indx++; // y aumenta el indice
}
}

void CargaMem(char ascii){ // Carga la memoria con el caracter deseado
switch (ascii){

case('B'):
GuardaClm(0b01111111);
GuardaClm(0b01111111);
GuardaClm(0b01001001);
GuardaClm(0b01001001);
GuardaClm(0b01111111);
GuardaClm(0b00110110);
break;
#include <16f88.h> .     // Tipo de microcontrolador

e os demais case etc... do nome entendeu! (PICROBOT)

Eu gostaria muito mesmo de poder entender e compartilhar minhas ideias depois de resolver esta duvida que tem dado tanta dor de cabeça aos iniciantes e hobbystas como eu!!

vtrx · 4 de setembro de 2013

A questão é que existem várias maneiras de fazer essas matrizes,por isso não existe uma informação 'padrão'.

Pode-se fazer por varredura horizontal,vertical,deslocamento e tem até quem desista e use Cis dedicados.

Existe tambem o uso das matrizes grandes feitas com Leds de alto brilho,com matrizes dedicadas e até com super Leds onde alguns Cis não podem ser usados.

charlesfrances · 4 de setembro de 2013

alguém mais poderia postar opiniões, um código de matriz rolante ,ou me fazer entender um pouco do assunto tipo o meu código lá em cima tem partes nele que eu não faço a mínima ideia de captar quem tiver um código mais simples de entender fiquem a vontade e poste ...

isso aqui não entendi output_bit(dLin,!!(Visor[Line]&Mul));

ricardospimentel · 4 de setembro de 2013

Só faltou você colocar o código entre

, senão dificulta saber quando é o final do teu código que não está completo, pois falta chave de fechamento da função CargaMem e podendo estar faltando ainda mais coisas, como as combinações binárias das saídas para cada caractere que no caso só tem a letra 'B'.

Exemplo: 
Bla bla, bla bla...
[code]
Codigo fonte escrito em C aqui.
[\code]   ← ← No lugar de "\", utilize este aqui "/", que é a barra invertida, a mesma usada para datas e divisão. Apenas utilizei outra para que vejas o exemplo.


Quanto ao código, como disse o vrtx, há várias formas de se fazê-lo. Inicialmente, nota-se que a função para se escrever é "CargaMem(Texto)", que o compilador é o CCS, que o microcontrolador usado é o 16f88.

Neste código, escreva o texto dentro da função "CargaMem(Texto aqui)" e neste trecho 
[code]
if(++ptime>5){         // Suma 1 a ptime. Si se pasa de 20
    ptime=0;         // lo pone en 0 y suma 1 a time.
    if(++time>200){ // Si se pasa de 200
        time=0;     // lo pone en 0
        Flag=true;     // y activa el flag.
    }
}

...você ajusta a velocidade de rolamento do texto.

charlesfrances · 4 de setembro de 2013

vou fazer 2 perguntas você recebendo este código completo , já que você falou um pouquinho dele sobre a velocidade quer obte-lo completo ? eu posto pra você estou usando

CCS C compiler ,você falou SDCC ? eu compilei sem erros no CCS C

...

Ele completo vamos é mais um código a mais para o conhecimento talvez você já conheça

alguns comando difíceis !! qundo me ajudaõ não decepciono ninguém pode ter certeza de sera quem quer que rsrs seja recompensado 3 que rsrsr falou!!

ricardospimentel · 4 de setembro de 2013

SDCC e CCS são o mesmo compilador, que é amado por uns e odiado por outros. Comecei com ele, como ele não oferece uma versão free, desisti dele. Até me interessei em comprá-lo, mas quando entrei em contato com os representantes dele aqui no Brasil me decepcionei, pois eles vendem a licença separada para cada microcontrolador que você for usar, o que não acontece se eu comprar direto nos EUA.

////Adicionado no dia 04!!!

SDCC não é igual ao CCS, me enganei, desculpe-me. CCS é CCS mesmo, o meu engano foi referente a uma das opções de venda do compilador, que é PCW, PCWH, etc, ou seja, nada a ver mesmo! Não sei no quê eu estava sonhando nessa hora, mas aí tá explicado. SDCC é um outro compilador, muito bom, que é open source e deveria receber mais atenção de todos da área PIC.

////

Quanto ao código, poste ele completo mesmo, assim mais gente pode tanto compartilhar experiências quanto aprender também, como tu.

Se for muito grande, poste seu código entre:

]SPOILER[ ← ← Repare nas CHAVES invertidas, usei assim apenas para te mostrar

Seu código aqui, ó!!!

Aí seu código ficará assim:

Viu só??

A graça do aprendizado é esta dificuldade que estais tendo. Vá alterando o seu código, aproveitando que tens instalado o Proteus Isis, e vá testando e durante as dúvidas, poste e pergunte. Assim aprende e ensina ao mesmo tempo.

charlesfrances · 4 de setembro de 2013

Ai é que tá a coisa coloquei o codigo, você so precisa termina-lo já esta completo

por exemplo case('C'): ai depois case('I'): case('O'): etc ...ate completar a palavra

(PICROBOT)

o mesmo que aconteceu pro case('B'): você faz com os outros entendeu ai fecha chavez e terminou!!

fale mais a respeito do meu código pra que eu entenda melhor rsrsrsr que seras Bem recompensado KKKKK entendeu!!

por exemplo fale assim oh!! sobre

int1 flag; // Flags de control
int1 flag2;
int indx; // Indice donde almacenará las nuevas columnas.
int line; // Linea que a mostrar.
int time; // Variables para el control de
int ptime; // la velocidad de desplazamiento.
int t; // Variable auxiliar.

void CargaMem(char Ascii);
void GuardaClm(char c);

Um pouco disto daquilo ,estes protótipos , variáveis que estão usando aonde estão indo um pouco de cada devagar e sempre, me ensine!rsr!,naõ que seja obrigatório

mais como diz o ditado quem naõ chora naõ mama rsrsr!!

ricardospimentel · 4 de setembro de 2013

O que não estou entendendo é que se você fez o código até aqui e já fez a letra "B", por que não faz o restante?

Vês a letra "B"?


case('B'):
    GuardaClm(0b01111111); 
    GuardaClm(0b01111111); 
    GuardaClm(0b01001001); 
    GuardaClm(0b01001001); 
    GuardaClm(0b01111111); 
    GuardaClm(0b00110110); 
break;

Repares que está em código binário, então se você observar, verás uma letra "B" deitada de bruços, ou seja, com a parte da frente da letra "B" para baixo.

Veja: "0b00000000" representa 8 bits, sendo o bit mais significativo próximo ao '0b' que também representa número binário, se fosse usar números Hexadecimais seria "0x00" e decimal, simplesmente "0". Cada um desses bits controlará uma das saídas de um dos deslocadores de registro, os 74595.

Basicamente, veja o "0" como o led apagado e o 1 como ele aceso, agora repare que temos ali acima 8 linhas horizontais e 6 linhas verticais (também repare que tudo está virado para a direita, deitado, portanto). Vendo agora isso, acho que fica fácil desenhar o restante.

Repare agora, gire a cabeça para ver melhor


case('B'):
    GuardaClm(0b01111111); →0b░███████
    GuardaClm(0b01111111); →0b░███████
    GuardaClm(0b01001001); →0b░█░░█░░█
    GuardaClm(0b01001001); →0b░█░░█░░█
    GuardaClm(0b01111111); →0b░███████
    GuardaClm(0b00110110); →0b░░██░██░
break;
case('O'):
    GuardaClm(0b00011000); →0b░░░██░░░
    GuardaClm(0b00100100); →0b░░█░░█░░
    GuardaClm(0b01000010); →0b░█░░░░█░
    GuardaClm(0b01000010); →0b░█░░░░█░
    GuardaClm(0b00100100); →0b░░█░░█░░
    GuardaClm(0b00011000); →0b░░░██░░░
break;
case('L'):
    GuardaClm(0b01111111); →0b░███████
    GuardaClm(0b01111111); →0b░███████
    GuardaClm(0b01000000); →0b░█░░░░░░
    GuardaClm(0b01000000); →0b░█░░░░░░
    GuardaClm(0b01000000); →0b░█░░░░░░
    GuardaClm(0b01000000); →0b░█░░░░░░
break;

Por hoje fico por aqui. Depois, se precisar, dou mais auxílio. já são 2:10hrs aqui, acho que aí em PB também.

Cabelo75 · 4 de setembro de 2013

Fala rapaziada!

Desculpe interromper o papo de vocês, mas queria agradecer ao Ricardo pelo "macete" que sempre quis fazer em meus posts "nada extensos".

Valeu Ricardo, muito obrigado!

Abraço a todos!

charlesfrances · 4 de setembro de 2013

Ricardo ,pó tu é inteligente pra caramba vou te entregar o restante do código

já que você entendeu o final ai você coloca as tagscode se quiser,pra quem você acha que merece,valeu! no momento estou estudando muito

mas de meia em meia hora ,respondo aos comentarios

,já que você entende é assim o final ,ignore o B que é o começo que já tem lá ,eu entendo

de protótipos ,variáveis globais ,locais laços de repetição tipo assim for, while, do while

condição ifs ,chamada da função parâmetros essas coisas mais Ricardo tem coisa nesse

código que é difícil de decifrar eu postei esse tópico para tentar dominalo nesse estilo

tipo tem muitas declarações de variáveis e códigos output_bit com delimitadores que eu não entendo você poderia falar um pouco mais do assunto o restante do código completo instala com o fechamento final da chave postei porque você é legal embora talvez você não precise você decifrou né!? se poder comentar mais a respeito do código fico agradecido tu és Fera cara valeu!!

case('B'):
      GuardaClm(0b01111111);
      GuardaClm(0b01111111);
      GuardaClm(0b01001001);
      GuardaClm(0b01001001);
      GuardaClm(0b01111111);
      GuardaClm(0b00110110);      
      break;

      case('C'):
      GuardaClm(0b00111110);
      GuardaClm(0b01111111);
      GuardaClm(0b01000001);
      GuardaClm(0b01000001);
      GuardaClm(0b01100011);
      GuardaClm(0b00100010);     
      break;

      case('I'):
      GuardaClm(0b01000001);
      GuardaClm(0b01000001);
      GuardaClm(0b01111111);
      GuardaClm(0b01111111);
      GuardaClm(0b01000001);
      GuardaClm(0b01000001);      
      break;  

      case('O'):
      GuardaClm(0b00111110);
      GuardaClm(0b01111111);
      GuardaClm(0b01000001);
      GuardaClm(0b01000001);
      GuardaClm(0b01111111);
      GuardaClm(0b00111110);      
      break;      

      case('P'):      
      GuardaClm(0b01111111);
      GuardaClm(0b01111111);
      GuardaClm(0b00001001);
      GuardaClm(0b00001001);
      GuardaClm(0b00001111);
      GuardaClm(0b00000110);      
      break;

      case('R'):
      GuardaClm(0b01111111);
      GuardaClm(0b01111111);
      GuardaClm(0b00001001);
      GuardaClm(0b00011001);
      GuardaClm(0b01111111);
      GuardaClm(0b01100110);
      break;

      case('T'):
      GuardaClm(0b00000011);
      GuardaClm(0b00000001);
      GuardaClm(0b01111111);
      GuardaClm(0b01111111);
      GuardaClm(0b00000001);
      GuardaClm(0b00000011);
      break;      
   }
      GuardaClm(0b00000000);
}

Observação: Quando se deseja delimitar os tipos de caracteres reconhecidos

por uma chamada de scanf, utiliza-se, entre o símbolo % e o tipo s, colchetes

envolvendo os caracteres específicos, como:

scanf ("´% [a-z] a", str);

que faz com que qualquer caractere digitado diferente dos que se encontram entre os limites a e z minúsculas.,Se é desejável uma sequencia de intervalos de caracteres, coloca-se um espaço separando-os na forma:

scanf("% [a-z A-F 0-5] s",str);

que indica que só serão reconhecidos os caracteres minúsculos de a até z, maiúsculos de A até F e dígitos de 0 até 5 . mais esse código da matriz ta me deixando doido por exemplo na output_bit lá no meio do código ,olha lá pra mim essa parte! output_bit(dLin,!!(Visor[Line]&Mul));

se naõ for pedir demais já que o código esta completo, você poderia me passar ele via email, caso você tenha deixado ele bem explicado,

quando você tiver um tempo extra pra deixar ele bem claro pra mim nos mínimos detalhes tipo como uma aula ,mande ai, queria também saber sobre essas declarações de variáveis char Memoria[96]; // 96 Bytes para a memoria (0 - 95)

char Visor[8]; // 8 para el visor (8 columnas)

qualquer coisa que precisar que eu pesquise estou as ordens ,Agradecido!!

ricardospimentel · 4 de setembro de 2013

Ok, vou responder bem brevemente, pois hoje o tempo tá concorrido.

Vamos dar uma analisada na expressão:

"output_bit(dLin,!!(Visor[Line]&Mul));"

...que está dentro de um laço de repetição e se repetirá por 8X.

A função "output_bit(Saída digital a ser modificada, 0 ou 1)", simplesmente, vai definir o estado lógico da saída ali definida antes da vírgula, que no caso é o pino B3, configurado para ser o pino Data do segundo Deslocador de Registro, com o resultado da expressão "!!(Visor[Line]&Mul)" contido após a vírgula, sendo ele 0 ou 1.

Tem um documento que pode te ajudar um pouco mais.

"http://www.mecatronica.org.br/disciplinas/programacao/CARTAO_REFERENCIA.pdf"