Error con "switch-case" en CCS

[aitopes]

Hola !
Estoy obligandome a comenzar con el CCS, y me he topado con un problema:
Trasteando con el ejemplo propuesto por redpic para el manejo de servos, me encuentro que el switch-case funciona si hago esto:

Código: [Seleccionar]

switch(Keypress){
    // Periodos Prefijados
    case 1: tSERVO1=ticks_PULSO_MINIMO;
              break;
Pero no si hago asi:

Código: [Seleccionar]

switch(Keypress){
    // Periodos Prefijados
    case "1": tSERVO1=ticks_PULSO_MINIMO;
              break;
La diferencia es la forma en que tomo el "1" o 1 . El error que me da el compilador es "Expresion must evaluate to a constant", y no logro pasar de ahi.
El codigo original esta en Ejemplito 16F876A: Controlando un SERVO con el PIC desde nuestro PC... , y seguro que no tiene errores. Sera que el maestro redpic uso otro compilador de C? 

[RedPic]

Ja, ja, ja      amigo Aitopes:

Si Keypress es char entonces la comparación es con simples comillas, no con dobles comillas que se reservan para los strings.

Queda entonces como case '1': ...

Puede ser que haya metido la pata al "editarlo" para ponerlo bonito ... ja ja ja  ...     

Edito: Exacto, es un error de transcripción. Te pongo el código original:

Código: C

1. // servo_pwm_232
2.  
3. // Ejemplo con un servo FUTABA S3003
4. // Alimentación y pulsos a 5V
5.  
6. // Cuadro de Tiempos :
7.  
8. //    Periodo 20 ms (Frecuencia 50 Hz)
9. //    Ancho Pulso minimo 0.5 ms
10. //    Ancho pulso medio  1.5 ms
11. //    Ancho pulso maximo 2.5 ms
12.  
13. //    TMR0 a 1:16 -> 1 RTCC cada 4.096 ms
14. //                -> 1 Tick cada 0.096 / 256 = 0.016 ms
15. //                -> 20 ms = (4 x RTCC completas) + (1 * RTCC - 30 ticks)
16.  
17. //    Ancho Pulso minimo 0.5 ms ->  31 ticks de TMR0
18. //    Ancho pulso medio  1.5 ms ->  93 ticks de TMR0
19. //    Ancho pulso maximo 2.5 ms -> 155 ticks de TMR0
20.  
21.  
22. #include <16f876a.h>
23. #fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
24. #use delay(clock=4000000)
25. #use standard_io(b)
26. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
27.  
28. #define PIN_SERVO1 PIN_B0
29.  
30. const int AJUSTE_FINO_DE_RTCC =  30;
31. const int ticks_PULSO_MINIMO  =  31;
32. const int ticks_PULSO_MEDIO   =  93;
33. const int ticks_PULSO_MAXIMO  = 155;
34.  
35. int1 flagRTCC   = 0;
36. int  contRTCC   = 0;
37. int1 flagSERVO1 = 0;
38. int  tSERVO1    = ticks_PULSO_MEDIO;
39.  
40. char Keypress=0x00;
41.  
42. void eco_servos(void);
43.  
44. #int_rda
45. void rda_isr() {
46.  
47.    Keypress=0x00;
48.    if(kbhit()){
49.       Keypress=getc();
50.    }
51. }
52.  
53. #int_RTCC
54. RTCC_isr(){
55.  
56.    ++contRTCC;
57.    if(contRTCC==4){
58.       set_TIMER0(AJUSTE_FINO_DE_RTCC);
59.    }
60.    if(contRTCC==5){
61.       flagRTCC=1;
62.       contRTCC=0x00;
63.    }
64. }
65.  
66. void main() {
67.  
68.    int ValTIMER0;
69.  
70.    setup_counters(RTCC_INTERNAL,RTCC_DIV_16);
71.  
72.    enable_interrupts(int_rda);
73.    enable_interrupts(global);
74.  
75.  
76.    printf("\r\n\SERVO Commander\r\n\r\n");
77.    eco_servos();
78.  
79.    set_TIMER0(0);
80.  
81.    enable_interrupts(INT_RTCC);
82.  
83.  
84.    do {
85.    
86.       // DISPARO DEL PULSO PWM
87.  
88.       if(flagRTCC==1){
89.          flagRTCC=0;
90.          output_high(PIN_SERVO1);
91.          flagSERVO1=1;    
92.       }
93.  
94.       // CONTROL DE ANCHO DEL PULSO PWM
95.       if(flagSERVO1==1){
96.          valTIMER0 = get_TIMER0();
97.          if(valTIMER0>tSERVO1){
98.             flagSERVO1=0;
99.             output_low(PIN_SERVO1);
100.          }  
101.       }
102.    
103.       // CONTROL DESDE LA RS-232
104.      
105.       if(Keypress!=0x00){
106.          switch(Keypress){
107.             // Periodos Prefijados
108.  
109.             case '1': tSERVO1=ticks_PULSO_MINIMO;
110.                       break;
111.             case '2': tSERVO1=ticks_PULSO_MEDIO;
112.                       break;
113.             case '3': tSERVO1=ticks_PULSO_MAXIMO;
114.                       break;
115.             case '+': if(++tSERVO1>ticks_PULSO_MAXIMO){
116.                         tSERVO1=ticks_PULSO_MAXIMO;
117.                       }
118.                       break;
119.             case '-': if(--tSERVO1<ticks_PULSO_MINIMO){
120.                         tSERVO1=ticks_PULSO_MINIMO;
121.                       }
122.                       break;
123.             case 'r': eco_servos();
124.                       break;
125.         }
126.          
127.          Keypress=0x00;
128.       }
129.  
130.  
131.    } while (TRUE);
132.  
133. }
134.  
135. void eco_servos(void){
136.    printf("S=%u\r\n",tSERVO1);
137. }

[aitopes]

Ops....Efectivamente, es ese el problema.
Pero copie-pegue desde el foro al CCS. Las comillas en mi navegador (Firefox) de ven como dobles. Eso unido a mi ignorancia respecro de CCS hicieron el resto.

Acaba de compilar ok. Como mi notebook no tiene puerto rs-232, voy a cacharrear un poco para probarlo. Estoy intentando dotar de vida a mi exapodo, aprovechando que llueve a mares.

GRACIAS!

Edito: acabo de ver tu "edición".

[aitopes]

Hola RedPic!

Tengo una consulta:
He modificado el codigo minimamente como para probar la placa controladora de una pata de mi robot (4 servos), tal como te copio mas abajo, pero los servos ni se mueven.....
Podrias (si tienes tiempo) mirar el tema de los fuses, etc, a ver que pasa?

Estoy usando un 16F627A, con los servos en B0, B3, B4 y B5, pin RESET a +V a travez de un diodo y resistencia de 4k7, nada conectado a ninguno de los otros pines del micro.
Las tensiones en la placa son correctas, 5V, GND, tengo en el reset 4.97V, etc.

Este es el codigo:

Código: C

1. #include <16F627A.h>
2. #fuses INTRC_IO,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
3. #use delay(clock=4000000)
4. #use standard_io(b)
5. #use standard_io(a)
6. #use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1)
7.  
8. #define PIN_SERVO1 PIN_B0
9. #define PIN_SERVO2 PIN_B3
10. #define PIN_SERVO3 PIN_B4
11. #define PIN_SERVO4 PIN_B5
12.  
13. const int AJUSTE_FINO_DE_RTCC =  30;
14. const int ticks_PULSO_MINIMO  =  31;
15. const int ticks_PULSO_MEDIO   =  93;
16. const int ticks_PULSO_MAXIMO  = 155;
17.  
18. int1 flagRTCC   = 0;
19. int  contRTCC   = 0;
20. int1 flagSERVO1 = 0;
21. int1 flagSERVO2 = 0;
22. int1 flagSERVO3 = 0;
23. int1 flagSERVO4 = 0;
24. int  tSERVO1    = ticks_PULSO_MEDIO;
25. int  tSERVO2    = ticks_PULSO_MEDIO;
26. int  tSERVO3    = ticks_PULSO_MEDIO;
27. int  tSERVO4    = ticks_PULSO_MEDIO;
28.  
29. char Keypress=0x00;
30.  
31. void eco_servos(void);
32.  
33. #int_rda
34. void rda_isr() {
35.   Keypress=0x00;
36.   if(kbhit()){
37.      Keypress=getc();
38.   }
39. }
40.  
41. #int_RTCC
42. RTCC_isr(){
43.   ++contRTCC;
44.   if(contRTCC==4){
45.      set_TIMER0(AJUSTE_FINO_DE_RTCC);
46.   }
47.   if(contRTCC==5){
48.      flagRTCC=1;
49.      contRTCC=0x00;
50.   }
51. }
52.  
53. void main() {
54.  
55.   int ValTIMER0;
56.   setup_counters(RTCC_INTERNAL,RTCC_DIV_16);
57.   enable_interrupts(int_rda);
58.   enable_interrupts(global);
59.  
60.   printf("\r\n\SERVO Commander\r\n\r\n");
61.   eco_servos();
62.   set_TIMER0(0);
63.  
64.   enable_interrupts(INT_RTCC);
65.  
66.   do {
67.      // DISPARO DEL PULSO PWM
68.      if(flagRTCC==1){
69.         flagRTCC=0;
70.         output_high(PIN_SERVO1);
71.         flagSERVO1=1;
72.        
73.         output_high(PIN_SERVO2);
74.         flagSERVO2=1;
75.        
76.         output_high(PIN_SERVO3);
77.         flagSERVO3=1;
78.        
79.         output_high(PIN_SERVO4);
80.         flagSERVO4=1;
81.      }
82.  
83.      // CONTROL DE ANCHO DEL PULSO PWM
84.      if(flagSERVO1==1){
85.         valTIMER0 = get_TIMER0();
86.         if(valTIMER0 > tSERVO1){
87.            flagSERVO1 = 0;
88.            output_low(PIN_SERVO1);
89.         }
90.      }
91.  
92.      if(flagSERVO2==1){
93.         valTIMER0 = get_TIMER0();
94.         if(valTIMER0 > tSERVO2){
95.            flagSERVO2 = 0;
96.            output_low(PIN_SERVO2);
97.         }
98.      }
99.  
100.      if(flagSERVO3==1){
101.         valTIMER0 = get_TIMER0();
102.         if(valTIMER0 > tSERVO3){
103.            flagSERVO3 = 0;
104.            output_low(PIN_SERVO3);
105.         }
106.      }
107.  
108.      if(flagSERVO4==1){
109.         valTIMER0 = get_TIMER0();
110.         if(valTIMER0 > tSERVO4){
111.            flagSERVO4 = 0;
112.            output_low(PIN_SERVO4);
113.         }
114.      }
115.  
116.    
117.  
118.   } while (TRUE);
119.  
120. }
121.  
122. void eco_servos(void){
123.   printf("S=%u\r\n",tSERVO1);
124. }

(ya se...podria haber sacada mas cosas, los printF por ejemplo, pero como estoy empezando con CCS quise toquetear lo menos posible. GRACIAS!

[RedPic]

Amigo Aitopes:

Primero decirte que me gustaría probarlo porque con ver solo el código me es dificil decidir qué puede estar mal ...

Prueba con esto y me cuentas los resultados. De todas formas voy a ver si puedo montar algo con un par de servos para poder probar bien (y un 16F628A porque 627 no tengo)

Código: C

1. //    Periodo 20 ms (Frecuencia 50 Hz)
2. //    Ancho Pulso minimo 0.75 ms
3. //    Ancho pulso medio  1.50 ms
4. //    Ancho pulso maximo 2.25 ms
5. //    TMR0 a 1:16 -> 1 RTCC cada 4.096 ms
6. //                -> 1 Tick cada 0.096 / 256 = 0.016 ms
7. //                -> 20 ms = (4 x RTCC completas) + (1 * RTCC - 30 ticks)
8.  
9. #include <16F627A.h>
10. #fuses INTRC_IO,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
11. #use delay(clock=4000000)
12. #use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1)
13.  
14. #define PIN_SERVO1 PIN_B0
15. #define PIN_SERVO2 PIN_B3
16. #define PIN_SERVO3 PIN_B4
17. #define PIN_SERVO4 PIN_B5
18.  
19. const int AJUSTE_FINO_DE_RTCC =  30;
20. const int ticks_PULSO_MINIMO  =  31;
21. const int ticks_PULSO_MEDIO   =  95;
22. const int ticks_PULSO_MAXIMO  = 155;
23.  
24. int1 flagRTCC   = 0;
25. int  contRTCC   = 0;
26.  
27. int1 flagSERVO1 = 0;
28. int1 flagSERVO2 = 0;
29. int1 flagSERVO3 = 0;
30. int1 flagSERVO4 = 0;
31.  
32. int  tSERVO1    = ticks_PULSO_MEDIO;
33. int  tSERVO2    = ticks_PULSO_MEDIO;
34. int  tSERVO3    = ticks_PULSO_MEDIO;
35. int  tSERVO4    = ticks_PULSO_MEDIO;
36.  
37. char Keypress=0x00;
38.  
39. #int_rda
40. void rda_isr() {
41.   Keypress=0x00;
42.   if(kbhit()){
43.      Keypress=getc();
44.   }
45. }
46.  
47. #int_RTCC
48. RTCC_isr(){
49.   ++contRTCC;
50.   if(contRTCC==4){
51.      set_TIMER0(AJUSTE_FINO_DE_RTCC);
52.   }
53.   if(contRTCC==5){
54.      flagRTCC=1;
55.      contRTCC=0x00;
56.   }
57. }
58.  
59. void main() {
60.  
61.   int ValTIMER0;
62.  
63.   setup_counters(RTCC_INTERNAL,RTCC_DIV_16);
64.   setup_timer_1(T1_DISABLED);
65.   setup_timer_2(T2_DISABLED,0,1);
66.   setup_comparator(NC_NC_NC_NC);
67.   setup_vref(FALSE);
68.   port_b_pullups(false);
69.   set_tris_b(0b00000010);
70.  
71.   printf("\r\n\SERVO Commander\r\n\r\n");
72.   set_TIMER0(0);
73.   enable_interrupts(int_rtcc);
74.   enable_interrupts(int_rda);
75.   enable_interrupts(global);
76.  
77.   do {
78.      // DISPARO DEL PULSO PWM
79.      if(flagRTCC==1){
80.         flagRTCC=0;
81.         output_high(PIN_SERVO1);
82.         flagSERVO1=1;
83.         output_high(PIN_SERVO2);
84.         flagSERVO2=1;
85.         output_high(PIN_SERVO3);
86.         flagSERVO3=1;
87.         output_high(PIN_SERVO4);
88.         flagSERVO4=1;
89.      }
90.  
91.      // CONTROL DE ANCHO DEL PULSO PWM
92.      if(flagSERVO1==1){
93.         valTIMER0 = get_TIMER0();
94.         if(valTIMER0 > tSERVO1){
95.            flagSERVO1 = 0;
96.            output_low(PIN_SERVO1);
97.         }
98.      }
99.  
100.      if(flagSERVO2==1){
101.         valTIMER0 = get_TIMER0();
102.         if(valTIMER0 > tSERVO2){
103.            flagSERVO2 = 0;
104.            output_low(PIN_SERVO2);
105.         }
106.      }
107.  
108.      if(flagSERVO3==1){
109.         valTIMER0 = get_TIMER0();
110.         if(valTIMER0 > tSERVO3){
111.            flagSERVO3 = 0;
112.            output_low(PIN_SERVO3);
113.         }
114.      }
115.  
116.      if(flagSERVO4==1){
117.         valTIMER0 = get_TIMER0();
118.         if(valTIMER0 > tSERVO4){
119.            flagSERVO4 = 0;
120.            output_low(PIN_SERVO4);
121.         }
122.      }
123.   } while (TRUE);
124. }

[aitopes]

Ahora si!  

PEro con una pega...supongo que de HARD:

Solo funciona cada servo cuando toco con el dedo el pin correspondiente del pic. Es decir, yo tengo 4 pines del pic conectados DIRECTAMENTE al cable de control de 4 servos. Si toco uno de esos cuatro pines, el servo correspondiente responde al programa. Si no...naranja.
¿No tengo puestas resistencias pull-up ni pull-down...seran necesarias? Que me dices?

PD: Ta gueno esto del Se...lo que debe ser el SeMasMas!!!! 

[RedPic]

 

[aitopes]

"Se" == C ....quise hacer un chiste, y no me salio

[Nocturno]

Podrías cambiar esto:   
  port_b_pullups(false);

por esto otro
  port_b_pullups(true);

A ver si se arregla tu problema con el dedo

De todas formas ese fallo es extraño, me suena a falta de masa en el oscilador   

[aitopes]

Gracias Nocturno!
Ya lo he probado, y hace lo mismo. (ya me veo montado en el robot, con un dedo tocando los pines para que se mueva).

Por cierto, no estoy usando oscilador externo..

[aitopes]

¡Funciono! He pasado un rato toqueteando el codigo, cambie a un 16F628A (originalmente use un 16F627A) y funciona. A jugar!!!!

Gracias maestros!

[MGLSOFT]

Podras poner el codigo ??
Me interesa ya que estoy haciendo un brazo con servos y me pasaba algo similar...

[aitopes]

Pero como no!

Eso si....no te hagas muchas ilusiones, mi idea fue solo probar el hard, asi que unicamente centra los servos.

Ahora estoy armando la placa "central" del robot, que le pasa las ordenes via RS-232 a estas "esclavas".

Asi me quedo el codigo. El hard esta armado sobre un 16F628A , sin cristal, reset, servos en B0, B3, B4 y B5, y RS-232 en B1/B2 .

Código: [Seleccionar]

//    Periodo 20 ms (Frecuencia 50 Hz)
//    Ancho Pulso minimo 0.5 ms
//    Ancho pulso medio  1.5 ms
//    Ancho pulso maximo 2.5 ms
//    TMR0 a 1:16 -> 1 RTCC cada 4.096 ms
//                -> 1 Tick cada 0.096 / 256 = 0.016 ms
//                -> 20 ms = (4 x RTCC completas) + (1 * RTCC - 30 ticks)

//    Ancho Pulso minimo 0.5 ms ->  31 ticks de TMR0
//    Ancho pulso medio  1.5 ms ->  93 ticks de TMR0
//    Ancho pulso maximo 2.5 ms -> 155 ticks de TMR0



#include <16F628A.h>
#fuses INTRC,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
#use delay(clock=4000000)
//#use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1)
#define PIN_SERVO1 PIN_B0
#define PIN_SERVO2 PIN_B3
#define PIN_SERVO3 PIN_B4
#define PIN_SERVO4 PIN_B5

const int AJUSTE_FINO_DE_RTCC =  30;
const int ticks_PULSO_MINIMO  =  31;
const int ticks_PULSO_MEDIO   =  95;
const int ticks_PULSO_MAXIMO  = 155;
int1 flagRTCC   = 1;
int  contRTCC   = 0;
int1 flagSERVO1 = 0;
int1 flagSERVO2 = 0;
int1 flagSERVO3 = 0;
int1 flagSERVO4 = 0;
int  tSERVO1    = ticks_PULSO_MEDIO;
int  tSERVO2    = ticks_PULSO_MEDIO;
int  tSERVO3    = ticks_PULSO_MEDIO;
int  tSERVO4    = ticks_PULSO_MEDIO;
char Keypress=0x00;

//#int_rda
//void rda_isr() {
// Keypress=0x00;
// if(kbhit()){
//    Keypress=getc();
// }
//}


#int_RTCC
RTCC_isr(){
 ++contRTCC;
 if(contRTCC==4){
    set_TIMER0(AJUSTE_FINO_DE_RTCC);
 }
 if(contRTCC==5){
    flagRTCC=1;
    contRTCC=0x00;
 }
}


void main() {
 int ValTIMER0;
 setup_counters(RTCC_INTERNAL,RTCC_DIV_16);
 setup_timer_1(T1_DISABLED);
 setup_timer_2(T2_DISABLED,0,1);
 setup_comparator(NC_NC_NC_NC);
 setup_vref(FALSE);
 port_b_pullups(true);
 set_tris_b(0b00000010);

 //printf("\r\n\SERVO Commander\r\n\r\n");
 set_TIMER0(0);
 enable_interrupts(int_rtcc);
 enable_interrupts(int_rda);
 enable_interrupts(global);


 do {
    // DISPARO DEL PULSO PWM
    if(flagRTCC==1){
       flagRTCC=0;
       output_high(PIN_SERVO1);
       flagSERVO1=1;
       output_high(PIN_SERVO2);
       flagSERVO2=1;
       output_high(PIN_SERVO3);
       flagSERVO3=1;
       output_high(PIN_SERVO4);
       flagSERVO4=1;
    }
    // CONTROL DE ANCHO DEL PULSO PWM
    if(flagSERVO1==1){
       valTIMER0 = get_TIMER0();
       if(valTIMER0 > tSERVO1){
          flagSERVO1 = 0;
          output_low(PIN_SERVO1);
       }
    }

    if(flagSERVO2==1){
       valTIMER0 = get_TIMER0();
       if(valTIMER0 > tSERVO2){
          flagSERVO2 = 0;
          output_low(PIN_SERVO2);
       }
    }

    if(flagSERVO3==1){
       valTIMER0 = get_TIMER0();
       if(valTIMER0 > tSERVO3){
          flagSERVO3 = 0;
          output_low(PIN_SERVO3);
       }
    }

    if(flagSERVO4==1){
       valTIMER0 = get_TIMER0();
       if(valTIMER0 > tSERVO4){
          flagSERVO4 = 0;
          output_low(PIN_SERVO4);
       }
    }



 } while (TRUE);
}

Por supuesto, el verdadero autor del codigo es RedPic. Lo mio solo fue....una poda.

[RedPic]

Ja, ja, ja  No hay nada como un 628 programado en Sé, aunque no sea SéMásMás ja ja ja 

Venga, ahora a reprogramar ese exápodo para que salte obstáculos ...