File content as of revision 12:254c32b4ece7:

#include "devices.h"

enum {
    estadoConfiguracao_idle = 0,
    estadoConfiguracao_creatingDevice,
    estadoConfiguracao_alarmSet,
    estadoConfiguracao_readingsSet,
    estadoConfiguracao_scheduleSet,
    estadoConfiguracao_scheduleExceptionSet
};

/*
Antigo
uint8_t resizeArray(uint32_t atual, uint32_t novo, char **array,uint16_t sizeUnit)
{
    uint32_t i;
    char *p = (char *) malloc(sizeUnit*novo);
    char *aux;

    if(p==NULL) {
        return 0;
    }

    aux = *array;

    if(atual) {
        //So sigo em frente se tinha algo dentro deste array
        for(i=0; i<(novo*sizeUnit); i++) {
            p[i]=aux[i];
        }
        free(aux);
    }

    *array = p;
    return 1;
}
*/

/*uint8_t resizeArray(uint32_t atual, uint32_t novo, char **array,uint16_t sizeUnit)
{
    uint32_t i;
    char *p = (char *) malloc(sizeUnit*novo);    

    if(p==NULL) {
        return 0;
    }   

    if(atual) {
        //So sigo em frente se tinha algo dentro deste array
        for(i=0; i<(novo*sizeUnit); i++) {
            p[i]=*array[i];
        }
        free(*array);
    }

    *array = p;
    return 1;
}*/

void writeReadingsToSD(){
    int i;
    for(i=0;i<devices;i++){
        dispositivos[i]->writeReadingsToSD();
    }
}

void verifyAlarms(){
    int i;
    for(i=0;i<devices;i++){
        dispositivos[i]->verifyAlarms();
    }
}

void verifySchedules(){
    int i;
    for(i=0;i<devices;i++){
        dispositivos[i]->verifySchedules();
    }
}

void device::floatToBin(uint8_t dir, float *v,uint8_t *p)
{
    //Variáveis locais
    union {
        char c[4];
        float v;
    }u;
    int i;

    if(dir) {
        u.v = *v;
        for(i=0; i<4; i++) {
            p[i]=u.c[3-i];
        }
    } else {
        for(i=0; i<4; i++) {
            u.c[3-i]=p[i];
        }
        *v = u.v;
    }
}

void device::uint32_t_ToBin(uint8_t dir, uint32_t *v,uint8_t *p)
{
    //Variáveis locais
    union {
        char c[4];
        uint32_t v;
    }u;
    int i;

    if(dir) {
        u.v = *v;
        for(i=0; i<4; i++) {
            p[i]=u.c[3-i];
        }
    } else {
        for(i=0; i<4; i++) {
            u.c[3-i]=p[i];
        }
        *v = u.v;
    }
}

void device::uint16_t_ToBin(uint8_t dir, uint16_t *v,uint8_t *p)
{
    //Variáveis locais
    union {
        char c[2];
        uint32_t v;
    }u;
    int i;

    if(dir) {
        u.v = *v;
        for(i=0; i<2; i++) {
            p[i]=u.c[1-i];
        }
    } else {
        for(i=0; i<2; i++) {
            u.c[1-i]=p[i];
        }
        *v = u.v;
    }
}

//Funcao restaurada
void device::verifyAlarms(){
    //Inicio da verificação
    uint16_t alarmIndex;
    float leitura_float,value_float;
    uint32_t leitura_uint32_t,value_uint32_t;
    uint16_t leitura_uint16_t,value_uint16_t;
    bool leitura_bit,value_bit;    
    bool alarmFound;
    char aux[30];
        
    for(alarmIndex = 0;alarmIndex < this->numAlarms;alarmIndex++){        

        /*pc.printf("\r\nTeste Alarm, id<%lu>.\r\n",this->alarms[alarmIndex].id);
        pc.printf("ON<%lu>.\r\n",this->alarms[alarmIndex].on);
        pc.printf("secAlarm<%lu>.\r\n",this->alarms[alarmIndex].secAlarm);
        pc.printf("alarmFound<%lu>.\r\n",this->alarms[alarmIndex].alarmFound);*/
        if(this->alarms[alarmIndex].on){            
            alarmFound=this->alarms[alarmIndex].alarmFound;
            switch(this->alarms[alarmIndex].type){
                case modBusType_float:                                        
                        //Montar float!
                        this->floatToBin(0,&value_float,&this->alarms[alarmIndex].value[0]);                    
                        
                        if(this->alarms[alarmIndex].addrModbusRead != enderecoControladoraVirtual){//Bloco de leitura da variável modBus;
                            modBusMaster1::readFloat(
                                this->alarms[alarmIndex].addrModbusRead,
                                this->alarms[alarmIndex].funcModbusRead,
                                this->alarms[alarmIndex].regModbusRead,
                                1,
                                &leitura_float
                            );
                        }else{
                            //leitura_float = temperaturas[this->alarms[alarmIndex].regModbusRead];
                            //Busca Interna                        
                            if(this->alarms[alarmIndex].regModbusRead<100){//Registradores das entradas de temperatura
                                //Populando floatBuffer com a temperaturas
                                if(this->alarms[alarmIndex].regModbusRead < num_temperatureSensors){
                                    leitura_float = temperaturas[this->alarms[alarmIndex].regModbusRead];
                                }    
                            }
                            if((this->alarms[alarmIndex].regModbusRead>99)&&(this->alarms[alarmIndex].regModbusRead<104)){//Registradores das entradas analógicas
                                leitura_float = aiFiltrada[this->alarms[alarmIndex].regModbusRead - 100];                            
                            }
                         }
                
                        if(this->alarms[alarmIndex].max!=0){
                            if(leitura_float > value_float){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }
                                    }
                                 }
                             }
                        }else{
                            if(leitura_float < value_float){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }    
                                    }
                                 }
                             }
                         }                                                                             
                    break;
                case modBusType_uint32_t:
                        //Montar uint32_t!
                        this->uint32_t_ToBin(0,&value_uint32_t,&this->alarms[alarmIndex].value[0]);                    
                        
                        if(this->alarms[alarmIndex].addrModbusRead != enderecoControladoraVirtual){//Bloco de leitura da variável modBus;
                            //Bloco de leitura da variável modBus;
                            modBusMaster1::readRegister32BIT(
                                this->alarms[alarmIndex].addrModbusRead,
                                this->alarms[alarmIndex].funcModbusRead,
                                this->alarms[alarmIndex].regModbusRead,
                                1,
                                &leitura_uint32_t
                            );
                        }else{
                            leitura_uint32_t = pulsosEDs[this->alarms[alarmIndex].regModbusRead];
                         }                                       
                
                        if(this->alarms[alarmIndex].max!=0){
                            if(leitura_uint32_t > value_uint32_t){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                    pulsosEDs[this->alarms[alarmIndex].regModbusRead]=0;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }
                                    }
                                 }
                             }
                        }else{
                            if(leitura_uint32_t < value_uint32_t){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                    pulsosEDs[this->alarms[alarmIndex].regModbusRead]=0;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }    
                                    }
                                 }
                             }
                         }                    
                    break;
                    
                case modBusType_uint16_t:
                        //Montar uint16_t!
                        this->uint16_t_ToBin(0,&value_uint16_t,&this->alarms[alarmIndex].value[0]);                    
                        
                        if(this->alarms[alarmIndex].addrModbusRead!=enderecoControladoraVirtual){
                            //Bloco de leitura da variável modBus;
                            modBusMaster1::readRegister16BIT(
                                this->alarms[alarmIndex].addrModbusRead,
                                this->alarms[alarmIndex].funcModbusRead,
                                this->alarms[alarmIndex].regModbusRead,
                                1,
                                &leitura_uint16_t
                            );     
                        }else{
                            if(this->alarms[alarmIndex].regModbusRead<4){
                                leitura_uint16_t = aiFiltrada[this->alarms[alarmIndex].regModbusRead];
                            }
                         }
                
                        if(this->alarms[alarmIndex].max!=0){
                            if(leitura_uint16_t > value_uint16_t){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }
                                    }
                                 }
                             }
                        }else{
                            if(leitura_uint16_t < value_uint16_t){
                                this->alarms[alarmIndex].secAlarm++;
                                if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                    this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                    alarmFound = true;
                                }
                            }else{
                                if(this->alarms[alarmIndex].secAlarm==1){
                                    this->alarms[alarmIndex].secAlarm=0;
                                    alarmFound = false;    
                                }else{
                                    if(this->alarms[alarmIndex].secAlarm){
                                        if(alarmFound){
                                         this->alarms[alarmIndex].secAlarm--;   
                                        }else{
                                            this->alarms[alarmIndex].secAlarm=0;
                                         }    
                                    }
                                 }
                             }
                         } 
                    break;
                
                case modBusType_bit: 
                        //Montar bit!
                        //O valor de alarm para bit é o value[0]!!!
                        value_bit = (this->alarms[alarmIndex].value[0] > 0); //Qualquer valor maior que zero da saída 1
                        
                        if(this->alarms[alarmIndex].addrModbusRead != enderecoControladoraVirtual){//Bloco de leitura da variável modBus;
                            //Bloco de leitura da variável modBus;
                            modBusMaster1::readCoils(
                                this->alarms[alarmIndex].addrModbusRead,                        
                                this->alarms[alarmIndex].regModbusRead,
                                1,
                                &leitura_bit
                            );                                                   
                        }else{
                            leitura_bit = entradasDigitais[this->alarms[alarmIndex].regModbusRead];
                         }
                        if(leitura_bit == value_bit){
                            this->alarms[alarmIndex].secAlarm++;
                            if(this->alarms[alarmIndex].secAlarm >= this->alarms[alarmIndex].seconds){
                                this->alarms[alarmIndex].secAlarm = this->alarms[alarmIndex].seconds;
                                alarmFound = true;
                            }
                        }else{
                            if(this->alarms[alarmIndex].secAlarm==1){
                                this->alarms[alarmIndex].secAlarm=0;
                                alarmFound = false;    
                            }else{
                                if(this->alarms[alarmIndex].secAlarm){
                                    if(alarmFound){
                                     this->alarms[alarmIndex].secAlarm--;   
                                    }else{
                                        this->alarms[alarmIndex].secAlarm=0;
                                     }
                                }
                             }
                         }                    
                    break;
                
            }
            
            //Verifico se houve alarme não tratado
            if(this->alarms[alarmIndex].alarmFound!=alarmFound){
               this->alarms[alarmIndex].alarmFound=alarmFound;
               if(alarmFound){
                   printf("Alarm FOUND! Id <%lu>.\n",this->alarms[alarmIndex].id);               
                   sdCardBuf.fill("log{alarm:event:found;id:",25);
                   sprintf(aux,"%lu",this->alarms[alarmIndex].id);
                   sdCardBuf.fill(aux,strlen(aux));               
                   
                   sdCardBuf.fill(";timestamp:",11);
                   sprintf(aux,"%lu",time(NULL));
                   sdCardBuf.fill(aux,strlen(aux));               
                   
                   sdCardBuf.fill(";reading:",9);
                   if(this->alarms[alarmIndex].type == modBusType_float){
                       sprintf(aux,"%f",leitura_float);
                   }else if(this->alarms[alarmIndex].type == modBusType_uint32_t){
                       sprintf(aux,"%lu",leitura_uint32_t);
                   }else if(this->alarms[alarmIndex].type == modBusType_uint16_t){
                       sprintf(aux,"%lu",leitura_uint16_t);
                   }else if(this->alarms[alarmIndex].type == modBusType_bit){
                       sprintf(aux,"%lu",leitura_bit);
                   }
                   sdCardBuf.fill(aux,strlen(aux));                            
                   leitura_uint16_t = sdCardBuf.fill("}log",4); //Reaproveitando uma variável de 16bit               
                   sdCard::insereDadosBank(sdCardBuf.get(),leitura_uint16_t);                   
                   
                   boolExecAct=true;
                   act = this->alarms[alarmIndex].idAct;
               }else{
                   printf("Alarm RELEASE! id <%lu>.\n",this->alarms[alarmIndex].id);               
                   sdCardBuf.fill("log{alarm:event:release;id:",27);
                   sprintf(aux,"%lu",this->alarms[alarmIndex].id);
                   sdCardBuf.fill(aux,strlen(aux));                              
                   
                   sdCardBuf.fill(";timestamp:",11);
                   sprintf(aux,"%lu",time(NULL));
                   sdCardBuf.fill(aux,strlen(aux));               
                   
                   leitura_uint16_t = sdCardBuf.fill("}log",4); //Reaproveitando uma variável de 16bit
                   sdCard::arquivoAberto(40000);
                   sdCard::insereDadosBank(sdCardBuf.get(),leitura_uint16_t);                   
                }                        
                //atrasa o envio em 3 segundos para que possa ser gravado o registro do alarme.
                enviaDadosPorAlarme=10;            
            }
        }
    }    
}

void device::verifySchedules(){
    char stringTime[30];
    char *weekdayString;
    time_t seconds = time(NULL)+5;
    uint8_t hora;
    uint16_t minuto;
    uint8_t weekday=0;
    uint16_t anoAtual=0;
    uint16_t diaAtual=0;
    uint16_t mesAtual=0;
    uint16_t anoScheduleException=0;
    uint16_t diaScheduleException=0;
    uint16_t mesScheduleException=0;
    const char* weekdayTable[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
    uint8_t indexSchedule;
    uint8_t indexScheduleException;
    bool exceptionDetected=false;    
    
    pc.printf("Verifing schedule.\r\n");
    
    strftime(stringTime, 30, "%a,%R,%y,%d,%m", localtime(&seconds));    
    //pc.printf("VerifySchedule <%s>.\r\n",stringTime);
    //Thu,20:48,17,2,7
    weekdayString = strtok(stringTime,",");    
    weekday = 0;
    while((weekday<10)&&(strstr(weekdayTable[weekday],weekdayString)==NULL)){
        weekday++;
    }    
    hora = atoi(strtok(NULL,":"));
    minuto = atoi(strtok(NULL,","));
    minuto = (hora*60)+minuto;
    anoAtual = atoi(strtok(NULL,","));
    diaAtual = atoi(strtok(NULL,","));
    mesAtual = atoi(strtok(NULL,""));
    
    //pc.printf("Passo 1 .\r\n");
    for(indexSchedule = 0; indexSchedule < qtdSchedules; indexSchedule++){
        //pc.printf("Passo 2.\r\n");        
        if(this->schedules[indexSchedule].weekday&(0x1<<weekday)){
            //pc.printf("Passo 3.\r\n");                      
            if(this->schedules[indexSchedule].minute == minuto){
                //pc.printf("Passo 4.\r\n");
                //Verifico se já executei e então executo a ação.
                if(!this->schedules[indexSchedule].actSent){
                    //pc.printf("Passo 5 .\r\n");
                    //Executa a ação;                    
                    for(indexScheduleException = 0;indexScheduleException<this->numScheduleExceptions;indexScheduleException++){
                        //pc.printf("Passo 6.\r\n");
                        if(this->schedules[indexSchedule].id == this->scheduleExceptions[indexScheduleException].id_schedule){
                            //pc.printf("Passo 7.\r\n");
                            seconds = this->scheduleExceptions[indexScheduleException].timestamp;
                            strftime(stringTime, 30, "%y,%d,%m", localtime(&seconds));
                            anoScheduleException=atoi(strtok(stringTime,","));
                            diaScheduleException=atoi(strtok(NULL,","));
                            mesScheduleException=atoi(strtok(NULL,""));
                            /*
                            pc.printf("\r\nDebug ScheduleException.\r\n");
                            pc.printf("stringTime <%s>.\r\n",stringTime);
                            pc.printf("anoScheduleException %lu.",anoScheduleException);
                            pc.printf("diaScheduleException %lu.",diaScheduleException);
                            pc.printf("mesScheduleException %lu.",mesScheduleException);
                            pc.printf("anoAtual %lu.",anoAtual);
                            pc.printf("diaAtual %lu.",diaAtual);
                            pc.printf("mesAtual %lu.",mesAtual);
                            pc.printf("\r\n");
                            */
                            if(
                                ((anoScheduleException == anoAtual) || (anoScheduleException == 70))
                                &&
                                (diaAtual == diaScheduleException)
                                &&
                                (mesAtual == mesScheduleException)
                            )
                            {
                                pc.printf("ScheduleException detected.\r\n");
                                exceptionDetected=true;
                            }
                        }
                    }
                    if(!exceptionDetected){
                        this->execAct(this->schedules[indexSchedule].idAct);
                        this->schedules[indexSchedule].actSent = true;
                    }
                }                
            }else{                
                this->schedules[indexSchedule].actSent = false;
             }
        }
    }    
}

/*
void device::verifySchedules(){
    char stringTime[15];
    char *weekdayString;
    time_t seconds = time(NULL);
    uint8_t hora;
    uint16_t minuto;
    uint8_t weekday=0;    
    const char* weekdayTable[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
    uint8_t indexSchedule;
    
    //Tue,19:09    
    strftime(stringTime, 15, "%a,%R", localtime(&seconds));    
    
    weekdayString = strtok(stringTime,",");    
    weekday = 0;
    while((weekday<10)&&(strstr(weekdayTable[weekday],weekdayString)==NULL)){
        weekday++;
    }
    weekday++;
    hora = atoi(strtok(NULL,":"));
    minuto = atoi(strtok(NULL,""));
    minuto = (hora*60)+minuto;
    //printf("\r\n\r\nMinuto %lu.\r\n\r\n",minuto);    
    for(indexSchedule = 0; indexSchedule < qtdSchedules; indexSchedule++){
        //printf("Executando item %u do for de schedules.\r\n\r\n",indexSchedule);
        if((this->schedules[indexSchedule].weekday == weekday)||(this->schedules[indexSchedule].weekday == 0)){
            //Se for um alarme para o dia de hoje ou o alarme independer de dia (Se o dia for zero)
            //printf("Hoje eh dia de executar a acão do schedule indice %u.\r\n\r\n",indexSchedule);
            if(this->schedules[indexSchedule].minute == minuto){
                //Verifico se já executei e então executo a ação.
                if(!this->schedules[indexSchedule].actSent){
                    //Executa a ação;
                    //printf("Executando a acao!\r\n\r\n");
                    this->execAct(this->schedules[indexSchedule].idAct);
                    this->schedules[indexSchedule].actSent = true;        
                }                
            }else{                
                this->schedules[indexSchedule].actSent = false;
             }
        } 
    }    
}
*/
/*
uint8_t device::execActSchedule(uint32_t index){            
    switch(this->schedules[index].actType){        
        case modBusType_float:
                float floatValueToWrite;
                //writeFloat(uint8_t,uint16_t,uint8_t,float*);
                this->floatToBin(0,&floatValueToWrite,&this->schedules[index].actValue[0]);                    
                modBusMaster1::writeFloat(
                    this->schedules[index].param1,
                    this->schedules[index].param2,
                    this->schedules[index].param3,
                    &floatValueToWrite
                );                    
            break;
        case modBusType_uint32_t:
                uint32_t uint32ValueToWrite;                
                this->uint32_t_ToBin(0,&uint32ValueToWrite,&this->schedules[index].actValue[0]);                    
                modBusMaster1::writeRegister32BIT(
                    this->schedules[index].param1,
                    this->schedules[index].param2,
                    this->schedules[index].param3,
                    &uint32ValueToWrite
                );                    
            break;
        case modBusType_uint16_t:
                uint16_t uint16ValueToWrite;                
                this->uint16_t_ToBin(0,&uint16ValueToWrite,&this->schedules[index].actValue[0]);                    
                modBusMaster1::writeRegister16BIT(
                    this->schedules[index].param1,
                    this->schedules[index].param2,
                    this->schedules[index].param3,
                    &uint16ValueToWrite
                ); 
            break;
        case modBusType_bit:
                bool boolValueToWrite;                
                boolValueToWrite = (this->schedules[index].actValue[0] != 0);                    
                modBusMaster1::writeSingleCoil(
                    this->schedules[index].param1,                    
                    this->schedules[index].param3,
                    boolValueToWrite
                ); 
            break;
        case IrCommandType:
                //Busca no arquivo
                //Abre arquivo
                char comandoIr[1024];
                char indexBusca[10]; 
                bool endOfFile = false;               
                
                //printf("\r\n===================DEBUG(Schedule)===================\r\n");
                //"Ir:0,6E01FFFFS"
                sprintf(indexBusca,"Ir:%u,",this->schedules[index].param3);
                //printf("indexBusca = <%s>.\r\n",indexBusca);
                if(sdCard::abreArquivo(&sdCard::devices,"r")){                
                    do{
                        fgets(comandoIr,1024,sdCard::devices.fp);                                            
                        endOfFile = feof(sdCard::devices.fp);                        
                        //printf("Linha comando Ir = <%s>.\r\nendOfFile = %u\r\n",comandoIr,endOfFile);
                    }while((strstr(comandoIr,indexBusca)==NULL)&&(endOfFile==0));                    
                    sdCard::fechaArquivo(&sdCard::devices);
                    
                    //Vê se deu tudo certo, se não encontrou, retorna false
                    if(!endOfFile){
                        //Encontrado o comando, vou desempacotar ele.
                        strtok(comandoIr,",");                        
                        //Neste ponto já tenho o meu comando pronto para ser executado dentro de comandoIr;
                        //printf("\r\n\r\n\r\nEstou enviando o comando %s de dentro do schedule.\r\n\r\n\r\n",strtok(NULL,"S"));
                        deserializaPacoteIR(strtok(NULL,"S"));
                        enviaComandoIR(this->schedules[index].param1,this->schedules[index].param2);    
                    }                    
                }else{
                    return false;
                 }
                //printf("\r\n===================DEBUG(Schedule)===================\r\n");
            break;        
    }  
    return true;  
}
*/
/*
uint8_t device::execActAlarm(uint32_t index){
    switch(this->alarms[index].actType){        
        case modBusType_float:
                float floatValueToWrite;
                //writeFloat(uint8_t,uint16_t,uint8_t,float*);
                this->floatToBin(0,&floatValueToWrite,&this->alarms[index].actValue[0]);                    
                modBusMaster1::writeFloat(
                    this->alarms[index].addrModbusWrite,
                    this->alarms[index].funcModbusWrite,
                    this->alarms[index].regModbusWrite,
                    &floatValueToWrite
                );                    
            break;
        case modBusType_uint32_t:
                uint32_t uint32ValueToWrite;                
                this->uint32_t_ToBin(0,&uint32ValueToWrite,&this->alarms[index].actValue[0]);                    
                modBusMaster1::writeRegister32BIT(
                    this->alarms[index].addrModbusWrite,
                    this->alarms[index].funcModbusWrite,
                    this->alarms[index].regModbusWrite,
                    &uint32ValueToWrite
                );                    
            break;
        case modBusType_uint16_t:
                uint16_t uint16ValueToWrite;                
                this->uint16_t_ToBin(0,&uint16ValueToWrite,&this->alarms[index].actValue[0]);                    
                modBusMaster1::writeRegister16BIT(
                    this->alarms[index].addrModbusWrite,
                    this->alarms[index].funcModbusWrite,
                    this->alarms[index].regModbusWrite,
                    &uint16ValueToWrite
                ); 
            break;
        case modBusType_bit:
                bool boolValueToWrite;                
                boolValueToWrite = (this->alarms[index].actValue[0] != 0);                    
                modBusMaster1::writeSingleCoil(
                    this->alarms[index].addrModbusWrite,                    
                    this->alarms[index].regModbusWrite,
                    boolValueToWrite
                ); 
            break;        
    }  
    return true;  
}
*/

void device::setReading(char *linha)
{
    uint8_t  addr=0;
    uint8_t  func=0;
    uint16_t  reg=0;
    uint8_t  numRegs=0;
    char *pChar;
    bool inputData = false;
    
    //printf("Linha <%s>.\n",linha);
    if(strstr(linha,"readingsSet")) {
        return;
    }

    this->numReadings++;
    
    if(strstr(linha,"float,")) {
        this->readings[this->numReadings-1].type=modBusType_float;                
        inputData = true;
    }

    if(strstr(linha,"uint32_t,")) {
        this->readings[this->numReadings-1].type=modBusType_uint32_t;
        inputData = true;
    }
    
    if(strstr(linha,"uint16_t,")) {
        this->readings[this->numReadings-1].type=modBusType_uint16_t;
        inputData = true;
    }
    
    if(strstr(linha,"uint8_t,")) {
        this->readings[this->numReadings-1].type=modBusType_uint8_t;
        inputData = true;
    }
    
    if(strstr(linha,"bit,")) {
        this->readings[this->numReadings-1].type=modBusType_bit;
        inputData = true;
    }
    
    if(inputData){
        pChar = strtok(linha,",");
        
        pChar = strtok(NULL,",");
        addr = atoi(pChar);        
        
        pChar = strtok(NULL,",");
        func = atoi(pChar);        
        
        pChar = strtok(NULL,",");
        reg = atoi(pChar);        
        
        pChar = strtok(NULL,",");
        numRegs = atoi(pChar);
        
        this->readings[this->numReadings-1].addr=addr;
        this->readings[this->numReadings-1].func=func;
        this->readings[this->numReadings-1].reg=reg;
        this->readings[this->numReadings-1].numRegs=numRegs;    
    }
    
}

void device::setAlarm(char *linha)
{    
    float floatVar;
    uint32_t aux32_t;
    uint16_t aux16_t;
    char *pChar;    

    if(strstr(linha,"alarmSet")) {
            //Inicialização de contadores de alarme
            //É necessário inicializar estes dados para quando a máquina de alarmes rodar ter um inicio correto.
            this->alarms[this->numAlarms].secAlarm=0;
            this->alarms[this->numAlarms].idAct=0;
            this->alarms[this->numAlarms].on=0;
            this->alarms[this->numAlarms].alarmFound = false;
            //Inicialização de contadores de alarme            
            this->numAlarms++;            
    }

    if(strstr(linha,"idAlarm:")){
        strtok(linha,":");
        this->alarms[this->numAlarms-1].id = atoi(strtok(NULL,"\r\n"));
    }
    
    if(strstr(linha,"seconds:")) {        
        strtok(linha,":");
        pChar = strtok(NULL,"\r\n");
        this->alarms[this->numAlarms-1].seconds = atoi(pChar);
    }    
    
    if(strstr(linha,"on:")) {        
        strtok(linha,":");
        pChar = strtok(NULL,"\r\n");
        this->alarms[this->numAlarms-1].on = atoi(pChar);
    }
    
    if(strstr(linha,"idAct:")) {        
        strtok(linha,":");        
        this->alarms[this->numAlarms-1].idAct = atoi(strtok(NULL,""));
        return;
    }

    if(strstr(linha,"bit,")){
        this->alarms[this->numAlarms-1].type=modBusType_bit;

        pChar = strtok(linha,",");        
        
        //Parametro1
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].addrModbusRead = atoi(pChar);    
        
        //Parametro2
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].funcModbusRead = atoi(pChar);
        
        //Parametro3
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].regModbusRead  = atoi(pChar);
        
        //Parametro4
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].max = (atoi(pChar) != 0); //Qualquer valor diferente de 0 é um
        
        //Parametro5
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].value[0]= (atoi(pChar) != 0); //Qualquer valor diferente de 0 é um
    }
    
    if(strstr(linha,"float,")) {
        this->alarms[this->numAlarms-1].type=modBusType_float;        
        strtok(linha,",");
        
        //Parametro 1;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].addrModbusRead = atoi(pChar);
        
        //Parametro 2;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].funcModbusRead = atoi(pChar);
        
        //Parametro 3;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].regModbusRead  = atoi(pChar);
        
        //Parametro 4;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].max = (atoi(pChar) != 0); //Qualquer valor diferente de 0 é um
                       
        //Parametro 5;
        pChar = strtok(NULL,"\r\n");        
        //floatVar = diversos::stringToFloat(pChar,100);        
        floatVar = atof(pChar);        

        this->floatToBin(1,&floatVar,&this->alarms[this->numAlarms-1].value[0]);
    }

    if(strstr(linha,"uint32_t,")) {
        this->alarms[this->numAlarms-1].type=modBusType_uint32_t;
        //sscanf(linha,"max:uint32_t,%lu,%lu,%lu,%lu",&aux1,&aux2,&aux3,&aux4);
        strtok(linha,",");
        
        //parametro1
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].addrModbusRead = atoi(pChar);
        
        //parametro2
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].funcModbusRead = atoi(pChar);
        
        //parametro3
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].regModbusRead  = atoi(pChar);
    
        //Parametro 4;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].max = (atoi(pChar) != 0); //Qualquer valor diferente de 0 é um
        
        //parametro5
        pChar = strtok(NULL,"\r\n");
        aux32_t = atoi(pChar);

        this->uint32_t_ToBin(1,&aux32_t,&this->alarms[this->numAlarms-1].value[0]);
    }    
    
    
    
    if(strstr(linha,"uint16_t,")) {
        this->alarms[this->numAlarms-1].type=modBusType_uint16_t;
        strtok(linha,",");
        
        //parametro1
        pChar = strtok(NULL,",");    
        this->alarms[this->numAlarms-1].addrModbusRead = atoi(pChar);
        
        //parametro2
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].funcModbusRead = atoi(pChar);
        
        //parametro3
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].regModbusRead  = atoi(pChar);
        
        //Parametro 4;
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].max = (atoi(pChar) != 0); //Qualquer valor diferente de 0 é um
        
        //parametro5
        pChar = strtok(NULL,"\r\n");
        aux16_t = atoi(pChar);

        this->uint16_t_ToBin(1,&aux16_t,&this->alarms[this->numAlarms-1].value[0]);
    }
}

void device::setSchedule(char *linha)
{    
    //float floatVar;
    //uint32_t aux32_t;
    //uint16_t aux16_t;
    char *pChar;
    
    if(strstr(linha,"scheduleSet")) {        
            //Inicialização de contadores de schedules
            //É necessário inicializar estes dados para quando a máquina de schedules rodar ter um inicio correto.                
            this->schedules[this->numSchedules].actSent = false;
            //Inicialização de contadores de schedules
            this->numSchedules++;
    }

    if(strstr(linha,"idSchedule:")) {
        strtok(linha,":");
        pChar = strtok(NULL,"");
        this->schedules[this->numSchedules-1].id = atoi(pChar);
    }

    if(strstr(linha,"dayTime:")) {
        strtok(linha,":");
        pChar = strtok(NULL,",");
        this->schedules[this->numSchedules-1].weekday = atoi(pChar);
        pChar = strtok(NULL,"");
        this->schedules[this->numSchedules-1].minute = atoi(pChar);
    }

    if(strstr(linha,"idAct:")) {
        strtok(linha,":");
        pChar = strtok(NULL,"");
        this->schedules[this->numSchedules-1].idAct = atoi(pChar);        
    }
    /*pc.printf("Debugando erro em scheduleSet.\r\n");
    pc.printf("Linha <%s>\r\n",linha);
    pc.printf("actSent = %lu",this->schedules[this->numSchedules-1].actSent);
    pc.printf("idSchedule = %lu",this->schedules[this->numSchedules-1].id);
    pc.printf("dayTime = %lu",this->schedules[this->numSchedules-1].weekday);
    pc.printf("idAct = %lu",this->schedules[this->numSchedules-1].idAct);    
    pc.printf("Debugando erro em scheduleSet.\r\n");*/
}

void device::setScheduleException(char *linha)
{    
    //float floatVar;
    //uint32_t aux32_t;
    //uint16_t aux16_t;
    char *pChar;
    if(strstr(linha,"scheduleExceptionSet")) {
            //Inicialização de contadores de schedulesExceptions
            this->numScheduleExceptions++;
    }

    if(strstr(linha,"idSchedule:")) {
        strtok(linha,":");
        this->scheduleExceptions[this->numScheduleExceptions-1].id_schedule = atoi(strtok(NULL,"\r\n"));
    }

    if(strstr(linha,"timestamp:")) {
        strtok(linha,":");
        pChar = strtok(NULL,",");
        this->scheduleExceptions[this->numScheduleExceptions-1].timestamp = atoi(pChar);
    }
}

/*void device::writeReadingsToSD(){    
    //Esta função faz a inserção de todos os dados no arquivo armazenamento.            
    uint16_t readingIndex=0;

    float *floatBuffer;
    uint32_t *uint32_tBuffer;
    uint16_t *uint16_tBuffer;
    bool *boolBuffer;
    uint32_t seconds_uint32_t;
    
    //char registro[1024];
    //uint16_t indexRegistro;
    
    seconds_uint32_t = (uint32_t) time(NULL);
    
    //Inicio da string dentro do arquivo binario
    sdCard::insereDadosBank("log{data:",9);            
    
    //O timestamp é posto nos 4 primeiros bytes (segundos)    
    sdCard::insereDadosBank(&sdCard::armazenamento,(char *)&seconds_uint32_t,4);
    
    for(readingIndex = 0;readingIndex < this->numReadings;readingIndex++){
        switch(this->readings[readingIndex].type){
            case modBusType_float:                    
                    floatBuffer = (float*) malloc(this->readings[readingIndex].numRegs*sizeof(float));                    
                    modBusMaster1::readFloat(
                        this->readings[readingIndex].addr,
                        this->readings[readingIndex].func,
                        this->readings[readingIndex].reg,
                        this->readings[readingIndex].numRegs,
                        floatBuffer
                    );
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCard::insereDadosBank((char *)floatBuffer,sizeof(float)*this->readings[readingIndex].numRegs);
                    free(floatBuffer);
                break;
            case modBusType_uint32_t:
                    uint32_tBuffer = (uint32_t*) malloc(this->readings[readingIndex].numRegs*sizeof(uint32_t));                                        
                    modBusMaster1::readRegister32BIT(
                        this->readings[readingIndex].addr,
                        this->readings[readingIndex].func,
                        this->readings[readingIndex].reg,
                        this->readings[readingIndex].numRegs,
                        uint32_tBuffer
                    );
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCard::insereDadosBank((char *)uint32_tBuffer,sizeof(uint32_t)*this->readings[readingIndex].numRegs);
                    free(uint32_tBuffer);            
                break;
                
            case modBusType_uint16_t:
                    uint16_tBuffer = (uint16_t*) malloc(this->readings[readingIndex].numRegs*sizeof(uint16_t));                                        
                    modBusMaster1::readRegister16BIT(
                        this->readings[readingIndex].addr,
                        this->readings[readingIndex].func,
                        this->readings[readingIndex].reg,
                        this->readings[readingIndex].numRegs,
                        uint16_tBuffer
                    );
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCard::insereDadosBank((char *)uint16_tBuffer,sizeof(uint16_t)*this->readings[readingIndex].numRegs);
                    free(uint16_tBuffer); 
                break;
            
            case modBusType_bit:
                    boolBuffer = (bool*) malloc(this->readings[readingIndex].numRegs*sizeof(bool));                                        
                    modBusMaster1::readCoils(
                        this->readings[readingIndex].addr,                        
                        this->readings[readingIndex].reg,
                        this->readings[readingIndex].numRegs,
                        boolBuffer
                    );
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCard::insereDadosBank((char *)boolBuffer,sizeof(bool)*this->readings[readingIndex].numRegs);
                    free(boolBuffer); 
                break;
            
        }
    }    
    sdCard::insereDadosBank("}log",4);
}*/

uint8_t device::execAct(uint32_t index){
    //Primeiro preciso decidir que tipo de act estou lidando para tanto preciso pegar a ACT inteira.
    //Busca no arquivo
    //Abre arquivo
    char actString[1024];
    char indexBusca[15];
    char alarmsSetString[256];
    char alarmsResetString[256];    
    char *pTipoComando; 
    uint8_t tipoComando;
    bool endOfFile = false;
    uint8_t indexAlarms;    
    char *pChar;
    bool commandExecOk = true;
    uint8_t i;
    
    //Variáveis comuns;
    uint8_t param1;
    uint8_t param2;
    uint16_t param3;
    uint32_t param4;
    
    //printf("\r\n===================DEBUG(execAct)===================\r\n"); 
    sprintf(indexBusca,"idAct:%lu;",index);
    pc.printf("Lido <%s>.\r\n",indexBusca);
    //printf("Buscando por indexBusca<%s>.\r\n",indexBusca);  
    if(sdCard::abreArquivo(&sdCard::devices,"r")){
        do{
            endOfFile = feof(sdCard::devices.fp);                        
            if(!endOfFile){fgets(actString,1024,sdCard::devices.fp);}            
        }while((strstr(actString,"actList")==NULL)&&(endOfFile==0));
        pc.printf("Achei o actList.\r\n");
        do{
            endOfFile = feof(sdCard::devices.fp);
            if(!endOfFile){fgets(actString,1024,sdCard::devices.fp);}
            //printf("Linha ACT = <%s>.\r\nendOfFile = %u\r\n",actString,endOfFile);
        }while((strstr(actString,indexBusca)==NULL)&&(endOfFile==0));
        sdCard::fechaArquivo(&sdCard::devices);
        
        //Vê se deu tudo certo, se não encontrou, retorna false
        if(endOfFile){
            return false;
        }
        //Tudo correndo bem.
        
        //printf("\r\nPoint 1\r\n");
        
        //Encontrado o tipo de comando reutilizando a string indexBusca;
        pChar = strtok(actString,";");
        pc.printf("1- <%s>.\r\n",pChar);
        pChar = strtok(NULL,";");
        strcpy(alarmsSetString,pChar);
        pChar = strtok(NULL,";");
        strcpy(alarmsResetString,pChar);               
        
        pTipoComando = strtok(NULL,",");        
        
        printf("\r\nPoint 2 comando <%s>\r\n",pTipoComando);
        if(strstr(pTipoComando,"float")){tipoComando = modBusType_float;}
        if(strstr(pTipoComando,"bit")){tipoComando = modBusType_bit;}
        if(strstr(pTipoComando,"uint8_t")){tipoComando = modBusType_uint8_t;}
        if(strstr(pTipoComando,"uint16_t")){tipoComando = modBusType_uint16_t;}
        if(strstr(pTipoComando,"uint32_t")){tipoComando = modBusType_uint32_t;}
        if(strstr(pTipoComando,"IR")){tipoComando = IrCommandType;}
        if(strstr(pTipoComando,"PWM")){tipoComando = PWMCommandType;}        
    }else{
            return false;
     }
     
    switch(tipoComando){        
        case modBusType_float:
                float floatValueToWrite;
                uint32_t auxMod;
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));                
                //floatValueToWrite = diversos::stringToFloat(strtok(NULL,","),100);                
                floatValueToWrite = atof(strtok(NULL,","));

                //Envio comando via Modbus                
                if(modBusMaster1::writeFloat(
                    param1,
                    param3,
                    1,
                    &floatValueToWrite
                )){commandExecOk = false;}
            break;
        case modBusType_uint32_t:                
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));
                param4 = atoi(strtok(NULL,","));                
                
                if(modBusMaster1::writeRegister32BIT(
                    param1,
                    param3,
                    1,
                    &param4
                )){commandExecOk = false;}
            break;
        case modBusType_uint16_t:
                uint16_t param4_uint16_t;
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));
                param4_uint16_t = atoi(strtok(NULL,","));                
                
                if(modBusMaster1::writeRegister16BIT(
                    param1,
                    param3,
                    1,
                    &param4_uint16_t
                )){commandExecOk = false;}
            break;
        case modBusType_bit:                
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));
                param4 = atoi(strtok(NULL,","));
                
                if(param1 != 254){
                    //Envia comando via Modbus
                    if(modBusMaster1::writeSingleCoil(
                        param1,                    
                        param3,
                        (bool)param4
                    )){commandExecOk = false;}
                }else{
                    //Executa comando interno;
                    switch(param3){
                        case 0:
                                SD1.write(param4*1.0f);
                            break;
                        case 1:
                                SD2.write(param4*1.0f);
                            break;
                        case 2:
                                SD3.write(param4*1.0f);
                            break;
                        case 3:
                                SD4.write(param4*1.0f);
                            break;
                        case 4:
                                SD5.write(param4*1.0f);
                            break;
                        case 5:
                                SD6.write(param4*1.0f);
                            break;
                        case 6:
                                SD7 = param4;
                            break;                            
                        case 7:
                                SD8 = param4;
                            break;                            
                    }   
                 }
            break;
        case IrCommandType:
                //Busca no arquivo
                //Abre arquivo                
                //printf("\r\nIniciando execucao de comando IR\r\n");
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));          
                //printf("\r\nparam 1 %lu, param2 %lu\r\n",param1,param2);
                pTipoComando = strtok(NULL,"S");//Reaproveitando variável pTipoComando
                //printf("\r\nPacote IR <%s>.\r\n",pTipoComando);    
                deserializaPacoteIR(pTipoComando);
                //printf("Deserializado.\r\nInicio do envio.\r\n");
                if(param1){
                    enviaComandoIR(param1,param2);
                }else{
                    for(i=33;i<41;i++){
                        enviaComandoIR(i,param2);
                        if(i!=40){osDelay(100);}    
                    } 
                 }
                //printf("Fim do envio.\r\n");
            break;
        
        case PWMCommandType:
                //float floatValuePWM;
                //uint32_t auxPeriod;
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));                
                //floatValueToWrite = diversos::stringToFloat(strtok(NULL,","),100);                
                floatValueToWrite = atof(strtok(NULL,","));
                
                //Executa comando interno;
                auxMod = floatValueToWrite/10;
                floatValueToWrite = floatValueToWrite-(auxMod*10);
                SD1.period_us(auxMod);
                pwmPeriod = auxMod;
                switch(param3){
                    case 0:                                
                            SD1.write(floatValueToWrite);
                        break;
                    case 1:
                            SD2.write(floatValueToWrite);
                        break;
                    case 2:
                            SD3.write(floatValueToWrite);
                        break;
                    case 3:
                            SD4.write(floatValueToWrite);
                        break;
                    case 4:
                            SD5.write(floatValueToWrite);
                        break;
                    case 5:
                            SD6.write(floatValueToWrite);
                        break;                                                 
                }                
            break;
        
        default:
                //printf("comando nao encontrado\r\n");
            break;        
    }
    //Coletando dados do alarmSet e alarmReset    
    
    pChar = strtok(alarmsSetString,",");
    while(pChar!=NULL){
        pc.printf("Lido Alarm Set %lu - <%lu>.\r\n",indexAlarms,atoi(pChar));
        dispositivos[0]->alarmOnOff(atoi(pChar),1);    
        pChar = strtok(NULL,",");
    }
    
    pChar = strtok(alarmsResetString,",");
    while(pChar!=NULL){
        pc.printf("Lido Alarm Reset %lu - <%lu>.\r\n",indexAlarms,atoi(pChar));
        dispositivos[0]->alarmOnOff(atoi(pChar),0);    
        pChar = strtok(NULL,",");
    }
    
    //printf("\r\n===================DEBUG(execAct)===================\r\n");    
    return commandExecOk;  
}

void device::alarmOnOff(uint32_t idAlarm,bool state){
    uint16_t alarmIndex;
    char indexBusca[30];    
    char alarmString[40];
    uint32_t seekPosition;
    bool endOfFile;
    char charState;
    
    for(alarmIndex = 0; alarmIndex < alarmes; alarmIndex++){
        if(this->alarms[alarmIndex].id == idAlarm){
            this->alarms[alarmIndex].on = state;
        }    
    }    
    
    if(!sdCard::abreArquivo(&sdCard::devices,"rb+")){return;}    
    
    sprintf(indexBusca,"idAlarm:%lu\r",idAlarm);    
    do{
        endOfFile = feof(sdCard::devices.fp);                        
        if(!endOfFile){fgets(alarmString,40,sdCard::devices.fp);}
    }while((strstr(alarmString,indexBusca)==NULL)&&(endOfFile==0));
    
    
    do{
        endOfFile = feof(sdCard::devices.fp);                        
        if(!endOfFile){fgets(alarmString,40,sdCard::devices.fp);}
    }while((strstr(alarmString,"on:")==NULL)&&(endOfFile==0));
                            
    
    if(endOfFile){
        sdCard::fechaArquivo(&sdCard::devices);
        return;
    }
    
    seekPosition = ftell(sdCard::devices.fp)-3;
    fseek(sdCard::devices.fp,seekPosition,SEEK_SET);
    if(state){charState='1';}else{charState='0';}    
    fputc(charState,sdCard::devices.fp);
    //fprintf(sdCard::devices.fp,"%u",state);
    fflush(sdCard::devices.fp);
    sdCard::fechaArquivo(&sdCard::devices);            
}

void device::writeReadingsToSD(){ 
    //Buffering before insertData   
    //Esta função faz a inserção de todos os dados no arquivo armazenamento.            
    uint16_t readingIndex=0;    
    /*
    union {
        char c[4];
        float v;
    }uFloat;
    */
    float *floatBuffer;
    uint32_t *uint32_tBuffer;
    uint16_t *uint16_tBuffer;    
    bool *boolBuffer;    
    uint32_t seconds_uint32_t;
    char seconds_char[5];    
    
    seconds_uint32_t = (uint32_t) time(NULL);
    seconds_char[0]=(seconds_uint32_t >> 0) & 0xFF;
    seconds_char[1]=(seconds_uint32_t >> 8) & 0xFF;
    seconds_char[2]=(seconds_uint32_t >> 16) & 0xFF;
    seconds_char[3]=(seconds_uint32_t >> 24) & 0xFF;
    seconds_char[4]=0;
    
    
    //Inicio da string dentro do arquivo binario
    //sdCardBuf.del();
    sdCardBuf.fill("log{data:",9);            
    
    //O timestamp é posto nos 4 primeiros bytes (segundos)    
    sdCardBuf.fill(seconds_char,5);
    
    for(readingIndex = 0;readingIndex < this->numReadings;readingIndex++){
        switch(this->readings[readingIndex].type){
            case modBusType_float:                    
                    if(this->readings[readingIndex].addr != enderecoControladoraVirtual){
                        //Busca externa via Modbus
                        floatBuffer = (float*) malloc(((this->readings[readingIndex].numRegs*sizeof(float))+1)); //Alocando mais um byte para status
                        modBusMaster1::readFloat(
                            this->readings[readingIndex].addr,
                            this->readings[readingIndex].func,
                            this->readings[readingIndex].reg,
                            this->readings[readingIndex].numRegs,
                            floatBuffer
                        );    
                    }else{
                        //Busca Interna
                        floatBuffer = (float*) malloc(sizeof(float));
                        if((this->readings[readingIndex].reg<100)&&(this->readings[readingIndex].reg < num_temperatureSensors)){//Registradores das entradas de temperatura
                            //Populando floatBuffer com a temperaturas                            
                            floatBuffer[0] = temperaturas[this->readings[readingIndex].reg];                            
                        }
                        if((this->readings[readingIndex].reg>100)&&(this->readings[readingIndex].reg<104)){
                            //Registradores das entradas analógicas                            
                            floatBuffer[0] = aiFiltrada[this->readings[readingIndex].reg - 100];                            
                        }
                        this->readings[readingIndex].numRegs = 1;
                     }
                    
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCardBuf.fill((char *)floatBuffer,((sizeof(float)*this->readings[readingIndex].numRegs)+1));//Ao fim appendo o byte de status
                    free(floatBuffer);
                break;
            case modBusType_uint32_t:
                    uint32_tBuffer = (uint32_t*) malloc((this->readings[readingIndex].numRegs*sizeof(uint32_t))+1); //Alocando mais um byte para status
                    if(this->readings[readingIndex].addr != enderecoControladoraVirtual){
                        modBusMaster1::readRegister32BIT(//Ponho o status no ultimo byte
                            this->readings[readingIndex].addr,
                            this->readings[readingIndex].func,
                            this->readings[readingIndex].reg,
                            this->readings[readingIndex].numRegs,
                            uint32_tBuffer
                        );
                        //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    }else{
                        uint32_tBuffer[0] = pulsosEDs[this->readings[readingIndex].reg];
                        this->readings[readingIndex].numRegs = 1;
                        pulsosEDs[this->readings[readingIndex].reg] = 0;
                     }
                    sdCardBuf.fill((char *)uint32_tBuffer,((sizeof(uint32_t)*this->readings[readingIndex].numRegs)+1));//Ao fim appendo o byte de status
                    free(uint32_tBuffer);            
                break;
                
            case modBusType_uint16_t:                    
                    if(this->readings[readingIndex].addr!=enderecoControladoraVirtual){
                        uint16_tBuffer = (uint16_t*) malloc(((this->readings[readingIndex].numRegs*sizeof(uint16_t))+1));//Alocando mais um byte para status
                        modBusMaster1::readRegister16BIT(//
                            this->readings[readingIndex].addr,
                            this->readings[readingIndex].func,
                            this->readings[readingIndex].reg,
                            this->readings[readingIndex].numRegs,
                            uint16_tBuffer
                        );
                        //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                        sdCardBuf.fill((char *)uint16_tBuffer,((sizeof(uint16_t)*this->readings[readingIndex].numRegs)+1));//Ao fim appendo o byte de status
                        free(uint16_tBuffer); 
                    }else{
                        if((this->readings[readingIndex].reg>0)&&((this->readings[readingIndex].reg + this->readings[readingIndex].numRegs)<=4)){                                                        
                            sdCardBuf.fill((char *)&aiFiltrada[this->readings[readingIndex].reg-1],sizeof(uint16_t)*this->readings[readingIndex].numRegs);    
                        }
                     }
                break;
            
            case modBusType_bit:
                    if(this->readings[readingIndex].addr != enderecoControladoraVirtual){
                        boolBuffer = (bool*) malloc(((this->readings[readingIndex].numRegs*sizeof(bool))+1));//Alocando mais um byte para status
                        modBusMaster1::readCoils(
                            this->readings[readingIndex].addr,                        
                            this->readings[readingIndex].reg,
                            this->readings[readingIndex].numRegs,
                            boolBuffer
                        );
                    }else{
                        boolBuffer = (bool*) malloc(sizeof(bool));
                        boolBuffer[0] = entradasDigitais[this->readings[readingIndex].reg];
                     }
                    //pc.printf("Lido dentro de modBusMaster1::teste() <%f>.\n",modBusMaster1::teste());
                    sdCardBuf.fill((char *)boolBuffer,((sizeof(bool)*this->readings[readingIndex].numRegs)+1));//Ao fim appendo o byte de status
                    free(boolBuffer); 
                break;
            
        }
    }    
    readingIndex = sdCardBuf.fill("}log",4); //Reaproveitando a variável de 16bit readingIndex
    sdCard::arquivoAberto(40000);
    //Insiro os dados se for possível.
    sdCard::insereDadosBank(sdCardBuf.get(),readingIndex);
}








device::device()
{
    this->numAlarms=0;
    this->numReadings=0;
}

int criaDevices(FILE *devicesCfg)
{
    char linha[maxCaractereLeLinha];
    int i;
    int linhas = 0;
    devices = 0;

    while(fgets(linha,maxCaractereLeLinha,devicesCfg)) {
        if(strstr(linha,"deviceCreate\\")) {
            devices++;
        }
        linhas++;
    }

    printf("Contei %u linha(s), %u device(s).\n",linhas,devices);

    //Criando vetor de objetos dispositivos;
    
    dispositivos = (device **) malloc(sizeof(device)*devices);

    for(i=0; i<devices; i++) {
        dispositivos[i] = new device();
        //dispositivos[i]->id=i;
    }

    rewind(devicesCfg);    
    return 1;
}


int configuraDevices(FILE *devicesCfg)
{
    uint16_t linhas=0;
    //uint16_t leituras = 0;
    char linha[maxCaractereLeLinha];
    uint8_t estadoConfiguracao=estadoConfiguracao_idle;
    int8_t dispositivoEmConfiguracao = -1;    

    while(fgets(linha,maxCaractereLeLinha,devicesCfg)){        
        if(strstr(linha,"alarmSet")) {
            //printf("Criando alarme no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            alarmes++;
            estadoConfiguracao = estadoConfiguracao_alarmSet;
        }        

        if(estadoConfiguracao == estadoConfiguracao_readingsSet){
            leituras++;
        }

        if(strstr(linha,"readingsSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);            
            estadoConfiguracao = estadoConfiguracao_readingsSet;
        }

        if(strstr(linha,"scheduleSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            qtdSchedules++;
            estadoConfiguracao = estadoConfiguracao_scheduleSet;
        }
        
        if(strstr(linha,"scheduleExceptionsSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            qtdScheduleExceptions++;
            estadoConfiguracao = estadoConfiguracao_scheduleSet;
        }

        linhas++;
    }
    printf("Contei %u linha(s), configurei %u dispositivo(s), instalei %u alarme(s), %u leituras(s) e %u schedule(s) nos dispositivo(s).\n",linhas,devices,alarmes,leituras,qtdSchedules);
    //Reservar memoria aqui.
    
    //if(resizeArray(this->numReadings, this->numReadings+1, (char **)&this->readings,sizeof(reading))) {        
    //(char *) malloc(sizeUnit*novo);
    dispositivos[0]->readings = (reading*) malloc(sizeof(reading)*leituras);
    dispositivos[0]->alarms = (alarm*) malloc(sizeof(alarm)*alarmes);
    dispositivos[0]->schedules = (schedule*) malloc(sizeof(schedule)*qtdSchedules);
    dispositivos[0]->scheduleExceptions = (scheduleException*) malloc(sizeof(scheduleException)*qtdScheduleExceptions);
    
    //Retornando ao inicio o arquivo
    rewind(devicesCfg);
    
    while(fgets(linha,maxCaractereLeLinha,devicesCfg)) {
        if(strstr(linha,"deviceCreate\\")) {
            dispositivoEmConfiguracao++;
            //printf("Configurando dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            estadoConfiguracao = estadoConfiguracao_creatingDevice;
        }

        if(strstr(linha,"alarmSet")) {
            //printf("Criando alarme no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            alarmes++;
            estadoConfiguracao = estadoConfiguracao_alarmSet;
        }

        if(strstr(linha,"readingsSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            leituras++;
            estadoConfiguracao = estadoConfiguracao_readingsSet;
        }

        if(strstr(linha,"scheduleExceptionSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            qtdScheduleExceptions++;
            estadoConfiguracao = estadoConfiguracao_scheduleExceptionSet;
        }

        if(strstr(linha,"readingsEnd")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            estadoConfiguracao = estadoConfiguracao_idle;
        }
        
        if(strstr(linha,"scheduleSet")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            qtdSchedules++;
            estadoConfiguracao = estadoConfiguracao_scheduleSet;
        }        

        if(strstr(linha,">")) {
            //printf("Fechando dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            estadoConfiguracao = estadoConfiguracao_idle;
        }

        switch(estadoConfiguracao) {
            case estadoConfiguracao_creatingDevice:
                /*if(strstr(linha,"id:")) {
                    sscanf(linha,"id:%u",&dispositivos[dispositivoEmConfiguracao]->id);                    
                }*/
                break;
            case estadoConfiguracao_alarmSet:
                //Inclue linha nos alarmes do dispositivo em configuração
                dispositivos[dispositivoEmConfiguracao]->setAlarm(linha);
                break;
            case estadoConfiguracao_readingsSet:
                //Inclue linha nas leituras do dispositivo em configuração
                dispositivos[dispositivoEmConfiguracao]->setReading(linha);
                break;
            case estadoConfiguracao_scheduleSet:
                //Inclue linha nos agendamentos do dispositivo em configuração
                dispositivos[dispositivoEmConfiguracao]->setSchedule(linha);
                break;
            case estadoConfiguracao_scheduleExceptionSet:
                //Inclue linha nas excessões dos agendamentos do dispositivo em configuração
                dispositivos[dispositivoEmConfiguracao]->setScheduleException(linha);
                break;                
        }
    }
    
    return 1;
}



void testaTudoDevices()
{
    int i;
    int j;

    for(i=0; i<devices; i++) {
        printf("Dispositivo %u tem %u alarmes sendo eles:\n",i,dispositivos[i]->numAlarms);

        for(j=0; j<dispositivos[i]->numAlarms; j++) {
            printf("Alarme %u:\n",j);
            printf("\tId <%lu>.\n",dispositivos[i]->alarms[j].id);
            printf("\tSeconds <%lu>.\n",dispositivos[i]->alarms[j].seconds);
            printf("\tAddr %u, func %u, reg %lu.\n",dispositivos[i]->alarms[j].addrModbusRead,dispositivos[i]->alarms[j].funcModbusRead,dispositivos[i]->alarms[j].regModbusRead);
            if(dispositivos[i]->alarms[j].type==modBusType_float) {
                float value;
                dispositivos[i]->floatToBin(0,&value,&dispositivos[i]->alarms[j].value[0]);                
                if(dispositivos[i]->alarms[j].max){
                    printf("\tFloat max <%f>.\n",value);
                }
                else{printf("\tFloat min <%f>.\n",value);}
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_uint32_t) {
                uint32_t value;
                dispositivos[i]->uint32_t_ToBin(0,&value,&dispositivos[i]->alarms[j].value[0]);
                if(dispositivos[i]->alarms[j].max){
                    printf("\tuint32_t max <%lu>.\n",value);
                }
                else{printf("\tuint32_t min <%lu>.\n",value);}
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_uint16_t) {
                uint16_t value;
                dispositivos[i]->uint16_t_ToBin(0,&value,&dispositivos[i]->alarms[j].value[0]);
                if(dispositivos[i]->alarms[j].max){
                    printf("\tuint16_t max <%lu>.\n",value);
                }
                else{printf("\tuint16_t min <%lu>.\n",value);}
            }            
            
            if(dispositivos[i]->alarms[j].type==modBusType_bit) {
                uint8_t value;
                value=dispositivos[i]->alarms[j].value[0];                
                if(dispositivos[i]->alarms[j].max){
                    printf("\tBIT max <%lu>.\n",value);
                }
                else{printf("\tBIT min <%lu>.\n",value);}
            }            
            
            printf("\tact:%lu\n",dispositivos[i]->alarms[j].idAct);
        }
        
        printf("Dispositivo %u tem %u schedules sendo eles:\n",i,dispositivos[i]->numSchedules);        
        for(j=0; j<dispositivos[i]->numSchedules; j++) {
            printf("Schedule %u:\n",j);
            printf("\tId <%lu>.\n",dispositivos[i]->schedules[j].id);
            printf("\tweekday <%lu>.\n",dispositivos[i]->schedules[j].weekday);
            printf("\tminute <%lu>.\n",dispositivos[i]->schedules[j].minute);
            printf("\tidAct <%lu>.\n",dispositivos[i]->schedules[j].idAct);
        }
        
        printf("Dispositivo %u tem %u scheduleExceptions sendo eles:\n",i,dispositivos[i]->numScheduleExceptions);        
        for(j=0; j<dispositivos[i]->numScheduleExceptions; j++) {
            printf("scheduleException %u:\n",j);
            printf("\tid_schedule <%lu>.\n",dispositivos[i]->scheduleExceptions[j].id_schedule);
            printf("\ttimestamp <%lu>.\n",dispositivos[i]->scheduleExceptions[j].timestamp);            
        }

        printf("Dispositivo %u tem %u leituras sendo elas:\n",i,dispositivos[i]->numReadings);
        for(j=0; j<dispositivos[i]->numReadings; j++) {
            printf("Leitura %u:",j);
            switch(dispositivos[i]->readings[j].type) {
                case modBusType_float:
                        printf("Tipo float ");
                    break;
                case modBusType_uint32_t:
                        printf("Tipo uint32_t ");
                    break;
                case modBusType_uint16_t:
                        printf("Tipo uint16_t ");
                    break;
                case modBusType_uint8_t:
                        printf("Tipo uint8_t ");
                    break;
                case modBusType_bit:
                        printf("Tipo bool ");
                    break;
            }
            printf("addr %u, func %u, reg %u, numRegs %u.\n",dispositivos[i]->readings[j].addr,dispositivos[i]->readings[j].func,dispositivos[i]->readings[j].reg,dispositivos[i]->readings[j].numRegs);
        }
    }
}