Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip

[MGLSOFT]

Lo mas importante no lo escribiste.
Anda ??   

Ademas la idea del bucle de 5 segundos de a 500 mseg era reemplazar esta instruccion en el programa principal:

      delay_ms(5000);

Tambien hay un reset del watchdog en Use_delay() 
Fijate en la ayuda que si lo pones no necesitas hacer este barullo del bucle for.

[luc_eluani88]

No me da error de checksum, pero no recibe los sms, me aparecen en el cel como enviados, pero no entregados. Eso estoy probando ahora. Puse eso, para ver con los reles si es que recibe y funciona.

[luc_eluani88]

Código: C

1. #include <pruebav003.h>
2.   #include <string.h>
3. #int_RDA
4. void  RDA_isr(void)
5. {
6. USART_buffer[USART_nextRec]=fgetc(SIM900);
7. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
8. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
9. }
10. //Rutinas de usuario
11. void inicializo_buffer_USART(void){ //Borra el contenido del buffer
12.  
13.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
14.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
15.    USART_buffer[i]='\0';}
16.    
17. }
18.  
19. int8 respuesta_CMD_SIM900(int8 *buffer[],char *cmd,int8 cmd_len){
20.  
21. // Variable local.
22. short respuesta=0x00;
23.  
24. ptr=strstr(buffer,cmd);              // Busca el comando OK en el buffer.
25.     if(strncmp(ptr,cmd,cmd_len)==0)  // Si lo encuentra..
26.        {respuesta=0x01;}             // respuesta válida --> 0x01.    
27.    else{respuesta=0x00;}             // Si no lo encuentra, respuesta errónea --> 0x00.              
28.  return(respuesta);                  // Retornamos con la respusta al comando.
29.  
30. }
31.  
32. int8 SIM900_ON(void){
33.  
34.   // Variables locales.
35.   int8 checksum[5]="";
36.   int8 resp=0x00;
37.  
38.   // Habilitamos interrupciones.
39.   enable_interrupts(int_RDA);
40.  
41.   POWERKEY_OFF;          // SIM900 -> Apagado.
42.   delay_ms(5);          // Esperamos 5ms.
43.   delay_ms(100);        // Esperamos 100ms.
44.   POWERKEY_ON;           // SIM900 -> Enciende.
45.   delay_ms(1500);       // Esperamos 1,5 seg.
46.   POWERKEY_OFF;          // PRWKEY=0;
47.   delay_ms(40000);      // Esperamos 40 segundos el Call Ready.
48.  
49.   // Inicializamos el buffer de la UART.
50.   inicializo_buffer_USART();
51.  
52.   fprintf(SIM900,"AT\r");                               // CMD: Comando de verificación.
53.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
54.   checksum[0]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
55.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.  
56.   fprintf(SIM900,"ATE0\r");                             // CMD: Eco OFF.
57.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
58.   checksum[1]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
59.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
60.   fprintf(SIM900,"AT+CMGF=1\r");                        // CMD: Configuramos modo texto.
61.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
62.   checksum[2]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
63.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
64.   fprintf(SIM900,"AT+CPMS=\"SM\",\"SM\"\r");            // CMD: Selecciono la mememoria SIM para recibir y leer SMS.
65.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
66.   checksum[3]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
67.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
68.   fprintf(SIM900,"AT+CNMI=2,2,0,0,0\r");                // CMD: Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
69.   delay_ms(500);        
70.   checksum[4]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
71.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
72.  
73.   // Comprobamos si respondió bien a todos los comandos.
74.   resp=checksum[0]+checksum[1]+checksum[2]+checksum[3]+checksum[4];
75.    if(resp==0x05){LED_ERROR_OFF LED_OK_ON}
76.      else{resp=0x00; LED_ERROR_ON LED_OK_OFF}
77.    
78.    return(resp);
79. }
80.  
81. void procesa_sms(int8 *buffer[],char *cmd,int8 cmd_len);
82.  
83.  
84. void main()
85. {int b=0;
86.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
87.    setup_wdt(WDT_OFF);
88.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
89.    enable_interrupts(INT_RDA);
90.    enable_interrupts(GLOBAL);
91. if(SIM900_ON()==0x05)
92. {RELAY1_ON;
93. delay_ms(1500);
94. RELAY1_OFF;
95. }
96.  
97.    
98.    while(TRUE)
99.    {
100.    
101.  
102.     delay_ms(500);
103.     procesa_sms(USART_buffer,"r1on",4);
104.      
105.      
106.    
107.    
108.    }
109.  
110. }
111. void procesa_sms(int8 *buffer[],char *cmd,int8 cmd_len)
112. {
113. pal=strstr(buffer,cmd);
114. if (strncmp(ptr,cmd,cmd_len)==0)
115.          {
116.          RELAY1_ON;
117.          delay_ms(2500);
118.          RELAY1_OFF;
119.          RELAY2_ON;
120.          delay_ms(2500);
121.         RELAY2_OFF;
122.          }
123. inicializo_buffer_USART();
124. }

Me pega el rele cuando arranca la rutina. Pero no se si estará recibiendo bien el string y demás. Por la forma de funcionar la rutina de Jonathan veo que la comunicación si funciona, porque envía el parámetro y responde OK. O sea que detecta eso. No me esta detectando la lectura de sms. Después de configurado. Le agregue esas funciones para eliminar el watchdog manualmente. Pero ahora no se apagan los LEDs de NET y READY, por ende el watchdog pudo haber sido problema.

[MGLSOFT]

Si entras a mirar la hoja de datos ampliada (que describe en cada capitulo la funcionalidad de cada modulo por separado) te vas a asombrar de la cantidad de cosas que afectan el watchdog.
No seria nada extraño que los de CCS hayan olvidado algún bit de configuración perdido por allí y quede activado pero no lo vemos.
Yo por las dudas hace mucho tiempo que hago esto en mis programas si uso un PIC18F, consume NADA y me aseguro que no es el WDT el que me embrome un programa.

[luc_eluani88]

El modulo aparentemente inicializa bien, pero no procesa los sms. Estoy probando con pequeñas modificaciones. Pero me resulta extraño si procesa bien los comandos de inicializacion.

Código: C

1. #include <pruebav003.h>
2.   #include <string.h>
3. #int_RDA
4. void  RDA_isr(void)
5. {
6. USART_buffer[USART_nextRec]=fgetc(SIM900);
7. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
8. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
9. }
10. //Rutinas de usuario
11. void inicializo_buffer_USART(void){ //Borra el contenido del buffer
12.  
13.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
14.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
15.    USART_buffer[i]='\0';}
16.    
17. }
18.  
19. int8 respuesta_CMD_SIM900(int8 *buffer[],char *cmd,int8 cmd_len){
20.  
21. // Variable local.
22. short respuesta=0x00;
23.  
24. ptr=strstr(buffer,cmd);              // Busca el comando OK en el buffer.
25.     if(strncmp(ptr,cmd,cmd_len)==0)  // Si lo encuentra..
26.        {respuesta=0x01;}             // respuesta válida --> 0x01.    
27.    else{respuesta=0x00;}             // Si no lo encuentra, respuesta errónea --> 0x00.              
28.  return(respuesta);                  // Retornamos con la respusta al comando.
29.  
30. }
31.  
32. int8 SIM900_ON(void){
33.  
34.   // Variables locales.
35.   int8 checksum[5]="";
36.   int8 resp=0x00;
37.  
38.   // Habilitamos interrupciones.
39.   enable_interrupts(int_RDA);
40.  
41.   POWERKEY_OFF;          // SIM900 -> Apagado.
42.   delay_ms(5);          // Esperamos 5ms.
43.   delay_ms(100);        // Esperamos 100ms.
44.   POWERKEY_ON;           // SIM900 -> Enciende.
45.   delay_ms(1500);       // Esperamos 1,5 seg.
46.   POWERKEY_OFF;          // PRWKEY=0;
47.   delay_ms(40000);      // Esperamos 40 segundos el Call Ready.
48.  
49.   // Inicializamos el buffer de la UART.
50.   inicializo_buffer_USART();
51.  
52.   fprintf(SIM900,"AT\r");                               // CMD: Comando de verificación.
53.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
54.   checksum[0]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
55.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.  
56.   fprintf(SIM900,"ATE0\r");                             // CMD: Eco OFF.
57.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
58.   checksum[1]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
59.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
60.   fprintf(SIM900,"AT+CMGF=1\r");                        // CMD: Configuramos modo texto.
61.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
62.   checksum[2]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
63.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
64.   fprintf(SIM900,"AT+CPMS=\"SM\",\"SM\"\r");            // CMD: Selecciono la mememoria SIM para recibir y leer SMS.
65.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
66.   checksum[3]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
67.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
68.   fprintf(SIM900,"AT+CNMI=2,2,0,0,0\r");                // CMD: Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
69.   delay_ms(500);        
70.   checksum[4]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
71.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
72.  
73.   // Comprobamos si respondió bien a todos los comandos.
74.   resp=checksum[0]+checksum[1]+checksum[2]+checksum[3]+checksum[4];
75.    if(resp==0x05){LED_ERROR_OFF LED_OK_ON}
76.      else{resp=0x00; LED_ERROR_ON LED_OK_OFF}
77.    
78.    return(resp);
79. }
80.  
81.  
82. void main()
83. {
84. RELAY1_OFF;
85. RELAY2_OFF;
86. int8 b=0x00;
87.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
88.    setup_wdt(WDT_OFF);
89.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
90.    enable_interrupts(INT_RDA);
91.    enable_interrupts(GLOBAL);
92. if(SIM900_ON()==0x05)
93. {RELAY1_ON;
94. delay_ms(1500);
95. RELAY1_OFF;
96. LED_OK_OFF;
97. }
98.  
99.    
100.    while(TRUE)
101.    {
102.    
103.    if (USART_buffer[1]!=0)
104.     {LED_OK_ON;
105.     LED_ERROR_ON;
106.     delay_ms(500);
107.     b=respuesta_CMD_SIM900(USART_buffer,"Porton",6);
108.     if(b=0x01)
109.       {LED_OK_OFF;
110.       LED_ERROR_OFF;
111.       }
112.     }
113.      
114.    
115.    
116.    }
117.  
118. }

Aprovechando la rutina de Jonathan, utilize la funcion respuesta_CMD_SIM900, y le cargue los parametros que yo utilizaria. Con esta logica, si llegaba un sms se debian encender los leds, y si era el que tenia la palabra correcta se apagaba. Pero quedan encendidos.

[MGLSOFT]

No encuentro donde esta declarado este valor:

bytes_for_USART_buffer

[luc_eluani88]

Lo tengo en el header:

Código: C

1. #include <18F14K50.h>
2. #device adc=16
3.  
4.  
5. #FUSES NOWDT                
6. #FUSES CPUDIV1                  
7. #FUSES HS                      
8. #FUSES NOPLLEN                  
9. #FUSES NOIESO                  
10. #FUSES PUT                      
11. #FUSES NOBROWNOUT            
12. #FUSES NOLVP                    
13. #FUSES NOXINST                  
14.  
15.  
16. // Declaración para trabajar con punteros a constantes.
17. #device PASS_STRINGS=IN_RAM
18.  
19. #use delay(crystal=12000000,  clock=3000000)
20.  
21. #use FIXED_IO( C_outputs=PIN_C7,PIN_C6,PIN_C4,PIN_C1,PIN_C0 )
22. #define RELAY1   PIN_C0
23. #define RELAY2   PIN_C1
24. #define POWERKEYGSM   PIN_C4
25. #define LED1   PIN_C6
26. #define LED2   PIN_C7
27.  
28. #use rs232(baud=4800,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SIM900,RESTART_WDT)
29.  
30. #define RELAY1_ON            output_high(RELAY1);
31. #define RELAY1_OFF            output_low(RELAY1);
32. #define RELAY2_ON            output_high(RELAY2);
33. #define RELAY2_OFF            output_low(RELAY2);
34. #define POWERKEY_ON          output_high(POWERKEYGSM);
35. #define POWERKEY_OFF         output_low(POWERKEYGSM);
36. #define LED_OK_ON            output_high(LED1);
37. #define LED_OK_OFF           output_low(LED1);
38. #define LED_ERROR_ON         output_high(LED2);
39. #define LED_ERROR_OFF        output_low(LED2);
40.  
41. // Variables utilizadas.
42.  
43. #define bytes_for_USART_buffer 160                  // Tamaño del buffer de la USART [140 bytes].
44. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
45. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
46. int8 i=0x00;                                        // Variable auxiliar.
47. char *ptr;                                          // Puntero auxiliar.
48.  
49.  
50. #use delay(restart_wdt)

[luc_eluani88]

HAciendo unas modificaciones el programa quedo funcional. Agradezco mucho a todos los moderadores y usuarios que me dieron esta mano tan grande!!

[MGLSOFT]

Deberías poner (si queres ) la solución, y agregarle al titulo del post (Solucionado), así quienes entran encuentran el tema y su solución.
Aunque sea comentarlo.
Y felicitaciones !!

[jonathanPIC888]

HAciendo unas modificaciones el programa quedo funcional. Agradezco mucho a todos los moderadores y usuarios que me dieron esta mano tan grande!!

Felicidades, es un aporte muy interesante para los que se inicien con el SIM900 

Deberías poner (si queres ) la solución, y agregarle al titulo del post (Solucionado), así quienes entran encuentran el tema y su solución.

+10

[luc_eluani88]

Gracias a la Colaboracion tanto de Mgsoft como de Jonathan, pude hacer funcionar la placa. La Rutina la tome de los archivos de Jonathan.

Código: C

1. #include <pruebav003.h>
2.   #include <string.h>
3.  
4. #int_RDA
5. void  RDA_isr(void)
6. {
7. USART_buffer[USART_nextRec]=fgetc(SIM900);
8. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
9. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
10. }
11. //Rutinas de usuario
12. void inicializo_buffer_USART(void){ //Borra el contenido del buffer
13.  
14.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
15.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
16.    USART_buffer[i]='\0';}
17.    
18. }
19.  
20. int8 respuesta_CMD_SIM900(int8 *buffer[],char *cmd,int8 cmd_len){
21.  
22. // Variable local.
23. short respuesta=0x00;
24.  
25. ptr=strstr(buffer,cmd);              // Busca el comando OK en el buffer.
26.     if(strncmp(ptr,cmd,cmd_len)==0)  // Si lo encuentra..
27.        {respuesta=0x01;}             // respuesta v&#225;lida --> 0x01.    
28.    else{respuesta=0x00;}             // Si no lo encuentra, respuesta err&#243;nea --> 0x00.              
29.  return(respuesta);                  // Retornamos con la respusta al comando.
30.  
31. }
32.  
33. int8 SIM900_ON(void){
34.  
35.   // Variables locales.
36.   int8 checksum[5]="";
37.   int8 resp=0x00;
38.  
39.   // Habilitamos interrupciones.
40.   enable_interrupts(int_RDA);
41.  
42.   POWERKEY_OFF;          // SIM900 -> Apagado.
43.   delay_ms(5);          // Esperamos 5ms.
44.   delay_ms(100);        // Esperamos 100ms.
45.   POWERKEY_ON;           // SIM900 -> Enciende.
46.   delay_ms(1500);       // Esperamos 1,5 seg.
47.   POWERKEY_OFF;          // PRWKEY=0;
48.   delay_ms(40000);      // Esperamos 40 segundos el Call Ready.
49.  
50.   // Inicializamos el buffer de la UART.
51.   inicializo_buffer_USART();
52.  
53.   fprintf(SIM900,"AT\r");                               // CMD: Comando de verificaci&#243;n.
54.   delay_ms(500);                                          // Esperamos 500ms la respuesta del m&#243;dulo.
55.   checksum[0]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
56.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepci&#243;n.  
57.   fprintf(SIM900,"ATE0\r");                             // CMD: Eco OFF.
58.   delay_ms(500);                                          // Esperamos 500ms la respuesta del m&#243;dulo.
59.   checksum[1]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
60.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepci&#243;n.
61.   fprintf(SIM900,"AT+CMGF=1\r");                        // CMD: Configuramos modo texto.
62.   delay_ms(500);                                          // Esperamos 500ms la respuesta del m&#243;dulo.
63.   checksum[2]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
64.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepci&#243;n.
65.   fprintf(SIM900,"AT+CPMS=\"SM\",\"SM\"\r");            // CMD: Selecciono la mememoria SIM para recibir y leer SMS.
66.   delay_ms(500);                                          // Esperamos 500ms la respuesta del m&#243;dulo.
67.   checksum[3]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
68.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepci&#243;n.
69.   fprintf(SIM900,"AT+CNMI=2,2,0,0,0\r");                // CMD: Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
70.   delay_ms(500);        
71.   checksum[4]=respuesta_CMD_SIM900(USART_buffer,"OK",2);  // Si la respuesta es OK, el comando se confirma.
72.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepci&#243;n.
73.  
74.   // Comprobamos si respondi&#243; bien a todos los comandos.
75.   resp=checksum[0]+checksum[1]+checksum[2]+checksum[3]+checksum[4];
76.    if(resp==0x05){LED_ERROR_OFF LED_OK_ON}
77.      else{resp=0x00; LED_ERROR_ON LED_OK_OFF}
78.    
79.    return(resp);
80. }
81.  
82.  
83. void main()
84. {
85. RELAY1_OFF;
86. RELAY2_OFF;
87. LED_OK_OFF;
88. LED_ERROR_OFF;
89. int8 b=0x00;
90.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
91.    setup_wdt(WDT_OFF);
92.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
93.    enable_interrupts(INT_RDA);
94.    enable_interrupts(GLOBAL);
95. if(SIM900_ON()==0x05)
96. {RELAY1_ON;
97. delay_ms(1500);
98. RELAY1_OFF;
99. LED_OK_OFF;
100. }
101.  inicializo_buffer_USART();
102.    
103.    while(TRUE)
104.    {
105.    
106.    if (USART_buffer[1]!=0)  //Si es 0 es que no entro ningun caracter, si es 1 es que entro un mensaje
107.     {LED_OK_ON;
108.     LED_ERROR_ON;
109.     delay_ms(500);
110.     b=respuesta_CMD_SIM900(USART_buffer,"Porton",6);     //Si es correcta la palabra, la funcion entrega un 1
111.     if(b==0x01)
112.       {LED_OK_OFF;
113.       LED_ERROR_OFF;
114.       }
115.      inicializo_buffer_USART();
116.     }
117.      
118.    
119.    
120.    }
121.  
122. }

Código: C

1. #include <18F14K50.h>
2. #device adc=16
3.  
4.  
5. #FUSES NOWDT                
6. #FUSES CPUDIV1                  
7. #FUSES HS                      
8. #FUSES NOPLLEN                  
9. #FUSES NOIESO                  
10. #FUSES PUT                      
11. #FUSES NOBROWNOUT            
12. #FUSES NOLVP                    
13. #FUSES NOXINST                  
14.  
15.  
16. // Declaraci&#243;n para trabajar con punteros a constantes.
17. #device PASS_STRINGS=IN_RAM
18.  
19. #use delay(crystal=12000000,  clock=3000000)
20.  
21. #use FIXED_IO( C_outputs=PIN_C7,PIN_C6,PIN_C4,PIN_C1,PIN_C0 )
22. #define RELAY1   PIN_C0
23. #define RELAY2   PIN_C1
24. #define POWERKEYGSM   PIN_C4
25. #define LED1   PIN_C6
26. #define LED2   PIN_C7
27.  
28. #use rs232(baud=4800,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SIM900,RESTART_WDT)
29.  
30. #define RELAY1_ON            output_high(RELAY1);
31. #define RELAY1_OFF            output_low(RELAY1);
32. #define RELAY2_ON            output_high(RELAY2);
33. #define RELAY2_OFF            output_low(RELAY2);
34. #define POWERKEY_ON          output_high(POWERKEYGSM);
35. #define POWERKEY_OFF         output_low(POWERKEYGSM);
36. #define LED_OK_ON            output_high(LED1);
37. #define LED_OK_OFF           output_low(LED1);
38. #define LED_ERROR_ON         output_high(LED2);
39. #define LED_ERROR_OFF        output_low(LED2);
40.  
41. // Variables utilizadas.
42.  
43. #define bytes_for_USART_buffer 160                  // Tama&#241;o del buffer de la USART [140 bytes].
44. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
45. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
46. int8 i=0x00;                                        // Variable auxiliar.
47. char *ptr;                                          // Puntero auxiliar.
48.  
49.  
50. #use delay(restart_wdt)

Y en el header tuve la colaboracion inestimable de Mglsoft, sino se me iba a seguir reiniciando el watchdog!

Datos a tener en cuenta:
*Siempre si se puede con un cdc o una comunicacion serial, verificar los comandos AT, por ej, AT+IPR?, o AT+CNMI? con eso me aseguro de que el comando esta bien cargado. Ese fue un grave error mio. Como algunos comandos se guardan en la memoria FLASH, (Ver hoja de datos cuales), puedo ver si estan bien cargados, o cargarlos desde la comunicacion CDC, (Dejar programado el modulo).
*Verificar que el watchdog no se reinicie, ver en las librerias como se soluciona, ahi esta el aporte de MGLSoft. Ese fue otro error.
*En caso de tener leds testigo, ir probando paso a paso la comunicacion. Gracias a la rutina de Jonathan, que verifica a traves de la suma de checksum, pude ver si estaba o no bien comunicado con el modulo.
*En caso de usar algun buffer, siempre vaciarlos apenas lo termine de utilizar.
*Caso de usar compilador CCS, verificar version. Para introducir los comandos \n\r, en el caso del SIM900 no hace falta el \n, detecta la instruccion solo con el \r.

De nuevo gracias a la ayuda que tuve. Y espero poder colaborar a quien tenga el mismo problema. Proximamente voy a intentar sumar la lista habilitada (Filtrado de numeros).

[Abner_emanuel]

Un saludo amigos.

Ya tiene un buen tiempo que no se comenta de esta tema, pero espero alguien me responda.

Implementando el módem SIM900 me surge la necesidad de realizar el envío de sms a múltiples destinatarios, es decir, no solo a un numero si no a 10 u mas.

Se que aquí se publico algo referente pero no se en que concluyo en cuanto a lo que llamaron LISTA NEGRA y llevaba la siguiente programación.

#include "GSM_18f14k50_v2.h"
#define PIN_ON  output_high
#define PIN_OFF output_low
#define RELAY1  PIN_C0
#define RELAY2  PIN_C1
#define PULSADOR1  PIN_C2
#define PULSADOR2  PIN_C3
#define PULSADOR3  PIN_B6
#define PWM_LED  PIN_C5
#define LED1  PIN_C6
#define LED2  PIN_C7
#define TEMP PIN_B4
#define POWERKEYGSM  PIN_C4
//#define char lista[177][10]={{'3','8','0','4','4','1','5','6','2','2'}}
const int8 lista[177][10]={{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'},{'x','x','x','x','x','x','x','x','x','x'}};

Alguien me puede comentar al respecto en que quedo?. Por que leyendo os comentarios decían que no sepo dia enviar en este tipo de formato la serie de numeros.

[armandoyamir]

Que tal?

http://www.ebay.com/itm/PIC-SmartPhone-Home-Control-Board-Development-Kit-with-Sim900-GSM-GPRS-RS232-/282219280461?hash=item41b594784d:g:T~gAAOSw8gVX32Ra

Con esto puedo trabajar muy bien SMS GSM

saludos.