Librería Matríz de LEDs Universal[compilador CCS](Aportes y Comentarios)

[oscar321]

Oscar, por lo general el buffer de entrada es sólo uno. En el ejemplo lo puse como const, por lo que no puede modificarse en tiempo de ejecución, pero removiendo el modificador const, se convierte en un arreglo modificable en ejecución y por ende libre para ser modificado a gusto. Si te interesa poder tener varios arrays y poder elegir cuál enviarle a las mísmas subrutinas, necesitarías modificar las subrutinas para que acepten y trabajen con un puntero a un arreglo de chars, para que de esa manera sea independiente del array original. Igualmente, sólo recomiendo hacerlo si aporta gran flexibilidad o característica pretendida al software, caso contrario, no es recomendable ya que en estos uC que tienen sólo un registro de trabajo, agregar parámetros a la funciones incrementa la cantidad de memoria RAM y ROM requerida por el programa para realizar las llamadas.

Saludos.

Gracias amigo BrunoF, se podría utilizar una EEPROM para cargar un mensaje uno por uno definiendo la dirección de inicio y de entrada, ademas de utilizar una interrupción para cargar los datos a la EEPROM a través de USB.

[jukinch]

Buen dato a tener en cuenta lo de "... sólo recomiendo hacerlo si aporta gran flexibilidad o característica pretendida al software, caso contrario, no es recomendable ya que en estos uC que tienen sólo un registro de trabajo, agregar parámetros a la funciones incrementa la cantidad de memoria RAM y ROM requerida por el programa para realizar las llamadas."

[BrunoF]

Oscar, por lo general el buffer de entrada es sólo uno. En el ejemplo lo puse como const, por lo que no puede modificarse en tiempo de ejecución, pero removiendo el modificador const, se convierte en un arreglo modificable en ejecución y por ende libre para ser modificado a gusto. Si te interesa poder tener varios arrays y poder elegir cuál enviarle a las mísmas subrutinas, necesitarías modificar las subrutinas para que acepten y trabajen con un puntero a un arreglo de chars, para que de esa manera sea independiente del array original. Igualmente, sólo recomiendo hacerlo si aporta gran flexibilidad o característica pretendida al software, caso contrario, no es recomendable ya que en estos uC que tienen sólo un registro de trabajo, agregar parámetros a la funciones incrementa la cantidad de memoria RAM y ROM requerida por el programa para realizar las llamadas.

Saludos.

Gracias amigo BrunoF, se podría utilizar una EEPROM para cargar un mensaje uno por uno definiendo la dirección de inicio y de entrada, ademas de utilizar una interrupción para cargar los datos a la EEPROM a través de USB.

Claro que sí, se podría. Sólo te resta hacerlo!

Buen dato a tener en cuenta lo de "... sólo recomiendo hacerlo si aporta gran flexibilidad o característica pretendida al software, caso contrario, no es recomendable ya que en estos uC que tienen sólo un registro de trabajo, agregar parámetros a la funciones incrementa la cantidad de memoria RAM y ROM requerida por el programa para realizar las llamadas."

Sí, y la cosa se empeora cuando se anidan funciones. Si bien la ROM necesaria no se incrementa mucho, el consumo de RAM oculto por parte del Compilador sube drásticamente. Después las personas no entienden cómo un programa que casi no tiene variables definidas por ellos puede estar consumiendo tanta RAM/ROM...

Saludos!

[jukinch]

Ahora me cierra el porque definiste todas las variables como globales.
Siempre las veía como mala palabra en los libros. Pero ahora no cuando son utilizadas en pro de la optimización.
No dejás de sorprenderme Bruno.

[oscar321]

Gracias amigo BrunoF, se podría utilizar una EEPROM para cargar un mensaje uno por uno definiendo la dirección de inicio y de entrada, ademas de utilizar una interrupción para cargar los datos a la EEPROM a través de USB.

Claro que sí, se podría. Sólo te resta hacerlo!

He creado un char text[500];     y al cual apunto definiendo a demo como puntero con dirección a text:
En publik.c elimino: const demo[]="";  y la remplazo con char text[500]; definiendo un maximo de palabras a 500.

En efectos.c agrego y defino a demo como puntero a text

Código: [Seleccionar]

char *demo=&text; //PUNTERO
aquí puedo utilizar en main.c para definir a text con cualquier texto definido por mi

Código: [Seleccionar]

while(ejecutando) {
char text[]="Hola amigos";
Publik_Ejecutar();
}



[oscar321]

Agrego libreria de EEPROM
#include "24256.c"

int8 ini, end, p, k;    //defino variables.

EN MAIN...

   init_ext_eeprom();   //Inicio Comunicación con EEPROM

   ini=read_ext_eeprom(0);  //Lectura de los 2 primeros Bytes para Inicio y Final de TEXTO.
   end=read_ext_eeprom(1);
   
   p=0;                                   //defino inicio de contador p para array text[];
   for(k=ini;k<end;k++) {       //Bucle de lectura de EEPROM para el text a mostrar
   text[p++] = read_ext_eeprom(k);   
   }
   
   for(k=0;k<7;k++) {            //
   text[p] = " ";                      //
   p++;                                 //        Espacio de Final del texto y Caracteres de Separación.
   }                                       //
   
   text[p++] = "<";
   text[p++] = "<";
   text[p++] = "<";
   text[p++] = "<";
 
   for(k=0;k<7;k++) {
   text[p] = " ";
   p++;
   }                                       //


Publik_Ejecutar();                  //Procesa el texto y muestra

Ahora mi pregunta como hago para calcular cuando el texto sea mostrado a su totalidad y para que este vuelva a hacer una lectura de la eeprom utlizando varias direcciones que podre definirlas en el inicio de la eeprom

[jeremylf]

Hola Bruno, estupenda librería. Gracias por compartirla.

He adaptado tu librería para trabajar con un 16f628a a 20mhz: cambio fuses, tris y demás.
También, estoy usando 74hc595 envés de 4094 como en la simulación.
Uso una matriz 8x8 de color rojo donde las filas tienen en común los anodos y las columnas tienen en común los catodos: para esto solo basto poner:

Código: [Seleccionar]

#define  FILAS_ANODO       TRUE    //establece si las FILAS controlaran los anodos en comun de los LEDs
#define  COLUMNAS_CATODO   TRUE    //establece si las COLUMNAS controlaran los catodos en comun de los LEDs

Me e dado cuenta que hay veces que el mensaje no se desplaza y esto ocasiona un feo efecto. Investigando, el problema viene por la función efecto_rota_izq(). Dentro de esta funcion, cuando la condición "if(ProximoElementoLetra())" devuelve false, es cuando no se desplaza las letras.

No se exactamente a que se debe este problema, seguro tu lo sabes más, de todas formas seguiré estudiando tu codigo. Por el momento, he resuelto este feo efecto agregando unas lineas de codigo alfnal de esta función, quedando así:

Código: [Seleccionar]

void efecto_rota_izq()
{
   if(ProximoElementoLetra())                                     //intentar obtener proximo elemento de la lectra actual...
   {
      if(++BufferInicio >= COLUMNAS) BufferInicio=0;              //rotar...
      if(BufferInicio>0) efAux1= BufferInicio-1; else efAux1=COLUMNAS - 1;     //calcular la ultima columna actual...
      buffer[efAux1] = letraData;                                 //e inyectarle el valor leido
   }else{
      //buffer[efAux1] = 0;                                        //inyectarle 0
      if(!nuevoEfecto) archivoPosicionActual++;
      nuevoEfecto = FALSE;
      if(demo[archivoPosicionActual] == 0) archivoPosicionActual = 0;
      CargarLetra(demo[archivoPosicionActual]);
      
      // ESTO HE AGREGADO ///////////////////////////////////////////////////////////////////////////////////////////////////
     if(++BufferInicio >= COLUMNAS) BufferInicio=0;              //rotar...
      if(BufferInicio>0) efAux1= BufferInicio-1; else efAux1=COLUMNAS - 1;     //calcular la ultima columna actual...
      buffer[efAux1] = 0;

   }
}


Saludos.

[jeremylf]

La verdad me parece muy curioso que les funcione de manera fluida el código de Bruno con este inconveniente que he mostrado en mi mensaje anterior. No se si será por que estoy con una matriz 8x8 o por que uso otro PIC u otra cosa y solo me pasa a mi; pero realmente no lo creo porque hasta en la simulación se puede notar que cada vez que intenta mostrar una nueva letra se detiene por un momento haciendo que el mensaje no corra fluidamente.

La propuesta de solución que di antes arregla este inconveniente. Ademas, algo que no mencione, añade una fila de espacio entre letras para que se pueda leer mejor estas. No estoy muy convencido si es la mejor solución pero funciona. Ahora, para que simplemente solucione el inconveniente de fluidez sin agregar ningún espacio entre letras y, al menos para mi, pueda convencerme más de que es una mejor solución he dejado esa parte del código así:

Código: [Seleccionar]

void efecto_rota_izq()
{
   if(ProximoElementoLetra())                                     //intentar obtener proximo elemento de la lectra actual...
   {
      if(++BufferInicio >= COLUMNAS)
         BufferInicio=0;              //rotar...
      if(BufferInicio>0)
         efAux1= BufferInicio-1;
      else
         efAux1=COLUMNAS - 1;     //calcular la ultima columna actual...
      buffer[efAux1] = letraData;                                 //e inyectarle el valor leido
   }
   else
   {//output_toggle(PIN_B1);
      //buffer[efAux1] = 0;                                        //inyectarle 0
      if(!nuevoEfecto)
         archivoPosicionActual++;
      nuevoEfecto = FALSE;
      if(demo[archivoPosicionActual] == 0)
         archivoPosicionActual = 0;
      CargarLetra(demo[archivoPosicionActual]);
     
// ESTO HE AGREGADO ///////////////////////////////////////////////////////
      ProximoElementoLetra();
     if(++BufferInicio >= COLUMNAS) BufferInicio=0;              //rotar...
      if(BufferInicio>0) efAux1= BufferInicio-1;
      else efAux1=COLUMNAS - 1;     //calcular la ultima columna actual...
      buffer[efAux1] = letraData;
//////////////////////////////////////////////////////////////////////////////////

   }
}


Saludos!

[BrunoF]

Perdoname jeremy si no puedo ofrecerte mucha ayuda, pero tengo completamente olvidado este código que escribí hace años.

Saludos!

[jeremylf]

No te preocupes, solo me parece curioso que pase eso.

Por cierto, usabas resistencias o no? Porque en el archivo de simulación no aparece ninguna =D

[BrunoF]

Si puedo le voy a pegar una mirada.

Sí, usaba resistencias pero en la simulación si no son estrictamente necesarias prefiero no colocarlas ya que cargan al CPU para simularlas.

[jeremylf]

Perfecto! Y de que valor? Yo estoy usando de 50 ohm para una matriz 8x8 roja y se ve bien pero para una verde ya no se ve bien, creo que le pondré 15 ohm. Espero no sobrepase los limites del 74HC595.

[BrunoF]

El valor dependerá de los LEDs y cuestiones de brillo que desees. Los límites del 74HC595? Lo tienes directo sin ULN? En ese caso trabajarás con una dV de 5V, lo que es bastante pobre para lograr buen brillo multiplexando.

Por otro lado, no he logrado que la simulación falle. Es utilizando tal cual el código? O has cambiado el texto?

Saludos.

[jeremylf]

Bueno, yo estoy usando para las filas y columnas los 74HC595 directos sin ULN alimentado todo a 5V. Entonces, dices que es necesario que los LEDs tengan mayor voltaje? Pero no se compensaría si la resistencia fuera menor para dejar pasar mas corriente? Total, lo LEDs funcionan a 3v aprox.

Por otro lado, no es que la simulación falle sino que el efecto de rotacion a la izquierda se detiene un poco cada vez que carga una nueva letra, haciendo que la rotacion no se vea fluida y, por el contrario, le de un mal efecto. Es un poco dificil de explicar con palabras pero siempre sucede cuando una letra a terminado de salir completa por el lado derecho y se pretende cargar la nueva letra, parece que en ese momento se demora en cargarlo o algo parecido. Y no es cosa de la simulación, pues sucede en fisico yo lo he probado. Post atras expliqué en que parte del código era que sucedía esto y mostré una rápida solución, aunque no se si del todo correcta. Efectivamente estoy usando tu código tal cual.

[BrunoF]

Sí, deberías elevar el voltaje. Pero para ello requieres agregar si o si los ULN. No puedes incrementar el voltaje con sólo los registros de desplazamiento porque tendrías siempre una diferencia de potencial presente y los LEDs no se apagarían nunca del todo.

Subes el votaje y mantienes la resistencia actual de filas. Eso debería darte mucho más brillo.

Miraré cuando pueda la simulación.

Saludos