teste de publish
Dependencies: DS1820 HighSpeedAnalogIn devices mbed
Diff: antigaDevices.txt
- Revision:
- 0:1c0a769988ee
diff -r 000000000000 -r 1c0a769988ee antigaDevices.txt --- /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