mirror of
https://github.com/anklimov/lighthub
synced 2026-06-16 12:56:23 +03:00
1133 lines
47 KiB
C++
1133 lines
47 KiB
C++
#ifndef MULTIVENT_DISABLE
|
|
|
|
#include "modules/out_multivent.h"
|
|
#include "Arduino.h"
|
|
#include "options.h"
|
|
#include "Streaming.h"
|
|
|
|
#include "item.h"
|
|
#include "main.h"
|
|
#include "utils.h"
|
|
|
|
void convert2float(aJsonObject * o)
|
|
{
|
|
if (!o) return;
|
|
switch (o->type)
|
|
{
|
|
case aJson_Int:
|
|
o->valuefloat = o->valueint;
|
|
o->type = aJson_Float;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void out_Multivent::getConfig()
|
|
{
|
|
gatesObj = NULL;
|
|
acObj = NULL;
|
|
if (!item || !item->itemArg || item->itemArg->type != aJson_Object) return;
|
|
gatesObj = item->itemArg;
|
|
if (gatesObj) acObj = aJson.getObjectItem(gatesObj, "");
|
|
}
|
|
|
|
int out_Multivent::Setup()
|
|
{
|
|
abstractOut::Setup();
|
|
//getConfig();
|
|
|
|
//Allocate objects to store persistent data in config tree
|
|
if (gatesObj)
|
|
{
|
|
aJsonObject * i = gatesObj->child;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
getCreateObject(i,"fan",-1L);
|
|
getCreateObject(i,"cmd",(long) CMD_OFF);
|
|
getCreateObject(i,"out",-1L);
|
|
|
|
aJsonObject * pidObj = aJson.getObjectItem(i, "pid");
|
|
if (pidObj && pidObj->type == aJson_Array && aJson.getArraySize(pidObj)>=3)
|
|
{
|
|
aJsonObject * setObj = getCreateObject(i,"set",(float) 20.0);
|
|
convert2float(setObj);
|
|
aJsonObject * valObj = getCreateObject(i,"val",(float) NAN);
|
|
convert2float(valObj);
|
|
aJsonObject * poObj = getCreateObject(i,"po", (float) -2.0);
|
|
convert2float(poObj);
|
|
|
|
int direction = DIRECT;
|
|
float kP=getFloatFromJson(pidObj,"kP",0,1.0);
|
|
if (kP<0)
|
|
{
|
|
kP=-kP;
|
|
direction=REVERSE;
|
|
}
|
|
float kI=getFloatFromJson(pidObj,"kI",1,0.0);
|
|
float kD=getFloatFromJson(pidObj,"kD",2,0.0);
|
|
float dT=getFloatFromJson(pidObj,"dT",3,5.0);
|
|
|
|
pidObj->valueint = (long int) new PID (&valObj->valuefloat, &poObj->valuefloat, &setObj->valuefloat, kP, kI, kD, P_ON_E,direction,
|
|
getFloatFromJson(i,"AlarmTime",4,120.0)*1000UL, getFloatFromJson(i,"AlarmValue",5,0.0));
|
|
|
|
//((PID*) pidObj->valueint)->SetMode (AUTOMATIC);
|
|
((PID*) pidObj->valueint)->SetSampleTime(dT*1000.0);
|
|
debugSerial << F ("VENT: PID P=")<<kP<<" I="<<kI<<" D="<<kD<< endl;
|
|
}
|
|
}
|
|
i=i->next;
|
|
}
|
|
debugSerial << F ("VENT: init")<< endl;
|
|
item->setExt(0);
|
|
setStatus(CST_INITIALIZED);
|
|
return 1;
|
|
}
|
|
|
|
debugSerial << F ("VENT: config failed")<< endl;
|
|
return 0;
|
|
|
|
}
|
|
|
|
int out_Multivent::Stop()
|
|
{
|
|
debugSerial << F ("VENT: De-Init") << endl;
|
|
if (gatesObj)
|
|
{
|
|
aJsonObject * i = gatesObj->child;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
aJsonObject * pidObj = aJson.getObjectItem(i, "pid");
|
|
if (pidObj && pidObj->valueint)
|
|
{
|
|
delete ((PID *) pidObj->valueint);
|
|
pidObj->valueint = 0;//NULL;
|
|
}
|
|
}
|
|
i=i->next;
|
|
}
|
|
}
|
|
setStatus(CST_UNKNOWN);
|
|
return 1;
|
|
}
|
|
|
|
int out_Multivent::isActive()
|
|
{
|
|
//debugSerial<<"VENT:active: ";
|
|
if (gatesObj)
|
|
{
|
|
/*
|
|
// metrics, collected from AC
|
|
aJsonObject * a = aJson.getObjectItem(gatesObj, "");
|
|
if (!a) return 0;
|
|
float acTemp = getFloatFromJson(a,"val",NAN);
|
|
int actualCmd = getIntFromJson (a,"mode");
|
|
int actualMode = CMD_FAN;
|
|
if (acTemp>30.0) actualMode = CMD_HEAT;
|
|
else if (acTemp<15.0) actualMode = CMD_COOL;
|
|
*/
|
|
aJsonObject * i = gatesObj->child;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
int cmd = getIntFromJson(i,"cmd");
|
|
switch (cmd)
|
|
{
|
|
case CMD_ON:
|
|
case CMD_HEATCOOL:
|
|
case CMD_FAN:
|
|
case CMD_AUTO:
|
|
case CMD_COOL:
|
|
case CMD_HEAT:
|
|
case CMD_DRY:
|
|
//case CMD_OFF:
|
|
return 1;
|
|
break;
|
|
}
|
|
}
|
|
i=i->next;
|
|
}//while
|
|
} // if gatesObj
|
|
return 0;
|
|
}
|
|
|
|
|
|
void out_Multivent::stopAllzones(){
|
|
if (!gatesObj) return;
|
|
debugSerial << F("VENT: Stop all zones. ")<<endl;
|
|
aJsonObject * i = gatesObj->child;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
int cmd = getIntFromJson(i,"cmd");
|
|
switch (cmd)
|
|
{
|
|
case CMD_ON:
|
|
case CMD_HEATCOOL:
|
|
case CMD_FAN:
|
|
case CMD_AUTO:
|
|
case CMD_COOL:
|
|
case CMD_HEAT:
|
|
case CMD_DRY:
|
|
//case CMD_OFF:
|
|
setValToJson(i,"@preHaltcmd",cmd);
|
|
// setPassiveMode(i, true);
|
|
fanCtrl(itemCmd().Cmd(CMD_OFF).setSuffix(S_CMD),i->name,true);
|
|
break;
|
|
}
|
|
}
|
|
i=i->next;
|
|
}//while
|
|
}
|
|
|
|
|
|
void out_Multivent::restoreAllzones(){
|
|
if (!gatesObj) return;
|
|
debugSerial << F("VENT: Restore all zones. ")<<endl;
|
|
aJsonObject * i = gatesObj->child;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
int preHaltcmd = getIntFromJson(i,"@preHaltcmd",CMD_OFF);
|
|
if (preHaltcmd && (preHaltcmd != CMD_OFF)) //setPassiveMode(i, false);
|
|
fanCtrl(itemCmd().Cmd(preHaltcmd).setSuffix(S_CMD),i->name,true);
|
|
setValToJson(i,"@preHaltcmd",0); //reset preHaltcmd in any case
|
|
}
|
|
i=i->next;
|
|
}//while
|
|
};
|
|
|
|
#define assign_if_positive(var, source) {int x=source; if (x>=0) {var=x;}}
|
|
|
|
int out_Multivent::Poll(short cause)
|
|
{
|
|
if (!acObj || !gatesObj) return 0;
|
|
|
|
if (cause == POLLING_SLOW && item->getExt() && isTimeOver(item->getExt(),millisNZ(),60000L))
|
|
{
|
|
item->setExt(0);
|
|
aJsonObject * a = aJson.getObjectItem(acObj,"val");
|
|
if (a) a->type = aJson_NULL; //invalidate in 60 sec after measure
|
|
}
|
|
|
|
// metrics, collected from AC
|
|
float acTemp = getFloatFromJson(acObj,"val",NAN);
|
|
int acCmd = getIntFromJson (acObj,"mode");
|
|
|
|
// global params
|
|
int boostTreshold = getIntFromJson (acObj,"boost",AC_BOOST_TRESHOLD);
|
|
int actualMode = CMD_FAN;
|
|
if (acTemp>30.0) actualMode = CMD_HEAT;
|
|
else if (acTemp<15.0) actualMode = CMD_COOL;
|
|
|
|
if (isnan(acTemp) && acCmd) actualMode = acCmd;
|
|
|
|
aJsonObject * i = gatesObj->child;
|
|
int balance = 0;
|
|
bool ventRequested = false; //At least 1 ch requested FAN mode
|
|
bool autoRequested = false; //At least 1 ch requested AUTO mode
|
|
bool pidActive = false;
|
|
bool pidComputed = false;
|
|
int lastACfan = -1;
|
|
while (i)
|
|
{
|
|
if (i->name && *i->name)
|
|
{
|
|
int cmd = getIntFromJson (i,"cmd");
|
|
float set = getFloatFromJson(i,"set");
|
|
float val = getFloatFromJson(i,"val");
|
|
int fan = getIntFromJson(i,"fan");
|
|
|
|
int execCmd = 0;
|
|
bool weakMode=false; // kind of modes when we activating PID only if AC in active mode
|
|
switch (cmd)
|
|
{
|
|
case CMD_HEATCOOL:
|
|
{
|
|
switch (acCmd) //TODO - release heat/cool then PID released it, not just set <> val
|
|
{
|
|
case CMD_HEAT:
|
|
if (set>val) execCmd = CMD_HEAT;
|
|
if (set<val-AC_HEATCOOL_DEADBAND) execCmd = CMD_COOL;
|
|
break;
|
|
case CMD_COOL:
|
|
if (set<val) execCmd = CMD_COOL;
|
|
if (set>val+AC_HEATCOOL_DEADBAND) execCmd = CMD_HEAT;
|
|
break;
|
|
default:
|
|
if (set>val+AC_HEATCOOL_DEADBAND) execCmd = CMD_HEAT;
|
|
if (set<val-AC_HEATCOOL_DEADBAND) execCmd = CMD_COOL;
|
|
}
|
|
}
|
|
break;
|
|
case CMD_FAN:
|
|
if (fan>0) ventRequested = true;
|
|
weakMode = true;
|
|
execCmd = cmd;
|
|
break;
|
|
case CMD_AUTO:
|
|
if (fan>0) autoRequested = true;
|
|
weakMode = true;
|
|
execCmd = cmd;
|
|
break;
|
|
case CMD_COOL:
|
|
case CMD_HEAT:
|
|
case CMD_OFF:
|
|
execCmd = cmd;
|
|
break;
|
|
}
|
|
bool passiveMode = getIntFromJson(i,"@pasv",0);
|
|
|
|
aJsonObject * pidObj = aJson.getObjectItem(i, "pid");
|
|
aJsonObject * poObj = aJson.getObjectItem(i, "po");
|
|
aJsonObject * valObj = aJson.getObjectItem(i, "val");
|
|
|
|
if (pidObj && pidObj->valueint && poObj && poObj->type == aJson_Float && valObj && valObj->type == aJson_Float)
|
|
{
|
|
PID * p = (PID *) pidObj->valueint;
|
|
|
|
/// Setup PID mode and direction based on real AC mode
|
|
switch (actualMode)
|
|
{ //if air hot or cold - uses temp PID and block control by /fan
|
|
case CMD_HEAT:
|
|
if (weakMode || passiveMode) p->SetMode(AUTOMATIC);
|
|
p->SetControllerDirection(DIRECT);
|
|
break;
|
|
case CMD_COOL:
|
|
if (weakMode || passiveMode) p->SetMode(AUTOMATIC);
|
|
p->SetControllerDirection(REVERSE);
|
|
break;
|
|
default:
|
|
if ((passiveMode || weakMode || execCmd ==CMD_OFF) && p->GetMode() == AUTOMATIC)
|
|
{
|
|
p->SetMode(MANUAL);
|
|
debugSerial<<F("VENT: PID set to MANUAL due no HEAT/COOL. zone:")<<i->name<<endl;
|
|
assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(getIntFromJson(i,"fan_in",0)).setSuffix(S_FAN),i->name,true));
|
|
}
|
|
}
|
|
|
|
if (!p->isOutdated() && (execCmd == CMD_HEAT || execCmd == CMD_COOL) && p->GetMode() == AUTOMATIC) pidActive = true;
|
|
|
|
if (p->Compute())
|
|
|
|
{
|
|
debugSerial<<F("VENT: ")
|
|
<<item->itemArr->name<<"/"<<i->name
|
|
<<F(" in:")<<p->GetIn()<<F(" set:")<<p->GetSet()<<F(" out:")<<p->GetOut()
|
|
<<" P:"<<p->GetKp()<<" I:"<<p->GetKi()<<" D:"<<p->GetKd()<<((p->GetDirection())?" Rev ":" Dir ")<<((p->GetMode())?"A":"M");
|
|
if (p->isOutdated()) debugSerial << F(" <ALM>");
|
|
debugSerial<<endl;
|
|
|
|
if (!isnan(poObj->valuefloat))
|
|
switch (execCmd)
|
|
{
|
|
case CMD_HEAT:
|
|
|
|
if (actualMode==CMD_COOL) //close
|
|
assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(0).setSuffix(S_FAN),i->name,true))
|
|
else
|
|
assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(poObj->valuefloat).setSuffix(S_FAN),i->name,true))
|
|
|
|
balance+=poObj->valuefloat;
|
|
pidComputed = true;
|
|
|
|
break;
|
|
case CMD_COOL:
|
|
if (actualMode==CMD_HEAT) //close
|
|
assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(0).setSuffix(S_FAN),i->name,true))
|
|
else
|
|
assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(poObj->valuefloat).setSuffix(S_FAN),i->name,true));
|
|
|
|
balance-=poObj->valuefloat;
|
|
pidComputed = true;
|
|
break;
|
|
|
|
default:
|
|
switch (actualMode)
|
|
{
|
|
case CMD_HEAT:
|
|
debugSerial<<F("VENT: HEAT PASS PID: ")<<item->itemArr->name<<"/"<<i->name<<F(" out:")<< poObj->valuefloat <<endl;
|
|
|
|
if (cmd !=CMD_OFF || passiveMode) assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(poObj->valuefloat).setSuffix(S_FAN),i->name,true));
|
|
break;
|
|
case CMD_COOL:
|
|
debugSerial<<F("VENT: COOL PASS PID: ")<<item->itemArr->name<<"/"<<i->name<<F(" out:")<< poObj->valuefloat <<endl;
|
|
|
|
if (cmd !=CMD_OFF || passiveMode) assign_if_positive(lastACfan, fanCtrl(itemCmd().Percents255(poObj->valuefloat).setSuffix(S_FAN),i->name,true));
|
|
break;
|
|
case CMD_FAN: //no more hot or cold air
|
|
((PID *) pidObj->valueint)->SetMode(MANUAL);
|
|
}
|
|
}
|
|
}
|
|
else //PID not computed - maybe not in time, but we can use PID output as indicator of balance and boost if needed
|
|
{
|
|
if (p->GetMode() == AUTOMATIC && !isnan(poObj->valuefloat))
|
|
{
|
|
balance+=(p->GetDirection() == DIRECT) ? poObj->valuefloat : -poObj->valuefloat;
|
|
//if (execCmd == CMD_HEAT) balance+=poObj->valuefloat;
|
|
//else if (execCmd == CMD_COOL) balance-=poObj->valuefloat;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
i=i->next;
|
|
}//while
|
|
|
|
if (pidComputed) //Active mode. PIDs in pasive mode do not triggered this flag
|
|
{
|
|
debugSerial<<F("VENT: Chan balance=")<<balance<<F(" treshold:")<<boostTreshold<<endl;
|
|
|
|
if (balance>boostTreshold) setBoost(itemCmd().Cmd(CMD_HEAT).Int(AC_BOOST_HIGH_TEMP).setSuffix(S_SET));
|
|
else if (-balance>boostTreshold) setBoost(itemCmd().Cmd(CMD_COOL).Int(AC_BOOST_LOW_TEMP).setSuffix(S_SET));
|
|
else
|
|
{
|
|
if (abs(balance)<AC_BOOST_DEADBAND) pidActive = false; //No request from active PID = no active PID
|
|
}
|
|
}
|
|
bool noFurtherModes = false;
|
|
bool activeMode = (actualMode==CMD_HEAT || actualMode==CMD_COOL);
|
|
|
|
if (!pidActive) // No active mode PID - no boost needed, but maybe vent still requested
|
|
|
|
{
|
|
resetBoost();
|
|
if (autoRequested && lastACfan>0) sendACcmd(itemCmd().Cmd(CMD_AUTO));
|
|
else if (ventRequested && lastACfan>0) sendACcmd(itemCmd().Cmd(CMD_FAN));
|
|
else noFurtherModes = true; //No AUTO or FAN mode requested - so we can skip sending command to AC at all and save some energy on it
|
|
}
|
|
|
|
if (lastACfan>0 || (lastACfan == 0 && (!activeMode || noFurtherModes))) sendACcmd(itemCmd().Percents255(lastACfan).setSuffix(S_FAN)); //if PID already set some fan value - send it to AC
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
|
|
int out_Multivent::getChanType()
|
|
{
|
|
return CH_THERMO;
|
|
}
|
|
|
|
|
|
|
|
void SubmitParameters(aJsonObject * callbackObj, const char * name, itemCmd value, bool doMapping){
|
|
if (callbackObj && callbackObj->type == aJson_Object)
|
|
{
|
|
aJsonObject * execObj = aJson.getObjectItem(callbackObj,name);
|
|
|
|
if (execObj)
|
|
{
|
|
aJsonObject * mapObj = NULL;
|
|
if (doMapping) mapObj = aJson.getObjectItem(execObj, "map");
|
|
executeCommand(execObj,-1,value.doReverseMapping(mapObj));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void out_Multivent::setPassiveMode(aJsonObject* zone, bool mode)
|
|
{
|
|
bool passiveMode = getIntFromJson(zone,"@pasv",0);
|
|
|
|
if (passiveMode != mode)
|
|
{
|
|
aJsonObject * cascadeObj=aJson.getObjectItem(zone, "cas");
|
|
|
|
//aJsonObject * cmdObj=aJson.getObjectItem(zone, "cmd");
|
|
//Set up passive mode
|
|
debugSerial<<F("VENT: passive mode: ")<<mode<<endl;
|
|
setValToJson(zone,"@pasv",mode);
|
|
|
|
if (mode)
|
|
{
|
|
if (isNotRetainingStatus())
|
|
item->SendStatusImmediate(itemCmd().Cmd(CMD_AUTO).setSuffix(S_FAN),FLAG_COMMAND,zone->name); //Send /fan->AUTO
|
|
|
|
SubmitParameters(cascadeObj,"fan",itemCmd().Cmd(CMD_AUTO).setSuffix(S_FAN),false);
|
|
setValToJson(zone,"fan",0); //reset fan level on passive mode ON
|
|
}
|
|
else
|
|
{
|
|
aJsonObject * fanObj=aJson.getObjectItem(zone, "fan");
|
|
if (!fanObj || fanObj->type!=aJson_Int) return;
|
|
if (isNotRetainingStatus())
|
|
item->SendStatusImmediate(itemCmd().Percents255(fanObj->valueint).setSuffix(S_FAN),FLAG_PARAMETERS,zone->name); //Send /fan->#
|
|
|
|
SubmitParameters(cascadeObj,"fan",itemCmd().Percents255(fanObj->valueint).setSuffix(S_FAN),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t out_Multivent::getFlag (aJsonObject* zone, uint32_t flag)
|
|
{
|
|
|
|
if (zone && (zone->type == aJson_Object))
|
|
{
|
|
return (uint32_t) zone->valueint & flag & FLAG_MASK;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void out_Multivent::setFlag (aJsonObject* zone, uint32_t flag)
|
|
{
|
|
if (zone && (zone->type == aJson_Object))
|
|
{
|
|
zone->valueint |= flag & FLAG_MASK;
|
|
}
|
|
|
|
}
|
|
|
|
void out_Multivent::clearFlag (aJsonObject* zone, uint32_t flag)
|
|
{
|
|
if (zone && (zone->type == aJson_Object))
|
|
{
|
|
zone->valueint &= CMD_MASK | ~(flag & FLAG_MASK);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int out_Multivent::Ctrl(itemCmd cmd, char* subItem , bool toExecute, bool authorized)
|
|
{
|
|
int result = fanCtrl(cmd,subItem, false);
|
|
|
|
if (result>=0)
|
|
{
|
|
debugSerial << F("VENT: CTRL fan level: ")<<result<<endl;
|
|
sendACcmd(itemCmd().Percents255(result).setSuffix(S_FAN));
|
|
}
|
|
else debugSerial << F("VENT: CTRL result: ")<<(result==-1? F("OK") : F("not OK"))<<endl;
|
|
// else debugSerial << F("VENT: Skip turning OFF by fan")<<endl;
|
|
return (result == -2)? 0 : 1;
|
|
}
|
|
|
|
// Return:
|
|
// Main AC fan value (0..255) or
|
|
// -1 unknown fan + success
|
|
// -2 unknown fan + error (forbidden by PID or frozen by freeze flag)
|
|
int out_Multivent::fanCtrl(itemCmd cmd, char* subItem , bool force)
|
|
{
|
|
if (!gatesObj || !acObj) return -2;
|
|
if (cmd.getCmd()==CMD_DISABLE || cmd.getCmd()==CMD_ENABLE) return -2;
|
|
int suffixCode = cmd.getSuffix();
|
|
debugSerial << "VENT: CTRL " << subItem << " "; cmd.debugOut();
|
|
|
|
if (cmd.isCommand() && !suffixCode) suffixCode=S_CMD; //if some known command find, but w/o correct suffix - got it
|
|
|
|
int turnbyfan = getIntFromJson(acObj,"turnbyfan",0);
|
|
|
|
if (cmd.getSuffix()==S_FAN)
|
|
{
|
|
switch (cmd.getCmd())
|
|
{
|
|
case CMD_HIGH:
|
|
cmd.Percents255(255);
|
|
cmd.Cmd(0);
|
|
break;
|
|
|
|
case CMD_MED:
|
|
cmd.Percents255(128);
|
|
cmd.Cmd(0);
|
|
break;
|
|
|
|
case CMD_LOW:
|
|
cmd.Percents255(64);
|
|
cmd.Cmd(0);
|
|
break;
|
|
|
|
// case CMD_OFF:
|
|
// cmd.Percents255(0);
|
|
// cmd.Cmd(0);
|
|
// break;
|
|
default:
|
|
if (cmd.isValue()) cmd.Percents255(cmd.getInt()); // convert to integer
|
|
} //switch cmd
|
|
}
|
|
|
|
if (!subItem) // feedback from shared AC
|
|
{
|
|
switch (suffixCode)
|
|
{
|
|
case S_VAL:
|
|
if (cmd.isValue())
|
|
{
|
|
debugSerial << F("VENT: ")<<F("AC air temp: ")<< cmd.getFloat()<<endl;
|
|
item->setExt(millisNZ()); //setup validity interval
|
|
setValToJson(acObj,"val",cmd.getFloat());
|
|
}
|
|
return -1;
|
|
|
|
case S_FAN:
|
|
if (cmd.isValue())
|
|
{
|
|
debugSerial << F("VENT: ")<<F("AC fan: ")<< cmd.getInt()<<endl;
|
|
checkACfan(cmd.getInt());
|
|
setValToJson(acObj,"fan",cmd.getInt());
|
|
}
|
|
return -1;
|
|
|
|
case S_SET:
|
|
if (cmd.isValue())
|
|
{
|
|
debugSerial << F("VENT: ")<<F("AC set: ")<< cmd.getFloat()<<endl;
|
|
checkACset(cmd.getFloat());
|
|
setValToJson(acObj,"set",cmd.getFloat());
|
|
if (cmd.getFloat() == AC_BOOST_HIGH_TEMP || cmd.getFloat() == AC_BOOST_LOW_TEMP)
|
|
{
|
|
setFlag(acObj, FLAG_ACTION_NEEDED);
|
|
debugSerial<<F("VENT: boost mode detected")<<endl;
|
|
}
|
|
}
|
|
return -1;
|
|
|
|
case S_MODE:
|
|
if (cmd.isCommand())
|
|
{
|
|
debugSerial << F("VENT: ")<<F("AC mode: ")<< cmd.getCmd()<<endl;
|
|
checkACcmd(cmd.getCmd());
|
|
setValToJson(acObj,"mode",cmd.getCmd());
|
|
}
|
|
return -1;
|
|
|
|
case S_CMD:
|
|
|
|
switch (cmd.getCmd())
|
|
{
|
|
case CMD_OFF:
|
|
stopAllzones();
|
|
break;
|
|
case CMD_ON:
|
|
case CMD_HEAT:
|
|
case CMD_COOL:
|
|
case CMD_HEATCOOL:
|
|
case CMD_DRY:
|
|
case CMD_FAN:
|
|
case CMD_AUTO:
|
|
restoreAllzones();
|
|
}
|
|
return -1;
|
|
|
|
//case S_TEMP: - temp corrupted by core
|
|
// debugSerial << F("VENT:")<<F("AC air roomtemp: ")<< cmd.getFloat()<<endl;
|
|
// setValToJson(acObj,"roomtemp",cmd.getFloat());
|
|
//return -1;
|
|
}
|
|
}
|
|
|
|
aJsonObject * i = NULL;
|
|
|
|
if (gatesObj) i = gatesObj->child; // Pass 1 - calculate summ air value, max value etc
|
|
|
|
int activeV = 0;
|
|
int totalV = 0;
|
|
int maxV=0;
|
|
int maxRequestedV=0;
|
|
int maxPercent=0;
|
|
bool exitAfterSendingStatus = false;
|
|
|
|
|
|
while (i)
|
|
{
|
|
aJsonObject * fanObj=aJson.getObjectItem(i, "fan");
|
|
aJsonObject * cmdObj=aJson.getObjectItem(i, "cmd");
|
|
aJsonObject * cascadeObj=aJson.getObjectItem(i, "cas");
|
|
|
|
//aJsonObject * setObj=aJson.getObjectItem(i, "set");
|
|
aJsonObject * pidObj=aJson.getObjectItem(i, "pid");
|
|
if (fanObj && cmdObj && fanObj->type==aJson_Int && cmdObj->type==aJson_Int)
|
|
{
|
|
|
|
int V = getIntFromJson(i,"V",60);
|
|
bool passiveMode = getIntFromJson(i,"@pasv",0);
|
|
int requestedV = 0;
|
|
|
|
if (subItem && !strcmp (i->name,subItem))
|
|
{
|
|
long sendFlags = 0;
|
|
switch (suffixCode)
|
|
{
|
|
|
|
case S_FAN:
|
|
if (getFlag(i,FLAG_FREEZED)) {debugSerial<<F("VENT: zone frozen")<<endl; return -2;}
|
|
if (cmd.isValue())
|
|
{
|
|
|
|
if (!force)
|
|
{
|
|
setValToJson(i,"fan_in",cmd.getInt()); //fan controlled by external source, save input value to restore after exit from passive mode
|
|
debugSerial<<"VENT: external fan level stored: "<<cmd.getInt()<<endl;
|
|
if (pidEnabled(pidObj))
|
|
{
|
|
debugSerial<<F("VENT: FAN control disabled by PID")<<endl;
|
|
return -2;
|
|
}
|
|
}
|
|
|
|
if (cmd.getInt())
|
|
{
|
|
if (cmdObj->valueint == CMD_OFF && turnbyfan)
|
|
{
|
|
cmd.Cmd(turnbyfan);
|
|
debugSerial<<"VENT: generating cmd by fan: "<<turnbyfan<<endl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (cmdObj->valueint != CMD_OFF && turnbyfan)
|
|
{
|
|
cmd.Cmd(CMD_OFF);
|
|
debugSerial<<"VENT: Turning OFF by fan"<<endl;
|
|
}
|
|
}
|
|
fanObj->valueint = cmd.getInt(); //
|
|
if (!passiveMode) sendFlags |= FLAG_PARAMETERS; //
|
|
//if (isNotRetainingStatus()) item->SendStatusImmediate(cmd,FLAG_PARAMETERS|FLAG_COMMAND,i->name);
|
|
}
|
|
else if (cmd.getCmd() == CMD_AUTO)
|
|
{
|
|
setPassiveMode(i,true); //Setup flag
|
|
passiveMode = true;
|
|
cmd.Cmd(CMD_OFF);
|
|
cmd.setSuffix(S_CMD);
|
|
}
|
|
else if (cmd.getCmd() == CMD_OFF)
|
|
{
|
|
setPassiveMode(i,false);
|
|
passiveMode = false;
|
|
}
|
|
|
|
if (!cmd.isCommand()) break; // if have command in FAN suffix - continue processing
|
|
debugSerial<<"VENT: cmd in FAN suffix, process as command. cmd="<<cmd.getCmd()<<endl;
|
|
case S_CMD:
|
|
if (cmd.isCommand())
|
|
{
|
|
bool checkMinFanLevel = false;
|
|
if (cmd.getCmd() == CMD_ON)
|
|
{
|
|
if (getFlag(i,FLAG_FREEZED)) {debugSerial<<F("VENT: zone frozen")<<endl; return -2;}
|
|
if (cmdObj->valueint != CMD_OFF && cmdObj->valueint != CMD_HALT) break;
|
|
cmd.Percents255(fanObj->valueint);
|
|
cmd.setSuffix(S_FAN);
|
|
sendFlags |= FLAG_COMMAND | FLAG_PARAMETERS;
|
|
//cmdObj->valueint = cmd.getCmd();
|
|
cmdObj->valueint = getIntFromJson(i,"@precmd",CMD_FAN);
|
|
debugSerial<<"VENT: Turning ON. cmd:"<<cmdObj->valueint<<endl;
|
|
cmd.Cmd(cmdObj->valueint);
|
|
setPassiveMode(i,false);
|
|
}
|
|
|
|
switch (cmd.getCmd())
|
|
{
|
|
case CMD_ON:
|
|
checkMinFanLevel = true;
|
|
break;
|
|
case CMD_OFF:
|
|
if (getFlag(i,FLAG_FREEZED)) {debugSerial<<F("VENT: zone frozen")<<endl; return -2;}
|
|
if (cmdObj->valueint != CMD_OFF) setValToJson(i,"@precmd",cmdObj->valueint); //saving previous mode
|
|
cmd.Percents255(0);
|
|
cmd.setSuffix(S_FAN);
|
|
debugSerial<<"VENT: Turning OFF. saving cmd:"<<cmdObj->valueint<<endl;
|
|
sendFlags |= FLAG_COMMAND;
|
|
//sendFlags |= FLAG_PARAMETERS; //experimental 30/03/26
|
|
//
|
|
if (!passiveMode) sendFlags |= FLAG_PARAMETERS;
|
|
// else cmd.Cmd(CMD_AUTO);
|
|
|
|
cmdObj->valueint = CMD_OFF;
|
|
enablePid(pidObj,false);
|
|
break;
|
|
/*
|
|
case CMD_ENABLE:
|
|
if (pidObj && pidObj->valueint) ((PID *) pidObj->valueint)->SetMode(AUTOMATIC);
|
|
sendFlags |= FLAG_FLAGS;
|
|
setPassiveMode(i,false);
|
|
break;
|
|
|
|
case CMD_DISABLE:
|
|
if (pidObj && pidObj->valueint) ((PID *) pidObj->valueint)->SetMode(MANUAL);
|
|
sendFlags |= FLAG_FLAGS;
|
|
setPassiveMode(i,false);
|
|
break;
|
|
*/
|
|
|
|
case CMD_FREEZE:
|
|
setFlag(i,FLAG_FREEZED);
|
|
return -1;
|
|
|
|
case CMD_UNFREEZE:
|
|
clearFlag(i,FLAG_FREEZED);
|
|
return -1;
|
|
|
|
case CMD_COOL:
|
|
case CMD_DRY:
|
|
enablePid(pidObj,true,REVERSE);
|
|
sendFlags |= FLAG_COMMAND;
|
|
cmdObj->valueint = cmd.getCmd();
|
|
setPassiveMode(i,false);
|
|
checkMinFanLevel = true;
|
|
break;
|
|
|
|
case CMD_HEAT:
|
|
enablePid(pidObj,true,DIRECT);
|
|
case CMD_HEATCOOL:
|
|
enablePid(pidObj,true);
|
|
|
|
sendFlags |= FLAG_COMMAND;
|
|
cmdObj->valueint = cmd.getCmd();
|
|
setPassiveMode(i,false);
|
|
checkMinFanLevel = true;
|
|
break;
|
|
|
|
case CMD_FAN:
|
|
sendFlags |= FLAG_PARAMETERS; //experimental 30/03/26
|
|
cmd.Percents255(fanObj->valueint);
|
|
cmd.setSuffix(S_FAN);
|
|
// continue
|
|
case CMD_AUTO:
|
|
enablePid(pidObj,false);
|
|
sendFlags |= FLAG_COMMAND;
|
|
cmdObj->valueint = cmd.getCmd();
|
|
setPassiveMode(i,false);
|
|
checkMinFanLevel = true;
|
|
break;
|
|
//todo - halt-rest-xon-xoff
|
|
}
|
|
if (isNotRetainingStatus() && checkMinFanLevel && (fanObj->valueint<20))
|
|
{
|
|
fanObj->valueint=30;
|
|
cmd.Percents255(30);
|
|
sendFlags |= FLAG_PARAMETERS;
|
|
}
|
|
}
|
|
break;
|
|
case S_SET:
|
|
if (cmd.isValue())
|
|
{
|
|
setValToJson(i,"set",cmd.getFloat());
|
|
sendFlags |= FLAG_PARAMETERS;
|
|
exitAfterSendingStatus = true; //if setpoint updated - send status immediately to update PID and sending status
|
|
}
|
|
else return -1;
|
|
break;
|
|
|
|
case S_VAL:
|
|
if (cmd.isValue())
|
|
{
|
|
aJsonObject * pidObj = aJson.getObjectItem(i, "pid");
|
|
if (pidObj && pidObj->valueint)
|
|
{
|
|
((PID *) pidObj->valueint)->SetVal(cmd.getFloat());
|
|
debugSerial<<F("VENT: PID input: ")<<i->name<<F(" updated by temp: ")<< cmd.getFloat()<<endl;
|
|
}
|
|
}
|
|
return -1;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
} //switch
|
|
if (isNotRetainingStatus()) //Send status separately for cmd, param, flags
|
|
{
|
|
if (sendFlags & FLAG_COMMAND) item->SendStatusImmediate(itemCmd().Cmd(cmd).setSuffix(S_CMD),FLAG_COMMAND,i->name);
|
|
if (sendFlags & FLAG_PARAMETERS ) item->SendStatusImmediate(cmd,FLAG_PARAMETERS,i->name);
|
|
if (sendFlags & FLAG_FLAGS) item->SendStatusImmediate(cmd,FLAG_FLAGS,i->name);
|
|
}
|
|
if (cascadeObj)
|
|
{
|
|
|
|
if (sendFlags & FLAG_COMMAND) SubmitParameters(cascadeObj,"cmd",itemCmd().Cmd(cmd).setSuffix(S_CMD).setArgType(0),true);
|
|
if (sendFlags & FLAG_PARAMETERS)
|
|
switch (cmd.getSuffix())
|
|
{
|
|
case S_SET:
|
|
SubmitParameters(cascadeObj,"set",cmd,true);
|
|
break;
|
|
case S_FAN:
|
|
SubmitParameters(cascadeObj,"fan",cmd,true);
|
|
break;
|
|
}
|
|
}
|
|
} // subitem
|
|
if (exitAfterSendingStatus) return -1; //if setpoint updated - send status immediately to update PID and sending status
|
|
|
|
if ((cmdObj->valueint != CMD_OFF && cmdObj->valueint != -1) || passiveMode)
|
|
{
|
|
requestedV=V*fanObj->valueint;
|
|
activeV+=requestedV;
|
|
|
|
if (fanObj->valueint>maxPercent )
|
|
{
|
|
maxRequestedV=requestedV;
|
|
maxV=V;
|
|
maxPercent=fanObj->valueint;
|
|
}
|
|
}
|
|
totalV+=V;
|
|
|
|
}
|
|
i=i->next;
|
|
}
|
|
|
|
if (!totalV) return 0;
|
|
|
|
int fanV=activeV/totalV;
|
|
debugSerial << F("VENT: Total V:")<<totalV<<F(" active V:")<<activeV/255<< F(" fan%:")<<fanV<< F(" Max req:")<<maxRequestedV/255 <<F(" from ")<<maxV<<F(" m3")<< endl;
|
|
|
|
|
|
|
|
//if (fanV || allowToTurnOffByFan) sendACcmd(itemCmd().Percents255(fanV).setSuffix(S_FAN));
|
|
// else debugSerial << F("VENT: Skip turning OFF by fan")<<endl;
|
|
|
|
|
|
//Move gates only if fan is actually on
|
|
if (!fanV) return 0;
|
|
|
|
i=NULL;
|
|
if (gatesObj) i = gatesObj->child; //Pass 2: re-distribute airflow
|
|
|
|
while (i)
|
|
{
|
|
|
|
int V = getIntFromJson(i,"V",60);
|
|
|
|
|
|
aJsonObject * outObj=aJson.getObjectItem(i, "out");
|
|
aJsonObject * fanObj=aJson.getObjectItem(i, "fan");
|
|
aJsonObject * cmdObj=aJson.getObjectItem(i, "cmd");
|
|
bool passiveMode = getIntFromJson(i,"@pasv",0);
|
|
|
|
|
|
if (outObj && fanObj && cmdObj && outObj->type==aJson_Int && fanObj->type==aJson_Int && cmdObj->type==aJson_Int && V)
|
|
{
|
|
long int out = 0;
|
|
if (((cmdObj->valueint != CMD_OFF && cmdObj->valueint != -1) || passiveMode) && maxRequestedV)
|
|
{
|
|
int requestedV=V*fanObj->valueint;
|
|
out = (( long)requestedV*255L)/(( long)V)*( long)maxV/( long)maxRequestedV;
|
|
debugSerial<<F("VENT: ")<<i->name<<F(" Req:")<<requestedV/255<<F(" Out:")<<out<<endl;
|
|
}
|
|
|
|
|
|
if ((out != outObj->valueint))
|
|
{
|
|
//report out
|
|
executeCommand(i,-1,itemCmd().Percents255(out));
|
|
outObj->valueint=out;
|
|
}
|
|
}
|
|
i=i->next;
|
|
}
|
|
|
|
return fanV;
|
|
}
|
|
|
|
void out_Multivent::enablePid(aJsonObject* pidObj, int enable, int direction )
|
|
{
|
|
if (pidObj && pidObj->valueint)
|
|
{
|
|
((PID *) pidObj->valueint)->SetMode(enable);
|
|
if (direction != -1) ((PID *) pidObj->valueint)->SetControllerDirection(direction);
|
|
}
|
|
}
|
|
|
|
|
|
bool out_Multivent::pidEnabled(aJsonObject* pidObj)
|
|
{
|
|
return ((pidObj && pidObj->valueint) && (((PID *) pidObj->valueint)->GetMode() ==AUTOMATIC));
|
|
}
|
|
|
|
|
|
void out_Multivent::checkACcmd (int acCmd)
|
|
{
|
|
if (!acObj) return;
|
|
int lastCmd = getIntFromJson(acObj,"@lastCmd");
|
|
int prevACcmd = getIntFromJson(acObj,"mode");
|
|
int lastFan = getIntFromJson(acObj,"@lastFan",-1);
|
|
|
|
if (!prevACcmd) {
|
|
debugSerial<<"VENT: AC MODE received initially "<<acCmd<<endl;
|
|
setValToJson(acObj,"@lastCmd",acCmd);
|
|
return;
|
|
}
|
|
|
|
if (lastCmd && (acCmd != lastCmd) ) {
|
|
|
|
if (!(acCmd == CMD_OFF && lastFan == 0))
|
|
{
|
|
debugSerial<<"VENT: AC MODE changed manually from "<<lastCmd<<" to "<<acCmd<<endl;
|
|
|
|
switch (acCmd)
|
|
{
|
|
case CMD_OFF:
|
|
stopAllzones();
|
|
break;
|
|
default:
|
|
restoreAllzones();
|
|
break;
|
|
}
|
|
|
|
aJsonObject * execObj = aJson.getObjectItem(acObj, "onextcmd");
|
|
if (execObj)
|
|
{
|
|
executeCommand(execObj,-1,itemCmd().Cmd(acCmd).setSuffix(S_CMD).setArgType(0).doReverseMapping(aJson.getObjectItem(execObj, "map")));
|
|
}
|
|
}
|
|
setValToJson(acObj,"@lastCmd",acCmd);
|
|
setValToJson(acObj,"@lastFan",-1);
|
|
return;}
|
|
|
|
}
|
|
|
|
void out_Multivent::checkACfan (int acFan)
|
|
{
|
|
if (!acObj) return;
|
|
int prevACfan = getIntFromJson(acObj,"fan");
|
|
if (acFan != prevACfan)
|
|
{
|
|
debugSerial<<"VENT: AC FAN changed, delete lastfan"<<endl;
|
|
setValToJson(acObj,"@lastFan",-1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void out_Multivent::checkACset (int acSet)
|
|
{
|
|
if (!acObj) return;
|
|
int lastSet = getIntFromJson(acObj,"@lastSet",-1);
|
|
//int prevACset = getIntFromJson(acObj,"set");
|
|
|
|
if (lastSet == -1) {
|
|
debugSerial<<"VENT: AC SET received initially "<<acSet<<endl;
|
|
setValToJson(acObj,"@lastSet",acSet);
|
|
return;
|
|
}
|
|
|
|
if (lastSet && (acSet != lastSet)) {
|
|
debugSerial<<"VENT: AC SET changed manually from "<<lastSet<<" to "<<acSet<<endl;
|
|
aJsonObject * execObj = aJson.getObjectItem(acObj, "onextcmd");
|
|
if (execObj)
|
|
{
|
|
executeCommand(execObj,-1,itemCmd().Int(acSet).setSuffix(S_SET).doReverseMapping(aJson.getObjectItem(execObj, "map")));
|
|
}
|
|
setValToJson(acObj,"@lastSet",acSet);
|
|
return;}
|
|
|
|
}
|
|
|
|
|
|
|
|
int out_Multivent::sendACcmd (itemCmd cmd)
|
|
{
|
|
if (!acObj) return 0;
|
|
int supress = getIntFromJson(acObj,"supress",0xF);
|
|
|
|
|
|
//int acCmd = getIntFromJson(acObj,"mode");
|
|
|
|
//if (lastCmd && (acCmd != lastCmd)) {
|
|
// //debugSerial<<"VENT: AC MODE changed manually to "<<item->getCmd()<<endl;
|
|
// return 0;}
|
|
|
|
if (cmd.isCommand())
|
|
{
|
|
int lastCmd = getIntFromJson(acObj,"@lastCmd");
|
|
int overrideCmd = getIntFromJson(acObj,"overridecmd");
|
|
if (overrideCmd && cmd.getCmd() != CMD_OFF) cmd.Cmd(overrideCmd); //if override cmd exist - use it instead of requested. But allow to turn off by original cmd
|
|
|
|
if (cmd.getCmd() == lastCmd && (supress & AC_SUPPRESS_CMD))
|
|
{
|
|
//debugSerial<<"VENT: AC MODE already "<<lastCmd<<endl;
|
|
}
|
|
else
|
|
{
|
|
debugSerial<<"VENT: sendACcmd. cmd="; cmd.debugOut(); debugSerial<<endl;
|
|
executeCommand(acObj,-1,itemCmd().Cmd(cmd).setSuffix(S_CMD).setArgType(0));
|
|
setValToJson(acObj,"@lastCmd",cmd.getCmd());
|
|
setValToJson(acObj,"@lastFan",-1); //reset last fan to avoid suppression after mode change
|
|
}
|
|
}
|
|
if (cmd.isValue())
|
|
{
|
|
int lastFan = getIntFromJson(acObj,"@lastFan",-1);
|
|
int lastSet = getFloatFromJson(acObj,"@lastSet");
|
|
int prevACcmd = getIntFromJson(acObj,"mode",-1);
|
|
bool isActiveNow = (prevACcmd != CMD_OFF && prevACcmd != -1) || (lastFan>0);
|
|
|
|
switch (cmd.getSuffix())
|
|
{
|
|
case S_FAN:
|
|
if (!(supress & AC_SUPPRESS_FAN) || lastFan != cmd.getInt()) {
|
|
debugSerial<<"VENT: sendACcmd. fan="; cmd.debugOut(); debugSerial<<endl;
|
|
executeCommand(acObj,-1,cmd.Cmd(0));
|
|
}
|
|
setValToJson(acObj,"@lastFan",cmd.getInt());
|
|
|
|
if (cmd.getInt() == 0)
|
|
{
|
|
/////setValToJson(acObj,"@lastCmd",CMD_OFF);
|
|
if (isActiveNow) setValToJson(acObj,"@preCmd",prevACcmd);
|
|
}
|
|
else if (cmd.getInt() > 0 && !isActiveNow)
|
|
{
|
|
int preCmd = getIntFromJson(acObj,"@preCmd",CMD_FAN);
|
|
setValToJson(acObj,"@lastCmd",preCmd);
|
|
}
|
|
break;
|
|
case S_SET:
|
|
if (!(supress & AC_SUPPRESS_SET) || lastSet != cmd.getFloat()) {
|
|
debugSerial<<"VENT: sendACcmd. set="; cmd.debugOut(); debugSerial<<endl;
|
|
executeCommand(acObj,-1,cmd.Cmd(0));
|
|
}
|
|
setValToJson(acObj,"@lastSet",cmd.getFloat());
|
|
break;
|
|
default:
|
|
executeCommand(acObj,-1,cmd.Cmd(0));
|
|
break;
|
|
}
|
|
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void out_Multivent::setBoost(itemCmd cmd)
|
|
{
|
|
if (!acObj || getFlag(acObj,FLAG_ACTION_NEEDED)) return;
|
|
debugSerial<<"VENT: boost on"<<endl;
|
|
int acSetTemp = getIntFromJson(acObj,"set",AC_PRESET_TEMP);
|
|
setValToJson(acObj,"@preset",acSetTemp);
|
|
sendACcmd(cmd);
|
|
setFlag(acObj,FLAG_ACTION_NEEDED);
|
|
}
|
|
|
|
void out_Multivent::resetBoost()
|
|
{
|
|
if (!acObj) return;
|
|
//int acSetTemp = getIntFromJson(acObj,"set");
|
|
if (!getFlag(acObj,FLAG_ACTION_NEEDED)) return;
|
|
debugSerial<<"VENT: boost off"<<endl;
|
|
int preTemp = getIntFromJson(acObj,"@preset",AC_PRESET_TEMP);
|
|
if (preTemp<=AC_BOOST_LOW_TEMP) preTemp = AC_PRESET_TEMP;
|
|
if (preTemp>=AC_BOOST_HIGH_TEMP) preTemp = AC_PRESET_TEMP;
|
|
sendACcmd(itemCmd().Cmd(0).Int(preTemp).setSuffix(S_SET));
|
|
clearFlag(acObj,FLAG_ACTION_NEEDED);
|
|
}
|
|
|
|
void out_Multivent::notifyState(itemCmd state)
|
|
{
|
|
char val[16];
|
|
state.toString(val,sizeof(val),FLAG_COMMAND);
|
|
publishTopic(item->itemArr->name,val,"/$state");
|
|
}
|
|
|
|
#endif
|