diff --git a/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/project-colors.json b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/project-colors.json new file mode 100644 index 0000000..a8fda78 --- /dev/null +++ b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/project-colors.json @@ -0,0 +1,16 @@ +{ + "Version": 1, + "ProjectMap": { + "a2fe74e1-b743-11d0-ae1a-00a0c90fffc3": { + "ProjectGuid": "a2fe74e1-b743-11d0-ae1a-00a0c90fffc3", + "DisplayName": "Archivos varios", + "ColorIndex": -1 + }, + "c5f80730-f44f-4478-bdae-6634efc2ca88": { + "ProjectGuid": "c5f80730-f44f-4478-bdae-6634efc2ca88", + "DisplayName": "DomoEsp_v02", + "ColorIndex": 0 + } + }, + "NextColorIndex": 1 +} \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/.suo b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/.suo new file mode 100644 index 0000000..0d6ecf8 Binary files /dev/null and b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/.suo differ diff --git a/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/Browse.VC.db b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/Browse.VC.db new file mode 100644 index 0000000..e280234 Binary files /dev/null and b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/Browse.VC.db differ diff --git a/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/.suo b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/.suo new file mode 100644 index 0000000..e19223f Binary files /dev/null and b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/.suo differ diff --git a/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/Browse.VC.db b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/Browse.VC.db new file mode 100644 index 0000000..cd6911d Binary files /dev/null and b/DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/Browse.VC.db differ diff --git a/DomoEsp_Potencia_v02/.vs/ProjectSettings.json b/DomoEsp_Potencia_v02/.vs/ProjectSettings.json new file mode 100644 index 0000000..52565e8 --- /dev/null +++ b/DomoEsp_Potencia_v02/.vs/ProjectSettings.json @@ -0,0 +1,3 @@ +{ + "CurrentProjectSetting": "Visual Micro" +} \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/.vs/VSWorkspaceState.json b/DomoEsp_Potencia_v02/.vs/VSWorkspaceState.json new file mode 100644 index 0000000..8a2798d --- /dev/null +++ b/DomoEsp_Potencia_v02/.vs/VSWorkspaceState.json @@ -0,0 +1,7 @@ +{ + "ExpandedNodes": [ + "" + ], + "SelectedNode": "\\MqttVarManager.h", + "PreviewInSolutionExplorer": false +} \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/.vs/slnx.sqlite b/DomoEsp_Potencia_v02/.vs/slnx.sqlite new file mode 100644 index 0000000..c2c7ee0 Binary files /dev/null and b/DomoEsp_Potencia_v02/.vs/slnx.sqlite differ diff --git a/DomoEsp_Potencia_v02/CppProperties.json b/DomoEsp_Potencia_v02/CppProperties.json new file mode 100644 index 0000000..f183473 --- /dev/null +++ b/DomoEsp_Potencia_v02/CppProperties.json @@ -0,0 +1,8 @@ +{ + "configurations": [ + { + "name": "Visual Micro", + "intelliSenseMode": "windows-msvc-x86" + } + ] +} \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/DomoEspManager.cpp b/DomoEsp_Potencia_v02/DomoEspManager.cpp new file mode 100644 index 0000000..81ad722 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEspManager.cpp @@ -0,0 +1,138 @@ + +#include "DomoEspManager.h" +DomoEspManager::DomoEspManager() +{ + vars.config(NULL, NULL); + //vars.AddListenner(&sens); + //vars.AddListenner(&des); + sens.Config(&vars); + sens.buzz=&buzz; + suscrito=false; +} + +void DomoEspManager::inicia(WakeOnLan *pwol, LiquidCrystal *lcd, PubSubClient *mqttClient, WiFiClient* espClient, DomoConfig* conf) +{ + mqttclient=mqttClient; + #ifdef DEBUG_PS + Serial.println("Inicia Wifi"); + #endif + wifi.inicia(espClient, conf->ssidWifi, conf->keyWifi, conf->ideEsp); + #ifdef DEBUG_PS + Serial.println("Inicia Mqtt"); + #endif + mqtt.inicia(mqttClient,conf->ideEsp, conf->hostMQTT, conf->portMQTT, this); +#ifdef DEBUG_PS + Serial.println("Configura Sensores"); + #endif + //pasar funcion de configuracion de añadir sensores + + + conf->ConfigGen(&sens, &vars, &lcdm, &wol, &des); + + + #ifdef DEBUG_PS + Serial.println("Inicia variables"); + #endif + vars.inicia(mqttClient); + + #ifdef DEBUG_PS + Serial.println("Inicia Sensores"); + #endif + sens.inicia(); + #ifdef DEBUG_PS + Serial.println("Iniciado Desencadenadores"); + #endif + des.inicia(&vars); + + + + #if CON_LCD + #ifdef DEBUG_PS + Serial.println("Iniciado LCD"); + #endif + //busca buzzer + int ibuzzer=-1; + for(int i=0; itipo == MqttSensor::SENS_BUZZ_OUT) + { + ibuzzer=s->ivar; + #ifdef DEBUG_PS + Serial.println("encuentrado buz"); + #endif + break; + } + } + #ifdef DEBUG_PS + Serial.println("inicia LCD"); + #endif + lcdm.inicia(&vars, lcd, conf->lcd.colum, conf->lcd.lines, ibuzzer); + #ifdef DEBUG_PS + Serial.println("iniciado LCD"); + #endif + #endif + wol.inicia(pwol); + +} + +void DomoEspManager::loop() +{ + + if(!wifi.loop()) + { + suscrito=false; + return; + } + + if(!mqtt.loop()) + { + suscrito=false; + return; + } + + if(!suscrito) + { + vars.Suscribe(); + #if CON_LCD + lcdm.suscribe(mqttclient); + #endif + wol.suscribe(mqttclient); + suscrito=true; + } + + sens.loop(); + vars.loop(); + des.loop(); + #if CON_LCD + lcdm.loop(); + #endif +} + +void DomoEspManager::OnMqtt(char* topic, char* payload) +{ + vars.OnMqtt(topic, payload); + des.OnMqtt(topic, payload); + #if CON_LCD + lcdm.OnMqtt(topic, payload); + #endif + + #if CON_WOL + wol.OnMqtt(topic, payload); + #endif + + #ifdef DEBUG_PS + Serial.println("OnMqtt fin"); + #endif +} + +void DomoEspManager::SubscribeMqtt(PubSubClient *client_mqtt) +{ + +} diff --git a/DomoEsp_Potencia_v02/DomoEspManager.h b/DomoEsp_Potencia_v02/DomoEspManager.h new file mode 100644 index 0000000..bca0977 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEspManager.h @@ -0,0 +1,115 @@ + +#ifndef DomoEspManagerDef +#define DomoEspManagerDef 1 + +//#include //este para esp8266 +//#include +#include +#include +/* +#include +#include +#include +*/ +#include "MqttVarManager.h" +#include "MqttUtiles.h" +#include "MqttSensManager.h" +#include "MqttDesencadenadorManager.h" +#include "LcdMQTTViewer.h" +#include "MqttWOLManager.h" + + +#if CON_LCD +//configuracion del lcd-------------------------- +#include + + +#include "LcdMQTTViewer.h" + +#endif + + +class PubSubClient; +class WiFiClient; +class MqttSensManager; +class WakeOnLan; +/* + * clase principal + */ +class DomoLcdConfig +{ + public: + //pines + byte rs; + byte en;//eneable + byte d0; + byte d1; + byte d2; + byte d3; + + byte colum; + byte lines; +}; + +class DomoConfig +{ + public: + DomoLcdConfig lcd; + + + + char ssidWifi[24]; + char keyWifi[32]; + char ideEsp[32];//identificador unico por esp + char hostMQTT[16]; + int portMQTT; + + int velocidadPortSerie; + int refresTimeVars;//tiempo de refresco en segundos de las variables + + int refresTimeSens;//tiempo de refresco en segundos de los sensores + + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager *wol, MqttDesencadenadorManager *des)=0; + + +}; +//TODO falta funcion en configuracion para añadir sensores y variables +class DomoEspManager: public MqttReceiver +{ + public: + + + + PubSubClient *mqttclient; + //variables------------- + //MqttVarArray avar; + //MqttTopicAttay topics; + + MqttVarManager vars; + MqttSensManager sens; + + WifiManager wifi; + MqttManager mqtt; + + MqttDesencadenadorManager des; + + SonidoBuzzer buzz; + + LcdMQTTViewer lcdm; + + MqttWOLManager wol; + + bool suscrito; + + //PubSubClient client_qqtt(WifiManager::espClient); + DomoEspManager(); + //PubSubClient client_qqtt(espClient); + void inicia(WakeOnLan* pwol, LiquidCrystal *lcd,PubSubClient *mqttClient, WiFiClient* espClient, DomoConfig* conf); + void loop(); + + //funciones auxiliares + virtual void OnMqtt(char* topic, char* payload); + virtual void SubscribeMqtt(PubSubClient *client_mqtt); + +}; +#endif diff --git a/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.filters b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.filters new file mode 100644 index 0000000..e2bbce9 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.filters @@ -0,0 +1,75 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.ino b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.ino new file mode 100644 index 0000000..ba60205 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.ino @@ -0,0 +1,92 @@ +/* + * Software basico sersor domotica con esp8266 / esp32 nodemcu + * Controlado por mqtt + * --------------------------------------------------------------- + * compatible con: + * sensor temperatura y humedad hdt22 + * sensores digitales de entrada (gestionado por interrupciones) + * presion y altura por sensor bmp180 + * sensores digitales de salida + * receptor rf + * emisor rf + * -------------------------------------------------------------- + */ + +/* + * la temperatura se tiene que cambiar a digital interrupcion + */ +/*falta transimsion en rf out +Y PROBAR RF*/ + +#define VERSION_PROG "V0201"//indica version del programa +//#define CONEXION_ETERNET 0//indica si la conexion es ethernet o wifi (para aruino uno) +//falta guardar estado de relees en eprom-------------------------- + + +//includes----------------------------------------- +#include +#include //este para esp8266 +//#include //este para esp32 +#include +#include +#include + +WiFiUDP UDP; +#include +#include +#include +//#include + + +#include "DomoEspManager.h" + +#include "MqttWOLManager.h" +#include + +#include "config_rf.h" + +//variables globales---------------------------- +DomoEspManager domoManager; + + +DomoEspManager domoEspManager; +WiFiClient EspClient; +PubSubClient clienteMqtt(EspClient); +LiquidCrystal *plcd=NULL; +#if CON_LCD + LiquidCrystal lcd( + ConfiguracionActual.lcd.rs, + ConfiguracionActual.lcd.en, + ConfiguracionActual.lcd.d0,ConfiguracionActual.lcd.d1,ConfiguracionActual.lcd.d2,ConfiguracionActual.lcd.d3); + +#endif + +WakeOnLan* pwol=NULL; +#if CON_WOL + +WakeOnLan WOL(UDP); +//pwol=&WOL; +#endif +//funciones principales------------------------ +void setup() +{ + #if CON_LCD + plcd=&lcd; + #endif + #ifdef DEBUG_PS + Serial.begin(ConfiguracionActual.velocidadPortSerie); + delay(10); + Serial.println(""); + Serial.println("Iniciando"); + #endif + #if CON_WOL + pwol=&WOL; + #endif + domoManager.inicia(pwol,plcd,&clienteMqtt,&EspClient,&ConfiguracionActual); + +} + +void loop() +{ + domoManager.loop(); +} diff --git a/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.sln b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.sln new file mode 100644 index 0000000..1e33a11 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.32112.339 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DomoEsp_v02", "DomoEsp_v02.vcxproj", "{C5F80730-F44F-4478-BDAE-6634EFC2CA88}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|x86.ActiveCfg = Debug|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Debug|x86.Build.0 = Debug|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|x86.ActiveCfg = Release|Win32 + {C5F80730-F44F-4478-BDAE-6634EFC2CA88}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {1995B5A1-341C-4B18-B509-04838EC7A212} + EndGlobalSection +EndGlobal diff --git a/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj new file mode 100644 index 0000000..6a2c993 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj @@ -0,0 +1,142 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {C5F80730-F44F-4478-BDAE-6634EFC2CA88} + DomoEsp_Potencia_v02 + DomoEsp_Potencia_v02 + + + + Application + true + MultiByte + v143 + + + Application + false + true + MultiByte + v143 + + + Application + true + MultiByte + v143 + + + Application + false + true + MultiByte + v143 + + + Application + false + true + MultiByte + v143 + + + + + + + + + + + + + + + + + + + + + + + + + + Level3 + Disabled + true + $(ProjectDir)..\DomoEsp_Potencia_v02;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\libraries\SPI;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\libraries\ESP8266WiFi\src;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\libraries\ESP8266mDNS\src;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\libraries\ArduinoOTA;C:\Users\Gerardo\Documents\Arduino\libraries\SimpleDHT;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\libraries\Wire;C:\Users\Gerardo\Documents\Arduino\libraries\Adafruit_BMP085_Library;C:\Users\Gerardo\Documents\Arduino\libraries\WakeOnLan\src;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\cores\esp8266;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\cores\esp8266\avr;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\cores\esp8266\libb64;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\cores\esp8266\spiffs;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\cores\esp8266\umm_malloc;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\variants\nodemcu;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\tools\sdk\include;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\tools\sdk\lwip2\include;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\tools\sdk\libc\xtensa-lx106-elf\include;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\tools\xtensa-lx106-elf-gcc\3.0.4-gcc10.3-1757bed\xtensa-lx106-elf\include\c++\4.8.2;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\tools\xtensa-lx106-elf-gcc\3.0.4-gcc10.3-1757bed\xtensa-lx106-elf\include\c++\4.8.2\xtensa-lx106-elf;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\tools\xtensa-lx106-elf-gcc\3.0.4-gcc10.3-1757bed\xtensa-lx106-elf\include;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\tools\xtensa-lx106-elf-gcc\3.0.4-gcc10.3-1757bed\lib\gcc\xtensa-lx106-elf\4.8.2\include;C:\Users\Gerardo\AppData\Local\arduino15\packages\esp8266\hardware\esp8266\3.0.2\tools\sdk\include;%(AdditionalIncludeDirectories) + $(ProjectDir)__vm\.DomoEsp_Potencia_v02.vsarduino.h;%(ForcedIncludeFiles) + true + __ESP8266_esp8266__;__ESP8266_ESP8266__;_VMDEBUG=1;__ets__;ICACHE_FLASH;_GNU_SOURCE;MMU_IRAM_SIZE=0x8000;MMU_ICACHE_SIZE=0x8000;NONOSDK22x_190703=1;F_CPU=80000000L;LWIP_OPEN_SRC;TCP_MSS=536;LWIP_FEATURES=1;LWIP_IPV6=0;ARDUINO=108016;ARDUINO_ESP8266_NODEMCU_ESP12E;ARDUINO_ARCH_ESP8266;LED_BUILTIN=2;FLASHMODE_DIO;ESP8266;__cplusplus=201103L;_VMICRO_INTELLISENSE;%(PreprocessorDefinitions) + + + true + + + + + Level3 + MaxSpeed + true + true + true + + + true + true + true + + + + + + + VisualMicroDebugger + + + + CppCode + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj.user b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/LcdMQTTViewer.cpp b/DomoEsp_Potencia_v02/LcdMQTTViewer.cpp new file mode 100644 index 0000000..f480669 --- /dev/null +++ b/DomoEsp_Potencia_v02/LcdMQTTViewer.cpp @@ -0,0 +1,183 @@ + + +#include +#include +#include +#include "MqttDefines.h" +#include "MqttUtiles.h" +#include "MqttVarManager.h" + +#include "LcdMQTTViewer.h" + +void LcdMQTTViewer::envia(char* txt, int pos, int line) +{ + char buf[MAXTOPICVAR]; + + int l = strlen(txt); + if (l > nchar) + l = nchar; + + + + for (int i = 0; i < nchar; i++) + if (i < l) + buf[i] = txt[i]; + else + buf[i] = ' '; + + buf[nchar] = 0; + lcd->setCursor(pos, line); + lcd->print(buf); +} +LcdMQTTViewer::LcdMQTTViewer() +{ + panActual = 0; + ivarBuzzer=-1; + topic[0]=0; + maxpan = 0; + tiempo = 0; + incre_t = 10 * 1000; + for (int i = 0; i < MAXINFOLCD; i++) + { + LcdConf[i].ivar=-1; + LcdConf[i].formatLCD[0] = 0; + LcdConf[i].pan = 255; + } +} +void LcdMQTTViewer::setTimer(int seg) +{ + incre_t = seg * 1000; +} + +void LcdMQTTViewer::envia(int pan) +{ + char val[16]; + char buf[MAXTOPICVAR]; + for (int i = 0; i < maxtInfo; i++) + { + if (LcdConf[i].pan != pan) + continue; + if(LcdConf[i].ivar>=0) + { + MqttVar *v=vars->Get(LcdConf[i].ivar); + if(v==NULL) + continue; + //pilla valor + if(v->flags & MqttVar::FLOAT_VAR) + dtostrf(v->val.f,3, 2, val); + else + sprintf(val, "%d", (int)v->val.i); + sprintf(buf, LcdConf[i].formatLCD, val); + } + else + strcpy( buf, LcdConf[i].formatLCD); + + envia(buf,0, LcdConf[i].line); + } +} + +void LcdMQTTViewer::inicia(MqttVarManager *v, LiquidCrystal* lcdEx, int digi, int lines,int ibuz) +{ + ivarBuzzer=(byte)ibuz; + vars=v; + lcd =lcdEx; + nchar = digi; + lcd->begin(nchar, lines); + nlineslcd=lines; + for(int i=0; i= MAXINFOLCD) + return; + LcdConf[maxtInfo].ivar=ivar; + strcpy(LcdConf[maxtInfo].formatLCD, formatLCD); + LcdConf[maxtInfo].line = line; + LcdConf[maxtInfo].pan = pan; + maxtInfo++; + //recalcula numero de pantallas + if (maxpan < pan) + maxpan = pan; +} + +int LcdMQTTViewer::OnMqtt(char* top, char* payload) +{ + if(strcmp(top,topic)) + return -1; + + int i=0; + int lin=0; + int n=0; + char buf[MAXTOPICVAR*2]; + char imelod[12]; + int nmelod=0; + bool melodia=false; + while(payload[i]) + { + if(payload[i]=='\n') + { + i++; + buf[n]=0; + envia(buf,0,lin); + lin++; + n=0; + } + else if(payload[i]=='$') + { + if(melodia) + { + imelod[nmelod]=0; + melodia=false; + MQTTvalor v; + v.i=atoi(imelod); + + if(ivarBuzzer>=0 && nmelod>0) + vars->SetVal(ivarBuzzer,v); + } + else + { + nmelod=0; + melodia=true; + } + i++; + } + else + { + if(melodia) + imelod[nmelod++]=payload[i++]; + else + buf[n++]=payload[i++]; + } + } + buf[n]=0; + envia(buf,0,lin); + lin++; + for(; linsubscribe(topic); +} diff --git a/DomoEsp_Potencia_v02/LcdMQTTViewer.h b/DomoEsp_Potencia_v02/LcdMQTTViewer.h new file mode 100644 index 0000000..d3e701d --- /dev/null +++ b/DomoEsp_Potencia_v02/LcdMQTTViewer.h @@ -0,0 +1,54 @@ +/*#if ARDUINO >= 100 +#include "Arduino.h" +#else +#include "WProgram.h" +#endif*/ +#ifndef LcdMQTTViewerdef +#define LcdMQTTViewerdef 1 + +#include "MqttDefines.h" +class LiquidCrystal; +class PubSubClient; +class MqttVarManager; +struct LcdMQTTInfo +{ + byte ivar;//indice a variable + char formatLCD[MAXTOPICVAR];//formato + byte pan;//pantalla en la que sale + byte line;//linea en la que sale + +}; + +#define MAXINFOLCD 8 +class LcdMQTTViewer +{ +public: + LiquidCrystal *lcd; + int nchar;//caracteres maximos por linea del lcd + int maxtInfo; + int maxpan;//maximo de pantallas configuradas + int panActual;//pantalla que esta mostrando actualmente + byte nlineslcd;//lineas maximas del lcd + byte ivarBuzzer; + unsigned long tiempo; + unsigned long incre_t; + char topic[MAXSTR];//topic de mqtt Alarma + + MqttVarManager* vars; + + LcdMQTTInfo LcdConf[MAXINFOLCD]; + + LcdMQTTViewer(); + + void inicia(MqttVarManager *vars, LiquidCrystal* lcdEx, int digi, int lines,int ibuz); + void loop();//publica datos variables + int OnMqtt(char* topic, char* payload); + void suscribe(PubSubClient *client_qqtt); + //auxiliares---------------------------------------------------------- + void add(byte ivar, char* formatLCD, int line, int pan); + void setTimer(int seg); + void envia(char* txt, int pos, int line); + void envia(int pan); + //void revisa(); +}; +#endif diff --git a/DomoEsp_Potencia_v02/MqttDefines.h b/DomoEsp_Potencia_v02/MqttDefines.h new file mode 100644 index 0000000..eb32e6f --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttDefines.h @@ -0,0 +1,28 @@ + +#ifndef MqttDefinesDef +#define MqttDefinesDef 1 +//generales +#define DEBUG_PS 1 +#define CON_WOL 0 +#define CON_LCD 0 + +#define MAXTOPICVAR 32//maximo de caracteres de los topic de las variables + +//vars-------------------- +#define MAXVAR 24//maximo de variables totales +#define MAXSTR 2024//maximo de caracteres para str + +//sens-------------------- +#define MAXSENS 8 +#define MAXINTERRUP 8 +//desencadenadores-------- +#define MAXSTRDESEN 64 +#define MAXDESEN 24 +//class------------------- +class MqttOnVarChangeListenner +{ + public: + virtual void OnVarChange(int ivar)=0; +}; + +#endif diff --git a/DomoEsp_Potencia_v02/MqttDesencadenadorManager.cpp b/DomoEsp_Potencia_v02/MqttDesencadenadorManager.cpp new file mode 100644 index 0000000..0fff170 --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttDesencadenadorManager.cpp @@ -0,0 +1,431 @@ + +#include "MqttDesencadenadorManager.h" + + +MqttDesencadenador::MqttDesencadenador() +{ + activo = true; +} +MQTTvalor MqttDesencadenador::GetVarValue(char* ivar, MqttVarManager* vars) +{ + MqttVar* v = GetVar(ivar, vars); + return v->val; +} +float MqttDesencadenador::GetValue(char* ivar, MqttVarManager* vars) +{ + MqttVar* v = GetVar(ivar, vars); + if (v->flags & MqttVar::FLOAT_VAR) + return v->val.f; + return (float)v->val.i; +} + +int MqttDesencadenador::GetIvar(char* ivar) +{ + char buf[16]; + int n = strlen(ivar); + strcpy(buf, ivar); + buf[n - 1] = 0; + return atoi(buf); +} +MqttVar* MqttDesencadenador::GetVar(char* ivar, MqttVarManager* vars) +{ + return vars->Get(GetIvar(ivar)); +} +void MqttDesencadenador::ExeEfecto(MqttVarManager* vars, char* oper, char* x, char* y) +{ +#ifdef DEBUG_PS + + Serial.print("MqttDesencadenador::ExeEfecto: "); + Serial.print(oper); + Serial.print(" x: "); + Serial.print(x); + Serial.print(" y: "); + Serial.println(y); +#endif + + switch (oper[0]) + { + case('!'): + { + vars->InvierteVar(GetIvar(x)); + return; + } + case('='): + { + MqttVar* v = GetVar(x, vars); + MQTTvalor val = GetVarValue(x, vars); + if (v->flags & MqttVar::FLOAT_VAR) + val.f = atof(y); + else + val.i = atoi(y); + vars->SetVal(GetIvar(x), val); + return; + } + } +} +bool MqttDesencadenador::Eval(MqttVarManager* vars, char* oper, char* x, char* y) +{ +#ifdef DEBUG_PS + + Serial.print("MqttDesencadenador::eval: "); + Serial.print(oper); + Serial.print(" x: "); + Serial.print(x); + Serial.print(" y: "); + Serial.println(y); +#endif + //las variables estaran terminadas en } + float vx, vy; + //pilla valores + int nx = strlen(x); + int ny = strlen(y); + if (x[nx - 1] == '}') + vx = GetValue(x, vars); + else + vx = atof(x); + if (ny <= 0) + vy = 0; + else if (y[ny - 1] == '}') + vy = GetValue(y, vars); + else + vy = atof(y); + switch (oper[0]) + { + case('!'): + return vx != 1; + case('='): + return vx == vy; + case('<'): + { + if (oper[1] == '=') + return vx <= vy; + return vx < vy; + } + + case('>'): + if (oper[1] == '=') + return vx >= vy; + return vx > vy; + } + return false; + +} +int MqttDesencadenador::GetElementosOper(char* oper) +{ + if (oper[0] == '!') + return 1; + else + return 2; +} +void MqttDesencadenador::procesaOper(MqttExeParam* p) +{ + if (expresion[p->i] <= '9' && expresion[p->i] >= '0' || expresion[p->i] == '.' || expresion[p->i] == '{' || expresion[p->i] == ' ') + { + p->estado = 0; + p->toper = true; + p->oper[p->noper] = 0; + #ifdef DEBUG_PS + Serial.print("encontrado oper: "); + Serial.println( p->oper); + #endif + } + else + { + p->oper[p->noper++] = expresion[p->i]; + p->i++; + } +} + +void MqttDesencadenador::procesaVar(MqttExeParam* p) +{ + if ((expresion[p->i] <= '9' && expresion[p->i] >= '0') || expresion[p->i] == '.') + { + if (p->tvar1) + p->var2[p->nvar2++] = expresion[p->i]; + else + p->var1[p->nvar1++] = expresion[p->i]; + p->i++; + + + } + else + { + p->estado = 0; + if (expresion[p->i] == '}') + { + if (p->tvar1) + p->var2[p->nvar2++] = expresion[p->i]; + else + p->var1[p->nvar1++] = expresion[p->i]; + p->i++; + } + if (p->tvar1) + { + p->var2[p->nvar2] = 0; + p->tvar2 = true; + #ifdef DEBUG_PS + Serial.print("encontrado var2: "); + Serial.println( p->var2); + #endif + } + else + { + p->var1[p->nvar1] = 0; + p->tvar1 = true; + #ifdef DEBUG_PS + Serial.print("encontrado var1: "); + Serial.println( p->var1); + #endif + } + } +} +bool MqttDesencadenador::Exe(MqttVarManager* vars) +{ +#ifdef DEBUG_PS + + Serial.print("MqttDesencadenador::Exe: "); + Serial.print(expresion); + Serial.print(" activo: "); + Serial.println(activo); +#endif + //por ahora limite de 2 var + MqttExeParam p; + bool res = false; + while (expresion[p.i] != 0 && p.sigue) + { + /* + #ifdef DEBUG_PS + Serial.print("MqttDesencadenador::Exe: "); + Serial.print(expresion[i]); + Serial.print(" estado "); + Serial.println(estado); + #endif + */ + + switch (p.estado) + { + + case(0)://estado selector + { + //distincion de operar + if (p.toper) + { + if (p.oper[0] == '-' && p.oper[1] == '>') + { + + p.tcausa = true; + p.toper = false; + p.noper = 0; + p.oper[0] = 0; + if (!p.res || !activo) + { + activo = !p.res; + /* #ifdef DEBUG_PS + + Serial.println("Fin causa sale "); + #endif*/ + p.sigue = false; + break; + } + else + { + activo = false; + res = true; + /*#ifdef DEBUG_PS + activo=false; + Serial.println("Fin causa sigue "); + #endif*/ + } + } + else if (p.oper[0] == '&') + { + /* #ifdef DEBUG_PS + + Serial.println("operador and "); + #endif*/ + //p.tcausa=true; + p.toper = false; + p.noper = 0; + p.esAnd = true; + p.oper[0] = 0; + + } + else if (p.oper[0] == '|') + { + /*#ifdef DEBUG_PS + + Serial.println("operador or "); + #endif*/ + //p.tcausa=true; + p.toper = false; + p.noper = 0; + p.esAnd = false; + } + } + if (p.toper && p.tvar1 && (GetElementosOper(p.oper) == 1 || p.tvar2)) + { + + //valida causa + if (!p.tcausa) + { + //valida causa + if (p.esAnd) + p.res = p.res && Eval(vars, p.oper, p.var1, p.var2); + else + p.res = p.res || Eval(vars, p.oper, p.var1, p.var2); + + /* #ifdef DEBUG_PS + Serial.print("validaCausa res: "); + Serial.print(p.res); + Serial.print(" esAnd: "); + Serial.println(p.esAnd); + #endif*/ + + } + else + { + //ejecuta efecto + ExeEfecto(vars, p.oper, p.var1, p.var2); + } + /*#ifdef DEBUG_PS + + Serial.println("Fin oper "); + #endif*/ + p.tvar1 = p.tvar2 = p.toper = false; + p.nvar1 = p.nvar2 = p.noper = 0; + p.var1[0] = 0; + p.var2[0] = 0; + p.oper[0] = 0; + } + if (expresion[p.i] == ' ')//pasa de los espacios + { + p.i++; + break; + } + + //distincion de escalares + if ((expresion[p.i] <= '9' && expresion[p.i] >= '0') || expresion[p.i] == '.') + { + p.estado = 1; + if (p.tvar1) + p.nvar2 = 0; + else + p.nvar1 = 0; + } + else + { + //distincion de variables + if (expresion[p.i] == '{') + { + p.estado = 1; + p.i++; + } + else//distincion de operadores + { + p.estado = 2; + } + } + } + break; + case(1)://pillando var o escalar + procesaVar(&p); + break; + case(2)://pilla oper + procesaOper(&p); + break; + } + } +#ifdef DEBUG_PS + + Serial.println("MqttDesencadenador::Exe fin"); +#endif + return res; +} +//******************************************************************* +MqttDesencadenadorArray::MqttDesencadenadorArray() +{ + n = 0; +} + +MqttDesencadenador* MqttDesencadenadorArray::Get(int i) +{ + return &(data[i]); +} + +int MqttDesencadenadorArray::Add(MqttDesencadenador* var) +{ + data[n] = *var; + strcpy(data[n].expresion, var->expresion); + n++; + return n - 1; +} +//******************************************************************* +MqttDesencadenadorManager::MqttDesencadenadorManager() +{ + revisa = true; +} + +void MqttDesencadenadorManager::OnVarChange(int ivar) +{ + revisa = true; + //marca Accion-- +} + +void MqttDesencadenadorManager::inicia(MqttVarManager* v) +{ + vars = v; + if (des.n > 0) + { +#ifdef DEBUG_PS + Serial.println("MqttDesencadenador::inicia como listenner"); +#endif + vars->AddListenner(this); + } +} + +void MqttDesencadenadorManager::Suscribe() +{ + +} +int MqttDesencadenadorManager::OnMqtt(char* topic, char* payload) +{ + return -1; +} + +void MqttDesencadenadorManager::loop() +{ + if (revisa) + { + revisa = false; + RevisaDesencadenadores(); + } +} + +void MqttDesencadenadorManager::RevisaDesencadenadores() +{ +#ifdef DEBUG_PS + Serial.println("MqttDesencadenadorManager::RevisaDesencadenadores"); +#endif + bool revisa = true; + while (revisa) + { + revisa = false; + for (int i = 0; i < des.n; i++) + { + if (des.Get(i)->Exe(vars)) + revisa = true; + } + //desmarca Var de volatiles + vars->ResetVolatileVar(); + } + +#ifdef DEBUG_PS + Serial.println("RevisaDesencadenadores fin"); +#endif +} +void MqttDesencadenadorManager::AddDes(char* expresion) +{ + MqttDesencadenador d; + strcpy(d.expresion, expresion); + des.Add(&d); +} diff --git a/DomoEsp_Potencia_v02/MqttDesencadenadorManager.h b/DomoEsp_Potencia_v02/MqttDesencadenadorManager.h new file mode 100644 index 0000000..6f499ca --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttDesencadenadorManager.h @@ -0,0 +1,116 @@ + +#ifndef MqttDesencadenadorManagerDef +#define MqttDesencadenadorManagerDef 1 +#include +#include "MqttDefines.h" +#include "MqttVarManager.h" +//expresiones del tipo{1}&{2} +struct MqttExeParam +{ + char oper[3]; + byte noper; + char var1[8]; + byte nvar1; + char var2[8]; + byte nvar2; + + byte estado; + int i; + bool tvar1; + bool tvar2; + bool toper; + bool tcausa; + bool res; + bool sigue; + bool esAnd; + MqttExeParam() + { + + noper=0; + nvar1=0; + nvar2=0; + estado=0; + i=0; + tvar1=false; + tvar2=false; + toper=false; + tcausa=false; + res=true; + sigue=true; + esAnd=true; + var1[0]=0; + var2[0]=0; + } +}; +class MqttDesencadenador +{ + public: + char expresion[MAXSTRDESEN];//"{1}=1 -> !{2} " + bool activo;//se desactivan automaticamente cuando se cumple la condicion y se vuelve activar cuando deja de cumplirse + + MqttDesencadenador(); + + bool Exe(MqttVarManager *vars); + + //auxiliar---------------- + void procesaVar(MqttExeParam *p);//recoge expresion de variable o float + void procesaOper(MqttExeParam *p);//recoge operador + + MQTTvalor GetVarValue(char*ivar, MqttVarManager *vars); + int GetIvar(char*ivar); + MqttVar* GetVar(char*ivar, MqttVarManager *vars); + int GetElementosOper( char *oper); + + bool Eval(MqttVarManager *vars, char *oper, char*x, char*y);//evalua operador + + void ExeEfecto(MqttVarManager *vars, char *oper, char*x, char*y);//ejecuta efecto + + float GetValue(char *ivar, MqttVarManager *vars); +}; + +class MqttDesencadenadorArray +{ + public: + MqttDesencadenador data[MAXDESEN]; + int n; + + + MqttDesencadenadorArray(); + + MqttDesencadenador* Get(int i); + + int Add(MqttDesencadenador* var); + +}; +//falta acciones y efectos +//acciones tienen valor, tipo y ivar(indice a variable) +class MqttDesencadenadorManager: public MqttOnVarChangeListenner +{ + public: + MqttVarManager *vars; + //byte ivars[24]; + int nv; + MqttDesencadenadorArray des; + bool revisa; + MqttDesencadenadorManager(); + + //------------------- + + void inicia( MqttVarManager *vars);//inicia variables si hace falta + void Suscribe();//subscribe variables a mqtt + int OnMqtt(char* topic, char* payload);//entra trama mqtt devuelve indice a sensor cambiado + void loop();//publica datos variables + + //add------------ + void AddDes(char *expresion); + + + virtual void OnVarChange(int ivar); + + void RevisaDesencadenadores(); + +}; +/* + * + */ + #endif diff --git a/DomoEsp_Potencia_v02/MqttSensManager.cpp b/DomoEsp_Potencia_v02/MqttSensManager.cpp new file mode 100644 index 0000000..e3998e8 --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttSensManager.cpp @@ -0,0 +1,618 @@ +//#include //este para esp8266 + + + + + + +#include "MqttSensManager.h" +#include "MqttVarManager.h" +#include "MqttUtiles.h" + +MqttSensor::MqttSensor() +{ + ivar=-1; + flags=0; +} +void MqttSensor::Set(MqttSensor *s) +{ + tipo=s->tipo; + flags=s->flags; + pin=s->pin; + ivar=s->ivar; + ie=s->ie; +} +//******************************************************************* +MqttSensArray::MqttSensArray() +{ + n=0; +} + +MqttSensor* MqttSensArray:: Get(int i) +{ + if (i < 0 || i >= n) + return NULL; + return &(sens[i]); +} +MqttSensor* MqttSensArray::Ivar2Sen(int ivar) +{ + MqttSensor* res; + for(int i=0; iivar==ivar) + return res; + } + #ifdef DEBUG_PS + Serial.print("Sens::Ivar2Sen: no encontrada sensor de variable: "); + Serial.println(ivar); + #endif + return NULL; +} + +int MqttSensArray::Add(MqttSensor* var) +{ + sens[n].Set(var); + n++; + return n-1; +} +//******************************************************************* +MqttSensManager::MqttSensManager() +{ + + n_inter=0; + bloqueo_sens=false; + tiempo_sens=0; + SetTimeRefres(15);//por defecto 15 segundos + n_inter=0; + pMqttSensManager=this; +} +void MqttSensManager::SetTimeRefres(int seg) +{ + incre_tsens=seg*1000; +} +void MqttSensManager::Config(MqttVarManager* var) +{ + vars=var; +} + +MqttSensor* MqttSensManager::Get(int i) +{ + return sens.Get(i); +} + +void MqttSensManager::inicia() +{ + if(sens.n>0) + vars->AddListenner(this); +} +void MqttSensManager::inicia(int i) +{ + +} +void MqttSensManager::loop() +{ + + + if(bloqueo_sens) + return; + procesaInterrupciones(); + + if(MqttUtiles::pasa_incre(&tiempo_sens, incre_tsens)) + { + #ifdef DEBUG_PS + Serial.println("Procesa Sens"); + #endif + procesaSens(); + } +} +void MqttSensManager::AddAnalogIn(int pin, char* topic, bool valNegado) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_ANALOG_IN; + s.pin=pin; + if(valNegado) + s.flags=MqttSensor::FLAG_NEG; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR | MqttVar::FLOAT_VAR),topic); + int isen=sens.Add(&s); + //pinMode(s.pin, INPUT); +} +void MqttSensManager::AddDout(int pin, char* topic, bool defautlValor) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DIGI_OUT; + s.pin=pin; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR|MqttVar::OUT_VAR|MqttVar::ACCION_VAR),topic); + sens.Add(&s); + pinMode(s.pin, OUTPUT); + digitalWrite(s.pin, defautlValor); + vars->Get(s.ivar)->val.i = defautlValor; +} +void MqttSensManager::AddDoutPulsador(int pin, char* topic, bool defautlValor, int seg) +{ + MqttSensor s; + s.tipo = (int)MqttSensor::SENS_DIGI_OUT_PULSANTE; + s.pin = pin; + s.ivar = vars->AddVar((byte)(MqttVar::IN_VAR | MqttVar::OUT_VAR | MqttVar::ACCION_VAR), topic); + s.ie.pul.t = seg * 1000; + s.ie.pul.vd = defautlValor; + sens.Add(&s); + pinMode(s.pin, OUTPUT); + digitalWrite(s.pin, defautlValor); + vars->Get(s.ivar)->val.i = defautlValor; +} +void MqttSensManager::AddBuzz(int pin, char* topic) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_BUZZ_OUT; + s.pin=pin; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR|MqttVar::OUT_VAR|MqttVar::ACCION_VAR),topic); + sens.Add(&s); + pinMode(s.pin, OUTPUT); +} +void MqttSensManager::AddMelodia(char* m) +{ + if(buzz) + { + buzz->Add(m); + } +} +void MqttSensManager::AddDin(int pin, char* topic) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DIGI_IN; + s.pin=pin; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR|MqttVar::ACCION_VAR),topic); + int isen=sens.Add(&s); + pinMode(s.pin, INPUT); + + ConfiguraInterrupcion(isen); + +} +void MqttSensManager::AddDinRetardOff(int pin, int seg,char* topic) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DIGI_IN; + s.pin=pin; + s.flags=MqttSensor::FLAG_RETARD_OFF; + s.ie.retard.r=seg*1000; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR|MqttVar::ACCION_VAR),topic); + s.ie.retard.val=vars->Get(s.ivar)->val.i; + int isen=sens.Add(&s); + pinMode(s.pin, INPUT); + + ConfiguraInterrupcion(isen); +} +void MqttSensManager::AddDinRetardOn(int pin, int seg,char* topic) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DIGI_IN; + s.pin=pin; + s.flags=MqttSensor::FLAG_RETARD_ON; + s.ie.retard.r=seg*1000; + s.ivar=vars->AddVar((byte)(MqttVar::IN_VAR|MqttVar::ACCION_VAR),topic); + s.ie.retard.val=vars->Get(s.ivar)->val.i; + int isen=sens.Add(&s); + pinMode(s.pin, INPUT); + + ConfiguraInterrupcion(isen); +} +void MqttSensManager::AddDinAccion(int pin, char* topic) +{ + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DIGI_IN_PULSANTE; + s.pin=pin; + s.ivar=vars->AddVar((byte)MqttVar::ACCION_VAR,topic); + int isen=sens.Add(&s); + pinMode(s.pin, INPUT); + ConfiguraInterrupcion(isen); +} +void MqttSensManager::AddHDT22(int pin, char* topic) +{ + char buffer_t[32]; + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_DHT22; + s.pin=pin; + s.ie.dht.p=&cdht; + sprintf(buffer_t, "%s/t", topic); + s.ivar=vars->AddVar((byte)MqttVar::IN_VAR| MqttVar::FLOAT_VAR,buffer_t);//variable temperatura + sprintf(buffer_t, "%s/h", topic); + s.ie.dht.ivarH=vars->AddVar((byte)MqttVar::IN_VAR| MqttVar::FLOAT_VAR,buffer_t);//variable humedad + sens.Add(&s); +} + +void MqttSensManager::AddBMP180(int sda,int scl, char* topic) +{ + /* + if(bmppillado) + return; + bmppillado=true; + */ + + char buffer_t[32]; + MqttSensor s; + s.tipo=(int)MqttSensor::SENS_BMP180; + s.pin=sda; + s.ie.bmp.p=&bmp; + s.ie.bmp.pinScl=scl; + sprintf(buffer_t, "%s/t", topic); + s.ivar=vars->AddVar((byte)MqttVar::IN_VAR | MqttVar::FLOAT_VAR,buffer_t);//variable temperatura + sprintf(buffer_t, "%s/p", topic); + s.ie.bmp.ivarP=vars->AddVar((byte)MqttVar::IN_VAR,buffer_t);//variable presion + sprintf(buffer_t, "%s/a", topic); + s.ie.bmp.ivarA=vars->AddVar((byte)MqttVar::IN_VAR| MqttVar::FLOAT_VAR,buffer_t);//variable altura + sens.Add(&s); + + + //inicia------------------ + Wire.begin( s.pin,s.ie.bmp.pinScl); + int i=0; + while(!bmp.begin(), i<300) + { + i++; + delay(10); + } +} +void MqttSensManager::procesaSens() +{ + for(int i=0; iGet(s->ivar); + MQTTvalor val; + switch((int)s->tipo) + { + case((int)MqttSensor::SENS_DHT22)://pilla temperatura y humedad + { + //MqttVar *vh=vars->Get(s->ie.dht.ivarH); + float t,h; + for(int i=0; i<4; i++) + { + if (s->ie.dht.p->read2(s->pin, &t, &h, NULL) != SimpleDHTErrSuccess) + { + delay(20); + continue; + } + val.f = t; + vars->SetVal(s->ivar, val); + //v->val.f=t; + val.f = h; + vars->SetVal(s->ie.dht.ivarH, val); + //vh->val.f=h; + break; + } + break; + } + case((int)MqttSensor::SENS_BMP180)://pilla temperatura y humedad + { + //MqttVar *vp=vars->Get(s->ie.bmp.ivarP); + // MqttVar *va=vars->Get(s->ie.bmp.ivarA); + val.f = s->ie.bmp.p->readTemperature(); + vars->SetVal(s->ivar, val); + val.f = s->ie.bmp.p->readPressure(); + vars->SetVal(s->ie.bmp.ivarP, val); + val.f = s->ie.bmp.p->readAltitude(); + vars->SetVal(s->ie.bmp.ivarA, val); + /* + v->val.f=s->ie.bmp.p->readTemperature(); + vp->val.i=s->ie.bmp.p->readPressure();//pascales; + va->val.f=s->ie.bmp.p->readAltitude(); + */ + break; + } + case((int)MqttSensor::SENS_ANALOG_IN)://pilla temperatura y humedad + { + if(s->flags & MqttSensor::FLAG_NEG) + val.f =100.*((float)(1024- analogRead(s->pin)))/1024; + else + val.f =100.*((float)(analogRead(s->pin)))/1024; + vars->SetVal(s->ivar, val); + break; + } + /* case((int)MqttSensor::SENS_DIGI_IN): + { + if(s->flags & MqttSensor::FLAG_NEG) + v->val.i=(byte)(1- digitalRead(s->pin)); + else + v->val.i=(byte)digitalRead(s->pin); + break; + }*/ + default: + { + break; + } + } +} +void MqttSensManager::OnVarChange(int ivar) +{ + MqttSensor *s = sens.Ivar2Sen(ivar); + if(s==NULL) + return; + MqttVar *v=vars->Get(ivar); + #ifdef DEBUG_PS + Serial.println("MqttSensManager::OnChange "); + #endif + switch(s->tipo) + { + case((int)MqttSensor::SENS_DIGI_OUT): + { + #ifdef DEBUG_PS + Serial.println("Sens::OnVarChangeSensor Dout cambiado"); + #endif + if(s->flags & MqttSensor::FLAG_NEG) + digitalWrite( s->pin, (1-v->val.i)); + else + digitalWrite( s->pin, v->val.i); + break; + } + case((int)MqttSensor::SENS_DIGI_OUT_PULSANTE): + { + if ((v->val.i>0) != s->ie.pul.vd) + { +#ifdef DEBUG_PS + Serial.println("Sens::OnVarChangeSensor Dout Pulsante cambiado"); +#endif + if (s->flags & MqttSensor::FLAG_NEG) + digitalWrite(s->pin, (1 - v->val.i)); + else + digitalWrite(s->pin, v->val.i); + delay(s->ie.pul.t); + v->val.i = 1 - v->val.i; + if (s->flags & MqttSensor::FLAG_NEG) + digitalWrite(s->pin, (1 - v->val.i)); + else + digitalWrite(s->pin, v->val.i); + vars->OnChange(ivar, true); + } + break; + } + case((int)MqttSensor::SENS_BUZZ_OUT): + { + #ifdef DEBUG_PS + Serial.println("Sens::OnVarChangeSensor buz cambiado"); + #endif + if(v->val.i>0 && buzz) + { + buzz->Toca( s->pin, v->val.i-1); + v->val.i=0; + vars->OnChange(ivar, true); + } + + break; + } + default: + break; + } + #ifdef DEBUG_PS + Serial.println("OnVarChangeSensor fin"); + #endif +} + +void MqttSensManager::procesaInterrupciones() +{ + if(MqttChangeInterrup) + { + noInterrupts(); + MqttChangeInterrup=false; + interrupts(); + for(int i=0; iGet(s->ivar); + byte val=digitalRead(s->pin); + if(s->flags & MqttSensor::FLAG_RETARD_OFF && v->val.i!=val && val==0) + { + #ifdef DEBUG_PS + Serial.println("Se aplica retardo al off"); + #endif + s->ie.retard.val=val; + s->ie.retard.t=millis(); + } + else if(s->flags & MqttSensor::FLAG_RETARD_ON && v->val.i!=val && val!=0) + { + #ifdef DEBUG_PS + Serial.println("Se aplica retardo al on"); + #endif + s->ie.retard.val=val; + s->ie.retard.t=millis(); + } + else + { + ProcesaSenInterrupciones(ind_interrup[i]); + } + } + } + } + + + //comprueba sensores retrasados + for(int i=0; iflags & (MqttSensor::FLAG_RETARD_OFF | MqttSensor::FLAG_RETARD_ON))) + continue; + MqttVar *v=vars->Get(s->ivar); + if(v->val.i==s->ie.retard.val) + continue; + if(!MqttUtiles::pasa_incre(&s->ie.retard.t, s->ie.retard.r)) + continue; + #ifdef DEBUG_PS + Serial.println("Se detecta cambio en sensor retardado"); + #endif + ProcesaSenInterrupciones(ind_interrup[i]); + } +} +void MqttSensManager::ProcesaSenInterrupciones(int isen) +{ + MqttSensor* s=sens.Get(isen); + MqttVar *v=vars->Get(s->ivar); + byte val=digitalRead(s->pin); + switch((int)s->tipo) + { + case((int)MqttSensor::SENS_DIGI_IN): + { + //lee y llama a cambio si es necesario + + if(val!=v->val.i) + { + v->val.i=val; + vars->OnChange(s->ivar, true); + } + break; + } + case((int)MqttSensor::SENS_DIGI_IN_PULSANTE): + { + //lee y llama a cambio si es necesario + if(val!=v->val.i) + { + v->val.i=val; + vars->OnChange(s->ivar, true); + } + + //v->val.i=val; + //vars->OnChange(s->ivar); + + break; + } + default: + break; + } +} + + //funciones auxiliares de interrupcion------------------------------- + void MqttSensManager::OnInterrupcion(int i) + { + + //MqttSensor* s=sens.Get(ind_interrup[i]); + MqttChangeInterrup=true; + MqttChange_ind_interrup[i]=true; + } + void MqttSensManager::ConfiguraInterrupcion(int isen) + { + #ifdef DEBUG_PS + + Serial.println("Configurando interrupcion"); + #endif + MqttChange_ind_interrup[n_inter]=false; + ind_interrup[n_inter++]=isen; + + int pin=sens.Get(isen)->pin; + switch(n_inter-1) + { + case(0): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion0, CHANGE); + break; + case(1): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion1, CHANGE); + break; + case(2): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion2, CHANGE); + break; + case(3): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion3, CHANGE); + break; + case(4): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion4, CHANGE); + break; + case(5): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion5, CHANGE); + break; + case(6): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion6, CHANGE); + break; + case(7): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion7, CHANGE); + break; + /* + case(8): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion8, CHANGE); + break; + case(9): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion9, CHANGE); + break; + case(10): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion10, CHANGE); + break; + case(11): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion11, CHANGE); + break; + case(12): + attachInterrupt(digitalPinToInterrupt(pin), MqttSensManagerInterrupcion12, CHANGE); + break;*/ + } + + } + + + //chapuza que no se como hacerlo de otra manera + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion0() + { + pMqttSensManager->OnInterrupcion(0); + } + + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion1() + { + pMqttSensManager->OnInterrupcion(1); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion2() + { + pMqttSensManager->OnInterrupcion(2); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion3() + { + pMqttSensManager->OnInterrupcion(3); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion4() + { + pMqttSensManager->OnInterrupcion(4); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion5() + { + pMqttSensManager->OnInterrupcion(5); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion6() + { + pMqttSensManager->OnInterrupcion(6); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion7() + { + pMqttSensManager->OnInterrupcion(7); + } + /* + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion8() + { + pMqttSensManager->OnInterrupcion(8); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion9() + { + pMqttSensManager->OnInterrupcion(9); + } +ICACHE_RAM_ATTR void MqttSensManagerInterrupcion10() + { + pMqttSensManager->OnInterrupcion(10); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion11() + { + pMqttSensManager->OnInterrupcion(11); + } + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion12() + { + pMqttSensManager->OnInterrupcion(12); + }*/ diff --git a/DomoEsp_Potencia_v02/MqttSensManager.h b/DomoEsp_Potencia_v02/MqttSensManager.h new file mode 100644 index 0000000..b2810f9 --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttSensManager.h @@ -0,0 +1,220 @@ + +#ifndef MqttSensManagerDef +#define MqttSensManagerDef 1 + + +/* + * cambiar en lugar de a topic a variable---------- + SENS_DIGI_IN y SENS_ANALOG_IN + publican un topic (set) con el valor correspondiente + + SENS_DIGI_OUT + escuchara los set de un topic y publicara el get + + SENS_DHT22,//sensor temperatura y humedad + + sensor dobles de tipo SENS_ANALOG_IN + publicaran set del topic asociado pñadiendo /t/set /h/set + para temperatura y humedad + + + SENS_BMP180,//sensor presion + sensor triple SENS_ANALOG_IN + ublicaran set del topic asociado pñadiendo /t/set /p/set /a/set + para temperatura, presion, altitud + + */ +#include "MqttDefines.h" +#include +class SonidoBuzzer; +//class PubSubClient; +class MqttVarManager; +#include +#include +#include +struct DhtExt +{ + byte ivarH;//puntero a variable humedad + SimpleDHT22 *p; +}; +struct BmpExt +{ + byte ivarP; + byte ivarA; + int pinScl; + Adafruit_BMP085 *p; +}; +struct SensRetardado +{ + unsigned long t;//ultimo tiempo en el que se recivio el cambio + unsigned long r;//retardo + byte val;//valor actual a cambiar +}; +struct InfoPulsante +{ + unsigned long t;//puntero a variable humedad + bool vd;//valor por defecto; +}; +union MqttInfEx//informacion extra segun sensor +{ + DhtExt dht; + BmpExt bmp; + SensRetardado retard; + InfoPulsante pul; + //DinEx din; +}; +class MqttSensor +{ + public: + + enum Tipo_sens//indica el tipo de sensor + { + SENS_NO_ASIG=0,//sensor sin asignar + SENS_DHT22,//sensor temperatura y humedad + SENS_BMP180,//sensor presion + SENS_ANALOG_IN,//sensor analogico in + SENS_DIGI_IN,//sensor digital in (algo con 2 estados) + SENS_DIGI_OUT,//sensor digital out + SENS_DIGI_IN_PULSANTE,//pensado para pulsadores + SENS_BUZZ_OUT,//sensor digital out con buzzer conectado + SENS_DIGI_OUT_PULSANTE,//pensado para hacer efecto pulsador + //SENS_DIGI_IN_OUT//sensor doble de entrada y salida (dos pines que tienen que tener el mismo valor) + }; + + enum Tipo_flags//indica el tipo de sensor + { + FLAG_NEG=0x01,//indica que el resultado del sensor hay que negarlo (valor invertido) + FLAG_INMED=0x02,//indica que es un sensor de actualizacion inmediata (interruptores ...) (TODO) + FLAG_RETARD_OFF=0X04,//indica que el sensor tiene un off con efecto retardado configurable + FLAG_RETARD_ON=0X08//indica que el sensor tiene un on con efecto retardado configurable + + }; + + + byte tipo;//tipo sensor + byte flags;//flags sensor + int pin;//pin de conexion scl para bmp + byte ivar;//indice a variable + MqttInfEx ie;//informacion extra + + MqttSensor(); + void Set(MqttSensor *s); + +}; + +//array de sensores-------------------------------------------------------------- +class MqttSensArray +{ + public: + MqttSensor sens[MAXSENS];//array de variables + int n; + + + MqttSensArray(); + + MqttSensor* Get(int i); + MqttSensor* Ivar2Sen(int ivar); + + int Add(MqttSensor* var); + +}; + +//array de sensores-------------------------------------------------------------- + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion0(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion1(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion2(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion3(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion4(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion5(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion6(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion7(); +/* ICACHE_RAM_ATTR void MqttSensManagerInterrupcion8(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion9(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion10(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion11(); + ICACHE_RAM_ATTR void MqttSensManagerInterrupcion12();*/ + + + +class MqttSensManager: public MqttOnVarChangeListenner +{ + public: + + MqttSensArray sens;//array de variables + MqttVarManager* vars; + PubSubClient *client_qqtt; + + SimpleDHT22 cdht;//clase para leer de dht + Adafruit_BMP085 bmp;//clase bmp + SonidoBuzzer *buzz; + bool bloqueo_sens;//bloquea todos los sensores (para poder editarlos) + + int ind_interrup[MAXINTERRUP]; + + int n_inter;//numero de interrupciones + + + unsigned long tiempo_sens; + unsigned long incre_tsens; + + MqttSensManager(); + + + void Config(MqttVarManager* varTopics); + void SetTimeRefres(int seg); + + void inicia(); + void loop(); + //int OnMqtt(char* topic, char* payload);//entra trama mqtt devuelve indice a sensor cambiado + + + //void AddSensor(MqttSensor* sens); + // + //funcion add sensor + //tempe y humedad + void AddHDT22(int pin, char* topic); + //tempe y presion varometrica + void AddBMP180(int sda,int scl, char* topic); + //entradas digitales + void AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..) + void AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...) + void AddDinRetardOff(int pin, int seg, char* topic);//añade variable con retardo al apagado (especial sensores de presencia) + void AddDinRetardOn(int pin, int seg, char* topic);//añade variable con retardo al apagado (especial sensores de presencia) + + void AddDoutPulsador(int pin, char* topic, bool defautlValor, int seg); + + //salida digital + void AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...) + void AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ... + void AddBuzz(int pin, char* topic); + void AddMelodia(char* m); + //funciones auxiliares------------ + + MqttSensor* Get(int i); + + void inicia(int i); + + void procesaSens(); + void procesaInterrupciones(); + + void procesaSensor(int i); + + //auxiliares de interrupciones----------- + void ConfiguraInterrupcion(int isen); + void OnInterrupcion(int i); + void ProcesaSenInterrupciones(int isen); + + + virtual void OnVarChange(int ivar); + +}; +#ifndef pMqttSensManagerdef +#define pMqttSensManagerdef 1 +static volatile bool MqttChange_ind_interrup[MAXINTERRUP]; +static volatile bool MqttChangeInterrup=false; +static MqttSensManager* pMqttSensManager; +#endif + +/* +*/ +#endif diff --git a/DomoEsp_Potencia_v02/MqttUtiles.cpp b/DomoEsp_Potencia_v02/MqttUtiles.cpp new file mode 100644 index 0000000..dc639b5 --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttUtiles.cpp @@ -0,0 +1,346 @@ +#include + + + +#include +#include + +#include +#include +#include +#include +#include + +#include "MqttUtiles.h" +//************************************************************************************************************************************************** + +bool MqttUtiles::pasa_incre( unsigned long *tt, unsigned long incre) +{ + unsigned long t=millis(); + if(t<*tt) + { + *tt=t; + return true; + } + if((*tt+incre)>=t) + return false; + *tt=t; + return true; +} + +bool MqttUtiles::pasa_incre( volatile unsigned long *tt, unsigned long incre) +{ + unsigned long t=millis(); + if(t<*tt) + { + *tt=t; + return true; + } + if((*tt+incre)>=t) + return false; + *tt=t; + return true; +} +//************************************************************************************************************************************************** +WifiManager::WifiManager() +{ + +} + +void WifiManager::inicia( WiFiClient *espclient,char *ssid, char* key, char *idArdu) +{ + espClient= espclient; + strcpy(nred, ssid); + strcpy(pass, key); + strcpy(idArduino,idArdu); + conecta(); + + //return WiFi.status() == WL_CONNECTED; +} +bool WifiManager::conecta() +{ + #ifdef DEBUG_PS + Serial.println("Conectando wifi"); + Serial.println(nred); + Serial.println(pass); + #endif + + WiFi.mode(WIFI_STA); + WiFi.begin(nred, pass); + + for(int i=0; i<100 && WiFi.status() != WL_CONNECTED; i++) + { + delay(500); + #ifdef DEBUG_PS + Serial.print("."); + #endif + } + #ifdef DEBUG_PS + Serial.println(""); + if(WiFi.status() == WL_CONNECTED) + Serial.println("Wifi Conectado"); + else + { + Serial.println("No se pudo conectar"); + + } + #endif + if(WiFi.status() != WL_CONNECTED) + return false; + + //ota---------------------------------- + // Port defaults to 8266 + // ArduinoOTA.setPort(8266); + + // Hostname defaults to esp8266-[ChipID] + ArduinoOTA.setHostname(idArduino); + + // No authentication by default + // ArduinoOTA.setPassword("admin"); + + // Password can be set with it's md5 value as well + // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3 + // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3"); + + ArduinoOTA.onStart([]() { + String type; + if (ArduinoOTA.getCommand() == U_FLASH) { + type = "sketch"; + } else { // U_FS + type = "filesystem"; + } + #ifdef DEBUG_PS + // NOTE: if updating FS this would be the place to unmount FS using FS.end() + Serial.println("Start updating " + type); + #endif + }); + ArduinoOTA.onEnd([]() { + Serial.println("\nEnd"); + }); + ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) { + #ifdef DEBUG_PS + Serial.printf("Progress: %u%%\r", (progress / (total / 100))); + #endif + }); + ArduinoOTA.onError([](ota_error_t error) { + #ifdef DEBUG_PS + Serial.printf("Error[%u]: ", error); + if (error == OTA_AUTH_ERROR) { + Serial.println("Auth Failed"); + } else if (error == OTA_BEGIN_ERROR) { + Serial.println("Begin Failed"); + } else if (error == OTA_CONNECT_ERROR) { + Serial.println("Connect Failed"); + } else if (error == OTA_RECEIVE_ERROR) { + Serial.println("Receive Failed"); + } else if (error == OTA_END_ERROR) { + Serial.println("End Failed"); + } + #endif + }); + ArduinoOTA.begin(); + #ifdef DEBUG_PS + Serial.println("Ready"); + Serial.print("IP address: "); + Serial.println(WiFi.localIP()); + #endif + return true; +} +bool WifiManager::loop() +{ + if((WiFi.status() == WL_CONNECTED)) + { + ArduinoOTA.handle(); + return true; + } + #ifdef DEBUG_PS + Serial.println("Fallo de conexion, se reinicia arduino"); + #endif + ESP.reset(); + return false; +} +//************************************************************************************************************************************************** +MqttManager::MqttManager() +{ + +} + +void MqttManager::inicia(PubSubClient *mqttClient,char *ideEsp, char *host, int port, MqttReceiver* classReceiver) +{ + strcpy(idEsp,ideEsp); + Mqttlistener=classReceiver; + client_mqtt=mqttClient; + client_mqtt->setServer(host, port); + client_mqtt->setCallback(MqttManager::OnMqtt); +} + +bool MqttManager::loop() +{ + if(client_mqtt->loop()) + return true; + #ifdef DEBUG_PS + if(WiFi.status() == WL_CONNECTED) + Serial.println("Conectando a broker"); + #endif + if(client_mqtt->connect(idEsp)) + { + #ifdef DEBUG_PS + if(WiFi.status() == WL_CONNECTED) + Serial.println("Conectado a broker"); + #endif + subscribe_mqtt(); + return true; + + } + #ifdef DEBUG_PS + Serial.println("Fallo de conexion, se reinicia arduino"); + #endif + ESP.reset(); + return false; +} +void MqttManager::subscribe_mqtt() +{ + if(Mqttlistener==NULL) + return; + Mqttlistener->SubscribeMqtt(client_mqtt); +} +//auxiliar------------------ +void MqttManager::OnMqtt(char* topic, byte* payload, unsigned int length) +{ + if(Mqttlistener==NULL) + return; + int i; + char buf[MAXTOPICVAR]; + i= MAXTOPICVAR-1; + if(i>length) + i=length; + memcpy(buf, payload, i); + buf[i]=0; + Mqttlistener->OnMqtt(topic, buf); + +} + +//************************************************************************************************************************************************** +void Ceprom_manager::fin_grabacion() +{ + EEPROM.commit(); +} + +Ceprom_manager::Ceprom_manager() +{ + nb=0; +} + +void Ceprom_manager::leeb(byte *p) +{ + *p=EEPROM.read(nb++); +} + +void Ceprom_manager::grabab(byte p) +{ + EEPROM.write(nb++, p); +} + +void Ceprom_manager::graba_st(char *st) +{ + for(int i=strlen(st); i>0; i--) + { + Ceprom_manager::grabab(*st); + st++; + } +} + +void Ceprom_manager::cursor(int pos) +{ + nb=pos; +} +//************************************************************************************************************************************************** +MelodiaBuzzer::MelodiaBuzzer() +{ + melodia[0]=0; +} +int MelodiaBuzzer::st2nota(char st) +{ + switch(st) + { + case 'd': + return 262; + case 'r': + return 294; + case 'm': + return 330; + case 'f': + return 349; + case 's': + return 392; + case 'l': + return 440; + case 'i': + return 494; + case 'D': + return 277; + case 'R': + return 311; + case 'M': + return 345; + case 'F': + return 350; + case 'S': + return 415; + case 'L': + return 466; + case 'I': + return 554,36; + default: + return 0; + } +} +int MelodiaBuzzer::str2t(char* st, int *t) +{ + char buf[8]; + int n=0; + int i; + while(st[i]<='9' && st[i]>='0') + { + buf[n++]=st[i++]; + } + buf[n]=0; + (*t)=atoi(buf); + return i; +} +void MelodiaBuzzer::Toca(int pin) +{ + int i=0; + int h=0, t=0; + + while (melodia[i]) + { + h=st2nota(melodia[i]); + i++; + t=0; + i+=str2t(&melodia[i], &t); + if(h>0) + tone(pin, h); + else + noTone(pin); + delay(t); + } +} +//************************************************* +SonidoBuzzer::SonidoBuzzer() +{ + n=0; +} + +void SonidoBuzzer::Toca(int pin, int imel) +{ + if (imel<0 || imel>=n) + return; + mel[imel].Toca(pin); +} + +int SonidoBuzzer::Add(char* melo) +{ + strcpy(mel[n].melodia, melo); + return n++; +} diff --git a/DomoEsp_Potencia_v02/MqttUtiles.h b/DomoEsp_Potencia_v02/MqttUtiles.h new file mode 100644 index 0000000..da0541f --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttUtiles.h @@ -0,0 +1,155 @@ +#ifndef MqttUtilesrDef +#define MqttUtilesDef 1 + + +//#include //este para esp32 +#include //este para esp8266*/ +class PubSubClient; +class WiFiClient; +#ifndef DO +#define D0 16 +#endif +#ifndef D1 +#define D1 5 +#endif +#ifndef D2 +#define D2 4 +#endif +#ifndef D3 +#define D3 0 +#endif +#ifndef D4 +#define D4 2 +#endif +#ifndef D5 +#define D5 14 +#endif +#ifndef D6 +#define D6 12 +#endif +#ifndef D7 +#define D7 13 +#endif +#ifndef D8 +#define D8 15 +#endif +#include "MQTTDefines.h" +//interfaces listener--------------------------------------- + +class MqttUtiles +{ + public: + static bool pasa_incre( unsigned long *tt, unsigned long incre); + static bool pasa_incre( volatile unsigned long *tt, unsigned long incre); + static void resetFunc() + { + ESP.wdtEnable(1); + while(1){}; + } +}; + + +class WifiManager +{ + public: + + char nred[32]; + char pass[32]; + char idArduino[32]; + WiFiClient *espClient; + + WifiManager(); + bool conecta(); + void inicia( WiFiClient *espClient, char *ssid, char* key, char *idArduino); + bool loop(); + +}; +class MqttReceiver +{ + public: + virtual void OnMqtt(char* topic, char* payload)=0; + virtual void SubscribeMqtt(PubSubClient *client_mqtt){} +}; + +class MqttManager +{ + public: + + private: + + char idEsp[32]; + public: + PubSubClient *client_mqtt; + + MqttManager(); + +/* + WiFiClient espClient;//conexion a wifi + PubSubClient client_qqtt(espClient);//para conexion con mqtt + */ + void inicia(PubSubClient *mqttClient,char *ideEsp, char *host, int port, MqttReceiver* classReceiver); + bool loop(); + + //void desconecta(); + + //auxiliar------------------ + static void OnMqtt(char* topic, byte* payload, unsigned int length); + void subscribe_mqtt(); +}; +static MqttReceiver* Mqttlistener; + + + + + +class Ceprom_manager +{ + public: + int nb; + + Ceprom_manager(); + + void leeb(byte *p);//lee un byte y deja en p + void grabab(byte p);//graba en eprom un byte + void graba_st(char *st); + void fin_grabacion();//hace efectivos los cambios en la eprom + void cursor(int pos=0);//mueve cursor a posicion indicada + template + void get(Cgeneg* dout)//lee entero + { + byte *b=(byte)dout; + for(int i=sizeof(Cgeneg); i>0;i--) + leeb(&b[i]); + }; + template + + void set(Cgenes* dout)//lee entero + { + byte *b=(byte*)dout; + for(int i=sizeof(Cgenes); i>0;i--) + grabab(b[i]); + }; +}; + +class MelodiaBuzzer +{ + public: + //melodia se compone de notas (primera letra y tiempo de duracion) silecio es # + char melodia[64]; + MelodiaBuzzer(); + int st2nota(char st); + int str2t(char* st, int *t); + + void Toca(int pin); +}; + +class SonidoBuzzer +{ + public: + MelodiaBuzzer mel[4]; + int n; + SonidoBuzzer(); + void Toca(int pin, int melodia); + int Add(char* melodia); +}; +#endif diff --git a/DomoEsp_Potencia_v02/MqttVarManager.cpp b/DomoEsp_Potencia_v02/MqttVarManager.cpp new file mode 100644 index 0000000..b410d46 --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttVarManager.cpp @@ -0,0 +1,424 @@ +//#include //este para esp8266 +#include +#include "MqttDefines.h" +#include "MqttVarManager.h" +#include "MqttUtiles.h" +#include +#include + +MqttTopicAttay::MqttTopicAttay() +{ + n=0; + nst=0; + def[0] = 0; +} + +char* MqttTopicAttay::Get(int i) +{ + if (i < 0 || i >= n) + return def; + return &str[(ind[i])]; +} + +int MqttTopicAttay::Get(char *topic) +{ + for(int i=0; i(int)0) + { + return i; + } + i=n; + if (n >= MAXVAR) + return-1; + n=n+1; + ind[i]=nst; + nst=nst+strlen(topic)+1; + if (nst > MAXSTR) + { + n--; + return-1; + } + + strcpy(Get(i), topic); + return i; +} + +//******************************************************************* + +MqttVar::MqttVar() +{ + flags=0; + val.f=0; + topic=0; +} + +//******************************************************************* +MqttVarArray::MqttVarArray() +{ + n=0; +} + +MqttVar* MqttVarArray::Get(int i) +{ + if (i < 0 || i >= n) + { +#ifdef DEBUG_PS + Serial.print("qttVarArray:: Get var no encontrada: "); + Serial.print(i); + Serial.print(" n: "); + Serial.println(i); + +#endif + return NULL; + } + return &(data[i]); +} + +MqttVar* MqttVarArray::GetVar(int itopic) +{ + for(int i=0; i= MAXVAR) + { +#ifdef DEBUG_PS + Serial.print("MqttVarArray::Add max var alcanzado: "); + Serial.println(n); +#endif + return -1; + } + + data[n]=*var; + n++; + return n-1; +} +//******************************************************************* + +MqttVarManager::MqttVarManager() +{ + + tiempo_var=0; + SetTimeRefres(30); + nListenner=0; + for (int i=0; in; i++) + { + v=vars->Get(i); + + if((v->flags & f) && !strcmp(topics->Get(v->topic),buf)) + { + if(v->flags & MqttVar::FLOAT_VAR) + { + float ff=v->val.f; + val.f=atof(payload); + + } + else + { + int ii=v->val.i; + val.i=atoi(payload); + } + SetVal(i, val); + break;//suponemos solo una variable con el mismo topic + } + } + + //if(res>=0) + // OnChange(res, isSet); + return; +} + +void MqttVarManager::loop() +{ + if(MqttUtiles::pasa_incre(&tiempo_var, incre_tvar)) + { + #ifdef DEBUG_PS + Serial.println("Procesa vars"); + #endif + PublicaVars(); + } +} + +void MqttVarManager::PublicaVar(int ivar) +{ + char buffer_t[MAXTOPICVAR]; + char buffer_p[MAXTOPICVAR]; + MqttVar* v=vars->Get(ivar); + if(v->flags & MqttVar::CHANGE_VAR) + { + + sprintf(buffer_t, "%s/set",topics->Get(v->topic)); + #ifdef DEBUG_PS + Serial.print("Publica /set var: "); + Serial.println(buffer_t); + #endif + } + else//in var + { + + sprintf(buffer_t, "%s/get",topics->Get(v->topic)); + #ifdef DEBUG_PS + Serial.print("Publica get var: "); + Serial.println(buffer_t); + #endif + } + //Publica valor + if(v->flags & MqttVar::FLOAT_VAR) + dtostrf(v->val.f,3, 2, buffer_p); + else + sprintf(buffer_p, "%d", (int)v->val.i); + client_qqtt->publish(buffer_t, buffer_p); + +} + + +void MqttVarManager::PublicaVars() +{ + + byte f=MqttVar::IN_VAR; + MqttVar* v; + for(int i=0; in; i++) + { + v=vars->Get(i); + if(v->flags & f) + PublicaVar(i); + } +} +void MqttVarManager::inicia(PubSubClient* client_mqtt) +{ + client_qqtt=client_mqtt; +} + +void MqttVarManager::Suscribe() +{ + //suscribe a mqtt------------ + char buffer_t[MAXTOPICVAR]; + MqttVar* v; + for(int i=0; in; i++) + { + v=vars->Get(i); + if(v->flags & MqttVar::OUT_VAR)//suscribe al set + { + sprintf(buffer_t, "%s/set",topics->Get(v->topic)); + client_qqtt->subscribe(buffer_t); + } + if(v->flags & MqttVar::PRIV_VAR)//suscribe al get + { + sprintf(buffer_t, "%s/get",topics->Get(v->topic)); + client_qqtt->subscribe(buffer_t); + } + } +} +int MqttVarManager::AddVar(byte flags, char*topic) +{ + MqttVar v; + v.flags=flags; + v.topic=topics->Add(topic); + return vars->Add(&v); +} +int MqttVarManager::AddInternalVarFloat( char* topic) +{ + return AddVar((byte)(MqttVar::PRIV_VAR|MqttVar::FLOAT_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR),topic); +} +int MqttVarManager::AddInternalVarInt( char* topic) +{ + return AddVar((byte)(MqttVar::PRIV_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR),topic); +} +int MqttVarManager::AddVirtualOutVarInt( char* topic) +{ + return AddVar((byte)(MqttVar::IN_VAR|MqttVar::OUT_VAR|MqttVar::ACCION_VAR),topic); +} +MqttVar* MqttVarManager::Get(int i) +{ + return vars->Get(i); +} +int MqttVarManager::GetId(char* topic) +{ + #ifdef DEBUG_PS + + Serial.println("MqttVarManager::GetId"); + #endif + int itop= topics->Get(topic); + #ifdef DEBUG_PS + + Serial.println("MqttVarManager::GetId busca var"); + #endif + for(int i=0;in; i++) + { + if(vars->Get(i)->topic==itop) + return i; + } + #ifdef DEBUG_PS + + Serial.println("MqttVarManager::GetId variable no encontrada"); + #endif + return -1; +} + +void MqttVarManager::OnChange(int ivar, bool publica) +{ + #ifdef DEBUG_PS + Serial.println("MqttVarManager::OnChange"); + #endif + + if(publica) + { + MqttVar* v=vars->Get(ivar); + byte f= MqttVar::ACCION_VAR; + if(v->flags & f) + { + PublicaVar(ivar); + } + } + + + for (int i=0; iOnVarChange(ivar); + } + +} +void MqttVarManager::AddListenner(MqttOnVarChangeListenner *pOnChangeListener) +{ + onChangeListener[nListenner++]=pOnChangeListener; +} +void MqttVarManager::ResetVolatileVar() +{ + for(int i=0; in; i++) + { + MqttVar* v=vars->Get(i); + if(v->flags& MqttVar::VOLATILE_VAR) + { + + if(v->flags & MqttVar::FLOAT_VAR) + v->val.f=0; + else + v->val.i=0; + } + + } +} +void MqttVarManager::InvierteVar(int ivar) +{ + MqttVar* v=vars->Get(ivar); + if(v->flags & MqttVar::FLOAT_VAR) + { + v->val.f=100.0-v->val.f; + } + else + v->val.i=1-v->val.i; + OnChange(ivar, true); +} +void MqttVarManager::SetVal(int ivar,MQTTvalor val) +{ + #ifdef DEBUG_PS + + Serial.print("MqttVarManager::SetVal int i: "); + Serial.print( val.i); + Serial.print(" f: "); + Serial.println( val.f); + #endif + MqttVar* v=vars->Get(ivar); + bool cambia = false; + if (v->flags & MqttVar::FLOAT_VAR) + cambia = val.f != v->val.f; + else + cambia = val.i != v->val.i; + + v->val=val; + if(cambia) + OnChange(ivar, true); +} diff --git a/DomoEsp_Potencia_v02/MqttVarManager.h b/DomoEsp_Potencia_v02/MqttVarManager.h new file mode 100644 index 0000000..62db11f --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttVarManager.h @@ -0,0 +1,127 @@ +/*#if ARDUINO >= 100 +#include "Arduino.h" +#else +#include "WProgram.h" +#endif*/ +#ifndef MqttvarManagerDef +#define MqttvarManagerDef 1 +#include "MqttDefines.h" + + +class PubSubClient; +//array de topic +class MqttTopicAttay +{ + char def[1]; + public: + + char str[MAXSTR];//topic de mqtt asociado + int ind[MAXVAR]; + int nst; + int n; + MqttTopicAttay(); + + char* Get(int i); + int Get(char *topic); + int Add(char *topic); + +}; + +union MQTTvalor +{ + float f; + byte i; +}; + +class MqttVar +{ + public: + enum TipoFlags//indica el tipo de sensor + { + OUT_VAR=0x01,//variable de salida (acepta set) + IN_VAR=0x02,//variable de entrada (publica get) (publica cada x tiempo) + PRIV_VAR=0x04,//variable privada de entrada (acepta get como si fueran set) + FLOAT_VAR=0x08,//variable en coma flotante + ACCION_VAR=0x10,//variable de accion (publica en cada cambio onchange si se le llama como publicar) + VOLATILE_VAR=0x20, //marca variable que una vez revisada se cambia internamente su valor (usado en desencadenadores para variables de accion) + CHANGE_VAR=0x40, //publica con set en lugar de get + + }; + + public: + //generales--------------------------------------------------------------------- + byte flags; + MQTTvalor val;//valor de la variable (tiene que ser union porque puede ser double) + byte topic;//topic de mqtt asociado + + MqttVar(); +}; + + +//array de variables-------------------------------------------------------------- +class MqttVarArray +{ + public: + MqttVar data[MAXVAR];//array de variables + int n; + + + MqttVarArray(); + + MqttVar* Get(int i); + + MqttVar* GetVar(int itopic); + + int Add(MqttVar* var); + + +}; + +class MqttOnVarChangeListenner; +//manager de variables------------------------------------------------------ +class MqttVarManager +{ + MqttVarArray _v; + MqttTopicAttay _t; + MqttOnVarChangeListenner* onChangeListener[2]; + int nListenner; + public: + + MqttVarArray* vars;//variables mqtt + MqttTopicAttay* topics; + PubSubClient* client_qqtt;//cliente mqtt + + unsigned long tiempo_var; + unsigned long incre_tvar; + + MqttVarManager(); + void config(MqttVarArray *vArray=NULL, MqttTopicAttay* t=NULL); + void SetTimeRefres(int seg); + + void inicia(PubSubClient *client_qqtt);//inicia variables si hace falta + void Suscribe();//subscribe variables a mqtt + void OnMqtt(char* topic, char* payload);//entra trama mqtt devuelve indice a sensor cambiado + void loop();//publica datos variables + + + //funciones auxiliares---------------------------- + void AddListenner(MqttOnVarChangeListenner *pOnChangeListener); + MqttVar* Get(int i); + int GetId(char* topic);//devuelve el id de una variable + + int AddVar(byte flags, char*topic); + int AddVirtualOutVarInt( char*topic); + int AddInternalVarFloat( char*topic); + int AddInternalVarInt( char*topic); + void PublicaVars(); + void PublicaVar(int ivar); + void OnChange(int ivar, bool publica); + + void ResetVolatileVar(); + void InvierteVar(int ivar); + void SetVal(int ivar,MQTTvalor val); +}; + +/* +*/ +#endif diff --git a/DomoEsp_Potencia_v02/MqttWOLManager.cpp b/DomoEsp_Potencia_v02/MqttWOLManager.cpp new file mode 100644 index 0000000..1077eee --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttWOLManager.cpp @@ -0,0 +1,36 @@ + +#include +#include +#include "MqttWOLManager.h" + +MqttWOLManager::MqttWOLManager() +{ + topic[0]=0; +} +void MqttWOLManager::inicia(WakeOnLan *pwol) +{ + wol=pwol; +} +void MqttWOLManager::loop() +{ + +} +int MqttWOLManager::OnMqtt(char* top, char* payload) +{ + if(strcmp(top,topic)) + return -1; + + wol->sendMagicPacket(payload); // Send Wake On Lan packet with the above MAC address. Default to port 9. + #ifdef DEBUG_PS + Serial.print("Enviado wol a: "); + Serial.println(payload); + #endif + // WOL.sendMagicPacket(MACAddress, 7); // Change the port number + return 1; +} +void MqttWOLManager::suscribe(PubSubClient *client_qqtt) +{ + if(!topic[0]) + return; + client_qqtt->subscribe(topic); +} diff --git a/DomoEsp_Potencia_v02/MqttWOLManager.h b/DomoEsp_Potencia_v02/MqttWOLManager.h new file mode 100644 index 0000000..8b7c10d --- /dev/null +++ b/DomoEsp_Potencia_v02/MqttWOLManager.h @@ -0,0 +1,22 @@ + +#ifndef MqttWOLManagerdef +#define MqttWOLManagerdef 1 +#include "MqttDefines.h" +class WakeOnLan; + +class MqttWOLManager +{ + WakeOnLan* wol; + public: + char topic[MAXSTR];//topic para llamada wol + + MqttWOLManager(); + + + void inicia(WakeOnLan* pwol); + void loop();//publica datos variables + int OnMqtt(char* topic, char* payload); + void suscribe(PubSubClient *client_qqtt); + +}; +#endif diff --git a/DomoEsp_Potencia_v02/__vm/.DomoEsp_v02.vsarduino.h b/DomoEsp_Potencia_v02/__vm/.DomoEsp_v02.vsarduino.h new file mode 100644 index 0000000..a57aeee --- /dev/null +++ b/DomoEsp_Potencia_v02/__vm/.DomoEsp_v02.vsarduino.h @@ -0,0 +1,142 @@ +/* + Editor: https://www.visualmicro.com/ + This file is for intellisense purpose only. + Visual micro (and the arduino ide) ignore this code during compilation. This code is automatically maintained by visualmicro, manual changes to this file will be overwritten + The contents of the _vm sub folder can be deleted prior to publishing a project + All non-arduino files created by visual micro and all visual studio project or solution files can be freely deleted and are not required to compile a sketch (do not delete your own code!). + Note: debugger breakpoints are stored in '.sln' or '.asln' files, knowledge of last uploaded breakpoints is stored in the upload.vmps.xml file. Both files are required to continue a previous debug session without needing to compile and upload again + + Hardware: NodeMCU 1.0 (ESP-12E Module), Platform=esp8266, Package=esp8266 +*/ + +#if defined(_VMICRO_INTELLISENSE) + +#ifndef _VSARDUINO_H_ +#define _VSARDUINO_H_ +#define __ESP8266_esp8266__ +#define __ESP8266_ESP8266__ +#define _VMDEBUG 1 +#define __ets__ +#define ICACHE_FLASH +#define _GNU_SOURCE +#define MMU_IRAM_SIZE 0x8000 +#define MMU_ICACHE_SIZE 0x8000 +#define NONOSDK22x_190703 1 +#define F_CPU 80000000L +#define LWIP_OPEN_SRC +#define TCP_MSS 536 +#define LWIP_FEATURES 1 +#define LWIP_IPV6 0 +#define ARDUINO 108016 +#define ARDUINO_ESP8266_NODEMCU_ESP12E +#define ARDUINO_ARCH_ESP8266 +#define LED_BUILTIN 2 +#define FLASHMODE_DIO +#define ESP8266 +#define __cplusplus 201103L +#undef __cplusplus +#define __cplusplus 201103L +#define __STDC__ +#define __ARM__ +#define __arm__ +#define __inline__ +#define __asm__(x) +#define __asm__ +#define __extension__ +#define __ATTR_PURE__ +#define __ATTR_CONST__ +#define __volatile__ + + +#define __ASM +#define __INLINE +#define __attribute__(noinline) + +//#define _STD_BEGIN +//#define EMIT +#define WARNING +#define _Lockit +#define __CLR_OR_THIS_CALL +#define C4005 +#define _NEW + +//typedef int uint8_t; +//#define __ARMCC_VERSION 400678 +//#define PROGMEM +//#define string_literal +// +//#define prog_void +//#define PGM_VOID_P int +// + +typedef int _read; +typedef int _seek; +typedef int _write; +typedef int _close; +typedef int __cleanup; + +//#define inline + +#define __builtin_clz +#define __builtin_clzl +#define __builtin_clzll +#define __builtin_labs +#define __builtin_va_list +typedef int __gnuc_va_list; + +#define __ATOMIC_ACQ_REL + +#define __CHAR_BIT__ +#define _EXFUN() + +typedef unsigned char byte; +extern "C" void __cxa_pure_virtual() {;} + + +typedef long __INTPTR_TYPE__ ; +typedef long __UINTPTR_TYPE__ ; +typedef long __SIZE_TYPE__ ; +typedef long __PTRDIFF_TYPE__; + +// Additions needed for v3.0.0 Core - Needs to be conditional on it being this core really!! +#ifndef isnan +#undef _Lockit +#undef __STDC__ +#define __STDC__ 1 +#define __CHAR_BIT__ 1 +extern int isinf(double); +extern int isnan(double); +extern int fpclassify(double); +extern int signbit(double); +extern int isfinite(double); +extern int isnormal(double); +extern int isgreater(double, double); +extern int isgreaterequal(double); +extern int isless(double, double); +extern int islessequal(double, double); +extern int islessgreater(double, double); +extern int isunordered(double, double); +#endif + +#include "new" +#include "Esp.h" + + +#include "arduino.h" +#include + +#include "..\generic\Common.h" +#include "..\generic\pins_arduino.h" + +#undef F +#define F(string_literal) ((const PROGMEM char *)(string_literal)) +#undef PSTR +#define PSTR(string_literal) ((const PROGMEM char *)(string_literal)) +//current vc++ does not understand this syntax so use older arduino example for intellisense +//todo:move to the new clang/gcc project types. +#define interrupts() sei() +#define noInterrupts() cli() + +#include "DomoEsp_v02.ino" +#endif +#endif diff --git a/DomoEsp_Potencia_v02/__vm/Compile.vmps.xml b/DomoEsp_Potencia_v02/__vm/Compile.vmps.xml new file mode 100644 index 0000000..59515da --- /dev/null +++ b/DomoEsp_Potencia_v02/__vm/Compile.vmps.xml @@ -0,0 +1,31 @@ + + + + + + + + + + + + + 82 #if CON_WOL +83 pwol=&WOL; +84 #endif +85 domoManager.inicia(pwol,plcd,&clienteMqtt,&EspClient,&ConfiguracionActual); +86 +87 } +88 +-->89 void loop() +90 { +91 domoManager.loop(); +92 } + + + + + + + + \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/__vm/Configuration.Debug.vmps.xml b/DomoEsp_Potencia_v02/__vm/Configuration.Debug.vmps.xml new file mode 100644 index 0000000..87fc142 --- /dev/null +++ b/DomoEsp_Potencia_v02/__vm/Configuration.Debug.vmps.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/DomoEsp_Potencia_v02/config_rf.h b/DomoEsp_Potencia_v02/config_rf.h new file mode 100644 index 0000000..23d0bf7 --- /dev/null +++ b/DomoEsp_Potencia_v02/config_rf.h @@ -0,0 +1,606 @@ +//parametros configurables************************************************* +#define DEBUG_PS 1//Descomentar para debug +#define CON_LCD 0 +#define CON_WOL 0 + //va por 16 + class CocinapRUBDomoConfig: public DomoConfig +{ + public: + CocinapRUBDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + strcpy(ideEsp,"Esp8266_P");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + } + //configuracion de sensores--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + sens->AddHDT22(D4, "casa/cocina");//01 + sens->AddDinRetardOff(D5, 60,"casa/p/mov");//2 + int mov=2; + sens->AddAnalogIn(0, "casa/p/luz",true);//3 + int luz=3; + sens->AddDin( D1, "casa/p/inter");//4 + int interr=4; + sens->AddDout(D2, "casa/p/lam", false);//5 + int lam=5; + int lauto= vars->AddVirtualOutVarInt( "casa/p/luzAuto");//variable privada + char st[64]; + + //Efecto Pulsadores + sprintf(st,"{%d}>0 -> !{%d} ",interr,lam);//accion interruptor + des->AddDes(st); + sprintf(st,"{%d}<1 -> !{%d} ",interr,lam);//accion interruptor + des->AddDes(st); + + sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",mov,lauto,lam,lam);//apaga luz si no hay nadie + des->AddDes(st); + sprintf(st,"{%d}>20&{%d}>0&{%d}>0 -> {%d}=1 ",luz,mov,lauto,lam);//enciende luz si hay presencia y esta oscuro + des->AddDes(st); + + } +}; +class ActDomoConfig: public DomoConfig +{ + public: + ActDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_pruebas");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=D5; + lcd.en=D6;//eneable + lcd.d0=D3; + lcd.d1=D2; + lcd.d2=D1; + lcd.d3=D0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + /* + sens->AddHDT22(int pin, char* topic); + //tempe y presion varometrica + sens->AddBMP180(int sda,int scl, char* topic); + //entradas digitales + sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..) + sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...) + //salida digital + sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...) + Sensor analogico + sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ... + + sens->AddBuzz(int pin, char* topic); + */ + + sens->AddDinRetardOn(D1,5,"casa/p/pul"); + sens->AddDout(D5,"casa/p/led", true); + //sens->AddHDT22(D4, "casa/desp"); + //sens->AddBuzz(D0, "casa/p/buz"); + //sens->AddMelodia("m200#100d200#0"); + //variables---------------------------------------------------- + /* + int ivar= vars->AddVar(byte flags, char*topic);//variable con flags a elegir + int ivar= vars->AddInternalVarFloat( char*topic);//variable privada + int ivar= vars->AddInternalVarInt( char*topic);//variable privada + * / + int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb"); + int lchim= vars->AddInternalVarInt( "casa/Salon/LChime"); + int lent= vars->AddInternalVarInt( "casa/Salon/LEnt"); + + int pul1= vars->AddInternalVarInt( "casa/Salon/pul1"); + int pul2= vars->AddInternalVarInt( "casa/Salon/pul2"); + int pul3= vars->AddInternalVarInt( "casa/Salon/pul3"); + int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll"); + int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll"); + //lcd--------------------------------------------------------- + + //lcd->add(0,"T des: %s",0,0); + //lcd->add(1,"H des: %s",1,0); + //lcd->add(temCoci,"T coci: %s",0,1); + //lcd->add(temDesp,"H coci: %s",1,1); + + /* + //sin depender de variable + lcd->add(-1,"Hola",0,0); + lcd->add(-1,"como va",1,0); + + lcd->add(-1,"Mi ritmo",0,1); + lcd->add(-1,"bueno pa goza",1,1);* / + */ + //desencadenaores---------- + char st[64]; + //Efecto Interruptor----- + sprintf(st,"{%d}<1 -> !{%d} ",0,1);//terminar en espacios y separar operadores (no puede estar 2 operadores juntos) + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",0,1);//terminar en espacios + des->AddDes(st); + /* + sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + //Efecto Pulsadores + sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios + des->AddDes(st); + /* */ + } +}; +class SalonHome: public DomoConfig +{ + public: + SalonHome() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_SalomHome");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=D5; + lcd.en=D6;//eneable + lcd.d0=D3; + lcd.d1=D2; + lcd.d2=D1; + lcd.d3=D0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + /* + sens->AddHDT22(int pin, char* topic); + //tempe y presion varometrica + sens->AddBMP180(int sda,int scl, char* topic); + //entradas digitales + sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..) + sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...) + //salida digital + sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...) + Sensor analogico + sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ... + + sens->AddBuzz(int pin, char* topic); + */ + sens->AddDoutPulsador(D4, "casa/Salon/ordeTele", true, 1); + sens->AddDoutPulsador(D2, "casa/Salon/router", true, 1); + + + sens->AddDout(D3,"casa/Salon/auxiliar", true); + int aux=2; + sens->AddDout(D1,"casa/Salon/equipoMusica", true); + int equipo=3; + sens->AddDin( D5,"casa/Salon/pulEquipoM"); + int pequipo=4; + sens->AddDin( D6, "casa/Salon/pulAux"); + int paux=5; + //variables---------------------------------------------------- + + //desencadenaores---------- + char st[64]; + //Efecto Interruptor----- + + sprintf(st,"{%d}>0 -> !{%d} ",pequipo,equipo);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",paux,aux);//terminar en espacios + des->AddDes(st); + + } +}; +class PulSalonPruebConfig: public DomoConfig +{ + public: + PulSalonPruebConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_pulSalonPrueb");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=0; + lcd.en=0;//eneable + lcd.d0=0; + lcd.d1=0; + lcd.d2=0; + lcd.d3=0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + + //sens->AddHDT22(D4, "casa/desp"); + // sens->AddDout(D1, "casa/p/LEnt", true); + sens->AddDout(D7, "casa/p/LEnt", true); + sens->AddDin( D1,"casa/p/pul1"); + sens->AddDin( D2, "casa/p/pul2"); + sens->AddDin( D3, "casa/p/pul3"); + sens->AddDin( D4,"casa/p/pulAll"); + } +}; +class AutomatismosDomoConfig: public DomoConfig +{ + public: + AutomatismosDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_autom");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=D5; + lcd.en=D6;//eneable + lcd.d0=D3; + lcd.d1=D2; + lcd.d2=D1; + lcd.d3=D0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + /* + sens->AddHDT22(int pin, char* topic); + //tempe y presion varometrica + sens->AddBMP180(int sda,int scl, char* topic); + //entradas digitales + sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..) + sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...) + //salida digital + sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...) + Sensor analogico + sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ... + */ + //sens->AddHDT22(D4, "casa/desp"); + //sens->AddAnalogIn(0, "casa/desp/luz",true); + //variables---------------------------------------------------- + /* + int ivar= vars->AddVar(byte flags, char*topic);//variable con flags a elegir + int ivar= vars->AddInternalVarFloat( char*topic);//variable privada + int ivar= vars->AddInternalVarInt( char*topic);//variable privada + */ + int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb"); + int lchim= vars->AddInternalVarInt( "casa/Salon/LChime"); + int lent= vars->AddInternalVarInt( "casa/Salon/LEnt"); + + int pul1= vars->AddInternalVarInt( "casa/Salon/pul1"); + int pul2= vars->AddInternalVarInt( "casa/Salon/pul2"); + int pul3= vars->AddInternalVarInt( "casa/Salon/pul3"); + int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll"); + int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll"); + //lcd--------------------------------------------------------- + + //lcd->add(0,"T des: %s",0,0); + //lcd->add(1,"H des: %s",1,0); + //lcd->add(temCoci,"T coci: %s",0,1); + //lcd->add(temDesp,"H coci: %s",1,1); + + /* + //sin depender de variable + lcd->add(-1,"Hola",0,0); + lcd->add(-1,"como va",1,0); + + lcd->add(-1,"Mi ritmo",0,1); + lcd->add(-1,"bueno pa goza",1,1);*/ + //desencadenaores---------- + char st[64]; + //Efecto Interruptor----- + sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + //Efecto Pulsadores + sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios + des->AddDes(st); + + } +}; + +class PulSalonConfig: public DomoConfig +{ + public: + PulSalonConfig() + { + //CON LCD Y WOL + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_pulSalon");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=0; + lcd.en=0;//eneable + lcd.d0=0; + lcd.d1=0; + lcd.d2=0; + lcd.d3=0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + /* + sens->AddHDT22(int pin, char* topic); + //tempe y presion varometrica + sens->AddBMP180(int sda,int scl, char* topic); + //entradas digitales + sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..) + sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...) + //salida digital + sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...) + Sensor analogico + sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ... + */ + //sens->AddHDT22(D4, "casa/desp"); + // sens->AddDout(D1, "casa/Salon/LEnt", true); + sens->AddDout(D7, "casa/Salon/LEnt", true); + sens->AddDinRetardOff( D1, 0,"casa/Salon/pul1"); + sens->AddDinRetardOff( D2, 0, "casa/Salon/pul2"); + sens->AddDinRetardOff( D5, 0, "casa/Salon/pul3"); + sens->AddDinRetardOff( D6, 0,"casa/Salon/pulAll"); + } +}; +class DespachoDomoConfig: public DomoConfig +{ + public: + DespachoDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + + strcpy(ideEsp,"Esp8266_Despacho");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + + //config lcd-------------------- + lcd.colum=16;//columnas lcd + lcd.lines=2;//lineas + //pines lcd + lcd.rs=D5; + lcd.en=D6;//eneable + lcd.d0=D3; + lcd.d1=D2; + lcd.d2=D1; + lcd.d3=D0; + + } + //configuracion de sensores, variables, lcd--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd,MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + //sensores-------------------------------------------------------- + sens->AddHDT22(D4, "casa/desp"); + sens->AddAnalogIn(0, "casa/desp/luz",true); + sens->AddBuzz(D7, "casa/des/buz"); + + sens->AddMelodia("m200#100d200#0");//titu + sens->AddMelodia("d200#100d200#100d200#100f200#100l300#0"); + + //variables---------------------------------------------------- + int temCoci= vars->AddInternalVarFloat( "casa/cocina/t");//variable privada + int hcocina= vars->AddInternalVarFloat( "casa/cocina/h");//variable privada + int temExt= vars->AddInternalVarFloat( "casa/ext/t");//variable privada + int hExt= vars->AddInternalVarFloat( "casa/ext/h");//variable privada + //lcd--------------------------------------------------------- + lcd->add(0,"T des: %s",0,0); + lcd->add(1,"H des: %s",1,0); + lcd->add(temCoci,"T coci: %s",0,1); + lcd->add(hcocina,"H coci: %s",1,1); + lcd->add(temExt,"T Ext: %s",0,2); + lcd->add(hExt,"H Ext: %s",1,2); + strcpy(lcd->topic,"casa/desp/msg"); + strcpy(wol->topic,"casa/wol"); + } +}; +class CocinaDomoConfig: public DomoConfig +{ + public: + CocinaDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + strcpy(ideEsp,"Esp8266_cocina");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + } + //configuracion de sensores--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + sens->AddHDT22(D4, "casa/cocina");//01 + sens->AddDinRetardOff(D5, 60,"casa/cocina/mov");//2 + int mov=2; + sens->AddAnalogIn(0, "casa/cocina/luz",true);//3 + int luz=3; + sens->AddDin( D1, "casa/cocina/inter");//4 + sens->AddDout(D2, "casa/cocina/lam", false);//5 + int lam=5; + int lauto= vars->AddVirtualOutVarInt( "casa/cocina/luzAuto"); + char st[64]; + + //Efecto Pulsadores + + sprintf(st,"{%d}>0 -> !{%d} ",4,lam);//accion interruptor + des->AddDes(st); + + sprintf(st,"{%d}<1 -> !{%d} ",4,lam);//accion interruptor + des->AddDes(st); + + sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",mov,lauto,lam,lam);//apaga luz si no hay nadie + des->AddDes(st); + sprintf(st,"{%d}<20&{%d}>0&{%d}>0 -> {%d}=1 ",luz,mov,lauto,lam);//enciende luz si hay presencia y esta oscuro + des->AddDes(st); + + } +}; +class SalonDomoConfig: public DomoConfig +{ + public: + SalonDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + strcpy(ideEsp,"Esp8266_salon");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + } + //configuracion de sensores--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + sens->AddHDT22(D4, "casa/Salon");//01 + sens->AddDinRetardOff(D5, 60,"casa/Salon/mov");//2 + sens->AddAnalogIn(0, "casa/Salon/luz",true);//3 + + //variables---------------------------------------------------- + //variables para pulsadores--------------------------- + int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb"); + int lchim= vars->AddInternalVarInt( "casa/Salon/LChime"); + int lent= vars->AddInternalVarInt( "casa/Salon/LEnt"); + + int pul1= vars->AddInternalVarInt( "casa/Salon/pul1"); + int pul2= vars->AddInternalVarInt( "casa/Salon/pul2"); + int pul3= vars->AddInternalVarInt( "casa/Salon/pul3"); + int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll"); + int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll"); +/* + int cociMov= vars->AddInternalVarInt( "casa/cocina/mov"); + int cociLuz= vars->AddInternalVarInt( "casa/cocina/luz"); + int cociLam= vars->AddInternalVarInt( "casa/cocina/lam"); + int cociAuto= vars->AddInternalVarInt("casa/cocina/luzAuto"); + */ + //variables para pulsadores cocina---------------------------- + + //desencadenaores---------- + char st[64]; + //Efecto Interruptor----- + sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios + des->AddDes(st); + //Efecto Pulsadores + sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios + des->AddDes(st); + sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios + des->AddDes(st); +/* + //variablaes cocina + sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",cociMov,cociAuto,cociLam,cociLam);//apaga luz si no hay nadie + des->AddDes(st); + sprintf(st,"{%d}<20&{%d}>0&{%d}>0 -> {%d}=1 ",cociLuz,cociMov,cociAuto,cociLam);//enciende luz si hay presencia y esta oscuro + des->AddDes(st); + */ + + } +}; +class ExteriorDomoConfig: public DomoConfig +{ + public: + ExteriorDomoConfig() + { + velocidadPortSerie=115200; + strcpy(ssidWifi,"Idhun");//nombre wifi + strcpy(keyWifi,"Ardileorca1234.");//key wifi + strcpy(ideEsp,"Esp8266_Ext");//idenitificador del esp (sera único) + strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker + portMQTT=1883;//puerto del servidor mqtt Broker + refresTimeVars=30;//tiempo de refresco en segundos de las variables + refresTimeSens=5;//tiempo de refresco en segundos de los sensores + } + //configuracion de sensores--------------------------------- + virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) + { + sens->AddHDT22(D2, "casa/ext"); + sens->AddAnalogIn(0, "casa/ext/lluvia",true); + } +}; + + + + +//configuracion que se usara-------------------------- +SalonDomoConfig ConfiguracionActual; diff --git a/DomoEsp_Potencia_v02/sube.bat b/DomoEsp_Potencia_v02/sube.bat new file mode 100644 index 0000000..0a4e144 --- /dev/null +++ b/DomoEsp_Potencia_v02/sube.bat @@ -0,0 +1,2 @@ +"c:\Program Files (x86)\Arduino\arduino.exe" --board arduino:avr:nano:cpu=atmega168 --port /dev/ttyACM0 --upload /path/to/sketch/sketch.ino +pause \ No newline at end of file