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

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

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
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. }
« Última modificación: 07 de Noviembre de 2012, 09:56:22 por luc_eluani88 »

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #1 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. ;-)
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #2 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!
« Última modificación: 07 de Noviembre de 2012, 09:54:32 por luc_eluani88 »

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #3 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:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #4 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:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #5 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

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #6 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:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado blackcat

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 600
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #7 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]
Control Automático, DSP & Microcontroladores

Desconectado Suky

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 6759
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #8 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!
No contesto mensajes privados, las consultas en el foro

Desconectado blackcat

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 600
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #9 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.



Control Automático, DSP & Microcontroladores

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #10 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??
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado blackcat

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 600
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #11 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.
Control Automático, DSP & Microcontroladores

Desconectado jonathanPIC888

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 287
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #12 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.


Desconectado luc_eluani88

  • PIC10
  • *
  • Mensajes: 32
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #13 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.
« Última modificación: 29 de Noviembre de 2012, 09:36:24 por luc_eluani88 »

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Proyecto: En una placa MCE GSM KIT con SIM900D y pic 18F14K50 de Microchip
« Respuesta #14 en: 29 de Noviembre de 2012, 08:33:35 »
Y donde esta la lista ?? :shock:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.


 

anything