como configurar pic para shift register TLC5925?

[uZYNQ]

uZYNQ, gracias por tu respuesta.
 antes trabaje con el xc8 ahora lo hago en ccs por lo que no tengo acceso a las librerias xc8,  busque para descargarla pero no la he podido conseguir.

XC8 es el compilador de microchip, si quieres lo puedes descargar de su página. Normalmente se instala para trabajar con su IDE el MplabX. Pero ya que tu trabajas con CCS, fácilmente puede pasar ese código y no necesitas ninguna librería.

Saludos.

[johenrod]

una libreria que tiene xc8 de ejemplo de shift register del 74hc595

[Eduardo2]

...
la idea es hacerlo con 12 de estos chips pero la idea es comenzar con 2 para ver el proceso.
creeria que puedo hacerlo con un pic de 8 bits y los datos almacenarlos en una variable de 16 y enviarlos.
como seria el proceso de envio de datos en el codigo, trabajo en CCS.

Con #USE SPI de CCS  podés enviar bloques de hasta 32 (o 40) bits.   En tu caso, siendo 12*8=96 bits vas a tener que enviar tandas de a 8 o 16 bits y al final un pulso en LE.

Algo asi:

Código: [Seleccionar]

#use spi (MASTER, CLK=PIN_B2,  DO=PIN_B1, BAUD=800000, MODE=0, BITS=8, LSB_FIRST)
#define LE  PIN_B3
y el envío de datos:

Código: [Seleccionar]

    spi_xfer(0xFF);  // primer dato
    spi_xfer(0x0F); 
    spi_xfer(0xF0);
    spi_xfer(0x11);
..............................
    spi_xfer(0x33);
    spi_xfer(0x55); // ultimo
   
    output_high(LE); // Pulso en LE
    delay_us(1) ;
    output_low(LE);


[johenrod]

Eduardo2, cordial saludo..
implemente tu sugerencia y los leds se quedan encendidos con un ligero titileo,, sera que los tiempos de este integrado son muy rigurosos?
lo implemente con un16f1827 no se si hay problema ya que tiene 2 spi.

[Eduardo2]

Tiempos rigurosos para nada, mientras los tiempos relativos al clk, SDI y LE no estén al limite...   
Probá a una frecuencia baja (BAUD=1000) y retardá y ensancha el pulso LE
ej:

Código: [Seleccionar]

    //------------------------------
    delay_us(100) ; output_high(LE);
    delay_us(100) ; output_low(LE);
    delay_us(100) ;
    //------------------------------

Si desaparece el problema entonces era distorsión se la señal --> vas aumentando la velocidad y achicando el LE hasta un valor seguro.

Si lo sigue haciendo ya habrá que revisar software y hardware. Sobre todo el hardware, porque en Proteus es un violín.

[johenrod]

Tiempos rigurosos para nada, mientras los tiempos relativos al clk, SDI y LE no estén al limite...   
Probá a una frecuencia baja (BAUD=1000) y retardá y ensancha el pulso LE
ej:

Código: [Seleccionar]

    //------------------------------
    delay_us(100) ; output_high(LE);
    delay_us(100) ; output_low(LE);
    delay_us(100) ;
    //------------------------------

Si desaparece el problema entonces era distorsión se la señal --> vas aumentando la velocidad y achicando el LE hasta un valor seguro.

Si lo sigue haciendo ya habrá que revisar software y hardware. Sobre todo el hardware, porque en Proteus es un violín.

gracias Eduardo2,
bueno al menos ya me prenden aunque descontrolados..
una pregunta este ic tlc5925 tiene 16 salidas hay 3 ic en cascada pero  manejan 12 leds tricolor el primero solo los rojos el segundo solo los verdes y el tercero solo los azules pero al ser 12 quedan faltando 4 posiciones para desplazarsen los datos y llegar al 16 creo, es que empiezan a pasar los datos al al otro integrado, como se puede resolver ya que siempre hay un espacio de 4 pociciones no utilizadas?

[Eduardo2]

...
bueno al menos ya me prenden aunque descontrolados..

Pero tenías razón con el MODE=0 , queda muy cerca el cambio del dato con el flanco del clock.  El que corresponde es MODE=2

una pregunta este ic tlc5925 tiene 16 salidas hay 3 ic en cascada pero  manejan 12 leds tricolor el primero solo los rojos el segundo solo los verdes y el tercero solo los azules pero al ser 12 quedan faltando 4 posiciones para desplazarsen los datos y llegar al 16 creo, es que empiezan a pasar los datos al al otro integrado, como se puede resolver ya que siempre hay un espacio de 4 pociciones no utilizadas?

Los 4 primeros o ultimos bits de cada tanda de 16 se llenan con cualquier cosa. Además, si vas a trabajarlo con esos datos te conviene que spi_xfer mande de a 16 bits.

Ejemplo

Código: [Seleccionar]

#use spi (MASTER, CLK=PIN_B2,  DO=PIN_B1, BAUD=500000, MODE=2 , BITS=16, LSB_FIRST)


Código: [Seleccionar]

    spi_xfer(0x0bbb);   // o 0xbbb0    según de qué lado estén los leds sin conexión
    spi_xfer(0x0ggg);   // o 0xggg0
    spi_xfer(0x0rrr);   // o 0xrrr0
   
    //------------------------------
    delay_us(2) ; output_high(LE);
    delay_us(2) ; output_low (LE);
    delay_us(2) ;
    //------------------------------


[johenrod]

todo va muy bien , el problema si,, efectivamente era ruido con pull down lo solucione.
por ultimo que podria hacer para ahorrar memoria ya que en algun momento para llegar al ultimo IC deberia enviar 192 bits en 12 tandas de 16 bytes, se me ocurre una matrix.
algo como esto,, aunque no se si sirva bit a bit.

Código: C

1. byte const s1d7[]={0b00000001,0b00000010,0b00000100,0b00001001,0b00010010,0b00100100,0b01001001,0b10010010
2.                     0b00100100,0b01001000,0b10010000,0b00100000,0b01000000,0b10000000,0b00000000};//0-14
3.                          
4.      const signed int16   s2d7[]={0,2000,3500,5000};//0-2
5.      const signed int16   s3d7[]={6000,4000,2500,1000};//0-2

[Eduardo2]

...por ultimo que podria hacer para ahorrar memoria ya que en algun momento para llegar al ultimo IC deberia enviar 192 bits en 12 tandas de 16 bytes,

- Tu idea era poner los 12 TLC5925 en cascada, eso en memoria son 24 bytes y para alterar cualquier bit siempre vas a tener que transferir todo de nuevo. 

- Se podrían transferir bloques mas chicos, por ejemplo de 48 bits ( tres TLC5925 en cascada) pero necesitás disponer de dos pines mas. De esta manera tendría 3 pines LE para activar el grupo de TLC5925 que corresponda.

- También se puede ir recirculando los datos en anillo e ir alterando solo los bits que corresponda.  No consume memoria pero consume ciclos, pues si antes era transferir 192 bits, de esta forma son 384.

Pero es difícil sugerir porque sé muy poco de lo que querés ni porqué lo querés hacer así.

[johenrod]

muchas gracias por  toda la ayuda,,,
sin un pic no tiene "SPI"  se podria emular?
en algun momento requiero llamar una variable de 16 bits y luego ir pasando bit a bit a un pin,, tengo esto pero no me funciona

Código: C

1. #bit   data = PORTa.1
2.       const signed int16   secuencia[]={0b00000000000001,0b0000000000000010,0b0000000000000100};
3.      
4.      int16 n =0;
5.      int16 x =0;
6.      int16 y =0;
7.      
8.      
9.       for (n=0;n<3;n++)
10.      {      
11.        x=secuencia[n]
12.        for (y=0;y<16;y++)
13.        {
14.        data=x,y
15.        }
16.        
17.        delay...
18.      
19.       }

[DominusDRR]

muchas gracias por  toda la ayuda,,,
sin un pic no tiene "SPI"  se podria emular?
en algun momento requiero llamar una variable de 16 bits y luego ir pasando bit a bit a un pin,, tengo esto pero no me funciona

Código: C

1. #bit   data = PORTa.1
2.       const signed int16   secuencia[]={0b00000000000001,0b0000000000000010,0b0000000000000100};
3.      
4.      int16 n =0;
5.      int16 x =0;
6.      int16 y =0;
7.      
8.      
9.       for (n=0;n<3;n++)
10.      {      
11.        x=secuencia[n]
12.        for (y=0;y<16;y++)
13.        {
14.        data=x,y
15.        }
16.        
17.        delay...
18.      
19.       }

Sería algo similar el código de Xc8 que tu mismo compartiste

Código: C

1. for (int i=0 ; i<16 ; i++){
2.  
3.         DATA_595 = (data >> i) & 0x01;
4.  
5.         clock();
6.  
7.     }

[Eduardo2]

...sin un pic no tiene "SPI"  se podria emular?

Sí.  Es mas, #USE SPI  te genera código emulado si querés.
Como el código necesario es sencillo, puede ser preferible escribir el propio y que funcione como uno quiere.

en algun momento requiero llamar una variable de 16 bits y luego ir pasando bit a bit a un pin,, tengo esto pero no me funciona
...........

Probá asi:

Código: [Seleccionar]

      for (n=0;n<3;n++)
     {     
       x=secuencia[n] ;
       for (y=0;y<16;y++ , x>>=1)
       {
       data=bit_test(x,0) ;
       }
       
       delay...

Para sacar primero el MSB  cambiás  x>>=1 por x<<=1 y bit_test(x,0) por bit_test(x,15)

[johenrod]

les agradezco mucho, tal como me dijeron trabaja al pelo. ya estoy esperimentando con las secuencias.
estoy enviando datos asi,,,

Código: C

1. const signed int16 sec0[]={   0b0000000000000000,0b0000000000000000,0b0000000000000000,  0b0000000000000000,0b0000000000000000,0b0000000000000000,    
2.                               0b0000000000000000,0b0000000000000000,0b0000000000000000,   0b0000000000000000,0b0000000000000000,0b0000000000000000};                      
3.  
4. const signed int16 sec1[]={   0b1111111111111111,0b0000000000000000,0b0000000000000000,  0b1111111111111111,0b0000000000000000,0b0000000000000000,  
5.                               0b1111111111111111,0b0000000000000000,0b0000000000000000,   0b1111111111111111,0b0000000000000000,0b0000000000000000};
6.  
7. const signed int16 sec2[]={   0b0000000000000000,0b1111111111111111,0b0000000000000000,  0b0000000000000000,0b1111111111111111,0b0000000000000000,  
8.                               0b0000000000000000,0b1111111111111111,0b0000000000000000,   0b0000000000000000,0b1111111111111111,0b0000000000000000};
9.  
10. const signed int16 sec3[]={   0b0000000000000000,0b0000000000000000,0b1111111111111111,  0b0000000000000000,0b0000000000000000,0b1111111111111111,  
11.                               0b0000000000000000,0b0000000000000000,0b1111111111111111,   0b0000000000000000,0b0000000000000000,0b1111111111111111};

me llama la atencion que con estas areglos tan grandes no se me incrementa el uso de la "RAM"

lo otro es que son muchas lineas para hacer una sola secuencia, se podria esto resumir un poco, estos son los detalles..

* son  4 modulos en cascada.
* cada modulo tiene 3 shift register uno para rojo otro para azul y otro para verde
* por lo que para encender un solo modulo digamos que en color blanco debo enviar 48 bits todos en "1"

[DominusDRR]

me llama la atencion que con estas areglos tan grandes no se me incrementa el uso de la "RAM"

Esto:

Código: C

1. const

crea una constante en la memoria flash

[DominusDRR]

* son  4 modulos en cascada.

En lugar de conectarlos en cascada, posiblemente puedas conectarlos en paralelo, algo similar a esto: