TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: Algec en 11 de Julio de 2011, 12:50:51

Título: Seleccionar #define en PICC
Publicado por: Algec en 11 de Julio de 2011, 12:50:51
Hice unos programas que utilizan diversas tablas que selecciono habilitando el #define correspondiente antes de compilar el fichero que finalmente implemento en el picc-
Ahora lo que quisiera es que mediante unas entradas sellecionar la tabla correspondiente, en funcion del estado de los pines con unos switches o jumpers
Lo que ocurre es que no se como hacer esto en PICC

Seria algo asi



//#define tabla1
//#define tabla2
//#define tabla3

....

#ifdef tabla1
#define tabla2
byte PB[4] = {
0b11111000,
0b00000000,
0b11110100,
0b00001100
};
#endif
.....

Aqui viene el resto del programa


No se como hacer que estas definiciones se puedan seleccionar dentro del main al arrancar
Alguien puede darme una ayuda para hacer algo asi?


Gracias

NOta, las tablas son algo grandes, no he probado si estando todas definidas entrarian  en la memoria del pic que uso pero eso seria otra cuestion
Título: Re: Seleccionar #define en PICC
Publicado por: Nocturno en 11 de Julio de 2011, 13:01:32
Si no caben las tres en la memoria será imposible hacer lo que quieres. Los defines sirven para decirle al compilador qué partes del programa debe incluir o no; si no las incluye, el PIC no podrá seleccionarlas nunca.

Por tanto, lo primero, probar si cabe todo.
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 11 de Julio de 2011, 13:03:26
vale probare primero eso y os comento, de todas formas las tablas son de distinto tamaño unas que otras por eso uso el define, pero luego se usan con el mismo nombre, lo que complica un poco el asunto
Gracias
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 11 de Julio de 2011, 15:02:31
Bueno caber caben todas definidas, lo que pasa es que como las tablas son de tamaños distintos, no se como hacer que la que finalmente sellecione mediante las dos entradas pueda igualarla a la que se vaya a usar.
Es decir si voy a usar una Tab[8} y una Taa[4]
 deberia hacer la que uso que podria ser tax[] y taY[] iguales a estas, pero si selecciono Tac[16] y TaD[32]
pàra usarlas e  funcion de la seleccion  deberia hacer tax = tab y taY= taa   y en el otro caso tax= Tac y TaY = TaD

no se como seria ya que todas son de tamaños distintos.
Me podeis echar una mano?
Título: Re: Seleccionar #define en PICC
Publicado por: Nocturno en 11 de Julio de 2011, 15:17:46
¿Y no puedes pasar a la función el puntero a la tabla y su longitud para que esta la procese adecuadamente?
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 12 de Julio de 2011, 08:47:20
A ver si me explico

Usaria los siguientes arrays definidos asi como origen posible de las dos tablas que finalmente usara el programa

byte TA[4] = {
0b11111000,
0b00000000,
0b11110100,
0b00001100
};

byte TB[4] = {
0b0000,
0b1111,
0b0000,
0b1111
};


byte TC[8] = {
0b11111000,
0b11111000,
0b00000000,
0b11110000,
0b11110100,
0b11110100,
0b00001100,
0b11111100
};

byte TD[8] = {
0b0000,
0b1111,
0b1111,
0b1111,
0b0000,
0b1111,
0b1111,
0b1111
};


byte TE[16] ={
0b00001100,
0b01101100,
0b10111100,
0b11101100,
0b11111000,
0b11101000,
0b10111000,
0b01101000,
0b00000000,
0b01100000,
0b10110000,
0b11100000,
0b11110100,
0b11100100,
0b10110100,
0b01100100
};

byte TF[16] = {
0b1111,
0b1110,
0b1011,
0b0110,
0b0000,
0b0110,
0b1011,
0b1110,
0b1111,
0b1110,
0b1011,
0b0110,
0b0000,
0b0110,
0b1011,
0b1110
};




Para el trabajo en el programa se usarian otros arrays que serian TX[] y TY[]
que no tienen el tamaño definido ya que no se cual sera a priori la que se usara, dependera de un valor o del estado de unas entradas

por lo que no se como hacer reserva de memoria, si seria algo asi
o se necesita algo mas

byte TX[];
byte TY[];


En funcion de el valor de las entradas A0 y A1, de una variable o lo que fuese...
en el main se haria un switch tal que..


switch (cmd)
      {
    case 0:
      Tx[]=TA[];
      Ty[]=TB[];
      break;
    case 1:
      Tx[]=TC[];
      Ty[]=TD[];
      break;
      ......
     
     
asi sucesivamente
   
La cuestion es que no se como hacer que esto funcione,
es decir, la forma de programar que los arrays TX y TY
tengan el tamaño y el valor igual que el correspondiente par TA....a TE
que le corresponda en ese ciclo de programa.....


Espero que este claro mi problema y que podais ayudarme, muchas gracias

 
Otra cuestion es, podria guardar las tablas originales en ROm en vez de Ram com lo que libero ram para el programa?
Como se hace eso?


MIl gracias
An los puntero si, claro pero no tengo claro como usarlos en este caso
Título: Re: Seleccionar #define en PICC
Publicado por: Nocturno en 12 de Julio de 2011, 11:13:20
Bien, supongamos que tienes una función que recorre el array completo y lo va sacando por printf.

A esa función deberás enviarle un puntero al array y su longitud, tal que así:

Código: C
  1. switch (cmd)
  2.       {
  3.     case 0:
  4.       recorre(TA,4);
  5.       recorre(TB,4);
  6.       break;
  7.     case 1:
  8.       recorre(TC,8);
  9.       recorre(TD,8);
  10.       break;
  11.     case 2:
  12.       recorre(TE,16);
  13.       recorre(TF,16);
  14.       break;
  15. }
El puntero al array es su propio nombre , y en la función trabajaremos con él de esta manera:

Código: C
  1. void recorre(byte *Tabla, int longitud) {
  2.       int i;
  3.       for (i=0;i<longitud;i++)
  4.             printf("%u ",Tabla[i]);
  5. }

Para guardar las tablas en la ROM basta con poner CONST al definirlas:
Código: C
  1. byte CONST TA[4] = {
  2. 0b11111000,
  3. 0b00000000,
  4. 0b11110100,
  5. 0b00001100
  6. };
Limitaciones de esta solución:
- cualquier cambio que hagas en el array dentro de la función, quedará hecho sobre el array original. Si no quieres que ocurra eso, habría que hacer una copia temporal del array.
- creo que CCS no admite el paso a una función de un array en ROM, pero no estoy seguro; habría que probarlo
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 12 de Julio de 2011, 12:02:52
La idea es la siguiente. al iniciar el programa leer el array correspondiente a lo seleccionado en la ROm y cargar esos valores en el array TX y TY en la ram, ese sera el array que usara el programa durante toda su ejecucion. La lectura se ghara al principio una vez determinado que array se va a usar  medianmte el estado de 2 bits de entrada del puerto A.
Una vez leido ya nada se modifica. los valores cargados en el array ram quedan asi y se usan de forma ciclica.
Esto para que te hagas una idea es la forma de seleccionar micropasos para una controladora de micropasos para motores paso a paso.
LEo el estado de dos pines, veo que micropasos he seleccionado y los paso de la rom a la ram, una vez en la ram se usan de forma cicclica pero no se vuelve a leer hasta un nuevo rearranque del programa-
Voy a ver lo que me has pegado y mirare como va a ver si me sirve
Muchas gracias
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 13 de Julio de 2011, 09:21:50
Veamos hice esto pero tengo algunas dudas

VArios arrays en ROm



Código: C
  1. CONST byte P1[4] = {
  2. 0b11111000,
  3. 0b00000000,
  4. 0b11110100,
  5. 0b00001100
  6. };
  7.  
  8. CONST byte P2[4] = {
  9. 0b0000,
  10. 0b1111,
  11. 0b0000,
  12. 0b1111
  13. };
  14.  
  15.  
  16.  
  17.  
  18. CONST byte P3[8] = {
  19. 0b11111000,
  20. 0b11111000,
  21. 0b00000000,
  22. 0b11110000,
  23. 0b11110100,
  24. 0b11110100,
  25. 0b00001100,
  26. 0b11111100
  27. };
  28.  
  29. CONST byte P4[8] = {
  30. 0b0000,
  31. 0b1111,
  32. 0b1111,
  33. 0b1111,
  34. 0b0000,
  35. 0b1111,
  36. 0b1111,
  37. 0b1111
  38. };
  39.  
  40.  
  41. CONST byte P5[8] = {
  42. 0b00001100,
  43. 0b10111100,
  44. 0b11111000,
  45. 0b10111000,
  46. 0b00000000,
  47. 0b10110000,
  48. 0b11110100,
  49. 0b10110100
  50. };
  51.  
  52. CONST byte P6[8] = {
  53. 0b1111,
  54. 0b1011,
  55. 0b0000,
  56. 0b1011,
  57. 0b1111,
  58. 0b1011,
  59. 0b0000,
  60. 0b1011
  61. };
  62.  
  63. // estos en ram sin definir el tamaño. primera duda, cuanta reserva hace el compilador si no he definido el tamaño?
  64.  
  65.  
  66. byte PA[];
  67. byte PB[];


// la funciona de cargar en los arrays de ram los que sellecione de rom seria esta
¿FUNCIONA BIEN ASI?


Código: C
  1. void leer_entradas_seleccion(void)
  2.    {
  3.    int valor=0; //valor de seleccion de los dos pines, va del 0 al 3, es decir 4 posibilidades
  4.    int i=0;
  5.    valor=input(pin_A4)+(input(pin_A5)*2);
  6.    switch (valor)
  7.       {
  8.       // paso completo
  9.        case 0:{
  10.          for(i=0;14;i++)
  11.             {PA[i]=P1[i];
  12.              PB[i]=P2[i];
  13.             }
  14.         break;
  15.         }
  16.         //medio paso
  17.         case 1:{
  18.          for(i=0;1<8;i++)
  19.             {PA[i]=P3[i];
  20.             PB[i]= P4[i];
  21.             }
  22.         break;
  23.         }
  24.         // medio paso con compensacion de par
  25.         //400 pasos por revolucion
  26.         case 2:{
  27.          for(i=0;1<8;i++)
  28.             {PA[i]=P4[i];
  29.             PB[i]= P5[i];
  30.             }
  31.         break;
  32.         }
  33.         //drive de 4 pasos
  34.         //800 pasos por revolucion
  35.         case 3:{
  36.          for(i=0;1<8;i++)
  37.             {PA[i]=P6[i];
  38.             PB[i]= P7[i];
  39.             }
  40.         break;
  41.    
  42.           }
  43.  
  44.    }
  45.    }
Título: Re: Seleccionar #define en PICC
Publicado por: Nocturno en 13 de Julio de 2011, 11:23:27
Cita de: Algec en 13 de Julio de 2011, 09:21:50
// estos en ram sin definir el tamaño. primera duda, cuanta reserva hace el compilador si no he definido el tamaño?


byte PA[];
byte PB[];

No sé cuánto ocupan así, pero mejor será que los definas con el tamaño máximo que deberían tener y evitas el problema.

byte PA[8];
byte PB[8];


Creo que la función que has escrito irá bien, con la excepción de que el primer bucle te dará un error de sintaxis porque has puesto 14 donde querías decir i<4


Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 13 de Julio de 2011, 12:49:12
Ok cierto, bien puedo reservar el maximo en los arrays en Ram a ver que pasa.
Si es cierto puse 14, error de sintaxis. ahora probare cuando este todo listo y comprobado en hard que funciona bien subire la controladora por si alguien la quiere

Gracias
Título: Re: Seleccionar #define en PICC
Publicado por: Algec en 14 de Julio de 2011, 15:53:44
Parece que compila bien, ahora otra cuestion, como puedo verificar en ISis que array se ha cargado? como ver en ISis los valores que tiene el array en cada momento?