File content as of revision 38:07d3907b74e5:

#include "devices.h"

//Devices
    device ** dispositivos;
    uint8_t devices=0;
    uint8_t alarmes=0;
//Devices

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

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

enum {        
    modBusType_float=0,
    modBusType_bit,
    modBusType_uint8_t,
    modBusType_uint16_t,
    modBusType_uint32_t
};

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::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,"bool,")) {
        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))) {            
            this->numAlarms++;
        }
    }

    if(strstr(linha,"name:")) {
        strtok(linha,":");
        strcpy(this->alarms[this->numAlarms-1].name,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,"bool:state")){        
        this->alarms[this->numAlarms-1].type=modBusType_bit;        
    
        pChar = strtok(linha,",");        
        
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].addrModbusRead = atoi(pChar);    
        
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].funcModbusRead = atoi(pChar);
        
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].regModbusRead  = atoi(pChar);
        
        pChar = strtok(NULL,",");
        this->alarms[this->numAlarms-1].max[0]=atoi(pChar);
    }
    
    
    if(strstr(linha,"max:float")) {
        this->alarms[this->numAlarms-1].type=modBusType_float;
        //sscanf(linha,"max:float,%lu,%lu,%lu,%s",&aux1,&aux2,&aux3,stringVar);
        //this->alarms[this->numAlarms-1].addrModbusRead = aux1;    
        //this->alarms[this->numAlarms-1].funcModbusRead = aux2;
        //this->alarms[this->numAlarms-1].regModbusRead  = aux3;    
        
        
        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,"\r\n");        
        floatVar = diversos::stringToFloat(pChar,100);        
    
        this->floatToBin(1,&floatVar,&this->alarms[this->numAlarms-1].max[0]);
    }    
    
    
    
    if(strstr(linha,"min:float")) {        
        this->alarms[this->numAlarms-1].type=modBusType_float;        
        strtok(linha,",");
        pChar = strtok(NULL,"\r\n");        
        floatVar = diversos::stringToFloat(pChar,100);
        this->floatToBin(1,&floatVar,&this->alarms[this->numAlarms-1].min[0]);
    }    
    
    if(strstr(linha,"max: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);
    
        //parametro4
        pChar = strtok(NULL,"\r\n");    
        aux32_t = atoi(pChar);
        
        this->uint32_t_ToBin(1,&aux32_t,&this->alarms[this->numAlarms-1].max[0]);
    }    
    
    if(strstr(linha,"min:uint32_t")) {        
        this->alarms[this->numAlarms-1].type=modBusType_uint32_t;
        //sscanf(linha,"min:uint32_t,%lu",&aux4);         
        strtok(linha,",");
        pChar = strtok(NULL,"\r\n");
        aux32_t = atoi(pChar);
        
        this->uint32_t_ToBin(1,&aux32_t,&this->alarms[this->numAlarms-1].min[0]);
    }    
    
    if(strstr(linha,"max: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);
    
        //parametro4
        pChar = strtok(NULL,"\r\n");    
        aux16_t = atoi(pChar);
        
        this->uint16_t_ToBin(1,&aux16_t,&this->alarms[this->numAlarms-1].max[0]);
    }    
    
    if(strstr(linha,"min:uint16_t")) {        
        this->alarms[this->numAlarms-1].type=modBusType_uint16_t;
        strtok(linha,",");
        pChar = strtok(NULL,"\r\n");
        aux16_t = atoi(pChar);
        
        this->uint16_t_ToBin(1,&aux16_t,&this->alarms[this->numAlarms-1].min[0]);
    }  
    
    if(strstr(linha,"max:uint8_t")) {
        this->alarms[this->numAlarms-1].type=modBusType_uint8_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);
    
        //parametro4
        pChar = strtok(NULL,"\r\n");    
        aux16_t = atoi(pChar);  
    
        this->alarms[this->numAlarms-1].max[0]=aux16_t;
    }    
    
    if(strstr(linha,"min:uint8_t")) {        
        this->alarms[this->numAlarms-1].type=modBusType_uint8_t;
        strtok(linha,",");
        pChar = strtok(NULL,"\r\n");
        aux16_t = atoi(pChar);
        
        this->alarms[this->numAlarms-1].min[0]=aux16_t;
    }    
    
        
    
    if(strstr(linha,"act:modbus:")) {
        //sscanf(linha,"act:modbus:%u,%u,%u,%u",&aux1,&aux2,&aux3,&aux4);
        
        printf("Lido em act <%s>.\n",linha);
        strtok(linha,":");
        strtok(NULL,":");
        
        
        //parametro1
        pChar = strtok(NULL,",");    
        this->alarms[this->numAlarms-1].addrModbusWrite = atoi(pChar);
        
        //parametro2
        pChar = strtok(NULL,",");    
        this->alarms[this->numAlarms-1].funcModbusWrite = atoi(pChar);
        
        //parametro3
        pChar = strtok(NULL,",");    
        this->alarms[this->numAlarms-1].regModbusWrite  = atoi(pChar);
    
        //parametro4
        pChar = strtok(NULL,"\r\n");    
        aux16_t = atoi(pChar);  
    
        this->alarms[this->numAlarms-1].act=aux16_t;
    }        
    
}

void device::writeReadingsToSD(){    
    //Esta função faz a inserção de todos os dados no arquivo armazenamento.            
    
    /*float floatBuffer[2];
    modBusMaster1::readFloat(9,4,1,2,floatBuffer);   
    pc.printf("Lido na fuc problema <%f,%f>.",floatBuffer[0],floatBuffer[1]);*/
    
    uint16_t readingIndex=0;    
    float *floatBuffer;    
    
    sdCard::insereDadosArquivo(&sdCard::armazenamento,"data{",5);    
    for(readingIndex = 0;readingIndex < this->numReadings;readingIndex++){
        switch(this->readings[readingIndex].type){
            case modBusType_float:
                    //readFloat(uint8_t,uint8_t,uint16_t,uint16_t,float*); //Endereço slave, funcCode, registrador, quantidade de registros,ponteiro para registros 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
                    );
                    sdCard::insereDadosArquivo(&sdCard::armazenamento,(char *)floatBuffer,4*this->readings[readingIndex].numRegs);
                    free(floatBuffer);
                break;
        }
    }
    sdCard::insereDadosArquivo(&sdCard::armazenamento,"}dataEnd;",9);
}


/*void device::verifyAlarms(){
    
}*/

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

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

int criaDevices(FILE *devicesCfg)
{
    char linha[40];
    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,">")) {
            //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;
        }

        linhas++;
    }
    printf("Contei %u linha(s), configurei %u dispositivo(s), instalei %u alarme(s) nos dispositivo(s).\n",linhas,devices,alarmes);    
    return 1;
}



void testaTudoDevices()
{
    int i;
    int j;

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

        for(j=0; j<dispositivos[i]->numAlarms; j++) {
            printf("Alarme %u:\n",j);
            printf("\tName <%s>.\n",dispositivos[i]->alarms[j].name);
            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 max,min;
                dispositivos[i]->floatToBin(0,&max,&dispositivos[i]->alarms[j].max[0]);
                dispositivos[i]->floatToBin(0,&min,&dispositivos[i]->alarms[j].min[0]);
                printf("\tFloat Max <%f>.\n",max);
                printf("\tFloat Min <%f>.\n",min);
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_uint32_t) {
                uint32_t max,min;
                dispositivos[i]->uint32_t_ToBin(0,&max,&dispositivos[i]->alarms[j].max[0]);
                dispositivos[i]->uint32_t_ToBin(0,&min,&dispositivos[i]->alarms[j].min[0]);
                printf("\tuint32_t Max <%lu>.\n",max);
                printf("\tuint32_t Min <%lu>.\n",min);
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_uint16_t) {
                uint16_t max,min;
                dispositivos[i]->uint16_t_ToBin(0,&max,&dispositivos[i]->alarms[j].max[0]);
                dispositivos[i]->uint16_t_ToBin(0,&min,&dispositivos[i]->alarms[j].min[0]);
                printf("\tuint16_t Max <%lu>.\n",max);
                printf("\tuint16_t Min <%lu>.\n",min);
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_uint8_t) {
                uint8_t max,min;
                max=dispositivos[i]->alarms[j].max[0];
                min=dispositivos[i]->alarms[j].min[0];
                printf("\tuint8_t Max <%u>.\n",max);
                printf("\tuint8_t Min <%u>.\n",min);
            }
            
            if(dispositivos[i]->alarms[j].type==modBusType_bit) {
                uint8_t max;
                max=dispositivos[i]->alarms[j].max[0];                
                printf("\tbool state <%u>.\n",max);                
            }

            printf("\tAct %u, Addr %u, func %u, reg %lu.\n",dispositivos[i]->alarms[j].act,dispositivos[i]->alarms[j].addrModbusWrite,dispositivos[i]->alarms[j].funcModbusWrite,dispositivos[i]->alarms[j].regModbusWrite);
        }

        printf("Dispositivo %u tem id %u, %u leituras sendo elas:\n",i,dispositivos[i]->id,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);
        }
    }
}