Autor Tema: matriz de leds desplazamiento vertical  (Leído 2095 veces)

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado antayhua

  • PIC10
  • *
  • Mensajes: 32
matriz de leds desplazamiento vertical
« en: 26 de Octubre de 2014, 21:57:46 »
Hola a todos, tengo un problema de como hacer mi tabla para mostrar un texto en una matriz de leds de forma vertical osea que el texto aparezca desde arriba, se como hacer que el texto se desplace de forma horizontal desplazandoce desde la derecha hacia la izquierda, quisiera alguna idea de como puedo hacerlo, no pido codigo solo quiera una explicacion de como hacer que el texto se desplace de arriba hacia abajo, gracias.


Este es el codigo para desplazalo de derercha a izquierda, como puedo cambiarlo.

#include <xc.h>
#include <stdio.h>
#include <string.h>

// CONFIG
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = ON       // Power-up Timer Enable bit (Power-up Timer is enabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)

#define _XTAL_FREQ 4000000

/****constantes****/
#define NUM_COLUMNAS 10
#define NUM_DATOS 75

/****Variables****/
unsigned char
n_col,
desplazar,
n_veces,
desplazar,
valor;

/*****************Tabla de datos***********************/
unsigned const char datos[NUM_DATOS] = {

    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //son 30 ceros uno para cada columna,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //lo que hacen es apagar o limpiar
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //todos la matrices.
    127, 8, 8, 8, 127, 0, //H
    62, 65, 65, 65, 62, 0, //O
    127, 64, 64, 64, 64, 0, //L
    126, 17, 17, 17, 126, 0, //A
    0, //separador
    127, 2, 12, 2, 127, 0, //M
    60, 64, 64, 64, 60, 0, //u
    120, 4, 4, 4, 120, 0, //n
    48, 72, 72, 72, 126, 0, //d
    56, 68, 68, 68, 56, 0, //o
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0

};

/****Inicio del programa****/
void main(void)
{
    TRISA = 0; //Puertos configurados
    TRISB = 0; //como salidas.
    PORTB = 0; //Apagamos el puerto B.
    while (1)
    {

        for (desplazar = 0; desplazar < NUM_DATOS - (NUM_COLUMNAS - 1); desplazar++)/*desplazar:Variable encargado de desplazar
                                                                                 el texto en el panel.*/
        {
            for (n_veces = 0; n_veces < 8; n_veces++)/*n_veces:Es el numero de veces que se
                                                      va mostrar el mismo valor en el panel.*/
            {
                for (n_col = 0; n_col < NUM_COLUMNAS; n_col++)/*n_col:Este valor ira activando
                                                               cada columna de cada matriz.*/
                {

                    PORTA = n_col; //asignando el numero de columna al puerto A.
                    valor = datos[desplazar + n_col]; //asignando a "valor" el dato almacenado en la tabla "datos".
                    PORTB = valor; //mostrando el dato por el puerto B.
                    __delay_ms(2); //Tiempo en el que aparecera el dato en cada columna.
                }

            }
        }
    }
}

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: matriz de leds desplazamiento vertical
« Respuesta #1 en: 27 de Octubre de 2014, 03:27:48 »
Imagino que la forma mas simple de hacerlo seria dezplazar en 1, luego en 2, luego 3 y asi continuamente hasta el maximo de leds en vertical, recordando que empieza de 0.


/*****************Tabla de datos***********************/
unsigned const char datos[NUM_DATOS] = {

    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //son 30 ceros uno para cada columna,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //lo que hacen es apagar o limpiar
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //todos la matrices.
    127, 8, 8, 8, 127, 0, //H
    62, 65, 65, 65, 62, 0, //O
    127, 64, 64, 64, 64, 0, //L
    126, 17, 17, 17, 126, 0, //A
    0, //separador
    127, 2, 12, 2, 127, 0, //M
    60, 64, 64, 64, 60, 0, //u
    120, 4, 4, 4, 120, 0, //n
    48, 72, 72, 72, 126, 0, //d
    56, 68, 68, 68, 56, 0, //o
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0

};

Por ejemplo la H tomando el primer "palito" ...  127d = 0x7F = 0111 1111 O si lo ves en vertical

Código: [Seleccionar]
Pasos
1 --- 2 ----  3

0 => 1 => 1
1 => 0 => 1
1 => 1 => 0
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1

Y para dezplazarlo verticalmente tendria que se 1011 1111 y luego 1101 1111 y asi continuamente. Lo que si no creo que sea algo bastante eficiente xD

es decir, sacandole el "dezplazar" que tenes horizontalmente y reemplazandolo por un dezplazar verticalmente

Código: [Seleccionar]
valor = datos[n_col] > dezplazar;
Y recorda cambiarle el maximo por la cantidad de leds en vertical a

Citar
for (desplazar = 0; desplazar < NUM_DATOS - (NUM_COLUMNAS - 1); desplazar++)

Al menos creo que eso funcionaria xD

// EDIT!

Lo que me olvide es que si tu micro no puede dezplazar X cantidad de posiciones de una sola vez para cuando este llegando al final va a estar bastante lento.... lo cual podrias modificar tu array e ir guardando los datos con el dezplazamiento.
Código: [Seleccionar]
datos[n_col] = datos[n_col] > 1;

Asi que por mas que tengas 6 dezplazamientos para el 7mo seguis teniendo 1 solo nomas. El principal problema es que tenes que deberia dar uan vuelta completa, y ahora que lo veo tus datos estan en la memoria de programa con lo que no creo que lo puedas modificar.

Otra que se me ocurrio:
O rotas a la derecha hasta 4 y luego rotas a la izquierda de 3 a 1, asi no llegan a 7  dezplazamiento y lo limitas a 4 ,
Pero pensandolo bien creo que perderias mas ciclos preguntando si llego a 4,3 o lo que sea que desplazandolo, resta, test de bit(peor caso 2 ciclos), rotar
Ya para 4 estarias consumiendo lo mismo que 7 desplazamientos :P, o si lo haces con for() seria un inc,resta,bittest, estando aproximadamente en la misma xD
« Última modificación: 27 de Octubre de 2014, 14:58:15 por KILLERJC »

Desconectado antayhua

  • PIC10
  • *
  • Mensajes: 32
Re: matriz de leds desplazamiento vertical
« Respuesta #2 en: 28 de Octubre de 2014, 19:26:01 »
Imagino que la forma mas simple de hacerlo seria dezplazar en 1, luego en 2, luego 3 y asi continuamente hasta el maximo de leds en vertical, recordando que empieza de 0.


/*****************Tabla de datos***********************/
unsigned const char datos[NUM_DATOS] = {

    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //son 30 ceros uno para cada columna,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //lo que hacen es apagar o limpiar
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //todos la matrices.
    127, 8, 8, 8, 127, 0, //H
    62, 65, 65, 65, 62, 0, //O
    127, 64, 64, 64, 64, 0, //L
    126, 17, 17, 17, 126, 0, //A
    0, //separador
    127, 2, 12, 2, 127, 0, //M
    60, 64, 64, 64, 60, 0, //u
    120, 4, 4, 4, 120, 0, //n
    48, 72, 72, 72, 126, 0, //d
    56, 68, 68, 68, 56, 0, //o
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
//    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0

};

Por ejemplo la H tomando el primer "palito" ...  127d = 0x7F = 0111 1111 O si lo ves en vertical

Código: [Seleccionar]
Pasos
1 --- 2 ----  3

0 => 1 => 1
1 => 0 => 1
1 => 1 => 0
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1
1 => 1 => 1

Y para dezplazarlo verticalmente tendria que se 1011 1111 y luego 1101 1111 y asi continuamente. Lo que si no creo que sea algo bastante eficiente xD

es decir, sacandole el "dezplazar" que tenes horizontalmente y reemplazandolo por un dezplazar verticalmente

Código: [Seleccionar]
valor = datos[n_col] > dezplazar;
Y recorda cambiarle el maximo por la cantidad de leds en vertical a

Citar
for (desplazar = 0; desplazar < NUM_DATOS - (NUM_COLUMNAS - 1); desplazar++)

Al menos creo que eso funcionaria xD

// EDIT!

Lo que me olvide es que si tu micro no puede dezplazar X cantidad de posiciones de una sola vez para cuando este llegando al final va a estar bastante lento.... lo cual podrias modificar tu array e ir guardando los datos con el dezplazamiento.
Código: [Seleccionar]
datos[n_col] = datos[n_col] > 1;

Asi que por mas que tengas 6 dezplazamientos para el 7mo seguis teniendo 1 solo nomas. El principal problema es que tenes que deberia dar uan vuelta completa, y ahora que lo veo tus datos estan en la memoria de programa con lo que no creo que lo puedas modificar.

Otra que se me ocurrio:
O rotas a la derecha hasta 4 y luego rotas a la izquierda de 3 a 1, asi no llegan a 7  dezplazamiento y lo limitas a 4 ,
Pero pensandolo bien creo que perderias mas ciclos preguntando si llego a 4,3 o lo que sea que desplazandolo, resta, test de bit(peor caso 2 ciclos), rotar
Ya para 4 estarias consumiendo lo mismo que 7 desplazamientos :P, o si lo haces con for() seria un inc,resta,bittest, estando aproximadamente en la misma xD

Gracias por tu comentario me diste una idea de como hacerlo.


 

anything