File content as of revision 3:73adce5a8603:

//  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 EL CODIGO NO FUNCIONA!!!!!! POSIBLEMENTE SEA POR LOS OPERADORES, RECIBE MENSAJES MAS NO ENVÍA!
//   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; //función que sirve para arrancar, parar y crear la medición de pequeños intervalos de tiempo
DigitalOut LedVerde(LED2);
DigitalOut LedRojo(LED1);
DigitalOut LedAzul(LED3);
DebouncedIn button1(PTC12); // con el switche iniciamos en envio del mensaje 
Serial GSM(PTE0,PTE1); //se configura la interfaz del módem en la tarjeta 
Serial pc(USBTX,USBRX);//Configura puerto USB a la consola serial del PC conectado.
void Rx_interrupt(); // se define la función sin retorno
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 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()){
     char1 = GSM.getc();} // se obtienen los datos enviados por el cel
     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) //leeemos todo lo que se encuentre en el buffer
{
    int i=0; 
    t.start();  // start timer
    while(1) {
        while (GSM.readable()) {
            char c = GSM.getc();
            if (c == '\r' || c == '\n') c = '$';
            buffer[i++] = c;
            if(i > count)break;
        }
        if(i > count)break;
        if(t.read() > 3) {
            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) //comando tipo AT
{
    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();
            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)){
        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 (0 != sendCmdAndWaitForResp("AT+CBST=0,0,1\r\n", "OK", 3)){
        return -1;
        }
        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
*/
//***************************************************************************************
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 transmisión     
       //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"); //IMPRIME EN TERMINAL QUE SE BORRA EL ECO
       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 envio de msj ubicado en PTC12
         { 
          wait(2);
           if (!button1) //condición de negado del boton por eje: boton=1--> !boton1=0
           {
           //inicia el envio de un sms    
           index=21;
           GSM.printf("AT+CMGS=%d\r\n",index); //Envia el encabezado con la longitud de lo que se va a transamitir (INDEX)
           wait(0.2); //Espero 0.2 segundos esperando que en terminal salga ">" esperando el mensaje
           GSM.printf("0011000A91"); //Pone el primer relleno del mensaje que es el mismo para todos
           GSM.printf("%s",tel);    //Este identifica el numero que le envio un mensaje con anterioridad (este ya esta invertido por pares) y es colocado luego del primer rello.
           GSM.printf("0000AA07417658DE0EC7"); //Aquí esta separado en tres partes, el segundo relleno, la cantidad de septetos+1 y 
           //el mensaje, en este caso es fijo porque el mensaje es el mismo siempre, de no ser así se separan y se pone en variable
           //la cantidad de septetos+1 y el mensaje.
           GSM.printf("\r\n");//devuelve el carrier y da enter
           wait(0.2); //Esperamos un poco antes de enviar ctrl+z
           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");     //Avisa en pantalla si ha recibido un mensaje mas aun no es comparado
                cleanBuffer(buffer,10); //Limpia el buffer
                wait(0.5);
                GSM.printf("AT+CMGL=0\r\n");//envio comando para leer mensaje, este abre por así decir la "bandeja de entrada"
                pc.printf("AT+CMGL=0\r\n");//Avisa 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]; //Con la cadena que llega de la recepcion del mensaje, este toma de ahi el telefono quien le envio SMS
                       }
                pc.printf("%s-\r\n",tel);   //Imprime el numero telefonico     
                //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]; //Almacena el mensaje
                   }
                   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); //Limpia nuevamente el buffer para futuras recepciones de mas SMS
                               
                }
            }
               

        }


//**********************************************************************************************************************           
loop1: LedRojo=0;
       wait(0.3);
       LedRojo=1;
       wait(0.3);  
       goto loop1;
 
}