diff --git a/CHANGELOG_LATEST.md b/CHANGELOG_LATEST.md index cd631b09c..3c54ca5f9 100644 --- a/CHANGELOG_LATEST.md +++ b/CHANGELOG_LATEST.md @@ -1,10 +1,14 @@ # Changelog ## Added + - Mock API to simulate an ESP, for testing web +- Able to write values from the Web UI + ## Fixed ## Changed + - Icon for Network - MQTT Formatting payload (nested vs single) is a pull-down option - moved mqtt-topics and texts to local_EN, all topics lower case diff --git a/interface/src/project/EMSESPDevicesForm.tsx b/interface/src/project/EMSESPDevicesForm.tsx index 7d3588927..2556d2e39 100644 --- a/interface/src/project/EMSESPDevicesForm.tsx +++ b/interface/src/project/EMSESPDevicesForm.tsx @@ -12,13 +12,17 @@ import IconButton from '@material-ui/core/IconButton'; import EditIcon from '@material-ui/icons/Edit'; import { redirectingAuthorizedFetch, withAuthenticatedContext, AuthenticatedContextProps } from "../authentication"; -import { RestFormProps, FormButton } from "../components"; +import { RestFormProps, FormButton, extractEventValue } from "../components"; -import { EMSESPDevices, EMSESPDeviceData, Device } from "./EMSESPtypes"; +import { EMSESPDevices, EMSESPDeviceData, Device, DeviceValue } from "./EMSESPtypes"; + +import ValueForm from './ValueForm'; import { ENDPOINT_ROOT } from "../api"; + export const SCANDEVICES_ENDPOINT = ENDPOINT_ROOT + "scanDevices"; export const DEVICE_DATA_ENDPOINT = ENDPOINT_ROOT + "deviceData"; +export const WRITE_VALUE_ENDPOINT = ENDPOINT_ROOT + "writeValue"; const StyledTableCell = withStyles((theme: Theme) => createStyles({ @@ -47,6 +51,7 @@ interface EMSESPDevicesFormState { processing: boolean; deviceData?: EMSESPDeviceData; selectedDevice?: number; + devicevalue?: DeviceValue; } type EMSESPDevicesFormProps = RestFormProps & AuthenticatedContextProps & WithWidthProps; @@ -71,15 +76,61 @@ class EMSESPDevicesForm extends Component { - const name = this.state.deviceData?.data[i+2]; - const value = this.state.deviceData?.data[i]; - const deviceType = this.state.selectedDevice; - console.log("type: " + deviceType + " name: " + name + " value: " + value); + handleValueChange = (name: keyof DeviceValue) => (event: React.ChangeEvent) => { + this.setState({ devicevalue: { ...this.state.devicevalue!, [name]: extractEventValue(event) } }); + }; - // this.setState({ - // user: undefined - // }); + cancelEditingValue = () => { + this.setState({ + devicevalue: undefined + }); + } + + doneEditingValue = () => { + const { devicevalue } = this.state; + + redirectingAuthorizedFetch(WRITE_VALUE_ENDPOINT, { + method: "POST", + body: JSON.stringify({ devicevalue: devicevalue }), + headers: { + "Content-Type": "application/json", + }, + }) + .then((response) => { + if (response.status === 200) { + this.props.enqueueSnackbar("Write command sent", { variant: "success" }); + return; + } + if (response.status === 204) { + this.props.enqueueSnackbar("Write command failed", { variant: "error" }); + return; + } + throw Error("Unexpected response code: " + response.status); + }) + .catch((error) => { + this.props.enqueueSnackbar( + error.message || "Problem writing value", { variant: "error" } + ); + }); + + if (devicevalue) { + this.setState({ + devicevalue: undefined + }); + } + + }; + + sendCommand = (i: any) => { + this.setState({ + devicevalue: { + id: this.state.selectedDevice!, + data: this.state.deviceData?.data[i]!, + uom: this.state.deviceData?.data[i + 1]!, + name: this.state.deviceData?.data[i + 2]!, + cmd: this.state.deviceData?.data[i + 3]!, + } + }); } noDevices = () => { @@ -109,19 +160,13 @@ class EMSESPDevicesForm extends Component {data.devices.sort(compareDevices).map((device) => ( - this.handleRowClick(device)} - > + this.handleRowClick(device)}> - @@ -201,21 +246,11 @@ class EMSESPDevicesForm extends Component - @@ -309,16 +344,18 @@ class EMSESPDevicesForm extends Component {deviceData.data.map((item, i) => { - if (i % 3) { + if (i % 4) { return null; } else { return ( - this.sendCommand(i)}> - - + {deviceData.data[i + 3] && ( + this.sendCommand(i)}> + + + )} {deviceData.data[i + 2]} {deviceData.data[i]}{formatUnit(deviceData.data[i + 1])} @@ -342,6 +379,7 @@ class EMSESPDevicesForm extends Component

@@ -351,27 +389,26 @@ class EMSESPDevicesForm extends Component
- } - variant="contained" - color="secondary" - onClick={this.props.loadData} - > + } variant="contained" color="secondary" onClick={this.props.loadData} > Refresh - } - variant="contained" - color="primary" - onClick={this.onScanDevices} - > + } variant="contained" onClick={this.onScanDevices} > Scan Devices {this.renderScanDevicesDialog()} + { + devicevalue && + + } ); } diff --git a/interface/src/project/EMSESPtypes.ts b/interface/src/project/EMSESPtypes.ts index a2a8f0ce7..ef0a47567 100644 --- a/interface/src/project/EMSESPtypes.ts +++ b/interface/src/project/EMSESPtypes.ts @@ -62,3 +62,11 @@ export interface EMSESPDeviceData { name: string; data: string[]; } + +export interface DeviceValue { + id: number; + data: string, + uom: string, + name: string, + cmd: string +} diff --git a/interface/src/project/ValueForm.tsx b/interface/src/project/ValueForm.tsx new file mode 100644 index 000000000..280c9b86a --- /dev/null +++ b/interface/src/project/ValueForm.tsx @@ -0,0 +1,64 @@ +import React, { RefObject } from 'react'; +import { TextValidator, ValidatorForm } from 'react-material-ui-form-validator'; +import { Dialog, DialogTitle, DialogContent, DialogActions, Box, Typography } from '@material-ui/core'; +import { FormButton } from '../components'; +import { DeviceValue } from './EMSESPtypes'; + +interface ValueFormProps { + devicevalue: DeviceValue; + onDoneEditing: () => void; + onCancelEditing: () => void; + handleValueChange: (data: keyof DeviceValue) => (event: React.ChangeEvent) => void; +} + +class ValueForm extends React.Component { + + formRef: RefObject = React.createRef(); + + submit = () => { + this.formRef.current.submit(); + } + + buildLabel = (devicevalue: DeviceValue) => { + if ((devicevalue.uom === "") || (!devicevalue.uom)) { + return "New value"; + } + return "New value (" + devicevalue.uom + ")"; + } + + render() { + const { devicevalue, handleValueChange, onDoneEditing, onCancelEditing } = this.props; + return ( + + + Modify the {devicevalue.name} + + + + + Note: It may take a few seconds before the change is visible. If nothing happens check the logs. + + + + + + Cancel + Done + + + + ); + } +} + +export default ValueForm; diff --git a/mock-api/server.js b/mock-api/server.js index f47bf3810..88650f963 100644 --- a/mock-api/server.js +++ b/mock-api/server.js @@ -110,6 +110,7 @@ const EMSESP_SCANDEVICES_ENDPOINT = ENDPOINT_ROOT + "scanDevices"; const EMSESP_DEVICEDATA_ENDPOINT = ENDPOINT_ROOT + "deviceData"; const EMSESP_STATUS_ENDPOINT = ENDPOINT_ROOT + "emsespStatus"; const EMSESP_BOARDPROFILE_ENDPOINT = ENDPOINT_ROOT + "boardProfile"; +const WRITE_VALUE_ENDPOINT = ENDPOINT_ROOT + "writeValue"; const emsesp_settings = { "tx_mode": 1, "tx_delay": 0, "ems_bus_id": 11, "syslog_enabled": false, "syslog_level": 3, "trace_raw": false, "syslog_mark_interval": 0, "syslog_host": "192.168.1.4", "syslog_port": 514, @@ -134,33 +135,78 @@ const emsesp_status = { "status": 0, "rx_received": 344, "tx_sent": 104, "rx_quality": 100, "tx_quality": 100 }; const emsesp_devicedata_1 = { - "name": "Thermostat: RC20/Moduline 300", "data": ["16:28:21 01/04/2021", "", "date/time", - "(0)", "", "error code", 15, "°C", "(hc1) setpoint room temperature", 20.5, "°C", - "(hc1) current room temperature", "auto", "", "(hc1) mode"] + "name": "Thermostat: RC20/Moduline 300", + "data": [ + "16:28:21 01/04/2021", "", "date/time", "", + "(0)", "", "error code", "", + 15, "°C", "(hc1) setpoint room temperature", "", + 20.5, "°C", "(hc1) current room temperature", "", + "auto", "", "(hc1) mode", "" + ] }; const emsesp_devicedata_2 = { - "name": "Boiler: Nefit GBx72/Trendline/Cerapur/Greenstar Si/27i", "data": ["off", "", "heating active", "off", "", - "warm water active", 5, "°C", "selected flow temperature", 0, "%", "burner selected max power", 0, "%", - "heating pump modulation", 42.7, "°C", "current flow temperature", 39, "°C", "return temperature", 1.2, - "bar", "system pressure", 45.3, "°C", "max boiler temperature", "off", "", "gas", 0, "uA", "flame current", - "off", "", "heating pump", "off", "", "fan", "off", "", "ignition", "on", "", "heating activated", 75, "°C", - "heating temperature", 90, "%", "burner pump max power", 55, "%", "burner pump min power", 1, null, "pump delay", - 10, null, "burner min period", 0, "%", "burner min power", 75, "%", "burner max power", -6, "°C", "hysteresis on temperature", 6, - "°C", "hysteresis off temperature", 0, "%", "burner current power", 295740, "", "burner # starts", "344 days 2 hours 8 minutes", - null, "total burner operating time", "279 days 11 hours 55 minutes", null, "total heat operating time", - "2946 days 19 hours 8 minutes", null, "total UBA operating time", "1C(210) 06.06.2020 12:07", "", - "last error code", "0H", "", "service code", 203, "", "service code number", "01.01.2012", "", - "maintenance set date", "off", "", "maintenance scheduled", 6000, "hours", "maintenance set time", 60, "°C", - "(warm water) selected temperature", 62, "°C", "(warm water) set temperature", "flow", "", "(warm water) type", "hot", - "", "(warm water) comfort", 40, "", "(warm water) flow temperature offset", 100, "%", "(warm water) max power", "off", - "", "(warm water) circulation pump available", "3-way valve", "", "(warm water) charging type", 70, "°C", - "(warm water) disinfection temperature", "off", "", "(warm water) circulation pump freq", "off", "", - "(warm water) circulation active", 34.7, "°C", "(warm water) current intern temperature", 0, "l/min", - "(warm water) current tap water flow", 34.6, "°C", "(warm water) storage intern temperature", "on", "", - "(warm water) activated", "off", "", "(warm water) one time charging", "off", "", - "(warm water) disinfecting", "off", "", "(warm water) charging", "off", "", "(warm water) recharging", "on", "", - "(warm water) temperature ok", "off", "", "(warm water) active", "on", "", "(warm water) heating", 262387, "", - "(warm water) # starts", "64 days 14 hours 13 minutes", null, "(warm water) active time"] + "name": "Boiler: Nefit GBx72/Trendline/Cerapur/Greenstar Si/27i", + "data": [ + "off", "", "heating active", "", + "off", "", "warm water active", "", + 5, "°C", "selected flow temperature", "selflowtemp", + 0, "%", "burner selected max power", "", + 0, "%", "heating pump modulation", "", + 42.7, "°C", "current flow temperature", "", + 39, "°C", "return temperature", "", + 1.2, "bar", "system pressure", "", + 45.3, "°C", "max boiler temperature", "", + "off", "", "gas", "", + 0, "uA", "flame current", "", + "off", "", "heating pump", "", + "off", "", "fan", "", + "off", "", "ignition", "", + "on", "", "heating activated", "", + 75, "°C", "heating temperature", "", + 90, "%", "burner pump max power", "", + 55, "%", "burner pump min power", "", + 1, null, "pump delay", "", + 10, null, "burner min period", "", + 0, "%", "burner min power", "", + 75, "%", "burner max power", "", + -6, "°C", "hysteresis on temperature", "", + 6, "°C", "hysteresis off temperature", "", + 0, "%", "burner current power", "", + 295740, "", "burner # starts", "", + "344 days 2 hours 8 minutes", null, "total burner operating time", "", + "279 days 11 hours 55 minutes", null, "total heat operating time", "", + "2946 days 19 hours 8 minutes", null, "total UBA operating time", "", + "1C(210) 06.06.2020 12:07", "", "last error code", "", + "0H", "", "service code", "", + 203, "", "service code number", "", + "01.01.2012", "", "maintenance set date", "", + "off", "", "maintenance scheduled", "", + 6000, "hours", "maintenance set time", "", + 60, "°C", "(warm water) selected temperature", "", + 62, "°C", "(warm water) set temperature", "", + "flow", "", "(warm water) type", "", + "hot", "", "(warm water) comfort", "", + 40, "", "(warm water) flow temperature offset", "", + 100, "%", "(warm water) max power", "", + "off", "", "(warm water) circulation pump available", "", + "3-way valve", "", "(warm water) charging type", "", + 70, "°C", "(warm water) disinfection temperature", "", + "off", "", "(warm water) circulation pump freq", "", + "off", "", "(warm water) circulation active", "", + 34.7, "°C", "(warm water) current intern temperature", "", + 0, "l/min", "(warm water) current tap water flow", "", + 34.6, "°C", "(warm water) storage intern temperature", "", + "on", "", "(warm water) activated", "", + "off", "", "(warm water) one time charging", "", + "off", "", "(warm water) disinfecting", "", + "off", "", "(warm water) charging", "", + "off", "", "(warm water) recharging", "", + "on", "", "(warm water) temperature ok", "", + "off", "", "(warm water) active", "", + "on", "", "(warm water) heating", "", + 262387, "", "(warm water) # starts", "", + "64 days 14 hours 13 minutes", null, "(warm water) active time", "" + ] }; @@ -206,6 +252,7 @@ app.post(SIGN_IN_ENDPOINT, (req, res) => { res.json(signin); }); app.get(EMSESP_SETTINGS_ENDPOINT, (req, res) => { res.json(emsesp_settings); }); app.post(EMSESP_SETTINGS_ENDPOINT, (req, res) => { res.json(emsesp_settings); }); app.get(EMSESP_ALLDEVICES_ENDPOINT, (req, res) => { res.json(emsesp_alldevices); }); +app.post(EMSESP_SCANDEVICES_ENDPOINT, (req, res) => { res.sendStatus(200); }); app.get(EMSESP_STATUS_ENDPOINT, (req, res) => { res.json(emsesp_status); }); app.post(EMSESP_DEVICEDATA_ENDPOINT, (req, res) => { const id = req.body.id; @@ -216,6 +263,15 @@ app.post(EMSESP_DEVICEDATA_ENDPOINT, (req, res) => { res.json(emsesp_devicedata_2); } }); + +app.post(WRITE_VALUE_ENDPOINT, (req, res) => { + const devicevalue = req.body.devicevalue; + + console.log(devicevalue); + + res.json(200); +}); + app.post(EMSESP_BOARDPROFILE_ENDPOINT, (req, res) => { const board_profile = req.body.code; diff --git a/src/WebDevicesService.cpp b/src/WebDevicesService.cpp index 25e4c9dcd..0f389c656 100644 --- a/src/WebDevicesService.cpp +++ b/src/WebDevicesService.cpp @@ -23,14 +23,18 @@ namespace emsesp { using namespace std::placeholders; // for `_1` etc WebDevicesService::WebDevicesService(AsyncWebServer * server, SecurityManager * securityManager) - : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) { + : _device_dataHandler(DEVICE_DATA_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::device_data, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) + , _writevalue_dataHandler(WRITE_VALUE_SERVICE_PATH, securityManager->wrapCallback(std::bind(&WebDevicesService::write_value, this, _1, _2), AuthenticationPredicates::IS_AUTHENTICATED)) { server->on(EMSESP_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::all_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); - server->on(SCAN_DEVICES_SERVICE_PATH, HTTP_GET, securityManager->wrapRequest(std::bind(&WebDevicesService::scan_devices, this, _1), AuthenticationPredicates::IS_AUTHENTICATED)); _device_dataHandler.setMethod(HTTP_POST); _device_dataHandler.setMaxContentLength(256); server->addHandler(&_device_dataHandler); + + _writevalue_dataHandler.setMethod(HTTP_POST); + _writevalue_dataHandler.setMaxContentLength(256); + server->addHandler(&_writevalue_dataHandler); } void WebDevicesService::scan_devices(AsyncWebServerRequest * request) { @@ -96,4 +100,42 @@ void WebDevicesService::device_data(AsyncWebServerRequest * request, JsonVariant request->send(response); } +void WebDevicesService::write_value(AsyncWebServerRequest * request, JsonVariant & json) { + if (json.is()) { + JsonObject dv = json["devicevalue"]; + + // using the unique ID from the web find the real device type + for (const auto & emsdevice : EMSESP::emsdevices) { + if (emsdevice) { + if (emsdevice->unique_id() == dv["id"].as()) { + const char * cmd = dv["cmd"]; + uint8_t device_type = emsdevice->device_type(); + bool ok = false; + char s[10]; + // the data could be in any format, but we need string + JsonVariant data = dv["data"]; + if (data.is()) { + ok = Command::call(device_type, cmd, data.as()); + } else if (data.is()) { + ok = Command::call(device_type, cmd, Helpers::render_value(s, data.as(), 0)); + } else if (data.is()) { + ok = Command::call(device_type, cmd, Helpers::render_value(s, (float)data.as(), 1)); + } else if (data.is()) { + ok = Command::call(device_type, cmd, data.as() ? "true" : "false"); + } + + if (ok) { + AsyncWebServerResponse * response = request->beginResponse(200); // OK + request->send(response); + } + return; // found device, quit + } + } + } + + AsyncWebServerResponse * response = request->beginResponse(204); // no content error + request->send(response); + } +} + } // namespace emsesp \ No newline at end of file diff --git a/src/WebDevicesService.h b/src/WebDevicesService.h index 8051f35e1..010a09bdc 100644 --- a/src/WebDevicesService.h +++ b/src/WebDevicesService.h @@ -27,6 +27,8 @@ #define EMSESP_DEVICES_SERVICE_PATH "/rest/allDevices" #define SCAN_DEVICES_SERVICE_PATH "/rest/scanDevices" #define DEVICE_DATA_SERVICE_PATH "/rest/deviceData" +#define WRITE_VALUE_SERVICE_PATH "/rest/writeValue" + namespace emsesp { @@ -35,11 +37,15 @@ class WebDevicesService { WebDevicesService(AsyncWebServer * server, SecurityManager * securityManager); private: + // GET void all_devices(AsyncWebServerRequest * request); void scan_devices(AsyncWebServerRequest * request); - void device_data(AsyncWebServerRequest * request, JsonVariant & json); - AsyncCallbackJsonWebHandler _device_dataHandler; + // POST + void device_data(AsyncWebServerRequest * request, JsonVariant & json); + void write_value(AsyncWebServerRequest * request, JsonVariant & json); + + AsyncCallbackJsonWebHandler _device_dataHandler, _writevalue_dataHandler; }; } // namespace emsesp diff --git a/src/command.cpp b/src/command.cpp index c7064a3e6..6f3483cce 100644 --- a/src/command.cpp +++ b/src/command.cpp @@ -30,14 +30,15 @@ std::vector Command::cmdfunctions_; // id may be used to represent a heating circuit for example, it's optional // returns false if error or not found bool Command::call(const uint8_t device_type, const char * cmd, const char * value, const int8_t id) { + std::string dname = EMSdevice::device_type_2_device_name(device_type); + auto cf = find_command(device_type, cmd); if ((cf == nullptr) || (cf->cmdfunction_json_)) { - LOG_WARNING(F("Command %s not found"), cmd); + LOG_WARNING(F("Command %s on %s not found"), cmd, dname.c_str()); return false; // command not found, or requires a json } #ifdef EMSESP_DEBUG - std::string dname = EMSdevice::device_type_2_device_name(device_type); if (value == nullptr) { LOG_DEBUG(F("[DEBUG] Calling %s command %s"), dname.c_str(), cmd); } else if (id == -1) { @@ -110,6 +111,7 @@ void Command::add_with_json(const uint8_t device_type, const __FlashStringHelper } // see if a command exists for that device type +// is not case sensitive Command::CmdFunction * Command::find_command(const uint8_t device_type, const char * cmd) { if ((cmd == nullptr) || (strlen(cmd) == 0) || (cmdfunctions_.empty())) { return nullptr; diff --git a/src/command.h b/src/command.h index ab108acb1..50d36cdc6 100644 --- a/src/command.h +++ b/src/command.h @@ -41,7 +41,7 @@ class Command { public: struct CmdFunction { uint8_t device_type_; // DeviceType:: - uint8_t flag_; + uint8_t flag_; // mqtt flags for command subscriptions const __FlashStringHelper * cmd_; cmdfunction_p cmdfunction_; cmdfunction_json_p cmdfunction_json_; diff --git a/src/devices/boiler.cpp b/src/devices/boiler.cpp index 60a72dedd..6eb7668b8 100644 --- a/src/devices/boiler.cpp +++ b/src/devices/boiler.cpp @@ -100,12 +100,12 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const reserve_device_values(50); // main - boiler_data topic - register_device_value(TAG_BOILER_DATA, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console + register_device_value(TAG_BOILER_DATA, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console id_ = product_id; - register_device_value(TAG_BOILER_DATA, &heatingActive_, DeviceValueType::BOOL, nullptr, FL_(heatingActive)); - register_device_value(TAG_BOILER_DATA, &tapwaterActive_, DeviceValueType::BOOL, nullptr, FL_(tapwaterActive)); - register_device_value(TAG_BOILER_DATA, &selFlowTemp_, DeviceValueType::UINT, nullptr, FL_(selFlowTemp), DeviceValueUOM::DEGREES); + register_device_value(TAG_BOILER_DATA, &heatingActive_, DeviceValueType::BOOL, nullptr, FL_(heatingActive), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &tapwaterActive_, DeviceValueType::BOOL, nullptr, FL_(tapwaterActive), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &selFlowTemp_, DeviceValueType::UINT, nullptr, FL_(selFlowTemp), DeviceValueUOM::DEGREES, true); register_device_value(TAG_BOILER_DATA, &selBurnPow_, DeviceValueType::UINT, nullptr, FL_(selBurnPow), DeviceValueUOM::PERCENT); register_device_value(TAG_BOILER_DATA, &heatingPumpMod_, DeviceValueType::UINT, nullptr, FL_(heatingPumpMod), DeviceValueUOM::PERCENT); register_device_value(TAG_BOILER_DATA, &heatingPump2Mod_, DeviceValueType::UINT, nullptr, FL_(heatingPump2Mod), DeviceValueUOM::PERCENT); @@ -116,85 +116,85 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const register_device_value(TAG_BOILER_DATA, &sysPress_, DeviceValueType::UINT, FL_(div10), FL_(sysPress), DeviceValueUOM::BAR); register_device_value(TAG_BOILER_DATA, &boilTemp_, DeviceValueType::USHORT, FL_(div10), FL_(boilTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA, &exhaustTemp_, DeviceValueType::USHORT, FL_(div10), FL_(exhaustTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA, &burnGas_, DeviceValueType::BOOL, nullptr, FL_(burnGas)); + register_device_value(TAG_BOILER_DATA, &burnGas_, DeviceValueType::BOOL, nullptr, FL_(burnGas), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &flameCurr_, DeviceValueType::USHORT, FL_(div10), FL_(flameCurr), DeviceValueUOM::UA); register_device_value(TAG_BOILER_DATA, &heatingPump_, DeviceValueType::BOOL, nullptr, FL_(heatingPump), DeviceValueUOM::PUMP); - register_device_value(TAG_BOILER_DATA, &fanWork_, DeviceValueType::BOOL, nullptr, FL_(fanWork)); - register_device_value(TAG_BOILER_DATA, &ignWork_, DeviceValueType::BOOL, nullptr, FL_(ignWork)); - register_device_value(TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated)); - register_device_value(TAG_BOILER_DATA, &heatingTemp_, DeviceValueType::UINT, nullptr, FL_(heatingTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA, &pumpModMax_, DeviceValueType::UINT, nullptr, FL_(pumpModMax), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &pumpModMin_, DeviceValueType::UINT, nullptr, FL_(pumpModMin), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &pumpDelay_, DeviceValueType::UINT, nullptr, FL_(pumpDelay), DeviceValueUOM::MINUTES); + register_device_value(TAG_BOILER_DATA, &fanWork_, DeviceValueType::BOOL, nullptr, FL_(fanWork), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &ignWork_, DeviceValueType::BOOL, nullptr, FL_(ignWork), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &heatingActivated_, DeviceValueType::BOOL, nullptr, FL_(heatingActivated), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA, &heatingTemp_, DeviceValueType::UINT, nullptr, FL_(heatingTemp), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_BOILER_DATA, &pumpModMax_, DeviceValueType::UINT, nullptr, FL_(pumpModMax), DeviceValueUOM::PERCENT, true); + register_device_value(TAG_BOILER_DATA, &pumpModMin_, DeviceValueType::UINT, nullptr, FL_(pumpModMin), DeviceValueUOM::PERCENT, true); + register_device_value(TAG_BOILER_DATA, &pumpDelay_, DeviceValueType::UINT, nullptr, FL_(pumpDelay), DeviceValueUOM::MINUTES, true); register_device_value(TAG_BOILER_DATA, &burnMinPeriod_, DeviceValueType::UINT, nullptr, FL_(burnMinPeriod), DeviceValueUOM::MINUTES); - register_device_value(TAG_BOILER_DATA, &burnMinPower_, DeviceValueType::UINT, nullptr, FL_(burnMinPower), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &burnMaxPower_, DeviceValueType::UINT, nullptr, FL_(burnMaxPower), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &boilHystOn_, DeviceValueType::INT, nullptr, FL_(boilHystOn), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA, &boilHystOff_, DeviceValueType::INT, nullptr, FL_(boilHystOff), DeviceValueUOM::DEGREES); + register_device_value(TAG_BOILER_DATA, &burnMinPower_, DeviceValueType::UINT, nullptr, FL_(burnMinPower), DeviceValueUOM::PERCENT, true); + register_device_value(TAG_BOILER_DATA, &burnMaxPower_, DeviceValueType::UINT, nullptr, FL_(burnMaxPower), DeviceValueUOM::PERCENT, true); + register_device_value(TAG_BOILER_DATA, &boilHystOn_, DeviceValueType::INT, nullptr, FL_(boilHystOn), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_BOILER_DATA, &boilHystOff_, DeviceValueType::INT, nullptr, FL_(boilHystOff), DeviceValueUOM::DEGREES, true); register_device_value(TAG_BOILER_DATA, &setFlowTemp_, DeviceValueType::UINT, nullptr, FL_(setFlowTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA, &setBurnPow_, DeviceValueType::UINT, nullptr, FL_(setBurnPow), DeviceValueUOM::PERCENT); register_device_value(TAG_BOILER_DATA, &curBurnPow_, DeviceValueType::UINT, nullptr, FL_(curBurnPow), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA, &burnStarts_, DeviceValueType::ULONG, nullptr, FL_(burnStarts)); + register_device_value(TAG_BOILER_DATA, &burnStarts_, DeviceValueType::ULONG, nullptr, FL_(burnStarts), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &burnWorkMin_, DeviceValueType::TIME, nullptr, FL_(burnWorkMin), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &heatWorkMin_, DeviceValueType::TIME, nullptr, FL_(heatWorkMin), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &UBAuptime_, DeviceValueType::TIME, nullptr, FL_(UBAuptime), DeviceValueUOM::MINUTES); - register_device_value(TAG_BOILER_DATA, &lastCode_, DeviceValueType::TEXT, nullptr, FL_(lastCode)); - register_device_value(TAG_BOILER_DATA, &serviceCode_, DeviceValueType::TEXT, nullptr, FL_(serviceCode)); - register_device_value(TAG_BOILER_DATA, &serviceCodeNumber_, DeviceValueType::USHORT, nullptr, FL_(serviceCodeNumber)); + register_device_value(TAG_BOILER_DATA, &lastCode_, DeviceValueType::TEXT, nullptr, FL_(lastCode), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &serviceCode_, DeviceValueType::TEXT, nullptr, FL_(serviceCode), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &serviceCodeNumber_, DeviceValueType::USHORT, nullptr, FL_(serviceCodeNumber), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &upTimeControl_, DeviceValueType::TIME, FL_(div60), FL_(upTimeControl), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &upTimeCompHeating_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompHeating), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &upTimeCompCooling_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompCooling), DeviceValueUOM::MINUTES); register_device_value(TAG_BOILER_DATA, &upTimeCompWw_, DeviceValueType::TIME, FL_(div60), FL_(upTimeCompWw), DeviceValueUOM::MINUTES); - register_device_value(TAG_BOILER_DATA, &heatingStarts_, DeviceValueType::ULONG, nullptr, FL_(heatingStarts)); - register_device_value(TAG_BOILER_DATA, &coolingStarts_, DeviceValueType::ULONG, nullptr, FL_(coolingStarts)); - register_device_value(TAG_BOILER_DATA, &nrgConsTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsTotal)); - register_device_value(TAG_BOILER_DATA, &nrgConsCompTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompTotal)); - register_device_value(TAG_BOILER_DATA, &nrgConsCompHeating_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompHeating)); - register_device_value(TAG_BOILER_DATA, &nrgConsCompWw_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompWw)); - register_device_value(TAG_BOILER_DATA, &nrgConsCompCooling_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompCooling)); - register_device_value(TAG_BOILER_DATA, &nrgSuppTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppTotal)); - register_device_value(TAG_BOILER_DATA, &nrgSuppHeating_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppHeating)); - register_device_value(TAG_BOILER_DATA, &nrgSuppWw_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppWw)); - register_device_value(TAG_BOILER_DATA, &nrgSuppCooling_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppCooling)); - register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsTotal_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsTotal)); - register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsHeating_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsHeating)); - register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsDHW_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsDHW)); - register_device_value(TAG_BOILER_DATA, &maintenanceMessage_, DeviceValueType::TEXT, nullptr, FL_(maintenanceMessage)); - register_device_value(TAG_BOILER_DATA, &maintenanceDate_, DeviceValueType::TEXT, nullptr, FL_(maintenanceDate)); - register_device_value(TAG_BOILER_DATA, &maintenanceType_, DeviceValueType::ENUM, FL_(enum_off_time_date), FL_(maintenanceType)); + register_device_value(TAG_BOILER_DATA, &heatingStarts_, DeviceValueType::ULONG, nullptr, FL_(heatingStarts), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &coolingStarts_, DeviceValueType::ULONG, nullptr, FL_(coolingStarts), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgConsTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsTotal), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgConsCompTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompTotal), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgConsCompHeating_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompHeating), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgConsCompWw_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompWw), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgConsCompCooling_, DeviceValueType::ULONG, nullptr, FL_(nrgConsCompCooling), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgSuppTotal_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppTotal), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgSuppHeating_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppHeating), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgSuppWw_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppWw), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &nrgSuppCooling_, DeviceValueType::ULONG, nullptr, FL_(nrgSuppCooling), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsTotal_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsTotal), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsHeating_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsHeating), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &auxElecHeatNrgConsDHW_, DeviceValueType::ULONG, nullptr, FL_(auxElecHeatNrgConsDHW), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &maintenanceMessage_, DeviceValueType::TEXT, nullptr, FL_(maintenanceMessage), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &maintenanceDate_, DeviceValueType::TEXT, nullptr, FL_(maintenanceDate), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA, &maintenanceType_, DeviceValueType::ENUM, FL_(enum_off_time_date), FL_(maintenanceType), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA, &maintenanceTime_, DeviceValueType::USHORT, nullptr, FL_(maintenanceTime), DeviceValueUOM::HOURS); // warm water - boiler_data_ww topic register_device_value(TAG_BOILER_DATA_WW, &wWSelTemp_, DeviceValueType::UINT, nullptr, FL_(wWSelTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA_WW, &wWSetTemp_, DeviceValueType::UINT, nullptr, FL_(wWSetTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA_WW, &wWType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wWType)); - register_device_value(TAG_BOILER_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort)); - register_device_value(TAG_BOILER_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset)); - register_device_value(TAG_BOILER_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT); - register_device_value(TAG_BOILER_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump)); - register_device_value(TAG_BOILER_DATA_WW, &wWChargeType_, DeviceValueType::BOOL, FL_(enum_charge), FL_(wWChargeType)); + register_device_value(TAG_BOILER_DATA_WW, &wWSetTemp_, DeviceValueType::UINT, nullptr, FL_(wWSetTemp), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_BOILER_DATA_WW, &wWType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wWType), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wWComfort), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWFlowTempOffset_, DeviceValueType::UINT, nullptr, FL_(wWFlowTempOffset), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWMaxPower_, DeviceValueType::UINT, nullptr, FL_(wWMaxPower), DeviceValueUOM::PERCENT, true); + register_device_value(TAG_BOILER_DATA_WW, &wWCircPump_, DeviceValueType::BOOL, nullptr, FL_(wWCircPump), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWChargeType_, DeviceValueType::BOOL, FL_(enum_charge), FL_(wWChargeType), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA_WW, &wWDisinfectionTemp_, DeviceValueType::UINT, nullptr, FL_(wWDisinfectionTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA_WW, &wWCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wWCircMode)); - register_device_value(TAG_BOILER_DATA_WW, &wWCirc_, DeviceValueType::BOOL, nullptr, FL_(wWCirc)); + register_device_value(TAG_BOILER_DATA_WW, &wWCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wWCircMode), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWCirc_, DeviceValueType::BOOL, nullptr, FL_(wWCirc), DeviceValueUOM::NONE, true); register_device_value(TAG_BOILER_DATA_WW, &wWCurTemp_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA_WW, &wWCurTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWCurTemp2), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA_WW, &wWCurFlow_, DeviceValueType::UINT, FL_(div10), FL_(wWCurFlow), DeviceValueUOM::LMIN); register_device_value(TAG_BOILER_DATA_WW, &wWStorageTemp1_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp1), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA_WW, &wWStorageTemp2_, DeviceValueType::USHORT, FL_(div10), FL_(wWStorageTemp2), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated)); - register_device_value(TAG_BOILER_DATA_WW, &wWOneTime_, DeviceValueType::BOOL, nullptr, FL_(wWOneTime)); - register_device_value(TAG_BOILER_DATA_WW, &wWDisinfecting_, DeviceValueType::BOOL, nullptr, FL_(wWDisinfecting)); - register_device_value(TAG_BOILER_DATA_WW, &wWCharging_, DeviceValueType::BOOL, nullptr, FL_(wWCharging)); - register_device_value(TAG_BOILER_DATA_WW, &wWRecharging_, DeviceValueType::BOOL, nullptr, FL_(wWRecharging)); - register_device_value(TAG_BOILER_DATA_WW, &wWTempOK_, DeviceValueType::BOOL, nullptr, FL_(wWTempOK)); - register_device_value(TAG_BOILER_DATA_WW, &wWActive_, DeviceValueType::BOOL, nullptr, FL_(wWActive)); - register_device_value(TAG_BOILER_DATA_WW, &wWHeat_, DeviceValueType::BOOL, nullptr, FL_(wWHeat)); + register_device_value(TAG_BOILER_DATA_WW, &wWActivated_, DeviceValueType::BOOL, nullptr, FL_(wWActivated), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWOneTime_, DeviceValueType::BOOL, nullptr, FL_(wWOneTime), DeviceValueUOM::NONE, true); + register_device_value(TAG_BOILER_DATA_WW, &wWDisinfecting_, DeviceValueType::BOOL, nullptr, FL_(wWDisinfecting), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWCharging_, DeviceValueType::BOOL, nullptr, FL_(wWCharging), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWRecharging_, DeviceValueType::BOOL, nullptr, FL_(wWRecharging), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWTempOK_, DeviceValueType::BOOL, nullptr, FL_(wWTempOK), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWActive_, DeviceValueType::BOOL, nullptr, FL_(wWActive), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWHeat_, DeviceValueType::BOOL, nullptr, FL_(wWHeat), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA_WW, &wWSetPumpPower_, DeviceValueType::UINT, nullptr, FL_(wWSetPumpPower), DeviceValueUOM::PERCENT); register_device_value(TAG_BOILER_DATA_WW, &mixerTemp_, DeviceValueType::USHORT, FL_(div10), FL_(mixerTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_BOILER_DATA_WW, &tankMiddleTemp_, DeviceValueType::USHORT, FL_(div10), FL_(tankMiddleTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_BOILER_DATA_WW, &wWStarts_, DeviceValueType::ULONG, nullptr, FL_(wWStarts)); - register_device_value(TAG_BOILER_DATA_WW, &wWStarts2_, DeviceValueType::ULONG, nullptr, FL_(wWStarts2)); + register_device_value(TAG_BOILER_DATA_WW, &wWStarts_, DeviceValueType::ULONG, nullptr, FL_(wWStarts), DeviceValueUOM::NONE); + register_device_value(TAG_BOILER_DATA_WW, &wWStarts2_, DeviceValueType::ULONG, nullptr, FL_(wWStarts2), DeviceValueUOM::NONE); register_device_value(TAG_BOILER_DATA_WW, &wWWorkM_, DeviceValueType::TIME, nullptr, FL_(wWWorkM), DeviceValueUOM::MINUTES); // fetch some initial data diff --git a/src/devices/heatpump.cpp b/src/devices/heatpump.cpp index d22a430b2..d1bc4f7c1 100644 --- a/src/devices/heatpump.cpp +++ b/src/devices/heatpump.cpp @@ -33,7 +33,7 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c register_telegram_type(0x047B, F("HP2"), true, MAKE_PF_CB(process_HPMonitor2)); // device values - register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console + register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console register_device_value(TAG_NONE, &airHumidity_, DeviceValueType::UINT, FL_(div2), FL_(airHumidity), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &dewTemperature_, DeviceValueType::UINT, nullptr, FL_(dewTemperature), DeviceValueUOM::DEGREES); diff --git a/src/devices/mixer.cpp b/src/devices/mixer.cpp index 3b9b5c4bd..4f28ca4e9 100644 --- a/src/devices/mixer.cpp +++ b/src/devices/mixer.cpp @@ -57,7 +57,7 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s type_ = Type::HC; hc_ = device_id - 0x20 + 1; uint8_t tag = TAG_HC1 + hc_ - 1; - register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console + register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT, nullptr, FL_(flowSetTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), FL_(flowTempHc), DeviceValueUOM::DEGREES); register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(pumpStatus), DeviceValueUOM::PUMP); @@ -67,10 +67,10 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s type_ = Type::WWC; hc_ = device_id - 0x28 + 1; uint8_t tag = TAG_WWC1 + hc_ - 1; - register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console + register_device_value(tag, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), FL_(wwTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, nullptr, FL_(pumpStatus), DeviceValueUOM::PUMP); - register_device_value(tag, &status_, DeviceValueType::INT, nullptr, FL_(tempStatus)); + register_device_value(tag, &status_, DeviceValueType::INT, nullptr, FL_(tempStatus), DeviceValueUOM::NONE); } id_ = product_id; diff --git a/src/devices/solar.cpp b/src/devices/solar.cpp index 91a3c4e4c..9cf01e47e 100644 --- a/src/devices/solar.cpp +++ b/src/devices/solar.cpp @@ -64,11 +64,11 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s // special case for a device_id with 0x2A where it's not actual a solar module if (device_id == 0x2A) { - register_device_value(TAG_NONE, &type_, DeviceValueType::TEXT, nullptr, F("type"), F("type")); + register_device_value(TAG_NONE, &type_, DeviceValueType::TEXT, nullptr, F("type"), F("type"), DeviceValueUOM::NONE); strncpy(type_, "warm water circuit", sizeof(type_)); } - register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console + register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console id_ = product_id; register_device_value(TAG_NONE, &collectorTemp_, DeviceValueType::SHORT, FL_(div10), FL_(collectorTemp), DeviceValueUOM::DEGREES); @@ -76,14 +76,14 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const s register_device_value(TAG_NONE, &tankBottomTemp2_, DeviceValueType::SHORT, FL_(div10), FL_(tank2BottomTemp), DeviceValueUOM::DEGREES); register_device_value(TAG_NONE, &heatExchangerTemp_, DeviceValueType::SHORT, FL_(div10), FL_(heatExchangerTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_NONE, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES); + register_device_value(TAG_NONE, &tankBottomMaxTemp_, DeviceValueType::UINT, nullptr, FL_(tankMaxTemp), DeviceValueUOM::DEGREES, true); register_device_value(TAG_NONE, &solarPumpModulation_, DeviceValueType::UINT, nullptr, FL_(solarPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &cylinderPumpModulation_, DeviceValueType::UINT, nullptr, FL_(cylinderPumpModulation), DeviceValueUOM::PERCENT); register_device_value(TAG_NONE, &solarPump_, DeviceValueType::BOOL, nullptr, FL_(solarPump), DeviceValueUOM::PUMP); - register_device_value(TAG_NONE, &valveStatus_, DeviceValueType::BOOL, nullptr, FL_(valveStatus)); - register_device_value(TAG_NONE, &tankHeated_, DeviceValueType::BOOL, nullptr, FL_(tankHeated)); - register_device_value(TAG_NONE, &collectorShutdown_, DeviceValueType::BOOL, nullptr, FL_(collectorShutdown)); + register_device_value(TAG_NONE, &valveStatus_, DeviceValueType::BOOL, nullptr, FL_(valveStatus), DeviceValueUOM::NONE); + register_device_value(TAG_NONE, &tankHeated_, DeviceValueType::BOOL, nullptr, FL_(tankHeated), DeviceValueUOM::NONE); + register_device_value(TAG_NONE, &collectorShutdown_, DeviceValueType::BOOL, nullptr, FL_(collectorShutdown), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &pumpWorkTime_, DeviceValueType::TIME, nullptr, FL_(pumpWorkTime), DeviceValueUOM::MINUTES); diff --git a/src/devices/switch.cpp b/src/devices/switch.cpp index 53a1f42a3..c0e8b7c4b 100644 --- a/src/devices/switch.cpp +++ b/src/devices/switch.cpp @@ -34,10 +34,10 @@ Switch::Switch(uint8_t device_type, uint8_t device_id, uint8_t product_id, const register_telegram_type(0x9D, F("WM10SetMessage"), false, MAKE_PF_CB(process_WM10SetMessage)); register_telegram_type(0x1E, F("WM10TempMessage"), false, MAKE_PF_CB(process_WM10TempMessage)); - register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console - register_device_value(TAG_NONE, &activated_, DeviceValueType::BOOL, nullptr, FL_(activated)); + register_device_value(TAG_NONE, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console + register_device_value(TAG_NONE, &activated_, DeviceValueType::BOOL, nullptr, FL_(activated), DeviceValueUOM::NONE); register_device_value(TAG_NONE, &flowTempHc_, DeviceValueType::USHORT, FL_(div10), FL_(flowTempHc), DeviceValueUOM::DEGREES); - register_device_value(TAG_NONE, &status_, DeviceValueType::INT, nullptr, FL_(status)); + register_device_value(TAG_NONE, &status_, DeviceValueType::INT, nullptr, FL_(status), DeviceValueUOM::NONE); id_ = product_id; } diff --git a/src/devices/thermostat.cpp b/src/devices/thermostat.cpp index 6078ae92d..23370b017 100644 --- a/src/devices/thermostat.cpp +++ b/src/devices/thermostat.cpp @@ -2133,42 +2133,42 @@ void Thermostat::register_device_values() { uint8_t model = this->model(); // Common for all thermostats - register_device_value(TAG_THERMOSTAT_DATA, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr); // empty full name to prevent being shown in web or console - register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime)); - register_device_value(TAG_THERMOSTAT_DATA, &errorCode_, DeviceValueType::TEXT, nullptr, FL_(errorCode)); - register_device_value(TAG_THERMOSTAT_DATA, &lastCode_, DeviceValueType::TEXT, nullptr, FL_(lastCode)); + register_device_value(TAG_THERMOSTAT_DATA, &id_, DeviceValueType::UINT, nullptr, F("id"), nullptr, DeviceValueUOM::NONE); // empty full name to prevent being shown in web or console + register_device_value(TAG_THERMOSTAT_DATA, &dateTime_, DeviceValueType::TEXT, nullptr, FL_(dateTime), DeviceValueUOM::NONE, true); + register_device_value(TAG_THERMOSTAT_DATA, &errorCode_, DeviceValueType::TEXT, nullptr, FL_(errorCode), DeviceValueUOM::NONE); + register_device_value(TAG_THERMOSTAT_DATA, &lastCode_, DeviceValueType::TEXT, nullptr, FL_(lastCode), DeviceValueUOM::NONE); // RC30 only if (model == EMSdevice::EMS_DEVICE_FLAG_RC30_1) { - register_device_value(TAG_THERMOSTAT_DATA, &ibaMainDisplay_, DeviceValueType::ENUM, FL_(enum_ibaMainDisplay), FL_(ibaMainDisplay)); - register_device_value(TAG_THERMOSTAT_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage)); - register_device_value(TAG_THERMOSTAT_DATA, &ibaClockOffset_, DeviceValueType::UINT, nullptr, FL_(ibaClockOffset)); // offset (in sec) to clock, 0xff=-1s, 0x02=2s + register_device_value(TAG_THERMOSTAT_DATA, &ibaMainDisplay_, DeviceValueType::ENUM, FL_(enum_ibaMainDisplay), FL_(ibaMainDisplay), DeviceValueUOM::NONE); + register_device_value(TAG_THERMOSTAT_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage), DeviceValueUOM::NONE); + register_device_value(TAG_THERMOSTAT_DATA, &ibaClockOffset_, DeviceValueType::UINT, nullptr, FL_(ibaClockOffset), DeviceValueUOM::NONE); // offset (in sec) to clock, 0xff=-1s, 0x02=2s } // RC300 and RC100 if (model == EMS_DEVICE_FLAG_RC300 || model == EMS_DEVICE_FLAG_RC100) { - register_device_value(TAG_THERMOSTAT_DATA, &floordrystatus_, DeviceValueType::ENUM, FL_(enum_floordrystatus), FL_(floordrystatus)); + register_device_value(TAG_THERMOSTAT_DATA, &floordrystatus_, DeviceValueType::ENUM, FL_(enum_floordrystatus), FL_(floordrystatus), DeviceValueUOM::NONE); register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp2_, DeviceValueType::SHORT, FL_(div10), FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &floordrytemp_, DeviceValueType::UINT, nullptr, FL_(floordrytemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType), FL_(ibaBuildingType)); - register_device_value(TAG_THERMOSTAT_DATA, &wwSetTemp_, DeviceValueType::UINT, nullptr, FL_(wwSetTemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode)); - register_device_value(TAG_THERMOSTAT_DATA, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode)); + register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType), FL_(ibaBuildingType), DeviceValueUOM::NONE, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwSetTemp_, DeviceValueType::UINT, nullptr, FL_(wwSetTemp), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode), DeviceValueUOM::NONE, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwSetTempLow_, DeviceValueType::UINT, nullptr, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wWCircMode), DeviceValueUOM::NONE, true); register_device_value(TAG_THERMOSTAT_DATA, &wwExtra1_, DeviceValueType::UINT, nullptr, FL_(wwExtra1), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &wwExtra2_, DeviceValueType::UINT, nullptr, FL_(wwExtra2), DeviceValueUOM::DEGREES); } // RC30 and RC35 if (model == EMS_DEVICE_FLAG_RC35 || model == EMS_DEVICE_FLAG_RC30_1) { - register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES); + register_device_value(TAG_THERMOSTAT_DATA, &ibaCalIntTemperature_, DeviceValueType::INT, FL_(div2), FL_(ibaCalIntTemperature), DeviceValueUOM::DEGREES, true); + register_device_value(TAG_THERMOSTAT_DATA, &ibaMinExtTemperature_, DeviceValueType::INT, nullptr, FL_(ibaMinExtTemperature), DeviceValueUOM::DEGREES, true); register_device_value(TAG_THERMOSTAT_DATA, &tempsensor1_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor1), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &tempsensor2_, DeviceValueType::USHORT, FL_(div10), FL_(tempsensor2), DeviceValueUOM::DEGREES); register_device_value(TAG_THERMOSTAT_DATA, &dampedoutdoortemp_, DeviceValueType::INT, nullptr, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); - register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType)); - register_device_value(TAG_THERMOSTAT_DATA, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode)); - register_device_value(TAG_THERMOSTAT_DATA, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode)); + register_device_value(TAG_THERMOSTAT_DATA, &ibaBuildingType_, DeviceValueType::ENUM, FL_(enum_ibaBuildingType2), FL_(ibaBuildingType), DeviceValueUOM::NONE, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode2), FL_(wwMode), DeviceValueUOM::NONE, true); + register_device_value(TAG_THERMOSTAT_DATA, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode2), FL_(wWCircMode), DeviceValueUOM::NONE, true); } } @@ -2193,7 +2193,7 @@ void Thermostat::register_device_values_hc(std::shared_ptrsetpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES); + register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, FL_(setpoint_roomTemp), DeviceValueUOM::DEGREES, true); register_device_value(tag, &hc->curr_roomTemp, DeviceValueType::SHORT, curr_temp_divider, FL_(curr_roomTemp), DeviceValueUOM::DEGREES); if (device_id() != EMSESP::actual_master_thermostat()) { @@ -2205,82 +2205,82 @@ void Thermostat::register_device_values_hc(std::shared_ptrcurr_roomTemp, DeviceValueType::SHORT, curr_temp_divider, F("hatemp"), nullptr); + register_device_value(tag, &hc->curr_roomTemp, DeviceValueType::SHORT, curr_temp_divider, F("hatemp"), nullptr, DeviceValueUOM::NONE); } else if (option == Mqtt::HA_Climate_Format::SETPOINT) { - register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, F("hatemp"), nullptr); + register_device_value(tag, &hc->setpoint_roomTemp, DeviceValueType::SHORT, setpoint_temp_divider, F("hatemp"), nullptr, DeviceValueUOM::NONE); } else if (option == Mqtt::HA_Climate_Format::ZERO) { - register_device_value(tag, &zero_value_, DeviceValueType::UINT, nullptr, F("hatemp"), nullptr); + register_device_value(tag, &zero_value_, DeviceValueType::UINT, nullptr, F("hatemp"), nullptr, DeviceValueUOM::NONE); } // if we're sending to HA the only valid mode types are heat, auto and off // manual & day = heat // night & off = off // everything else auto - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_hamode), F("hamode"), nullptr); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_hamode), F("hamode"), nullptr, DeviceValueUOM::NONE); } if (model == EMSdevice::EMS_DEVICE_FLAG_RC300 || model == EMSdevice::EMS_DEVICE_FLAG_RC100) { - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode), FL_(mode)); - register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype), FL_(modetype)); - register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(ecotemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->manualtemp, DeviceValueType::UINT, FL_(div2), FL_(manualtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(comforttemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, nullptr, FL_(summertemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, nullptr, FL_(designtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->offsettemp, DeviceValueType::INT, nullptr, FL_(offsettemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, nullptr, FL_(minflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, nullptr, FL_(maxflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, nullptr, FL_(roominfluence)); - register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode), FL_(mode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype), FL_(modetype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(ecotemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->manualtemp, DeviceValueType::UINT, FL_(div2), FL_(manualtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(comforttemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, nullptr, FL_(summertemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, nullptr, FL_(designtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->offsettemp, DeviceValueType::INT, nullptr, FL_(offsettemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, nullptr, FL_(minflowtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, nullptr, FL_(maxflowtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, nullptr, FL_(roominfluence), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES, true); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, nullptr, FL_(targetflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype)); - register_device_value(tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode)); - register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode)); - register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program)); + register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->summer_setmode, DeviceValueType::ENUM, FL_(enum_summermode), FL_(summermode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode), FL_(controlmode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, true); } if (model == EMS_DEVICE_FLAG_RC20) { - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode)); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode), DeviceValueUOM::NONE, true); } if (model == EMS_DEVICE_FLAG_RC20_2) { - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode)); - register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype2), FL_(modetype)); - register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(daytemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(nighttemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program)); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype2), FL_(modetype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(daytemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(nighttemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, true); } if (model == EMS_DEVICE_FLAG_RC35 || model == EMS_DEVICE_FLAG_RC30_1) { - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode)); - register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype)); - register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(daytemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(nighttemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, nullptr, FL_(designtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->offsettemp, DeviceValueType::INT, FL_(div2), FL_(offsettemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->holidaytemp, DeviceValueType::UINT, FL_(div2), FL_(holidaytemp), DeviceValueUOM::DEGREES); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(daytemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(nighttemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, nullptr, FL_(designtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->offsettemp, DeviceValueType::INT, FL_(div2), FL_(offsettemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->holidaytemp, DeviceValueType::UINT, FL_(div2), FL_(holidaytemp), DeviceValueUOM::DEGREES, true); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, nullptr, FL_(targetflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, nullptr, FL_(summertemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->summermode, DeviceValueType::BOOL, nullptr, FL_(summermode)); - register_device_value(tag, &hc->holidaymode, DeviceValueType::BOOL, nullptr, FL_(holidaymode)); - register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, nullptr, FL_(roominfluence)); - register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, nullptr, FL_(minflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, nullptr, FL_(maxflowtemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->flowtempoffset, DeviceValueType::UINT, nullptr, FL_(flowtempoffset), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype)); - register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode)); - register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode)); - register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control), FL_(control)); - register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program)); + register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, nullptr, FL_(summertemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->summermode, DeviceValueType::BOOL, nullptr, FL_(summermode), DeviceValueUOM::NONE); + register_device_value(tag, &hc->holidaymode, DeviceValueType::BOOL, nullptr, FL_(holidaymode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, nullptr, FL_(nofrosttemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, nullptr, FL_(roominfluence), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, nullptr, FL_(minflowtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, nullptr, FL_(maxflowtemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->flowtempoffset, DeviceValueType::UINT, nullptr, FL_(flowtempoffset), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control), FL_(control), DeviceValueUOM::NONE); + register_device_value(tag, &hc->program, DeviceValueType::UINT, nullptr, FL_(program), DeviceValueUOM::NONE, true); } if (model == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) { - register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(mode)); - register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype4), FL_(modetype)); - register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(heattemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(ecotemp), DeviceValueUOM::DEGREES); - register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, FL_(div2), FL_(nofrosttemp), DeviceValueUOM::DEGREES); + register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(mode), DeviceValueUOM::NONE, true); + register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype4), FL_(modetype), DeviceValueUOM::NONE); + register_device_value(tag, &hc->daytemp, DeviceValueType::UINT, FL_(div2), FL_(heattemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->nighttemp, DeviceValueType::UINT, FL_(div2), FL_(ecotemp), DeviceValueUOM::DEGREES, true); + register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, FL_(div2), FL_(nofrosttemp), DeviceValueUOM::DEGREES, true); } } diff --git a/src/emsdevice.cpp b/src/emsdevice.cpp index f987729f3..92be57414 100644 --- a/src/emsdevice.cpp +++ b/src/emsdevice.cpp @@ -423,7 +423,14 @@ void EMSdevice::register_telegram_type(const uint16_t telegram_type_id, const __ // short_name: used in Mqtt as keys // full name: used in Web and Console unless empty (nullptr) // uom: unit of measure from DeviceValueUOM -void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * short_name, const __FlashStringHelper * full_name, uint8_t uom) { +void EMSdevice::register_device_value(uint8_t tag, + void * value_p, + uint8_t type, + const __FlashStringHelper * const * options, + const __FlashStringHelper * short_name, + const __FlashStringHelper * full_name, + uint8_t uom, + bool has_cmd) { // init the value depending on it's type if (type == DeviceValueType::TEXT) { *(char *)(value_p) = {'\0'}; @@ -448,11 +455,11 @@ void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, }; } - devicevalues_.emplace_back(device_type_, tag, value_p, type, options, options_size, short_name, full_name, uom); + devicevalues_.emplace_back(device_type_, tag, value_p, type, options, options_size, short_name, full_name, uom, has_cmd); } -void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom) { - register_device_value(tag, value_p, type, options, name[0], name[1], uom); +void EMSdevice::register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, bool has_cmd) { + register_device_value(tag, value_p, type, options, name[0], name[1], uom, has_cmd); } // looks up the uom (suffix) for a given key from the device value table @@ -570,7 +577,7 @@ bool EMSdevice::generate_values_json_web(JsonObject & json) { if (sz > num_elements) { // add the unit of measure (uom) if (dv.uom == DeviceValueUOM::MINUTES) { - data.add(nullptr); + data.add(nullptr); // use null for time/date } else { data.add(uom_to_string(dv.uom)); } @@ -583,7 +590,15 @@ bool EMSdevice::generate_values_json_web(JsonObject & json) { snprintf_P(name, sizeof(name), "(%s) %s", tag_to_string(dv.tag).c_str(), uuid::read_flash_string(dv.full_name).c_str()); data.add(name); } - num_elements = sz + 2; + + // add the name of the Command function if it exists + if (dv.has_cmd) { + data.add(dv.short_name); + } else { + data.add(""); + } + + num_elements = sz + 3; // increase count by 3 } } } diff --git a/src/emsdevice.h b/src/emsdevice.h index d27daf9ec..7a6debb67 100644 --- a/src/emsdevice.h +++ b/src/emsdevice.h @@ -269,9 +269,10 @@ class EMSdevice { const __FlashStringHelper * const * options, const __FlashStringHelper * short_name, const __FlashStringHelper * full_name, - uint8_t uom = DeviceValueUOM::NONE); + uint8_t uom, + bool has_cmd = false); + void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom, bool has_cmd = false); - void register_device_value(uint8_t tag, void * value_p, uint8_t type, const __FlashStringHelper * const * options, const __FlashStringHelper * const * name, uint8_t uom = DeviceValueUOM::NONE); void write_command(const uint16_t type_id, const uint8_t offset, uint8_t * message_data, const uint8_t message_length, const uint16_t validate_typeid); void write_command(const uint16_t type_id, const uint8_t offset, const uint8_t value, const uint16_t validate_typeid); void write_command(const uint16_t type_id, const uint8_t offset, const uint8_t value); @@ -406,6 +407,7 @@ class EMSdevice { const __FlashStringHelper * short_name; // used in MQTT const __FlashStringHelper * full_name; // used in Web and Console uint8_t uom; // DeviceValueUOM::* + bool has_cmd; // true if there is a Console/MQTT command which matches the short_name DeviceValue(uint8_t device_type, uint8_t tag, @@ -415,7 +417,8 @@ class EMSdevice { uint8_t options_size, const __FlashStringHelper * short_name, const __FlashStringHelper * full_name, - uint8_t uom) + uint8_t uom, + bool has_cmd) : device_type(device_type) , tag(tag) , value_p(value_p) @@ -424,7 +427,8 @@ class EMSdevice { , options_size(options_size) , short_name(short_name) , full_name(full_name) - , uom(uom) { + , uom(uom) + , has_cmd(has_cmd) { } }; const std::vector devicevalues() const; diff --git a/src/locale_EN.h b/src/locale_EN.h index 282ff5ed0..ec3ab2e76 100644 --- a/src/locale_EN.h +++ b/src/locale_EN.h @@ -254,16 +254,17 @@ MAKE_PSTR_LIST(enum_hamode, F_(off), F_(heat), F_(auto), F_(heat), F_(off), F_(h */ // Boiler -//extra commands +// extra commands MAKE_PSTR(wwtapactivated, "wwtapactivated") MAKE_PSTR(maintenance, "maintenance") MAKE_PSTR(error, "error") MAKE_PSTR(reset, "reset") + // single mqtt topics MAKE_PSTR(heating_active, "heating_active") MAKE_PSTR(tapwater_active, "tapwater_active") + // mqtt, commands and text -// MAKE_PSTR_LIST(id, F("id"), F("id")) MAKE_PSTR_LIST(burnPeriod, F("burnperiod"), F("min burner periode")) MAKE_PSTR_LIST(heatingActive, F("heatingactive"), F("heating active")) MAKE_PSTR_LIST(tapwaterActive, F("tapwateractive"), F("warm water active")) @@ -332,7 +333,7 @@ MAKE_PSTR_LIST(wWSetTemp, F("wwsettemp"), F("set temperature")) MAKE_PSTR_LIST(wWType, F("wwtype"), F("type")) MAKE_PSTR_LIST(wWComfort, F("wwcomfort"), F("comfort")) MAKE_PSTR_LIST(wWFlowTempOffset, F("wwFlowtempoffset"), F("flow temperature offset")) -MAKE_PSTR_LIST(wWMaxPower, F("wwMaxpower"), F("max power")) +MAKE_PSTR_LIST(wWMaxPower, F("wwmaxpower"), F("max power")) MAKE_PSTR_LIST(wWCircPump, F("wwcircpump"), F("circulation pump available")) MAKE_PSTR_LIST(wWChargeType, F("wwchargetype"), F("charging type")) MAKE_PSTR_LIST(wWDisinfectionTemp, F("wwdisinfectiontemp"), F("disinfection temperature")) @@ -344,18 +345,18 @@ MAKE_PSTR_LIST(wWCurFlow, F("wwcurflow"), F("current tap water flow")) MAKE_PSTR_LIST(wWStorageTemp1, F("wwstoragetemp1"), F("storage intern temperature")) MAKE_PSTR_LIST(wWStorageTemp2, F("wwstoragetemp2"), F("storage extern temperature")) MAKE_PSTR_LIST(wWActivated, F("wwactivated"), F("activated")) -MAKE_PSTR_LIST(wWOneTime, F("wwOnetime"), F("one time charging")) +MAKE_PSTR_LIST(wWOneTime, F("wwonetime"), F("one time charging")) MAKE_PSTR_LIST(wWDisinfecting, F("wwdisinfecting"), F("disinfecting")) MAKE_PSTR_LIST(wWCharging, F("wwcharging"), F("charging")) MAKE_PSTR_LIST(wWRecharging, F("wwrecharging"), F("recharging")) MAKE_PSTR_LIST(wWTempOK, F("wwtempok"), F("temperature ok")) MAKE_PSTR_LIST(wWActive, F("wwactive"), F("active")) MAKE_PSTR_LIST(wWHeat, F("wwHeat"), F("heating")) -MAKE_PSTR_LIST(wWSetPumpPower, F("wWSetPumpPower"), F("pump set power")) +MAKE_PSTR_LIST(wWSetPumpPower, F("wwsetpumppower"), F("pump set power")) MAKE_PSTR_LIST(mixerTemp, F("mixerTemp"), F("mixer temperature")) -MAKE_PSTR_LIST(tankMiddleTemp, F("tankMiddleTemp"), F("tank middle temperature (TS3)")) -MAKE_PSTR_LIST(wWStarts, F("wwStarts"), F("# starts")) -MAKE_PSTR_LIST(wWStarts2, F("wwStarts2"), F("# control starts")) +MAKE_PSTR_LIST(tankMiddleTemp, F("tankmiddletemp"), F("tank middle temperature (TS3)")) +MAKE_PSTR_LIST(wWStarts, F("wwstarts"), F("# starts")) +MAKE_PSTR_LIST(wWStarts2, F("wwstarts2"), F("# control starts")) MAKE_PSTR_LIST(wWWorkM, F("wwworkm"), F("active time")) //thermostat @@ -387,7 +388,6 @@ MAKE_PSTR_LIST(floordrytemp, F("floordrytemp"), F("floor drying temperature")) MAKE_PSTR_LIST(wwMode, F("wwmode"), F("warm water mode")) MAKE_PSTR_LIST(wwSetTemp, F("wwsettemp"), F("warm water set temperature")) MAKE_PSTR_LIST(wwSetTempLow, F("wwsettemplow"), F("warm water set temperature low")) -// MAKE_PSTR_LIST(wwCircMode, F("wwcircmode"), F("warm water circulation mode")) MAKE_PSTR_LIST(wwExtra1, F("wwextra1"), F("warm water circuit 1 extra")) MAKE_PSTR_LIST(wwExtra2, F("wwextra2"), F("warm water circuit 2 extra")) @@ -436,30 +436,28 @@ MAKE_PSTR_LIST(flowTempVf, F("flowtempvf"), F("flow temperature in header (T0/Vf MAKE_PSTR_LIST(tempStatus, F("tempstatus"), F("temperature switch in assigned hc (MC1)")) MAKE_PSTR_LIST(wwTemp, F("wwtemp"), F("current warm water temperature")) -// MAKE_PSTR_LIST(mixertype, F("type"), F("type")) // solar -MAKE_PSTR_LIST(collectorTemp, F("collectorTemp"), F("collector temperature (TS1)")) -MAKE_PSTR_LIST(tankBottomTemp, F("tankBottomTemp"), F("tank bottom temperature (TS2)")) -MAKE_PSTR_LIST(tank2BottomTemp, F("tank2BottomTemp"), F("second tank bottom temperature (TS5)")) -MAKE_PSTR_LIST(heatExchangerTemp, F("heatExchangerTemp"), F("heat exchanger temperature (TS6)")) +MAKE_PSTR_LIST(collectorTemp, F("collectortemp"), F("collector temperature (TS1)")) +MAKE_PSTR_LIST(tankBottomTemp, F("tankbottomtemp"), F("tank bottom temperature (TS2)")) +MAKE_PSTR_LIST(tank2BottomTemp, F("tank2bottomtemp"), F("second tank bottom temperature (TS5)")) +MAKE_PSTR_LIST(heatExchangerTemp, F("heatexchangertemp"), F("heat exchanger temperature (TS6)")) -MAKE_PSTR_LIST(tankMaxTemp, F("tankMaxTemp"), F("maximum tank temperature")) -MAKE_PSTR_LIST(solarPumpModulation, F("solarPumpModulation"), F("pump modulation (PS1)")) -MAKE_PSTR_LIST(cylinderPumpModulation, F("cylinderPumpModulation"), F("cylinder pump modulation (PS5)")) +MAKE_PSTR_LIST(tankMaxTemp, F("tankmaxtemp"), F("maximum tank temperature")) +MAKE_PSTR_LIST(solarPumpModulation, F("solarpumpmodulation"), F("pump modulation (PS1)")) +MAKE_PSTR_LIST(cylinderPumpModulation, F("cylinderpumpmodulation"), F("cylinder pump modulation (PS5)")) -MAKE_PSTR_LIST(solarPump, F("solarPump"), F("pump (PS1)")) -MAKE_PSTR_LIST(valveStatus, F("valveStatus"), F("valve status")) -MAKE_PSTR_LIST(tankHeated, F("tankHeated"), F("tank heated")) -MAKE_PSTR_LIST(collectorShutdown, F("collectorShutdown"), F("collector shutdown")) +MAKE_PSTR_LIST(solarPump, F("solarpump"), F("pump (PS1)")) +MAKE_PSTR_LIST(valveStatus, F("valvestatus"), F("valve status")) +MAKE_PSTR_LIST(tankHeated, F("tankheated"), F("tank heated")) +MAKE_PSTR_LIST(collectorShutdown, F("collectorshutdown"), F("collector shutdown")) -MAKE_PSTR_LIST(pumpWorkTime, F("pumpWorkTime"), F("pump working time")) +MAKE_PSTR_LIST(pumpWorkTime, F("pumpWorktime"), F("pump working time")) -MAKE_PSTR_LIST(energyLastHour, F("energyLastHour"), F("energy last hour")) -MAKE_PSTR_LIST(energyTotal, F("energyTotal"), F("energy total")) -MAKE_PSTR_LIST(energyToday, F("energyToday"), F("energy today")) +MAKE_PSTR_LIST(energyLastHour, F("energylasthour"), F("energy last hour")) +MAKE_PSTR_LIST(energyTotal, F("energytotal"), F("energy total")) +MAKE_PSTR_LIST(energyToday, F("energytoday"), F("energy today")) // switch MAKE_PSTR_LIST(activated, F("activated"), F("activated")) -// MAKE_PSTR_LIST(flowTempHc, F("flowTempHc"), F("flow temperature in assigned hc (TC1)")) MAKE_PSTR_LIST(status, F("status"), F("status"))