Matriz de Led 48x8

[Byakuya]

 
Hola amigos del foro. Les mando un saludo, quisiera pedirles una ayudadita, quiero realizar un programa simple, para una matriz de led, la eh diseñado usando registros de dezplazamiento 74HC595, la matriz la dividi en 3 fragmentos de 16 led por columna ( 16 led  x 3 placas con 2 registros cada una me da un total de 48  leds en columna este procedimiento lo realize dos veces 4 led en vertical y 4 led, En total  8 leds. adjunto mas abajo la imagen ) ,he utilizado 12 registros, para controlar los 48 led x 8 led = 384 leds. para controlar la fila uso 4 transistores, mas abajo esquematizo mi diagrama.... Un micro ARM sera el encargado de esta tarea para ser exacto STM32F103 y entorno de programacion de arduino, eh estado probando dos maneras de hacer el dezplazaiento en los registros sin conseguir buenos resultados, usando el modulo SPI del ARM escribiendo 16 bits 0x8080 parte alta y parte baja, o que piensan ustedes... Aqui muestro como conecte los registros...

El registro 1-595 comparte lineas de comunicacion de Reloj y Latch, El pin de datos entra por el regitro 1... Despues la salida de datos de este registro esta conectado al Registro 2-595, la salida del registro 2...Conectada a la entrada de datos del registro 3-595.... y haci repitiendo el proceso hasta finalizar con los 12 registros... los led estan conectados a las salidas de los registros en catodo...

Para el barrido vertical, utilizo un transistor para los anodos de toda la fila
//**************************************************

Transistores 4 para Y

transistor 1===0Led----48Led.  Fila1---Fila5
transistor 2===0Led----48Led   Fila2---Fila6
transistor 3===0Led----48Led   Fila3---Fila7
transistor 4===0Led----48Led   Fila4---Fila8

//**************************************************

Registros 12 registros para X

1-595      3-595          5-595              7-595
-----          -----
-    -          -    -
-----          -----

2-595      4- 595          6-595            8-595....
-----          -----
-    -          -    -
-----          -----

[Byakuya]

Parece que ando en delirios, y nadie podra ayudar.. se me ocurrieron algunas ideas y entonces copio y pego algunas partes utilizadas por este personaje...


//驱动函数，
void TM82(unsigned int wr_dat82)
{
for(int i = 16; i > 0; i--)
{
 digitalWrite(BCK, LOW);
 digitalWrite(DIN, (wr_dat82 >> i) & 0x01);
 digitalWrite(BCK, HIGH);
 }
}

[KILLERJC]

Eso es un SPI por software, el problema es que no se entiende nada la explicacion del primer post.

Por lo que entendi:

Son 16 columnas, es decir que cada salida de los hc595 irian conectadas a las columnas.
Tenes transistores manejando las filas el comun de los leds de todas las filas.

¿Ahora cual es el problema?

Ya que lo unico que hay que hacer es enviar los 48bits y activar por un tiempo uno de los comunes.

La idea es que en memoria tengas la "imagen" ya realizada, asi solo enviarias.
En caso de querer actualizar el display modificas esa "imagen" dentro de la memoria y luego envias.

Asi como esta es un poco mas compleja la logica de hacer un texto en movimiento por ejemplo.

[Byakuya]

Hola KillerJC com siempre contestando a mis llamados, buen dia y comentando, exactamente como tu lo dices tengo mi "HARD", creo que no me di a entender una disculpa, pensemos en una matriz de 8x16 como lo comentas tu. las 8 filas comparten la coneccion de 4 transistores, la fila 1 y la fila 5 estan conectadas a un transistor que activa en 1 el anodo de los 16 leds de la columna, un segundo transistor para activar la fila 2 y la fila 6, un tercer transistor para activar el anodo de la fila 3 y 7 y un ultimo transistor para activar la fila 4 y 8. ahora para controlar las 16 columnas tengo 4 registros de 8 bits "74HC595" pensemos en la matriz de 16x8 partida a la mitad en donde uso 2 registros para controlar 16x4 parte arriba, y otros dos registros para controlar los 16x4 de abajo.

1-595      3-595         
-----          -----
-    -          -    -                 Registro 1 y 3
-----          -----

2-595      4- 595         
-----          -----
-    -          -    -                 Registro 2 y 4
-----          -----

Despues de eso los datos estan encadenados de tal forma que la salida DATA del registro 1 conecta con el Registro 2 y la salida de este con el Registro 3 y la salida de este con el Registro 4, todo esto es una copia del modulo de led P10 sin usar el decoder 74HC138 por eso reemplazo con los transistores.. Espero averme explicado, mi problema radica en el buffer de la ram para controlar los 48 led, en el programa puedo configurar el modulo SPI para enviar solo datos de 8 bits o datos de 16 bits, Escribo un poco de esta configuracion aqui...


#include <SPI.h>

#define latch   PA4   //P12
#define clocke  PA5   //P11
#define data    PA7   //P14

uint16_t hData, lData;
uint8_t display_ram[48]={0};

void setup()
{
  // Setup SPI 1
  SPI.begin(); //Initializa the SPI_1 port.
  SPI.setBitOrder(MSBFIRST); // fija el orden de los datos
  SPI.setDataMode(SPI_MODE0); //fija SPI_2 en modo 0
  SPI.setClockDivider(SPI_CLOCK_DIV16); // Velocida del SPI(72MHZ / 16 = 4.5 MHz SPI_1)
  pinMode(latch, OUTPUT);
  pinMode(PC13, OUTPUT);
  //SPI.setDataSize (SPI_CR1_DFF);   // Para configuara el modulo SPI para 16Bit
}

// no entiendo como dezplazar los datos si lo hago por parte alta y árte baja seria usando SPI.transfer(0xFF); y de nuevo SPI:transfer(0xFF);
o si escribo 16 bits parte alta y parte baja solo hago SPI.write(0xFFFF);  //0x  hData  lDAta

void send_data()
{
 signed int i,j;
 for(i=47; i>= 0; i--) {    //columnas
  for(j=0; j<2; j++) {     // filas
     digitalWrite(latch, HIGH);
     SPI.transfer(display_ram[j]);
     digitalWrite(latch, LOW);
   }
  }
}

Me estoy volviendo loco..... y no se como controlar este diseño que yo ise   

[KILLERJC]

Tu problema es exactamente ese, lo complicado que hiciste el driver en hardware que ahora para realizarlo en software se vuelve un caos.

El grafico que me hiciste es de 1 solo panel. Los demas paneles se conectan a la salida del registro de desplazamiento 4 ? ( Voy a suponer que es asi )

Creo que lo conveniente es que se envie 8 bits, asi no tener que crear los 16 bits dentro del micro.

Veamos... Siguiendo las secuencias a enviar si es que fuera un array tenemos que:

Datos a enviar:
0,1,2,3,4,5          //Esto si : Fila 1
6...11                  // Esto no : Fila 2
12...17                  // Esto no : Fila 3
18...23                      // Esto no : Fila 4
24,25,26,27,28,29    // Esto si : Fila 1
30....35                     // Esto no : Fila 2

En orden como debe ser enviado (segun el conexionado de los 74hc595):
29,5,28,4,27,3,26,2,25,1,24,0

Resumen despues de analizar el primer envio, siempre van a estar separados por 24, vas a comenzar con el mas alto y luego de alli alternando hacia el mas bajo.

Código: C

1. //Filas
2. for(j=0;j<4;j++)
3. {
4.         for(i=0; i<6 ;i++)
5.         {
6.                 Enviar_SPI( Display[(6*j)+29-i])
7.                 Enviar_SPI( Display[(6*j)+5-i])
8.         }
9.         // Aca latch y activo comunes, es donde deberias esperar antes de enviar lo de la otra fila
10. }

Probemos esto.. Primer fila, i desde 0 a 5

Valores de indice de array:

Código: C

1. i ->  Indice
2. 0 ->  0 + 29 - 0 = 29
3. 0 ->  0 + 5 - 0 =  5
4. 1 ->  0 + 29 - 1 = 28
5. 1 ->  0 + 5 - 1 =  4
6. 2 ->  0 + 29 - 2 = 27
7. 2 ->  0 + 5 - 2 =  3
8. 3 ->  0 + 29 - 3 = 26
9. 3 ->  0 + 5 - 3 =  2
10. 4 ->  0 + 29 - 4 = 25
11. 4 ->  0 + 5 - 4 =  1
12. 5 ->  0 + 29 - 5 = 24
13. 5 ->  0 + 5 - 5 =  0

Los valores dan correctamente. La formulas asi tambien los loops se pueden mejorar un poco pero lo dejo ya a tu voluntad.

Sigamos el ejemplo con la 2da fila (j=1), esta ves debemos enviar:
35,11,34,10,33,9,32,8,31,7,30,6

Código: C

1. i ->  Indice
2. 0 ->  6 + 29 - 0 = 35
3. 0 ->  6 + 5 - 0 =  11
4. 1 ->  6 + 29 - 1 = 34
5. 1 ->  6 + 5 - 1 =  10
6. 2 ->  6 + 29 - 2 = 33
7. 2 ->  6 + 5 - 2 =  9
8. 3 ->  6 + 29 - 3 = 32
9. 3 ->  6 + 5 - 3 =  8
10. 4 ->  6 + 29 - 4 = 31
11. 4 ->  6 + 5 - 4 =  7
12. 5 ->  6 + 29 - 5 = 30
13. 5 ->  6 + 5 - 5 =  6

Lo cual es correcto. Ahi tenes tu envio

PD:

Tome el formato del array con que lo hiciste ( display_ram[48] )