Autor Tema: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip  (Leído 15832 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #30 en: 08 de Febrero de 2013, 16:52:02 »
Citar
Tome nota Jonathan de los cambios en la posicion del compilador. Mi compilador CCS es el 4.138. Probe de las 2 formas y no hay caso y ya no se me ocurre con que probar.

Sinceramente a mi tampoco se me ocurre nada....pero si no te enciende ningún led del SIM900...quizás esté quemado el módulo. No lo creo, pero es una posibilidad.
Probá midiendo Vbat, tiene que ser max de 4.1v...el led de NETLIGHT también tendría que encender y empezar a parpadear...si no lo hacen quizás el modulo esté averiado.

PD: me parece que la configuración del header está muy mal hecha.

Intentá con lo siguiente:

Código: C
  1. #include <18F14K50.h>
  2. #device adc=16
  3.  
  4. #FUSES NOWDT                
  5. #FUSES CPUDIV1                  
  6. #FUSES HS                      
  7. #FUSES NOPLLEN                  
  8. #FUSES NOIESO                  
  9. #FUSES PUT                      
  10. #FUSES NOBROWNOUT            
  11. #FUSES NOLVP                    
  12. #FUSES NOXINST                  
  13.  
  14. #use delay(clock=12000000)
  15.  
  16.  
  17. #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SERIAL_SIM900)
  18.  
  19. #define RELAY1          PIN_C0
  20. #define RELAY2          PIN_C1
  21. #define POWERKEYGSM     PIN_C3
  22. #define LED1            PIN_C6
  23. #define LED2            PIN_C7
  24.  

Los pines no veo que los configures como entrada o salida, analizá bien tu código.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #31 en: 08 de Febrero de 2013, 20:09:14 »
Con tu parte de la libreria pasa eso. Con la de Mcelectronics no. Eso es rarisimo. Ahora cambio el header y pruebo. Aun que todavia no funcione, les agradezco a todos el conocimiento y la voluntad de ayudar que tienen.

Desconectado todopic

  • Administrador
  • DsPIC30
  • *******
  • Mensajes: 3492
    • http://www.todopicelectronica.com.ar
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #32 en: 08 de Febrero de 2013, 21:32:10 »
Por lo que estuve leyendo, los ejemplos de MCE, estan hechos para SIM340

Marcos ¡ Son 40 paginas de diferencias!!!!  :mrgreen:, imposible que funcionen...
Firmat - Santa Fe - Argentina

www.TodoPic.net

Solo se tiran piedras, al arbol que tiene frutos...

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #33 en: 09 de Febrero de 2013, 11:55:30 »
Código: [Seleccionar]
Con tu parte de la libreria pasa eso. Con la de Mcelectronics no. Eso es rarisimo. Ahora cambio el header y pruebo. Aun que todavia no funcione, les agradezco a todos el conocimiento y la voluntad de ayudar que tienen.
Que raro sinceramente...yo he probado todo el código que te pasé y funciona de 10 con el SIM900  :lol:


Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #34 en: 10 de Febrero de 2013, 22:46:22 »
Revise el codigo me habia confundido. Ahora si enciende el modulo GSM, pero me da error de checksum. Me habia confundido, la salida que tiene conectada es la C4, y yo habia utilizado C3. Je. Errores. Me tira el destello de ready y me enciende el led de GSM cada tanto. Pero no se si detecta el sms. Cargo el programa modificado.

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

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #35 en: 11 de Febrero de 2013, 22:30:19 »
Se que quizás es frustrante el hecho de que no funcione a la primera, pero hay que realizar algunas pruebas para ver que todo esté OK.

- Ver que lo que llega al puerto del módem es correcto, a mi al principio no me enviaba bien los comandos por problemas con la configuración de la UART.
- No es necesario tener crédito en la tarjeta SIM, pero es buena idea cuando probés el tema de SMS.
- Ver si la respuesta de los comandos llega correctamente y si la interrupción por puerto serie se está produciendo de manera correcta.
- LO PRIMERO QUE TE TIENE QUE FUNCIONAR ES LA INICIALIZACIÓN, SI NO TE INICIA BIEN ALGO ESTÁ FALLANDO Y NUNCA TE VA A RECONOCER LOS MENSAJES ENTRANTES, YO LO HE PROBADO Y ES ASÍ.

Te recomiendo que al ejemplo que te pasé no le modifiques nada, solo la configuración del microcontrolador usado y lo que tenga que ver pura y esclusivamente con el ...pines ..configuración de los mismos, etc. Y veas si el ejemplo es funcional.
Si pretendes que te va a recibir los mensajes a la primera y los va a procesar, te va a dar un gran dolor de cabeza, mejor hacé pasos y configuraciones pequeñas y luego pasas a los comandos más avanzados, para asegurarte que todo funciona OK.

Saludos !

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #36 en: 12 de Febrero de 2013, 12:08:29 »
Gracias jonathan, por ahora cambie el compilador, me fui al CCS 4.108 y vi que tenia muchas mas opciones que el que usaba 4.138 no me daba. Ahora voy a hacer igual que vos y ponerme a leer la hoja de datos del 18F14K50 para ver si tengo algun error en el header y las configuraciones del pic. Porque metiendole un prog de debug, le mando la secuencia AT y me responde lo mas bien, por ende voy a suponer que no recibe la secuencia y empezar a ver el pic y no el modulo como el problema.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #37 en: 12 de Febrero de 2013, 17:10:15 »
Este es el programa que le cargue:

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\n");                               // 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\n");                             // 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\n");                        // 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\n");            // 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\n");                // 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.  
  83.  
  84. void main()
  85. {
  86.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
  87.  
  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.    SIM900_ON();
  92.    while(TRUE)
  93.    {
  94.     if(SIM900_ON()==0x05){    //TODO: User Code
  95.     RELAY1_ON;
  96.     RELAY2_ON;
  97.     delay_ms(2500);
  98.     RELAY1_OFF;
  99.     RELAY2_OFF;
  100.     }
  101.    }
  102.  
  103. }

Y este el header que utilize:

Código: C
  1. #include <18F14K50.h>
  2. #device adc=16
  3.  
  4. #FUSES NOWDT                    //No Watch Dog Timer
  5. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
  6. #FUSES CPUDIV4                  //System Clock by 4
  7. #FUSES USBDIV1                  //USB clock comes directly from the OSC1/OSC
  8. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
  9. #FUSES NOPLLEN                  //HW PLL disabled, PLL enabled in software
  10. #FUSES NOIESO                   //Internal External Switch Over mode disabled
  11. #FUSES NOBROWNOUT               //No brownout reset
  12. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
  13. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
  14. // Declaración para trabajar con punteros a constantes.
  15. #device PASS_STRINGS=IN_RAM
  16.  
  17. #use delay(crystal=12000000,  clock=3000000)
  18.  
  19. #use FIXED_IO( C_outputs=PIN_C7,PIN_C6,PIN_C4,PIN_C1,PIN_C0 )
  20. #define RELAY1   PIN_C0
  21. #define RELAY2   PIN_C1
  22. #define POWERKEYGSM   PIN_C4
  23. #define LED1   PIN_C6
  24. #define LED2   PIN_C7
  25.  
  26. #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SIM900)
  27.  
  28. #define RELAY1_ON            output_high(RELAY1);
  29. #define RELAY1_OFF            output_low(RELAY1);
  30. #define RELAY2_ON            output_high(RELAY2);
  31. #define RELAY2_OFF            output_low(RELAY2);
  32. #define POWERKEY_ON          output_high(POWERKEYGSM);
  33. #define POWERKEY_OFF         output_low(POWERKEYGSM);
  34. #define LED_OK_ON            output_high(LED1);
  35. #define LED_OK_OFF           output_low(LED1);
  36. #define LED_ERROR_ON         output_high(LED2);
  37. #define LED_ERROR_OFF        output_low(LED2);
  38.  
  39. // Variables utilizadas.
  40.  
  41. #define bytes_for_USART_buffer 160                  // Tamaño del buffer de la USART [140 bytes].
  42. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
  43. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
  44. int8 i=0x00;                                        // Variable auxiliar.
  45. char *ptr;  

No cambie nada del programa, y me sigue dando error del checksum. Ya no se que cambiar... Sinceramente me estoy quedando sin ideas....

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7841
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #38 en: 12 de Febrero de 2013, 17:39:51 »
Esto de donde lo sacaste ???

Citar
#use FIXED_IO( C_outputs=PIN_C7,PIN_C6,PIN_C4,PIN_C1,PIN_C0 )

No lo encuentro en la ayuda de CCS ni en ningún lado !!


¡¡¡ Perdón , Mire mal !!!
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #39 en: 12 de Febrero de 2013, 19:24:32 »
Volvi a instalar el CCS 4.138. Ya no se como probar. Probablemente el error este en la rutina de inicializacion. No se me ocurre que cambiar. O si alguien vio en el header algun error o algo que se halla pasado.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #40 en: 16 de Febrero de 2013, 13:01:21 »
Al final encontre el error de Cheksum... Resulta que yo en pruebas habia seteado la velocidad con AT+IPR, y cuando utilizaba el autobauding no funcionaba, lo volvia a setear a 0 y por lo menos el error de checksum se fue. Y con la rutina de Jonathan arranco. Pregunta, es normal que se apague el led net y ready?

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #41 en: 16 de Febrero de 2013, 13:29:30 »
Citar
Al final encontre el error de Cheksum... Resulta que yo en pruebas habia seteado la velocidad con AT+IPR, y cuando utilizaba el autobauding no funcionaba, lo volvia a setear a 0 y por lo menos el error de checksum se fue. Y con la rutina de Jonathan arranco.

Genial, el primer paso está dado  :-/

Citar
Pregunta, es normal que se apague el led net y ready?

Bajo que condiciones ?

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #42 en: 16 de Febrero de 2013, 18:14:43 »
Una vez que configura todo y enciende el LED_OK. Se apagan los 2 y al tiempo como 1 min vuelven a encenderse y a apagarse. O estare inicializando mal el modulo?

Cargo el programa que estoy utilizando actualmente:

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. {
  86.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
  87.  
  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.    while(TRUE)
  98.    {
  99.    
  100.         //TODO: User Code
  101.       delay_ms(5000);
  102.       procesa_sms(USART_buffer,"r1on",4);
  103.    
  104.    
  105.    }
  106.  
  107. }
  108. void procesa_sms(int8 *buffer[],char *cmd,int8 cmd_len)
  109. {
  110. pal=strstr(buffer,cmd);
  111. if (strncmp(ptr,cmd,cmd_len)==0)
  112.          {
  113.          RELAY1_ON;
  114.          delay_ms(2500);
  115.          RELAY1_OFF;
  116.          RELAY2_ON;
  117.          delay_ms(2500);
  118.         RELAY2_OFF;
  119.          }
  120. inicializo_buffer_USART();
  121. }
« Última modificación: 16 de Febrero de 2013, 18:44:24 por luc_eluani88 »

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7841
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #43 en: 16 de Febrero de 2013, 19:29:21 »
Prueba hacer una pausa de 500 mseg y repetirla 10 veces con un lazo for y dentro de la misma poner la instruccion para resetear el watch dog timer. es restart_wdt();
Si bien esta deshabilitado por fuses, a mi me paso en un PIC18 que se reseteaba igual y me volvio loco.
Tambien puedes poner la instruccion en la declaracion del port serie, si miras hay un que permite resetear el watch dog cada vez que se llama.
Solo se declara en use_rs232 y se llama RESTART_WDT.
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #44 en: 16 de Febrero de 2013, 21:11:14 »
Ahi puse lo que me recomendaste, el programa principal quedo asi:

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.  
  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. for(b=0;b<10;b++)
  97.    {
  98.     restart_wdt();
  99.     delay_ms(500);
  100.    }
  101.    
  102.    while(TRUE)
  103.    {
  104.    
  105.     //TODO: User Code
  106.       delay_ms(5000);
  107.       procesa_sms(USART_buffer,"r1on",4);
  108.    
  109.    
  110.    }
  111.  
  112. }
  113. void procesa_sms(int8 *buffer[],char *cmd,int8 cmd_len)
  114. {
  115. pal=strstr(buffer,cmd);
  116. if (strncmp(ptr,cmd,cmd_len)==0)
  117.          {
  118.          RELAY1_ON;
  119.          delay_ms(2500);
  120.          RELAY1_OFF;
  121.          RELAY2_ON;
  122.          delay_ms(2500);
  123.         RELAY2_OFF;
  124.          }
  125. inicializo_buffer_USART();
  126. }

y el header con la modificacion que me recomendaste as:

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=9600,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. char *pal



 

anything