File content as of revision 5:7801f913384e:

#include "modem.h"

modemStatus modemCom::status;
char* modemCom::bufIn; //Ponteiro para buffer de entrada do modem;
uint32_t modemCom::timeOutModem;
bool modemCom::atendendoWebServer;
bool modemCom::exibeEntradaPacote;
int16_t numeroDeBytesPorEnvio;
uint8_t connID;
uint16_t IPDNumBytes;
bool enviaSendData;
char *bufInPtr;
bool mudaRede = false;

void modemCom::atendeSRING(uint8_t conId){           
            pc.printf("Atendendo a conexao entrante.\n");
            modemCom::status.socketEntranteAtivo=true;            
            modemCom::status.timeOut = 30;
            modemCom::timeOutModem = 50;            
            while(modemCom::status.timeOut||modemCom::status.NO_CARRIER){
             modemCom::status.timeOut--;
             /*//Aqui devo perguntar e pedir os dados em buffer
             */             
             osDelay(100); 
            }
            
            //Para parar de colocar dentro do arquivo
            modemCom::status.recebendoArquivoDoServer = false;
            
            modemCom::status.serverConnected=0;
            modemCom::timeOutModem = 10;            
                        
            //Fechando o socket                        
            modemCom::closeConnection(conId);
            modemCom::status.socketEntranteAtivo=false;
            modemCom::status.emComunicacao = false;
            modemCom::timeOutModem = 10;
}

bool modemCom::sendBufferCommandMode(uint8_t sId, char *buffer, uint16_t bufferLength){    
    char aux[25];
    uint16_t numeroByteSendoEnviado;

    sprintf(aux,"AT+CIPSEND=%u,%lu\r\n",sId,bufferLength);    
    if(modemCom::sendToModem(aux,1,&modemCom::status.PROMPT_ENVIO_COMMAND_MODE,2000,10)) {    
        for(numeroByteSendoEnviado = 0; numeroByteSendoEnviado<bufferLength; numeroByteSendoEnviado++) {            
            modem.printf("%c",buffer[numeroByteSendoEnviado]);            
            #ifdef xereta_modem
                pc.printf("%c",buffer[numeroByteSendoEnviado]);
            #endif
        }        
        numeroByteSendoEnviado = modemCom::sendToModem(NULL,1,&modemCom::status.SEND_OK,5000,1);
    }else{
        numeroByteSendoEnviado = false;   //Reaproveitando numeroByteSendoEnviado para resultado de retorno
     }
    return numeroByteSendoEnviado; //Reaproveitando numeroByteSendoEnviado para resultado de retorno
}   

void modemCom::leMAC(void)
{
    char *ptr;    
    if(modemCom::sendToModem("AT+CIPSTAMAC?\r\n",1,&modemCom::status.OK,250,20)){
        //resposta: +CIPSTAMAC:"18:fe:34:f4:5f:c4"
        ptr = strtok(bufModem.getRowBuffer(),"\"");
        ptr = strtok(NULL,"\"");
        if(ptr) {
            strcpy(modemCom::status.MAC,ptr);
            pc.printf("Lido MAC <%s>.\n",modemCom::status.MAC);
        }
    }
}

bool modemCom::getSocketInfo(uint8_t sId){
    bool retorno=false;
    sId++; //Para transformar de indice C para o índice usado no modem;
    switch(sId){
        case 1:
                retorno=modemCom::sendToModem("AT#SI=1\r",1,&modemCom::status.OK,300,1);
            break;    
        case 2:
                retorno=modemCom::sendToModem("AT#SI=2\r",1,&modemCom::status.OK,300,1);
            break;                
    }
    return retorno;
}

bool modemCom::writeStatusToSD(void){
    char aux[30];
    int16_t RSSI;
    RSSI = modemCom::getRSSI();
    sdCardBuf.del();
    sdCardBuf.fill("log{status:ip=255.255.255.255;csq=",34);
    
    sprintf(aux,"%d",RSSI);
    sdCardBuf.fill(aux,strlen(aux));
    
    sprintf(aux,";imsi=%s}log",modemCom::status.MAC);    
    sdCardBuf.fill(aux,strlen(aux));
    
    if(!sdCard::arquivoAberto()){
        sdCard::insereDadosArquivo(&sdCard::armazenamento,sdCardBuf.get(),sdCardBuf.getLength());
    }
}

bool modemCom::montaStatus(void)
{
    if(sdCard::abreArquivo(&sdCard::status,"w")) {                
        fprintf(sdCard::status.fp,"log{status:ip:255.255.255.255;csq:30;imsi:%s}log",modemCom::status.MAC);        
        sdCard::fechaArquivo(&sdCard::status);        
        sdCard::exibeArquivo(&sdCard::status);
    } else {
        return 0;
    }
    return true;
}



uint8_t modemCom::enviaDados(char tipoDado)
{
    uint8_t result=0;
    modemCom::status.emComunicacao = true;

    switch(tipoDado) {
        case dadosArmazenados:
            if(!sdCard::preparaEnvio()){
                pc.printf("Nao foi possivel preparar o envio.\n");
                return false;                
            }
            if(sdCard::envio.bytes==0) {
                sdCard::getFileTam(&sdCard::envio);
            }
            pc.printf("Preparado o envio do arquivo com %lu bytes.\n",sdCard::envio.bytes);
            break;
        case dadosStatus:
            modemCom::montaStatus();
            break;
    }
    
    switch(tipoDado) {
        case dadosArmazenados:
                result = modemCom::postFileCommandMode(serverAddress,"/drome/Parser/",&sdCard::envio);                
            break;
        case dadosStatus:
                result = modemCom::postFileCommandMode(serverAddress,"/drome/Parser/",&sdCard::status);
            break;
    }
    
    if(!result){
        return result;    
    }

    //Envia uma string nula e faz o processador esperar a resposta do server!
    if(modemCom::status.ServerAck) {
        pc.printf("Enviado e recebido resposta do server (*ServerAck*).\n");
    } else {
        pc.printf("Enviado mas nao recebido resposta do server (*ServerAck*).\n");
        pc.printf("Conteudo de getRowBuffer <%s>.\n",bufModem.getRowBuffer());
    }        
    return result;
}



uint8_t modemCom::postFileCommandMode(char *host, char *uri, arquivoSD *arquivo)
{
    #define maxRetentativasEnvioParteArquivo 20
    uint32_t numeroDePartes;
    uint16_t restoDoEnvio;
    int32_t parteSendoEnviada;
    uint16_t numeroByteSendoEnviado;
    uint16_t maxTentativas=0;
    //unsigned int result;
    char header[512];
    char aux[40];    
    uint16_t headerTam;
    uint32_t dataTam=0;
    char c;
    bool passaParaProximaParte = false;

    //Para garantir que não seja duvidoso proveniente de outra conexão.
    modemCom::status.ServerAck=0;
    modemCom::status.NO_CARRIER=0;

    if(arquivo->bytes==0){
        
        if((!sdCard::getFileTam(arquivo))||(arquivo->bytes == 0)){
            return false;    
        }
    }
    
    pc.printf("Abrindo o socket em <%s>.\n",host);
    sprintf(header,"AT+CIPSTART=1,\"TCP\",\"%s\",80\r\n",host);
    if(modemCom::sendToModem(header,1,&modemCom::status.OK,20000,2)) {
        modemCom::status.NO_CARRIER=0; //Socket Aberto!
        pc.printf("Aberto o socket em command mode.\n");
        pc.printf("Enviando arquivo com nome %s.\n",arquivo->nome);
        modemCom::status.serverConnected=1;
        modemCom::timeOutModem = 100;
        modemCom::status.emComunicacao = true;
    } else {
        pc.printf("Nao foi possivel Abrir o socket. Abortando tentativa.\n");
        modemCom::timeOutModem = 10;
        return 0;
    }
    
    numeroDePartes = arquivo->bytes / numeroDeBytesPorEnvio;
    restoDoEnvio = arquivo->bytes % numeroDeBytesPorEnvio;
    
    
    pc.printf("Iniciando o envio do arquivo de %lu bytes\nnumeroDePartes = %lu\nrestoDoEnvio = %lu\n",arquivo->bytes,numeroDePartes,restoDoEnvio);
    
    if(!sdCard::abreArquivo(arquivo,"r")){
        pc.printf("Nao foi posssivel abrir o arquivo de dentro da funcao sendFileCommandMode().\n");
        modemCom::status.emComunicacao = false;
        return 0;
    }        
    
    
    //Monta Header aqui!
    //application/octet-stream
    sprintf(header,"--xxBOUNDARYxx\r\nContent-Type: text/plain\r\nContent-Disposition: form-data; name=\"IMEI\"\r\n\r\n%s\r\n--xxBOUNDARYxx\r\nContent-Type: application/octet-stream\r\nContent-Disposition: form-data; name=\"file\"; filename=\"%s\"\r\n\r\n",modemCom::status.MAC,arquivo->nome);
    
    dataTam = strlen(header);   
    dataTam+=arquivo->bytes;
    dataTam+= strlen("\r\n--xxBOUNDARYxx--");
    //"/drome/parser/index.php" uri drome
    sprintf(header,"POST %s HTTP/1.1\r\nHost: %s\r\nContent-Type: multipart/form-data; boundary=xxBOUNDARYxx\r\nContent-Length: %lu\r\n\r\n",uri,host,dataTam); 
    headerTam = strlen(header); //Pego o tamanho parcial para fazer a concatenaçao a fim de predizer o tamanho do post total
    
    sprintf(&header[headerTam],"--xxBOUNDARYxx\r\nContent-Type: text/plain\r\nContent-Disposition: form-data; name=\"IMEI\"\r\n\r\n%s\r\n--xxBOUNDARYxx\r\nContent-Type: application/octet-stream\r\nContent-Disposition: form-data; name=\"file\"; filename=\"%s\"\r\n\r\n",modemCom::status.MAC,arquivo->nome);
    headerTam = strlen(header);

    sprintf(aux,"AT+CIPSEND=1,%u\r\n",headerTam);
    if(modemCom::sendToModem(aux,1,&modemCom::status.PROMPT_ENVIO_COMMAND_MODE,100,10)) {
        if(!modemCom::sendToModem(header,1,&modemCom::status.SEND_OK,1000,1)) {            
            sdCard::fechaArquivo(arquivo);
            modemCom::status.emComunicacao = false;
            pc.printf("Cabecalho http nao enviado.\n");
            return 0;
        } else {
            pc.printf("Cabecalho http enviado.\n");
        }
    } else {
        pc.printf("Erro enviando arquivo.\n");
        sdCard::fechaArquivo(arquivo);
        modemCom::status.emComunicacao = false;
        return 0;
    }

    //Enviando as partes inteiras
    maxTentativas = maxRetentativasEnvioParteArquivo;
    for(parteSendoEnviada=0; parteSendoEnviada<numeroDePartes; parteSendoEnviada++) {
        //Aqui realizo o envio de cada parte.
        passaParaProximaParte = false;
        while((maxTentativas)&&(!passaParaProximaParte)) {
            sprintf(aux,"AT+CIPSEND=1,%u\r\n",numeroDeBytesPorEnvio);
            if(modemCom::sendToModem(aux,1,&modemCom::status.PROMPT_ENVIO_COMMAND_MODE,100,20)) {
                if(maxTentativas!=maxRetentativasEnvioParteArquivo) {
                    //Estou realizando reenvio desta parte logo preciso fazer fseek para a quantidade de bytes do envio anterior
                    fseek(arquivo->fp,-numeroDeBytesPorEnvio,SEEK_CUR);
                }
                pc.printf("Numero de bytes por envio = %lu.\r\n",numeroDeBytesPorEnvio);                
                for(numeroByteSendoEnviado=0; numeroByteSendoEnviado<(numeroDeBytesPorEnvio); numeroByteSendoEnviado++) {                    
                    c = fgetc(arquivo->fp);                    
                    modem.printf("%c",c);
                    #ifdef xereta_modem
                        pc.printf("%c",c);
                    #endif
                }

                if(modemCom::sendToModem(NULL,1,&modemCom::status.SEND_OK,5000,1)) {
                    diversos::progressBar(parteSendoEnviada,numeroDePartes);
                    //Preciso verificar se o buffer esvaziou. Se deu "flush"
                    //if(modemCom::aguardaFlush(0)==1) {
                    //passa pra proxima parte
                    passaParaProximaParte = true;
                    maxTentativas = maxRetentativasEnvioParteArquivo;                    
                } else {
                    maxTentativas--;
                    if(maxTentativas == 1) {
                        pc.printf("MaxTentativas dentro de envio das partes == 1, vou aguardar o flush.\n");                        
                    }
                    if(maxTentativas == 0) {
                        sdCard::fechaArquivo(arquivo);
                        modemCom::status.emComunicacao = false;
                        return 0;
                    }                    
                }
            } else {
                pc.printf("Erro enviando o arquivo nao recebeu a tentativa de envio de parte inteira.\n");
                sdCard::fechaArquivo(arquivo);
                modemCom::status.emComunicacao = false;
                return 0;
            }
        }
        if(!passaParaProximaParte) {
            pc.printf("Erro enviando o arquivo nao recebeu a tentativa de envio de parte inteira.\n");
            sdCard::fechaArquivo(arquivo);
            modemCom::status.emComunicacao = false;
            return 0;
        }
    }    

    //Enviando o resto
    passaParaProximaParte = false;
    maxTentativas = maxRetentativasEnvioParteArquivo;
    while((maxTentativas)&&(!passaParaProximaParte)) {
        sprintf(aux,"AT+CIPSEND=1,%u\r\n",restoDoEnvio+strlen("\r\n--xxBOUNDARYxx--\r\n\r\n")); //Para incluir "\n--xxBOUNDARYxx--\n\n" no fim da msg http
        if(modemCom::sendToModem(aux,1,&modemCom::status.PROMPT_ENVIO_COMMAND_MODE,100,3)) {
            for(numeroByteSendoEnviado=0; numeroByteSendoEnviado<restoDoEnvio; numeroByteSendoEnviado++) {
                //Envio os bytes aqui! Menos o ultimo para ter o check;
                c = fgetc(arquivo->fp);
                modem.printf("%c",c);
                #ifdef xereta_modem
                    pc.printf("%c",c);
                #endif
            }
            if(modemCom::sendToModem("\r\n--xxBOUNDARYxx--\r\n\r\n",1,&modemCom::status.SEND_OK,5000,1)) {
                if(numeroDePartes) {
                    diversos::progressBar(parteSendoEnviada,numeroDePartes);
                }                
                passaParaProximaParte = true;
                pc.printf("\nEnviado o resto do envio com fim de cabecalho!\n",parteSendoEnviada);
                modemCom::timeOutModem = 250;
                //}
                /*else {
                    pc.printf("Erro enviando arquivo.\n");
                    fclose(fp);
                    *aberto = false;
                    return 0;
                }*/
            } else {
                sdCard::fechaArquivo(arquivo);
                modemCom::status.emComunicacao = false;
                return 0;
            }
        } else {
            maxTentativas--;
            modemCom::sendToModem("AT\r\n",1,&modemCom::status.OK,1000,100);            
        }
    }

    if(!passaParaProximaParte) {
        pc.printf("Erro enviando o arquivo nao recebeu a tentativa de envio de parte inteira.\n");
        sdCard::fechaArquivo(arquivo);
        modemCom::status.emComunicacao = false;
        return 0;
    }

    //Logica de timeout esperando confirmação modemCom::status.ServerAck 20 segundos
    parteSendoEnviada = 600;    
    while((parteSendoEnviada)&&(!modemCom::status.ServerAck)&&(!modemCom::status.NO_CARRIER)) {
        osDelay(100);
        parteSendoEnviada--;
    }

    modemCom::status.serverConnected=0;
    sdCard::fechaArquivo(arquivo);
    
    //modemCom::sendToModem("AT+CIPCLOSE=1\r\n",1,&modemCom::status.OK,500,3);    
    modemCom::closeConnection(1);
    modemCom::status.emComunicacao = false;    
    return modemCom::status.ServerAck;
}

uint8_t modemCom::sendToModem(char *string,uint8_t confirmado,char *codigoConfirmacao,uint16_t timeOut,uint8_t maxTentativas)
{
    uint16_t timeOutProcesso;
    uint16_t indexString,strLen; //Para exibir retentativas!
    led3=1;
    while(maxTentativas){
        timeOutProcesso=timeOut;
        //UARTSend(2,string,strlen(string));
        if(string!=NULL) {
            modem.puts(string);
#ifdef xereta_modem
            //DebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebug
            pc.printf("Sai pro modem <%s>\n",string); //Enviando na serial PC para debug
#endif
        }
        if(confirmado==1){
            *codigoConfirmacao=0;
            modemCom::status.ERROR=0;
            while((timeOutProcesso)&&(!(*codigoConfirmacao))&&(!modemCom::status.ERROR)) {
                osDelay(5); //timeOut em mS
                timeOutProcesso--;
            }
            if(modemCom::status.ERROR||modemCom::status.busy) {
                osDelay(1000);//espera 0.1S
            }

#ifdef xereta_modem
            //DebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebugDebug
            pc.printf("Vem do modem <%s>\n",bufModem.getRowBuffer());
#endif
            if(*codigoConfirmacao==1) {
                led3=0;
                return maxTentativas;                
            }            
            strLen = strlen(string);
            pc.printf("Erro em sendToModem codigo <%s> Retentativa de envio da string <",bufModem.getRowBuffer());
            for(indexString=0; indexString<(strLen-1); indexString++) {
                pc.putc(string[indexString]);
            }
            pc.printf("> maxTentativas = %lu.\n",maxTentativas);
        }    
        maxTentativas--;    
    }
    led3=0;
    return 0;
}

bool modemCom::closeConnection(uint8_t id){
    char command[20];
    sprintf(command,"AT+CIPCLOSE=%u\r\n",id);
    return modemCom::sendToModem(command,1,&modemCom::status.CLOSED,500,5);
}

char modemCom::cipSend(uint8_t connID,char *buffer,uint16_t len){
    char aux[20];
    uint16_t i;
    if(!len){
        len = strlen(buffer);    
    }
    printf("conteudo de cipsend.<");
    sprintf(aux,"AT+CIPSENDEX=%u,%lu\r\n",connID,len);
    if(sendToModem(aux,1,&modemCom::status.OK,500,1)){        
        for(i=0;i<len;i++){
            modem.putc(buffer[i]);
            pc.putc(buffer[i]);    
        }
    }else{       
        return 0;            
    }
    printf(">\r\n");
    if(sendToModem("",1,&modemCom::status.SEND_OK,2000,1)){
        return 1;
    }
    return 2;
}

void modemCom::webServer(void){
    char buf[512];
    char auxMsg[50];
    bool encontrado=0;
    uint32_t aux_int;
    
    
    
    if(strstr(bufInPtr,"favicon.ico")){        
        //sprintf(buf,"<!DOCTYPE html><html><body><h1>DROME-Seu processo na palma da sua mao!</h1><img src='http://criandoriquezaimagens.s3.amazonaws.com/wp-content/uploads/2014/12/casaPropria.png' width='200' height='210'><br><p><a href='/lecomandocontrole.htm'>Ler comando do controle.</a></p><br></body></html>");
        sprintf(buf,"<!DOCTYPE html><html><link rel=\"icon\" href=\"http://vitaesolucoes.com.br/drome/assets/local/images/favicon/favicon.ico\" type=\"image/x-icon\"></html>");
        if(cipSend(connID,buf,0)==1){
            printf("Requisicao enviada!\n");    
        }else{
            printf("Requisicao nao enviada 1!!\n");
        }        
        encontrado = 1;
    }
    
    if(strstr(bufInPtr,"comandos.htm")){
        
        //sprintf(buf,"<!DOCTYPE html><html><body><h1>DROME-Seu processo na palma da sua mao!</h1><img src='http://criandoriquezaimagens.s3.amazonaws.com/wp-content/uploads/2014/12/casaPropria.png' width='200' height='210'><br><p><a href='/lecomandocontrole.htm'>Ler comando do controle.</a></p><br></body></html>");
        sprintf(buf,"<!DOCTYPE html><html><body><h1>DROME-Dispositivo Remoto de Operacao e Monitoramento de Equipamentos</h1><br><p><a href='/lecomandocontrole.htm'>Ler comando do controle.</a><a href='/configRede.htm'><br>Configurar rede.</a></p><br></body></html>");
        if(cipSend(connID,buf,0)==1){
            printf("Requisicao enviada!\n");    
        }else{
            printf("Requisicao nao enviada 1!!\n");
        }        
        encontrado = 1;
    }
        
    if(strstr(bufInPtr,"configRede.htm")){
        
        
        //Pegando o IP
        sendToModem("AT+CIFSR\r\n",1,&modemCom::status.OK,200,1);        
        //sprintf(buf,"<script>window.location.href = 'http://www.vitaesolucoes.com.br/controladorawifi/config.php?ip=%s'</script>",modemStatus.STAIP);
        
        //sprintf(buf,"<!DOCTYPE html><form action='cwjap.htm' method='GET'><fieldset><legend>Parametros de Configuracao da rede:</legend>SSID WiFi:<br><input type='text' name='ssid' value=''><br>Senha WiFi:<br><input type='text' name='password' value=''><br>IP:(0 para DHCP)<br><input type='text' name='ip' value='0'><br>Porta:<br><input type='text' name='port' value=''><br><input type='submit' value='Configurar'></fieldset></form>");
        sprintf(buf,"<!DOCTYPE html>IP Atual = %s.<br><form action='cwjap.htm' method='GET'><fieldset><legend>Parametros de Configuracao da rede:</legend>SSID WiFi:<br><input type='text' name='ssid' value='%s'><br>Senha WiFi:<br><input type='text' name='password' value='%s'><br>PORTA:<br><input type='text' name='porta' value='%s'><br><input type='submit' value='Configurar'></fieldset></form>",modemCom::status.STAIP,modemCom::status.ssid,modemCom::status.password,modemCom::status.port);
        
        cipSend(connID,buf,0);
        encontrado = 1;
    }
    
    if(strstr(bufInPtr,"cwjap.htm")){
        //cwjap.htm?ssid=VSA&password=vitaeBBYP&ip=0&port=80
        
        strtok(bufInPtr,"=");
        strcpy(modemCom::status.ssid,strtok(NULL,"&")); //pegando ssid        
        
        strtok(NULL,"=");
        strcpy(modemCom::status.password,strtok(NULL,"&")); //pegando password
        
        //strtok(NULL,"=");
        //strcpy(modemStatus.STAIP,strtok(NULL,"&")); //pegando ip
        
        strtok(NULL,"=");
        strcpy(modemCom::status.port,strtok(NULL," ")); //pegando port
        
        pc.printf("Antes <%s>.\r\n",modemCom::status.ssid);
        diversos::strReplace(modemCom::status.ssid,"%20"," ");
        pc.printf("Tirado %%20 <%s>.\r\n",modemCom::status.ssid);
        diversos::strReplace(modemCom::status.ssid,"+"," ");
        pc.printf("Tirado + <%s>.\r\n",modemCom::status.ssid);        
        
        if((modemCom::status.ssid[0]!=0) && (modemCom::status.password[0]!=0)){
            sprintf(buf,"HTTP/1.1 200 OK\n\nACK");                      
            mudaRede = true;
        }else{
            sprintf(buf,"HTTP/1.1 200 OK\n\nNACK");
        }
        cipSend(connID,buf,0);
        encontrado = 1;
    }    
        
    /*if(strstr(bufInPtr,"leTemperaturas.htm")){
        
        
        
            strtok(bufInPtr,"=");
            bufInPtr = strtok(NULL,NULL);
            //sprintf(buf,"%s",bufInPtr);
            aux_int = atoi(bufInPtr);
            aux_int--;
        */
        
        /*if(num_temperatureSensors){            
            //Zerano conteudo de buff
            sprintf(buf,"callback({\"response\":\"");     
            probe[0]->convertTemperature(true, DS1820::all_devices);         //Start temperature conversion, wait until ready            
            for (int i = 0; i<num_temperatureSensors; i++){                                
                sprintf(auxMsg,"%3.1f;",probe[i]->temperature());                
                strcat(buf,auxMsg);
            }
            buf[strlen(buf)-1]=0;
            sprintf(auxMsg,"\"})");
            strcat(buf,auxMsg);
        }else{
            sprintf(buf,"callback({\"response\":\"Sensor_ERROR\"})");   
         }        
        if(cipSend(connID,buf,0)==1){
            printf("Requisicao enviada!\n");    
        }else{
            printf("Requisicao nao enviada 1!!\n");
        }        
        encontrado = 1;
    }*/
    
    
    
    if(strstr(bufInPtr,"lecomandocontrole.htm")){        
        led2=1;
        uint16_t timeout = 5000;
        IrDetect.reset();
        IrDetect.start();
        
        while((IrDetect.read_ms()<timeout) && (!detectaIRIn()));
        if(IrDetect.read_ms()<timeout){
            serializaPacoteIR(connID);            
        }else{
            sprintf(buf,"erro");   
            if(cipSend(connID,buf,0)==1){
                printf("Requisicao enviada!\n");    
            }
         }
        IrDetect.stop();        
        encontrado = 1;
        led2=0;
    }
    
    if(!encontrado){        
        sprintf(buf,"Pagina Nao Encontrada.");
        if(cipSend(connID,buf,0)==1){
            printf("Requisicao enviada!\n");    
        }else{
            printf("Requisicao nao enviada 3!!\n");
        }         
    }
    
    modemCom::closeConnection(connID);
    /*sprintf(buf,"AT+CIPCLOSE=%u\r\n",connID);
    sendToModem(buf,1,&modemCom::status.OK,300,1);*/
    
    if(mudaRede){            
        mudaRede = false;
        modemCom::sendToModem("AT+CIPSERVER=0\r\n",1,&modemCom::status.OK,2000,1);        
        pc.printf("Mudando para rede:\r\nSSID:%s\r\nPASSWORD:%S\r\nPORTA:%s\r\n\r\n",modemCom::status.ssid,modemCom::status.password,modemCom::status.port);
        if(sdCard::abreArquivo(&sdCard::config,"w")){
            pc.printf("Guardando config.\r\n");
            fprintf(sdCard::config.fp,"SSID:%s\r\nPASSWORD:%s\r\nPORT:%s",modemCom::status.ssid,modemCom::status.password,modemCom::status.port);
            sdCard::fechaArquivo(&sdCard::config);
            modemCom::conectaWiFi();
        }    
    }
}

int16_t modemCom::getRSSI(void){
    /*char *ptr;
    int16_t RSSI = 0;
    if(modemCom::sendToModem("AT+CWLAP\r\n",1,&modemCom::status.OK,1000,1)){        
        ptr = strstr(modemCom::bufIn,(const char*)modemCom::status.ssid);
        if(ptr){
            ptr = strtok(ptr,",");            
            ptr = strtok(NULL,",");            
            RSSI = atoi(ptr);
        }
    }
    return RSSI;*/
    return -50;
}
    
void modemCom::conectaWiFi(void){
    //Função para mudança de rede
    char *ptr;
    char aux[128];
    if(sdCard::abreArquivo(&sdCard::config,"r")){
        pc.printf("Abrindo arquivo de config para buscar dados de conexao.\r\n");        
        //"SSID:DROME\r\nPASSWORD:VITAE\r\nPORT:80"
        
        //Pegando SSID        
        fgets(modemCom::status.ssid,40,sdCard::config.fp);
        ptr = strstr(modemCom::status.ssid,"SSID");
        if(ptr!=NULL){
            ptr = strtok(modemCom::status.ssid,":");        
            ptr = strtok(NULL,"\r\n");
            strcpy(modemCom::status.ssid,ptr);
            
            //Pegando PASSWORD
            fgets(modemCom::status.password,50,sdCard::config.fp);
            ptr = strtok(modemCom::status.password,":");
            ptr = strtok(NULL,"\r\n");
            strcpy(modemCom::status.password,ptr);
            
            //Pegando PORT
            fgets(modemCom::status.port,20,sdCard::config.fp);
            ptr = strtok(modemCom::status.port,":");
            ptr = strtok(NULL,"\r\n");        
            strcpy(modemCom::status.port,ptr);
        }else{
            strcpy(modemCom::status.ssid,"VSA");
            strcpy(modemCom::status.password,"vitaeBBYP");
            strcpy(modemCom::status.port,"80");
         }
        sdCard::fechaArquivo(&sdCard::config);
        pc.printf("Lidos os parametros de configuracao de wifi como sendo:\r\nSSID:<%s>\r\nPASSWORD:<%s>\r\nPORT:<%s>\r\n\r\n",modemCom::status.ssid,modemCom::status.password,modemCom::status.port);        
        pc.printf("Iniciando conexao wifi.\r\n");        
    }else{
            strcpy(modemCom::status.ssid,"VSA");
            strcpy(modemCom::status.password,"vitaeBBYP");
            strcpy(modemCom::status.port,"80");
         }           
        
        //Mudando mode para AP e Station
        if(modemCom::sendToModem("AT+CWMODE=3\r\n",1,&modemCom::status.OK,10000,1)) {
            pc.printf("Modo AP+STATION aceito.\n");
        }
        
        //AT+CWJAP=\"\",\"\"\r\n
        sprintf(aux,"AT+CWJAP=\"%s\",\"%s\"\r\n",modemCom::status.ssid,modemCom::status.password);
        if(modemCom::sendToModem(aux,1,&modemCom::status.OK,10000,1)) {
            pc.printf("WiFi Conectado.\n");
        }
            
        //AT+CIPSERVER=1,80
        if(modemCom::sendToModem("AT+CIPMUX=1\r\n",1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando AT+CIPMUX=1.\n");
        }
        
        //AT+CIPSERVER=1,80
        sprintf(aux,"AT+CIPSERVER=1,%s\r\n",modemCom::status.port);
        if(modemCom::sendToModem(aux,1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando <%s>.\n",aux);
        }
    
        if(modemCom::sendToModem("AT+CIPSTO=60\r\n",1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando AT+CIPSTO=60.\n");
        }        
        
        sprintf(aux,"AT+CWSAP_CUR=\"DROME_WIFI_%s\",\"VsaDROME\",5,3\r\n",modemCom::status.MAC);
        if(modemCom::sendToModem(aux,1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando %s.\n",aux);
        }

        
        if(modemCom::sendToModem("AT+CIPAP_CUR=\"192.168.4.1\",\"192.168.4.1\",\"255.255.255.0\"\r\n",1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando AT+CIPAP_CUR=\"192.168.4.1\",\"192.168.4.1\",\"255.255.255.0\".\n");
        }    
        
        if(modemCom::sendToModem("AT+CWDHCP_CUR=2,1\r\n",1,&modemCom::status.OK,250,4)) {
            pc.printf("Recebeu o comando AT+CWDHCP_CUR=2,1.\n");
        }

}

void modemCom::processaPacote(void const *args){
    char *ptr,*scanPtr;        
    bool naoCompreendido=true;
    uint16_t bufInLength = bufModem.getLength();
    modemCom::bufIn = bufModem.get();    
    
    //pc.printf("Entrada do modem<\n\n%s\n\n>\n",modemCom::bufIn);
    
    /*
    if(modemCom::exibeEntradaPacote){
        modemCom::exibeEntradaPacote=false;
        pc.printf("Lido entrada Pacote modem<%s>.\n",modemCom::bufIn);        
    }
    */
    
    //Reconhecendo GET HTTP e atendendo com um servidor web    
    if(strstr(modemCom::bufIn,"GET /") && strstr(modemCom::bufIn,"HTTP/1.1")){
        ptr=strstr(modemCom::bufIn,"GET /");
        if(ptr) {
            naoCompreendido=false;
            ptr = strtok(ptr,"/");
            ptr = strtok(NULL," ");
            bufInPtr = ptr;        
            modemCom::atendendoWebServer = true;            
            //osSignalSet(idThreadComunicacoes, 0x1);        
            
        }
    }
    
    //Buscando connect
    if(!modemCom::atendendoWebServer){
        ptr=strstr(modemCom::bufIn,"CONNECT\r\n");
        if(ptr) {
            ptr = strtok(modemCom::bufIn,",");
            connID = atoi(ptr);                        
            naoCompreendido=false;
            modemCom::status.serverConnected=1;        
            pc.printf("Recebido string CONNECT socket na conexao %u.\n",connID);
            if(!modemCom::status.emComunicacao){            
                //Preciso saber se é decorrente de uma chamada minha ou se é uma entrada de socket.            
                pc.printf("Atendendo socket entrante na conexao %u.\n",connID);
                modemCom::status.SRINGsockEntrante = true;
            }
            modemCom::status.emComunicacao=true;
            modemCom::bufIn = strtok(NULL,NULL);
        }    
    }
    
    IPDNumBytes = 0;
    ptr = strstr(modemCom::bufIn,"+IPD");
    if(ptr!=NULL){
        //+IPD,0,480:GET
        strtok(ptr,",");           //Separando +IPD
        
        ptr = strtok(NULL,",");    //Pegando o numero da conexão
        connID = atoi(ptr);
        
        ptr = strtok(NULL,":");    //Pegando o numero de caracteres IPD
        IPDNumBytes = atoi(ptr);
        
        modemCom::bufIn = strtok(NULL,NULL);
        
        printf("Recebido pacote via conexao %u com %lu bytes.\n",connID,IPDNumBytes);
        
    }
    
    if(modemCom::atendendoWebServer){
        return;    
    }
    
    //printf("Sobrou pacote <%s>.\n\n",modemCom::bufIn);
    //uint8_t i;

    
    
    ptr=strstr(modemCom::bufIn,"*ServerAck*");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.ServerAck=1;
        pc.printf("SERVER RESPONSE\n%s\n\n",modemCom::bufIn);
    }        
    
    ptr=strstr(modemCom::bufIn,"*ServerCommand*");
    if(ptr) {
        naoCompreendido=false;
        scanPtr = strtok (ptr,"\\");
        scanPtr = strtok (NULL,">");
        //modemCom::status.ServerCommand=1;
        strcpy(commands::buffer,scanPtr);
        pc.printf("Comandos <%s>.\n",commands::buffer);
        executaComandoServer = true;
        //Se devo executar comando tenho que sair imediatamente.
        return;
    }
    
    //if(modemCom::status.recebendoArquivoDoServer){
    if(IPDNumBytes && modemCom::status.recebendoArquivoDoServer && (strstr(modemCom::bufIn,"CONNECT")==NULL) && (strstr(modemCom::bufIn,"*ServerCommand*")==NULL) ){        
        //Appenda bufIn no devicescfg        
        //sdCard::insereDadosArquivo(&sdCard::devices,modemCom::bufIn,bufInLength);
        sdCard::insereDadosArquivo(&sdCard::tempFile,modemCom::bufIn,IPDNumBytes);
        osDelay(250);
        
        
        modemCom::status.timeOut=100;        
        
        sprintf(modemCom::bufIn,"AT+CIPSEND=%u,%lu\r\n",connID,10);
        modem.puts(modemCom::bufIn);
        osDelay(100);
        modem.puts("sendData\r\n");
        pc.printf("sendData\n");
        return;
    }    
    
    //Reconhecimento dos status
    modemCom::status.PROMPT_ENVIO_COMMAND_MODE=0;

    ptr=strstr(modemCom::bufIn,"> ");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.serverConnected=1;
        modemCom::status.commandMode=1;
        modemCom::status.NO_CARRIER=0;
        modemCom::status.PROMPT_ENVIO_COMMAND_MODE=1;
    }

    modemCom::status.OK=0;

    ptr=strstr(modemCom::bufIn,"OK\r");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.OK=1;
    }    
    
    
    ptr=strstr(modemCom::bufIn,"+CIFSR:STAIP,");
    if(ptr) {
        naoCompreendido=false;
        ptr = strtok(ptr,"\"");
        ptr = strtok(NULL,"\"");
        strcpy(modemCom::status.STAIP,ptr);
    }

    modemCom::status.busy=false;
    ptr=strstr(modemCom::bufIn,"busy s...");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.busy=1;
    }
    
    modemCom::status.SEND_OK=0;
    ptr=strstr(modemCom::bufIn,"SEND OK");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.SEND_OK=1;
    }

    ptr=strstr(modemCom::bufIn,"#SGACT: 1,");
    if(ptr) {
        naoCompreendido=false;
        if(ptr[10]=='1') {
            modemCom::status.associated=1;
        }
        if(ptr[10]=='0') {
            modemCom::status.associated=0;
        }
    } else {

        ptr=strstr(modemCom::bufIn,"#SGACT: ");
        if(ptr) {
            naoCompreendido=false;
            modemCom::status.associated=1;
            scanPtr = strtok (ptr," ");
            scanPtr = strtok (NULL,"\r");
            if(scanPtr) {
                strcpy(modemCom::status.modemIP,scanPtr);
            }
        }
    }


    ptr=strstr(modemCom::bufIn,"+CGPADDR: 1,");
    if(ptr) {
        naoCompreendido=false;
        scanPtr = strtok (ptr,"\"");
        scanPtr = strtok (NULL,"\"");
        if(scanPtr) {
            strcpy(modemCom::status.modemIP,scanPtr);
        }
    }


    //#PING: 01,"187.45.195.188",5,54
    ptr=strstr(modemCom::bufIn,"#PING: ");
    if(ptr) {
        naoCompreendido=false;
        scanPtr = strtok (ptr,"\"");
        scanPtr = strtok (NULL,"\"");
        if(scanPtr) {
            strcpy(modemCom::status.serverIP,scanPtr);
            modemCom::status.serverIP[16]=1;
            modemCom::status.ping=1;
        }
    }


    //SocketBufferPendent?
    //#SI: 1,123,400,10,50

    ptr=strstr(modemCom::bufIn,"#SI: ");
    if(ptr) {        
        //uint8_t connId;        
        naoCompreendido=false;     
        
        //Descartando "#SI: "   
        scanPtr = strtok (ptr," ");
        
        //Capturando connId
        scanPtr = strtok (NULL,",");        
        connID = atoi(scanPtr);
        connID--; //Para transformar em indice de linguagem C que começa em zero;        
        
        //capturando sent
        scanPtr = strtok (NULL,",");
        modemCom::status.socketInfo[connID].sent = atoi(scanPtr);
        
        //capturando received
        scanPtr = strtok (NULL,",");
        modemCom::status.socketInfo[connID].received = atoi(scanPtr);
        
        //capturando buff_in
        scanPtr = strtok (NULL,",");
        modemCom::status.socketInfo[connID].buff_in = atoi(scanPtr);
        
        //capturando ack_waiting
        scanPtr = strtok (NULL,",");
        modemCom::status.socketInfo[connID].ack_waiting = atoi(scanPtr);
    }


    modemCom::status.ERROR=0;
    ptr=strstr(modemCom::bufIn,"ERROR");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.ERROR=1;
        modemCom::status.OK=0;
    }

    ptr=strstr(modemCom::bufIn,"HTTP/1.1");
    if(ptr) {
        naoCompreendido=false;
        pc.printf("HTTP RESPONSE\n%s\n\n",modemCom::bufIn);
    }
    
    ptr=strstr(modemCom::bufIn,"SRING: 1");
    if(ptr) {
        naoCompreendido=false;
        modem.printf("AT#SRECV=1,1500\r");          
    }
        
    ptr=strstr(modemCom::bufIn,"SRING: 2");
    if(ptr){
        naoCompreendido=false;
        if(!modemCom::status.socketEntranteAtivo){
         modemCom::status.SRINGsockEntrante=1;    
         osSignalSet(idThreadComunicacoes, 0x1);   
        }else{
            //modem.printf("AT#SRECV=2,1500\r");
         }
    }
    

    ptr=strstr(modemCom::bufIn,"NO CARRIER");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.serverConnected=0;
        modemCom::status.commandMode=1;
        modemCom::status.NO_CARRIER=1;
        pc.printf("NO CARRIER!!\n");
    }
    
    modemCom::status.CLOSED=false;
    
    ptr=strstr(modemCom::bufIn,"CLOSED");
    if(ptr) {
        naoCompreendido=false;
        modemCom::status.CLOSED=1;        
    }

    if(naoCompreendido) {
        pc.printf("Mensagem nao compreendida vinda do modem \n ->{\n\n%s\n\n}<-\n",modemCom::bufIn);
    }   
    
    //if(modemCom::status.exibeBufModem){
    //    modemCom::status.exibeBufModem=false;
        //pc.printf("Entrada do modem<\n\n%s\n\n>\n",modemCom::bufIn);
    //} 
}

uint8_t modemCom::inicializaModem(void)
{
    //uint8_t maxTentativas=0;

    //char config[255];
    //char *ptr;
    char *buf;
    buf = bufModem.getRowBuffer();
    
    modemCom::timeOutModem = 10;
    modemCom::status.emComunicacao = true;    

    if(modemCom::sendToModem("ATE0\r\n",1,&modemCom::status.OK,1000,10)) {
        pc.printf("Recebeu o comando ATE0.\n");
    }

    modemCom::leMAC();

    
    
    /*    
    if(modemCom::sendToModem("\r",1,&modemCom::status.OK,250,4)) {
        pc.printf("Recebeu o comando .\n");
    }
    */
        
    modemCom::status.emComunicacao = false;
    return 1;
}