diff --git a/CHANGELOG.md b/CHANGELOG.md index e0ed29912..83a0ff3cd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/RELEASENOTES.md b/RELEASENOTES.md index 51bf7b199..17f7a24b1 100644 --- a/RELEASENOTES.md +++ b/RELEASENOTES.md @@ -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) diff --git a/tasmota/my_user_config.h b/tasmota/my_user_config.h index 579e65dbb..44415794f 100644 --- a/tasmota/my_user_config.h +++ b/tasmota/my_user_config.h @@ -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 diff --git a/tasmota/support_features.ino b/tasmota/support_features.ino index db5cc9b17..6000b4b09 100644 --- a/tasmota/support_features.ino +++ b/tasmota/support_features.ino @@ -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; diff --git a/tasmota/tasmota_globals.h b/tasmota/tasmota_globals.h index 76675b55d..ea3785b44 100644 --- a/tasmota/tasmota_globals.h +++ b/tasmota/tasmota_globals.h @@ -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 diff --git a/tasmota/xdrv_48_timeprop.ino b/tasmota/xdrv_48_timeprop.ino index 6e8537dbb..bddf2653f 100644 --- a/tasmota/xdrv_48_timeprop.ino +++ b/tasmota/xdrv_48_timeprop.ino @@ -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 . */ -/** +#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. */ -/** - * 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; }