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

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

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #15 en: 29 de Noviembre de 2012, 09:37:25 »
Ahi corregi. esta al inicio cuando defino

Código: C
  1. const int8 lista[177][10]

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #16 en: 17 de Diciembre de 2012, 13:50:33 »
Pregunta, cuando se refieren a fallas, ¿cuales son las que les detectaron?. ¿Tienen solucion? Porque yo compilo y no tengo problemas.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #17 en: 17 de Diciembre de 2012, 15:30:58 »
Estuve revisando las sugerencias, y mi programa quedo asi:

Código: C
  1. #include <v01.h>
  2. #include <string.h>
  3. #define PIN_ON  output_high
  4. #define PIN_OFF output_low
  5. const int8 lista[178][10]={{'3','8','0','4','4','1','5','6','2','2'}};
  6. //Interrupcion puerto serie
  7.  
  8.  
  9.  
  10. void inicializo_buffer(void);      // Borramos el buffer de recepción.
  11. void inicializo_buffer_aux(void);  // Borramos el buffer auxiliar.
  12. void inicializo_buffer_aux2(void); // Borramos el buffer auxiliar 2.
  13. void  leer_sms(void);                         // Leemos un mensaje de texto.
  14. void  borrar_sms(void);                       // Borra un mensaje de texto de la posición 1.
  15. void  borrar_todos_sms(void);                 // Borro todos los mensajes.
  16. // Variables interrupciones.
  17.  
  18. #define bytes_for_USART_buffer 75                   // Tamaño del buffer de la USART.
  19. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
  20. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
  21. // Punteros.
  22. char *ptr;
  23. // Variables auxiliares.
  24. int8 i=0;
  25. int8 x=0;
  26. int8 j=0;
  27. char a='\0';
  28. int32 ph_max=0;
  29. int32 ph_min=0;
  30. int8 numok=0;
  31. // Buffer auxiliar.
  32. #define bytes_for_AUX_buffer   75                   // Tamaño del buffer auxliar.
  33. int8 AUX_buffer[bytes_for_AUX_buffer ];             // Buffer auxiliar de 75 bytes.
  34. int8 SMS_Buffer[15];                                // Buffer auxiliar 2
  35. void comparacion_numero ();
  36. void compara_palabra();
  37. void apertura_porton();
  38. #int_RDA //rutina de captura de puerto serie
  39. void  RDA_isr(void)
  40. {
  41. USART_buffer[USART_nextRec]=fgetc(SERIAL_SIM900);
  42. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
  43. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
  44. }
  45.  
  46. #int_RAB // En caso de interrupcion por infrarrojo
  47. void  RAB_isr(void)
  48. {
  49. if (IR==1)
  50. apertura_porton();
  51. }
  52. //Rutina Inicializacion SIM900
  53. void inicializacion_SIM900(){
  54.  
  55.  
  56.   PIN_OFF (POWERKEYGSM);      // PWRKEY=0;
  57.   delay_ms(1500);       // Esperamos 1-1/2 seg.
  58.   PIN_ON(POWERKEYGSM);     // PRWKEY=1;
  59.   delay_ms(40000);      // Esperamos 40 segundos el Call Ready.
  60.   fputs("AT",SERIAL_SIM900);
  61.   delay_ms(10000);    
  62.   fprintf(SERIAL_SIM900,"AT\n\r");                    // Comando de verificación.
  63.   delay_ms(500);                               // Esperamos 500ms.
  64.   fprintf(SERIAL_SIM900,"ATE0\n\r");                  // Eco OFF.
  65.   delay_ms(500);                               // Esperamos 500ms.
  66.   fprintf(SERIAL_SIM900,"AT+CMGF=1\n\r");             // Configuramos modo texto.
  67.   delay_ms(500);                               // Esperamos 500ms.
  68.   fprintf(SERIAL_SIM900,"ATS0=1\r");
  69.   delay_ms(500);
  70.   fprintf(SERIAL_SIM900,"AT+CPMS=\"SM\",\"SM\"\n\r"); // Selecciono la mememoria SIM para recibir y leer SMS.
  71.   delay_ms(500);                               // Esperamos 500ms.
  72.   fprintf(SERIAL_SIM900,"AT+CNMI=2,2,0,0,0\n\r");     // Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
  73.   delay_ms(500);                               // Esperamos 500ms.
  74.   inicializo_buffer();                         // Limpiamos el buffer de recepción.
  75.  
  76. }
  77. void borrar_sms(void){
  78.  
  79.  fprintf(SERIAL_SIM900,"AT+CMGD=1\n\r",);   // Enviamos comando: "AT+CMGD=1 para borrar un mensaje de la posición 1 de memoria de la SIM.
  80.  delay_ms(1000);                     // Esperamos 1 segundo.
  81.  inicializo_buffer();                // Limpiamos el buffer de recepción.
  82.  inicializo_buffer_aux();            // Borramos el buffer auxiliar.
  83.  inicializo_buffer_aux2();           // Borramo el buffer de mensajes.
  84.  ptr=&a;                             // Inicializamos el puntero.
  85.  
  86. }
  87. void main()
  88. {
  89.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
  90.  
  91.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
  92.    enable_interrupts(INT_RDA);
  93.    enable_interrupts(INT_RAB);
  94.    enable_interrupts(GLOBAL);
  95.  
  96.    while(TRUE)
  97.    {
  98.       //TODO: User Code
  99.    }
  100.  
  101. }
  102.  
  103. void inicializo_buffer(void)
  104. {
  105.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
  106.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
  107.    USART_buffer[i]='\0';}
  108. }
  109.  
  110. void inicializo_buffer_aux(void)
  111. {
  112.   for(x=0; x<=bytes_for_AUX_buffer ; x++){ // Borro el contenido del buffer auxiliar.
  113.    AUX_buffer[x]='\0';}
  114. }
  115.  
  116. void inicializo_buffer_aux2(void)
  117. {
  118.   for(j=0; j<=15 ; j++){ // Borro el contenido del buffer auxiliar 2.
  119.    SMS_Buffer[j]='\0';}
  120. }
  121.  
  122. void borrar_todos_sms(void)
  123. {
  124.  
  125.    disable_interrupts(int_rda);
  126.    for(i=1;i<=10;i++)                      // Bucle para borrar los 10 mensajes.
  127.    {
  128.    fprintf(SERIAL_SIM900,"AT+CMGD=%d\n\r\0",i);   // Borro los 10 primeros sms.
  129.    delay_ms(500);                          // Esperamos 500ms.
  130.    }
  131.    enable_interrupts(int_rda);             // Habilitamos nuevamente las interrupciones por el puerto serie.
  132.    inicializo_buffer();          // Limpiamos el buffer de recepción.
  133.    inicializo_buffer_aux();      // Borramos el buffer auxiliar.
  134.    inicializo_buffer_aux2();     // Borramo el buffer de mensajes.
  135.    
  136. }
  137.  
  138. void procesa_sms(void)
  139. {
  140. char  delimitante2[] = "\r\n"; // Delimitante (para el mensaje principal).
  141. char  delimitante1[] = '"';    // Delimitante (para el numero).
  142. // Constantes de parámentros.
  143.  // 1° - Copiamos el buffer de la usart en el buffer auxiliar.
  144.  strcpy(AUX_buffer, USART_buffer);
  145.  // 2° - Tomamos del buffer auxiliar el numero.
  146.  ptr = strtok(AUX_buffer, delimitante1);                              
  147.  ptr = strtok(NULL, delimitante1);
  148.  // 3° Copiamos en un buffer auxiliar el numero.
  149.  strcpy(SMS_Buffer, ptr);
  150.   // 4° llamo a la rutina de comparacion de numeros.
  151. comparacion_numero();
  152. ptr=strtok(AUX_buffer,delimitante2);
  153. ptr=strtok(NULL,delimitante2);
  154. if (numok==1)
  155.    {compara_palabra();
  156.    }
  157.  borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  158.  delay_ms(1000); // Esperamos 1 segundo.
  159. }
  160.  
  161. void comparacion_numero()
  162. {int c=0;
  163. for(c=0;c<178;c++)
  164.    {if (stricmp(lista[c][],SMS_buffer)==0x00)
  165.    numok=1;
  166.    }
  167. }
  168. void compara_palabra()
  169. {char palabra[6]={'p','o','r','t','o','n'};
  170. if (stricmp(palabra,SMS_buffer)==0x00)
  171.    apertura_porton();
  172. }
  173. void apertura_porton()
  174. {PIN_ON (PORTAPMAE);
  175. delay_ms (5000);
  176. PIN_ON (PORTAPESC);
  177. delay_ms(25000);
  178. PIN_OFF (PORTAPMAE);
  179. PIN_OFF (PORTAPESC);
  180. delay_ms (40000);
  181. PIN_ON (PORTCIMAE);
  182. delay_ms (5000);
  183. PIN_ON (PORTCIESC);
  184. delay_ms(40000);
  185. PIN_OFF (PORTCIMAE);
  186. PIN_OFF (PORTCIESC);
  187.  
  188. }

Cuando hago el stringcmp no puedo xq como defini la lista como

Código: C
  1. const int8 lista[][]
no se como cargar la lista de otra forma. Agradezco su ayuda. Saludos.

Desconectado fighter

  • PIC10
  • *
  • Mensajes: 14
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #18 en: 04 de Febrero de 2013, 09:04:04 »
buenas Foro


Tengo una placa de MCE trae un sim 908. Estoy teniendo problemas para ver lo q envia el pic y recibe el pic. me estoy conectando al bus atraves de un conversor usb - serie PL-2303HX. el micro envia los comandos hacia el modem( llamada de voz) para no si estoy recibiendo las respuesta. El pic es 18F26j50. Estoy usando ccs


Interrupciones serie

Cuando se envia un dato por la uart, se activa la interrupcion serie??


Port USB


De los ejemplos q traer el kit de MCE no funciona ninguno. El problema creo q es la velocidad del clock. Tienen alguna configuracion del port usb q me sirva de ejemplo.


gracias





Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #19 en: 04 de Febrero de 2013, 09:24:40 »
Si pusieras en algun lado los ejemplos podriamos opinar.
Las interrupciones de la UART pueden ser por tx y rx o ambas a la vez, pero hay que ver el codigo... :?
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #20 en: 04 de Febrero de 2013, 17:34:52 »
Citar
Cuando se envia un dato por la uart, se activa la interrupcion serie??

Siempre y cuando las hayas activado primero, en la ayuda de CCS aparece como se utiliza la interrupción por recepción del puerto serie.

Citar
De los ejemplos q traer el kit de MCE no funciona ninguno. El problema creo q es la velocidad del clock. Tienen alguna configuracion del port usb q me sirva de ejemplo.

Fijate con los ejemplos que trae de fábrica el CCS y hacé las modificaciones para que funcione con el 18F26J50.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #21 en: 06 de Febrero de 2013, 20:41:22 »
Buenas. Traigo el nuevo codigo que implemente. Modifique y temporalmente deshabilite la lista de llamadas.

Código: C
  1. #include <progv03.h>
  2. #include <string.h>
  3. #define PIN_ON  output_high
  4. #define PIN_OFF output_low
  5. //const int8 lista[179][10]={{'x','x','x','x','x','x','x','x','x','x'}};
  6. const int8 palabra[6]={'p','o','r','t','o','n'};
  7.  
  8.  
  9.  
  10.  
  11. void inicializo_buffer(void);      // Borramos el buffer de recepción.
  12. void inicializo_buffer_aux(void);  // Borramos el buffer auxiliar.
  13. void  leer_sms(void);                         // Leemos un mensaje de texto.
  14. void  borrar_sms(void);                       // Borra un mensaje de texto de la posición 1.
  15. void  borrar_todos_sms(void);                 // Borro todos los mensajes.
  16. // Variables interrupciones.
  17.  
  18. #define bytes_for_USART_buffer 75                   // Tamaño del buffer de la USART.
  19. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
  20. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
  21. // Punteros.
  22. char *ptr;
  23. // Variables auxiliares.
  24. int8 i=0;
  25. int8 x=0;
  26. char a='\0';
  27. // Buffer auxiliar.
  28. #define bytes_for_AUX_buffer   75                   // Tamaño del buffer auxliar.
  29. int8 AUX_buffer[bytes_for_AUX_buffer ];             // Buffer auxiliar de 75 bytes.
  30.                        
  31. void apertura_porton();
  32. #int_RDA //rutina de captura de puerto serie
  33. void  RDA_isr(void)
  34. {
  35. USART_buffer[USART_nextRec]=fgetc(SERIAL_SIM900);
  36. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
  37. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
  38. }
  39.  
  40. #int_RAB // En caso de interrupcion por infrarrojo
  41. void  RAB_isr(void)
  42. {
  43. if (IR==1)
  44. apertura_porton();
  45. }
  46. //Rutina Inicializacion SIM900
  47. void inicializacion_SIM900(){
  48.  
  49.  
  50.   PIN_OFF (POWERKEYGSM);      // PWRKEY=0;
  51.   delay_ms(1500);       // Esperamos 1-1/2 seg.
  52.   PIN_ON(POWERKEYGSM);     // PRWKEY=1;
  53.  
  54.   fputs("AT",SERIAL_SIM900);
  55.   delay_ms(10000);    
  56.   fprintf(SERIAL_SIM900,"AT\n\r");                    // Comando de verificación.
  57.   delay_ms(500);                               // Esperamos 500ms.
  58.   fprintf(SERIAL_SIM900,"ATE0\n\r");                  // Eco OFF.
  59.   delay_ms(500);                               // Esperamos 500ms.
  60.   fprintf(SERIAL_SIM900,"AT+CMGF=1\n\r");             // Configuramos modo texto.
  61.   delay_ms(500);                               // Esperamos 500ms.
  62.   fprintf(SERIAL_SIM900,"ATS0=0\r");           // No acepta llamada
  63.   delay_ms(500);                               //Espero 500ms
  64.   fprintf(SERIAL_SIM900,"AT+CPMS=\"SM\",\"SM\"\n\r"); // Selecciono la mememoria SIM para recibir y leer SMS.
  65.   delay_ms(500);                               // Esperamos 500ms.
  66.   fprintf(SERIAL_SIM900,"AT+CNMI=2,2,0,0,0\n\r");     // Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
  67.   delay_ms(500);                               // Esperamos 500ms.
  68.   inicializo_buffer();                         // Limpiamos el buffer de recepción.
  69.  
  70. }
  71. void borrar_sms(void){
  72.  
  73.  fprintf(SERIAL_SIM900,"AT+CMGD=1\n\r",);   // Enviamos comando: "AT+CMGD=1 para borrar un mensaje de la posición 1 de memoria de la SIM.
  74.  delay_ms(1000);                     // Esperamos 1 segundo.
  75.  inicializo_buffer();                // Limpiamos el buffer de recepción.
  76.  inicializo_buffer_aux();            // Borramos el buffer auxiliar.
  77.  ptr=&a;                             // Inicializamos el puntero.
  78.  
  79. }
  80.  
  81. void main()
  82. {
  83.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
  84.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
  85.    enable_interrupts(INT_RDA);
  86.    enable_interrupts(INT_RAB);
  87.    enable_interrupts(GLOBAL);
  88.    inicializacion_SIM900();
  89.    while(TRUE)
  90.    {
  91.      leer_sms();
  92.    }
  93.  
  94. }
  95. void inicializo_buffer(void)
  96. {
  97.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
  98.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
  99.    USART_buffer[i]='\0';}
  100. }
  101.  
  102. void inicializo_buffer_aux(void)
  103. {
  104.   for(x=0; x<=bytes_for_AUX_buffer ; x++){ // Borro el contenido del buffer auxiliar.
  105.    AUX_buffer[x]='\0';}
  106. }
  107.  
  108. void borrar_todos_sms(void)
  109. {
  110.  
  111.    disable_interrupts(int_rda);
  112.    for(i=1;i<=10;i++)                      // Bucle para borrar los 10 mensajes.
  113.    {
  114.    fprintf(SERIAL_SIM900,"AT+CMGD=%d\n\r\0",i);   // Borro los 10 primeros sms.
  115.    delay_ms(500);                          // Esperamos 500ms.
  116.    }
  117.    enable_interrupts(int_rda);             // Habilitamos nuevamente las interrupciones por el puerto serie.
  118.    inicializo_buffer();          // Limpiamos el buffer de recepción.
  119.    inicializo_buffer_aux();      // Borramos el buffer auxiliar.
  120. }
  121.  
  122. void leer_sms(void)
  123. {int8 pal[7];
  124. char list[10];
  125. pal=palabra;
  126.    strcpy(AUX_buffer, USART_buffer);
  127.          if (strncmp(AUX_buffer,pal,6)==0)
  128.             {
  129.              apertura_porton();
  130.              }
  131.            
  132.          
  133.  borrar_todos_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  134. }
  135.  
  136.  
  137. void apertura_porton()
  138. {PIN_ON (APAGSIST);
  139. PIN_ON (MOTAPMAE);
  140. delay_ms (5000);
  141. PIN_ON (MOTAPESC);
  142. delay_ms(25000);
  143. PIN_OFF (MOTAPMAE);
  144. PIN_OFF (MOTAPESC);
  145. delay_ms (40000);
  146. PIN_ON (MOTCIEMAE);
  147. delay_ms (5000);
  148. PIN_ON (MOTCIESC);
  149. delay_ms(40000);
  150. PIN_OFF (MOTCIEMAE);
  151. PIN_OFF (MOTCIESC);
  152. PIN_OFF(APAGSIST);
  153. borrar_todos_sms();
  154. }

Cuando envio el sms con la palabra habilitada no pasa nada. Saco el chip GSM y lo ubico en un celular y recibe los sms. Por ende supongo el modulo no los esta recibiendo. Les pido me digan si ubican mi error en la rutina de inicializacion del modulo. Saludos.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #22 en: 07 de Febrero de 2013, 00:20:45 »
Cargue el programa original de MCElectronics y recibe cada tanto un sms. Evidentemente tengo un error de código. Agradecería la ayuda que me puedan dar. Igual voy a seguir buscando la alternativa.

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #23 en: 07 de Febrero de 2013, 11:34:48 »
A mi el programa original de MCelectronics me dió muchisimos fallos...casi nunca me agarraba un SMS. Les dejo una de las prácticas del SIM900, que he realizado con un microcontrolador PIC18F4520 y CCS.
Mi idea es desarrollar una librería que incluya SMS, VOZ Y GPRS...también GPS, en caso de trabajar con el SIM908. Por ahora mis pasos han sido mínimos, pero voy avanzando....he realizado más prácticas, incluyendo la recepción de mensajes de texto y envío de datos por GPRS a un servidor..pero todavía no están lo suficientemente pulidas.




Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #24 en: 07 de Febrero de 2013, 16:02:44 »
Gracias Jonathan. Estoy jugando con tu libreria. Por lo menos ahora me inicializa bien. No tengo herramientas para hacer un debug, asi que estoy a la antigua, mandando sms, esperando que encienda el bendito led.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #25 en: 07 de Febrero de 2013, 17:13:52 »
Corrijo, me entrega error de Checksum. El led de error queda funcionando.

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #26 en: 07 de Febrero de 2013, 21:39:27 »
Mirá yo usé el kit de entrenamiento de MCelectronics muy poco, por que se me quemó a las 2 semanas de usarlo...su diseño pésimo de la fuente no me permitió usarlo durante mucho tiempo.
Personalmente uso un kit original de SIMCOM, con el cuál he realizado todas las prácticas. Tips no tengo ninguno, más que decirte que compres un kit de desarrollo original en CIKA (Buenos Aires). Yo tengo uno y lo único que tuve que hacer es poner el control de alimentación con un regulador MIC29302...usar TX/RX del puerto RS232, usar el Pin PowerKey y listo.

Para mi se tenés error de checksum, puede ser por 3 cosas:

1) - IMPROBABLE: FALLA EN LA CONEXIÓN TX/RX del PIC CON EL MÓDULO....PUEDE PASAR QUE TENGAS LA PLACA AVERIADA...

2) - PROBABLE: MAL CONFIGURADO EL MICROCONTROLADOR...FUSES...Y FRECUENCIA DE TRABAJO..A MI ME PASO QUE TUVE QUE LEER LA HOJA DE DATOS MUY DETALLADAMENTE PARA CONFIGURARLO..PERO EN UN FORMATEO PERDÍ LAS PRÁCTICAS QUE REALIZÉ CON EL PIC18F14K50.

3) - PROBABLE Y ADEMÁS EXTRAÑO: FALLA DEL COMPILADOR CCS. DEPENDIENDO DE LA VERSIÓN HAY UNA MODIFICACIÓN QUE HAN REALIZADO...UNA CORRECIÓN....Y ES EL ORDEN EN EL QUE ENVÍAS LOS BYTES DE CAMBIO DE LÍNEA Y RETORNO DE CARRO. POR EJEMPLO:

V4.104 y anteriores:

fprintf(SERIAL_SIM900,"AT\n\r");

V4.134 y posteriores:

fprintf(SERIAL_SIM900,"AT\r\n");

Analizá lo que te expuse y hacé las pruebas...yo personalmente me decanto por esto último.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #27 en: 08 de Febrero de 2013, 12:06:47 »
Adjunto el codigo que tome de Jonathan y las modificaciones que les hice. Adjunto el header
Código: C
  1. #include <prueba001.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.  
  15. // Variables utilizadas.
  16. int d;
  17. int const lenbuff=4;  // Tamaño del buffer de recepción
  18. int8 cbuff[lenbuff];   // Buffer de recepcion de datos serie
  19. #define bytes_for_USART_buffer 140                  // Tamaño del buffer de la USART [140 bytes].
  20. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
  21. #define bytes_for_USART_AUX 20                      // Tamaño del buffer auxiliar [30 bytes].
  22. volatile int8 USART_AUX[bytes_for_USART_AUX];       // Buffer auxiliar.
  23. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
  24. int8 i=0x00;                                        // Variable auxiliar.
  25. char *ptr;                                          // Puntero auxiliar.
  26. char ok[2]={'O','K'},pal[4]={'r','1','o','n'};
  27. // Declaro funciones utilizadas.
  28.  
  29. void configurar_parametros(void);    // Configuramos parámetros principales.
  30. void inicializo_buffer_USART(void); // Borramos el buffer de recepción.
  31. void leer_sms(void);
  32. void borrar_todos_sms();
  33.  
  34. // Desarrollo de funciones de usuario.
  35. void  RDA_isr(void)
  36. {
  37. USART_buffer[USART_nextRec]=fgetc(SERIAL_SIM900);
  38. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
  39. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
  40. d=0;                      
  41.       d=getchar(SERIAL_SIM900);
  42.       cbuff[0]=cbuff[1];
  43.       cbuff[1]=cbuff[2];
  44.       cbuff[2]=cbuff[3];
  45.       cbuff[3]=d;
  46. }
  47.  
  48.  
  49. int8 respuesta_CMD_SIM900(int8 *buffer[],char *cmd,int8 cmd_len){
  50.  
  51. // Variable local.
  52. short respuesta=0x00;
  53.  
  54. ptr=strstr(buffer,cmd);              // Busca el comando OK en el buffer.
  55.     if(strncmp(ptr,cmd,cmd_len)==0)  // Si lo encuentra..
  56.        {respuesta=0x01;}             // respuesta válida --> 0x01.    
  57.    else{respuesta=0x00;}             // Si no lo encuentra, respuesta errónea --> 0x00.              
  58.  return(respuesta);                  // Retornamos con la respusta al comando.
  59.  
  60. }
  61. int8 SIM900_ON(void){
  62.  
  63.   // Variables locales.
  64.   int8 checksum[6]="";
  65.   int8 resp=0x00;
  66.  
  67.   // Habilitamos interrupciones.
  68.   enable_interrupts(int_RDA);
  69.  
  70.  
  71.   POWERKEY_ON;           // SIM900 -> Enciende.
  72.   delay_ms(1500);       // Esperamos 1,5 seg.
  73.   POWERKEY_OFF;          // PRWKEY=0;
  74.   delay_ms(40000);      // Esperamos 40 segundos el Call Ready.
  75.  
  76.   // Inicializamos el buffer de la UART.
  77.   inicializo_buffer_USART();
  78.  
  79.   fprintf(SERIAL_SIM900,"AT+IPR=9600\r");                                        // Esperamos 500ms la respuesta del módulo.                                    
  80.   checksum[0]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  81.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.  
  82.   fprintf(SERIAL_SIM900,"AT\n\r");                               // CMD: Comando de verificación.
  83.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
  84.   checksum[1]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  85.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.  
  86.   fprintf(SERIAL_SIM900,"ATE0\n\r");                             // CMD: Eco OFF.
  87.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
  88.   checksum[2]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  89.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
  90.   fprintf(SERIAL_SIM900,"AT+CMGF=1\n\r");                        // CMD: Configuramos modo texto.
  91.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
  92.   checksum[3]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  93.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
  94.   fprintf(SERIAL_SIM900,"AT+CPMS=\"SM\",\"SM\"\n\r");            // CMD: Selecciono la mememoria SIM para recibir y leer SMS.
  95.   delay_ms(500);                                          // Esperamos 500ms la respuesta del módulo.
  96.   checksum[4]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  97.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
  98.   fprintf(SERIAL_SIM900,"AT+CNMI=2,2,0,0,0\n\r");                // CMD: Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
  99.   delay_ms(500);        
  100.   checksum[5]=respuesta_CMD_SIM900(USART_buffer,ok,2);  // Si la respuesta es OK, el comando se confirma.
  101.   inicializo_buffer_USART();                              // Limpiamos el buffer de recepción.
  102.  
  103.   // Comprobamos si respondió bien a todos los comandos.
  104.   resp=checksum[0]+checksum[1]+checksum[2]+checksum[3]+checksum[4]+checksum[5];
  105.    if(resp==6){LED_ERROR_OFF LED_OK_ON}
  106.      else{resp=0; LED_ERROR_ON LED_OK_OFF}
  107.    
  108.    return(resp);
  109. }
  110.  
  111. void inicializo_buffer_USART(void){
  112.  
  113.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
  114.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
  115.    USART_buffer[i]='\0';}
  116.    
  117. }
  118. void main()
  119. {int8 pal[4]={'r','1','o','n'};
  120.    setup_timer_3(T3_DISABLED | T3_DIV_BY_1);
  121.    SIM900_ON();
  122.    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
  123.    enable_interrupts(INT_RDA);
  124.    enable_interrupts(GLOBAL);
  125.    inicializo_buffer_USART();
  126.    borrar_todos_sms();
  127.    while(TRUE)
  128.    {if(strncmp(pal,cbuff,4)==0)
  129.       {
  130.       cbuff[0]=0;
  131.       LED_OK_ON;  
  132.       RELAY1_ON;
  133.       delay_ms(2000);
  134.       LED_OK_OFF;
  135.       RELAY1_OFF;
  136.       }
  137.  
  138.  
  139. }
  140. void leer_sms()
  141. {
  142. for (i=0;i<5;i++)
  143.    fprintf(SERIAL_SIM900,"AT+CMGR=%d\n",i);                             // CMD: Eco OFF.
  144.    delay_ms(500);
  145.    if (USART_buffer[0]!=0x00)
  146.       {if(strncmp(USART_buffer,pal,4)==0)
  147.          {LED_OK_OFF;
  148.          LED_ERROR_OFF;
  149.          }
  150.       }
  151.    
  152. }
  153. void borrar_todos_sms(void)
  154. {
  155.  
  156.    disable_interrupts(int_rda);
  157.    for(i=0;i<=5;i++)                      // Bucle para borrar los 10 mensajes.
  158.    {
  159.    fprintf(SERIAL_SIM900,"AT+CMGD=%d\n\r\0",i);   // Borro los 10 primeros sms.
  160.    delay_ms(500);                          // Esperamos 500ms.
  161.    }
  162.    enable_interrupts(int_rda);             // Habilitamos nuevamente las interrupciones por el puerto serie.
  163.    inicializo_buffer_USART();          // Limpiamos el buffer de recepción.
  164. }

Este es el Header que utilizo.
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 LP                       //Low power osc < 200 khz
  8. #FUSES NOBROWNOUT               //No brownout reset
  9. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
  10. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
  11.  
  12. #use delay(crystal=12000000,  clock=3000000)
  13.  
  14. #use FIXED_IO( C_outputs=PIN_C7,PIN_C6,PIN_C3,PIN_C1,PIN_C0 )
  15. #define RELAY1  PIN_C0
  16. #define RELAY2  PIN_C1
  17. #define POWERKEYGSM     PIN_C3
  18. #define LED1    PIN_C6
  19. #define LED2    PIN_C7
  20.  
  21. #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SERIAL_SIM900)

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.

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 #28 en: 08 de Febrero de 2013, 15:12:13 »
Sigo de cerca sus comentarios.... hace un par de años que tengo guardada la placa con el SIM900D y el micro 18F14K50, pero recién ahora me estoy pasando al "C"... así que ... solo mirando  :mrgreen:
Firmat - Santa Fe - Argentina

www.TodoPic.net

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

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #29 en: 08 de Febrero de 2013, 15:34:34 »
Lucas y los demas:
Lean este documento, que muestra las diferencias entre los comandos AT entre SIM3xx y SIM900.

http://wm.sim.com/upfile/2010712134316.pdf

Por lo que estuve leyendo, los ejemplos de MCE, estan hechos para SIM340, y seguramente por aqui anda el problema, asumieron que son iguales, pero no... :mrgreen:
« Última modificación: 08 de Febrero de 2013, 15:37:20 por MGLSOFT »
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.


 

anything