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

Añade sensor potencia

master
Gerardo 2023-03-10 12:18:40 +01:00
parent ab9404d4dc
commit a36d5a068b
34 changed files with 4175 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
DomoEsp_Potencia_v02/.vs/DomoEsp_v02/project-colors.json Normal file
View File

@ -0,0 +1,16 @@
{
"Version": 1,
"ProjectMap": {
"a2fe74e1-b743-11d0-ae1a-00a0c90fffc3": {
"ProjectGuid": "a2fe74e1-b743-11d0-ae1a-00a0c90fffc3",
"DisplayName": "Archivos varios",
"ColorIndex": -1
},
"c5f80730-f44f-4478-bdae-6634efc2ca88": {
"ProjectGuid": "c5f80730-f44f-4478-bdae-6634efc2ca88",
"DisplayName": "DomoEsp_v02",
"ColorIndex": 0
}
},
"NextColorIndex": 1
}

BIN
DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/.suo Normal file
View File

Binary file not shown.

BIN
DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v16/Browse.VC.db Normal file
View File

Binary file not shown.

BIN
DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/.suo Normal file
View File

Binary file not shown.

BIN
DomoEsp_Potencia_v02/.vs/DomoEsp_v02/v17/Browse.VC.db Normal file
View File

Binary file not shown.

3
DomoEsp_Potencia_v02/.vs/ProjectSettings.json Normal file
View File

@ -0,0 +1,3 @@
{
"CurrentProjectSetting": "Visual Micro"
}

7
DomoEsp_Potencia_v02/.vs/VSWorkspaceState.json Normal file
View File

@ -0,0 +1,7 @@
{
"ExpandedNodes": [
""
],
"SelectedNode": "\\MqttVarManager.h",
"PreviewInSolutionExplorer": false
}

BIN
DomoEsp_Potencia_v02/.vs/slnx.sqlite Normal file
View File

Binary file not shown.

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

424
DomoEsp_Potencia_v02/MqttVarManager.cpp Normal file
View File

@ -0,0 +1,424 @@
//#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::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::AddInternalVarFloat( char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR|MqttVar::FLOAT_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR),topic);
}
int MqttVarManager::AddInternalVarInt( char* topic)
{
return AddVar((byte)(MqttVar::PRIV_VAR| MqttVar::CHANGE_VAR|MqttVar::ACCION_VAR),topic);
}
int MqttVarManager::AddVirtualOutVarInt( char* topic)
{
return AddVar((byte)(MqttVar::IN_VAR|MqttVar::OUT_VAR|MqttVar::ACCION_VAR),topic);
}
MqttVar* MqttVarManager::Get(int i)
{
return vars->Get(i);
}
int MqttVarManager::GetId(char* topic)
{
#ifdef DEBUG_PS
Serial.println("MqttVarManager::GetId");
#endif
int itop= topics->Get(topic);
#ifdef DEBUG_PS
Serial.println("MqttVarManager::GetId busca var");
#endif
for(int i=0;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);
}

127
DomoEsp_Potencia_v02/MqttVarManager.h Normal file
View File

@ -0,0 +1,127 @@
/*#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif*/
#ifndef MqttvarManagerDef
#define MqttvarManagerDef 1
#include "MqttDefines.h"
class PubSubClient;
//array de topic
class MqttTopicAttay
{
char def[1];
public:
char str[MAXSTR];//topic de mqtt asociado
int ind[MAXVAR];
int nst;
int n;
MqttTopicAttay();
char* Get(int i);
int Get(char *topic);
int Add(char *topic);
};
union MQTTvalor
{
float f;
byte i;
};
class MqttVar
{
public:
enum TipoFlags//indica el tipo de sensor
{
OUT_VAR=0x01,//variable de salida (acepta set)
IN_VAR=0x02,//variable de entrada (publica get) (publica cada x tiempo)
PRIV_VAR=0x04,//variable privada de entrada (acepta get como si fueran set)
FLOAT_VAR=0x08,//variable en coma flotante
ACCION_VAR=0x10,//variable de accion (publica en cada cambio onchange si se le llama como publicar)
VOLATILE_VAR=0x20, //marca variable que una vez revisada se cambia internamente su valor (usado en desencadenadores para variables de accion)
CHANGE_VAR=0x40, //publica con set en lugar de get
};
public:
//generales---------------------------------------------------------------------
byte flags;
MQTTvalor val;//valor de la variable (tiene que ser union porque puede ser double)
byte topic;//topic de mqtt asociado
MqttVar();
};
//array de variables--------------------------------------------------------------
class MqttVarArray
{
public:
MqttVar data[MAXVAR];//array de variables
int n;
MqttVarArray();
MqttVar* Get(int i);
MqttVar* GetVar(int itopic);
int Add(MqttVar* var);
};
class MqttOnVarChangeListenner;
//manager de variables------------------------------------------------------
class MqttVarManager
{
MqttVarArray _v;
MqttTopicAttay _t;
MqttOnVarChangeListenner* onChangeListener[2];
int nListenner;
public:
MqttVarArray* vars;//variables mqtt
MqttTopicAttay* topics;
PubSubClient* client_qqtt;//cliente mqtt
unsigned long tiempo_var;
unsigned long incre_tvar;
MqttVarManager();
void config(MqttVarArray *vArray=NULL, MqttTopicAttay* t=NULL);
void SetTimeRefres(int seg);
void inicia(PubSubClient *client_qqtt);//inicia variables si hace falta
void Suscribe();//subscribe variables a mqtt
void OnMqtt(char* topic, char* payload);//entra trama mqtt devuelve indice a sensor cambiado
void loop();//publica datos variables
//funciones auxiliares----------------------------
void AddListenner(MqttOnVarChangeListenner *pOnChangeListener);
MqttVar* Get(int i);
int GetId(char* topic);//devuelve el id de una variable
int AddVar(byte flags, char*topic);
int AddVirtualOutVarInt( char*topic);
int AddInternalVarFloat( char*topic);
int AddInternalVarInt( char*topic);
void PublicaVars();
void PublicaVar(int ivar);
void OnChange(int ivar, bool publica);
void ResetVolatileVar();
void InvierteVar(int ivar);
void SetVal(int ivar,MQTTvalor val);
};
/*
*/
#endif

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

142
DomoEsp_Potencia_v02/__vm/.DomoEsp_v02.vsarduino.h Normal file
View File

@ -0,0 +1,142 @@
/*
Editor: https://www.visualmicro.com/
This file is for intellisense purpose only.
Visual micro (and the arduino ide) ignore this code during compilation. This code is automatically maintained by visualmicro, manual changes to this file will be overwritten
The contents of the _vm sub folder can be deleted prior to publishing a project
All non-arduino files created by visual micro and all visual studio project or solution files can be freely deleted and are not required to compile a sketch (do not delete your own code!).
Note: debugger breakpoints are stored in '.sln' or '.asln' files, knowledge of last uploaded breakpoints is stored in the upload.vmps.xml file. Both files are required to continue a previous debug session without needing to compile and upload again
Hardware: NodeMCU 1.0 (ESP-12E Module), Platform=esp8266, Package=esp8266
*/
#if defined(_VMICRO_INTELLISENSE)
#ifndef _VSARDUINO_H_
#define _VSARDUINO_H_
#define __ESP8266_esp8266__
#define __ESP8266_ESP8266__
#define _VMDEBUG 1
#define __ets__
#define ICACHE_FLASH
#define _GNU_SOURCE
#define MMU_IRAM_SIZE 0x8000
#define MMU_ICACHE_SIZE 0x8000
#define NONOSDK22x_190703 1
#define F_CPU 80000000L
#define LWIP_OPEN_SRC
#define TCP_MSS 536
#define LWIP_FEATURES 1
#define LWIP_IPV6 0
#define ARDUINO 108016
#define ARDUINO_ESP8266_NODEMCU_ESP12E
#define ARDUINO_ARCH_ESP8266
#define LED_BUILTIN 2
#define FLASHMODE_DIO
#define ESP8266
#define __cplusplus 201103L
#undef __cplusplus
#define __cplusplus 201103L
#define __STDC__
#define __ARM__
#define __arm__
#define __inline__
#define __asm__(x)
#define __asm__
#define __extension__
#define __ATTR_PURE__
#define __ATTR_CONST__
#define __volatile__
#define __ASM
#define __INLINE
#define __attribute__(noinline)
//#define _STD_BEGIN
//#define EMIT
#define WARNING
#define _Lockit
#define __CLR_OR_THIS_CALL
#define C4005
#define _NEW
//typedef int uint8_t;
//#define __ARMCC_VERSION 400678
//#define PROGMEM
//#define string_literal
//
//#define prog_void
//#define PGM_VOID_P int
//
typedef int _read;
typedef int _seek;
typedef int _write;
typedef int _close;
typedef int __cleanup;
//#define inline
#define __builtin_clz
#define __builtin_clzl
#define __builtin_clzll
#define __builtin_labs
#define __builtin_va_list
typedef int __gnuc_va_list;
#define __ATOMIC_ACQ_REL
#define __CHAR_BIT__
#define _EXFUN()
typedef unsigned char byte;
extern "C" void __cxa_pure_virtual() {;}
typedef long __INTPTR_TYPE__ ;
typedef long __UINTPTR_TYPE__ ;
typedef long __SIZE_TYPE__ ;
typedef long __PTRDIFF_TYPE__;
// Additions needed for v3.0.0 Core - Needs to be conditional on it being this core really!!
#ifndef isnan
#undef _Lockit
#undef __STDC__
#define __STDC__ 1
#define __CHAR_BIT__ 1
extern int isinf(double);
extern int isnan(double);
extern int fpclassify(double);
extern int signbit(double);
extern int isfinite(double);
extern int isnormal(double);
extern int isgreater(double, double);
extern int isgreaterequal(double);
extern int isless(double, double);
extern int islessequal(double, double);
extern int islessgreater(double, double);
extern int isunordered(double, double);
#endif
#include "new"
#include "Esp.h"
#include "arduino.h"
#include <pins_arduino.h>
#include "..\generic\Common.h"
#include "..\generic\pins_arduino.h"
#undef F
#define F(string_literal) ((const PROGMEM char *)(string_literal))
#undef PSTR
#define PSTR(string_literal) ((const PROGMEM char *)(string_literal))
//current vc++ does not understand this syntax so use older arduino example for intellisense
//todo:move to the new clang/gcc project types.
#define interrupts() sei()
#define noInterrupts() cli()
#include "DomoEsp_v02.ino"
#endif
#endif

31
DomoEsp_Potencia_v02/__vm/Compile.vmps.xml Normal file
View File

File diff suppressed because one or more lines are too long

9
DomoEsp_Potencia_v02/__vm/Configuration.Debug.vmps.xml Normal file
View File

File diff suppressed because one or more lines are too long

606
DomoEsp_Potencia_v02/config_rf.h Normal file
View File

@ -0,0 +1,606 @@
//parametros configurables*************************************************
#define DEBUG_PS 1//Descomentar para debug
#define CON_LCD 0
#define CON_WOL 0
//va por 16
class CocinapRUBDomoConfig: public DomoConfig
{
public:
CocinapRUBDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_P");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
}
//configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
sens->AddHDT22(D4, "casa/cocina");//01
sens->AddDinRetardOff(D5, 60,"casa/p/mov");//2
int mov=2;
sens->AddAnalogIn(0, "casa/p/luz",true);//3
int luz=3;
sens->AddDin( D1, "casa/p/inter");//4
int interr=4;
sens->AddDout(D2, "casa/p/lam", false);//5
int lam=5;
int lauto= vars->AddVirtualOutVarInt( "casa/p/luzAuto");//variable privada
char st[64];
//Efecto Pulsadores
sprintf(st,"{%d}>0 -> !{%d} ",interr,lam);//accion interruptor
des->AddDes(st);
sprintf(st,"{%d}<1 -> !{%d} ",interr,lam);//accion interruptor
des->AddDes(st);
sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",mov,lauto,lam,lam);//apaga luz si no hay nadie
des->AddDes(st);
sprintf(st,"{%d}>20&{%d}>0&{%d}>0 -> {%d}=1 ",luz,mov,lauto,lam);//enciende luz si hay presencia y esta oscuro
des->AddDes(st);
}
};
class ActDomoConfig: public DomoConfig
{
public:
ActDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_pruebas");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=D5;
lcd.en=D6;//eneable
lcd.d0=D3;
lcd.d1=D2;
lcd.d2=D1;
lcd.d3=D0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
/*
sens->AddHDT22(int pin, char* topic);
//tempe y presion varometrica
sens->AddBMP180(int sda,int scl, char* topic);
//entradas digitales
sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..)
sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...)
//salida digital
sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...)
Sensor analogico
sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ...
sens->AddBuzz(int pin, char* topic);
*/
sens->AddDinRetardOn(D1,5,"casa/p/pul");
sens->AddDout(D5,"casa/p/led", true);
//sens->AddHDT22(D4, "casa/desp");
//sens->AddBuzz(D0, "casa/p/buz");
//sens->AddMelodia("m200#100d200#0");
//variables----------------------------------------------------
/*
int ivar= vars->AddVar(byte flags, char*topic);//variable con flags a elegir
int ivar= vars->AddInternalVarFloat( char*topic);//variable privada
int ivar= vars->AddInternalVarInt( char*topic);//variable privada
* /
int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb");
int lchim= vars->AddInternalVarInt( "casa/Salon/LChime");
int lent= vars->AddInternalVarInt( "casa/Salon/LEnt");
int pul1= vars->AddInternalVarInt( "casa/Salon/pul1");
int pul2= vars->AddInternalVarInt( "casa/Salon/pul2");
int pul3= vars->AddInternalVarInt( "casa/Salon/pul3");
int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll");
int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll");
//lcd---------------------------------------------------------
//lcd->add(0,"T des: %s",0,0);
//lcd->add(1,"H des: %s",1,0);
//lcd->add(temCoci,"T coci: %s",0,1);
//lcd->add(temDesp,"H coci: %s",1,1);
/*
//sin depender de variable
lcd->add(-1,"Hola",0,0);
lcd->add(-1,"como va",1,0);
lcd->add(-1,"Mi ritmo",0,1);
lcd->add(-1,"bueno pa goza",1,1);* /
*/
//desencadenaores----------
char st[64];
//Efecto Interruptor-----
sprintf(st,"{%d}<1 -> !{%d} ",0,1);//terminar en espacios y separar operadores (no puede estar 2 operadores juntos)
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",0,1);//terminar en espacios
des->AddDes(st);
/*
sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
//Efecto Pulsadores
sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios
des->AddDes(st);
/* */
}
};
class SalonHome: public DomoConfig
{
public:
SalonHome()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_SalomHome");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=D5;
lcd.en=D6;//eneable
lcd.d0=D3;
lcd.d1=D2;
lcd.d2=D1;
lcd.d3=D0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
/*
sens->AddHDT22(int pin, char* topic);
//tempe y presion varometrica
sens->AddBMP180(int sda,int scl, char* topic);
//entradas digitales
sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..)
sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...)
//salida digital
sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...)
Sensor analogico
sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ...
sens->AddBuzz(int pin, char* topic);
*/
sens->AddDoutPulsador(D4, "casa/Salon/ordeTele", true, 1);
sens->AddDoutPulsador(D2, "casa/Salon/router", true, 1);
sens->AddDout(D3,"casa/Salon/auxiliar", true);
int aux=2;
sens->AddDout(D1,"casa/Salon/equipoMusica", true);
int equipo=3;
sens->AddDin( D5,"casa/Salon/pulEquipoM");
int pequipo=4;
sens->AddDin( D6, "casa/Salon/pulAux");
int paux=5;
//variables----------------------------------------------------
//desencadenaores----------
char st[64];
//Efecto Interruptor-----
sprintf(st,"{%d}>0 -> !{%d} ",pequipo,equipo);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",paux,aux);//terminar en espacios
des->AddDes(st);
}
};
class PulSalonPruebConfig: public DomoConfig
{
public:
PulSalonPruebConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_pulSalonPrueb");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=0;
lcd.en=0;//eneable
lcd.d0=0;
lcd.d1=0;
lcd.d2=0;
lcd.d3=0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
//sens->AddHDT22(D4, "casa/desp");
// sens->AddDout(D1, "casa/p/LEnt", true);
sens->AddDout(D7, "casa/p/LEnt", true);
sens->AddDin( D1,"casa/p/pul1");
sens->AddDin( D2, "casa/p/pul2");
sens->AddDin( D3, "casa/p/pul3");
sens->AddDin( D4,"casa/p/pulAll");
}
};
class AutomatismosDomoConfig: public DomoConfig
{
public:
AutomatismosDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_autom");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=D5;
lcd.en=D6;//eneable
lcd.d0=D3;
lcd.d1=D2;
lcd.d2=D1;
lcd.d3=D0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
/*
sens->AddHDT22(int pin, char* topic);
//tempe y presion varometrica
sens->AddBMP180(int sda,int scl, char* topic);
//entradas digitales
sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..)
sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...)
//salida digital
sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...)
Sensor analogico
sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ...
*/
//sens->AddHDT22(D4, "casa/desp");
//sens->AddAnalogIn(0, "casa/desp/luz",true);
//variables----------------------------------------------------
/*
int ivar= vars->AddVar(byte flags, char*topic);//variable con flags a elegir
int ivar= vars->AddInternalVarFloat( char*topic);//variable privada
int ivar= vars->AddInternalVarInt( char*topic);//variable privada
*/
int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb");
int lchim= vars->AddInternalVarInt( "casa/Salon/LChime");
int lent= vars->AddInternalVarInt( "casa/Salon/LEnt");
int pul1= vars->AddInternalVarInt( "casa/Salon/pul1");
int pul2= vars->AddInternalVarInt( "casa/Salon/pul2");
int pul3= vars->AddInternalVarInt( "casa/Salon/pul3");
int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll");
int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll");
//lcd---------------------------------------------------------
//lcd->add(0,"T des: %s",0,0);
//lcd->add(1,"H des: %s",1,0);
//lcd->add(temCoci,"T coci: %s",0,1);
//lcd->add(temDesp,"H coci: %s",1,1);
/*
//sin depender de variable
lcd->add(-1,"Hola",0,0);
lcd->add(-1,"como va",1,0);
lcd->add(-1,"Mi ritmo",0,1);
lcd->add(-1,"bueno pa goza",1,1);*/
//desencadenaores----------
char st[64];
//Efecto Interruptor-----
sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
//Efecto Pulsadores
sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios
des->AddDes(st);
}
};
class PulSalonConfig: public DomoConfig
{
public:
PulSalonConfig()
{
//CON LCD Y WOL
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_pulSalon");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=0;
lcd.en=0;//eneable
lcd.d0=0;
lcd.d1=0;
lcd.d2=0;
lcd.d3=0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
/*
sens->AddHDT22(int pin, char* topic);
//tempe y presion varometrica
sens->AddBMP180(int sda,int scl, char* topic);
//entradas digitales
sens->AddDin(int pin, char* topic);//añade variable digital que se actualiza de manera instantanea (interruptores sensor presencia ..)
sens->AddDinAccion(int pin, char* topic);//añade variable que solo publica en el cambio (pulsadores, ...)
//salida digital
sens->AddDout(int pin, char* topic, bool defautlValor);//variable que solo publica en el cambio (pulsadores, ...)
Sensor analogico
sens->AddAnalogIn(int pin, char* topic, bool ValNegado);//nivel de luz, nivel de lluvia ...
*/
//sens->AddHDT22(D4, "casa/desp");
// sens->AddDout(D1, "casa/Salon/LEnt", true);
sens->AddDout(D7, "casa/Salon/LEnt", true);
sens->AddDinRetardOff( D1, 0,"casa/Salon/pul1");
sens->AddDinRetardOff( D2, 0, "casa/Salon/pul2");
sens->AddDinRetardOff( D5, 0, "casa/Salon/pul3");
sens->AddDinRetardOff( D6, 0,"casa/Salon/pulAll");
}
};
class DespachoDomoConfig: public DomoConfig
{
public:
DespachoDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_Despacho");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
//config lcd--------------------
lcd.colum=16;//columnas lcd
lcd.lines=2;//lineas
//pines lcd
lcd.rs=D5;
lcd.en=D6;//eneable
lcd.d0=D3;
lcd.d1=D2;
lcd.d2=D1;
lcd.d3=D0;
}
//configuracion de sensores, variables, lcd---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd,MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
//sensores--------------------------------------------------------
sens->AddHDT22(D4, "casa/desp");
sens->AddAnalogIn(0, "casa/desp/luz",true);
sens->AddBuzz(D7, "casa/des/buz");
sens->AddMelodia("m200#100d200#0");//titu
sens->AddMelodia("d200#100d200#100d200#100f200#100l300#0");
//variables----------------------------------------------------
int temCoci= vars->AddInternalVarFloat( "casa/cocina/t");//variable privada
int hcocina= vars->AddInternalVarFloat( "casa/cocina/h");//variable privada
int temExt= vars->AddInternalVarFloat( "casa/ext/t");//variable privada
int hExt= vars->AddInternalVarFloat( "casa/ext/h");//variable privada
//lcd---------------------------------------------------------
lcd->add(0,"T des: %s",0,0);
lcd->add(1,"H des: %s",1,0);
lcd->add(temCoci,"T coci: %s",0,1);
lcd->add(hcocina,"H coci: %s",1,1);
lcd->add(temExt,"T Ext: %s",0,2);
lcd->add(hExt,"H Ext: %s",1,2);
strcpy(lcd->topic,"casa/desp/msg");
strcpy(wol->topic,"casa/wol");
}
};
class CocinaDomoConfig: public DomoConfig
{
public:
CocinaDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_cocina");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
}
//configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
sens->AddHDT22(D4, "casa/cocina");//01
sens->AddDinRetardOff(D5, 60,"casa/cocina/mov");//2
int mov=2;
sens->AddAnalogIn(0, "casa/cocina/luz",true);//3
int luz=3;
sens->AddDin( D1, "casa/cocina/inter");//4
sens->AddDout(D2, "casa/cocina/lam", false);//5
int lam=5;
int lauto= vars->AddVirtualOutVarInt( "casa/cocina/luzAuto");
char st[64];
//Efecto Pulsadores
sprintf(st,"{%d}>0 -> !{%d} ",4,lam);//accion interruptor
des->AddDes(st);
sprintf(st,"{%d}<1 -> !{%d} ",4,lam);//accion interruptor
des->AddDes(st);
sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",mov,lauto,lam,lam);//apaga luz si no hay nadie
des->AddDes(st);
sprintf(st,"{%d}<20&{%d}>0&{%d}>0 -> {%d}=1 ",luz,mov,lauto,lam);//enciende luz si hay presencia y esta oscuro
des->AddDes(st);
}
};
class SalonDomoConfig: public DomoConfig
{
public:
SalonDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_salon");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
}
//configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
sens->AddHDT22(D4, "casa/Salon");//01
sens->AddDinRetardOff(D5, 60,"casa/Salon/mov");//2
sens->AddAnalogIn(0, "casa/Salon/luz",true);//3
//variables----------------------------------------------------
//variables para pulsadores---------------------------
int lamb= vars->AddInternalVarInt( "casa/Salon/LAmb");
int lchim= vars->AddInternalVarInt( "casa/Salon/LChime");
int lent= vars->AddInternalVarInt( "casa/Salon/LEnt");
int pul1= vars->AddInternalVarInt( "casa/Salon/pul1");
int pul2= vars->AddInternalVarInt( "casa/Salon/pul2");
int pul3= vars->AddInternalVarInt( "casa/Salon/pul3");
int pulIall= vars->AddInternalVarInt( "casa/Salon/intAll");
int pulAll= vars->AddInternalVarInt( "casa/Salon/pulAll");
/*
int cociMov= vars->AddInternalVarInt( "casa/cocina/mov");
int cociLuz= vars->AddInternalVarInt( "casa/cocina/luz");
int cociLam= vars->AddInternalVarInt( "casa/cocina/lam");
int cociAuto= vars->AddInternalVarInt("casa/cocina/luzAuto");
*/
//variables para pulsadores cocina----------------------------
//desencadenaores----------
char st[64];
//Efecto Interruptor-----
sprintf(st,"{%d}>0 -> {%d}=1 & {%d}=1 & {%d}=0 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}<1 -> {%d}=0 & {%d}=0 & {%d}=1 ",pulIall,lamb,lchim, lent);//terminar en espacios
des->AddDes(st);
//Efecto Pulsadores
sprintf(st,"{%d}>0 -> !{%d} ",pulAll,pulIall);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul1,lamb);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul2,lchim);//terminar en espacios
des->AddDes(st);
sprintf(st,"{%d}>0 -> !{%d} ",pul3,lent);//terminar en espacios
des->AddDes(st);
/*
//variablaes cocina
sprintf(st,"{%d}<1&{%d}>0&{%d}=1 -> {%d}=0 ",cociMov,cociAuto,cociLam,cociLam);//apaga luz si no hay nadie
des->AddDes(st);
sprintf(st,"{%d}<20&{%d}>0&{%d}>0 -> {%d}=1 ",cociLuz,cociMov,cociAuto,cociLam);//enciende luz si hay presencia y esta oscuro
des->AddDes(st);
*/
}
};
class ExteriorDomoConfig: public DomoConfig
{
public:
ExteriorDomoConfig()
{
velocidadPortSerie=115200;
strcpy(ssidWifi,"Idhun");//nombre wifi
strcpy(keyWifi,"Ardileorca1234.");//key wifi
strcpy(ideEsp,"Esp8266_Ext");//idenitificador del esp (sera único)
strcpy(hostMQTT,"192.168.2.50");//servidor mqttBroker
portMQTT=1883;//puerto del servidor mqtt Broker
refresTimeVars=30;//tiempo de refresco en segundos de las variables
refresTimeSens=5;//tiempo de refresco en segundos de los sensores
}
//configuracion de sensores---------------------------------
virtual void ConfigGen(MqttSensManager* sens, MqttVarManager* vars, LcdMQTTViewer *lcd, MqttWOLManager* wol, MqttDesencadenadorManager *des)
{
sens->AddHDT22(D2, "casa/ext");
sens->AddAnalogIn(0, "casa/ext/lluvia",true);
}
};
//configuracion que se usara--------------------------
SalonDomoConfig ConfiguracionActual;

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