GiroPlay: un display giratorio con vistas

[Nocturno]

Continúo divagando sobre la posibilidad de armar algún día un bicho de estos y he estado intentando hacer un algoritmo que ilumine los leds según lo que hemos comentado, utilizando para ello 6 latches de 16 bits.

Ya sabéis cuál es mi relación con el maldito ASM, así que seguro que el algoritmo que os presento a continuación seguro que puede ser optimizado en gran medida.

No obstante, y aquí viene la buena noticia, este algoritmo sólo consume 1,275us (o sea, 1.275ns). Como teníamos una ventana de tiempo de 83us por pixel, en la que había que ejecutar al menos 3PWM, disponíamos de un tiempo de 27,66us, nos sobran 26,39us para organizar la vRAM, recibir datos por radio y atender otras interrupciones.

Quizás convenga aumentar el nº de ciclos de PWM que podemos hacer en cada pixel, no sé si con eso mejorará el gradiente de color, pero en vista del margen que tenemos podemos permitirnos probarlo.

Y bien, sin enrollarme más, aquí va el susodicho algoritmo:

Código: C

1. void __attribute__((__interrupt__))  _T2Interrupt(void) {
2.  
3.         asm ("mov.w _contador,w1");             // cargamos la variable Contador en W1
4.         asm ("mov.w #_vRAM,w2");                // cargamos el puntero de vRAM en W2
5.         asm ("add.w w1,w2,w2");                 // efectuamos desplazamiento en vRAM
6.        
7.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a R1
8.         Latch5=0;                                               // desactivamos el Latch anterior
9.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
10.         Latch0=1;                                               // activamos el Latch que corresponde a R1
11.        
12.         asm ("inc2.w w2,w2");                   // siguiente word
13.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a R2
14.         Latch0=0;                                               // desactivamos el Latch anterior
15.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
16.         Latch1=1;                                               // activamos el Latch que corresponde a R2
17.  
18.         asm ("inc2.w w2,w2");                   // siguiente word
19.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a G1
20.         Latch1=0;                                               // desactivamos el Latch anterior
21.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
22.         Latch2=1;                                               // activamos el Latch que corresponde a G1
23.  
24.         asm ("inc2.w w2,w2");                   // siguiente word
25.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a G2
26.         Latch2=0;                                               // desactivamos el Latch anterior
27.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
28.         Latch3=1;                                               // activamos el Latch que corresponde a G2
29.        
30.         asm ("inc2.w w2,w2");                   // siguiente word
31.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a B1
32.         Latch3=0;                                               // desactivamos el Latch anterior
33.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
34.         Latch4=1;                                               // activamos el Latch que corresponde a B1
35.  
36.         asm ("inc2.w w2,w2");                   // siguiente word
37.         asm ("mov.w [w2],w0");                  // leemos la posición de memoria que corresponde a B2
38.         Latch4=0;                                               // desactivamos el Latch anterior
39.         asm ("mov.w w0,PORTB");                 // y la sacamos por el puerto
40.         Latch5=1;                                               // activamos el Latch que corresponde a B2
41.  
42.         asm ("add.w w1,#12,w1");                // incrementamos el contador 12 bytes para siguiente lectura
43.  
44.         asm ("mov.w #0x1200,w0");               // 0x1200 es la memoria de vídeo en bytes
45.         asm ("sub.w w1,w0,w0");                 // se resta del contador para comparar si ha llegado
46.         asm ("bra nz, salir");                  // si no es igual, saltamos a "salir"
47.         asm ("clr.w w1");                               // si ha llegado, la inicializamos a 0
48.  
49.         asm ("salir:");
50.         asm ("mov.w w1,_contador");             // volcamos sobre la variable el valor que corresponda
51.  
52.         IFS0bits.T2IF = 0;    /* Borra flag */
53. }

Mediante este código en el main configuro el oscilador, el timer y la interrupción:

Código: C

1. int main() {
2.  
3.         // OSCILADOR
4.         CLKDIVbits.PLLPRE=2;
5.         CLKDIVbits.PLLPOST=1;
6.         PLLFBD=158;
7.         OSCTUN=23;
8.  
9.         // TIMER
10.         T2CONbits.T32=0;   // Modo 16 bits
11.         T2CONbits.TCS=0;   // Fuente = Internos (Fcy)
12.         T2CONbits.TCKPS=0; // Prescaler=1:1
13.         T2CONbits.TGATE=0; // TGate inactivo
14.         T2CONbits.TSIDL=0; //Continúa activo en modo Idle / Sleep
15.         T2CONbits.TON=1;   //Timer en marcha
16.         PR2=0x452;                      // 27,65us
17.  
18.         inicializa_vRAM();
19.         IEC0bits.T2IE=1;        // Interrupión Timer2 activa
20.  
21.        
22.         while (1);
23.         }

Y con esta función lleno la vRAM de datos conocidos; aquí habrá que meter las funciones de proceso de la memoria de vídeo:

Código: C

1. void inicializa_vRAM() {
2.         int i;
3.  
4.         for (i=0;i<TAM_MEMORIA_VIDEO;i++) {
5.                 vRAM[i]=i;
6.         }
7. }

Por último pego aquí lo que va al principio del programa:

Código: C

1. #include "p33FJ64GP306.h"
2. #define MIPS 40
3. _FOSCSEL(1);
4. _FOSC (195);
5.  
6. #define Latch0                                  PORTDbits.RD0
7. #define Latch1                                  PORTDbits.RD1
8. #define Latch2                                  PORTDbits.RD2
9. #define Latch3                                  PORTDbits.RD3
10. #define Latch4                                  PORTDbits.RD4
11. #define Latch5                                  PORTDbits.RD5
12.  
13.  
14. #define TAM_MEMORIA_VIDEO       2304    // words
15.  
16.  
17. int vRAM[TAM_MEMORIA_VIDEO];
18. int contador;

[flacoclau]

Acá están los dibujitos de lo que expliqué ayer, anoche los hice 
hay una variante con un transistor.

[flacoclau]

Otra cosa,¿No es posible utilizar una memoria o un grupo de memorias con salida paralelo?, ¿de las cuales sus salidas exiten un buffer a los leds directamente? esto gestionadas con algún pic que reciba los datos y mantenga el sincronismo del sistema, osea que el pic solo se encargue de sensar el pulso de sincronismo, para indicarles a cada memoria el instante que deben empezar a "tirar" los datos desde sus salidas a los leds, mantener un pulso reloj para todas estas memorias y además recibir los datos y cargarlos en estas memos.
 hay memorias bien rápidas y con mucho espacio, incluso se puede llegar a manejar con una misma varios colores, (a una buena velocidad de giro) osea en cada vuelta maneje cada color, multiplexando cada tira de leds de cada color.
saludos!!

[Nocturno]

¿Y qué nos merecerá más la pena, regular la velocidad del motor para que sea constante, o adaptar el algoritmo del display para que la interrupción del Timer se sincronice con la velocidad del motor pudiendo esta última cambiar dentro de unos márgenes?

En teoría, si tenemos una interrupción externa que nos indica el paso por 0 del motor y tenemos un timer libre para contar el tiempo que tarda en dar una vuelta, además de poner a 0 el puntero a la vRAM en cada nueva vuelta, podríamos configurar la precarga del timer para que divida un giro completo en 384 pixeles, sea cual sea la velocidad del motor dentro de unos márgenes establecidos.

Creo que intentaré programar esto, aunque ya se va haciendo necesario hacer alguna prueba física, porque difícilmente podré simularlo en MPLAB.

Como alguno de vosotros habéis sugerido, quizás sea bueno empezar por alguna prueba poco ambiciosa para chocar con todas las paredes que salgan al camino y luego acometer la construcción del definitivo. A lo mejor hago algo con 8 leds normales.

[Leon Pic]

Como alguno de vosotros habéis sugerido, quizás sea bueno empezar por alguna prueba poco ambiciosa para chocar con todas las paredes que salgan al camino y luego acometer la construcción del definitivo. A lo mejor hago algo con 8 leds normales.

Yo diría empezar como tu lo dices con algo más básico hasta aprender a manejarlo bien y luego ir complicándolo más.

Yo queiro empezar a  armar algo y aún ando buscando materiales para poder armar el software con lo que poseo, como mis conocimiento de electrónica no son muy avanzados, probare con solo pasar frases.

Saludos. 

[Sispic]

cambiando al hardware .

y con una columna de leds fijos en el centro ? , solo girarian unos cablecitos de fibra optica que pesan nada .







la pcb con el micro , alimentacion y leds fijos.

Boy a cortar la general de telefonica para coger unos trozos y provar .

[Nocturno]

Maestro, la idea es maravillosa, pero le veo una pega.,
Los leds casi no iluminan nada por el lado, tienen su máxima potencia mirándolos desde arriba. Si pudiéramos hacer algo para que la luz la roben desde la parte superior...

[aitopes]

Hola amigos!
Todavia no he probado mi "transformador con nucleo de aire", pero pienzo hacerlo esta tarde. Al menos, tengo los componentes para generar los 12V pulsados a unos cuandos khz, con buena corriente.

Coincido con Manolo en cuanto a comenzar con algo simple, y eso es justamente lo que voy a intentar. Mi motor tiene incluido un chip para ajustar su velocidad de una forma muy sencilla,asi que voy a delegar esa tarea al hard, al menos por ahora.

Y respecto de la idea de la fibra, no es para nada mala....y como se puede torcer, tranquilamente se puede poner con un extremo en la parte superior de los LEDs y curvarla 90 grados (con un radio de giro de un par de cm) sin demasiados problemas.

Saludos!

[Nocturno]

Sé que se puede curvar, Ariel, pero no puede girar curvada los 360º sin chocar con los pines de los leds que están arriba 

[aitopes]

Claro! la curva sirve para 1 Led solamente.

se me paso el pequeño detalle.

[MGLSOFT]

Pongan los leds horizontales en un placa fina atada al eje y luego de alli con las fibras!!

[aitopes]

Hola Marcos!
Es que la idea de Cisco era (creo) evitar el tener que poner electronica sobre la parte que gira....y si ponemos los leds a dar vueltas, estamos de nuevo como al principio. 

[MGLSOFT]

Dicho en gauchesco:
Como perro mordiendose la cola !!

[Nocturno]

En ocasiones he visto cómo los dispositivos electrónicos desvían la luz de un punto a otro con una pieza de plástico rígido de color semitransparente. En la punta se ve la luz como si el led estuviera allí.

¿No habrá piezas de plástico con forma de disco que reciban la luz por el centro y la desvíen a su circunferencia?

[aitopes]

¿No habrá piezas de plástico con forma de disco que reciban la luz por el centro y la desvíen a su circunferencia?

No las he visto circulares. Pero es posible que al repartir la luminosidad del led por toda la circunferencia, el brillo sea muy debil para nuestros propositos, no?