Narvaling-Arduino
/
DomoEsp_v1
mirror of http://desa.narvaling.com/Bonobo.Git.Server/DomoEsp_v1.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

correcciones publicacion

Gerardo/correcciones_publicacion
Gerardo 2023-04-11 22:03:37 +02:00
parent ab9404d4dc
commit 08357b8eb9
28 changed files with 4055 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1,2 +1,4 @@
/DomoEsp_v02/.vs/* /DomoEsp_v02/.vs/*
/DomoEsp_v02/.vs/DomoEsp_v02/v17/* /DomoEsp_v02/.vs/DomoEsp_v02/v17/*
/DomoEsp_Potencia_v02/.vs/*
/DomoEsp_Potencia_v02/__vm/*

8
DomoEsp_Potencia_v02/CppProperties.json Normal file
View File

@ -0,0 +1,8 @@
{
"configurations": [
{
"name": "Visual Micro",
"intelliSenseMode": "windows-msvc-x86"
}
]
}

138
DomoEsp_Potencia_v02/DomoEspManager.cpp Normal file
View File

@ -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; i<sens.sens.n; i++)
{
#ifdef DEBUG_PS
Serial.println("busca BUzz");
#endif
MqttSensor* s= sens.Get(i);
#ifdef DEBUG_PS
Serial.println("busca BUzz 2");
#endif
if(s->tipo == 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)
{
}

115
DomoEsp_Potencia_v02/DomoEspManager.h Normal file
View File

@ -0,0 +1,115 @@
#ifndef DomoEspManagerDef
#define DomoEspManagerDef 1
//#include <ESP8266WiFi.h>//este para esp8266
//#include <PubSubClient.h>
#include <SPI.h>
#include <LiquidCrystal.h>
/*
#include <SimpleDHT.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
*/
#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 <LiquidCrystal.h>
#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

75
DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.filters Normal file
View File

@ -0,0 +1,75 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<None Include="DomoEsp_v02.ino" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="__vm\.DomoEsp_v02.vsarduino.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="config_rf.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="DomoEspManager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="LcdMQTTViewer.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttDefines.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttDesencadenadorManager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttSensManager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttUtiles.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttVarManager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MqttWOLManager.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="DomoEspManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="LcdMQTTViewer.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MqttDesencadenadorManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MqttSensManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MqttUtiles.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MqttVarManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MqttWOLManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>

92
DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.ino Normal file
View File

@ -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 <SPI.h>
#include <ESP8266WiFi.h>//este para esp8266
//#include <WiFi.h>//este para esp32
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
WiFiUDP UDP;
#include <SimpleDHT.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
//#include <PubSubClient.h>
#include "DomoEspManager.h"
#include "MqttWOLManager.h"
#include <WakeOnLan.h>
#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();
}

25
DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.sln Normal file
View File

@ -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

142
DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj Normal file
View File

File diff suppressed because one or more lines are too long

4
DomoEsp_Potencia_v02/DomoEsp_Potencia_v02.vcxproj.user Normal file
View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

183
DomoEsp_Potencia_v02/LcdMQTTViewer.cpp Normal file
View File

@ -0,0 +1,183 @@
#include <SPI.h>
#include <LiquidCrystal.h>
#include <PubSubClient.h>
#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<lines; i++)
{
envia("Iniciando",0,i);
}
}
void LcdMQTTViewer::loop()
{
if (!MqttUtiles::pasa_incre(&tiempo, incre_t))
return;
#ifdef DEBUG_PS
Serial.println("Refres lcd");
#endif
envia(panActual);
panActual = (panActual + 1) % (maxpan+1);
}
void LcdMQTTViewer::add(byte ivar, char* formatLCD, int line, int pan)
{
if (maxtInfo >= 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(; lin<nlineslcd; lin++)
{
envia("",0,lin);
}
tiempo=millis();
return -1;
}
void LcdMQTTViewer::suscribe(PubSubClient *client_qqtt)
{
if(!topic[0])
return;
client_qqtt->subscribe(topic);
}

54
DomoEsp_Potencia_v02/LcdMQTTViewer.h Normal file
View File

@ -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

28
DomoEsp_Potencia_v02/MqttDefines.h Normal file
View File

@ -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

431
DomoEsp_Potencia_v02/MqttDesencadenadorManager.cpp Normal file
View File

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

116
DomoEsp_Potencia_v02/MqttDesencadenadorManager.h Normal file
View File

@ -0,0 +1,116 @@
#ifndef MqttDesencadenadorManagerDef
#define MqttDesencadenadorManagerDef 1
#include <SPI.h>
#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

618
DomoEsp_Potencia_v02/MqttSensManager.cpp Normal file
View File

@ -0,0 +1,618 @@
//#include <ESP8266WiFi.h>//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; i<n; i++)
{
res=Get(i);
if (!res)
continue;
if(res->ivar==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; i<sens.n; i++)
procesaSensor(i);
}
void MqttSensManager::procesaSensor(int i)
{
MqttSensor *s=sens.Get(i);
MqttVar *v=vars->Get(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; i<n_inter; i++)
{
if(!MqttChange_ind_interrup[i])
continue;
noInterrupts();
MqttChange_ind_interrup[i]=false;
interrupts();
MqttSensor* s=sens.Get(ind_interrup[i]);
//if(chg_interrup[i])
{
#ifdef DEBUG_PS
Serial.println("Detectado cambio en interrupcion");
#endif
//lee variable
MqttVar *v=vars->Get(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; i<n_inter; i++)
{
MqttSensor* s=sens.Get(ind_interrup[i]);
if(!(s->flags & (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);
}*/

220
DomoEsp_Potencia_v02/MqttSensManager.h Normal file
View File

@ -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 <PubSubClient.h>
class SonidoBuzzer;
//class PubSubClient;
class MqttVarManager;
#include <SimpleDHT.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
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

346
DomoEsp_Potencia_v02/MqttUtiles.cpp Normal file
View File

@ -0,0 +1,346 @@
#include <SPI.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <EEPROM.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
#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++;
}

155
DomoEsp_Potencia_v02/MqttUtiles.h Normal file
View File

@ -0,0 +1,155 @@
#ifndef MqttUtilesrDef
#define MqttUtilesDef 1
//#include <WiFi.h>//este para esp32
#include <ESP8266WiFi.h>//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 <class Cgeneg>
void get(Cgeneg* dout)//lee entero
{
byte *b=(byte)dout;
for(int i=sizeof(Cgeneg); i>0;i--)
leeb(&b[i]);
};
template <class Cgenes>
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

434
DomoEsp_Potencia_v02/MqttVarManager.cpp Normal file
View File

@ -0,0 +1,434 @@
//#include <ESP8266WiFi.h>//este para esp8266
#include <SPI.h>
#include "MqttDefines.h"
#include "MqttVarManager.h"
#include "MqttUtiles.h"
#include <cstring>
#include <PubSubClient.h>
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<n; i++)
{
if(!strcmp(topic,Get(i)))
return i;
}
return (int)-1;
}
int MqttTopicAttay::Add(char *topic)
{
int i=Get(topic);
if(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<n; i++)
{
if(data[i].topic==itopic)
return &(data[i]);
}
return NULL;
}
int MqttVarArray::Add(MqttVar* var)
{
if (n >= 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; i<nListenner; i++)
{
onChangeListener[i]=NULL;
}
}
void MqttVarManager::SetTimeRefres(int seg)
{
incre_tvar=seg*1000;
}
void MqttVarManager::config(MqttVarArray *vArray, MqttTopicAttay* t)
{
if(vArray)
vars=vArray;
else
vars=&_v;
if(t)
topics=t;
else
topics=&_t;
}
void MqttVarManager::OnMqtt(char* topic, char* payload)
{
char buf[MAXTOPICVAR];
#ifdef DEBUG_PS
Serial.print("OnmqttVars: ");
Serial.println(topic);
Serial.print("val: ");
Serial.println(payload);
#endif
strcpy(buf, topic);
int nt=strlen(buf);
int ng=strlen("/get");
if(nt<ng)
{
#ifdef DEBUG_PS
Serial.print("se descarta por topic corto:");
Serial.println(buf);
#endif
return;
}
bool isGet=!strcmp("/get", &buf[nt-ng]);
bool isSet=!strcmp("/set", &buf[nt-ng]);
buf[nt-ng]=0;
/*#ifdef DEBUG_PS
Serial.print("OnmqttVars:Topiccompara:");
Serial.println(buf);
#endif*/
byte f=MqttVar::OUT_VAR;
if(isGet)
{
f=(byte)MqttVar::PRIV_VAR;
#ifdef DEBUG_PS
Serial.println("OnmqttVars: get detectado");
#endif
}
else if(isSet)
{
#ifdef DEBUG_PS
Serial.println("OnmqttVars: set detectado");
#endif
}
else
{
#ifdef DEBUG_PS
Serial.println("OnmqttVars: Ni get ni set");
#endif
return;//no es ni get ni set
}
//comprueba variables
MqttVar* v;
int res=-1;
MQTTvalor val;
for(int i=0; i<vars->n; 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::INTERNAL_VAR)
return;
else 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; i<vars->n; 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; i<vars->n; 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::AddPrivadaVarFloat(char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR | MqttVar::FLOAT_VAR | MqttVar::CHANGE_VAR | MqttVar::ACCION_VAR), topic);
}
int MqttVarManager::AddPrivadaVarInt(char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR | MqttVar::CHANGE_VAR | MqttVar::ACCION_VAR), topic);
}
int MqttVarManager::AddInternalVarFloat( char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR|MqttVar::FLOAT_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR | MqttVar::INTERNAL_VAR),topic);
}
int MqttVarManager::AddInternalVarInt( char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR | MqttVar::INTERNAL_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;i<vars->n; 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; i<nListenner; i++)
{
if(onChangeListener[i]==NULL)
continue;
onChangeListener[i]->OnVarChange(ivar);
}
}
void MqttVarManager::AddListenner(MqttOnVarChangeListenner *pOnChangeListener)
{
onChangeListener[nListenner++]=pOnChangeListener;
}
void MqttVarManager::ResetVolatileVar()
{
for(int i=0; i<vars->n; 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);
}

129
DomoEsp_Potencia_v02/MqttVarManager.h Normal file
View File

@ -0,0 +1,129 @@
/*#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
INTERNAL_VAR = 0x80//no publica
};
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);
int AddPrivadaVarFloat(char* topic);
int AddPrivadaVarInt(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

36
DomoEsp_Potencia_v02/MqttWOLManager.cpp Normal file
View File

@ -0,0 +1,36 @@
#include <PubSubClient.h>
#include <WakeOnLan.h>
#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);
}

22
DomoEsp_Potencia_v02/MqttWOLManager.h Normal file
View File

@ -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

657
DomoEsp_Potencia_v02/config_rf.h Normal file
View File

@ -0,0 +1,657 @@
//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->AddPrivadaVarInt( "casa/Salon/LAmb");
int lchim= vars->AddPrivadaVarInt( "casa/Salon/LChime");
int lent= vars->AddPrivadaVarInt( "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}=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);
/*
//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);
}
};
class SalonPruebaConfig: public DomoConfig
{
public:
SalonPruebaConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_salonPruebas");//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/Prueba");//01
//sens->AddDinRetardOff(D5, 60,"casa/Prueba/mov");//2
//sens->AddAnalogIn(0, "casa/Prueba/luz",true);//3
//variables----------------------------------------------------
//variables para pulsadores---------------------------
int lamb= vars->AddPrivadaVarInt( "casa/Prueba/LAmb");
int lchim= vars->AddPrivadaVarInt( "casa/Prueba/LChime");
int lent= vars->AddPrivadaVarInt( "casa/Prueba/LEnt");
int pul1= vars->AddInternalVarInt( "casa/Prueba/pul1");
int pul2= vars->AddInternalVarInt( "casa/Prueba/pul2");
int pul3= vars->AddInternalVarInt( "casa/Prueba/pul3");
int pulIall= vars->AddInternalVarInt( "casa/Prueba/intAll");
int pulAll= vars->AddInternalVarInt( "casa/Prueba/pulAll");
//variables para pulsadores cocina----------------------------
//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);
}
};
//configuracion que se usara--------------------------
SalonDomoConfig ConfiguracionActual;

2
DomoEsp_Potencia_v02/sube.bat Normal file
View File

@ -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

BIN
DomoEsp_v02/.vs/DomoEsp_v02/v17/.suo
View File

Binary file not shown.

BIN
DomoEsp_v02/.vs/DomoEsp_v02/v17/Browse.VC.db
View File

Binary file not shown.

4
DomoEsp_v02/MqttDefines.h
View File

@ -3,8 +3,8 @@
#define MqttDefinesDef 1 #define MqttDefinesDef 1
//generales //generales
#define DEBUG_PS 1 #define DEBUG_PS 1
#define CON_WOL 1 #define CON_WOL 0
#define CON_LCD 1 #define CON_LCD 0
#define MAXTOPICVAR 32//maximo de caracteres de los topic de las variables #define MAXTOPICVAR 32//maximo de caracteres de los topic de las variables

42
DomoEsp_v02/config_rf.h
View File

@ -1,7 +1,7 @@
//parametros configurables************************************************* //parametros configurables*************************************************
#define DEBUG_PS 1//Descomentar para debug #define DEBUG_PS 1//Descomentar para debug
#define CON_LCD 1 #define CON_LCD 0
#define CON_WOL 1 #define CON_WOL 0
//va por 16 //va por 16
class CocinapRUBDomoConfig: public DomoConfig class CocinapRUBDomoConfig: public DomoConfig
{ {
@ -15,7 +15,7 @@
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
} }
//configuracion de sensores--------------------------------- //configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
@ -59,7 +59,7 @@ class ActDomoConfig: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -165,7 +165,7 @@ class SalonHome: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -236,7 +236,7 @@ class PulSalonPruebConfig: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -258,10 +258,10 @@ class PulSalonPruebConfig: public DomoConfig
//sens->AddHDT22(D4, "casa/desp"); //sens->AddHDT22(D4, "casa/desp");
// sens->AddDout(D1, "casa/p/LEnt", true); // sens->AddDout(D1, "casa/p/LEnt", true);
sens->AddDout(D7, "casa/p/LEnt", true); sens->AddDout(D7, "casa/p/LEnt", true);
sens->AddDin( D1,"casa/p/pul1"); // sens->AddDin( D1,"casa/p/pul1");
sens->AddDin( D2, "casa/p/pul2"); //sens->AddDin( D2, "casa/p/pul2");
sens->AddDin( D3, "casa/p/pul3"); //sens->AddDin( D3, "casa/p/pul3");
sens->AddDin( D4,"casa/p/pulAll"); //sens->AddDin( D4,"casa/p/pulAll");
} }
}; };
class AutomatismosDomoConfig: public DomoConfig class AutomatismosDomoConfig: public DomoConfig
@ -278,7 +278,7 @@ class AutomatismosDomoConfig: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -374,7 +374,7 @@ class PulSalonConfig: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -407,10 +407,10 @@ class PulSalonConfig: public DomoConfig
//sens->AddHDT22(D4, "casa/desp"); //sens->AddHDT22(D4, "casa/desp");
// sens->AddDout(D1, "casa/Salon/LEnt", true); // sens->AddDout(D1, "casa/Salon/LEnt", true);
sens->AddDout(D7, "casa/Salon/LEnt", true); sens->AddDout(D7, "casa/Salon/LEnt", true);
sens->AddDinRetardOff( D1, 1,"casa/Salon/pul1"); //sens->AddDinRetardOff( D1, 1,"casa/Salon/pul1");
sens->AddDinRetardOff( D2, 1, "casa/Salon/pul2"); //sens->AddDinRetardOff( D2, 1, "casa/Salon/pul2");
sens->AddDinRetardOff( D5, 1, "casa/Salon/pul3"); //sens->AddDinRetardOff( D5, 1, "casa/Salon/pul3");
sens->AddDinRetardOff( D6, 1,"casa/Salon/pulAll"); //sens->AddDinRetardOff( D6, 1,"casa/Salon/pulAll");
} }
}; };
class DespachoDomoConfig: public DomoConfig class DespachoDomoConfig: public DomoConfig
@ -427,7 +427,7 @@ class DespachoDomoConfig: public DomoConfig
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd-------------------- //config lcd--------------------
lcd.colum=16;//columnas lcd lcd.colum=16;//columnas lcd
@ -480,7 +480,7 @@ class CocinaDomoConfig: public DomoConfig
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
} }
//configuracion de sensores--------------------------------- //configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
@ -523,7 +523,7 @@ class SalonDomoConfig: public DomoConfig
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
} }
//configuracion de sensores--------------------------------- //configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
@ -589,7 +589,7 @@ class ExteriorDomoConfig: public DomoConfig
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=15;//tiempo de refresco en segundos de los sensores refresTimeSens=5;//tiempo de refresco en segundos de los sensores
} }
//configuracion de sensores--------------------------------- //configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des) virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
@ -603,4 +603,4 @@ class ExteriorDomoConfig: public DomoConfig
//configuracion que se usara-------------------------- //configuracion que se usara--------------------------
DespachoDomoConfig ConfiguracionActual; SalonHome ConfiguracionActual;