main.cpp

00001 //  Programa para enviar desde la FRDMKL25Z un mensaje de texto en formatp PDU
00002 //   Como modem usa un celular SIEMENS a56i
00003 //   ENVIAR -----la palabra "ALARMA 1"
00004 //   conector del siemens cable verde es RX conectelo a PTE0  cable blanco es TX conectelo a PTE1
00005 #include "mbed.h"
00006 #include "DebouncedIn.h"
00007 #include "stdio.h"
00008 #include "string.h"
00009 Timer t; //función que sirve para arrancar, parar y crear la medición de pequeños intervalos de tiempo
00010 DigitalOut LedVerde(LED2);
00011 DigitalOut LedRojo(LED1);
00012 DigitalOut LedAzul(LED3);
00013 DebouncedIn button1(PTC12); // Se inicia el envío del mensaje 
00014 Serial GSM(PTE0,PTE1); //Configura el puerto UART de la tarjeta
00015 Serial pc(USBTX,USBRX);//Configura puerto USB a la consola 
00016 void Rx_interrupt();
00017 int position=0;
00018 int intentos=0;
00019 int lenpack=6;
00020 int ret=1;
00021 int longi=0;
00022 char tel[11];
00023 char DE[50];
00024 char buffer[100];
00025 char buffermsg[100];
00026 char buffer1[100];
00027 char datos[100];
00028 char NUMBER[13]; 
00029 char resp[6];  
00030 char CMT[]="+CMTI";
00031 char tam[2];
00032 int index;
00033 int count;
00034 int i = 0;
00035 int j = 0;
00036 int c=0;
00037 unsigned char CtrlZ = 0x1A;  // comodin de emision controlZ
00038 bool Flag = false; // bandera 
00039 char r[]=""; //Cadena de recepcion de la trama PDU si se usa!!
00040 char msg[256];
00041 char char1;
00042 //Flush serial para el buffer
00043 void FlushGSM(void) { 
00044 char1 = 0;
00045  while (GSM.readable()){
00046      char1 = GSM.getc();} // Comando para obtener los datos enviados por el celular
00047      return;}
00048 
00049 void callback() {
00050     // Note: you need to actually read from the serial to clear the RX interrupt
00051     pc.printf("%c\n", GSM.getc()); // Enviar datos al Pc por Serial
00052     
00053 }
00054 //****************************************************************************************************************
00055 //esta funcion de abajo lee todo un bufer hasta encontrar CR o LF y el resto lo rellena de
00056 //$, count es lo que va a leer.Lo leido lo mete en buffer que es una cadena previamente definida
00057 //incorpora medida de tiempo si se demora mas de tres segundos retorna fracaso con -1
00058 //**************************************************************************************************************** 
00059 int readBuffer(char *buffer,int count) //Se lee todo lo que halla en el Buffer
00060 {
00061     int i=0; 
00062     t.start();  // start timer
00063     while(1) {
00064         while (GSM.readable()) {
00065             char c = GSM.getc();
00066             if (c == '\r' || c == '\n') c = '$';
00067             buffer[i++] = c;
00068             if(i > count)break;
00069         }
00070         if(i > count)break;
00071         if(t.read() > 3) {
00072             t.stop();
00073             t.reset();
00074             break;
00075         }
00076     }
00077     wait(0.5);
00078     while(GSM.readable()) {  // display the other thing..
00079         char c = GSM.getc();
00080     }
00081     return 0;
00082 }
00083 //********************************************************************************
00084 /* esta funcion de abajo limpia o borra todo un "buffer" de tamaño "count"
00085 lo revisa elemento por elemento y le mete el caracter null que indica fin de cadena
00086 no retorna nada
00087 */
00088 //***************************************************************************************
00089 void cleanBuffer(char *buffer, int count)
00090 {
00091     for(int i=0; i < count; i++) {
00092         buffer[i] = '\0';
00093     }
00094 }
00095 /* esta funcion de abajo envia un comando parametrizado como cadena
00096 puede ser un comando tipo AT
00097 */
00098 //***************************************************************************************
00099 void sendCmd(char *cmd)
00100 {
00101     GSM.puts(cmd);
00102 }
00103 //****************************************************************************************
00104 /* esta funcion de abajo espera la respuesta de un comando que debe ser identica a la cadena "resp" y un tiempo timeout"
00105 si todo sale bien retorna un cero que en la programacion hay que validar
00106 si algo sale mal ( no se parece o se demora mucho )retorna -1 que debera validarse con alguna expresion logica
00107 */
00108 //***************************************************************************************
00109 int waitForResp(char *resp, int timeout)
00110 {
00111     int len = strlen(resp);
00112     int sum=0;
00113     t.start();
00114 
00115     while(1) {
00116         if(GSM.readable()) {
00117             char c = GSM.getc();
00118             sum = (c==resp[sum]) ? sum+1 : 0;// esta linea de C# sum se incrementa o se hace cero segun c
00119             if(sum == len)break;  //ya acabo se sale
00120         }
00121         if(t.read() > timeout) {  // time out chequea el tiempo minimo antes de salir perdiendo
00122             t.stop();
00123             t.reset();
00124             return -1;
00125         }
00126     }
00127     t.stop();                 // stop timer  antes de retornar
00128     t.reset();                    // clear timer
00129     while(GSM.readable()) {      // display the other thing..
00130         char c = GSM.getc();
00131     }
00132 
00133     return 0;
00134 }
00135 /* esta funcion de abajo es muy completa e util se encarga de enviar el comando y esperar la respuesta
00136 si todo sale bien retorna un cero(herencia de las funciones contenedoras) que en la programacion hay que validar
00137 con alguna expresion logica
00138 */
00139 //***************************************************************************************
00140 int sendCmdAndWaitForResp(char *cmd, char *resp, int timeout)
00141 {
00142     sendCmd(cmd);
00143     return waitForResp(resp,timeout);
00144 }
00145 /* esta funcion de abajo chequea que el modem este vivo  envia AT y le contesta con OK y espera 2 segundos
00146 */
00147 //***************************************************************************************
00148 int powerCheck(void)// este comando se manda para verificar si el modem esta vivo o conectado
00149 {
00150     return sendCmdAndWaitForResp("AT\r\n", "OK", 2);    
00151 }
00152 /* esta funcion de abajo chequea el estado de la sim card
00153 y si todo sale bien retorna un cero que en la programacion hay que validar
00154 con alguna expresion logica
00155 */
00156 //***************************************************************************************
00157 int checkSIMStatus(void)
00158 {
00159     char gprsBuffer[30];
00160     int count = 0;
00161     cleanBuffer(gprsBuffer,30);
00162     while(count < 3) {
00163         sendCmd("AT+CPIN?\r\n");
00164         readBuffer(gprsBuffer,30);
00165         if((NULL != strstr(gprsBuffer,"+CPIN: READY"))) {
00166             break;
00167         }
00168         count++;
00169         wait(1);
00170     }
00171 
00172     if(count == 3) {
00173         return -1;
00174     }
00175     return 0;
00176 }
00177 /* esta funcion de abajo chequea la calidad de la señal
00178 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
00179 con alguna expresion logica
00180 */
00181 //***************************************************************************************
00182 int checkSignalStrength(void)
00183 {
00184     char gprsBuffer[100];
00185     int index,count = 0;
00186     cleanBuffer(gprsBuffer,100);
00187     while(count < 3) {
00188         sendCmd("AT+CSQ\r\n");
00189         readBuffer(gprsBuffer,25);
00190         if(sscanf(gprsBuffer, "AT+CSQ$$$$+CSQ: %d", &index)>0) {
00191             break;
00192         }
00193         count++;
00194         wait(1);
00195     }
00196     if(count == 3) {
00197         return -1;
00198     }
00199     return index;
00200 }
00201 
00202 /* esta funcion de abajo inicaliza el modem se compone de un grupo de subfunciones ya definidas previamente
00203 primero chequea que este vivo
00204 segundo chequea el estado de la simcard
00205 tercero chequea la intencidad de señal celular
00206 cuarto aplica la configuracion
00207 y si todo sale bien retorna un cero que en la programacion hay que validar
00208 con alguna expresion logica
00209 */
00210 //***************************************************************************************
00211 int init()
00212 {
00213     if (0 != sendCmdAndWaitForResp("AT\r\n", "OK", 3)){
00214         return -1;
00215         }
00216     if (0 != sendCmdAndWaitForResp("AT+CNMI=1,1\r\n", "OK", 3)){
00217         return -1;
00218         }
00219     if (0 != sendCmdAndWaitForResp("AT+CMGF=0\r\n", "OK", 3)){
00220         return -1;
00221         }
00222     if (0 != sendCmdAndWaitForResp("AT+CBST=0,0,1\r\n", "OK", 3)){
00223         return -1;
00224         }
00225         LedVerde=0;
00226         return 0;
00227         }
00228   
00229 /* esta funcion de abajo intenta leer un mensaje de texto en formato PDU o HEX
00230 y si todo sale bien retorna un cero que en la programacion hay que validar
00231 con alguna expresion logica
00232 */
00233 //***************************************************************************************
00234 int readSMSpdu(char *message, int index)
00235 {
00236     int i = 0;
00237     char gprsBuffer[100];
00238     char *p,*s;
00239     GSM.printf("AT+CMGR=%d\r\n",index);
00240     cleanBuffer(gprsBuffer,100);
00241     readBuffer(gprsBuffer,100);
00242     if(NULL == ( s = strstr(gprsBuffer,"+CMGR"))) {
00243         return -1;
00244     }
00245     if(NULL != ( s = strstr(gprsBuffer,"+32"))) {
00246         p = s + 6;
00247         while((*p != '$')&&(i < 5)) {
00248             message[i++] = *(p++);
00249         }
00250         message[i] = '\0';
00251     }
00252     return 0;
00253 }
00254 /* esta funcion de abajo borra mensajes SMS del modem
00255 y si todo sale bien retorna un cero que en la programacion hay que validar
00256 con alguna expresion logica
00257 */
00258 //***************************************************************************************
00259 int deleteSMS(int index)
00260 {
00261     char cmd[32];
00262     snprintf(cmd,sizeof(cmd),"AT+CMGD=%d\r\n",index);
00263     sendCmd(cmd);
00264     return 0;
00265 }
00266 //************************************************************************************
00267      
00268 //RUTINA PRINCIPAL*******************************************************************************************
00269 int main(void)
00270        {
00271        //configuramos los puertos seriales    
00272        GSM.baud(9600);//configura los baudios de la FRDMKL25Z en 9600
00273        GSM.format(8,Serial::None,1); //configura el formato de los datos de la transmisión     
00274        //apagamos los 3 leds
00275        LedVerde=1;
00276        LedRojo=1;
00277        LedAzul=1;
00278        //quito el eco del modem
00279        GSM.printf("ATE0\r\n");
00280        pc.printf("ATE0\r\n"); //Se imprime en la terminal del computador si se borro el Eco del Modem
00281        for(i=0;i<6;i++){
00282           GSM.printf("AT+CMGD=%d\r\n",i);
00283           wait(0.2);
00284           }
00285        //cleanBuffer(buffer,10);
00286        //definicion de algunas variables
00287        lenpack=6;  //tamaño de "ALARMA"
00288        //Configuro el Modem, le doy solo 10 intentos si esos fracasan se bloquea y prende intermitente el led rojo
00289 inicio:if(init()<0){
00290        intentos++;
00291        if (intentos==10){goto loop1;}
00292        goto inicio;
00293        } 
00294        //cleanBuffer(buffer,50);
00295        //inicia el programa ciclico
00296        //esperar señales de alarma por boton1
00297        //se envia "Alarma1"
00298        //al telefono que envio mensaje antes
00299    
00300 //*********************************************************************************************************************
00301 while(1){ 
00302          if (button1.falling()) // condición para cuando se oprime el botón para enviar mensajes que se encuentra en el pin PTC12
00303          { 
00304           wait(2); // Tiempo de espera
00305            if (!button1) 
00306            {
00307            //inicia el envio de un sms    
00308            index=19;
00309            GSM.printf("AT+CMGS=%d\r\n",index); //Se envia el encabezado con la longitud de lo que se va a transmitir
00310            wait(0.2); //Tiempo de espera de 0.2 segundos para que el mensaje llegue
00311            GSM.printf("0011000A91"); //Agrega el primer relleno del mensaje
00312            GSM.printf("%s",tel);//Se obtiene el numero del celular que envio el mensaje(invertido por pares)
00313            GSM.printf("0000AA07417658DE0EC7"); //Esto es relleno, la cantidad de septetos+1 y el mensaje fijo en este caso
00314            GSM.printf("\r\n");//devuelve el carrier y se pasa de línea
00315            wait(0.2); //Se espera antes de enviar ctrl+z
00316            GSM.putc(0x1A); //el mensaje ya fue enviado con esto
00317            for(i=0;i<6;i++){
00318                LedVerde=1;
00319                wait(0.5);
00320                LedVerde=0;
00321                wait(0.5);
00322                }
00323            }
00324          }  
00325       
00326 
00327 
00328        //inicia la recepcion de un mensaje de texto
00329        if (GSM.readable()) {
00330             readBuffer(buffer,100);
00331             pc.printf("%s\r\n",buffer);
00332             for(i=0;i<5;i++)
00333             {
00334             resp[i]=buffer[i];
00335             }  
00336              
00337             pc.printf("%s\r\n",resp);
00338             if(strcmp("$$+CM",resp) == 0){//COMPARA resp con "+CMTI"
00339                 pc.printf("llego MSG\r\n");//Avisa en el Pc si se ha recibido un mensaje
00340                 cleanBuffer(buffer,10); //Se limpia el buffer
00341                 wait(0.5); // Tiempo de espera de 0.5 segundos
00342                 GSM.printf("AT+CMGL=0\r\n");//Se envia el comando para leer mensaje 
00343                 pc.printf("AT+CMGL=0\r\n");//Este avisa que  se abren los mensajes entrantes
00344                 //if (GSM.readable()) {
00345                 GSM.printf("AT+CMGD=0\r\n");    
00346                 readBuffer(buffer,100);
00347                 pc.printf("%s\r\n",buffer);
00348                 wait(5);
00349                    //leer telefono
00350                 for(i=0;i<10;i++){
00351                        tel[i]=buffer[i+40];//Se coge el telefono que envio SMS
00352                        }
00353                 pc.printf("%s-\r\n",tel);//Imprime el numero telefonico     
00354                 //leer tamaño
00355                    for(i=0;i<2;i++){
00356                        tam[i]=buffer[i+68];
00357                    }
00358                    pc.printf("%s-\r\n",tam);        
00359                    //leer mensaje
00360                     for(i=0;i<14;i++){
00361                        msg[i]=buffer[i+70]; //Se almacena el mensaje
00362                    }
00363                    pc.printf("%s-\r\n",msg);        
00364                    //decodificar mensaje
00365                    //comparar mensaje
00366                    if(strcmp("417658DE0EC700",msg) == 0){  //COMPARA resp con "417658DE0EC700" que es Alarma1
00367                    //Como necesitamos un mensaje en especifico, comparamos si el mensaje que llego es igual a Alarma1 (Compara cadena en formato string)
00368                    LedVerde=1;
00369                    LedAzul=0;
00370                    wait(15);
00371                    LedAzul=1;
00372                    LedVerde=0;
00373                    }
00374                    if(strcmp("417658DE0ECB00",msg) == 0){  //COMPARA resp con "417658DE0ECB00" que es Alarma2
00375                    LedVerde=1;
00376                    LedRojo=0;
00377                    wait(15);
00378                    LedRojo=1;
00379                    LedVerde=0;
00380                    }
00381                    
00382                    
00383                    //ejecurar orden  //ya se ejecuto
00384                    //08-D6379B1E569763  esto es Voltaje1
00385                    
00386                    
00387                    cleanBuffer(buffer,100); //Se limpia el buffer para otra nueva recepción
00388                                
00389                 }
00390             }
00391                
00392 
00393         }
00394 
00395 
00396 //**********************************************************************************************************************           
00397 loop1: LedRojo=0;
00398        wait(0.3);
00399        LedRojo=1;
00400        wait(0.3);  
00401        goto loop1;
00402  
00403 }