Revision 2:44e88001ce29, committed 2015-11-24

Comitter:

GermanD

Date:

Tue Nov 24 05:19:14 2015 +0000

Parent:

1:6b506dde0a6e

Commit message:

Trabajo, en el cual se envia un mensaje al celular, el cual actua como modem, y en el mensaje esta para activar una alarma segun el mensaje que se envie

Changed in this revision

diff -r 6b506dde0a6e -r 44e88001ce29 main.cpp
--- a/main.cpp	Tue Dec 02 03:41:43 2014 +0000
+++ b/main.cpp	Tue Nov 24 05:19:14 2015 +0000
@@ -18,13 +18,20 @@
 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];
 char DE[50];
 char buffer[100];
+char buffermsg[100];
+char buffer1[100];
 char datos[100];
-char NUMBER[13];    
+char NUMBER[13]; 
+char resp[6];  
+char CMT[]="+CMTI";
+char tam[2];
 int index;
 int count;
 int i = 0;
@@ -38,8 +45,8 @@
 //Flush serial para el buffer
 void FlushGSM(void) { 
 char1 = 0;
- while (GSM.readable()){
-     char1 = GSM.getc();}
+ while (GSM.readable()){  // lee lo que le entra por el puerto GSM
+     char1 = GSM.getc();} // y lo pone en la variable hcar1
      return;}
 
 void callback() {
@@ -47,22 +54,26 @@
     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();
+        while (GSM.readable()) { // leelo que está entrando por el GSM
+            char c = GSM.getc(); //  asigna el valor que entra a c
             if (c == '\r' || c == '\n') c = '$';
-            buffer[i++] = c;
-            if(i > count)break;
+            buffer[i++] = c; // aumenta la posición del buffer y coloca c en ella
+            if(i > count)break; // si i es mayor que lo que lee para y sale del ciclo infinito
         }
-        if(i > count)break;
-        if(t.read() > 3) {
-            t.stop();
-            t.reset();
+        if(i > count)break; 
+        if(t.read() > 3) { // si se demora mas de 3 segundos 
+            t.stop();      // para el reloj y 
+            t.reset();     // lo resetea
             break;
         }
     }
@@ -72,9 +83,9 @@
     }
     return 0;
 }
-
+//********************************************************************************
 /* esta funcion de abajo limpia o borra todo un "buffer" de tamaño "count"
-lo revisa uno por un elemento y le mete el caracter null que indica fin de cadena
+lo revisa elemento por elemento y le mete el caracter null que indica fin de cadena
 no retorna nada
 */
 //***************************************************************************************
@@ -85,12 +96,14 @@
     }
 }
 /* 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
@@ -98,20 +111,20 @@
 //***************************************************************************************
 int waitForResp(char *resp, int timeout)
 {
-    int len = strlen(resp);
+    int len = strlen(resp); // mide la longitud del string
     int sum=0;
     t.start();
 
     while(1) {
-        if(GSM.readable()) {
-            char c = GSM.getc();
+        if(GSM.readable()) { 
+            char c = GSM.getc();  // pone lo que le entra por GSM en la variable c
             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;
+            return -1;  // devuelve -1 como "fallo"
         }
     }
     t.stop();                 // stop timer  antes de retornar
@@ -150,7 +163,7 @@
     int count = 0;
     cleanBuffer(gprsBuffer,30);
     while(count < 3) {
-        sendCmd("AT+CPIN?\r\n");
+        sendCmd("AT+CPIN?\r\n"); // envia el comando AT para ver que le devuelve
         readBuffer(gprsBuffer,30);
         if((NULL != strstr(gprsBuffer,"+CPIN: READY"))) {
             break;
@@ -158,14 +171,14 @@
         count++;
         wait(1);
     }
-
-    if(count == 3) {
+// si la simcard no responde envia -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 cun el valor de señal util o un -1 si nop es aceptable, en la programacion hay que validar
+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
 */
 //***************************************************************************************
@@ -173,47 +186,21 @@
 {
     char gprsBuffer[100];
     int index,count = 0;
-    cleanBuffer(gprsBuffer,100);
+    cleanBuffer(gprsBuffer,100); // siempre hacemos esto para garantizar que el buffer esté limpio y no haga nada raro
     while(count < 3) {
-        sendCmd("AT+CSQ\r\n");
-        readBuffer(gprsBuffer,25);
-        if(sscanf(gprsBuffer, "AT+CSQ$$$$+CSQ: %d", &index)>0) {
+        sendCmd("AT+CSQ\r\n");  // envia un comando al odem y para verificar si la señal está buena
+        readBuffer(gprsBuffer,25); // lee lo que devuelve el modem desde el buffer
+        if(sscanf(gprsBuffer, "AT+CSQ$$$$+CSQ: %d", &index)>0) { // verifica que el nivel de cobertura sea bueno
             break;
         }
         count++;
         wait(1);
     }
     if(count == 3) {
-        return -1;
+        return -1; // si no es lo esperado devuelve un erro con -1
     }
     return index;
 }
-/* esta funcion de abajo configura el modem de forma inicial con comandas AT
-y si todo sale bien retorna un cero que en la programacion hay que validar
-con alguna expresion logica pero si algo sale mal retorna un -1
-*/
-//***************************************************************************************
-/*int settingSMS() //esta funcion se invoca para configurar el modem al principio
-{
-    if(0 != sendCmdAndWaitForResp("AT\r\n", "OK", 1)) {
-        return -1;
-    }
-    if(0 != sendCmdAndWaitForResp("AT+CNMI=1,1\r\n", "OK", 1)) {
-        return -1;
-    }
-    if(0 != sendCmdAndWaitForResp("AT+CMGF=0\r\n", "OK", 1)) {
-        return -1;
-    }
-    if(0 != sendCmdAndWaitForResp("ATE\r\n", "OK", 1)) {
-        return -1;
-    }
-    if(0 != sendCmdAndWaitForResp("CBST=0,0,1\r\n", "OK", 1)) {
-        return -1;
-    }
-    return 0;
-}
-*/
-
 
 /* esta funcion de abajo inicaliza el modem se compone de un grupo de subfunciones ya definidas previamente
 primero chequea que este vivo
@@ -226,20 +213,22 @@
 //***************************************************************************************
 int init()
 {
-    for(int i = 0; i < 3; i++){
-        sendCmdAndWaitForResp("AT\r\n", "OK", 1);
-        wait(0.5);
-    }
-    if(0 != checkSIMStatus()) {
+    if (0 != sendCmdAndWaitForResp("AT\r\n", "OK", 3)){
+        return -1;
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CNMI=1,1\r\n", "OK", 3)){
+        return -1;
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CMGF=0\r\n", "OK", 3)){
         return -1;
-    }
-    if(checkSignalStrength()<1) {
+        }
+    if (0 != sendCmdAndWaitForResp("AT+CBST=0,0,1\r\n", "OK", 3)){
         return -1;
-    }
-   
-    GSM.attach(&Rx_interrupt, Serial::RxIrq);
-    return 0;
-}
+        }
+        LedVerde=0;
+        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
@@ -277,104 +266,149 @@
     sendCmd(cmd);
     return 0;
 }
-//***0*********************************************************************************
-
-// Interupt Routine to read in data from serial port
-void Rx_interrupt(){
-     }
-     /*
-     readBuffer(buffer,6);
-     if(strncmp(buffer, "+CMTI", 5)){
-     wait(1);
-     GSM.printf("AT+CMGL=%d\r\n",0);
-     readBuffer(buffer,100);}
-     if(strncmp(buffer, "+CMGL:", 5)){  
-     for (i=0;i<31;i++){
-     buffer[5+i]=c;  // 32 de basura
-     }
-     }
-     for (i=0;i<10;i++){
-     buffer[36+i]=tel[i];  // numero telefonico
-     }
-     for (i=0;i<18;i++){
-     buffer[46+i]=c;  // 18 de basura
-     }
-     for (i=0;i<2;i++){
-     buffer[64+i]=tel[i];  // tamaño de septetos
-     }
-     for (i=0;i<30;i++){
-     buffer[66+i]=DE[i];  // datos en octetos hex
-     if (buffer[i]=='\0'){
-     }
-     */
+//************************************************************************************
      
-
+//RUTINA PRINCIPAL*******************************************************************************************
 int main(void)
-       { 
-           
-       //NVIC_DisableIRQ(UART1_IRQn);       
+       {
+       //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"
-       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
-       //configuro modem GSM
-       GSM.printf("AT\r\n");
-       wait(0.5);
-       GSM.printf("AT+CNMI=1,1\r\n");
-       wait(0.5);
-       GSM.printf("AT+CMGF=0\r\n");
-       wait(0.5);
-       GSM.printf("ATE\r\n");
-       wait(0.5);
-       GSM.printf("CBST=0,0,1\r\n");
-       wait(0.5);  
-       LedVerde=0;     
-      
-       //if(0!= init()){  //se configura y chequea el modem GSM 
-       // LedRojo=0;
-       //}
-       while(1){
-        if (button1.falling())
-        { LedVerde=1;
+       //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())
+         { 
           wait(2);
            if (!button1)
-           {LedVerde=0;
-           index=20;
-       //GSM.printf("AT+CNMI=1,1\r\n"); //configuracion inicial del MODEM!
-       GSM.printf("AT+CMGS=%d\r\n",index);
-       wait(0.2);
-       GSM.printf("0011000A9113223717370000AA08416650DA0C8262"); //esto es "ALARMA 1"
-       wait(0.5);
-       GSM.putc((char)0x1A); //esto es controlZ   
-       LedVerde=1;
-       LedRojo=0;  //lo prendo
-       wait(3);
-       LedRojo=1;  //lo apago
-       LedVerde=0;          
-       }
-    
-}      
-       if(GSM.readable()) {       //USE ESTE FRAGMENTO DE CODIGO PARA LEER LO QUE EL CELULAR RESPONDE
-            while(GSM.readable()) {
-                char c = GSM.getc();
-                buffer[count++] = c;
-                if(count == 64) break;
+           {
+           //inicia el envio de un sms    
+           index=19;
+           GSM.printf("AT+CMGS=%d\r\n",index);
+           wait(0.2);
+           GSM.printf("0011000A91");
+           GSM.printf("%s",tel); 
+           GSM.printf("0000AA07417658DE0EC7");
+           GSM.printf("\r\n");
+           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];
+            }  
+            
+             //el programa empieza a verificar que le llego el mensaje
+             //para que le llegue la cadena larga de caracteres, hay se detecta el numero telefonico
+             //ya que en la cadena nos envia caracteres "basura" que no necesitamos
+             
+            pc.printf("%s\r\n",resp);
+            if(strcmp("$$+CM",resp) == 0){  //COMPARA resp con "+CMTI"
+                pc.printf("llego MSG\r\n");
+                cleanBuffer(buffer,10);
+                wait(0.5);
+                GSM.printf("AT+CMGL=0\r\n");//envio comando para leer mensaje
+                pc.printf("AT+CMGL=0\r\n");
+                //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];
+                       }
+                pc.printf("%s-\r\n",tel);        
+                //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];
+                   }
+                   
+                   //lee el resto del mensaje de los valores que necesitamos al final de la cadena para hacer el codigo
+                   
+                   pc.printf("%s-\r\n",msg);        
+                   //decodificar mensaje
+                   //comparar mensaje
+                   if(strcmp("417658DE0EC700",msg) == 0){  //COMPARA resp con "417658DE0EC700" que es Alarma1
+                   LedVerde=1;
+                   LedAzul=0;
+                   wait(15);
+                   LedAzul=1;
+                   LedVerde=0;
+                   }
+                   // cuando se le envia el mensaje conociendo lo anterior, y si el mensaje es prender la alarma, 
+                   // este preunde el led corresponiente indicando que se activo la alarma, con el mensaje que le llego al telefono
+                   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
+                   //finalmente limpa la memoria para que pueda recibir nuevos mensajes
+                   
+                   cleanBuffer(buffer,100);
+                               
+                }
             }
-            pc.puts(buffer);
-                  
-            
-            for(int i = 0; i < count; i++) {
-                buffer[i] = NULL;
-            }
-            
-            count = 0;
-            
-            }
-   
+               
+
+        }
+
+
+//**********************************************************************************************************************           
+loop1: LedRojo=0;
+       wait(0.3);
+       LedRojo=1;
+       wait(0.3);  
+       goto loop1;
+ 
 }
-} 
-
-// buffer[i] contiene lo que regresa
\ No newline at end of file