correcciones publicacion
parent
ab9404d4dc
commit
08357b8eb9
|
|
@ -1,2 +1,4 @@
|
|||
/DomoEsp_v02/.vs/*
|
||||
/DomoEsp_v02/.vs/DomoEsp_v02/v17/*
|
||||
/DomoEsp_Potencia_v02/.vs/*
|
||||
/DomoEsp_Potencia_v02/__vm/*
|
||||
|
|
|
|||
|
|
@ -0,0 +1,8 @@
|
|||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Visual Micro",
|
||||
"intelliSenseMode": "windows-msvc-x86"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -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)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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>
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
|
@ -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
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,4 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup />
|
||||
</Project>
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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);
|
||||
}*/
|
||||
|
|
@ -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
|
||||
|
|
@ -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++;
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
|
|
@ -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
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -3,8 +3,8 @@
|
|||
#define MqttDefinesDef 1
|
||||
//generales
|
||||
#define DEBUG_PS 1
|
||||
#define CON_WOL 1
|
||||
#define CON_LCD 1
|
||||
#define CON_WOL 0
|
||||
#define CON_LCD 0
|
||||
|
||||
#define MAXTOPICVAR 32//maximo de caracteres de los topic de las variables
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
//parametros configurables*************************************************
|
||||
#define DEBUG_PS 1//Descomentar para debug
|
||||
#define CON_LCD 1
|
||||
#define CON_WOL 1
|
||||
#define CON_LCD 0
|
||||
#define CON_WOL 0
|
||||
//va por 16
|
||||
class CocinapRUBDomoConfig: public DomoConfig
|
||||
{
|
||||
|
|
@ -15,7 +15,7 @@
|
|||
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=15;//tiempo de refresco en segundos de los sensores
|
||||
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)
|
||||
|
|
@ -59,7 +59,7 @@ class ActDomoConfig: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -165,7 +165,7 @@ class SalonHome: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -236,7 +236,7 @@ class PulSalonPruebConfig: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -258,10 +258,10 @@ class PulSalonPruebConfig: public DomoConfig
|
|||
//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");
|
||||
// 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
|
||||
|
|
@ -278,7 +278,7 @@ class AutomatismosDomoConfig: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -374,7 +374,7 @@ class PulSalonConfig: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -407,10 +407,10 @@ class PulSalonConfig: public DomoConfig
|
|||
//sens->AddHDT22(D4, "casa/desp");
|
||||
// sens->AddDout(D1, "casa/Salon/LEnt", true);
|
||||
sens->AddDout(D7, "casa/Salon/LEnt", true);
|
||||
sens->AddDinRetardOff( D1, 1,"casa/Salon/pul1");
|
||||
sens->AddDinRetardOff( D2, 1, "casa/Salon/pul2");
|
||||
sens->AddDinRetardOff( D5, 1, "casa/Salon/pul3");
|
||||
sens->AddDinRetardOff( D6, 1,"casa/Salon/pulAll");
|
||||
//sens->AddDinRetardOff( D1, 1,"casa/Salon/pul1");
|
||||
//sens->AddDinRetardOff( D2, 1, "casa/Salon/pul2");
|
||||
//sens->AddDinRetardOff( D5, 1, "casa/Salon/pul3");
|
||||
//sens->AddDinRetardOff( D6, 1,"casa/Salon/pulAll");
|
||||
}
|
||||
};
|
||||
class DespachoDomoConfig: public DomoConfig
|
||||
|
|
@ -427,7 +427,7 @@ class DespachoDomoConfig: public DomoConfig
|
|||
portMQTT=1883;//puerto del servidor mqtt Broker
|
||||
|
||||
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--------------------
|
||||
lcd.colum=16;//columnas lcd
|
||||
|
|
@ -480,7 +480,7 @@ class CocinaDomoConfig: public DomoConfig
|
|||
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=15;//tiempo de refresco en segundos de los sensores
|
||||
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)
|
||||
|
|
@ -523,7 +523,7 @@ class SalonDomoConfig: public DomoConfig
|
|||
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=15;//tiempo de refresco en segundos de los sensores
|
||||
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)
|
||||
|
|
@ -589,7 +589,7 @@ class ExteriorDomoConfig: public DomoConfig
|
|||
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=15;//tiempo de refresco en segundos de los sensores
|
||||
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)
|
||||
|
|
@ -603,4 +603,4 @@ class ExteriorDomoConfig: public DomoConfig
|
|||
|
||||
|
||||
//configuracion que se usara--------------------------
|
||||
DespachoDomoConfig ConfiguracionActual;
|
||||
SalonHome ConfiguracionActual;
|
||||
|
|
|
|||
Loading…
Reference in New Issue