Revision 0:d1f7bad3a2cf, committed 2015-11-25

Comitter:

Meli

Date:

Wed Nov 25 02:12:44 2015 +0000

Commit message:

este programa recibe ordenes codificadas en mensajes de texto y envia mensajes cuando pulsan un boton use Alarma1 y Alarma2 de prueba...regresa por pulsador Alarma1. captura el numero de telefono de quien manda la orden;

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Debounced.lib	Wed Nov 25 02:12:44 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/WarwickRacing/code/Debounced/#8992c13bbb9b

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Nov 25 02:12:44 2015 +0000
@@ -0,0 +1,407 @@
+//  Programa para enviar desde la FRDMKL25Z un mensaje de texto en formatp PDU
+//   Como modem usa un celular SIEMENS a56i
+//   ENVIAR -----la palabra "ALARMA 1"
+//  
+
+//   OJO CON ESTO
+//   conector del siemens cable verde es RX conectelo a PTE0  cable blanco es TX conectelo a PTE1
+#include "mbed.h"
+#include "DebouncedIn.h"
+#include "stdio.h"
+#include "string.h"
+Timer t;
+DigitalOut LedVerde(LED2);
+DigitalOut LedRojo(LED1);
+DigitalOut LedAzul(LED3);
+DebouncedIn button1(PTC12);  //señal que inicia el envio del mensaje
+Serial GSM(PTE0,PTE1); //Configura puerto UART de la FRDMKL25Z
+Serial pc(USBTX,USBRX);//Configura puerto USB a la consola serial del PC conectado.
+void Rx_interrupt();
+int position=0;
+int intentos=0;
+int lenpack=6;
+int ret=1;
+int longi=0;
+char tel[11];        //Numero de celular
+char DE[50];
+char buffer[100];
+char buffermsg[100];
+char buffer1[100];
+char datos[100];
+char NUMBER[13]; 
+char resp[6];  
+char CMT[]="+CMTI";
+char tam[2];
+int index;
+int count;
+int i = 0;
+int j = 0;
+int c=0;
+unsigned char CtrlZ = 0x1A;  // comodin de emision controlZ
+bool Flag = false; // bandera 
+char r[]=""; //Cadena de recepcion de la trama PDU si se usa!!
+char msg[256];
+char char1;
+//Flush serial para el buffer
+void FlushGSM(void) { 
+char1 = 0;
+ while (GSM.readable()){      //mientras el celular este recibiendo datos
+     char1 = GSM.getc();}    
+     return;}
+
+void callback() {
+    // Note: you need to actually read from the serial to clear the RX interrupt
+    pc.printf("%c\n", GSM.getc());
+    
+}
+//****************************************************************************************************************
+//esta funcion de abajo lee todo un bufer hasta encontrar CR o LF y el resto lo rellena de
+//$, count es lo que va a leer.Lo leido lo mete en buffer que es una cadena previamente definida
+//incorpora medida de tiempo si se demora mas de tres segundos retorna fracaso con -1
+//**************************************************************************************************************** 
+int readBuffer(char *buffer,int count)
+{
+    int i=0; 
+    t.start();  // start timer
+    while(1) {
+        while (GSM.readable()) {
+            char c = GSM.getc();                     //lo obtenido en GSM se guarda en la variable c como caracter
+            if (c == '\r' || c == '\n') c = '$';    //si c es igual a un espacio o a un enter, entonces que c pasa a ser $
+            buffer[i++] = c;                       //incrementa la posicion del buffer (count)
+            if(i > count)break;                   //si el contador supera el tamaño del buffer, entonces para
+        }
+        if(i > count)break;
+        if(t.read() > 3) {                       //si el timer supera 3 segundos, retorma fracaso
+            t.stop();
+            t.reset();
+            break;
+        }
+    }
+    wait(0.5);
+    while(GSM.readable()) {  // display the other thing..
+        char c = GSM.getc();
+    }
+    return 0;
+}
+//********************************************************************************
+/* esta funcion de abajo limpia o borra todo un "buffer" de tamaño "count"
+lo revisa elemento por elemento y le mete el caracter null que indica fin de cadena
+no retorna nada
+*/
+//***************************************************************************************
+void cleanBuffer(char *buffer, int count)
+{
+    for(int i=0; i < count; i++) {
+        buffer[i] = '\0';
+    }
+}
+/* esta funcion de abajo envia un comando parametrizado como cadena
+puede ser un comando tipo AT
+*/
+//***************************************************************************************
+void sendCmd(char *cmd)
+{
+    GSM.puts(cmd);
+}
+//****************************************************************************************
+/* esta funcion de abajo espera la respuesta de un comando que debe ser identica a la cadena "resp" y un tiempo timeout"
+si todo sale bien retorna un cero que en la programacion hay que validar
+si algo sale mal ( no se parece o se demora mucho )retorna -1 que debera validarse con alguna expresion logica
+*/
+//***************************************************************************************
+int waitForResp(char *resp, int timeout)
+{
+    int len = strlen(resp);
+    int sum=0;
+    t.start();                   //
+
+    while(1) {
+        if(GSM.readable()) {
+            char c = GSM.getc();              //lo obtenido en GSM se guarda en la variable c como caracter
+            sum = (c==resp[sum]) ? sum+1 : 0;// esta linea de C# sum se incrementa o se hace cero segun c
+            if(sum == len)break;  //ya acabo se sale
+        }
+        if(t.read() > timeout) {  // time out chequea el tiempo minimo antes de salir perdiendo
+            t.stop();
+            t.reset();
+            return -1;
+        }
+    }
+    t.stop();                 // stop timer  antes de retornar
+    t.reset();                    // clear timer
+    while(GSM.readable()) {      // display the other thing..
+        char c = GSM.getc();
+    }
+
+    return 0;
+}
+/* esta funcion de abajo es muy completa e util se encarga de enviar el comando y esperar la respuesta
+si todo sale bien retorna un cero(herencia de las funciones contenedoras) que en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int sendCmdAndWaitForResp(char *cmd, char *resp, int timeout)
+{
+    sendCmd(cmd);
+    return waitForResp(resp,timeout);
+}
+/* esta funcion de abajo chequea que el modem este vivo  envia AT y le contesta con OK y espera 2 segundos
+*/
+//***************************************************************************************
+int powerCheck(void)// este comando se manda para verificar si el modem esta vivo o conectado
+{
+    return sendCmdAndWaitForResp("AT\r\n", "OK", 2);    
+}
+/* esta funcion de abajo chequea el estado de la sim card
+y si todo sale bien retorna un cero que en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int checkSIMStatus(void)
+{
+    char gprsBuffer[30];    
+    int count = 0;
+    cleanBuffer(gprsBuffer,30);
+    while(count < 3) {
+        sendCmd("AT+CPIN?\r\n");
+        readBuffer(gprsBuffer,30);
+        if((NULL != strstr(gprsBuffer,"+CPIN: READY"))) {
+            break;
+        }
+        count++;
+        wait(1);
+    }
+
+    if(count == 3) {
+        return -1;
+    }
+    return 0;
+}
+/* esta funcion de abajo chequea la calidad de la señal
+y si todo sale bien retorna con el valor de señal util o un -1 si no es aceptable, en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int checkSignalStrength(void)
+{
+    char gprsBuffer[100];
+    int index,count = 0;
+    cleanBuffer(gprsBuffer,100);
+    while(count < 3) {
+        sendCmd("AT+CSQ\r\n");
+        readBuffer(gprsBuffer,25);
+        if(sscanf(gprsBuffer, "AT+CSQ$$$$+CSQ: %d", &index)>0) {
+            break;
+        }
+        count++;
+        wait(1);
+    }
+    if(count == 3) {
+        return -1;
+    }
+    return index;
+}
+
+/* esta funcion de abajo inicaliza el modem se compone de un grupo de subfunciones ya definidas previamente
+primero chequea que este vivo
+segundo chequea el estado de la simcard
+tercero chequea la intencidad de señal celular
+cuarto aplica la configuracion
+y si todo sale bien retorna un cero que en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int init()
+{
+    if (0 != sendCmdAndWaitForResp("AT\r\n", "OK", 3)){        //chequea que este vivo, es decir, que responda con 0
+        return -1;                                             // de lo contrario, de vuelve fracaso 
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CNMI=1,1\r\n", "OK", 3)){ //chequea el estado de la simcard, es decir, que responda con 0
+        return -1;                                              // de lo contrario, de vuelve fracaso 
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CMGF=0\r\n", "OK", 3)){  //chequea la intensidad de señal, es decir, que responda con 0
+        return -1;                                              // de lo contrario, de vuelve fracaso 
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CBST=0,0,1\r\n", "OK", 3)){ //aplica la configuracion
+        return -1;                                                // de lo contrario, de vuelve fracaso 
+        }
+        LedVerde=0;                                               //led verde encendido
+        return 0;
+        }
+  
+/* esta funcion de abajo intenta leer un mensaje de texto en formato PDU o HEX
+y si todo sale bien retorna un cero que en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int readSMSpdu(char *message, int index)
+{
+    int i = 0;
+    char gprsBuffer[100];
+    char *p,*s;
+    GSM.printf("AT+CMGR=%d\r\n",index);
+    cleanBuffer(gprsBuffer,100);
+    readBuffer(gprsBuffer,100);
+    if(NULL == ( s = strstr(gprsBuffer,"+CMGR"))) {
+        return -1;
+    }
+    if(NULL != ( s = strstr(gprsBuffer,"+32"))) {
+        p = s + 6;
+        while((*p != '$')&&(i < 5)) {
+            message[i++] = *(p++);
+        }
+        message[i] = '\0';
+    }
+    return 0;
+}
+/* esta funcion de abajo borra mensajes SMS del modem
+y si todo sale bien retorna un cero que en la programacion hay que validar
+con alguna expresion logica
+*/
+//***************************************************************************************
+int deleteSMS(int index)
+{
+    char cmd[32];
+    snprintf(cmd,sizeof(cmd),"AT+CMGD=%d\r\n",index);
+    sendCmd(cmd);
+    return 0;
+}
+//************************************************************************************
+     
+//RUTINA PRINCIPAL*******************************************************************************************
+int main(void)
+       {
+       //configuramos los puertos seriales    
+       GSM.baud(9600);//configura los baudios de la FRDMKL25Z en 9600
+       GSM.format(8,Serial::None,1); //configura el formato de los datos de la UART     
+       //apagamos los 3 leds
+       LedVerde=1;
+       LedRojo=1;
+       LedAzul=1;
+       //quito el eco del modem
+       GSM.printf("ATE0\r\n");
+       pc.printf("ATE0\r\n");
+       for(i=0;i<6;i++){
+          GSM.printf("AT+CMGD=%d\r\n",i);
+          wait(0.2);
+          }
+       //cleanBuffer(buffer,10);
+       //definicion de algunas variables
+       lenpack=6;  //tamaño de "ALARMA"
+       //Configuro el Modem, le doy solo 10 intentos si esos fracasan se bloquea y prende intermitente el led rojo
+inicio:if(init()<0){
+       intentos++;
+       if (intentos==10){goto loop1;}
+       goto inicio;
+       } 
+       //cleanBuffer(buffer,50);
+       //inicia el programa ciclico
+       //esperar señales de alarma por boton1
+       //se envia "Alarma1"
+       //al telefono que envio mensaje antes
+   
+//*********************************************************************************************************************
+while(1){ 
+         if (button1.falling()) // cuando se oprima el boton de PTC12
+         { 
+          wait(2);
+           if (!button1)
+           {
+           //inicia el envio de un sms    
+           index=19;
+           GSM.printf("AT+CMGS=%d\r\n",index); //envia el index (mensaje a transmitir)
+           wait(0.2);
+           GSM.printf("0011000A91"); //imprime el relleno 
+           GSM.printf("%s",tel);     //identifica el numero del remitente (invertido por pares)
+           GSM.printf("0000AA07417658DE0EC7"); //segundo relleno+la cantidad de septetos+1+el mensaje(gallina cafe)
+           GSM.printf("\r\n");       //espacio y enter
+           wait(0.2);
+           GSM.putc(0x1A);          //el mensaje ya fue enviado con esto
+           for(i=0;i<6;i++){
+               LedVerde=1;
+               wait(0.5);
+               LedVerde=0;
+               wait(0.5);
+               }
+           }
+         }  
+      
+
+
+       //inicia la recepcion de un mensaje de texto
+       if (GSM.readable()) {
+            readBuffer(buffer,100);
+            pc.printf("%s\r\n",buffer);
+            for(i=0;i<5;i++)
+            {
+            resp[i]=buffer[i];
+            }  
+            
+             
+            pc.printf("%s\r\n",resp);
+            if(strcmp("$$+CM",resp) == 0){  //COMPARA resp con "+CMTI"
+                pc.printf("llego MSG\r\n");     
+                cleanBuffer(buffer,10); //limpia el buffer
+                wait(0.5);
+                GSM.printf("AT+CMGL=0\r\n");//envio comando para leer mensaje
+                pc.printf("AT+CMGL=0\r\n");//imprime que abrio los mensajes entrantes
+                //if (GSM.readable()) {
+                GSM.printf("AT+CMGD=0\r\n");    
+                readBuffer(buffer,100);
+                pc.printf("%s\r\n",buffer);
+                wait(5);
+                   //leer telefono
+                for(i=0;i<10;i++){
+                       tel[i]=buffer[i+40]; //toma el numero de celular apartir de la cadena 
+                       }
+                pc.printf("%s-\r\n",tel);   //imprime el numero de celular  
+                //leer tamaño
+                   for(i=0;i<2;i++){
+                       tam[i]=buffer[i+68];
+                   }
+                   pc.printf("%s-\r\n",tam);        
+                   //leer mensaje
+                    for(i=0;i<14;i++){
+                       msg[i]=buffer[i+70]; 
+                   }
+                   pc.printf("%s-\r\n",msg);        
+                   //decodificar mensaje
+                   //comparar mensaje
+                   if(strcmp("417658DE0EC700",msg) == 0){  //COMPARA resp con "417658DE0EC700" que es Alarma1
+                   //Como necesitamos un mensaje en especifico, comparamos si el mensaje que llego es igual a Alarma1 (Compara cadena en formato string)
+                   LedVerde=1;
+                   LedAzul=0;
+                   wait(15);
+                   LedAzul=1;
+                   LedVerde=0;
+                   }
+                   if(strcmp("417658DE0ECB00",msg) == 0){  //COMPARA resp con "417658DE0ECB00" que es Alarma2
+                   LedVerde=1;
+                   LedRojo=0;
+                   wait(15);
+                   LedRojo=1;
+                   LedVerde=0;
+                   }
+                   
+                   
+                   //ejecurar orden  //ya se ejecuto
+                   //08-D6379B1E569763  esto es Voltaje1
+                   
+                   
+                   cleanBuffer(buffer,100);
+                               
+                }
+            }
+               
+
+        }
+
+
+//**********************************************************************************************************************           
+loop1: LedRojo=0;
+       wait(0.3);
+       LedRojo=1;
+       wait(0.3);  
+       goto loop1;
+ 
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Nov 25 02:12:44 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/9296ab0bfc11
\ No newline at end of file