File content as of revision 0:8c59a494a451:

#include "devices.h"

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

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;
}

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;
    }
}

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++){
        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 != 254){
                        //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 = aiFiltrada[this->alarms[alarmIndex].regModbusRead];   
                     }
            
                    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]);                    
                    
                    //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
                    );                                       
            
                    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;
                            }
                        }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;
                            }
                        }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!=255){
                        //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 > 0) &&(this->alarms[alarmIndex].regModbusRead<4)){
                            leitura_uint16_t = aiFiltrada[this->alarms[alarmIndex].regModbusRead-1];
                        }
                     }
            
                    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 != 254){
                        //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
               if((!modemCom::status.emComunicacao)&&(!sdCard::arquivoAberto())){
                    sdCard::insereDadosArquivo(&sdCard::armazenamento,sdCardBuf.get(),leitura_uint16_t);
               }
               
               this->execAct(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
               if((!modemCom::status.emComunicacao)&&(!sdCard::arquivoAberto())){
                    sdCard::insereDadosArquivo(&sdCard::armazenamento,sdCardBuf.get(),leitura_uint16_t);
               }
            }                        
            //atrasa o envio em 3 segundos para que possa ser gravado o registro do alarme.
            enviaDadosPorAlarme=10;            
        }
       
        /*printf("\n\nAlarme \"%s\".\n",this->alarms[alarmIndex].name);
        printf("\nsecAlarme <%lu>.\n",this->alarms[alarmIndex].secAlarm);
        printf("\nthis->alarms[alarmIndex].alarmFound <%lu>.\n",this->alarms[alarmIndex].alarmFound);
        printf("\nalarmFound <%lu>.\n",alarmFound);
        printf("\nmax <%lu>.\n",this->alarms[alarmIndex].max);*/        
    }    
}

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++;
    }    
    hora = atoi(strtok(NULL,":"));
    minuto = atoi(strtok(NULL,""));
    minuto = (hora*60)+minuto;    
    for(indexSchedule = 0; indexSchedule < qtdSchedules; indexSchedule++){        
        //this->schedules[indexSchedule].weekday (Sun bit0, Mon bit1, Tue bit2, etc...)
        if(this->schedules[indexSchedule].weekday&(0x1<<weekday)){                      
            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;                    
                    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;
    }

    //printf("O tamanho da struct eh <%lu>.\n",sizeof(reading));

    
    if(resizeArray(this->numReadings, this->numReadings+1, (char **)&this->readings,sizeof(reading))) {        
        //printf("Resize em readings beleza!\n");
        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")) {
        if(resizeArray(this->numAlarms, this->numAlarms+1, (char **)&this->alarms,sizeof(alarm))) {                        
            
            //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].alarmFound = false;            
            //Inicialização de contadores de alarme
            
            this->numAlarms++;            
        }
    }

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

    
    if(strstr(linha,"seconds:")) {
        //sscanf(linha,"seconds:%lu",&this->alarms[this->numAlarms-1].seconds);
        strtok(linha,":");
        pChar = strtok(NULL,"\r\n");
        this->alarms[this->numAlarms-1].seconds = atoi(pChar);
    }    
    
    if(strstr(linha,"act:")) {        
        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")) {
        if(resizeArray(this->numSchedules, this->numSchedules+1, (char **)&this->schedules,sizeof(schedule))) {
            //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,"id:")) {
        strtok(linha,":");
        this->schedules[this->numSchedules-1].id = atoi(strtok(NULL,"\r\n"));
    }

    
    if(strstr(linha,"dayTime:")) {        
        strtok(linha,":");
        pChar = strtok(NULL,",");
        this->schedules[this->numSchedules-1].weekday = atoi(pChar);
        pChar = strtok(NULL,"\r\n");
        this->schedules[this->numSchedules-1].minute = atoi(pChar);
    }
    
    if(strstr(linha,"act:")) {        
        strtok(linha,":");
        pChar = strtok(NULL,"");
        this->schedules[this->numSchedules-1].idAct = 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::insereDadosArquivo(&sdCard::armazenamento,"log{data:",9);            
    
    //O timestamp é posto nos 4 primeiros bytes (segundos)    
    sdCard::insereDadosArquivo(&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::insereDadosArquivo(&sdCard::armazenamento,(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::insereDadosArquivo(&sdCard::armazenamento,(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::insereDadosArquivo(&sdCard::armazenamento,(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::insereDadosArquivo(&sdCard::armazenamento,(char *)boolBuffer,sizeof(bool)*this->readings[readingIndex].numRegs);
                    free(boolBuffer); 
                break;
            
        }
    }    
    sdCard::insereDadosArquivo(&sdCard::armazenamento,"}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 *pTipoComando; 
    uint8_t tipoComando;
    bool endOfFile = false;

    //Variáveis comuns;
    uint8_t param1;
    uint8_t param2;
    uint16_t param3;
    uint32_t param4;
    
    //printf("\r\n===================DEBUG(execAct)===================\r\n"); 
    sprintf(indexBusca,"actId:%lu,",index);
    //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);}
            //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;
        strtok(actString,",");
        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;}
    }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,","));
                
                if(param1 != 254){
                    //Envio comando via Modbus                
                    modBusMaster1::writeFloat(
                        param1,
                        param2,
                        param3,
                        &floatValueToWrite
                    );              
                }else{
                    //Executa comando interno;
                    auxMod = floatValueToWrite/10;
                    floatValueToWrite = floatValueToWrite-(auxMod*10);
                    SD1.period_us(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;
        case modBusType_uint32_t:                
                param1 = atoi(strtok(NULL,","));
                param2 = atoi(strtok(NULL,","));
                param3 = atoi(strtok(NULL,","));
                param4 = atoi(strtok(NULL,","));                
                
                modBusMaster1::writeRegister32BIT(
                    param1,
                    param2,
                    param3,
                    &param4
                );                    
            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,","));                
                
                modBusMaster1::writeRegister16BIT(
                    param1,
                    param2,
                    param3,
                    &param4_uint16_t
                ); 
            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
                    modBusMaster1::writeSingleCoil(
                        param1,                    
                        param3,
                        (bool)param4
                    );
                }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);
                enviaComandoIR(param1,param2);                    
            break;
        default:
                //printf("comando nao encontrado\r\n");
            break;        
    }
    //printf("\r\n===================DEBUG(execAct)===================\r\n");    
    return true;  
}

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 != 0){
                        //Busca externa via Modbus
                        floatBuffer = (float*) malloc(((this->readings[readingIndex].numRegs*sizeof(float))+1)); //Alocando mais um byte para status
                        ((char *)floatBuffer)[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
                        );    
                    }else{
                        //Busca Interna
                        floatBuffer = (float*) malloc(sizeof(float));
                        //Populando floatBuffer com a entrada analógica
                        floatBuffer[0] = aiFiltrada[this->readings[readingIndex].reg];                        
                     }
                    
                    //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
                    ((char *) uint32_tBuffer)[(this->readings[readingIndex].numRegs*sizeof(uint32_t))]=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());
                    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!=255){
                        uint16_tBuffer = (uint16_t*) malloc(((this->readings[readingIndex].numRegs*sizeof(uint16_t))+1));//Alocando mais um byte para status
                        ((char *) uint16_tBuffer)[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());
                        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 != 0){
                        boolBuffer = (bool*) malloc(((this->readings[readingIndex].numRegs*sizeof(bool))+1));//Alocando mais um byte para status
                        ((char *)boolBuffer)[this->readings[readingIndex].numRegs*sizeof(bool)]=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
    if((!modemCom::status.emComunicacao)&&(!sdCard::arquivoAberto())){
        //Insiro os dados se for possível.
        sdCard::insereDadosArquivo(&sdCard::armazenamento,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[40];
    uint8_t estadoConfiguracao=estadoConfiguracao_idle;
    int8_t dispositivoEmConfiguracao = -1;

    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);
            estadoConfiguracao = estadoConfiguracao_readingsSet;
        }

        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,"schedulesEnd")) {
            //printf("Criando leituras no dispositivo de indice %u.\n",dispositivoEmConfiguracao);
            estadoConfiguracao = estadoConfiguracao_idle;
        }

        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 nas leituras do dispositivo em configuração
                dispositivos[dispositivoEmConfiguracao]->setSchedule(linha);
                break;                
        }

        linhas++;
    }
    printf("Contei %u linha(s), configurei %u dispositivo(s), instalei %u alarme(s) e %u schedule(s) nos dispositivo(s).\n",linhas,devices,alarmes,qtdSchedules);    
    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 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);
        }
    }
}