Bruno Cavalcanti
teste de publish
Diff: devices.cpp
- Revision:
- 0:8c59a494a451
- Child:
- 1:3f9e5b86d9e4
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/devices.cpp Fri Mar 24 15:54:14 2017 +0000
@@ -0,0 +1,1485 @@
+#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,
+ ¶m4
+ );
+ 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,
+ ¶m4_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);
+ }
+ }
+}