mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Support for time proportioned relays 

Support for time proportioned (``#define USE_TIMEPROP``) and optional PID (``#define USE_PID``) relay control (#10412)
This commit is contained in:
Theo Arends 2021-01-07 15:07:14 +01:00
parent a814ec52a9
commit 23cb8ac559
7 changed files with 210 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
## [Unreleased] - Development
## [9.2.0.3]
### Added
- Support for time proportioned (``#define USE_TIMEPROP``) and optional PID (``#define USE_PID``) relay control (#10412)
### Breaking Changed
- ESP32 switch from default SPIFFS to default LittleFS file system loosing current (zigbee) files

1
RELEASENOTES.md
View File

@ -75,6 +75,7 @@ The attached binaries can also be downloaded from http://ota.tasmota.com/tasmota
- Support for IR inverted leds using ``#define IR_SEND_INVERTED true`` [#10301](https://github.com/arendst/Tasmota/issues/10301)
- Support for disabling 38kHz IR modulation using ``#define IR_SEND_USE_MODULATION false`` [#10301](https://github.com/arendst/Tasmota/issues/10301)
- Support for SPI display driver for ST7789 TFT by Gerhard Mutz [#9037](https://github.com/arendst/Tasmota/issues/9037)
- Support for time proportioned (``#define USE_TIMEPROP``) and optional PID (``#define USE_PID``) relay control [#10412](https://github.com/arendst/Tasmota/issues/10412)
- Basic support for ESP32 Odroid Go 16MB binary tasmota32-odroidgo.bin [#8630](https://github.com/arendst/Tasmota/issues/8630)
- SPI display driver SSD1331 Color oled by Jeroen Vermeulen [#10376](https://github.com/arendst/Tasmota/issues/10376)

11
tasmota/my_user_config.h
View File

@ -774,6 +774,8 @@
//#define USE_HRE // Add support for Badger HR-E Water Meter (+1k4 code)
//#define USE_A4988_STEPPER // Add support for A4988/DRV8825 stepper-motor-driver-circuit (+10k5 code)
//#define USE_PROMETHEUS // Add support for https://prometheus.io/ metrics exporting over HTTP /metrics endpoint
// -- Thermostat control ----------------------------
//#define USE_THERMOSTAT // Add support for Thermostat
#define THERMOSTAT_CONTROLLER_OUTPUTS 1 // Number of outputs to be controlled independently
@ -808,15 +810,12 @@
#define THERMOSTAT_TEMP_BAND_NO_PEAK_DET 1 // Default temperature band in thenths of degrees celsius within no peak will be detected
#define THERMOSTAT_TIME_STD_DEV_PEAK_DET_OK 10 // Default standard deviation in minutes of the oscillation periods within the peak detection is successful
// -- Prometheus exporter ---------------------------
//#define USE_PROMETHEUS // Add support for https://prometheus.io/ metrics exporting over HTTP /metrics endpoint
// -- PID and Timeprop ------------------------------
// #define use TIMEPROP // Add support for the timeprop feature (+0k8 code)
//#define USE_TIMEPROP // Add support for the timeprop feature (+0k8 code)
// For details on the configuration please see the header of tasmota/xdrv_48_timeprop.ino
// #define USE_PID // Add suport for the PID feature (+11k1 code)
//#define USE_PID // Add suport for the PID feature (+11k1 code)
// For details on the configuration please see the header of tasmota/xdrv_49_pid.ino
// -- End of general directives -------------------
// -- End of general directives ---------------------
/*********************************************************************************************\
* ESP32 only features

10
tasmota/support_features.ino
View File

@ -690,10 +690,14 @@ void ResponseAppendFeatures(void)
feature7 |= 0x00100000; // xdsp_14_SSD1331.ino
#endif
#ifdef USE_UFILESYS
feature7 |= 0x00200000;
feature7 |= 0x00200000; // xdrv_50_filesystem.ino
#endif
#ifdef USE_TIMEPROP
feature7 |= 0x00400000; // xdrv_48_timeprop.ino
#endif
#ifdef USE_PID
feature7 |= 0x00800000; // xdrv_49_pid.ino
#endif
// feature7 |= 0x00400000;
// feature7 |= 0x00800000;
// feature7 |= 0x01000000;
// feature7 |= 0x02000000;

4
tasmota/tasmota_globals.h
View File

@ -163,6 +163,10 @@ String EthernetMacAddress(void);
#endif
#ifdef USE_EMULATION_HUE
#define USE_UNISHOX_COMPRESSION // Add support for string compression
#endif
#ifdef USE_PID
#define USE_TIMEPROP
#endif
// See https://github.com/esp8266/Arduino/pull/4889

104
tasmota/xdrv_48_timeprop.ino
View File

@ -1,19 +1,24 @@
/*
xdrv_48_timeprop.ino - Timeprop support for Sonoff-Tasmota
Copyright (C) 2018 Colin Law and Thomas Herrmann
Copyright (C) 2021 Colin Law and Thomas Herrmann
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
#ifdef USE_TIMEPROP
/*********************************************************************************************\
* Code to drive one or more relays in a time proportioned manner give a
* required power value.
*
@ -74,33 +79,48 @@
#define TIMEPROP_RELAYS 1, 2 // which relay to control 1:8
* Publish values between 0 and 1 to the topic(s) described above
*
**/
\*********************************************************************************************/
#ifndef TIMEPROP_NUM_OUTPUTS
#define TIMEPROP_NUM_OUTPUTS 1 // how many outputs to control (with separate alogorithm for each)
#endif
#ifndef TIMEPROP_CYCLETIMES
#define TIMEPROP_CYCLETIMES 60 // cycle time seconds
#endif
#ifndef TIMEPROP_DEADTIMES
#define TIMEPROP_DEADTIMES 0 // actuator action time seconds
#endif
#ifndef TIMEPROP_OPINVERTS
#define TIMEPROP_OPINVERTS false // whether to invert the output
#endif
#ifndef TIMEPROP_FALLBACK_POWERS
#define TIMEPROP_FALLBACK_POWERS 0 // falls back to this if too long betwen power updates
#endif
#ifndef TIMEPROP_MAX_UPDATE_INTERVALS
#define TIMEPROP_MAX_UPDATE_INTERVALS 120 // max no secs that are allowed between power updates (0 to disable)
#endif
#ifndef TIMEPROP_RELAYS
#define TIMEPROP_RELAYS 1 // which relay to control 1:8
#endif
#ifdef USE_TIMEPROP
#include "Timeprop.h"
# include "Timeprop.h"
static Timeprop timeprops[TIMEPROP_NUM_OUTPUTS];
static int relayNos[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_RELAYS};
static long currentRelayStates = 0; // current actual relay states. Bit 0 first relay
static long timeprop_current_time_secs = 0; // a counter that counts seconds since initialisation
struct {
Timeprop timeprops[TIMEPROP_NUM_OUTPUTS];
int relay_nos[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_RELAYS};
long current_relay_states = 0; // current actual relay states. Bit 0 first relay
long current_time_secs = 0; // a counter that counts seconds since initialisation
} Tprop;
/* call this from elsewhere if required to set the power value for one of the timeprop instances */
/* index specifies which one, 0 up */
void Timeprop_Set_Power( int index, float power )
{
if (index >= 0 && index < TIMEPROP_NUM_OUTPUTS)
{
timeprops[index].setPower( power, timeprop_current_time_secs);
void TimepropSetPower(int index, float power) {
if (index >= 0 && index < TIMEPROP_NUM_OUTPUTS) {
Tprop.timeprops[index].setPower( power, Tprop.current_time_secs);
}
}
void Timeprop_Init()
{
void TimepropInit(void) {
// AddLog_P(LOG_LEVEL_INFO, PSTR("TPR: Timeprop Init"));
int cycleTimes[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_CYCLETIMES};
int deadTimes[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_DEADTIMES};
@ -108,29 +128,29 @@ void Timeprop_Init()
int fallbacks[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_FALLBACK_POWERS};
int maxIntervals[TIMEPROP_NUM_OUTPUTS] = {TIMEPROP_MAX_UPDATE_INTERVALS};
for (int i=0; i<TIMEPROP_NUM_OUTPUTS; i++) {
timeprops[i].initialise(cycleTimes[i], deadTimes[i], opInverts[i], fallbacks[i],
maxIntervals[i], timeprop_current_time_secs);
for (int i = 0; i < TIMEPROP_NUM_OUTPUTS; i++) {
Tprop.timeprops[i].initialise(cycleTimes[i], deadTimes[i], opInverts[i], fallbacks[i],
maxIntervals[i], Tprop.current_time_secs);
}
}
void Timeprop_Every_Second() {
timeprop_current_time_secs++; // increment time
void TimepropEverySecond(void) {
Tprop.current_time_secs++; // increment time
for (int i=0; i<TIMEPROP_NUM_OUTPUTS; i++) {
int newState = timeprops[i].tick(timeprop_current_time_secs);
if (newState != bitRead(currentRelayStates, relayNos[i]-1)){
int newState = Tprop.timeprops[i].tick(Tprop.current_time_secs);
if (newState != bitRead(Tprop.current_relay_states, Tprop.relay_nos[i]-1)){
// remove the third parameter below if using tasmota prior to v6.0.0
ExecuteCommandPower(relayNos[i], newState,SRC_IGNORE);
ExecuteCommandPower(Tprop.relay_nos[i], newState,SRC_IGNORE);
}
}
}
// called by the system each time a relay state is changed
void Timeprop_Xdrv_Power() {
void TimepropXdrvPower(void) {
// for a single relay the state is in the lsb of index, I have think that for
// multiple outputs then succesive bits will hold the state but have not been
// able to test that
currentRelayStates = XdrvMailbox.index;
Tprop.current_relay_states = XdrvMailbox.index;
}
/* struct XDRVMAILBOX { */
@ -142,8 +162,7 @@ void Timeprop_Xdrv_Power() {
/* char *data; */
/* } XdrvMailbox; */
// To get here post with topic cmnd/timeprop_setpower_n where n is index into timeprops 0:7
// To get here post with topic cmnd/timeprop_setpower_n where n is index into Tprop.timeprops 0:7
/*********************************************************************************************\
* Interface
@ -151,20 +170,19 @@ void Timeprop_Xdrv_Power() {
#define XDRV_48 48
bool Xdrv48(byte function)
{
bool Xdrv48(byte function) {
bool result = false;
switch (function) {
case FUNC_INIT:
Timeprop_Init();
break;
case FUNC_EVERY_SECOND:
Timeprop_Every_Second();
break;
case FUNC_SET_POWER:
Timeprop_Xdrv_Power();
break;
case FUNC_INIT:
TimepropInit();
break;
case FUNC_EVERY_SECOND:
TimepropEverySecond();
break;
case FUNC_SET_POWER:
TimepropXdrvPower();
break;
}
return result;
}

230
tasmota/xdrv_49_pid.ino
View File

@ -1,28 +1,26 @@
/*
xdrv_49_pid.ino - PID algorithm plugin for Sonoff-Tasmota
Copyright (C) 2018 Colin Law and Thomas Herrmann
Copyright (C) 2021 Colin Law and Thomas Herrmann
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Code to
*
* Usage:
* Place this file in the sonoff folder.
* Clone the library https://github.com/colinl/process-control.git from Github
* into a subfolder of lib.
* If you want to use a time proportioned relay output with this then also get
* xdrv_49_timeprop.ino
* In user_config.h or user_config_override.h include code as follows:
#ifdef USE_PID
/*********************************************************************************************\
* Uses the library https://github.com/colinl/process-control.git from Github
* In user_config_override.h include code as follows:
#define USE_PID // include the pid feature (+4.3k)
#define PID_SETPOINT 19.5 // Setpoint value. This is the process value that the process is
@ -113,7 +111,7 @@
// If not using the sensor then you can supply process values via MQTT using
// cmnd PidPv
#define PID_SHUTTER 1 // if using the PID to control a 3-way valve, create Tasmota Shutter and define the
#define PID_SHUTTER 1 // if using the PID to control a 3-way valve, create Tasmota Shutter and define the
// number of the shutter here. Otherwise leave this commented out
#define PID_REPORT_MORE_SETTINGS // If defined, the SENSOR output will provide more extensive json
@ -127,13 +125,44 @@
* Help with using the PID algorithm and with loop tuning can be found at
* http://blog.clanlaw.org.uk/2018/01/09/PID-tuning-with-node-red-contrib-pid.html
* This is directed towards using the algorithm in the node-red node node-red-contrib-pid but the algorithm here is based on
* the code there and the tuning techique described there should work just the same.
* the code there and the tuning technique described there should work just the same.
\*********************************************************************************************/
*
**/
#ifndef PID_SETPOINT
#define PID_SETPOINT 19.5 // [PidSp] Setpoint value.
#endif
#ifndef PID_PROPBAND
#define PID_PROPBAND 5 // [PidPb] Proportional band in process units (eg degrees).
#endif
#ifndef PID_INTEGRAL_TIME
#define PID_INTEGRAL_TIME 1800 // [PidTi] Integral time seconds.
#endif
#ifndef PID_DERIVATIVE_TIME
#define PID_DERIVATIVE_TIME 15 // [PidTd] Derivative time seconds.
#endif
#ifndef PID_INITIAL_INT
#define PID_INITIAL_INT 0.5 // Initial integral value (0:1).
#endif
#ifndef PID_MAX_INTERVAL
#define PID_MAX_INTERVAL 300 // [PidMaxInterval] This is the maximum time in seconds between samples.
#endif
#ifndef PID_DERIV_SMOOTH_FACTOR
#define PID_DERIV_SMOOTH_FACTOR 3 // [PidDSmooth]
#endif
#ifndef PID_AUTO
#define PID_AUTO 1 // [PidAuto] Auto mode 1 or 0 (for manual).
#endif
#ifndef PID_MANUAL_POWER
#define PID_MANUAL_POWER 0 // [PidManualPower] Power output when in manual mode or fallback mode.
#endif
#ifndef PID_UPDATE_SECS
#define PID_UPDATE_SECS 0 // [PidUpdateSecs] How often to run the pid algorithm
#endif
#ifdef USE_PID
#define PID_USE_TIMPROP 1 // To disable this feature leave this undefined
//#define PID_USE_LOCAL_SENSOR // [PidPv] If defined then the local sensor will be used for pv.
//#define PID_SHUTTER 1 // Number of the shutter here. Otherwise leave this commented out
#define PID_REPORT_MORE_SETTINGS // If defined, the SENSOR output will provide more extensive json
#include "PID.h"
@ -166,11 +195,11 @@ const char kPIDCommands[] PROGMEM = D_PRFX_PID "|" // Prefix
;
void (* const PIDCommand[])(void) PROGMEM = {
&CmndSetPv,
&CmndSetPv,
&CmndSetSp,
&CmndSetPb,
&CmndSetTi,
&cmndsetTd,
&CmndSetTd,
&CmndSetInitialInt,
&CmndSetDSmooth,
&CmndSetAuto,
@ -179,32 +208,33 @@ void (* const PIDCommand[])(void) PROGMEM = {
&CmndSetUpdateSecs
};
static PID pid;
static int update_secs = PID_UPDATE_SECS <= 0 ? 0 : PID_UPDATE_SECS; // how often (secs) the pid alogorithm is run
static int max_interval = PID_MAX_INTERVAL;
static unsigned long last_pv_update_secs = 0;
static bool run_pid_now = false; // tells PID_Every_Second to run the pid algorithm
struct {
PID pid;
int update_secs = PID_UPDATE_SECS <= 0 ? 0 : PID_UPDATE_SECS; // how often (secs) the pid alogorithm is run
int max_interval = PID_MAX_INTERVAL;
unsigned long last_pv_update_secs = 0;
bool run_pid_now = false; // tells PID_Every_Second to run the pid algorithm
long current_time_secs = 0; // a counter that counts seconds since initialisation
} Pid;
static long pid_current_time_secs = 0; // a counter that counts seconds since initialisation
void PID_Init()
void PIDInit()
{
pid.initialise( PID_SETPOINT, PID_PROPBAND, PID_INTEGRAL_TIME, PID_DERIVATIVE_TIME, PID_INITIAL_INT,
Pid.pid.initialise( PID_SETPOINT, PID_PROPBAND, PID_INTEGRAL_TIME, PID_DERIVATIVE_TIME, PID_INITIAL_INT,
PID_MAX_INTERVAL, PID_DERIV_SMOOTH_FACTOR, PID_AUTO, PID_MANUAL_POWER );
}
void PID_Every_Second() {
void PIDEverySecond() {
static int sec_counter = 0;
pid_current_time_secs++; // increment time
// run the pid algorithm if run_pid_now is true or if the right number of seconds has passed or if too long has
Pid.current_time_secs++; // increment time
// run the pid algorithm if Pid.run_pid_now is true or if the right number of seconds has passed or if too long has
// elapsed since last pv update. If too long has elapsed the the algorithm will deal with that.
if (run_pid_now || pid_current_time_secs - last_pv_update_secs > max_interval || (update_secs != 0 && sec_counter++ % update_secs == 0)) {
run_pid();
run_pid_now = false;
if (Pid.run_pid_now || Pid.current_time_secs - Pid.last_pv_update_secs > Pid.max_interval || (Pid.update_secs != 0 && sec_counter++ % Pid.update_secs == 0)) {
PIDRun();
Pid.run_pid_now = false;
}
}
void PID_Show_Sensor() {
void PIDShowSensor() {
// Called each time new sensor data available, data in mqtt data in same format
// as published in tele/SENSOR
// Update period is specified in TELE_PERIOD
@ -212,13 +242,13 @@ void PID_Show_Sensor() {
const float temperature = TasmotaGlobal.temperature_celsius;
// pass the value to the pid alogorithm to use as current pv
last_pv_update_secs = pid_current_time_secs;
pid.setPv(temperature, last_pv_update_secs);
Pid.last_pv_update_secs = Pid.current_time_secs;
Pid.pid.setPv(temperature, Pid.last_pv_update_secs);
// also trigger running the pid algorithm if we have been told to run it each pv sample
if (update_secs == 0) {
if (Pid.update_secs == 0) {
// this runs it at the next second
run_pid_now = true;
}
Pid.run_pid_now = true;
}
} else {
AddLog_P(LOG_LEVEL_ERROR, PSTR("PID: No local temperature sensor found"));
}
@ -234,69 +264,69 @@ void PID_Show_Sensor() {
/* } XdrvMailbox; */
void CmndSetPv(void) {
last_pv_update_secs = pid_current_time_secs;
pid.setPv(atof(XdrvMailbox.data), last_pv_update_secs);
Pid.last_pv_update_secs = Pid.current_time_secs;
Pid.pid.setPv(atof(XdrvMailbox.data), Pid.last_pv_update_secs);
// also trigger running the pid algorithm if we have been told to run it each pv sample
if (update_secs == 0) {
if (Pid.update_secs == 0) {
// this runs it at the next second
run_pid_now = true;
Pid.run_pid_now = true;
}
}
void CmndSetSp(void) {
pid.setSp(atof(XdrvMailbox.data));
Pid.pid.setSp(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetPb(void) {
pid.setPb(atof(XdrvMailbox.data));
Pid.pid.setPb(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetTi(void) {
pid.setTi(atof(XdrvMailbox.data));
Pid.pid.setTi(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void cmndsetTd(void) {
pid.setTd(atof(XdrvMailbox.data));
void CmndSetTd(void) {
Pid.pid.setTd(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetInitialInt(void) {
pid.setInitialInt(atof(XdrvMailbox.data));
Pid.pid.setInitialInt(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetDSmooth(void) {
pid.setDSmooth(atof(XdrvMailbox.data));
Pid.pid.setDSmooth(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetAuto(void) {
pid.setAuto(atoi(XdrvMailbox.data));
Pid.pid.setAuto(atoi(XdrvMailbox.data));
ResponseCmndNumber(atoi(XdrvMailbox.data));
}
void CmndSetManualPower(void) {
pid.setManualPower(atof(XdrvMailbox.data));
Pid.pid.setManualPower(atof(XdrvMailbox.data));
ResponseCmndNumber(atof(XdrvMailbox.data));
}
void CmndSetMaxInterval(void) {
pid.setMaxInterval(atoi(XdrvMailbox.data));
Pid.pid.setMaxInterval(atoi(XdrvMailbox.data));
ResponseCmndNumber(atoi(XdrvMailbox.data));
}
// case CMND_PID_SETUPDATE_SECS:
// update_secs = atoi(XdrvMailbox.data) ;
// if (update_secs < 0)
// update_secs = 0;
// Pid.update_secs = atoi(XdrvMailbox.data) ;
// if (Pid.update_secs < 0)
// Pid.update_secs = 0;
void CmndSetUpdateSecs(void) {
update_secs = (atoi(XdrvMailbox.data));
if (update_secs < 0)
update_secs = 0;
ResponseCmndNumber(update_secs);
Pid.update_secs = (atoi(XdrvMailbox.data));
if (Pid.update_secs < 0)
Pid.update_secs = 0;
ResponseCmndNumber(Pid.update_secs);
}
void PIDShowValues(void) {
@ -307,61 +337,60 @@ void PIDShowValues(void) {
ResponseAppend_P(PSTR(",\"PID\":{"));
// #define D_CMND_PID_SETPV "Pv"
d_buf = pid.getPv();
d_buf = Pid.pid.getPv();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidPv\":%s,"), str_buf);
// #define D_CMND_PID_SETSETPOINT "Sp"
d_buf = pid.getSp();
d_buf = Pid.pid.getSp();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidSp\":%s,"), str_buf);
#ifdef PID_REPORT_MORE_SETTINGS
// #define D_CMND_PID_SETPROPBAND "Pb"
d_buf = pid.getPb();
d_buf = Pid.pid.getPb();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidPb\":%s,"), str_buf);
// #define D_CMND_PID_SETINTEGRAL_TIME "Ti"
d_buf = pid.getTi();
d_buf = Pid.pid.getTi();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidTi\":%s,"), str_buf);
// #define D_CMND_PID_SETDERIVATIVE_TIME "Td"
d_buf = pid.getTd();
d_buf = Pid.pid.getTd();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidTd\":%s,"), str_buf);
// #define D_CMND_PID_SETINITIAL_INT "Initint"
d_buf = pid.getInitialInt();
d_buf = Pid.pid.getInitialInt();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidInitialInt\":%s,"), str_buf);
// #define D_CMND_PID_SETDERIV_SMOOTH_FACTOR "DSmooth"
d_buf = pid.getDSmooth();
d_buf = Pid.pid.getDSmooth();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidDSmooth\":%s,"), str_buf);
// #define D_CMND_PID_SETAUTO "Auto"
chr_buf = pid.getAuto();
chr_buf = Pid.pid.getAuto();
ResponseAppend_P(PSTR("\"PidAuto\":%d,"), chr_buf);
// #define D_CMND_PID_SETMANUAL_POWER "ManualPower"
d_buf = pid.getManualPower();
d_buf = Pid.pid.getManualPower();
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidManualPower\":%s,"), str_buf);
// #define D_CMND_PID_SETMAX_INTERVAL "MaxInterval"
i_buf = pid.getMaxInterval();
i_buf = Pid.pid.getMaxInterval();
ResponseAppend_P(PSTR("\"PidMaxInterval\":%d,"), i_buf);
// #define D_CMND_PID_SETUPDATE_SECS "UpdateSecs"
ResponseAppend_P(PSTR("\"PidUpdateSecs\":%d,"), update_secs);
ResponseAppend_P(PSTR("\"PidUpdateSecs\":%d,"), Pid.update_secs);
#endif // PID_REPORT_MORE_SETTINGS
// The actual power value
d_buf = pid.tick(pid_current_time_secs);
d_buf = Pid.pid.tick(Pid.current_time_secs);
dtostrfd(d_buf, 2, str_buf);
ResponseAppend_P(PSTR("\"PidPower\":%s"), str_buf);
ResponseAppend_P(PSTR("}"));
}
static void run_pid()
{
double power = pid.tick(pid_current_time_secs);
void PIDRun(void) {
double power = Pid.pid.tick(Pid.current_time_secs);
#ifdef PID_BACKWARD_COMPATIBLE
// This part is left inside to regularly publish the PID Power via
// `%topic%/PID {"power":"0.000"}`
@ -372,14 +401,14 @@ static void run_pid()
#endif // PID_BACKWARD_COMPATIBLE
#if defined PID_SHUTTER
// send output as a position from 0-100 to defined shutter
int pos = power * 100;
ShutterSetPosition(PID_SHUTTER, pos);
// send output as a position from 0-100 to defined shutter
int pos = power * 100;
ShutterSetPosition(PID_SHUTTER, pos);
#endif //PID_SHUTTER
#if defined PID_USE_TIMPROP
// send power to appropriate timeprop output
Timeprop_Set_Power( PID_USE_TIMPROP-1, power );
// send power to appropriate timeprop output
TimepropSetPower( PID_USE_TIMPROP-1, power );
#endif // PID_USE_TIMPROP
}
@ -389,29 +418,28 @@ static void run_pid()
#define XDRV_49 49
bool Xdrv49(byte function)
{
bool Xdrv49(byte function) {
bool result = false;
switch (function) {
case FUNC_INIT:
PID_Init();
break;
case FUNC_EVERY_SECOND:
PID_Every_Second();
break;
case FUNC_SHOW_SENSOR:
// only use this if the pid loop is to use the local sensor for pv
#if defined PID_USE_LOCAL_SENSOR
PID_Show_Sensor();
#endif // PID_USE_LOCAL_SENSOR
break;
case FUNC_COMMAND:
result = DecodeCommand(kPIDCommands, PIDCommand);
break;
case FUNC_JSON_APPEND:
PIDShowValues();
break;
case FUNC_INIT:
PIDInit();
break;
case FUNC_EVERY_SECOND:
PIDEverySecond();
break;
case FUNC_SHOW_SENSOR:
// only use this if the pid loop is to use the local sensor for pv
#if defined PID_USE_LOCAL_SENSOR
PIDShowSensor();
#endif // PID_USE_LOCAL_SENSOR
break;
case FUNC_COMMAND:
result = DecodeCommand(kPIDCommands, PIDCommand);
break;
case FUNC_JSON_APPEND:
PIDShowValues();
break;
}
return result;
}