Ir ao conteúdo
  • Cadastre-se
Entre para seguir isso  
Visitante

[Resolvido] Como eu faço uma matriz rolante

Recommended Posts

Visitante

:bandeira::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!-_-:blush::aplausos::jump:

Matriz8x8.jpg

Compartilhar este post


Link para o post
Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    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!!

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    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 ...:confused:

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

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    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

    ...:confused::rolleyes:

    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!!:wacko:

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    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!!

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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!

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    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!!:eek:

    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));:wacko::confused:

    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!!

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    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"

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •    1
    Visitante

    Obrigado, valeu!!

    O conhecimento é o processo de acumular dados. A sabedoria reside na sua simplificação. (Martin H. Fischer)

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Caso o autor necessite, o mesmo será reaberto, para isso deverá entrar em contato com a moderação solicitando o desbloqueio.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
    Visitante
    Este tópico está impedido de receber novos posts.
    Entre para seguir isso  





    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

    ×