Diff: antigaDevices.txt

Revision:

0:1c0a769988ee

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/antigaDevices.txt	Fri Mar 24 15:54:41 2017 +0000
@@ -0,0 +1,626 @@
+#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);
+        }
+    }
+}
\ No newline at end of file