Array bidimensional con pic

[Miquel_S]

Buenas noches, necesitaría de vuestra ayuda, tengo problemas para sacar un array por el puerto b del pic y no se como hacerlo, ni tampoco encuentro nada por Internet relacionado con arrays y pics, este es el código con el que estoy trabajando:

Código: C

1. #include <xc.h>
2. #include "config_bits.h"
3.  
4. #define _XTAL_FREQ 8000000  // usado para delays
5.  
6. /* Secuencia de pasos (medio-paso) */
7. int medio_paso [8][4] = {
8.     {1, 0, 0, 0},
9.     {1, 1, 0, 0},
10.     {0, 1, 0, 0},
11.     {0, 1, 1, 0},
12.     {0, 0, 1, 0},
13.     {0, 0, 1, 1},
14.     {0, 0, 0, 1},
15.     {1, 0, 0, 1}
16. };
17.  
18.  
19. void setupClock(void);
20.  
21. void main(void){
22.    
23. /* Configuracion de puertos */
24.     ADCON1 = 0x0E;  // set RB<4:0> as digital I/O pins
25.                     // (required if config bit PBADEN is set)
26.     TRISB = 0x00;   // configuramos todo el PORTB como salidas
27.    
28.     setupClock();   // configuramos oscilador interno a 8MHz
29.    
30.     while(1){
31.         for(unsigned int i = 0; i < 8; i++)
32.         {
33.             LATBbits.LATB0, medio_paso[i][0];
34.             LATBbits.LATB1, medio_paso[i][1];
35.             LATBbits.LATB2, medio_paso[i][2];
36.             LATBbits.LATB3, medio_paso[i][3];
37.             __delay_ms(10);
38.         }
39.     }
40. }
41.  
42. void setupClock(void){
43.     OSCCONbits.IRCF0 = 1;
44.     OSCCONbits.IRCF1 = 1;
45.     OSCCONbits.IRCF2 = 1;
46.     OSCCONbits.SCS = 0b10;
47. }

Muchas Gracias.

[KILLERJC]

Primero y en principal no veo sentido a un array bidimensional.


Prefiero algo asi (Aprovechando que esta seguido y sin modificar RB4 a RB7):

Código: C

1. int medio_paso [8] = { 0b1000, 0b1100, 0b0100, 0b0110, 0b0010, 0b0011, 0b0001, 0b1001};
2.  
3. // Y luego:
4.  
5.         for(unsigned int i = 0; i < 8; i++)
6.         {
7.             LATB = ( LATB & 0xF0 ) | medio_paso[i];
8.             __delay_ms(10);
9.         }

Si no estan seguidos se puede fabricar algo de la misma forma.
Pero si lo queres hacer como vos estas intentando entonces tu problema es que pusiste una coma, y no un igual.

Código: C

1. LATBbits.LATB0, medio_paso[i][0];  //Mal
2.             LATBbits.LATB0 = medio_paso[i][0]; //Correcto

[Miquel_S]

Muchas gracias KILLERJC por la aclaración, una duda ¿Por motivos de consumo de recursos es mejor el uso de un array u otro?
Gracias de nuevo.

[KILLERJC]

Yo me preocuparia por los recursos cuando me falten.
Personalmente considero que una opcion bastante simple seria poner el array en la flash y de alli hacer como hice en el primer codigo, de paso ponerlo como char, ya que int en XC8 es de 16 bits.

Código: C

1. const uint8_t medio_paso [8] = { 0b1000, 0b1100, 0b0100, 0b0110, 0b0010, 0b0011, 0b0001, 0b1001};
2.  
3.         for(unsigned uint8_t i = 0; i < 8; i++)
4.         {
5.             LATB = ( LATB & 0xF0 ) | medio_paso[i];
6.             __delay_ms(10);
7.         }

Y si te preocupas por los recursos (tiempo de procesamiento,RAM,Flash,etc) tambien deberias pensar en ese delay de 10ms.
Por eso es un tire y afloje, podes ganar algo por un lado pero empeorarlo del otro. Ejemplo..
Podria hacerlo con un Timer al delay, gano tiempo de procesamiento, consumo un poco mas de Flash,
Podes hacerlo con delays como lo hiciste, pierdo tiempo de procesamiento, gano un poco de flash, un modulo, y tambien tiempo de desarrollo. Es mas facil poner un delay que calcular el timer y escribir todo el codigo para eso.
Ahora... ese delay molesta?, Si no molesta entonces no justifica que te tomes ese EXTRA para optimizarlo.
Te falta Flash? Te falta RAM, te faltan Timers (raro )? 

[tsk]

Bueno, aunque esto no es un estire y afloja, también se puede observar la estructura del problema para obtener optimizaciones  que son triviales.

Por ejemplo, lo primero que se puede observar es que entre pasos existe un sólo cambio, al puro estilo del código grey, eso se puede aprovechar, ya que lo único que debes de hacer es estar atento cual es el bit que cambia.

0b1000, 0b1100, 0b0100, 0b0110, 0b0010, 0b0011, 0b0001, 0b1001

Considerando que tu estado inicial es 0b1000, el contenido del arreglo podría quedar así

Código: C

1. const uint8_t medio_paso[] = {2,3,1,2,0,1,3,0};

y luego, en el lugar que decidas que debe ir, ya sea usando un delay o un timer, colocas

Código: C

1. LATB^= 1 << medio_paso[i];

Estado Inicial
0b1000

Código: [Seleccionar]

1 << 2 -> 0b0100

0b1000 xor 0b0100 = 0b1100

1 << 3 -> 0b1000

0b1100 xor 0b1000 = 0b0100

1 << 1 -> 0b0010

0b0100 xor 0b0010 = 0b0110

1 << 2 -> 0b0100

0b0110 xor 0b0100 = 0b0010

1 << 0 -> 0b0001

0b0010 xor 0b0001 = 0b0011

1 << 1 -> 0b0010

0b0011 xor 0b0001 = 0b0001

1 << 3 -> 0b1000

0b0001 xor 0b1000 = 0b1001

1 << 0 -> 0b0001

0b1001 xor 0b0001 = 0b1000

1 << 2 -> 0b0100

0b1000 xor 0b0100 = 0b1100

En ASM esto puede representar tan sólo un bit set o un bit reset, que de todas formas también vienen en la siguiente secuencia:

{1,0,1,0,1,0...}

Donde 1 es un bit set y 0 es un bit reset.

[Miquel_S]

Bueno, aunque esto no es un estire y afloja, también se puede observar la estructura del problema para obtener optimizaciones  que son triviales.

Por ejemplo, lo primero que se puede observar es que entre pasos existe un sólo cambio, al puro estilo del código grey, eso se puede aprovechar, ya que lo único que debes de hacer es estar atento cual es el bit que cambia.

0b1000, 0b1100, 0b0100, 0b0110, 0b0010, 0b0011, 0b0001, 0b1001

Considerando que tu estado inicial es 0b1000, el contenido del arreglo podría quedar así

Código: C

1. const uint8_t medio_paso[] = {2,3,1,2,0,1,3,0};

y luego, en el lugar que decidas que debe ir, ya sea usando un delay o un timer, colocas

Código: C

1. LATB^= 1 << medio_paso[i];

Estado Inicial
0b1000

Código: [Seleccionar]

1 << 2 -> 0b0100

0b1000 xor 0b0100 = 0b1100

1 << 3 -> 0b1000

0b1100 xor 0b1000 = 0b0100

1 << 1 -> 0b0010

0b0100 xor 0b0010 = 0b0110

1 << 2 -> 0b0100

0b0110 xor 0b0100 = 0b0010

1 << 0 -> 0b0001

0b0010 xor 0b0001 = 0b0011

1 << 1 -> 0b0010

0b0011 xor 0b0001 = 0b0001

1 << 3 -> 0b1000

0b0001 xor 0b1000 = 0b1001

1 << 0 -> 0b0001

0b1001 xor 0b0001 = 0b1000

1 << 2 -> 0b0100

0b1000 xor 0b0100 = 0b1100

En ASM esto puede representar tan sólo un bit set o un bit reset, que de todas formas también vienen en la siguiente secuencia:

{1,0,1,0,1,0...}

Donde 1 es un bit set y 0 es un bit reset.

  Aquí me has matado tsk, de todos modos voy a estudiar las dos opciones la tuya y la de KILLERJC y decantarme por la que mas me convenga al resultado final que quiero darle a todo el conjunto.

Muchas Gracias.
https://vimeo.com/124110129

[planeta9999]

 
Los operadores bitwise se ven muy interesantes.

Los he visto con frecuencia en fuentes de otros, pero por ahora no los he aplicado en desarrollos míos, los de desplazamiento de bits los cazo, el resto no veo cuando puede ser recomendable usarlos.

Por ejemplo, en esta parte de un fuente, del que partí para una aplicación mía, no se exactamente que están haciendo con esos AND, luego le aplican también un desplazamiento de 1bit (o eso creo):

Código: C++

1. uint16_t dotMask = 0x8000;
2.     while (dotMask)
3.     {
4.       uint8_t colorEntry = 0;
5.       if (dots0 & dotMask) colorEntry += 4;
6.       if (dots1 & dotMask) colorEntry += 4;
7.       if (dots2 & dotMask) colorEntry += 4;
8.       if (dots3 & dotMask) colorEntry += 4;
9.      *pixelBuffer = activePalette[colorEntry];
10.       pixelBuffer++;
11.       dotMask >>= 1;
12.     }

Un día de estos me gustaría profundizar en el manejo de los operadores bitwise, deben de tener un potencial importante.

[tsk]

Lo que se ve a simple vista es que te convierte de un conjunto de puntos a una paleta de 16 colores.

Con el AND lo que haces conocer si el punto está prendido o apagado, en cada vuelta puedes procesar una región o ventana conformada por una matriz de 4x16 puntos.

Así que, aunque los operadores bitwise sean interesantes, es más interesante el algoritmo que hay detrás del trabajo de procesamiento de imágenes.


A menos que que cada punto físico original esté conformado por 4 puntos más pequeños, si lo vemos como un filtro, aparte de convertir de unos puntos cualquiera a una paleta de colores, al realizar una combinación de los puntos que son adyacentes al punto que quieres convertir a pixel, generas mejores los contornos y suavizas la imagen resultante. Pero los puntos adyacentes pueden ser cualquiera. Por ejemplo, estos podrían ser los cuatro puntos que se encuentran alrededor del punto a convertir, y es lo más común.

Código: [Seleccionar]

  1
0 p 2
  3

Pero también podrían tomar cualquier otro forma como algunos de los puntos que se encuentran arriba y abajo, del punto a convertir.

Código: [Seleccionar]

0
1
2
3

1
2
3
4

2
3
4
5
...

Hablando de procesamiento digital de imágenes, a lo de arriba se le conoce como kernel y te indica las operaciones que vas a realizar y sobre cuales pixeles los vas realizar. Por ejemplo hay un filtro conocido como Sobel, el cual se usa para detectar bordes en imágenes, y su kernel toma la siguiente forma

X

Código: [Seleccionar]

+1 0 -1
+2 0 -2
+1 0 -1

Y

Código: [Seleccionar]

+1 +2 +1
 0  0  0
-1 -2 -1

En tu caso el kernel podría ser

Código: [Seleccionar]

   +4 
+4  p +4
   +4 

Y aplicas ese kernel a tu imagen (formada por puntos prendidos y apagados) por medio de un operador conocido como Convolución, con lo cual obtienes lo que deseas, ya sea suavizar bordes, extraer objetos, quitar o aplicar ruido, etc.

[planeta9999]

Lo que se ve a simple vista es que te convierte de un conjunto de puntos a una paleta de 16 colores.

Con el AND lo que haces conocer si el punto está prendido o apagado, en cada vuelta puedes procesar una región o ventana conformada por una matriz de 4x16 puntos.

Así que, aunque los operadores bitwise sean interesantes, es más interesante el algoritmo que hay detrás del trabajo de procesamiento de imágenes.

A menos que que cada punto físico original esté conformado por 4 puntos más pequeños, si lo vemos como un filtro, aparte de convertir de unos puntos cualquiera a una paleta de colores, al realizar una combinación de los puntos que son adyacentes al punto que quieres convertir a pixel, generas mejores los contornos y suavizas la imagen resultante. Pero los puntos adyacentes pueden ser cualquiera. Por ejemplo, estos podrían ser los cuatro puntos que se encuentran alrededor del punto a convertir, y es lo más común.

En este caso, se trata de una imagen que llega como cuatro frames o imágenes separadas, y la mezcla de las cuatro genera la imagen final, en la que cada punto tiene un nivel de brillo de 0 a 15. Esa función convierte cada nivel de brillo de 1 pixel (mezcla de 4) a un color de una paleta de 16 colores.

Lo que no cazo es lo de la máscara a 0x8000, y porque el bucle while está rodando hasta que la máscara dotMask deja de ser cierta. Supongo que el while se ejecuta mientras dosMask no sea cero.

La máscara empieza en 0x8000, y por cada pase por el bucle del while, le hace un desplazamiento de un bit a la derecha, no entiendo para que sirve esto.

Ahora que lo pienso, las variables dotsx son de 16 bit, y creo que cada una almacena el estado de 16 pixel de la imagen. Supongo que la máscara sirve para barrer, en cada paso del bucle, uno a uno los  16 pixel.

0x8000 en binario es 1000000000000000, entiendo que por cada pase por el bucle va desplazando un bit a la derecha, los siguientes serían 0100000000000000, 0010000000000000, etc... hasta llegar a 0000000000000000 que es cuando sale del while.

Código: C++

1. uint16_t dotMask = 0x8000;
2.     while (dotMask)
3.     {
4.       uint8_t colorEntry = 0;
5.       if (dots0 & dotMask) colorEntry += 4;
6.       if (dots1 & dotMask) colorEntry += 4;
7.       if (dots2 & dotMask) colorEntry += 4;
8.       if (dots3 & dotMask) colorEntry += 4;
9.      *pixelBuffer = activePalette[colorEntry];
10.       pixelBuffer++;
11.       dotMask >>= 1;
12.     }

[KILLERJC]

Lo que no cazo es lo de la máscara a 0x8000, y porque el bucle while está rodando hasta que la máscara dotMask deja de ser cierta. Supongo que el while se ejecuta mientras dosMask no sea cero.

La máscara empieza en 0x8000, y por cada pase por el bucle del while, le hace un desplazamiento de un bit a la derecha, no entiendo para que sirve esto.

en binario
0x800 = 1000.0000.0000.0000
Rotado 1 ves
0x400 = 0100.0000.0000.0000
Otra ves rotado
0x200 = 0010.0000.0000.0000

Y revisa en las 4 imagenes el mismo bit aumentando el "brillo" si es que posee un 1 esa imagen. Cuando las 4 imagenes posean un 1 en ese bit, significa que el resultado sera maximo.

Como vos dijiste y en resumen...

Forma de 4 imagenes donde en cada una de esas imagenes cada pixel equivale a un bit ( 0 o 1 ), a una imagen donde cada pixel puede tener valores de 0 a 16

Cuando esta ene 0x001 = 0000.0000.0000.0001 al rotarlo otra ves, queda en 0x000, por lo tanto la condicion del while ya no se cumple y sale.

[planeta9999]

Si, eso mismo entendí, no hay como leer un programa unas cuantas veces y al final sale todo, aunque al principio me sonaba a chino mandarín.

El día que domine el DMA, ya puedo escribir un libro.   

[Miquel_S]

Hola, sigo avanzando en mi pequeño proyecto y como era de esperar tengo errores y no doy con ellos, mi intención era que dependiendo del pulsador tuviera un movimiento u otro, pero creo tener un error en los switch-case y no consigo verlo. Algún buen samaritano me da una mano.

Código: C

1. #include <xc.h>
2. #include "config_bits.h"
3.  
4. #define _XTAL_FREQ 8000000  // usado para delays
5.  
6. /* Secuencia de pasos (medio-paso)
7.    Motor derecho => bits de menor peso
8.    Motor izquierdo => bits de mayor peso */
9.  
10. char forward_medio_paso [8] = {
11.     0b10001001, 0b11000001,
12.     0b01000011, 0b01100010,
13.     0b00100110, 0b00110100,
14.     0b00011100, 0b10011000};
15.  
16. char backward_medio_paso [8] = {
17.     0b10011000, 0b00011100,
18.     0b00110100, 0b00100110,
19.     0b01100010, 0b01000011,
20.     0b11000001, 0b10001001};
21.  
22. char right_medio_paso [8] = {
23.     0b10001000, 0b11001100,
24.     0b01000100, 0b01100110,
25.     0b00100010, 0b00110011,
26.     0b00010001, 0b10011001};
27.  
28. char left_medio_paso [8] = {
29.     0b10011001, 0b00010001,
30.     0b00110011, 0b00100010,
31.     0b01100110, 0b01000100,
32.     0b11001100, 0b10001000};
33.  
34. void setupClock(void);
35.  
36. char movimiento;
37.  
38. void main(void){
39.    
40. /* Configuracion de puertos */
41.     ADCON1 = 0b00001111;    // todos los pines como digitales
42.     //CMCON = 0x07;
43.     TRISA = 0b00001111; // RA3:RA0 entradas
44.     TRISB = 0x00;   // configuramos todo el PORTB como salidas
45.  
46. /* Configuracion oscilador interno */    
47.     setupClock();   // configuramos oscilador interno a 8MHz
48.    
49.     while(1){
50.        
51.         switch(movimiento){
52.             case 1:
53.                 while(LATAbits.LATA0 == 1);
54.                     for(char i = 0; i < 8; i++)
55.                     {
56.                         LATB = ( LATB & 0x00 ) | forward_medio_paso[i];
57.                         __delay_ms(1);
58.                     }
59.             break;
60.            
61.             case 2:
62.                 while(LATAbits.LATA1 == 1);
63.                     for(char i = 0; i < 8; i++)
64.                     {
65.                         LATB = ( LATB & 0x00 ) | backward_medio_paso[i];
66.                         __delay_ms(1);
67.                     }
68.             break;
69.            
70.             case 3:
71.                 while(LATAbits.LATA2 == 1);
72.                     for(char i = 0; i < 8; i++)
73.                     {
74.                         LATB = ( LATB & 0x00 ) | right_medio_paso[i];
75.                         __delay_ms(1);
76.                     }
77.             break;
78.            
79.             case 4:
80.                 while(LATAbits.LATA3 == 1);
81.                     for(char i = 0; i < 8; i++)
82.                     {
83.                         LATB = ( LATB & 0x00 ) | left_medio_paso[i];
84.                         __delay_ms(1);
85.                     }
86.             break;
87.                
88.         }
89.     }
90. }
91.  
92. void setupClock(void){
93.     OSCCONbits.IRCF0 = 1;
94.     OSCCONbits.IRCF1 = 1;
95.     OSCCONbits.IRCF2 = 1;
96.     OSCCONbits.SCS = 0b10;
97. }

Gracias.

[KILLERJC]

No tiene ningun sentido crear tantos arrays asi para manejar 2 motores. No se como estas conectando los motores pero podria llegar a ser mucho mas simple.

Tus errores son:

movimiento, no esta inicializado, deberias hacerlo a 0.
Luego no hay incremento de movimiento, es decir falta un movimiento++, y ademas verificar que sea valido de 1 a 4, o de 0 a 3 (es mas facil este)

Respecto a los arrays, porque crear 2 arrays distintos por ejemplo para fordward o backwards, cuando podes en ves de incrementar, podrias decrementar la variable i, y comenzar desde 7 en tu for.

[Miquel_S]

Hola KILLERJC, gracias por la ayuda, he probado parte de lo que me aconsejas y me encuentro con un problema que no se muy bien el porque, probando de usar el mismo array para dos movimientos distintos (adelante-atrás), me pasa que si uso el array para el avance

Código: C

1. for(char i = 0; i < 8; i++)

los motores funcionan de forma correcta, pero al usar

Código: C

1. for(char i = 7; i > 0; i--)

para el giro en sentido contrario uno de los motores tarda en arrancar o sencillamente no arrancan ni uno ni otro.

Código: C

1. #include <xc.h>
2. #include "config_bits.h"
3.  
4. #define _XTAL_FREQ 8000000  // usado para delays
5.  
6. /* Secuencia de pasos (medio-paso)
7.    Motor derecho => bits de menor peso
8.    Motor izquierdo => bits de mayor peso */
9.  
10. char forward_medio_paso [8] = {
11.     0b10001001, 0b11000001,
12.     0b01000011, 0b01100010,
13.     0b00100110, 0b00110100,
14.     0b00011100, 0b10011000};
15.  
16. /*char backward_medio_paso [8] = {
17.     0b10011000, 0b00011100,
18.     0b00110100, 0b00100110,
19.     0b01100010, 0b01000011,
20.     0b11000001, 0b10001001};*/
21.  
22. /*char right_medio_paso [8] = {
23.     0b10001000, 0b11001100,
24.     0b01000100, 0b01100110,
25.     0b00100010, 0b00110011,
26.     0b00010001, 0b10011001};*/
27.  
28. /*char left_medio_paso [8] = {
29.     0b10011001, 0b00010001,
30.     0b00110011, 0b00100010,
31.     0b01100110, 0b01000100,
32.     0b11001100, 0b10001000};*/
33.  
34. void setupClock(void);
35.  
36. void main(void){
37.    
38. /* Configuracion de puertos */
39.     ADCON1 = 0x0E;  // set RB<4:0> as digital I/O pins
40.                     // (required if config bit PBADEN is set)
41.     TRISB = 0x00;   // configuramos todo el PORTB como salidas
42.    
43.     setupClock();   // configuramos oscilador interno a 8MHz
44.    
45.     while(1){
46.         for(char i = 7; i > 0; i--)
47.         {
48.             LATB = ( LATB & 0x00 ) | forward_medio_paso[i];
49.             __delay_ms(1);
50.         }
51.     }
52. }
53.  
54. void setupClock(void){
55.     OSCCONbits.IRCF0 = 1;
56.     OSCCONbits.IRCF1 = 1;
57.     OSCCONbits.IRCF2 = 1;
58.     OSCCONbits.SCS = 0b10;
59. }

NOTA: Si uso un array diferente para cada movimiento funcionan todos de forma correcta.
Saludos!

[KILLERJC]

Podes decir como tenes conectado el motor al PIC?, supongo que son 2 motores, para tener adelante/atras e izquierda/derecha.