TODOPIC

FORO TÉCNICO => Telefonía, GPS y Microcontroladores => Mensaje iniciado por: luc_eluani88 en 06 de Noviembre de 2012, 21:14:36

Título: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 06 de Noviembre de 2012, 21:14:36
Hola. Tengo un proyecto, estoy intentando utilizar la placa MCE GSM KIT con SIM900D y el pic 18F14K50 incorportado, para una aplicacion de manejo de salidas y lista negra.
Tome el programa de ejemplo que entrega Mcelectronics y lo estoy intentando modificar para lograr mi cometido. Tengo una consulta y solicito su ayuda, como necesito lista negra no se si puedo usar el comando AT+CNMI=2,2,0,0,0, no se si se envía también el numero de telefono que lo envía, y como recibo caracteres char y la secuencia si no utilizo esta opcion es cuando recibo tomar los valores de numero, y despues en otro vector la palabra clave para activar una salida. La comparacion la haria letra por letra, a la palabra, pero al valor numérico haría un vector y compararia con el valor entero, jugando con operaciondes de registro, desplazando y sumando. Si alguien tiene una mejor idea, acepto. Gracias

Código: C
  1. /*
  2. Version 2
  3. Ejemplo para la placa GSM
  4. Fecha:15/11/2011
  5. Compilador a utilizar: CCS 4.104
  6. Al presionar el pulsador1 enciende el led RC6
  7. Al presionar el pulsador2  se envia un SMS al telefono asignado
  8. Al enviar el comando r1on se enciende el relay y el led por 2 segundos
  9. ATENSION: No olvidar que el led NEt debe tener un destello de 64ms on y 3000ms off
  10. Detalle de estado del led de NET
  11.  OFF  Módulo Apagado.
  12.  64ms on/ 800ms no encuentra la red.
  13.  64ms on/3000ms red encontrada.
  14.  64ms on/300ms GPRS comunicación
  15.  Autor: Ing. Fernando R. Tagliaferri
  16.  MCELECTRONICS
  17. */
  18.  
  19. #include "GSM_18f14k50_v2.h"
  20. #define PIN_ON  output_high
  21. #define PIN_OFF output_low
  22. #define RELAY1  PIN_C0
  23. #define RELAY2  PIN_C1
  24. #define PULSADOR1  PIN_C2
  25. #define PULSADOR2  PIN_C3
  26. #define PULSADOR3  PIN_B6
  27. #define PWM_LED  PIN_C5
  28. #define LED1  PIN_C6
  29. #define LED2  PIN_C7
  30. #define TEMP PIN_B4
  31. #define POWERKEYGSM  PIN_C4
  32. #define N1=415622
  33. #define N2=537407
  34.  
  35. //*************************************************************************************************************************************
  36. //--------------------------------------variables globales
  37. //*************************************************************************************************************************************
  38. int d,n=0;
  39. int const lenbuff=6;  // Tamaño del buffer de recepción
  40. int8 cbuff[lenbuff];   // Buffer de recepcion de datos serie
  41. //*************************************************************************************************************************************
  42. //--------------------------------------Interrupcion serie
  43. //*************************************************************************************************************************************
  44. #int_RDA //En esta interrupcion es cuando cargo el valor que obtengo del puerto y lo guardo en un vector char.
  45. void  RDA_isr(void)
  46. {
  47.      d=0;                      
  48.       d=getchar(SERIAL_SIM900);
  49.       cbuff[0]=cbuff[1];
  50.       cbuff[1]=cbuff[2];
  51.       cbuff[2]=cbuff[3];
  52.       cbuff[3]=cbuff[4];
  53.       cbuff[4]=cbuff[5];
  54.       cbuff[5]=d;
  55. }
  56. //*************************************************************************************************************************************
  57. //--------------------------------------Funciones
  58. //*************************************************************************************************************************************
  59.  
  60. void inicializacionSIM900(void)
  61. {
  62.    int cont;
  63.    delay_ms(1000);
  64.    puts("A",SERIAL_SIM900); //para sincronizar el baudrate del SIM 900
  65.    delay_ms(300);
  66.    putchar(0x0d,SERIAL_SIM900);
  67.    delay_ms(1000);
  68.    for(cont=0;cont<5;cont++)              // mando varios AT para el autobauding
  69.          {
  70.          puts("AT",SERIAL_SIM900);
  71.          delay_ms(200);
  72.          putchar(0x0d,SERIAL_SIM900);
  73.          delay_ms(200);
  74.          PIN_ON(LED1);
  75.          delay_ms(200);
  76.          PIN_OFF(LED1);
  77.          }
  78. //-----------------------------------seteos de configuracion del SIM900------------------------        
  79.    puts("AT+CMGF=1\r",SERIAL_SIM900);                  // configuro para que trabaje en modo texto y no PDU
  80.    delay_ms(200);
  81.    putchar(0x0d,SERIAL_SIM900);
  82.    delay_ms(200);
  83.    puts("AT+CNMI=2,2,0,0,0\r",SERIAL_SIM900);                  // configuro para que en cuanto llegue un mensaje lo envie el modulo gsm por el puerto serie
  84.    delay_ms(200);
  85.    putchar(0x0d,SERIAL_SIM900);
  86.    delay_ms(200);
  87.   // puts("ATS0=1\r",SERIAL_SIM900);                  // configuro para que atienda en el segundo llamado
  88.   // delay_ms(200);
  89.   // putchar(0x0d,SERIAL_SIM900);
  90.   //delay_ms(200);
  91.    return;
  92. }  
  93. //*************************************************************************************************************************************
  94. //*************************************************************************************************************************************
  95. //------------------------------------Programa Principal
  96. //*************************************************************************************************************************************
  97. void main()
  98. {
  99.    setup_adc_ports(sAN10|VSS_VDD);  
  100.    setup_adc(ADC_CLOCK_DIV_2|ADC_TAD_MUL_0);
  101.    setup_spi(SPI_SS_DISABLED);
  102.    setup_wdt(WDT_OFF);
  103.    setup_timer_0(RTCC_INTERNAL);
  104.    setup_timer_1(T1_DISABLED);
  105.    setup_timer_2(T2_DISABLED,0,1);
  106.    enable_interrupts(INT_RDA);
  107.    enable_interrupts(GLOBAL);
  108. //------------------------------------------------MI PROGRAMA!!-------------------------------------------------------------------
  109.    set_tris_b(0b00001100);    
  110.    set_tris_c(0b01110000);  
  111.    PIN_OFF(RELAY1);
  112.    PIN_OFF(RELAY2);
  113.    PIN_OFF(LED1);
  114.    PIN_OFF(LED2);
  115.    
  116.    PIN_OFF(POWERKEYGSM);    //Enciendo modulo GSM
  117.    delay_ms(1200);
  118.    PIN_ON(POWERKEYGSM);
  119.    
  120.    
  121.    inicializacionSIM900();  //Inicializo el SIM900
  122.  
  123.   while (true)               // bucle infinito
  124.    {
  125.  
  126.      if(input(PULSADOR1)==0)      
  127.          {
  128.            PIN_ON(LED1);
  129.            while(input(PULSADOR1)==0);
  130.            PIN_OFF(LED1);
  131.          }
  132.     /n if(input(PULSADOR2)==0)                                  // Si presiono el boton manda un SMS indicando que se preciono el boton
  133.          {  
  134. //         fprintf(SERIAL_SIM900,"AT+CMGS=\"15xxxxxxxxxxx\"\r"); // aca poner el numero de celular que recibe el SMS
  135.   //       delay_ms(300);
  136.     //     puts("Mensaje Mcelectronics",SERIAL_SIM900);
  137.       //   delay_ms(300);
  138.         // fprintf(SERIAL_SIM900,"%c",0x1a);
  139.         // PIN_ON(LED2);
  140.         // while(input(PULSADOR2)==0);
  141.         // PIN_OFF(LED2);
  142.       //   }
  143.      if(cbuff[0]=='p' && cbuff[1]=='o' && cbuff[2]=='r'&& cbuff[3]=='t'&& cbuff[4]=='o' &&cbuff[5]=='n')
  144.       {
  145.       cbuff[0]=0;
  146.       PIN_ON(LED1);  
  147.       PIN_ON(RELAY1);
  148.       delay_ms(2000);
  149.       PIN_OFF(LED1);  
  150.       PIN_OFF(RELAY1);
  151.       }
  152.  
  153.    }
  154. }
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 06 de Noviembre de 2012, 22:10:57
Primero, te aconsejo meter tu codigo en codigo Geshi, opcion C o C++.
Asi queda mas legible.
Por otro lado, podrias poner la libreria GSM_18f14k50_v2.h que va incluida en el proyecto??
Creo que alli hay datos de configuracio que o se ven e el programa principal.

Respecto a como enviar comandos para encender y apagar un bit de salida, creo que la mejor forma es enviar un Byte o una Word, y al recibirla, desarmarla en sus bits, y con el valor de estos, puedes asignarlos a tu salida sin problemas...
Yo lo hago en Modbus y va bien. ;-)
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 06 de Noviembre de 2012, 23:31:56
La idea es hacer una lista negra, entonces cargar los N° habilitados como int ej 415622, y cuando el modulo gsm reciba el sms, tomar el dato de la palabra y del numero de quien envia.
Código: C
  1. #include <18F14K50.h>
  2. #device adc=10
  3.  
  4. #FUSES NOWDT                    //No Watch Dog Timer
  5. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
  6. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
  7. #FUSES FCMEN                    //Fail-safe clock monitor enabled
  8. #FUSES NOBROWNOUT               //No brownout reset
  9. #FUSES BORV19                
  10. #FUSES NOPUT                    //No Power Up Timer
  11. #FUSES NOCPD                    //No EE protection
  12. #FUSES STVREN                   //Stack full/underflow will cause reset
  13. #FUSES NODEBUG                  //No Debug mode for ICD
  14. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
  15. #FUSES NOWRT                    //Program memory not write protected
  16. #FUSES NOWRTD                   //Data EEPROM not write protected
  17. #FUSES NOWRTC                   //configuration not registers write protected
  18. #FUSES IESO                     //Internal External Switch Over mode enabled
  19. #FUSES NOEBTR                   //Memory not protected from table reads
  20. #FUSES NOEBTRB                  //Boot block not protected from table reads
  21. #FUSES MCLR                     //Master Clear pin enabled
  22. #FUSES NOPROTECT                //Code not protected from reading
  23. #FUSES NOCPB                    //No Boot Block code protection
  24. #FUSES NOWRTB                   //Boot block not write protected
  25. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
  26. #FUSES HFOFST                
  27. #FUSES NOWRT0                
  28. #FUSES NOWRT1                
  29. #FUSES USBDIV1              
  30. #FUSES BBSIZ2K                  //2K words Boot Block size
  31. #FUSES PLLEN                
  32. #FUSES CPUDIV4                  //System Clock by 4
  33. #FUSES PCLKEN                
  34.  
  35. #use delay(clock=12000000)
  36.  
  37. #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SERIAL_SIM900)

Baje el geshi, pero me sale un archivo .php y no se que hacer con eso!
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 07 de Noviembre de 2012, 00:13:25
A esto me referia:


Código: C
  1. #include <18F14K50.h>
  2. #device adc=10
  3.  
  4. #FUSES NOWDT                    //No Watch Dog Timer
  5. #FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
  6. #FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
  7. #FUSES FCMEN                    //Fail-safe clock monitor enabled
  8. #FUSES NOBROWNOUT               //No brownout reset
  9. #FUSES BORV19              
  10. #FUSES NOPUT                    //No Power Up Timer
  11. #FUSES NOCPD                    //No EE protection
  12. #FUSES STVREN                   //Stack full/underflow will cause reset
  13. #FUSES NODEBUG                  //No Debug mode for ICD
  14. #FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
  15. #FUSES NOWRT                    //Program memory not write protected
  16. #FUSES NOWRTD                   //Data EEPROM not write protected
  17. #FUSES NOWRTC                   //configuration not registers write protected
  18. #FUSES IESO                     //Internal External Switch Over mode enabled
  19. #FUSES NOEBTR                   //Memory not protected from table reads
  20. #FUSES NOEBTRB                  //Boot block not protected from table reads
  21. #FUSES MCLR                     //Master Clear pin enabled
  22. #FUSES NOPROTECT                //Code not protected from reading
  23. #FUSES NOCPB                    //No Boot Block code protection
  24. #FUSES NOWRTB                   //Boot block not write protected
  25. #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
  26. #FUSES HFOFST              
  27. #FUSES NOWRT0              
  28. #FUSES NOWRT1              
  29. #FUSES USBDIV1              
  30. #FUSES BBSIZ2K                  //2K words Boot Block size
  31. #FUSES PLLEN                
  32. #FUSES CPUDIV4                  //System Clock by 4
  33. #FUSES PCLKEN              
  34.  
  35. #use delay(clock=12000000)
  36.  
  37. #use rs232(baud=9600,parity=N,xmit=PIN_B7,rcv=PIN_B5,bits=8,stream=SERIAL_SIM900)

Hay una lista desplegable con el nombre GeSHi cuando envias un programa, y es la mejor opcion para ver el codigo tal como lo verias en el editor... :mrgreen:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 07 de Noviembre de 2012, 00:15:18
Yo tengo una placa desarrollo de SIM908, estare aprendiendo pronto a usarlo, disculpa si no entiendo bien algunas cosas, pero esto es bastante nuevo para mi.
 :mrgreen: :mrgreen:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 07 de Noviembre de 2012, 10:05:26
Ahi modifique las respuestas con el formato. Algo que vi es como hacen la codificación, van copiando los valores de la cadena que reciben, sabiendo que las ultimas letras son el mensaje, en cbuff, la idea mia es generar 2 vectores, uno para los numeros uno para la cadena, despues convertir el vector en un int y compararlo. Pero no se si el comando  "AT+CNMI=2,2,0,0,0\r" tiene la misma secuencia que el otro que muestra el manual:

AT+CMGL="ALL"
+CMGL: 1,"REC READ","+85291234567",,"06/11/11,00:30:29+32"
Hello, welcome to our SMS tutorial.
 
En rojo marco lo que necesitaria. Espero su ayuda! Gracias
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 07 de Noviembre de 2012, 11:58:32
Lo que si aprendí es que la cadena de datos es ASCII.
Por mas que envíes un mensaje con números, en el otro lado se reciben caracteres, correspondientes con ese numero, por lo tanto hay que volver a decodificarlos como números si es que necesitas compararlos con números.

Creo que Suky puede ayudarnos bastante con esto, se que estuvo trabajando con el modulo SIM900 y ya paso esta etapa de reniegues.
Ojala se interese en este hilo. :mrgreen:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: blackcat en 12 de Noviembre de 2012, 00:41:50
Hola.

Hace poco compre la tarjeta para GSM que viene con el SIM900 y toda la comunicacion es ASCII, me tiene un poco decepcionado pues por el pic que trae no se puede hacer debug .. el programa que esta en internet para MPLAB no funciona y tuve que arreglarlo.

Ya me envia SMS, pero la recepción del primer msg es rápido, pero el resto es lento.

Gente como han hecho para poder hacer DEBUG, sin eso es un poco dificil manejarlo ... yo pensaba cambiar el PIC de la tarjeta es 14k50 me tiene  :5] :5] :5]
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: Suky en 12 de Noviembre de 2012, 18:06:47
Hola! Como bien dice blackcat, el ejemplo que entrega MCE esta plagado de errores  :undecided: En algún momento me lo dieron para que lo revise y solucione.

Así como está el ejemplo se debe configurar con AT+CNMI=2,1,0,0,0, de esa manera quedas a la espera de <CR><LF>+CMTI: <mem>,<index><CR><LF> que indica que hay un nuevo mensaje en determinada posición. Cuando solicitas el mensaje la estructura es la siguiente:

<CR><LF>+CMGR:"REC UNREAD","numero","asunto","fecha"<CR><LF>"Mensaje"<CR><LF><CR><LF>"OK"<CR><LF>

Ahí utilizando la función strtok podes separar el string y testear si el numero corresponde a la lista negra con la función strncmp

Saludos!
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: blackcat en 18 de Noviembre de 2012, 02:52:13
Cambie el pic a un PIC18F14K22 .. y ya puedo hacer debug.  ;-)

El detalle es que eliminé la funcion USB. Pero a lo que necesito eso está de mas.

Ya me funciona perfecto, ese programa de MCelectronics está lleno de fallas.



Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 18 de Noviembre de 2012, 12:04:32
Como es esto de la lista negra??
La armas y después se compara??
Para que sirve eso??
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: blackcat en 18 de Noviembre de 2012, 12:24:22
Estoy usando el comando  AT+CNMI=2,2,0,0,0 .. y si se obtiene toda la informacion: telefono, fecha, hora y mensaje ...

en la aplicacion que hice yo filtro todos los numeros exepto el mio.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 en 18 de Noviembre de 2012, 16:05:16
Hola a todos  :-/

Yo estuve analizando mucho esa placa de MCelectronics y tiene errores grosos en la fuente. Toda la placa funciona de 10, pero el diseño de la fuente deja mucho que desear. Si se ponen a ver, se darán cuenta que toda la electrónica está conectada a un diodo que es usado como regulador de 4v a 3.3v. Además el fabricante aconseja usar un regulador LDO dedicado para usarse con el módulo GSM, como puede ser el MIC29302BBT. A mi personalmente, en un momento dado el LM350 dejó de regular y me quemó toda la placa....ahora estoy usando un trainer GMS con SIM900 de SIMCOM original y ningún drama.

Lo más sencillo como habrán visto es resolver el tema de enviar mensajes, que en un montón de foros aparece como hacerlo.
Quiero aclarar que los ejemplos que les voy a mostrar los probé con el SIM300D de la placa de MCelectronics (mientras estuvo con vida) y con el trainer PLC12 de IT&T (empresa mendocina de desarrollo) y funcionaron bien.
Están todos probados usando el compilador CCS v4.114.

Código: C
  1. // Pruebas MODEM SIM300 - Ejercicio Nº1.
  2. // Ejercicio: Setup del modulo GSM y envio de SMS.
  3. // Microcontrolador utilizado: PIC16F88.
  4. // Plataforma: PLC12 - Módulo de desarrollo GSM.
  5. // Versión del compilador: v4.114
  6.  
  7. // Definimos el microcontrolador utilizado.
  8. #include <16F88.h>
  9. // Conversor de 10 bits con justificación a la derecha.
  10. #device ADC=10
  11. // Configuramos fusibles de programación.
  12.  
  13. // Configuración rápida de puertos.
  14. #use fast_io(A)
  15. #use fast_io(B)
  16.  
  17. #fuses INTRC_IO    // Oscilador interno.
  18. #fuses NOWDT       // No utilizamos el perro guardian.
  19. #fuses NOPROTECT   // Memoria de programa no protejida.
  20. #fuses PUT         // Power-up timer activado.
  21. #fuses MCLR        // Master clear reset.
  22. #fuses NOBROWNOUT  // Reset por bajo voltaje desactivado.
  23. #fuses NOLVP       // Programación con bajo voltaje desactivado.
  24. #fuses NOCPD       // Memoria EEPROM no protejida.
  25. #fuses WRT         // Habilitar escritura en memoria FLASH.
  26. #fuses NODEBUG     // No incluir código para debug.
  27.  
  28. // Configuramos velocidad de operación.
  29. #use delay(clock=8000000) // Clock: 8Mhz. Reseteamos WDT en los delay's.
  30.  
  31. // Configuramos los puertos RS232 utilizados.
  32. #use rs232(baud=9600,parity=N,xmit=PIN_B5,rcv=PIN_B2,bits=8,stream=SIM300, UART1) // RS232 - SIM300.
  33. #use rs232(baud=9600,parity=N,xmit=PIN_B3,rcv=PIN_B0,bits=8,stream=DEBUG)         // RS232 - DEBUG.
  34.  
  35. // Incluimos librerías utilizadas.
  36. #include "genf.c" // Funciones generales de configuración.
  37. #include "gsmf.c" // Funciones de control del módulo GSM SIM300.
  38.  
  39. // Teléfonos de destinatarios:
  40. char tel1[12]="xxxxxxxxxxxxx";
  41. // Mensajes fijos.
  42. char msg[5]="HOLA";
  43.  
  44. void main() {
  45.  
  46.  configurar_parametros();     // Configuramos parámetros principales.
  47.  SIM300_on();                 // Encendemos el módulo GSM SIM300.
  48.  Enviar_SMS(msg,tel1); // Enviamos mensaje con la función.
  49.  
  50.  
  51.  }
  52.  

Código: C
  1. // Configuraciones y funciones generales para PLC12.
  2.  
  3. // Declaramos funciones usadas:
  4.  
  5. void  configurar_parametros(void);    // Parámetros iniciales del programa.
  6.  
  7. void  sel_adc(int8 canal);            // Seleccionamos canal AD para trabajar.
  8.  
  9. float adc_temp(void);                 // Función para leer un sensor de temperatura.
  10.  
  11. /* Definimos el hardware utilizado:
  12.  
  13. ---------
  14. Puerto A:
  15. ---------
  16. RA0 ----> OUT1       --> salida digital 1.
  17. RA1 ----> OUT2       --> Salida digital 2.
  18. RA2 <---- AN0        --> Entrada analógica 0.
  19. RA3 <---- AN1        --> Entrada analógica 1.
  20. RA4 ----> Relé       --> salida potencia.
  21. RA5 ----- N/A (MCLR)
  22. RA6 <---- INP1       --> Entrada digital 1.
  23. RA7 <---- INP3       --> Entrada digital 3.
  24.  
  25. ---------
  26. Puerto B:
  27. ---------
  28. Rb0 <---- Rx_DEBUG   --> Entrada RS232 - Debug.
  29. Rb1 <---- INP4       --> Entrada digital 4.
  30. Rb2 <---- Rx_SIM300  --> Entrada RS232 - GSM.
  31. Rb3 ----> Tx_DEBUG   --> Salida  RS232 - Debug.
  32. Rb4 ----> SIM300_PS  --> SIM300  Power Supply. ON=1 OFF=0
  33. Rb5 ----> Tx_SIM300  --> Salida  RS232 - GSM.
  34. Rb6 ----> PowerKey_SIM300 --> ON/OFF SIM300. ON=0 OFF=1
  35. Rb7 <---- INP2       --> Entrada digital 2.
  36.  
  37. */
  38.  
  39. // Definimos macros de hardware:
  40.  
  41. #define PULSADOR1 PIN_A6 // Pulsador 1 - Activo en nivel bajo.
  42. #define PULSADOR2 PIN_B7 // Pulsador 2 - Activo en nivel bajo.
  43. #define PULSADOR3 PIN_A7 // Pulsador 3 - Activo en nivel bajo.
  44. #define PULSADOR4 PIN_B1 // Pulsador 4 - Activo en nivel bajo.
  45.  
  46. #define PWRKEY   PIN_B6 // Pin PWRKEY SIM300.
  47. #define PSSIM300 PIN_B4 // Fuente del SIM300.
  48. #define LED1     PIN_A0 // led 1 - Activo a nivel alto.
  49. #define LED2     PIN_A1 // led 2 - Activo a nivel alto.
  50. #define RELAY    PIN_A4 // RELE  - Activo a nivel alto.
  51.  
  52. #define LED1_ON  output_high(LED1);  // Encendemos LED1.
  53. #define LED1_OFF output_low(LED1);   // Apagamos   LED1.
  54. #define LED2_ON  output_high(LED2);  // Encendemos LED2.
  55. #define LED2_OFF output_low(LED2);   // Apagamos   LED2.
  56. #define RELAY_ON output_high(RELAY); // Encendemos RELE.
  57. #define RELAY_OFF output_low(RELAY); // Apagamos   RELE.
  58.  
  59. // Macros del módulo SIM300.
  60.  
  61. #define SIM300_PWRKEY_ON    output_low(PWRKEY);    // SIM300 ON.
  62. #define SIM300_PWRKEY_OFF   output_high(PWRKEY);   // SIM300 OFF.
  63.  
  64. #define PSSIM300_ON  output_high(PSSIM300);        // Power Supply SIM300 ON.
  65. #define PSSIM300_OFF output_low(PSSIM300);         // Power Supply SIM300 OFF.
  66.  
  67.  
  68.  
  69. // Funciones de usuario:
  70.  
  71. void  configurar_parametros(void) {
  72.  
  73. // Limpiamos las salidas..
  74.  
  75. output_A(0x00); // del puerto A.
  76. output_B(0x00); // del puerto B.
  77.  
  78. // Configuramos E/S:
  79.  
  80. set_tris_a (0b11101100); // RA7 a RA0.
  81. set_tris_b (0b10000111); // RB7 a RB0.
  82.  
  83. // Apamos el módulo GSM (se mantiene apagado manteniendo un nivel alto en PWRKEY).
  84.  
  85. SIM300_PWRKEY_OFF
  86.  
  87. // Configuramos el conversor AD.
  88.  
  89. SETUP_ADC(ADC_CLOCK_DIV_16); // Clock/16.
  90. SETUP_ADC_PORTS(sAN2|sAN3|VSS_VDD); // Canal AD: 2 y 3 ; referencia: 0 - VDD.
  91.  
  92. }
  93.  
  94.  
  95. void  sel_adc(int8 canal) {
  96.  
  97.   set_adc_channel(canal);
  98.  
  99.  }
  100.  

Código: C
  1. // Funciones de setup del modulo SIM300.
  2.  
  3. // Declaramos funciones usadas:
  4.  
  5. void SIM300_on(void);                    // Encendemos el módulo SIM300.
  6. void Enviar_SMS(char *texto, char *tel); // Función para enviar mensajes de texto.
  7.  
  8. // Funciones de usuario:
  9.  
  10. void SIM300_on(void){
  11.  
  12. // Apagamos las interrupciones.
  13. disable_interrupts(INT_rda);
  14. disable_interrupts(INT_RTCC);
  15.  
  16.   PSSIM300_OFF
  17.   SIM300_PWRKEY_ON  
  18.   delay_ms(2000);       // Esperamos 2 seg.
  19.   PSSIM300_ON
  20.   delay_ms(500);        // Esperamos 1/2 seg.
  21.   SIM300_PWRKEY_OFF
  22.   delay_ms(2000);       // Esperamos 2 seg.
  23.   SIM300_PWRKEY_ON
  24.   delay_ms(30000); // Esperamos 30 segundos el Call Ready.
  25.   fputs("at",SIM300);
  26.   delay_ms(10000);
  27.   fprintf(SIM300,"AT\n\r");           // Comando de verificación.
  28.   delay_ms(500);
  29.   fprintf(SIM300,"ATE0\n\r");         // Eco OFF.
  30.   delay_ms(250);
  31.   fprintf(SIM300,"AT+CMGF=1\n\r");    // Configuramos modo texto.
  32.   delay_ms(250);
  33. }
  34.  
  35. void Enviar_SMS(char *texto, char *tel){
  36.  
  37.  fprintf(SIM300,"AT+CMGS=\"%s\"\r",tel); // Teléfono al cúal le enviaremos el mensaje.
  38.  delay_ms(300);
  39.  fprintf(SIM300,"%s",texto); // Mensaje que contiene la temperatura ambiente.
  40.  delay_ms(500);
  41.  fprintf(SIM300,"%c",0x1A);       // Comando para enviar el mensaje. Equivale al CRTL+Z.
  42.  delay_ms(1000);  
  43.  
  44. }
  45.  

Ahora para recibir un mensaje, aclaro que la función no discrimina entre mensajes, pero la estructura básica para que lo implementen está hecha.

Código: C
  1. // Pruebas MODEM SIM300 - Ejercicio Nº3.
  2. // Ejercicio: Inicialización del módulo GSM y recepción de mensajes con toma de parámetros.
  3. // Microcontrolador utilizado: PIC16F88.
  4. // Plataforma: PLC12 - Módulo de desarrollo GSM.
  5. // Versión del compilador: v4.114
  6.  
  7. // Definimos el microcontrolador utilizado.
  8. #include <16F88.h>
  9. // Conversor de 10 bits con justificación a la derecha.
  10. #device ADC=10
  11. // Configuramos velocidad de operación.
  12. #use delay(clock=8000000) // Clock: 8Mhz.
  13.  
  14. // Configuramos fusibles de programación.
  15. #fuses INTRC_IO    // Oscilador interno.
  16. #fuses NOWDT       // No utilizamos el perro guardian.
  17. #fuses NOPROTECT   // Memoria de programa no protejida.
  18. #fuses PUT         // Power-up timer activado.
  19. #fuses NOMCLR      // NO Master clear reset.
  20. #fuses NOBROWNOUT  // Reset por bajo voltaje desactivado.
  21. #fuses NOLVP       // Programación con bajo voltaje desactivado.
  22. #fuses NOCPD       // Memoria EEPROM no protejida.
  23. #fuses NOWRT       // NO habilitar escritura en memoria FLASH.
  24. #fuses NODEBUG     // No incluir código para debug.
  25.  
  26. // Configuramos los puertos RS232 utilizados.
  27. #use rs232(baud=9600, xmit=PIN_B5,rcv=PIN_B2,errors,stream=SIM300)  // RS232 - SIM300.
  28. #use rs232(baud=9600, xmit=PIN_B3,rcv=PIN_B0,errors,stream=DEBUG)   // RS232 - DEBUG.
  29.  
  30. // Utilizamos el modo de acceso rápido a los puertos.
  31. #use fast_io(A)
  32. #USE fast_io(B)
  33.  
  34. // Incluimos librerías utilizadas.
  35. #include <stdlib.h> // Funciones standar.
  36. #include <string.h> // Funciones para el manejo de cadenas.
  37. #include "genf.c"   // Funciones generales de configuración.
  38. #include "gsmf.c"   // Funciones de control del módulo GSM SIM300.
  39.  
  40.  
  41. ///////////////// Recepción de datos del modem GSM ////////////////////
  42.  
  43. #int_RDA
  44.  
  45. void RDA_isr()
  46. {
  47. USART_buffer[USART_nextRec]=fgetc(SIM300);
  48. if(USART_buffer[USART_nextRec]!=0x0A)USART_nextRec++;
  49. if(USART_nextRec==bytes_for_USART_buffer)USART_nextRec=0;
  50. }
  51.  
  52. void main() {
  53.  
  54.  configurar_parametros();      // Configuramos parámetros principales.
  55.  SIM300_on();                  // Encendemos el módulo GSM SIM300.
  56.  
  57.  // Habilitamos interrupciones.
  58.  enable_interrupts(GLOBAL);
  59.  enable_interrupts(int_rda);
  60.  borrar_todos_sms();           // Borramos todos los mensajes de la SIM.
  61.  
  62.  
  63.  
  64.   while(true){
  65.    
  66.   procesa_sms();
  67.  
  68.    }
  69. }
  70.  
  71.  

Código: C
  1. // Configuraciones y funciones generales para PLC12.
  2.  
  3. // Declaramos funciones usadas:
  4.  
  5. void configurar_parametros(void);  // Parámetros iniciales del programa.
  6. void inicializo_buffer(void);      // Borramos el buffer de recepción.
  7. void inicializo_buffer_aux(void);  // Borramos el buffer auxiliar.
  8. void inicializo_buffer_aux2(void); // Borramos el buffer auxiliar 2.
  9.  
  10. /* Definimos el hardware utilizado:
  11.  
  12. ---------
  13. Puerto A:
  14. ---------
  15. RA0 ----> OUT1       --> salida digital 1.
  16. RA1 ----> OUT2       --> Salida digital 2.
  17. RA2 <---- AN0        --> Entrada analógica 0.
  18. RA3 <---- AN1        --> Entrada analógica 1.
  19. RA4 ----> Relé       --> salida potencia.
  20. RA5 ----- N/A (MCLR)
  21. RA6 <---- INP1       --> Entrada digital 1.
  22. RA7 <---- INP3       --> Entrada digital 3.
  23.  
  24. ---------
  25. Puerto B:
  26. ---------
  27. Rb0 <---- Rx_DEBUG   --> Entrada RS232 - Debug.
  28. Rb1 <---- INP4       --> Entrada digital 4.
  29. Rb2 <---- Rx_SIM300  --> Entrada RS232 - GSM.
  30. Rb3 ----> Tx_DEBUG   --> Salida  RS232 - Debug.
  31. Rb4 ----> SIM300_PS  --> SIM300  Power Supply. ON=1 OFF=0
  32. Rb5 ----> Tx_SIM300  --> Salida  RS232 - GSM.
  33. Rb6 ----> PowerKey_SIM300 --> ON/OFF SIM300. ON=0 OFF=1
  34. Rb7 <---- INP2       --> Entrada digital 2.
  35.  
  36. */
  37.  
  38. // Definimos macros de hardware:
  39.  
  40. #define PULSADOR1 PIN_A6 // Pulsador 1 - Activo en nivel bajo.
  41. #define PULSADOR2 PIN_B7 // Pulsador 2 - Activo en nivel bajo.
  42. #define PULSADOR3 PIN_A7 // Pulsador 3 - Activo en nivel bajo.
  43. #define PULSADOR4 PIN_B1 // Pulsador 4 - Activo en nivel bajo.
  44.  
  45. #define PWRKEY   PIN_B6 // Pin PWRKEY SIM300.
  46. #define PSSIM300 PIN_B4 // Fuente del SIM300.
  47. #define OUT1     PIN_A0 // OUT 1 - Activo a nivel alto.
  48. #define OUT2     PIN_A1 // OUT 2 - Activo a nivel alto.
  49. #define RELAY    PIN_A4 // RELE  - Activo a nivel alto.
  50.  
  51. #define OUT1_ON  output_high(OUT1);  // Encendemos OUT1.
  52. #define OUT1_OFF output_low(OUT1);   // Apagamos   OUT1.
  53. #define OUT2_ON  output_high(OUT2);  // Encendemos OUT2.
  54. #define OUT2_OFF output_low(OUT2);   // Apagamos   OUT2.
  55. #define RELAY_ON output_high(RELAY); // Encendemos RELE.
  56. #define RELAY_OFF output_low(RELAY); // Apagamos   RELE.
  57.  
  58. // Estado de las entradas digitales.
  59. #define ESTADO_PULSADOR1 input(PULSADOR1)
  60. #define ESTADO_PULSADOR2 input(PULSADOR2)
  61. #define ESTADO_PULSADOR3 input(PULSADOR3)
  62. #define ESTADO_PULSADOR4 input(PULSADOR4)
  63.  
  64. // Estado de las salidas digitales.
  65. #define ESTADO_OUT1 input(OUT1)
  66. #define ESTADO_OUT2 input(OUT2)
  67. #define ESTADO_RELE input(RELAY)
  68.  
  69. // Macros del módulo SIM300.
  70.  
  71. #define SIM300_PWRKEY_ON    output_high(PWRKEY);  // SIM300 ON.
  72. #define SIM300_PWRKEY_OFF   output_low(PWRKEY);   // SIM300 OFF.
  73.  
  74. #define PSSIM300_ON  output_high(PSSIM300);       // Power Supply SIM300 ON.
  75. #define PSSIM300_OFF output_low(PSSIM300);        // Power Supply SIM300 OFF.
  76.  
  77. // Variables interrupciones.
  78.  
  79. #define bytes_for_USART_buffer 75                   // Tamaño del buffer de la USART.
  80.  
  81. volatile int8 USART_buffer[bytes_for_USART_buffer]; // Buffer de la USART.
  82.  
  83. volatile int8 USART_nextRec=0;                      // Contador de caracteres recibidos.
  84.  
  85. // Punteros.
  86.  
  87. char *ptr;
  88.  
  89. // Variables auxiliares.
  90.  
  91. int8 i=0;
  92. int8 x=0;
  93. int8 j=0;
  94. char a='\0';
  95. int32 ph_max=0;
  96. int32 ph_min=0;
  97.  
  98.  
  99. // Buffer auxiliar.
  100.  
  101. #define bytes_for_AUX_buffer   75                   // Tamaño del buffer auxliar.
  102.  
  103. int8 AUX_buffer[bytes_for_AUX_buffer ];             // Buffer auxiliar de 75 bytes.
  104.  
  105. int8 SMS_Buffer[15];                                // Buffer auxiliar 2
  106.  
  107. // desarrollo de funciones de usuario:
  108.  
  109. void  configurar_parametros(void) {
  110.  
  111. // Configuramos E/S:
  112. set_tris_a (0b11101100); // RA7 a RA0.
  113. set_tris_b (0b10000111); // RB7 a RB0.
  114. // Configuramos el oscilador.
  115. setup_oscillator(OSC_8MHZ);
  116. // Desactivamos las interrupciones.
  117. disable_interrupts(GLOBAL);
  118. disable_interrupts(INT_rda);
  119. // Configuramos el conversor AD.
  120. SETUP_ADC(ADC_CLOCK_DIV_16); // Clock/16.
  121. SETUP_ADC_PORTS(sAN2|sAN3|VSS_VDD); // Canal AD: 2 y 3 ; referencia: 0 - VDD.
  122.  
  123. // Iniciamos los puertos:
  124. RELAY_OFF // Apagamos   RELE.
  125. OUT1_OFF  // Apagamos   OUT1.
  126. OUT2_OFF  // Apagamos   OUT2.
  127.  
  128. }
  129.  
  130. void inicializo_buffer(void){
  131.  
  132.  USART_nextRec=0; // Inicializo el contador de datos entrantes.
  133.   for(i=0; i<=bytes_for_USART_buffer; i++){ // Borro el contenido del buffer de datos.
  134.    USART_buffer[i]='\0';}
  135.  
  136. }
  137.  
  138. void inicializo_buffer_aux(void){
  139.  
  140.   for(x=0; x<=bytes_for_AUX_buffer ; x++){ // Borro el contenido del buffer auxiliar.
  141.    AUX_buffer[x]='\0';}
  142.  
  143. }
  144.  
  145. void inicializo_buffer_aux2(void){
  146.  
  147.   for(j=0; j<=15 ; j++){ // Borro el contenido del buffer auxiliar 2.
  148.    SMS_Buffer[j]='\0';}
  149.  
  150. }
  151.  

Código: C
  1. // Funciones del módulo SIM300.
  2. // Versión 0.1 estable.
  3.  
  4. // Declaramos funciones usadas:
  5.  
  6. void  SIM300_on(void);                        // Encendemos y configuramos el módulo SIM300.
  7. void  enviar_SMS(char *texto, char *tel);     // Función para enviar mensajes de texto.
  8. void  leer_sms(void);                         // Leemos un mensaje de texto.
  9. void  borrar_sms(void);                       // Borra un mensaje de texto de la posición 1.
  10. void  borrar_todos_sms(void);                 // Borro todos los mensajes.
  11. void  procesa_sms(void);                      // Procesamos el contenido del mensaje de texto y actuamos en consecuencia.
  12.  
  13.  
  14.  
  15. // desarrollo de las funciones del modem:
  16.  
  17. void SIM300_on(void){
  18.  
  19.   PSSIM300_OFF          // Apagamos la fuente del SIM300.
  20.   SIM300_PWRKEY_OFF     // PRWKEY=0;
  21.   delay_ms(1000);       // Esperamos 1 seg.
  22.   PSSIM300_ON           // Encendemos la fuente del SIM300.
  23.   delay_ms(500);        // Esperamos 1/2 seg.
  24.   SIM300_PWRKEY_ON      // PWRKEY=1;
  25.   delay_ms(1500);       // Esperamos 1-1/2 seg.
  26.   SIM300_PWRKEY_OFF     // PRWKEY=0;
  27.   delay_ms(30000);      // Esperamos 40 segundos el Call Ready.
  28.   fputs("AT",SIM300);
  29.   delay_ms(10000);    
  30.   fprintf(SIM300,"AT\n\r");                    // Comando de verificación.
  31.   delay_ms(500);                               // Esperamos 500ms.
  32.   fprintf(SIM300,"ATE0\n\r");                  // Eco OFF.
  33.   delay_ms(500);                               // Esperamos 500ms.
  34.   fprintf(SIM300,"AT+CMGF=1\n\r");             // Configuramos modo texto.
  35.   delay_ms(500);                               // Esperamos 500ms.
  36.   fprintf(SIM300,"AT+CPMS=\"SM\",\"SM\"\n\r"); // Selecciono la mememoria SIM para recibir y leer SMS.
  37.   delay_ms(500);                               // Esperamos 500ms.
  38.   fprintf(SIM300,"AT+CNMI=2,2,0,0,0\n\r");     // Los mensajes de texto, una vez recibidos son enviados directamente al buffer de la USART.
  39.   delay_ms(500);                               // Esperamos 500ms.
  40.   inicializo_buffer();                         // Limpiamos el buffer de recepción.
  41.  
  42. }
  43.  
  44. void Enviar_SMS(char *texto, char *tel){
  45.  
  46.  inicializo_buffer();                    // Limpiamos el buffer de recepción.
  47.  fprintf(SIM300,"AT+CMGS=\"%s\"\r",tel); // Teléfono al cúal le enviaremos el mensaje.
  48.  delay_ms(300);                          // Esperamos 300ms.
  49.  fprintf(SIM300,"%s",texto);             // Cargamos mensaje.
  50.  delay_ms(500);                          // Esperamos 500ms.
  51.  fprintf(SIM300,"%c",0x1A);              // Comando para enviar el mensaje. Equivale al CRTL+Z.
  52.  delay_ms(4000);                         // Esperamos 4 seg.
  53.  inicializo_buffer();                    // Limpiamos el buffer de recepción.
  54.  
  55. }
  56.  
  57.  
  58. void borrar_sms(void){
  59.  
  60.  fprintf(SIM300,"AT+CMGD=1\n\r",);   // Enviamos comando: "AT+CMGD=1 para borrar un mensaje de la posición 1 de memoria de la SIM.
  61.  delay_ms(1000);                     // Esperamos 1 segundo.
  62.  inicializo_buffer();                // Limpiamos el buffer de recepción.
  63.  inicializo_buffer_aux();            // Borramos el buffer auxiliar.
  64.  inicializo_buffer_aux2();           // Borramo el buffer de mensajes.
  65.  ptr=&a;                             // Inicializamos el puntero.
  66.  
  67. }
  68.  
  69. void borrar_todos_sms(void){
  70.  
  71.    disable_interrupts(int_rda);
  72.    for(i=1;i<=10;i++)                      // Bucle para borrar los 10 mensajes.
  73.    {
  74.    fprintf(SIM300,"AT+CMGD=%d\n\r\0",i);   // Borro los 10 primeros sms.
  75.    delay_ms(500);                          // Esperamos 500ms.
  76.    }
  77.    enable_interrupts(int_rda);             // Habilitamos nuevamente las interrupciones por el puerto serie.
  78.    inicializo_buffer();          // Limpiamos el buffer de recepción.
  79.    inicializo_buffer_aux();      // Borramos el buffer auxiliar.
  80.    inicializo_buffer_aux2();     // Borramo el buffer de mensajes.
  81.    
  82. }
  83.  
  84. void procesa_sms(void){
  85.  
  86. char  delimitante1[] = "\r\n"; // Delimitante (para el mensaje principal).
  87. char  delimitante2[] = "+";    // Delimitante (entre valores).
  88.  
  89.  
  90. // Constantes de comando.
  91. char LED_CMD1[4]= "LED";
  92. char LED_CMD2[2]= "1";
  93. char LED2_CMD[2]= "2";
  94. char LED_CMD3[3]= "ON";
  95. char LED_CMD4[4]= "OFF";
  96. char CONF_CMD[5]= "CONF";
  97. char PH_CMD[3]=   "PH";
  98.  
  99. // Constantes de parámentros.
  100.  
  101.  
  102.  // 1° - Copiamos el buffer de la usart en el buffer auxiliar.
  103.  strcpy(AUX_buffer, USART_buffer);
  104.  // 2° - Tomamos del buffer auxiliar el SMS.
  105.  ptr = strtok(AUX_buffer, delimitante1);                              
  106.  ptr = strtok(NULL, delimitante1);
  107.  // 3° Copiamos en un buffer auxiliar el SMS.
  108.  strcpy(SMS_Buffer, ptr);
  109.  // 4° - Imprimimos el mensaje.
  110.  fprintf(DEBUG,"SMS:%s\n\r",SMS_Buffer);
  111.  // 5° - Nos quedamos con el comando principal.
  112.  ptr = strtok(SMS_Buffer, delimitante2);
  113.  // 6° - Imprimimos el comando principal.
  114.  fprintf(DEBUG,"CMD:%s\n\r",ptr);
  115.  
  116.  // 7° - Comparamos el comando principal con la lista en memoria.
  117.  
  118.  if(stricmp(ptr,LED_CMD1)==0x00){       // Comparamos el primero comando con el CMD[LED]. Si es válido...
  119.   ptr = strtok(NULL, delimitante2);     // Determinamos cual LED necesitamos controlar...
  120.    if(stricmp(ptr,LED_CMD2)==0x00){     // Si es el LED1...
  121.     ptr = strtok(NULL, delimitante2);   // Nos fijamos en el segundo comando CMD[ON] o CMD[OFF]. Si es válido....
  122.      if(stricmp(ptr,LED_CMD3)==0x00){   // Queremos prender el LED1 ??
  123.      
  124.      OUT1_ON       // Encendemos LED1.
  125.      borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  126.      
  127.      }
  128.      
  129.    if(stricmp(ptr,LED_CMD4)==0x00){    // Queremos prender el Apagar el LED1 ??
  130.      
  131.      OUT1_OFF      // Apagamos LED1.
  132.      borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  133.  }
  134.   }
  135.  
  136.   if(stricmp(ptr,LED2_CMD)==0x00){      // Si es el LED2...
  137.     ptr = strtok(NULL, delimitante2);   // Nos fijamos en el segundo comando CMD[ON] o CMD[OFF]. Si es válido...
  138.      if(stricmp(ptr,LED_CMD3)==0x00){   // Queremos prender el LED2 ??
  139.      
  140.      OUT2_ON       // Encendemos LED2.
  141.      borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  142.      
  143.      }
  144.      
  145.    if(stricmp(ptr,LED_CMD4)==0x00){     // Queremos prender el Apagar el LED2 ??
  146.      
  147.      OUT2_OFF      // Apagamos LED2.
  148.      borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  149.  }
  150.   }
  151.    }
  152.    
  153.    
  154.    if(stricmp(ptr,CONF_CMD)==0x00){    // Comparamos el primero comando con el CMD[CONF]. Si es válido...
  155.    ptr = strtok(NULL, delimitante2);   // Tomamos el segundo CMD, ya sea PH,CLORO,TURBIDEZ,ETC.
  156.    
  157.    if(stricmp(ptr,PH_CMD)==0x00){      // Si necesitamos configurar el PH..
  158.    ptr = strtok(NULL, delimitante2);   // 1° - Tomamos el máximo del valor.
  159.     ph_max=atoi32(ptr);                // Lo convertimos de tipo y lo guardamos en la variable ph_max.
  160.      fprintf(DEBUG,"ph_max:%lu\n\r",ph_max); // 2° - Imprimimos el valor de ph_max.
  161.       ptr = strtok(NULL, delimitante2);      // 3° - Tomamos el parámetro mínimo.
  162.        ph_min=atoi32(ptr);             // Lo convertimos de tipo y lo guardamos en la variable ph_min.
  163.         fprintf(DEBUG,"ph_min:%lu\n\r",ph_min);  // 2° - Imprimimos el valor de ph_min.
  164.          }
  165.    
  166.    borrar_sms(); // Borramos mensaje para dejar espacio para el próximo comando.
  167.     }
  168.    
  169.  delay_ms(1000); // Esperamos 1 segundo.
  170.  
  171.  }
  172.  

A mi personalmente los ejemplos que me brindaron desde MCelectronics no me funcionó ninguno....o funcionaron con muchos errores. Espero que estos ejemplos les sirvan de guía para poder armar aplicaciones más robustas.
Es preciso comentar que estos ejemplos no sirven para aplicaciones comerciales debido principalmente a problemas que se presentan en la vida real, como pueden ser los siguientes:

- Que llamen al celular mientras está procesando un mensaje.
- Que lleguen muchos mensajes al mismo tiempo y saturen el buffer de la USART.
- Que lleguen mensajes con números cortos.. como los de propaganda....(el parser no los puede discriminar por la longitud)
- No tiene funciones que vean el estado del módulo...etc

Sirve para aplicaciones simples y en ambientes controlados...de desarrollos didácticos.

Espero les sirva, un saludo !

PD: Para poderlos hacer andar en la placa de MCelectronics tiene que cambiar todo lo referente a la configuración al pic y la definición de pines, que está detallada en los ejemplos.

Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 29 de Noviembre de 2012, 00:39:50
Yo termine el programa de lista negra. No sabia de las fallas de la placa de Mcelectronics. Todavia no la compre. Alguno me recomienda alguna con pic incorporado para probar?. Tienen las fallas del programa asi modifico?.
El codigo me quedo asi:

Código: C
  1. #include "GSM_18f14k50_v2.h"
  2. #define PIN_ON  output_high
  3. #define PIN_OFF output_low
  4. #define RELAY1  PIN_C0
  5. #define RELAY2  PIN_C1
  6. #define PULSADOR1  PIN_C2
  7. #define PULSADOR2  PIN_C3
  8. #define PULSADOR3  PIN_B6
  9. #define PWM_LED  PIN_C5
  10. #define LED1  PIN_C6
  11. #define LED2  PIN_C7
  12. #define TEMP PIN_B4
  13. #define POWERKEYGSM  PIN_C4
  14. //#define char lista[177][10]={{'3','8','0','4','4','1','5','6','2','2'}}
  15. 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'}};
  16.  
  17.  
  18.  
  19.  
  20. //*************************************************************************************************************************************
  21. //--------------------------------------variables globales
  22. //*************************************************************************************************************************************
  23. //char lista[178][10];
  24. int d,numok=0,i,j,numcorr,iniciorecpnum;
  25. int const lenbuff=6;  // Tamaño del buffer de recepción
  26. int8 cbuff[lenbuff];   // Buffer de recepcion de datos serie
  27. int const num=10;
  28. int8 numrec[num];
  29. //*************************************************************************************************************************************
  30. //--------------------------------------Interrupcion serie
  31. //*************************************************************************************************************************************
  32. #int_RDA //En esta interrupcion es cuando cargo el valor que obtengo del puerto y lo guardo en un vector char.
  33. void  RDA_isr(void)
  34. {
  35.  
  36.  
  37.    d=0;
  38.       d=getchar(SERIAL_SIM900);
  39.       if (d=='"')                //Pregunto si entro un " del modulo gsm caso afirmativo incrementa un contador
  40.          {iniciorecpnum=iniciorecpnum+1;
  41.          }
  42.       if (iniciorecpnum>0 && iniciorecpnum<2) // como el numero llega precedido por comillas "xxxxxxxxxx", pregunto por las comillas despues de que la detecta por 2da vez y acumulo en un vector
  43.          {   numrec[0]=numrec[1];
  44.              numrec[1]=numrec[2];
  45.              numrec[2]=numrec[3];
  46.              numrec[3]=numrec[4];
  47.              numrec[4]=numrec[5];
  48.              numrec[5]=numrec[6];
  49.              numrec[6]=numrec[7];
  50.              numrec[7]=numrec[8];
  51.              numrec[8]=numrec[9];
  52.              numrec[9]=d;
  53.          }
  54.       cbuff[0]=cbuff[1];
  55.       cbuff[1]=cbuff[2];
  56.       cbuff[2]=cbuff[3];
  57.       cbuff[3]=cbuff[4];
  58.       cbuff[4]=cbuff[5];
  59.       cbuff[5]=d;
  60.  
  61. }
  62. //*************************************************************************************************************************************
  63. //--------------------------------------Funciones
  64. //*************************************************************************************************************************************
  65.  
  66. void inicializacionSIM900(void)
  67. {
  68.    int cont;
  69.    delay_ms(1000);
  70.    puts("A",SERIAL_SIM900); //para sincronizar el baudrate del SIM 900
  71.    delay_ms(300);
  72.    putchar(0x0d,SERIAL_SIM900);
  73.    delay_ms(1000);
  74.    for(cont=0;cont<5;cont++)              // mando varios AT para el autobauding
  75.          {
  76.          puts("AT",SERIAL_SIM900);
  77.          delay_ms(200);
  78.          putchar(0x0d,SERIAL_SIM900);
  79.          delay_ms(200);
  80.          PIN_ON(LED1);
  81.          delay_ms(200);
  82.          PIN_OFF(LED1);
  83.          }
  84. //-----------------------------------seteos de configuracion del SIM900------------------------        
  85.    puts("AT+CMGF=1\r",SERIAL_SIM900);                  // configuro para que trabaje en modo texto y no PDU
  86.    delay_ms(200);
  87.    putchar(0x0d,SERIAL_SIM900);
  88.    delay_ms(200);
  89.    puts("AT+CNMI=2,2,0,0,0\r",SERIAL_SIM900);                  // configuro para que en cuanto llegue un mensaje lo envie el modulo gsm por el puerto serie
  90.    delay_ms(200);
  91.    putchar(0x0d,SERIAL_SIM900);
  92.    delay_ms(200);
  93.     return;
  94. }  
  95. //*************************************************************************************************************************************
  96. //*************************************************************************************************************************************
  97. //------------------------------------Programa Principal
  98. //*************************************************************************************************************************************
  99. void main()
  100. {
  101.    setup_adc_ports(sAN10|VSS_VDD);  
  102.    setup_adc(ADC_CLOCK_DIV_2|ADC_TAD_MUL_0);
  103.    setup_spi(SPI_SS_DISABLED);
  104.    setup_wdt(WDT_OFF);
  105.    setup_timer_0(RTCC_INTERNAL);
  106.    setup_timer_1(T1_DISABLED);
  107.    setup_timer_2(T2_DISABLED,0,1);
  108.    enable_interrupts(INT_RDA);
  109.    enable_interrupts(GLOBAL);
  110. //------------------------------------------------MI PROGRAMA!!-------------------------------------------------------------------
  111.    set_tris_b(0b00001100);    
  112.    set_tris_c(0b01110000);  
  113.    PIN_OFF(RELAY1);
  114.    PIN_OFF(RELAY2);
  115.    PIN_OFF(LED1);
  116.    PIN_OFF(LED2);
  117.    
  118.    PIN_OFF(POWERKEYGSM);    //Enciendo modulo GSM
  119.    delay_ms(1200);
  120.    PIN_ON(POWERKEYGSM);
  121.    
  122.    
  123.    inicializacionSIM900();  //Inicializo el SIM900
  124.  
  125.   while (true)               // bucle infinito
  126.    {
  127.     for (i=0;i<178;i++)                     //Recorro la matriz preguntando si alguno de los numeros cargados se corresponde con el que envio el sms
  128.       {if(numok==10)                         //Si tengo las 10 coincidencias el numero es correcto, caso contrario tendria valor 0. Si alguno de los numeros es correcto habilito la marca para avisar que el numero esta habilitado
  129.             {numcorr=1;
  130.                for (j=0;j<10;j++)
  131.                   {  if (lista[i][j]==numrec[j])  //Comparo caracter a caracter los vectores
  132.                      numok=numok+1;
  133.                      else
  134.                      numok=0;
  135.                   }
  136.             }
  137.       if(i==178)
  138.       iniciorecpnum=0;//Una vez que ya compare todos los valores habilito una nueva recepcion
  139.       }
  140.     if(cbuff[0]=='p' && cbuff[1]=='o' && cbuff[2]=='r'&& cbuff[3]=='t'&& cbuff[4]=='o' &&cbuff[5]=='n'&&numcorr==1 ) //Pregunto por la palabra habilitada y si el numero se encuentra en la lista habilitada
  141.       {
  142.       cbuff[0]=0;              //Salidas del sistema
  143.       PIN_ON(LED1);  
  144.       PIN_ON(RELAY1);
  145.       delay_ms(2000);
  146.       PIN_OFF(LED1);  
  147.       PIN_OFF(RELAY1);
  148.       numcorr=0;
  149.       }
  150.  
  151.    }
  152. }
Esta la funcion de lista blanca con la matriz de 177 x 10 numeros. Una condicion teniendo en cuenta como recibe el pic el sms en el formato:

+CMT: ”12345678”,,”28/05/10,11:20:28+32”
Hola Mundo

Tengo un contador de comillas para guardar el texto. Creo que funcionaria.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 29 de Noviembre de 2012, 08:33:35
Y donde esta la lista ?? :shock:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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]
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: fighter 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




Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT 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... :?
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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.



Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 07 de Febrero de 2013, 17:13:52
Corrijo, me entrega error de Checksum. El led de error queda funcionando.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: todopic 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:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT 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 (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:
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: todopic 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...
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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:

Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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. }
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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 !
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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....
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT 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 !!!
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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?
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: jonathanPIC888 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 ?
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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. }
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT 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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 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

Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 16 de Febrero de 2013, 21:39:38
Lo mas importante no lo escribiste.
Anda ??   :shock: :shock:

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

Citar
      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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 16 de Febrero de 2013, 21:42:36
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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 16 de Febrero de 2013, 21:54:15
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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: MGLSOFT en 16 de Febrero de 2013, 22:00:35
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.
Título: Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
Publicado por: luc_eluani88 en 16 de Febrero de 2013, 22:25:27
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.