andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 15:59:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1707 from MichaelDvP/dev

Browse Source 
Rename DeviceValueTypes, add UINT32 for custom entities #1706
This commit is contained in:
Proddy
2024-04-22 19:06:36 +02:00
committed by GitHub
parent 01cd3c3587 0dcd0bad68
commit b893b5d609
31 changed files with 763 additions and 738 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG_LATEST.md
View File

@@ -27,3 +27,4 @@
- use factory partition for 16M flash - use factory partition for 16M flash
- store digital out states to nvs - store digital out states to nvs
- Refresh UI - moving settings to one location [#1665](https://github.com/emsesp/EMS-ESP32/issues/1665) - Refresh UI - moving settings to one location [#1665](https://github.com/emsesp/EMS-ESP32/issues/1665)
- rename DeviceValueTypes, add UINT32 for custom entities

19
interface/src/project/CustomEntitiesDialog.tsx
View File

@@ -26,7 +26,7 @@ import { useI18nContext } from 'i18n/i18n-react';
import { numberValue, updateValue } from 'utils'; import { numberValue, updateValue } from 'utils';
import { validate } from 'validators'; import { validate } from 'validators';
import { DeviceValueType, DeviceValueUOM_s } from './types'; import { DeviceValueType, DeviceValueUOM_s, DeviceValueTypeNames } from './types';
import type { EntityItem } from './types'; import type { EntityItem } from './types';
interface CustomEntitiesDialogProps { interface CustomEntitiesDialogProps {
@@ -210,14 +210,15 @@ const CustomEntitiesDialog = ({
fullWidth fullWidth
select select
> >
<MenuItem value={DeviceValueType.BOOL}>BOOL</MenuItem> <MenuItem value={DeviceValueType.BOOL}>{DeviceValueTypeNames[DeviceValueType.BOOL]}</MenuItem>
<MenuItem value={DeviceValueType.INT}>INT</MenuItem> <MenuItem value={DeviceValueType.INT8}>{DeviceValueTypeNames[DeviceValueType.INT8]}</MenuItem>
<MenuItem value={DeviceValueType.UINT}>UINT</MenuItem> <MenuItem value={DeviceValueType.UINT8}>{DeviceValueTypeNames[DeviceValueType.UINT8]}</MenuItem>
<MenuItem value={DeviceValueType.SHORT}>SHORT</MenuItem> <MenuItem value={DeviceValueType.INT16}>{DeviceValueTypeNames[DeviceValueType.INT16]}</MenuItem>
<MenuItem value={DeviceValueType.USHORT}>USHORT</MenuItem> <MenuItem value={DeviceValueType.UINT16}>{DeviceValueTypeNames[DeviceValueType.UINT16]}</MenuItem>
<MenuItem value={DeviceValueType.ULONG}>ULONG</MenuItem> <MenuItem value={DeviceValueType.UINT24}>{DeviceValueTypeNames[DeviceValueType.UINT24]}</MenuItem>
<MenuItem value={DeviceValueType.TIME}>TIME</MenuItem> <MenuItem value={DeviceValueType.TIME}>{DeviceValueTypeNames[DeviceValueType.TIME]}</MenuItem>
<MenuItem value={DeviceValueType.STRING}>RAW</MenuItem> <MenuItem value={DeviceValueType.UINT32}>{DeviceValueTypeNames[DeviceValueType.UINT32]}</MenuItem>
<MenuItem value={DeviceValueType.STRING}>{DeviceValueTypeNames[DeviceValueType.STRING]}</MenuItem>
</TextField> </TextField>
</Grid> </Grid>

24
interface/src/project/types.ts
View File

@@ -379,12 +379,13 @@ export const enum DeviceType {
// matches emsdevicevalue.h // matches emsdevicevalue.h
export const enum DeviceValueType { export const enum DeviceValueType {
BOOL, BOOL,
INT, INT8,
UINT, UINT8,
SHORT, INT16,
USHORT, UINT16,
ULONG, UINT24,
TIME, // same as ULONG (32 bits) TIME, // same as UINT24
UINT32,
ENUM, ENUM,
STRING, STRING,
CMD CMD
@@ -393,12 +394,13 @@ export const enum DeviceValueType {
export const DeviceValueTypeNames = [ export const DeviceValueTypeNames = [
// //
'BOOL', 'BOOL',
'INT', 'INT8',
'UINT', 'UINT8',
'SHORT', 'INT16',
'USHORT', 'UINT16',
'ULONG', 'UINT24',
'TIME', 'TIME',
'UINT32',
'ENUM', 'ENUM',
'RAW', 'RAW',
'CMD' 'CMD'

4
src/devices/alert.cpp
View File

@@ -29,8 +29,8 @@ Alert::Alert(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
// see https://github.com/emsesp/EMS-ESP32/issues/575 // see https://github.com/emsesp/EMS-ESP32/issues/575
register_telegram_type(0x1A, "UBASetPoints", false, MAKE_PF_CB(process_UBASetPoints)); register_telegram_type(0x1A, "UBASetPoints", false, MAKE_PF_CB(process_UBASetPoints));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setFlowTemp_, DeviceValueType::UINT, FL_(setFlowTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setFlowTemp_, DeviceValueType::UINT8, FL_(setFlowTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setBurnPow_, DeviceValueType::UINT, FL_(setBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setBurnPow_, DeviceValueType::UINT8, FL_(setBurnPow), DeviceValueUOM::PERCENT);
} }
// UBASetPoint 0x1A // UBASetPoint 0x1A
void Alert::process_UBASetPoints(std::shared_ptr<const Telegram> telegram) { void Alert::process_UBASetPoints(std::shared_ptr<const Telegram> telegram) {

353
src/devices/boiler.cpp
View File

@@ -97,22 +97,22 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&netFlowTemp_, &netFlowTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(netFlowTemp), FL_(netFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatValve_, DeviceValueType::UINT, FL_(heatValve), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatValve_, DeviceValueType::UINT8, FL_(heatValve), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwValve_, DeviceValueType::UINT, FL_(wwValve), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DHW1, &wwValve_, DeviceValueType::UINT8, FL_(wwValve), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurFlow_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurFlow), DeviceValueUOM::LMIN); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurFlow_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurFlow), DeviceValueUOM::LMIN);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&keepWarmTemp_, &keepWarmTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(keepWarmTemp), FL_(keepWarmTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_keepWarmTemp)); MAKE_CF_CB(set_keepWarmTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&setReturnTemp_, &setReturnTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(setReturnTemp), FL_(setReturnTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_returnTemp)); MAKE_CF_CB(set_returnTemp));
@@ -141,37 +141,37 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingActive_, DeviceValueType::BOOL, FL_(heatingActive), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingActive_, DeviceValueType::BOOL, FL_(heatingActive), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &tapwaterActive_, DeviceValueType::BOOL, FL_(tapwaterActive), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &tapwaterActive_, DeviceValueType::BOOL, FL_(tapwaterActive), DeviceValueUOM::NONE);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &selFlowTemp_, DeviceValueType::UINT, FL_(selFlowTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flow_temp), 0, 90); DeviceValueTAG::TAG_DEVICE_DATA, &selFlowTemp_, DeviceValueType::UINT8, FL_(selFlowTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flow_temp), 0, 90);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPumpMod_, DeviceValueType::UINT, FL_(heatingPumpMod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPumpMod_, DeviceValueType::UINT8, FL_(heatingPumpMod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&outdoorTemp_, &outdoorTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(outdoorTemp), FL_(outdoorTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&curFlowTemp_, &curFlowTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(curFlowTemp), FL_(curFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &retTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &retTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&switchTemp_, &switchTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(switchTemp), FL_(switchTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &sysPress_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysPress), DeviceValueUOM::BAR); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &sysPress_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysPress), DeviceValueUOM::BAR);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&boilTemp_, &boilTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(boilTemp), FL_(boilTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&headertemp_, &headertemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(headertemp), FL_(headertemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
@@ -180,7 +180,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
if (model() != EMSdevice::EMS_DEVICE_FLAG_HEATPUMP && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) { if (model() != EMSdevice::EMS_DEVICE_FLAG_HEATPUMP && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&exhaustTemp_, &exhaustTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(exhaustTemp), FL_(exhaustTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
@@ -188,7 +188,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnGas2_, DeviceValueType::BOOL, FL_(burnGas2), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnGas2_, DeviceValueType::BOOL, FL_(burnGas2), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&flameCurr_, &flameCurr_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(flameCurr), FL_(flameCurr),
DeviceValueUOM::UA); DeviceValueUOM::UA);
@@ -197,13 +197,13 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &oilPreHeat_, DeviceValueType::BOOL, FL_(oilPreHeat), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &oilPreHeat_, DeviceValueType::BOOL, FL_(oilPreHeat), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&burnMinPower_, &burnMinPower_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(burnMinPower), FL_(burnMinPower),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_min_power)); MAKE_CF_CB(set_min_power));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&burnMaxPower_, &burnMaxPower_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(burnMaxPower), FL_(burnMaxPower),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_max_power), MAKE_CF_CB(set_max_power),
@@ -211,28 +211,28 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
254); 254);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&burnMinPeriod_, &burnMinPeriod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(burnMinPeriod), FL_(burnMinPeriod),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_burn_period), MAKE_CF_CB(set_burn_period),
0, 0,
120); 120);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &absBurnPow_, DeviceValueType::UINT, FL_(absBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &absBurnPow_, DeviceValueType::UINT8, FL_(absBurnPow), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatblock_, &heatblock_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(heatblock), FL_(heatblock),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &boilHystOn_, DeviceValueType::INT, FL_(boilHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst_on), -20, 0); DeviceValueTAG::TAG_DEVICE_DATA, &boilHystOn_, DeviceValueType::INT8, FL_(boilHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst_on), -20, 0);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &boilHystOff_, DeviceValueType::INT, FL_(boilHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst_off), 0, 20); DeviceValueTAG::TAG_DEVICE_DATA, &boilHystOff_, DeviceValueType::INT8, FL_(boilHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst_off), 0, 20);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &boil2HystOn_, DeviceValueType::INT, FL_(boil2HystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst2_on), -20, 0); DeviceValueTAG::TAG_DEVICE_DATA, &boil2HystOn_, DeviceValueType::INT8, FL_(boil2HystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_hyst2_on), -20, 0);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&boil2HystOff_, &boil2HystOff_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(boil2HystOff), FL_(boil2HystOff),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_hyst2_off), MAKE_CF_CB(set_hyst2_off),
@@ -240,14 +240,20 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &curveOn_, DeviceValueType::BOOL, FL_(curveOn), DeviceValueUOM::NONE, MAKE_CF_CB(set_curveOn)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &curveOn_, DeviceValueType::BOOL, FL_(curveOn), DeviceValueUOM::NONE, MAKE_CF_CB(set_curveOn));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &curveBase_, DeviceValueType::UINT, FL_(curveBase), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_curveBase), 20, 90); DeviceValueTAG::TAG_DEVICE_DATA, &curveBase_, DeviceValueType::UINT8, FL_(curveBase), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_curveBase), 20, 90);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &curveEnd_, DeviceValueType::UINT, FL_(curveEnd), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_curveEnd), 20, 90); DeviceValueTAG::TAG_DEVICE_DATA, &curveEnd_, DeviceValueType::UINT8, FL_(curveEnd), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_curveEnd), 20, 90);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &summerTemp_, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summerTemp), 0, 30); DeviceValueTAG::TAG_DEVICE_DATA, &summerTemp_, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summerTemp), 0, 30);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nofrost_, DeviceValueType::BOOL, FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrost)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nofrost_, DeviceValueType::BOOL, FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrost));
register_device_value( register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
DeviceValueTAG::TAG_DEVICE_DATA, &nofrostTemp_, DeviceValueType::UINT, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrostTemp), 0, 10); &nofrostTemp_,
DeviceValueType::UINT8,
FL_(nofrosttemp),
DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_nofrostTemp),
0,
10);
} }
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatingActivated_, &heatingActivated_,
@@ -256,28 +262,28 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_heating_activated)); MAKE_CF_CB(set_heating_activated));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &heatingTemp_, DeviceValueType::UINT, FL_(heatingTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heating_temp), 0, 90); DeviceValueTAG::TAG_DEVICE_DATA, &heatingTemp_, DeviceValueType::UINT8, FL_(heatingTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heating_temp), 0, 90);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPump_, DeviceValueType::BOOL, FL_(heatingPump), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPump_, DeviceValueType::BOOL, FL_(heatingPump), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpModMax_, DeviceValueType::UINT, FL_(pumpModMax), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_max_pump)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpModMax_, DeviceValueType::UINT8, FL_(pumpModMax), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_max_pump));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpModMin_, DeviceValueType::UINT, FL_(pumpModMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_min_pump)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpModMin_, DeviceValueType::UINT8, FL_(pumpModMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_min_pump));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &pumpMode_, DeviceValueType::ENUM, FL_(enum_pumpMode), FL_(pumpMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_pumpMode)); DeviceValueTAG::TAG_DEVICE_DATA, &pumpMode_, DeviceValueType::ENUM, FL_(enum_pumpMode), FL_(pumpMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_pumpMode));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &pumpDelay_, DeviceValueType::UINT, FL_(pumpDelay), DeviceValueUOM::MINUTES, MAKE_CF_CB(set_pump_delay), 0, 60); DeviceValueTAG::TAG_DEVICE_DATA, &pumpDelay_, DeviceValueType::UINT8, FL_(pumpDelay), DeviceValueUOM::MINUTES, MAKE_CF_CB(set_pump_delay), 0, 60);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setFlowTemp_, DeviceValueType::UINT, FL_(setFlowTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setFlowTemp_, DeviceValueType::UINT8, FL_(setFlowTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setBurnPow_, DeviceValueType::UINT, FL_(setBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setBurnPow_, DeviceValueType::UINT8, FL_(setBurnPow), DeviceValueUOM::PERCENT);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &selBurnPow_, DeviceValueType::UINT, FL_(selBurnPow), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_burn_power), 0, 254); DeviceValueTAG::TAG_DEVICE_DATA, &selBurnPow_, DeviceValueType::UINT8, FL_(selBurnPow), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_burn_power), 0, 254);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &curBurnPow_, DeviceValueType::UINT, FL_(curBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &curBurnPow_, DeviceValueType::UINT8, FL_(curBurnPow), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnStarts_, DeviceValueType::ULONG, FL_(burnStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnStarts_, DeviceValueType::UINT24, FL_(burnStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnWorkMin_, DeviceValueType::TIME, FL_(burnWorkMin), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burnWorkMin_, DeviceValueType::TIME, FL_(burnWorkMin), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burn2WorkMin_, DeviceValueType::TIME, FL_(burn2WorkMin), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &burn2WorkMin_, DeviceValueType::TIME, FL_(burn2WorkMin), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatWorkMin_, DeviceValueType::TIME, FL_(heatWorkMin), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatWorkMin_, DeviceValueType::TIME, FL_(heatWorkMin), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatStarts_, DeviceValueType::ULONG, FL_(heatStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatStarts_, DeviceValueType::UINT24, FL_(heatStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &UBAuptime_, DeviceValueType::TIME, FL_(UBAuptime), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &UBAuptime_, DeviceValueType::TIME, FL_(UBAuptime), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &lastCode_, DeviceValueType::STRING, FL_(lastCode), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &lastCode_, DeviceValueType::STRING, FL_(lastCode), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &serviceCode_, DeviceValueType::STRING, FL_(serviceCode), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &serviceCode_, DeviceValueType::STRING, FL_(serviceCode), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &serviceCodeNumber_, DeviceValueType::USHORT, FL_(serviceCodeNumber), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &serviceCodeNumber_, DeviceValueType::UINT16, FL_(serviceCodeNumber), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &maintenanceMessage_, DeviceValueType::STRING, FL_(maintenanceMessage), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &maintenanceMessage_, DeviceValueType::STRING, FL_(maintenanceMessage), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&maintenanceType_, &maintenanceType_,
@@ -288,7 +294,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_maintenance)); MAKE_CF_CB(set_maintenance));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&maintenanceTime_, &maintenanceTime_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
FL_(maintenanceTime), FL_(maintenanceTime),
DeviceValueUOM::HOURS, DeviceValueUOM::HOURS,
MAKE_CF_CB(set_maintenancetime)); MAKE_CF_CB(set_maintenancetime));
@@ -307,7 +313,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_emergency_ops)); MAKE_CF_CB(set_emergency_ops));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&emergencyTemp_, &emergencyTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(emergencyTemp), FL_(emergencyTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_emergency_temp), MAKE_CF_CB(set_emergency_temp),
@@ -329,7 +335,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_hybridStrategy)); MAKE_CF_CB(set_hybridStrategy));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&switchOverTemp_, &switchOverTemp_,
DeviceValueType::INT, DeviceValueType::INT8,
nullptr, nullptr,
FL_(switchOverTemp), FL_(switchOverTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
@@ -338,7 +344,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyCostRatio_, &energyCostRatio_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyCostRatio), FL_(energyCostRatio),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -347,7 +353,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&fossileFactor_, &fossileFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(fossileFactor), FL_(fossileFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -356,7 +362,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&electricFactor_, &electricFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(electricFactor), FL_(electricFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -365,7 +371,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&delayBoiler_, &delayBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
nullptr, nullptr,
FL_(delayBoiler), FL_(delayBoiler),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
@@ -374,7 +380,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
120); 120);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempDiffBoiler_, &tempDiffBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
nullptr, nullptr,
FL_(tempDiffBoiler), FL_(tempDiffBoiler),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -388,42 +394,42 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
if (model() == EMSdevice::EMS_DEVICE_FLAG_HEATPUMP) { if (model() == EMSdevice::EMS_DEVICE_FLAG_HEATPUMP) {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&nrgTotal_, &nrgTotal_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(nrgTotal), FL_(nrgTotal),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &nrgWw_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &nrgWw_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgWw), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&nrgHeat_, &nrgHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(nrgHeat), FL_(nrgHeat),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterTotal_, &meterTotal_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterTotal), FL_(meterTotal),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterComp_, &meterComp_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterComp), FL_(meterComp),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterEHeat_, &meterEHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterEHeat), FL_(meterEHeat),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterHeat_, &meterHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterHeat), FL_(meterHeat),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &meterWw_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(meterWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &meterWw_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(meterWw), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&upTimeTotal_, &upTimeTotal_,
DeviceValueType::TIME, DeviceValueType::TIME,
@@ -460,40 +466,40 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
DeviceValueNumOp::DV_NUMOP_DIV60, DeviceValueNumOp::DV_NUMOP_DIV60,
FL_(upTimeCompPool), FL_(upTimeCompPool),
DeviceValueUOM::MINUTES); DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &totalCompStarts_, DeviceValueType::ULONG, FL_(totalCompStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &totalCompStarts_, DeviceValueType::UINT24, FL_(totalCompStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingStarts_, DeviceValueType::ULONG, FL_(heatingStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingStarts_, DeviceValueType::UINT24, FL_(heatingStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &coolingStarts_, DeviceValueType::ULONG, FL_(coolingStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &coolingStarts_, DeviceValueType::UINT24, FL_(coolingStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwStarts2_, DeviceValueType::ULONG, FL_(wwStarts2), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwStarts2_, DeviceValueType::UINT24, FL_(wwStarts2), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolStarts_, DeviceValueType::ULONG, FL_(poolStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolStarts_, DeviceValueType::UINT24, FL_(poolStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsTotal_, DeviceValueType::ULONG, FL_(nrgConsTotal), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsTotal_, DeviceValueType::UINT24, FL_(nrgConsTotal), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompTotal_, DeviceValueType::ULONG, FL_(nrgConsCompTotal), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompTotal_, DeviceValueType::UINT24, FL_(nrgConsCompTotal), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompHeating_, DeviceValueType::ULONG, FL_(nrgConsCompHeating), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompHeating_, DeviceValueType::UINT24, FL_(nrgConsCompHeating), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &nrgConsCompWw_, DeviceValueType::ULONG, FL_(nrgConsCompWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &nrgConsCompWw_, DeviceValueType::UINT24, FL_(nrgConsCompWw), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompCooling_, DeviceValueType::ULONG, FL_(nrgConsCompCooling), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompCooling_, DeviceValueType::UINT24, FL_(nrgConsCompCooling), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompPool_, DeviceValueType::ULONG, FL_(nrgConsCompPool), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgConsCompPool_, DeviceValueType::UINT24, FL_(nrgConsCompPool), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxElecHeatNrgConsTotal_, DeviceValueType::ULONG, FL_(auxElecHeatNrgConsTotal), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxElecHeatNrgConsTotal_, DeviceValueType::UINT24, FL_(auxElecHeatNrgConsTotal), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&auxElecHeatNrgConsHeating_, &auxElecHeatNrgConsHeating_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
FL_(auxElecHeatNrgConsHeating), FL_(auxElecHeatNrgConsHeating),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &auxElecHeatNrgConsWW_, DeviceValueType::ULONG, FL_(auxElecHeatNrgConsWW), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &auxElecHeatNrgConsWW_, DeviceValueType::UINT24, FL_(auxElecHeatNrgConsWW), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxElecHeatNrgConsPool_, DeviceValueType::ULONG, FL_(auxElecHeatNrgConsPool), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxElecHeatNrgConsPool_, DeviceValueType::UINT24, FL_(auxElecHeatNrgConsPool), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppTotal_, DeviceValueType::ULONG, FL_(nrgSuppTotal), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppTotal_, DeviceValueType::UINT24, FL_(nrgSuppTotal), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppHeating_, DeviceValueType::ULONG, FL_(nrgSuppHeating), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppHeating_, DeviceValueType::UINT24, FL_(nrgSuppHeating), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &nrgSuppWw_, DeviceValueType::ULONG, FL_(nrgSuppWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &nrgSuppWw_, DeviceValueType::UINT24, FL_(nrgSuppWw), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppCooling_, DeviceValueType::ULONG, FL_(nrgSuppCooling), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppCooling_, DeviceValueType::UINT24, FL_(nrgSuppCooling), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppPool_, DeviceValueType::ULONG, FL_(nrgSuppPool), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgSuppPool_, DeviceValueType::UINT24, FL_(nrgSuppPool), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPower_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPower), DeviceValueUOM::KW); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPower_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPower), DeviceValueUOM::KW);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpMaxPower_, &hpMaxPower_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(hpMaxPower), FL_(hpMaxPower),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_hpMaxPower)); MAKE_CF_CB(set_hpMaxPower));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpSetDiffPress_, &hpSetDiffPress_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL50, DeviceValueNumOp::DV_NUMOP_MUL50,
FL_(hpSetDiffPress), FL_(hpSetDiffPress),
DeviceValueUOM::MBAR, DeviceValueUOM::MBAR,
@@ -506,39 +512,39 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
// register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCoolingOn_, DeviceValueType::BOOL, FL_(hpCoolingOn), DeviceValueUOM::NONE); // register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCoolingOn_, DeviceValueType::BOOL, FL_(hpCoolingOn), DeviceValueUOM::NONE);
// register_device_value(DeviceValueTAG::TAG_DHW1, &hpWwOn_, DeviceValueType::BOOL, FL_(hpWwOn), DeviceValueUOM::NONE); // register_device_value(DeviceValueTAG::TAG_DHW1, &hpWwOn_, DeviceValueType::BOOL, FL_(hpWwOn), DeviceValueUOM::NONE);
// register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPoolOn_, DeviceValueType::BOOL, FL_(hpPoolOn), DeviceValueUOM::NONE); // register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPoolOn_, DeviceValueType::BOOL, FL_(hpPoolOn), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpBrinePumpSpd_, DeviceValueType::UINT, FL_(hpBrinePumpSpd), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpBrinePumpSpd_, DeviceValueType::UINT8, FL_(hpBrinePumpSpd), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpSwitchValve_, DeviceValueType::BOOL, FL_(hpSwitchValve), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpSwitchValve_, DeviceValueType::BOOL, FL_(hpSwitchValve), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCompSpd_, DeviceValueType::UINT, FL_(hpCompSpd), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCompSpd_, DeviceValueType::UINT8, FL_(hpCompSpd), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCircSpd_, DeviceValueType::UINT, FL_(hpCircSpd), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCircSpd_, DeviceValueType::UINT8, FL_(hpCircSpd), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpBrineIn_, &hpBrineIn_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(hpBrineIn), FL_(hpBrineIn),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpBrineOut_, &hpBrineOut_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(hpBrineOut), FL_(hpBrineOut),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc0_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc0), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc0_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc0), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc3_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc3), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTc3_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTc3), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr3_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr3), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr3_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr3), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr4_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr4), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr4_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr4), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr5_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr5), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr5_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr5), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr6_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr6), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr6_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr6), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr7_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr7), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr7_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr7), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTl2_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTl2), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTl2_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTl2), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPl1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPl1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPl1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPl1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPh1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPh1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPh1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPh1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTa4_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTa4), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTa4_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTa4), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTw1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTw1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTw1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTw1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&poolSetTemp_, &poolSetTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(poolSetTemp), FL_(poolSetTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
@@ -614,7 +620,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxHeaterStatus_, DeviceValueType::BOOL, FL_(auxHeaterStatus), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxHeaterStatus_, DeviceValueType::BOOL, FL_(auxHeaterStatus), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&auxHeaterDelay_, &auxHeaterDelay_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_MUL10, DeviceValueNumOp::DV_NUMOP_MUL10,
FL_(auxHeaterDelay), FL_(auxHeaterDelay),
DeviceValueUOM::KMIN, DeviceValueUOM::KMIN,
@@ -623,7 +629,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
1000); 1000);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&auxMaxLimit_, &auxMaxLimit_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(auxMaxLimit), FL_(auxMaxLimit),
DeviceValueUOM::K, DeviceValueUOM::K,
@@ -632,7 +638,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
10); 10);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&auxLimitStart_, &auxLimitStart_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(auxLimitStart), FL_(auxLimitStart),
DeviceValueUOM::K, DeviceValueUOM::K,
@@ -648,7 +654,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_auxHeatMode)); MAKE_CF_CB(set_auxHeatMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpHystHeat_, &hpHystHeat_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_MUL5, DeviceValueNumOp::DV_NUMOP_MUL5,
FL_(hpHystHeat), FL_(hpHystHeat),
DeviceValueUOM::KMIN, DeviceValueUOM::KMIN,
@@ -657,7 +663,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
1500); 1500);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpHystCool_, &hpHystCool_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_MUL5, DeviceValueNumOp::DV_NUMOP_MUL5,
FL_(hpHystCool), FL_(hpHystCool),
DeviceValueUOM::KMIN, DeviceValueUOM::KMIN,
@@ -666,7 +672,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
1500); 1500);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hpHystPool_, &hpHystPool_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_MUL5, DeviceValueNumOp::DV_NUMOP_MUL5,
FL_(hpHystPool), FL_(hpHystPool),
DeviceValueUOM::KMIN, DeviceValueUOM::KMIN,
@@ -682,34 +688,34 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_silentMode)); MAKE_CF_CB(set_silentMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&silentFrom_, &silentFrom_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(silentFrom), FL_(silentFrom),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_silentFrom)); MAKE_CF_CB(set_silentFrom));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&silentTo_, &silentTo_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(silentTo), FL_(silentTo),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_silentTo)); MAKE_CF_CB(set_silentTo));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&minTempSilent_, &minTempSilent_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(minTempSilent), FL_(minTempSilent),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_minTempSilent)); MAKE_CF_CB(set_minTempSilent));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempParMode_, &tempParMode_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(tempParMode), FL_(tempParMode),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_tempParMode)); MAKE_CF_CB(set_tempParMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxHeatMixValve_, DeviceValueType::INT, FL_(auxHeatMixValve), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &auxHeatMixValve_, DeviceValueType::INT8, FL_(auxHeatMixValve), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempDiffHeat_, &tempDiffHeat_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempDiffHeat), FL_(tempDiffHeat),
DeviceValueUOM::K, DeviceValueUOM::K,
@@ -718,7 +724,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
10); 10);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempDiffCool_, &tempDiffCool_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempDiffCool), FL_(tempDiffCool),
DeviceValueUOM::K, DeviceValueUOM::K,
@@ -731,7 +737,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &primePump_, DeviceValueType::BOOL, FL_(primePump), DeviceValueUOM::NONE, MAKE_CF_CB(set_primePump)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &primePump_, DeviceValueType::BOOL, FL_(primePump), DeviceValueUOM::NONE, MAKE_CF_CB(set_primePump));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&primePumpMod_, &primePumpMod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(primePumpMod), FL_(primePumpMod),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_primePumpMod)); MAKE_CF_CB(set_primePumpMod));
@@ -767,7 +773,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
FL_(hpPumpMode), FL_(hpPumpMode),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_hpPumpMode)); MAKE_CF_CB(set_hpPumpMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &fan_, DeviceValueType::UINT, FL_(hpFan), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_fan), 20, 100); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &fan_, DeviceValueType::UINT8, FL_(hpFan), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_fan), 20, 100);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpshutdown_, DeviceValueType::BOOL, FL_(hpShutdown), DeviceValueUOM::NONE, MAKE_CF_CB(set_shutdown)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpshutdown_, DeviceValueType::BOOL, FL_(hpShutdown), DeviceValueUOM::NONE, MAKE_CF_CB(set_shutdown));
// heatpump DHW settings // heatpump DHW settings
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
@@ -778,7 +784,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
MAKE_CF_CB(set_wwAlternatingOper)); MAKE_CF_CB(set_wwAlternatingOper));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwAltOpPrioHeat_, &wwAltOpPrioHeat_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwAltOpPrioHeat), FL_(wwAltOpPrioHeat),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_wwAltOpPrioHeat), MAKE_CF_CB(set_wwAltOpPrioHeat),
@@ -786,31 +792,37 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
120); 120);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwAltOpPrioWw_, &wwAltOpPrioWw_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwAltOpPrioWw), FL_(wwAltOpPrioWw),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_wwAltOpPrioWw), MAKE_CF_CB(set_wwAltOpPrioWw),
30, 30,
120); 120);
register_device_value(DeviceValueTAG::TAG_DHW1,
&wwComfOffTemp_,
DeviceValueType::UINT8,
FL_(wwComfOffTemp),
DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwComfOffTemp),
15,
65);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwComfOffTemp_, DeviceValueType::UINT, FL_(wwComfOffTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwComfOffTemp), 15, 65); DeviceValueTAG::TAG_DHW1, &wwEcoOffTemp_, DeviceValueType::UINT8, FL_(wwEcoOffTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwEcoOffTemp), 15, 65);
register_device_value(
DeviceValueTAG::TAG_DHW1, &wwEcoOffTemp_, DeviceValueType::UINT, FL_(wwEcoOffTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwEcoOffTemp), 15, 65);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwEcoPlusOffTemp_, &wwEcoPlusOffTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwEcoPlusOffTemp), FL_(wwEcoPlusOffTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwEcoPlusOffTemp), MAKE_CF_CB(set_wwEcoPlusOffTemp),
48, 48,
63); 63);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwComfDiffTemp_, DeviceValueType::UINT, FL_(wwComfDiffTemp), DeviceValueUOM::K, MAKE_CF_CB(set_wwComfDiffTemp), 6, 12); DeviceValueTAG::TAG_DHW1, &wwComfDiffTemp_, DeviceValueType::UINT8, FL_(wwComfDiffTemp), DeviceValueUOM::K, MAKE_CF_CB(set_wwComfDiffTemp), 6, 12);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwEcoDiffTemp_, DeviceValueType::UINT, FL_(wwEcoDiffTemp), DeviceValueUOM::K, MAKE_CF_CB(set_wwEcoDiffTemp), 6, 12); DeviceValueTAG::TAG_DHW1, &wwEcoDiffTemp_, DeviceValueType::UINT8, FL_(wwEcoDiffTemp), DeviceValueUOM::K, MAKE_CF_CB(set_wwEcoDiffTemp), 6, 12);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwEcoPlusDiffTemp_, &wwEcoPlusDiffTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwEcoPlusDiffTemp), FL_(wwEcoPlusDiffTemp),
DeviceValueUOM::K, DeviceValueUOM::K,
MAKE_CF_CB(set_wwEcoPlusDiffTemp), MAKE_CF_CB(set_wwEcoPlusDiffTemp),
@@ -818,19 +830,19 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
12); 12);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwComfStopTemp_, &wwComfStopTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwComfStopTemp), FL_(wwComfStopTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwComfStopTemp)); MAKE_CF_CB(set_wwComfStopTemp));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwEcoStopTemp_, &wwEcoStopTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwEcoStopTemp), FL_(wwEcoStopTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwEcoStopTemp)); MAKE_CF_CB(set_wwEcoStopTemp));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwEcoPlusStopTemp_, &wwEcoPlusStopTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwEcoPlusStopTemp), FL_(wwEcoPlusStopTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwEcoPlusStopTemp)); MAKE_CF_CB(set_wwEcoPlusStopTemp));
@@ -844,37 +856,37 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
FL_(wwtapactivated), FL_(wwtapactivated),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_tapwarmwater_activated)); MAKE_CF_CB(set_tapwarmwater_activated));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTemp_, DeviceValueType::UINT, FL_(wwSetTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTemp_, DeviceValueType::UINT8, FL_(wwSetTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTemp_, DeviceValueType::UINT, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_temp)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTemp_, DeviceValueType::UINT8, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_temp));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTempLow_, DeviceValueType::UINT, FL_(wwSelTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_temp_low)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTempLow_, DeviceValueType::UINT8, FL_(wwSelTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_temp_low));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwSelTempEcoplus_, &wwSelTempEcoplus_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwSelTempEco), FL_(wwSelTempEco),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_ww_temp_eco)); MAKE_CF_CB(set_ww_temp_eco));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTempOff_, DeviceValueType::UINT, FL_(wwSelTempOff), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSelTempOff_, DeviceValueType::UINT8, FL_(wwSelTempOff), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwSelTempSingle_, &wwSelTempSingle_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwSelTempSingle), FL_(wwSelTempSingle),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_ww_temp_single)); MAKE_CF_CB(set_ww_temp_single));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwSolarTemp_, &wwSolarTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(wwSolarTemp), FL_(wwSolarTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wwType), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwType_, DeviceValueType::ENUM, FL_(enum_flow), FL_(wwType), DeviceValueUOM::NONE);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wwComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_mode)); DeviceValueTAG::TAG_DHW1, &wwComfort_, DeviceValueType::ENUM, FL_(enum_comfort), FL_(wwComfort), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_mode));
wwComfort2_ = EMS_VALUE_UINT_NOTSET; // read separately, but published as wwComfort1_ wwComfort2_ = EMS_VALUE_UINT8_NOTSET; // read separately, but published as wwComfort1_
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwComfort1_, DeviceValueType::ENUM, FL_(enum_comfort1), FL_(wwComfort1), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_mode)); DeviceValueTAG::TAG_DHW1, &wwComfort1_, DeviceValueType::ENUM, FL_(enum_comfort1), FL_(wwComfort1), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_mode));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwFlowTempOffset_, &wwFlowTempOffset_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwFlowTempOffset), FL_(wwFlowTempOffset),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_ww_flowTempOffset), MAKE_CF_CB(set_ww_flowTempOffset),
@@ -886,15 +898,16 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
FL_(wwChargeOptimization), FL_(wwChargeOptimization),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_ww_chargeOptimization)); MAKE_CF_CB(set_ww_chargeOptimization));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwMaxPower_, DeviceValueType::UINT, FL_(wwMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_ww_maxpower), 0, 254); register_device_value(
register_device_value(DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_maxtemp), 0, 80); DeviceValueTAG::TAG_DHW1, &wwMaxPower_, DeviceValueType::UINT8, FL_(wwMaxPower), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_ww_maxpower), 0, 254);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT8, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ww_maxtemp), 0, 80);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCircPump_, DeviceValueType::BOOL, FL_(wwCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_circulation_pump)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCircPump_, DeviceValueType::BOOL, FL_(wwCircPump), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_circulation_pump));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwChargeType_, DeviceValueType::ENUM, FL_(enum_charge), FL_(wwChargeType), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwChargeType_, DeviceValueType::ENUM, FL_(enum_charge), FL_(wwChargeType), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwHystOn_, DeviceValueType::INT, FL_(wwHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_ww_hyst_on)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwHystOn_, DeviceValueType::INT8, FL_(wwHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_ww_hyst_on));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwHystOff_, DeviceValueType::INT, FL_(wwHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_ww_hyst_off)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwHystOff_, DeviceValueType::INT8, FL_(wwHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_ww_hyst_off));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfectionTemp_, &wwDisinfectionTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwDisinfectionTemp), FL_(wwDisinfectionTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_ww_disinfect_temp), MAKE_CF_CB(set_ww_disinfect_temp),
@@ -908,18 +921,18 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_ww_circulation_mode)); MAKE_CF_CB(set_ww_circulation_mode));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_circulation)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_ww_circulation));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurTemp2_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp2), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurTemp2_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp2), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurFlow_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurFlow), DeviceValueUOM::LMIN); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCurFlow_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurFlow), DeviceValueUOM::LMIN);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwStorageTemp1_, &wwStorageTemp1_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(wwStorageTemp1), FL_(wwStorageTemp1),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwStorageTemp2_, &wwStorageTemp2_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(wwStorageTemp2), FL_(wwStorageTemp2),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
@@ -931,20 +944,20 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DHW1, &wwTempOK_, DeviceValueType::BOOL, FL_(wwTempOK), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwTempOK_, DeviceValueType::BOOL, FL_(wwTempOK), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwActive_, DeviceValueType::BOOL, FL_(wwActive), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwActive_, DeviceValueType::BOOL, FL_(wwActive), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &ww3wayValve_, DeviceValueType::BOOL, FL_(ww3wayValve), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &ww3wayValve_, DeviceValueType::BOOL, FL_(ww3wayValve), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetPumpPower_, DeviceValueType::UINT, FL_(wwSetPumpPower), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetPumpPower_, DeviceValueType::UINT8, FL_(wwSetPumpPower), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwMixerTemp_, &wwMixerTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(wwMixerTemp), FL_(wwMixerTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwCylMiddleTemp_, &wwCylMiddleTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(wwCylMiddleTemp), FL_(wwCylMiddleTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwStarts_, DeviceValueType::ULONG, FL_(wwStarts), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DHW1, &wwStarts_, DeviceValueType::UINT24, FL_(wwStarts), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwWorkM_, DeviceValueType::TIME, FL_(wwWorkM), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwWorkM_, DeviceValueType::TIME, FL_(wwWorkM), DeviceValueUOM::MINUTES);
// fetch some initial data // fetch some initial data
@@ -957,16 +970,16 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
if (model() != EMSdevice::EMS_DEVICE_FLAG_HEATPUMP && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) { if (model() != EMSdevice::EMS_DEVICE_FLAG_HEATPUMP && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) {
register_telegram_type(0x04, "UBAFactory", true, MAKE_PF_CB(process_UBAFactory)); register_telegram_type(0x04, "UBAFactory", true, MAKE_PF_CB(process_UBAFactory));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nomPower_, DeviceValueType::UINT, FL_(nomPower), DeviceValueUOM::KW, MAKE_CF_CB(set_nomPower)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nomPower_, DeviceValueType::UINT8, FL_(nomPower), DeviceValueUOM::KW, MAKE_CF_CB(set_nomPower));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&nrgTotal_, &nrgTotal_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(nrgTotal), FL_(nrgTotal),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&nrgHeat_, &nrgHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(nrgHeat), FL_(nrgHeat),
DeviceValueUOM::KWH, DeviceValueUOM::KWH,
@@ -975,7 +988,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
10000000UL); 10000000UL);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&nrgWw_, &nrgWw_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(nrgWw), FL_(nrgWw),
DeviceValueUOM::KWH, DeviceValueUOM::KWH,
@@ -986,13 +999,13 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
nrgHeatF_ = EMSESP::nvs_.getDouble(FL_(nrgHeat)[0], 0); nrgHeatF_ = EMSESP::nvs_.getDouble(FL_(nrgHeat)[0], 0);
nrgWwF_ = EMSESP::nvs_.getDouble(FL_(nrgWw)[0], 0); nrgWwF_ = EMSESP::nvs_.getDouble(FL_(nrgWw)[0], 0);
nomPower_ = EMSESP::nvs_.getUChar(FL_(nomPower)[0], 0); nomPower_ = EMSESP::nvs_.getUChar(FL_(nomPower)[0], 0);
if (nrgHeatF_ < 0 || nrgHeatF_ >= EMS_VALUE_ULLONG_NOTSET) { if (nrgHeatF_ < 0 || nrgHeatF_ >= EMS_VALUE_UINT32_NOTSET) {
nrgHeatF_ = 0; nrgHeatF_ = 0;
} }
if (nrgWwF_ < 0 || nrgWwF_ >= EMS_VALUE_ULLONG_NOTSET) { if (nrgWwF_ < 0 || nrgWwF_ >= EMS_VALUE_UINT32_NOTSET) {
nrgWwF_ = 0; nrgWwF_ = 0;
} }
if (nomPower_ == EMS_VALUE_UINT_NOTSET) { if (nomPower_ == EMS_VALUE_UINT8_NOTSET) {
nomPower_ = 0; nomPower_ = 0;
} }
store_energy(); store_energy();
@@ -1239,7 +1252,7 @@ void Boiler::process_UBAParameterWW(std::shared_ptr<const Telegram> telegram) {
has_update(telegram, wwDisinfectionTemp_, 8); has_update(telegram, wwDisinfectionTemp_, 8);
has_bitupdate(telegram, wwChargeType_, 10, 0); // 0 = charge pump, 0xff = 3-way valve has_bitupdate(telegram, wwChargeType_, 10, 0); // 0 = charge pump, 0xff = 3-way valve
uint8_t wwComfort = EMS_VALUE_UINT_NOTSET; uint8_t wwComfort = EMS_VALUE_UINT8_NOTSET;
if (telegram->read_value(wwComfort, 9)) { if (telegram->read_value(wwComfort, 9)) {
if (wwComfort == 0) { if (wwComfort == 0) {
wwComfort = 0; // Hot wwComfort = 0; // Hot
@@ -1248,7 +1261,7 @@ void Boiler::process_UBAParameterWW(std::shared_ptr<const Telegram> telegram) {
} else if (wwComfort == 0xEC) { } else if (wwComfort == 0xEC) {
wwComfort = 2; // Intelligent wwComfort = 2; // Intelligent
} else { } else {
wwComfort = EMS_VALUE_UINT_NOTSET; wwComfort = EMS_VALUE_UINT8_NOTSET;
} }
has_update(wwComfort_, wwComfort); has_update(wwComfort_, wwComfort);
} }
@@ -1304,7 +1317,7 @@ void Boiler::process_UBAMonitorFastPlus(std::shared_ptr<const Telegram> telegram
uint8_t syspress = sysPress_; uint8_t syspress = sysPress_;
telegram->read_value(syspress, 21); // 0 means no sensor telegram->read_value(syspress, 21); // 0 means no sensor
if (syspress == 0) { if (syspress == 0) {
syspress = EMS_VALUE_UINT_NOTSET; syspress = EMS_VALUE_UINT8_NOTSET;
} }
has_update(sysPress_, syspress); has_update(sysPress_, syspress);
@@ -1331,7 +1344,7 @@ void Boiler::process_UBAMonitorFastPlus(std::shared_ptr<const Telegram> telegram
has_update(telegram, serviceCodeNumber_, 4); has_update(telegram, serviceCodeNumber_, 4);
// at this point do a quick check to see if the hot water or heating is active // at this point do a quick check to see if the hot water or heating is active
uint8_t state = EMS_VALUE_UINT_NOTSET; uint8_t state = EMS_VALUE_UINT8_NOTSET;
if (telegram->read_value(state, 11) && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) { if (telegram->read_value(state, 11) && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) {
boilerState_ = state & 0x01 ? 0x08 : 0; // burnGas boilerState_ = state & 0x01 ? 0x08 : 0; // burnGas
boilerState_ |= state & 0x02 ? 0x01 : 0; // heatingPump boilerState_ |= state & 0x02 ? 0x01 : 0; // heatingPump
@@ -1372,12 +1385,12 @@ void Boiler::process_UBAMonitorSlow(std::shared_ptr<const Telegram> telegram) {
void Boiler::process_UBAMonitorSlowPlus2(std::shared_ptr<const Telegram> telegram) { void Boiler::process_UBAMonitorSlowPlus2(std::shared_ptr<const Telegram> telegram) {
has_update(telegram, absBurnPow_, 13); // current burner absolute power (percent of rating plate power) has_update(telegram, absBurnPow_, 13); // current burner absolute power (percent of rating plate power)
if (model() == EMSdevice::EMS_DEVICE_FLAG_HIU) { if (model() == EMSdevice::EMS_DEVICE_FLAG_HIU) {
uint8_t state = EMS_VALUE_UINT_NOTSET; uint8_t state = EMS_VALUE_UINT8_NOTSET;
boilerState_ = 0; boilerState_ = 0;
if (telegram->read_value(state, 2)) { if (telegram->read_value(state, 2)) {
boilerState_ |= state == 1 ? 0x09 : 0; // heating 0/1 boilerState_ |= state == 1 ? 0x09 : 0; // heating 0/1
} }
state = EMS_VALUE_UINT_NOTSET; state = EMS_VALUE_UINT8_NOTSET;
if (telegram->read_value(state, 5)) { if (telegram->read_value(state, 5)) {
boilerState_ |= state == 1 ? 0x0A : 0; // dhw 0/1 boilerState_ |= state == 1 ? 0x0A : 0; // dhw 0/1
} }
@@ -1452,7 +1465,7 @@ void Boiler::process_UBAParameterWWPlus(std::shared_ptr<const Telegram> telegram
has_update(telegram, wwSelTempEcoplus_, 27); has_update(telegram, wwSelTempEcoplus_, 27);
telegram->read_value(wwComfort2_, 26); telegram->read_value(wwComfort2_, 26);
uint8_t wwComfort1 = EMS_VALUE_UINT_NOTSET; uint8_t wwComfort1 = EMS_VALUE_UINT8_NOTSET;
if (Helpers::hasValue(wwComfort2_)) { if (Helpers::hasValue(wwComfort2_)) {
has_update(wwComfort1_, wwComfort2_); has_update(wwComfort1_, wwComfort2_);
} else if (telegram->read_value(wwComfort1, 13)) { } else if (telegram->read_value(wwComfort1, 13)) {
@@ -1461,7 +1474,7 @@ void Boiler::process_UBAParameterWWPlus(std::shared_ptr<const Telegram> telegram
} else if (wwComfort1 == 0xD8) { } else if (wwComfort1 == 0xD8) {
wwComfort1 = 1; // Eco wwComfort1 = 1; // Eco
} else { } else {
wwComfort1 = EMS_VALUE_UINT_NOTSET; wwComfort1 = EMS_VALUE_UINT8_NOTSET;
} }
has_update(wwComfort1_, wwComfort1); has_update(wwComfort1_, wwComfort1);
} }
@@ -1711,7 +1724,7 @@ void Boiler::process_UBAErrorMessage(std::shared_ptr<const Telegram> telegram) {
// data: displaycode(2), errornumber(2), year, month, hour, day, minute, duration(2), src-addr // data: displaycode(2), errornumber(2), year, month, hour, day, minute, duration(2), src-addr
static uint32_t lastCodeDate_ = 0; // last code date static uint32_t lastCodeDate_ = 0; // last code date
char code[3] = {0}; char code[3] = {0};
uint16_t codeNo = EMS_VALUE_SHORT_NOTSET; uint16_t codeNo = EMS_VALUE_INT16_NOTSET;
code[0] = telegram->message_data[0]; code[0] = telegram->message_data[0];
code[1] = telegram->message_data[1]; code[1] = telegram->message_data[1];
code[2] = 0; code[2] = 0;
@@ -1744,7 +1757,7 @@ void Boiler::process_UBAErrorMessage2(std::shared_ptr<const Telegram> telegram)
static uint32_t lastCodeDate_ = 0; // last code date static uint32_t lastCodeDate_ = 0; // last code date
uint32_t date = 0; uint32_t date = 0;
char code[sizeof(lastCode_)] = {0}; char code[sizeof(lastCode_)] = {0};
uint16_t codeNo = EMS_VALUE_SHORT_NOTSET; uint16_t codeNo = EMS_VALUE_INT16_NOTSET;
code[0] = telegram->message_data[5]; code[0] = telegram->message_data[5];
code[1] = telegram->message_data[6]; code[1] = telegram->message_data[6];
code[2] = telegram->message_data[7]; code[2] = telegram->message_data[7];
@@ -1809,7 +1822,7 @@ void Boiler::process_UBAMaintenanceData(std::shared_ptr<const Telegram> telegram
// added additional type 3 (for Nefit TrendLine HRC 30/CW5) // added additional type 3 (for Nefit TrendLine HRC 30/CW5)
has_update(telegram, maintenanceType_, 0); // 0 = off, 1 = by operating hours, 2 = by date, 3 = manual has_update(telegram, maintenanceType_, 0); // 0 = off, 1 = by operating hours, 2 = by date, 3 = manual
uint8_t time = (maintenanceTime_ == EMS_VALUE_USHORT_NOTSET) ? EMS_VALUE_UINT_NOTSET : maintenanceTime_ / 100; uint8_t time = (maintenanceTime_ == EMS_VALUE_UINT16_NOTSET) ? EMS_VALUE_UINT8_NOTSET : maintenanceTime_ / 100;
telegram->read_value(time, 1); telegram->read_value(time, 1);
if (Helpers::hasValue(time)) { if (Helpers::hasValue(time)) {
if (time * 100 != maintenanceTime_) { if (time * 100 != maintenanceTime_) {
@@ -3109,7 +3122,7 @@ bool Boiler::set_nomPower(const char * value, const int8_t id) {
if (!Helpers::value2number(value, v)) { if (!Helpers::value2number(value, v)) {
return false; return false;
} }
if (v > 0 && v < EMS_VALUE_UINT_NOTSET) { if (v > 0 && v < EMS_VALUE_UINT8_NOTSET) {
has_update(nomPower_, (uint8_t)v); has_update(nomPower_, (uint8_t)v);
} }
store_energy(); store_energy();

4
src/devices/boiler.h
View File

@@ -38,7 +38,7 @@ class Boiler : public EMSdevice {
void check_active(); void check_active();
void store_energy(); void store_energy();
uint8_t boilerState_ = EMS_VALUE_UINT_NOTSET; // Boiler state flag - FOR INTERNAL USE uint8_t boilerState_ = EMS_VALUE_UINT8_NOTSET; // Boiler state flag - FOR INTERNAL USE
static constexpr uint8_t EMS_TYPE_UBASettingsWW = 0x26; static constexpr uint8_t EMS_TYPE_UBASettingsWW = 0x26;
static constexpr uint8_t EMS_TYPE_UBAParameterWW = 0x33; static constexpr uint8_t EMS_TYPE_UBAParameterWW = 0x33;
@@ -117,7 +117,7 @@ class Boiler : public EMSdevice {
uint16_t boilTemp_; // Boiler temperature uint16_t boilTemp_; // Boiler temperature
uint16_t exhaustTemp_; // Exhaust temperature published uint16_t exhaustTemp_; // Exhaust temperature published
// read second value from E4 and initialize it // read second value from E4 and initialize it
uint16_t exhaustTemp1_ = EMS_VALUE_USHORT_NOTSET; uint16_t exhaustTemp1_ = EMS_VALUE_UINT16_NOTSET;
uint8_t burnGas_; // Gas on/off uint8_t burnGas_; // Gas on/off
uint8_t burnGas2_; // Gas stage 2 on/off uint8_t burnGas2_; // Gas stage 2 on/off
uint16_t flameCurr_; // Flame current in micro amps uint16_t flameCurr_; // Flame current in micro amps

2
src/devices/connect.cpp
View File

@@ -28,7 +28,7 @@ Connect::Connect(uint8_t device_type, uint8_t device_id, uint8_t product_id, con
register_telegram_type(0xD1, "RFOutdoorTemp", false, MAKE_PF_CB(process_OutdoorTemp)); register_telegram_type(0xD1, "RFOutdoorTemp", false, MAKE_PF_CB(process_OutdoorTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&outdoorTemp_, &outdoorTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(outdoorTemp), FL_(outdoorTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);

20
src/devices/extension.cpp
View File

@@ -38,31 +38,31 @@ Extension::Extension(uint8_t device_type, uint8_t device_id, uint8_t product_id,
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&headerTemp_, &headerTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(flowTempVf), FL_(flowTempVf),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &input_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(input), DeviceValueUOM::VOLTS); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &input_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(input), DeviceValueUOM::VOLTS);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &outPower_, DeviceValueType::UINT, FL_(outPower), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &outPower_, DeviceValueType::UINT8, FL_(outPower), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setPower_, DeviceValueType::UINT, FL_(setPower), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setPower_, DeviceValueType::UINT8, FL_(setPower), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setPoint_, DeviceValueType::UINT, FL_(setPoint), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &setPoint_, DeviceValueType::UINT8, FL_(setPoint), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&minV_, &minV_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(minV), FL_(minV),
DeviceValueUOM::VOLTS, DeviceValueUOM::VOLTS,
MAKE_CF_CB(set_minV)); MAKE_CF_CB(set_minV));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&maxV_, &maxV_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(maxV), FL_(maxV),
DeviceValueUOM::VOLTS, DeviceValueUOM::VOLTS,
MAKE_CF_CB(set_maxV)); MAKE_CF_CB(set_maxV));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &minT_, DeviceValueType::UINT, FL_(minT), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minT)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &minT_, DeviceValueType::UINT8, FL_(minT), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minT));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &maxT_, DeviceValueType::UINT, FL_(maxT), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxT)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &maxT_, DeviceValueType::UINT8, FL_(maxT), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxT));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dip_, DeviceValueType::UINT, FL_(mode), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dip_, DeviceValueType::UINT8, FL_(mode), DeviceValueUOM::NONE);
// register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &errorState_, DeviceValueType::BOOL, FL_(error), DeviceValueUOM::NONE); // register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &errorState_, DeviceValueType::BOOL, FL_(error), DeviceValueUOM::NONE);
} }

64
src/devices/heatpump.cpp
View File

@@ -37,35 +37,35 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
register_telegram_type(0x4AF, "HPMeters", true, MAKE_PF_CB(process_HpMeters)); register_telegram_type(0x4AF, "HPMeters", true, MAKE_PF_CB(process_HpMeters));
// device values // device values
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &airHumidity_, DeviceValueType::UINT, FL_(airHumidity), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &airHumidity_, DeviceValueType::UINT8, FL_(airHumidity), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dewTemperature_, DeviceValueType::UINT, FL_(dewTemperature), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dewTemperature_, DeviceValueType::UINT8, FL_(dewTemperature), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&flowTemp_, &flowTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(curFlowTemp), FL_(curFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &retTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &retTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&sysRetTemp_, &sysRetTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(sysRetTemp), FL_(sysRetTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTa4_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTa4), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTa4_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTa4), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr3_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr3), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr3_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr3), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr4_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr4), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr4_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr4), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr5_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr5), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr5_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr5), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr6_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr6), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTr6_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTr6), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTl2_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTl2), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpTl2_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpTl2), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpJr0_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPl1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpJr0_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPl1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpJr1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPh1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpJr1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hpPh1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPumpMod_, DeviceValueType::UINT, FL_(heatingPumpMod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatingPumpMod_, DeviceValueType::UINT8, FL_(heatingPumpMod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCompSpd_, DeviceValueType::UINT, FL_(hpCompSpd), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpCompSpd_, DeviceValueType::UINT8, FL_(hpCompSpd), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&controlStrategy_, &controlStrategy_,
@@ -82,9 +82,9 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_lowNoiseMode)); MAKE_CF_CB(set_lowNoiseMode));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStart_, DeviceValueType::UINT, FL_(lowNoiseStart), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStart), 0, 23); DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStart_, DeviceValueType::UINT8, FL_(lowNoiseStart), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStart), 0, 23);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStop_, DeviceValueType::UINT, FL_(lowNoiseStop), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStop), 0, 23); DeviceValueTAG::TAG_DEVICE_DATA, &lowNoiseStop_, DeviceValueType::UINT8, FL_(lowNoiseStop), DeviceValueUOM::NONE, MAKE_CF_CB(set_lowNoiseStop), 0, 23);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&hybridDHW_, &hybridDHW_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -94,25 +94,25 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
MAKE_CF_CB(set_hybridDHW)); MAKE_CF_CB(set_hybridDHW));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyPriceGas_, &energyPriceGas_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(energyPriceGas), FL_(energyPriceGas),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_energyPriceGas)); MAKE_CF_CB(set_energyPriceGas));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyPriceEl_, &energyPriceEl_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(energyPriceEl), FL_(energyPriceEl),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_energyPriceEl)); MAKE_CF_CB(set_energyPriceEl));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyPricePV_, &energyPricePV_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(energyPricePV), FL_(energyPricePV),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_energyPricePV)); MAKE_CF_CB(set_energyPricePV));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&switchOverTemp_, &switchOverTemp_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(switchOverTemp), FL_(switchOverTemp),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_switchOverTemp)); MAKE_CF_CB(set_switchOverTemp));
@@ -125,7 +125,7 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
MAKE_CF_CB(set_airPurgeMode)); MAKE_CF_CB(set_airPurgeMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatPumpOutput_, &heatPumpOutput_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(heatPumpOutput), FL_(heatPumpOutput),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_heatPumpOutput)); MAKE_CF_CB(set_heatPumpOutput));
@@ -137,7 +137,7 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
MAKE_CF_CB(set_coolingCircuit)); MAKE_CF_CB(set_coolingCircuit));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&compStartMod_, &compStartMod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(compStartMod), FL_(compStartMod),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_compStartMod)); MAKE_CF_CB(set_compStartMod));
@@ -148,34 +148,34 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_heatDrainPan)); MAKE_CF_CB(set_heatDrainPan));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCable_, DeviceValueType::BOOL, FL_(heatCable), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatCable)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCable_, DeviceValueType::BOOL, FL_(heatCable), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatCable));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgTotal_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgTotal), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgTotal_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgTotal), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &nrgWw_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &nrgWw_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgWw), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgHeat_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgHeat), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgHeat_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgHeat), DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterTotal_, &meterTotal_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterTotal), FL_(meterTotal),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterComp_, &meterComp_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterComp), FL_(meterComp),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterEHeat_, &meterEHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterEHeat), FL_(meterEHeat),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&meterHeat_, &meterHeat_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV100, DeviceValueNumOp::DV_NUMOP_DIV100,
FL_(meterHeat), FL_(meterHeat),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DHW1, &meterWw_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(meterWw), DeviceValueUOM::KWH); register_device_value(DeviceValueTAG::TAG_DHW1, &meterWw_, DeviceValueType::UINT24, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(meterWw), DeviceValueUOM::KWH);
} }
/* /*

50
src/devices/heatsource.cpp
View File

@@ -35,42 +35,42 @@ Heatsource::Heatsource(uint8_t device_type, uint8_t device_id, uint8_t product_i
register_telegram_type(0x550, "AmExtra", false, MAKE_PF_CB(process_amExtraMessage)); register_telegram_type(0x550, "AmExtra", false, MAKE_PF_CB(process_amExtraMessage));
register_telegram_type(0x54C, "AmSettings", true, MAKE_PF_CB(process_amSettingMessage)); // not broadcasted register_telegram_type(0x54C, "AmSettings", true, MAKE_PF_CB(process_amSettingMessage)); // not broadcasted
register_device_value(tag, &curFlowTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysFlowTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &curFlowTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysFlowTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &retTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysRetTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &retTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(sysRetTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &aFlowTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aFlowTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &aFlowTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aFlowTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &aRetTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aRetTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &aRetTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aRetTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &cylTopTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylTopTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &cylTopTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylTopTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &cylCenterTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylCenterTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &cylCenterTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylCenterTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &cylBottomTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylBottomTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &cylBottomTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(aCylBottomTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &flueGasTemp_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flueGasTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &flueGasTemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flueGasTemp), DeviceValueUOM::DEGREES);
// register_device_value(tag, &valveByPass_, DeviceValueType::BOOL, nullptr, FL_(valveByPass), DeviceValueUOM::NONE); // register_device_value(tag, &valveByPass_, DeviceValueType::BOOL, nullptr, FL_(valveByPass), DeviceValueUOM::NONE);
register_device_value(tag, &valveBuffer_, DeviceValueType::UINT, FL_(valveBuffer), DeviceValueUOM::PERCENT); register_device_value(tag, &valveBuffer_, DeviceValueType::UINT8, FL_(valveBuffer), DeviceValueUOM::PERCENT);
register_device_value(tag, &valveReturn_, DeviceValueType::UINT, FL_(valveReturn), DeviceValueUOM::PERCENT); register_device_value(tag, &valveReturn_, DeviceValueType::UINT8, FL_(valveReturn), DeviceValueUOM::PERCENT);
register_device_value(tag, &aPumpMod_, DeviceValueType::UINT, FL_(aPumpMod), DeviceValueUOM::PERCENT); register_device_value(tag, &aPumpMod_, DeviceValueType::UINT8, FL_(aPumpMod), DeviceValueUOM::PERCENT);
// register_device_value(tag, &heatSource_, DeviceValueType::BOOL, nullptr, FL_(heatSource), DeviceValueUOM::NONE); // register_device_value(tag, &heatSource_, DeviceValueType::BOOL, nullptr, FL_(heatSource), DeviceValueUOM::NONE);
// Settings: // Settings:
register_device_value(tag, &vr2Config_, DeviceValueType::ENUM, FL_(enum_vr2Config), FL_(vr2Config), DeviceValueUOM::NONE, MAKE_CF_CB(set_vr2Config)); register_device_value(tag, &vr2Config_, DeviceValueType::ENUM, FL_(enum_vr2Config), FL_(vr2Config), DeviceValueUOM::NONE, MAKE_CF_CB(set_vr2Config));
register_device_value(tag, &ahsActivated_, DeviceValueType::BOOL, FL_(ahsActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_ahsActivated)); register_device_value(tag, &ahsActivated_, DeviceValueType::BOOL, FL_(ahsActivated), DeviceValueUOM::NONE, MAKE_CF_CB(set_ahsActivated));
register_device_value(tag, &aPumpConfig_, DeviceValueType::BOOL, FL_(aPumpConfig), DeviceValueUOM::NONE, MAKE_CF_CB(set_aPumpConfig)); register_device_value(tag, &aPumpConfig_, DeviceValueType::BOOL, FL_(aPumpConfig), DeviceValueUOM::NONE, MAKE_CF_CB(set_aPumpConfig));
register_device_value(tag, &aPumpSignal_, DeviceValueType::ENUM, FL_(enum_aPumpSignal), FL_(aPumpSignal), DeviceValueUOM::NONE, MAKE_CF_CB(set_aPumpSignal)); register_device_value(tag, &aPumpSignal_, DeviceValueType::ENUM, FL_(enum_aPumpSignal), FL_(aPumpSignal), DeviceValueUOM::NONE, MAKE_CF_CB(set_aPumpSignal));
register_device_value(tag, &aPumpMin_, DeviceValueType::UINT, FL_(aPumpMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_aPumpMin), 12, 50); register_device_value(tag, &aPumpMin_, DeviceValueType::UINT8, FL_(aPumpMin), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_aPumpMin), 12, 50);
register_device_value(tag, &tempRise_, DeviceValueType::BOOL, FL_(tempRise), DeviceValueUOM::NONE, MAKE_CF_CB(set_tempRise)); register_device_value(tag, &tempRise_, DeviceValueType::BOOL, FL_(tempRise), DeviceValueUOM::NONE, MAKE_CF_CB(set_tempRise));
register_device_value(tag, &setReturnTemp_, DeviceValueType::UINT, FL_(setReturnTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_setReturnTemp), 40, 75); register_device_value(tag, &setReturnTemp_, DeviceValueType::UINT8, FL_(setReturnTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_setReturnTemp), 40, 75);
register_device_value(tag, &mixRuntime_, DeviceValueType::USHORT, FL_(mixRuntime), DeviceValueUOM::SECONDS, MAKE_CF_CB(set_mixRuntime), 0, 600); register_device_value(tag, &mixRuntime_, DeviceValueType::UINT16, FL_(mixRuntime), DeviceValueUOM::SECONDS, MAKE_CF_CB(set_mixRuntime), 0, 600);
register_device_value(tag, &setFlowTemp_, DeviceValueType::UINT, FL_(setFlowTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_setFlowTemp), 40, 75); register_device_value(tag, &setFlowTemp_, DeviceValueType::UINT8, FL_(setFlowTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_setFlowTemp), 40, 75);
register_device_value(tag, &bufBypass_, DeviceValueType::ENUM, FL_(enum_bufBypass), FL_(bufBypass), DeviceValueUOM::NONE, MAKE_CF_CB(set_bufBypass)); register_device_value(tag, &bufBypass_, DeviceValueType::ENUM, FL_(enum_bufBypass), FL_(bufBypass), DeviceValueUOM::NONE, MAKE_CF_CB(set_bufBypass));
register_device_value(tag, &bufMixRuntime_, DeviceValueType::USHORT, FL_(bufMixRuntime), DeviceValueUOM::SECONDS, MAKE_CF_CB(set_bufMixRuntime), 0, 600); register_device_value(tag, &bufMixRuntime_, DeviceValueType::UINT16, FL_(bufMixRuntime), DeviceValueUOM::SECONDS, MAKE_CF_CB(set_bufMixRuntime), 0, 600);
register_device_value(tag, &bufConfig_, DeviceValueType::ENUM, FL_(enum_bufConfig), FL_(bufConfig), DeviceValueUOM::NONE, MAKE_CF_CB(set_bufConfig)); register_device_value(tag, &bufConfig_, DeviceValueType::ENUM, FL_(enum_bufConfig), FL_(bufConfig), DeviceValueUOM::NONE, MAKE_CF_CB(set_bufConfig));
register_device_value(tag, &blockMode_, DeviceValueType::ENUM, FL_(enum_blockMode), FL_(blockMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_blockMode)); register_device_value(tag, &blockMode_, DeviceValueType::ENUM, FL_(enum_blockMode), FL_(blockMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_blockMode));
register_device_value(tag, &blockTerm_, DeviceValueType::ENUM, FL_(enum_blockTerm), FL_(blockTerm), DeviceValueUOM::NONE, MAKE_CF_CB(set_blockTerm)); register_device_value(tag, &blockTerm_, DeviceValueType::ENUM, FL_(enum_blockTerm), FL_(blockTerm), DeviceValueUOM::NONE, MAKE_CF_CB(set_blockTerm));
register_device_value(tag, &blockHyst_, DeviceValueType::INT, FL_(blockHyst), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_blockHyst), 0, 50); register_device_value(tag, &blockHyst_, DeviceValueType::INT8, FL_(blockHyst), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_blockHyst), 0, 50);
register_device_value(tag, &releaseWait_, DeviceValueType::UINT, FL_(releaseWait), DeviceValueUOM::MINUTES, MAKE_CF_CB(set_releaseWait), 0, 240); register_device_value(tag, &releaseWait_, DeviceValueType::UINT8, FL_(releaseWait), DeviceValueUOM::MINUTES, MAKE_CF_CB(set_releaseWait), 0, 240);
register_device_value(tag, &burner_, DeviceValueType::BOOL, FL_(burner), DeviceValueUOM::NONE); register_device_value(tag, &burner_, DeviceValueType::BOOL, FL_(burner), DeviceValueUOM::NONE);
register_device_value(tag, &aPump_, DeviceValueType::BOOL, FL_(aPump), DeviceValueUOM::NONE); register_device_value(tag, &aPump_, DeviceValueType::BOOL, FL_(aPump), DeviceValueUOM::NONE);
register_device_value(tag, &heatRequest_, DeviceValueType::UINT, FL_(heatRequest), DeviceValueUOM::PERCENT); register_device_value(tag, &heatRequest_, DeviceValueType::UINT8, FL_(heatRequest), DeviceValueUOM::PERCENT);
register_device_value(tag, &blockRemain_, DeviceValueType::UINT, FL_(blockRemain), DeviceValueUOM::MINUTES); register_device_value(tag, &blockRemain_, DeviceValueType::UINT8, FL_(blockRemain), DeviceValueUOM::MINUTES);
register_device_value(tag, &blockRemainWw_, DeviceValueType::UINT, FL_(blockRemainWw), DeviceValueUOM::MINUTES); register_device_value(tag, &blockRemainWw_, DeviceValueType::UINT8, FL_(blockRemainWw), DeviceValueUOM::MINUTES);
} }
// cascaded heating sources, only some values per individual heatsource (hs) // cascaded heating sources, only some values per individual heatsource (hs)
@@ -83,15 +83,15 @@ Heatsource::Heatsource(uint8_t device_type, uint8_t device_id, uint8_t product_i
// register_telegram_type(0xD2, "CascadePowerMessage", false, MAKE_PF_CB(process_CascadePowerMessage)); // register_telegram_type(0xD2, "CascadePowerMessage", false, MAKE_PF_CB(process_CascadePowerMessage));
// individual Flowtemps and powervalues for each heatingsource in E4 // individual Flowtemps and powervalues for each heatingsource in E4
register_telegram_type(0xE4, "UBAMonitorFastPlus", false, MAKE_PF_CB(process_UBAMonitorFastPlus)); register_telegram_type(0xE4, "UBAMonitorFastPlus", false, MAKE_PF_CB(process_UBAMonitorFastPlus));
register_device_value(DeviceValueTAG::TAG_HS1 + hs, &setFlowTemp_, DeviceValueType::UINT, FL_(setFlowTemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_HS1 + hs, &setFlowTemp_, DeviceValueType::UINT8, FL_(setFlowTemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_HS1 + hs, &selBurnPow_, DeviceValueType::UINT, FL_(selBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_HS1 + hs, &selBurnPow_, DeviceValueType::UINT8, FL_(selBurnPow), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_HS1 + hs, register_device_value(DeviceValueTAG::TAG_HS1 + hs,
&curFlowTemp_, &curFlowTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(curFlowTemp), FL_(curFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_HS1 + hs, &curBurnPow_, DeviceValueType::UINT, FL_(curBurnPow), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_HS1 + hs, &curBurnPow_, DeviceValueType::UINT8, FL_(curBurnPow), DeviceValueUOM::PERCENT);
return; return;
} }
} }

26
src/devices/mixer.cpp
View File

@@ -33,21 +33,21 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_telegram_type(device_id - 0x20 + 0x02CD, "MMPLUSSetMessage_HC", true, MAKE_PF_CB(process_MMPLUSSetMessage_HC)); register_telegram_type(device_id - 0x20 + 0x02CD, "MMPLUSSetMessage_HC", true, MAKE_PF_CB(process_MMPLUSSetMessage_HC));
hc_ = device_id - 0x20 + 1; hc_ = device_id - 0x20 + 1;
uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1; uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1;
register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempHc_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES);
register_device_value(tag, &status_, DeviceValueType::UINT, FL_(mixerStatus), DeviceValueUOM::PERCENT); register_device_value(tag, &status_, DeviceValueType::UINT8, FL_(mixerStatus), DeviceValueUOM::PERCENT);
register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp)); register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT8, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp));
register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump)); register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump));
register_device_value(tag, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE, MAKE_CF_CB(set_activated)); register_device_value(tag, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE, MAKE_CF_CB(set_activated));
register_device_value(tag, register_device_value(tag,
&setValveTime_, &setValveTime_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL10, DeviceValueNumOp::DV_NUMOP_MUL10,
FL_(mixerSetTime), FL_(mixerSetTime),
DeviceValueUOM::SECONDS, DeviceValueUOM::SECONDS,
MAKE_CF_CB(set_setValveTime), MAKE_CF_CB(set_setValveTime),
10, 10,
600); 600);
register_device_value(tag, &flowTempOffset_, DeviceValueType::UINT, FL_(flowtempoffset), DeviceValueUOM::K, MAKE_CF_CB(set_flowTempOffset), 0, 20); register_device_value(tag, &flowTempOffset_, DeviceValueType::UINT8, FL_(flowtempoffset), DeviceValueUOM::K, MAKE_CF_CB(set_flowTempOffset), 0, 20);
} }
// EMS 1.0 // EMS 1.0
@@ -57,14 +57,14 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_telegram_type(0x00AC, "MMSetMessage", false, MAKE_PF_CB(process_MMSetMessage)); register_telegram_type(0x00AC, "MMSetMessage", false, MAKE_PF_CB(process_MMSetMessage));
hc_ = device_id - 0x20 + 1; hc_ = device_id - 0x20 + 1;
uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1; uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1;
register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempHc_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES);
register_device_value(tag, &status_, DeviceValueType::INT, FL_(mixerStatus), DeviceValueUOM::PERCENT); register_device_value(tag, &status_, DeviceValueType::INT8, FL_(mixerStatus), DeviceValueUOM::PERCENT);
register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp)); register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT8, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp));
register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump)); register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump));
register_device_value(tag, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE, MAKE_CF_CB(set_activated)); register_device_value(tag, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE, MAKE_CF_CB(set_activated));
register_device_value(tag, register_device_value(tag,
&setValveTime_, &setValveTime_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL10, DeviceValueNumOp::DV_NUMOP_MUL10,
FL_(mixerSetTime), FL_(mixerSetTime),
DeviceValueUOM::SECONDS, DeviceValueUOM::SECONDS,
@@ -80,11 +80,11 @@ Mixer::Mixer(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
// register_telegram_type(0x0123, "IPMSetMessage", false, MAKE_PF_CB(process_IPMSetMessage)); // register_telegram_type(0x0123, "IPMSetMessage", false, MAKE_PF_CB(process_IPMSetMessage));
hc_ = device_id - 0x20 + 1; hc_ = device_id - 0x20 + 1;
uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1; uint8_t tag = DeviceValueTAG::TAG_HC1 + hc_ - 1;
register_device_value(tag, &flowTempHc_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempHc_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempHc), DeviceValueUOM::DEGREES);
register_device_value(tag, &status_, DeviceValueType::UINT, FL_(mixerStatus), DeviceValueUOM::PERCENT); register_device_value(tag, &status_, DeviceValueType::UINT8, FL_(mixerStatus), DeviceValueUOM::PERCENT);
register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp)); register_device_value(tag, &flowSetTemp_, DeviceValueType::UINT8, FL_(flowSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_flowSetTemp));
register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump)); register_device_value(tag, &pumpStatus_, DeviceValueType::BOOL, FL_(pumpStatus), DeviceValueUOM::NONE, MAKE_CF_CB(set_pump));
register_device_value(tag, &flowTempVf_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempVf), DeviceValueUOM::DEGREES); register_device_value(tag, &flowTempVf_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(flowTempVf), DeviceValueUOM::DEGREES);
} }
} }

2
src/devices/mixer.h
View File

@@ -55,7 +55,7 @@ class Mixer : public EMSdevice {
uint8_t setValveTime_; uint8_t setValveTime_;
uint8_t flowTempOffset_; uint8_t flowTempOffset_;
uint16_t hc_ = EMS_VALUE_USHORT_NOTSET; uint16_t hc_ = EMS_VALUE_UINT16_NOTSET;
}; };
} // namespace emsesp } // namespace emsesp

4
src/devices/pool.cpp
View File

@@ -30,12 +30,12 @@ Pool::Pool(uint8_t device_type, uint8_t device_id, uint8_t product_id, const cha
register_telegram_type(0x5BA, "HpPoolStatus", true, MAKE_PF_CB(process_HpPoolStatus)); register_telegram_type(0x5BA, "HpPoolStatus", true, MAKE_PF_CB(process_HpPoolStatus));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&poolTemp_, &poolTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(poolTemp), FL_(poolTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolShuntStatus_, DeviceValueType::ENUM, FL_(enum_shunt), FL_(poolShuntStatus), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolShuntStatus_, DeviceValueType::ENUM, FL_(enum_shunt), FL_(poolShuntStatus), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolShunt_, DeviceValueType::UINT, FL_(poolShunt), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &poolShunt_, DeviceValueType::UINT8, FL_(poolShunt), DeviceValueUOM::PERCENT);
} }
// Mixer MP100 for pools - 0x5BA // Mixer MP100 for pools - 0x5BA

2
src/devices/pool.h
View File

@@ -38,7 +38,7 @@ class Pool : public EMSdevice {
uint8_t poolShuntStatus_; uint8_t poolShuntStatus_;
uint8_t poolShunt_; uint8_t poolShunt_;
uint8_t poolShuntStatus__ = EMS_VALUE_UINT_NOTSET; // temp value uint8_t poolShuntStatus__ = EMS_VALUE_UINT8_NOTSET; // temp value
}; };
} // namespace emsesp } // namespace emsesp

114
src/devices/solar.cpp
View File

@@ -62,60 +62,60 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
// common solar values for all modules (except dhw) // common solar values for all modules (except dhw)
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collectorTemp_, &collectorTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(collectorTemp), FL_(collectorTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&cylBottomTemp_, &cylBottomTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(cylBottomTemp), FL_(cylBottomTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump_, DeviceValueType::BOOL, FL_(solarPump), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump_, DeviceValueType::BOOL, FL_(solarPump), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpWorkTime_, DeviceValueType::TIME, FL_(pumpWorkTime), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pumpWorkTime_, DeviceValueType::TIME, FL_(pumpWorkTime), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylMaxTemp_, DeviceValueType::UINT, FL_(cylMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_cylMaxTemp)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylMaxTemp_, DeviceValueType::UINT8, FL_(cylMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_cylMaxTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &collectorShutdown_, DeviceValueType::BOOL, FL_(collectorShutdown), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &collectorShutdown_, DeviceValueType::BOOL, FL_(collectorShutdown), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylHeated_, DeviceValueType::BOOL, FL_(cylHeated), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylHeated_, DeviceValueType::BOOL, FL_(cylHeated), DeviceValueUOM::NONE);
// values per device flag // values per device flag
if (flags == EMSdevice::EMS_DEVICE_FLAG_SM10) { if (flags == EMSdevice::EMS_DEVICE_FLAG_SM10) {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPumpMod_, DeviceValueType::UINT, FL_(solarPumpMod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPumpMod_, DeviceValueType::UINT8, FL_(solarPumpMod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpMinMod_, &solarPumpMinMod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(pumpMinMod), FL_(pumpMinMod),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_PumpMinMod)); MAKE_CF_CB(set_PumpMinMod));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpTurnonDiff_, &solarPumpTurnonDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(solarPumpTurnonDiff), FL_(solarPumpTurnonDiff),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_TurnonDiff)); MAKE_CF_CB(set_TurnonDiff));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpTurnoffDiff_, &solarPumpTurnoffDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(solarPumpTurnoffDiff), FL_(solarPumpTurnoffDiff),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_TurnoffDiff)); MAKE_CF_CB(set_TurnoffDiff));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPower_, DeviceValueType::SHORT, FL_(solarPower), DeviceValueUOM::W); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPower_, DeviceValueType::INT16, FL_(solarPower), DeviceValueUOM::W);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyLastHour_, &energyLastHour_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyLastHour), FL_(energyLastHour),
DeviceValueUOM::WH); DeviceValueUOM::WH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&maxFlow_, &maxFlow_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(maxFlow), FL_(maxFlow),
DeviceValueUOM::LMIN, DeviceValueUOM::LMIN,
MAKE_CF_CB(set_SM10MaxFlow)); MAKE_CF_CB(set_SM10MaxFlow));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwMinTemp_, &wwMinTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwMinTemp), FL_(wwMinTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_wwMinTemp)); MAKE_CF_CB(set_wwMinTemp));
@@ -129,125 +129,125 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
/* /*
// unknown values for testing and logging. Used by MichaelDvP // unknown values for testing and logging. Used by MichaelDvP
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &setting3_, DeviceValueType::UINT, FL_(setting3), DeviceValueUOM::NONE, MAKE_CF_CB(set_CollectorMaxTemp)); DeviceValueTAG::TAG_DEVICE_DATA, &setting3_, DeviceValueType::UINT8, FL_(setting3), DeviceValueUOM::NONE, MAKE_CF_CB(set_CollectorMaxTemp));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &setting4_, DeviceValueType::UINT, FL_(setting4), DeviceValueUOM::NONE, MAKE_CF_CB(set_CollectorMinTemp)); DeviceValueTAG::TAG_DEVICE_DATA, &setting4_, DeviceValueType::UINT8, FL_(setting4), DeviceValueUOM::NONE, MAKE_CF_CB(set_CollectorMinTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data11_, DeviceValueType::UINT, FL_(data11), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data11_, DeviceValueType::UINT8, FL_(data11), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data12_, DeviceValueType::UINT, FL_(data12), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data12_, DeviceValueType::UINT8, FL_(data12), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data1_, DeviceValueType::UINT, FL_(data1), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data1_, DeviceValueType::UINT8, FL_(data1), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data0_, DeviceValueType::UINT, FL_(data0), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &data0_, DeviceValueType::UINT8, FL_(data0), DeviceValueUOM::NONE);
*/ */
} }
if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) { if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&cylMiddleTemp_, &cylMiddleTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(cylMiddleTemp), FL_(cylMiddleTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&retHeatAssist_, &retHeatAssist_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(retHeatAssist), FL_(retHeatAssist),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Valve_, DeviceValueType::BOOL, FL_(m1Valve), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Valve_, DeviceValueType::BOOL, FL_(m1Valve), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyLastHour_, &energyLastHour_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyLastHour), FL_(energyLastHour),
DeviceValueUOM::WH); DeviceValueUOM::WH);
} }
if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) { if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPumpMod_, DeviceValueType::UINT, FL_(solarPumpMod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPumpMod_, DeviceValueType::UINT8, FL_(solarPumpMod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpMinMod_, &solarPumpMinMod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL5, DeviceValueNumOp::DV_NUMOP_MUL5,
FL_(pumpMinMod), FL_(pumpMinMod),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_PumpMinMod)); MAKE_CF_CB(set_PumpMinMod));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpTurnonDiff_, &solarPumpTurnonDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(solarPumpTurnonDiff), FL_(solarPumpTurnonDiff),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_TurnonDiff)); MAKE_CF_CB(set_TurnonDiff));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPumpTurnoffDiff_, &solarPumpTurnoffDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(solarPumpTurnoffDiff), FL_(solarPumpTurnoffDiff),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_TurnoffDiff)); MAKE_CF_CB(set_TurnoffDiff));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collector2Temp_, &collector2Temp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(collector2Temp), FL_(collector2Temp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&cylMiddleTemp_, &cylMiddleTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(cylMiddleTemp), FL_(cylMiddleTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&retHeatAssist_, &retHeatAssist_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(retHeatAssist), FL_(retHeatAssist),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Valve_, DeviceValueType::BOOL, FL_(m1Valve), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Valve_, DeviceValueType::BOOL, FL_(m1Valve), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Power_, DeviceValueType::UINT, FL_(m1Power), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1Power_, DeviceValueType::UINT8, FL_(m1Power), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump2_, DeviceValueType::BOOL, FL_(solarPump2), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump2_, DeviceValueType::BOOL, FL_(solarPump2), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump2Mod_, DeviceValueType::UINT, FL_(solarPump2Mod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &solarPump2Mod_, DeviceValueType::UINT8, FL_(solarPump2Mod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&cylBottomTemp2_, &cylBottomTemp2_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(cyl2BottomTemp), FL_(cyl2BottomTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatExchangerTemp_, &heatExchangerTemp_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(heatExchangerTemp), FL_(heatExchangerTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylPumpMod_, DeviceValueType::UINT, FL_(cylPumpMod), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cylPumpMod_, DeviceValueType::UINT8, FL_(cylPumpMod), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &valveStatus_, DeviceValueType::BOOL, FL_(valveStatus), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &valveStatus_, DeviceValueType::BOOL, FL_(valveStatus), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &vs1Status_, DeviceValueType::BOOL, FL_(vs1Status), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &vs1Status_, DeviceValueType::BOOL, FL_(vs1Status), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collectorMaxTemp_, &collectorMaxTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(collectorMaxTemp), FL_(collectorMaxTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_CollectorMaxTemp)); MAKE_CF_CB(set_CollectorMaxTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collectorMinTemp_, &collectorMinTemp_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(collectorMinTemp), FL_(collectorMinTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_CollectorMinTemp)); MAKE_CF_CB(set_CollectorMinTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyLastHour_, &energyLastHour_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyLastHour), FL_(energyLastHour),
DeviceValueUOM::WH); DeviceValueUOM::WH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &energyToday_, DeviceValueType::ULONG, FL_(energyToday), DeviceValueUOM::WH); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &energyToday_, DeviceValueType::UINT24, FL_(energyToday), DeviceValueUOM::WH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyTotal_, &energyTotal_,
DeviceValueType::ULONG, DeviceValueType::UINT24,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyTotal), FL_(energyTotal),
DeviceValueUOM::KWH); DeviceValueUOM::KWH);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pump2WorkTime_, DeviceValueType::TIME, FL_(pump2WorkTime), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pump2WorkTime_, DeviceValueType::TIME, FL_(pump2WorkTime), DeviceValueUOM::MINUTES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1WorkTime_, DeviceValueType::TIME, FL_(m1WorkTime), DeviceValueUOM::MINUTES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &m1WorkTime_, DeviceValueType::TIME, FL_(m1WorkTime), DeviceValueUOM::MINUTES);
// register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cyl2MaxTemp_, DeviceValueType::UINT, nullptr, FL_(cyl2MaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_cyl2MaxTemp)); // register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &cyl2MaxTemp_, DeviceValueType::UINT8, nullptr, FL_(cyl2MaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_cyl2MaxTemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatTransferSystem_, &heatTransferSystem_,
@@ -312,20 +312,20 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPump2MinMod_, &solarPump2MinMod_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(pump2MinMod), FL_(pump2MinMod),
DeviceValueUOM::PERCENT, DeviceValueUOM::PERCENT,
MAKE_CF_CB(set_Pump2MinMod)); MAKE_CF_CB(set_Pump2MinMod));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPump2TurnonDiff_, &solarPump2TurnonDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(solarPump2TurnonDiff), FL_(solarPump2TurnonDiff),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_TurnonDiff2)); MAKE_CF_CB(set_TurnonDiff2));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&solarPump2TurnoffDiff_, &solarPump2TurnoffDiff_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(solarPump2TurnoffDiff), FL_(solarPump2TurnoffDiff),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
@@ -341,13 +341,13 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
// telegram 0x380 // telegram 0x380
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&climateZone_, &climateZone_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(climateZone), FL_(climateZone),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_climateZone)); // climate zone identifier MAKE_CF_CB(set_climateZone)); // climate zone identifier
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collector1Area_, &collector1Area_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(collector1Area), FL_(collector1Area),
DeviceValueUOM::SQM, DeviceValueUOM::SQM,
@@ -361,7 +361,7 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
MAKE_CF_CB(set_collector1Type)); // Type of collector field 1, 01=flat, 02=vacuum MAKE_CF_CB(set_collector1Type)); // Type of collector field 1, 01=flat, 02=vacuum
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&collector2Area_, &collector2Area_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(collector2Area), FL_(collector2Area),
DeviceValueUOM::SQM, DeviceValueUOM::SQM,
@@ -382,26 +382,26 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
MAKE_CF_CB(set_cylPriority)); MAKE_CF_CB(set_cylPriority));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatCntFlowTemp_, &heatCntFlowTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(heatCntFlowTemp), FL_(heatCntFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&heatCntRetTemp_, &heatCntRetTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(heatCntRetTemp), FL_(heatCntRetTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCnt_, DeviceValueType::UINT, FL_(heatCnt), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCnt_, DeviceValueType::UINT8, FL_(heatCnt), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&swapFlowTemp_, &swapFlowTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(swapFlowTemp), FL_(swapFlowTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&swapRetTemp_, &swapRetTemp_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(swapRetTemp), FL_(swapRetTemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
@@ -552,12 +552,12 @@ void Solar::process_SM100Differential(std::shared_ptr<const Telegram> telegram)
* e.g. B0 0B F9 00 00 02 5A 00 00 6E * e.g. B0 0B F9 00 00 02 5A 00 00 6E
*/ */
void Solar::process_SM100ParamCfg(std::shared_ptr<const Telegram> telegram) { void Solar::process_SM100ParamCfg(std::shared_ptr<const Telegram> telegram) {
uint16_t t_id = EMS_VALUE_USHORT_NOTSET; uint16_t t_id = EMS_VALUE_UINT16_NOTSET;
uint8_t of = EMS_VALUE_UINT_NOTSET; uint8_t of = EMS_VALUE_UINT8_NOTSET;
int32_t min = EMS_VALUE_USHORT_NOTSET; int32_t min = EMS_VALUE_UINT16_NOTSET;
int32_t def = EMS_VALUE_USHORT_NOTSET; int32_t def = EMS_VALUE_UINT16_NOTSET;
int32_t max = EMS_VALUE_USHORT_NOTSET; int32_t max = EMS_VALUE_UINT16_NOTSET;
int32_t cur = EMS_VALUE_USHORT_NOTSET; int32_t cur = EMS_VALUE_UINT16_NOTSET;
telegram->read_value(t_id, 1); telegram->read_value(t_id, 1);
telegram->read_value(of, 3); telegram->read_value(of, 3);
telegram->read_value(min, 5); telegram->read_value(min, 5);
@@ -679,8 +679,8 @@ void Solar::process_SM100CollectorConfig(std::shared_ptr<const Telegram> telegra
telegram->read_value(collector2Area_, 6); telegram->read_value(collector2Area_, 6);
telegram->read_enumvalue(collector2Type_, 8, 1); telegram->read_enumvalue(collector2Type_, 8, 1);
if (collector2Area_ == 0) { if (collector2Area_ == 0) {
collector2Area_ = EMS_VALUE_USHORT_NOTSET; collector2Area_ = EMS_VALUE_UINT16_NOTSET;
collector2Type_ = EMS_VALUE_UINT_NOTSET; collector2Type_ = EMS_VALUE_UINT8_NOTSET;
} }
// has_enumupdate(telegram, collector2Type_, 8, 1); // has_enumupdate(telegram, collector2Type_, 8, 1);
} }

4
src/devices/switch.cpp
View File

@@ -32,11 +32,11 @@ Switch::Switch(uint8_t device_type, uint8_t device_id, uint8_t product_id, const
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &activated_, DeviceValueType::BOOL, FL_(activated), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&flowTempHc_, &flowTempHc_,
DeviceValueType::USHORT, DeviceValueType::UINT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(flowTempHc), FL_(flowTempHc),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &status_, DeviceValueType::INT, FL_(status), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &status_, DeviceValueType::INT8, FL_(status), DeviceValueUOM::NONE);
} }
// message 0x9D switch on/off // message 0x9D switch on/off

336
src/devices/thermostat.cpp
View File

@@ -438,7 +438,7 @@ std::shared_ptr<Thermostat::HeatingCircuit> Thermostat::heating_circuit(std::sha
// add the HVAC/Climate HA component for the HC // add the HVAC/Climate HA component for the HC
void Thermostat::add_ha_climate(std::shared_ptr<HeatingCircuit> hc) const { void Thermostat::add_ha_climate(std::shared_ptr<HeatingCircuit> hc) const {
if (!Mqtt::ha_enabled()) { if (!Mqtt::ha_enabled()) {
hc->climate = EMS_VALUE_UINT_NOTSET; hc->climate = EMS_VALUE_UINT8_NOTSET;
return; return;
} }
@@ -449,7 +449,7 @@ void Thermostat::add_ha_climate(std::shared_ptr<HeatingCircuit> hc) const {
hc->climate = 0; // use selTemp, as there is no sensor present in the thermostat hc->climate = 0; // use selTemp, as there is no sensor present in the thermostat
} }
} else { } else {
hc->climate = EMS_VALUE_UINT_NOTSET; hc->climate = EMS_VALUE_UINT8_NOTSET;
} }
} }
@@ -734,7 +734,7 @@ void Thermostat::process_RemoteHumidity(std::shared_ptr<const Telegram> telegram
if (telegram->offset == 0 && telegram->message_length < 4) { if (telegram->offset == 0 && telegram->message_length < 4) {
int8_t dew = dewtemperature_ / 10; int8_t dew = dewtemperature_ / 10;
telegram->read_value(dew, 0); telegram->read_value(dew, 0);
if (dew != EMS_VALUE_INT_NOTSET && dewtemperature_ != dew * 10) { if (dew != EMS_VALUE_INT8_NOTSET && dewtemperature_ != dew * 10) {
dewtemperature_ = dew * 10; dewtemperature_ = dew * 10;
has_update(dewtemperature_); has_update(dewtemperature_);
} }
@@ -1036,10 +1036,10 @@ void Thermostat::process_RC300Monitor(std::shared_ptr<const Telegram> telegram)
// use summertemp or hpoperatingstate, https://github.com/emsesp/EMS-ESP32/issues/747, #550, #503 // use summertemp or hpoperatingstate, https://github.com/emsesp/EMS-ESP32/issues/747, #550, #503
if ((hc->statusbyte & 1) || !is_received(summer2_typeids[hc->hc()])) { if ((hc->statusbyte & 1) || !is_received(summer2_typeids[hc->hc()])) {
has_update(hc->summermode, hc->statusbyte & 0x50 ? 1 : 0); has_update(hc->summermode, hc->statusbyte & 0x50 ? 1 : 0);
has_update(hc->hpoperatingstate, EMS_VALUE_UINT_NOTSET); has_update(hc->hpoperatingstate, EMS_VALUE_UINT8_NOTSET);
} else { } else {
has_enumupdate(telegram, hc->hpoperatingstate, 20, 1); // 1:heating, 2:off, 3:cooling has_enumupdate(telegram, hc->hpoperatingstate, 20, 1); // 1:heating, 2:off, 3:cooling
has_update(hc->summermode, EMS_VALUE_UINT_NOTSET); has_update(hc->summermode, EMS_VALUE_UINT8_NOTSET);
} }
has_update(telegram, hc->targetflowtemp, 4); has_update(telegram, hc->targetflowtemp, 4);
has_update(telegram, hc->curroominfl, 27); has_update(telegram, hc->curroominfl, 27);
@@ -1137,10 +1137,10 @@ void Thermostat::process_RC300Summer2(std::shared_ptr<const Telegram> telegram)
} }
if (hc->statusbyte & 1) { if (hc->statusbyte & 1) {
has_update(telegram, hc->summersetmode, 0); has_update(telegram, hc->summersetmode, 0);
has_update(hc->hpoperatingmode, EMS_VALUE_UINT_NOTSET); has_update(hc->hpoperatingmode, EMS_VALUE_UINT8_NOTSET);
} else { } else {
has_update(telegram, hc->hpoperatingmode, 0); has_update(telegram, hc->hpoperatingmode, 0);
has_update(hc->summersetmode, EMS_VALUE_UINT_NOTSET); has_update(hc->summersetmode, EMS_VALUE_UINT8_NOTSET);
} }
has_update(telegram, hc->summertemp, 1); has_update(telegram, hc->summertemp, 1);
has_update(telegram, hc->heatondelay, 2); has_update(telegram, hc->heatondelay, 2);
@@ -1183,10 +1183,10 @@ void Thermostat::process_RC300WWmode(std::shared_ptr<const Telegram> telegram) {
if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) { if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) {
const uint8_t modes[] = {0, 5, 1, 2, 4}; // off, eco+, eco, comfort, auto const uint8_t modes[] = {0, 5, 1, 2, 4}; // off, eco+, eco, comfort, auto
uint8_t wwmode = wwMode_ < sizeof(modes) ? modes[wwMode_] : EMS_VALUE_UINT_NOTSET; uint8_t wwmode = wwMode_ < sizeof(modes) ? modes[wwMode_] : EMS_VALUE_UINT8_NOTSET;
telegram->read_value(wwmode, 2); telegram->read_value(wwmode, 2);
const uint8_t modes1[] = {0, 2, 3, 0, 4, 1}; const uint8_t modes1[] = {0, 2, 3, 0, 4, 1};
has_update(wwMode_, wwmode < sizeof(modes1) ? modes1[wwmode] : EMS_VALUE_UINT_NOTSET); has_update(wwMode_, wwmode < sizeof(modes1) ? modes1[wwmode] : EMS_VALUE_UINT8_NOTSET);
} else { } else {
has_update(telegram, wwMode_, 2); // 0=off, 1=low, 2=high, 3=auto, 4=own prog has_update(telegram, wwMode_, 2); // 0=off, 1=low, 2=high, 3=auto, 4=own prog
} }
@@ -1207,10 +1207,10 @@ void Thermostat::process_RC300WW2mode(std::shared_ptr<const Telegram> telegram)
if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) { if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) {
const uint8_t modes[] = {0, 5, 1, 2, 4}; // off, eco+, eco, comfort, auto const uint8_t modes[] = {0, 5, 1, 2, 4}; // off, eco+, eco, comfort, auto
uint8_t wwmode = wwMode_ < sizeof(modes) ? modes[wwMode2_] : EMS_VALUE_UINT_NOTSET; uint8_t wwmode = wwMode_ < sizeof(modes) ? modes[wwMode2_] : EMS_VALUE_UINT8_NOTSET;
telegram->read_value(wwmode, 2); telegram->read_value(wwmode, 2);
const uint8_t modes1[] = {0, 2, 3, 0, 4, 1}; const uint8_t modes1[] = {0, 2, 3, 0, 4, 1};
has_update(wwMode2_, wwmode < sizeof(modes1) ? modes1[wwmode] : EMS_VALUE_UINT_NOTSET); has_update(wwMode2_, wwmode < sizeof(modes1) ? modes1[wwmode] : EMS_VALUE_UINT8_NOTSET);
} else { } else {
has_update(telegram, wwMode2_, 2); // 0=off, 1=low, 2=high, 3=auto, 4=own prog has_update(telegram, wwMode2_, 2); // 0=off, 1=low, 2=high, 3=auto, 4=own prog
} }
@@ -1582,7 +1582,7 @@ void Thermostat::process_RCErrorMessage(std::shared_ptr<const Telegram> telegram
if (telegram->message_data[4] & 0x80) { // valid date if (telegram->message_data[4] & 0x80) { // valid date
static uint32_t lastCodeDate_ = 0; // last code date static uint32_t lastCodeDate_ = 0; // last code date
char code[sizeof(lastCode_)] = {0}; char code[sizeof(lastCode_)] = {0};
uint16_t codeNo = EMS_VALUE_USHORT_NOTSET; uint16_t codeNo = EMS_VALUE_UINT16_NOTSET;
code[0] = telegram->message_data[0]; code[0] = telegram->message_data[0];
code[1] = telegram->message_data[1]; code[1] = telegram->message_data[1];
code[2] = 0; code[2] = 0;
@@ -1592,7 +1592,7 @@ void Thermostat::process_RCErrorMessage(std::shared_ptr<const Telegram> telegram
uint8_t day = telegram->message_data[7]; uint8_t day = telegram->message_data[7];
uint8_t hour = telegram->message_data[6]; uint8_t hour = telegram->message_data[6];
uint8_t min = telegram->message_data[8]; uint8_t min = telegram->message_data[8];
uint16_t duration = EMS_VALUE_SHORT_NOTSET; uint16_t duration = EMS_VALUE_INT16_NOTSET;
uint32_t date = (year - 2000) * 535680UL + month * 44640UL + day * 1440UL + hour * 60 + min; uint32_t date = (year - 2000) * 535680UL + month * 44640UL + day * 1440UL + hour * 60 + min;
telegram->read_value(duration, 9); telegram->read_value(duration, 9);
// store only the newest code from telegrams 12 and 13 // store only the newest code from telegrams 12 and 13
@@ -1853,7 +1853,7 @@ bool Thermostat::set_remotetemp(const char * value, const int8_t id) {
} }
if (f > 100 || f < 0) { if (f > 100 || f < 0) {
hc->remotetemp = EMS_VALUE_SHORT_NOTSET; hc->remotetemp = EMS_VALUE_INT16_NOTSET;
} else { } else {
hc->remotetemp = (int16_t)(f * 10); hc->remotetemp = (int16_t)(f * 10);
} }
@@ -1870,8 +1870,8 @@ bool Thermostat::set_remotetemp(const char * value, const int8_t id) {
} else if (hc->control == 2) { // RC100(2) } else if (hc->control == 2) { // RC100(2)
Roomctrl::set_remotetemp(Roomctrl::RC100, hc->hc(), hc->remotetemp); // RC100 Roomctrl::set_remotetemp(Roomctrl::RC100, hc->hc(), hc->remotetemp); // RC100
} else { } else {
hc->remotetemp = EMS_VALUE_SHORT_NOTSET; hc->remotetemp = EMS_VALUE_INT16_NOTSET;
Roomctrl::set_remotetemp(0, hc->hc(), EMS_VALUE_SHORT_NOTSET); // unknown remote set, switch off Roomctrl::set_remotetemp(0, hc->hc(), EMS_VALUE_INT16_NOTSET); // unknown remote set, switch off
} }
} }
@@ -1891,7 +1891,7 @@ bool Thermostat::set_remotehum(const char * value, const int8_t id) {
} }
if (h > 100 || h < 0) { if (h > 100 || h < 0) {
hc->remotehum = EMS_VALUE_UINT_NOTSET; hc->remotehum = EMS_VALUE_UINT8_NOTSET;
} else { } else {
hc->remotehum = h; hc->remotehum = h;
} }
@@ -1990,7 +1990,7 @@ bool Thermostat::set_control(const char * value, const int8_t id) {
} else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_RC300 || model() == EMSdevice::EMS_DEVICE_FLAG_RC100) { } else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_RC300 || model() == EMSdevice::EMS_DEVICE_FLAG_RC100) {
if (Helpers::value2enum(value, ctrl, FL_(enum_control1))) { if (Helpers::value2enum(value, ctrl, FL_(enum_control1))) {
write_command(hpmode_typeids[hc->hc()], 3, ctrl); write_command(hpmode_typeids[hc->hc()], 3, ctrl);
if (hc->remotetemp != EMS_VALUE_SHORT_NOTSET && ctrl > 0) { if (hc->remotetemp != EMS_VALUE_INT16_NOTSET && ctrl > 0) {
if (ctrl == 1) { if (ctrl == 1) {
Roomctrl::set_remotetemp(Roomctrl::RC200, hc->hc(), hc->remotetemp); Roomctrl::set_remotetemp(Roomctrl::RC200, hc->hc(), hc->remotetemp);
} else if (ctrl == 2) { } else if (ctrl == 2) {
@@ -1998,7 +1998,7 @@ bool Thermostat::set_control(const char * value, const int8_t id) {
} else if (ctrl == 3) { } else if (ctrl == 3) {
Roomctrl::set_remotetemp(Roomctrl::RC100H, hc->hc(), hc->remotetemp); Roomctrl::set_remotetemp(Roomctrl::RC100H, hc->hc(), hc->remotetemp);
} else { } else {
hc->remotetemp = EMS_VALUE_SHORT_NOTSET; hc->remotetemp = EMS_VALUE_INT16_NOTSET;
Roomctrl::set_remotetemp(0, hc->hc(), hc->remotetemp); Roomctrl::set_remotetemp(0, hc->hc(), hc->remotetemp);
} }
// Roomctrl::set_remotetemp(ctrl == 1 ? Roomctrl::RC200 : ctrl == 3 ? Roomctrl::RC100H : Roomctrl::RC100, hc->hc(), hc->remotetemp); // Roomctrl::set_remotetemp(ctrl == 1 ? Roomctrl::RC200 : ctrl == 3 ? Roomctrl::RC100H : Roomctrl::RC100, hc->hc(), hc->remotetemp);
@@ -3783,30 +3783,30 @@ void Thermostat::register_device_values() {
// RF remote sensor seen at 0x40, maybe this is also for different hc with id 0x40 - 0x47? emsesp.cpp maps only 0x40 // RF remote sensor seen at 0x40, maybe this is also for different hc with id 0x40 - 0x47? emsesp.cpp maps only 0x40
if (device_id() >= 0x40 && device_id() <= 0x47) { if (device_id() >= 0x40 && device_id() <= 0x47) {
uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x40; uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x40;
register_device_value(tag, &tempsensor1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(RFTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &tempsensor1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(RFTemp), DeviceValueUOM::DEGREES);
return; return;
} }
// RC100H remote with humidity, this is also EMSdevice::EMS_DEVICE_FLAG_RC100 for set_calinttemp // RC100H remote with humidity, this is also EMSdevice::EMS_DEVICE_FLAG_RC100 for set_calinttemp
if (device_id() >= 0x38 && device_id() <= 0x3F) { if (device_id() >= 0x38 && device_id() <= 0x3F) {
// each device controls only one hc, so we tag the values // each device controls only one hc, so we tag the values
uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x38; uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x38;
register_device_value(tag, &tempsensor1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES); register_device_value(tag, &tempsensor1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &dewtemperature_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(dewTemperature), DeviceValueUOM::DEGREES); register_device_value(tag, &dewtemperature_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(dewTemperature), DeviceValueUOM::DEGREES);
register_device_value(tag, &humidity_, DeviceValueType::UINT, FL_(airHumidity), DeviceValueUOM::PERCENT); register_device_value(tag, &humidity_, DeviceValueType::UINT8, FL_(airHumidity), DeviceValueUOM::PERCENT);
register_device_value(tag, register_device_value(tag,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_calinttemp)); MAKE_CF_CB(set_calinttemp));
register_device_value(tag, &battery_, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(battery), DeviceValueUOM::PERCENT); register_device_value(tag, &battery_, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(battery), DeviceValueUOM::PERCENT);
return; return;
} }
// Junkers FB10 remote, show only internal sensor // Junkers FB10 remote, show only internal sensor
if (this->model() == EMSdevice::EMS_DEVICE_FLAG_JUNKERS && device_id() >= 0x18 && device_id() <= 0x1B) { if (this->model() == EMSdevice::EMS_DEVICE_FLAG_JUNKERS && device_id() >= 0x18 && device_id() <= 0x1B) {
uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x18; uint8_t tag = DeviceValueTAG::TAG_HC1 + device_id() - 0x18;
register_device_value(tag, &tempsensor1_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES); register_device_value(tag, &tempsensor1_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES);
return; return;
} }
// Common for all thermostats // Common for all thermostats
@@ -3826,7 +3826,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_datetime)); MAKE_CF_CB(set_datetime));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -3839,11 +3839,11 @@ void Thermostat::register_device_values() {
DeviceValueUOM::NONE); DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&dampedoutdoortemp2_, &dampedoutdoortemp2_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(dampedoutdoortemp), FL_(dampedoutdoortemp),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &floordrytemp_, DeviceValueType::UINT, FL_(floordrytemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &floordrytemp_, DeviceValueType::UINT8, FL_(floordrytemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaBuildingType_, &ibaBuildingType_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -3853,12 +3853,12 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_building)); MAKE_CF_CB(set_building));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaMinExtTemperature_, &ibaMinExtTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaMinExtTemperature), FL_(ibaMinExtTemperature),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_minexttemp)); MAKE_CF_CB(set_minexttemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTemp_, DeviceValueType::UINT, FL_(wwSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemp)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTemp_, DeviceValueType::UINT8, FL_(wwSetTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemp));
if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) { if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) {
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode4), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode)); DeviceValueTAG::TAG_DHW1, &wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode4), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
@@ -3871,7 +3871,7 @@ void Thermostat::register_device_values() {
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW2, &wwMode2_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode)); DeviceValueTAG::TAG_DHW2, &wwMode2_, DeviceValueType::ENUM, FL_(enum_wwMode), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
} }
register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTempLow_, DeviceValueType::UINT, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwSetTempLow_, DeviceValueType::UINT8, FL_(wwSetTempLow), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwtemplow));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwCircMode_, &wwCircMode_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -3881,13 +3881,13 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwcircmode)); MAKE_CF_CB(set_wwcircmode));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwChargeDuration_, &wwChargeDuration_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwChargeDuration), FL_(wwChargeDuration),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_wwchargeduration)); MAKE_CF_CB(set_wwchargeduration));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwCharge_, DeviceValueType::BOOL, FL_(wwCharge), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcharge)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwCharge_, DeviceValueType::BOOL, FL_(wwCharge), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcharge));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwExtra1_, DeviceValueType::UINT, FL_(wwExtra1), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW1, &wwExtra1_, DeviceValueType::UINT8, FL_(wwExtra1), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfecting_, &wwDisinfecting_,
DeviceValueType::BOOL, DeviceValueType::BOOL,
@@ -3903,7 +3903,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDisinfectDay)); MAKE_CF_CB(set_wwDisinfectDay));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfectHour_, &wwDisinfectHour_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwDisinfectTime), FL_(wwDisinfectTime),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
@@ -3918,7 +3918,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDailyHeating)); MAKE_CF_CB(set_wwDailyHeating));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDailyHeatTime_, &wwDailyHeatTime_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwDailyHeatTime), FL_(wwDailyHeatTime),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
@@ -3934,13 +3934,13 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwcircmode)); MAKE_CF_CB(set_wwcircmode));
register_device_value(DeviceValueTAG::TAG_DHW2, register_device_value(DeviceValueTAG::TAG_DHW2,
&wwChargeDuration2_, &wwChargeDuration2_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwChargeDuration), FL_(wwChargeDuration),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_wwchargeduration)); MAKE_CF_CB(set_wwchargeduration));
register_device_value(DeviceValueTAG::TAG_DHW2, &wwCharge2_, DeviceValueType::BOOL, FL_(wwCharge), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcharge)); register_device_value(DeviceValueTAG::TAG_DHW2, &wwCharge2_, DeviceValueType::BOOL, FL_(wwCharge), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwcharge));
register_device_value(DeviceValueTAG::TAG_DHW2, &wwExtra2_, DeviceValueType::UINT, FL_(wwExtra2), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DHW2, &wwExtra2_, DeviceValueType::UINT8, FL_(wwExtra2), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DHW2, register_device_value(DeviceValueTAG::TAG_DHW2,
&wwDisinfecting2_, &wwDisinfecting2_,
DeviceValueType::BOOL, DeviceValueType::BOOL,
@@ -3956,7 +3956,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDisinfectDay)); MAKE_CF_CB(set_wwDisinfectDay));
register_device_value(DeviceValueTAG::TAG_DHW2, register_device_value(DeviceValueTAG::TAG_DHW2,
&wwDisinfectHour2_, &wwDisinfectHour2_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwDisinfectTime), FL_(wwDisinfectTime),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
@@ -3971,7 +3971,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDailyHeating)); MAKE_CF_CB(set_wwDailyHeating));
register_device_value(DeviceValueTAG::TAG_DHW2, register_device_value(DeviceValueTAG::TAG_DHW2,
&wwDailyHeatTime2_, &wwDailyHeatTime2_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_MUL15, DeviceValueNumOp::DV_NUMOP_MUL15,
FL_(wwDailyHeatTime), FL_(wwDailyHeatTime),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
@@ -3987,7 +3987,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_hybridStrategy)); MAKE_CF_CB(set_hybridStrategy));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&switchOverTemp_, &switchOverTemp_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(switchOverTemp), FL_(switchOverTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_switchOverTemp), MAKE_CF_CB(set_switchOverTemp),
@@ -3995,7 +3995,7 @@ void Thermostat::register_device_values() {
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyCostRatio_, &energyCostRatio_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyCostRatio), FL_(energyCostRatio),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4004,7 +4004,7 @@ void Thermostat::register_device_values() {
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&fossileFactor_, &fossileFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(fossileFactor), FL_(fossileFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4013,7 +4013,7 @@ void Thermostat::register_device_values() {
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&electricFactor_, &electricFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(electricFactor), FL_(electricFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4022,7 +4022,7 @@ void Thermostat::register_device_values() {
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&delayBoiler_, &delayBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(delayBoiler), FL_(delayBoiler),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_delayBoiler), MAKE_CF_CB(set_delayBoiler),
@@ -4030,7 +4030,7 @@ void Thermostat::register_device_values() {
120); 120);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempDiffBoiler_, &tempDiffBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(tempDiffBoiler), FL_(tempDiffBoiler),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_tempDiffBoiler), MAKE_CF_CB(set_tempDiffBoiler),
@@ -4038,14 +4038,14 @@ void Thermostat::register_device_values() {
99); 99);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pvEnableWw_, DeviceValueType::BOOL, FL_(pvEnableWw), DeviceValueUOM::NONE, MAKE_CF_CB(set_pvEnableWw)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &pvEnableWw_, DeviceValueType::BOOL, FL_(pvEnableWw), DeviceValueUOM::NONE, MAKE_CF_CB(set_pvEnableWw));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &pvRaiseHeat_, DeviceValueType::INT, FL_(pvRaiseHeat), DeviceValueUOM::K, MAKE_CF_CB(set_pvRaiseHeat), 0, 5); DeviceValueTAG::TAG_DEVICE_DATA, &pvRaiseHeat_, DeviceValueType::INT8, FL_(pvRaiseHeat), DeviceValueUOM::K, MAKE_CF_CB(set_pvRaiseHeat), 0, 5);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &pvLowerCool_, DeviceValueType::INT, FL_(pvLowerCool), DeviceValueUOM::K, MAKE_CF_CB(set_pvLowerCool), -5, 0); DeviceValueTAG::TAG_DEVICE_DATA, &pvLowerCool_, DeviceValueType::INT8, FL_(pvLowerCool), DeviceValueUOM::K, MAKE_CF_CB(set_pvLowerCool), -5, 0);
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC10: case EMSdevice::EMS_DEVICE_FLAG_RC10:
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -4065,7 +4065,7 @@ void Thermostat::register_device_values() {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dateTime_, DeviceValueType::STRING, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dateTime_, DeviceValueType::STRING, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaMinExtTemperature_, &ibaMinExtTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaMinExtTemperature), FL_(ibaMinExtTemperature),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_minexttemp)); MAKE_CF_CB(set_minexttemp));
@@ -4077,7 +4077,7 @@ void Thermostat::register_device_values() {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dateTime_, DeviceValueType::STRING, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dateTime_, DeviceValueType::STRING, FL_(dateTime), DeviceValueUOM::NONE); // can't set datetime
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaClockOffset_, &ibaClockOffset_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaClockOffset), FL_(ibaClockOffset),
DeviceValueUOM::SECONDS, DeviceValueUOM::SECONDS,
MAKE_CF_CB(set_clockoffset)); // offset (in sec) to clock, 0xff=-1s, 0x02=2s MAKE_CF_CB(set_clockoffset)); // offset (in sec) to clock, 0xff=-1s, 0x02=2s
@@ -4091,9 +4091,9 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_language)); MAKE_CF_CB(set_language));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &backlight_, DeviceValueType::BOOL, FL_(backlight), DeviceValueUOM::NONE, MAKE_CF_CB(set_backlight)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &backlight_, DeviceValueType::BOOL, FL_(backlight), DeviceValueUOM::NONE, MAKE_CF_CB(set_backlight));
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &brightness_, DeviceValueType::INT, FL_(brightness), DeviceValueUOM::NONE, MAKE_CF_CB(set_brightness), -15, 15); DeviceValueTAG::TAG_DEVICE_DATA, &brightness_, DeviceValueType::INT8, FL_(brightness), DeviceValueUOM::NONE, MAKE_CF_CB(set_brightness), -15, 15);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &mixingvalves_, DeviceValueType::UINT, FL_(mixingvalves), DeviceValueUOM::NONE, MAKE_CF_CB(set_mixingvalves), 0, 2); DeviceValueTAG::TAG_DEVICE_DATA, &mixingvalves_, DeviceValueType::UINT8, FL_(mixingvalves), DeviceValueUOM::NONE, MAKE_CF_CB(set_mixingvalves), 0, 2);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaBuildingType_, &ibaBuildingType_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -4111,7 +4111,7 @@ void Thermostat::register_device_values() {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &preheating_, DeviceValueType::BOOL, FL_(preheating), DeviceValueUOM::NONE, MAKE_CF_CB(set_preheating)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &preheating_, DeviceValueType::BOOL, FL_(preheating), DeviceValueUOM::NONE, MAKE_CF_CB(set_preheating));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -4138,7 +4138,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDisinfectDay)); MAKE_CF_CB(set_wwDisinfectDay));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfectHour_, &wwDisinfectHour_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwDisinfectHour), FL_(wwDisinfectHour),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_wwDisinfectHour), MAKE_CF_CB(set_wwDisinfectHour),
@@ -4171,37 +4171,37 @@ void Thermostat::register_device_values() {
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaLanguage_, DeviceValueType::ENUM, FL_(enum_ibaLanguage), FL_(ibaLanguage), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaClockOffset_, &ibaClockOffset_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaClockOffset), FL_(ibaClockOffset),
DeviceValueUOM::SECONDS, DeviceValueUOM::SECONDS,
MAKE_CF_CB(set_clockoffset)); // offset (in sec) to clock, 0xff=-1s, 0x02=2s MAKE_CF_CB(set_clockoffset)); // offset (in sec) to clock, 0xff=-1s, 0x02=2s
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_calinttemp)); MAKE_CF_CB(set_calinttemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaMinExtTemperature_, &ibaMinExtTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaMinExtTemperature), FL_(ibaMinExtTemperature),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_minexttemp)); MAKE_CF_CB(set_minexttemp));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempsensor1_, &tempsensor1_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempsensor1), FL_(tempsensor1),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempsensor2_, &tempsensor2_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempsensor2), FL_(tempsensor2),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dampedoutdoortemp_, DeviceValueType::INT, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dampedoutdoortemp_, DeviceValueType::INT8, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaBuildingType_, &ibaBuildingType_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -4246,13 +4246,13 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDisinfectDay)); MAKE_CF_CB(set_wwDisinfectDay));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfectHour_, &wwDisinfectHour_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwDisinfectHour), FL_(wwDisinfectHour),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_wwDisinfectHour), MAKE_CF_CB(set_wwDisinfectHour),
0, 0,
23); 23);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT8, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp));
register_device_value(DeviceValueTAG::TAG_DHW1, &wwOneTimeKey_, DeviceValueType::BOOL, FL_(wwOneTimeKey), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwOneTimeKey)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwOneTimeKey_, DeviceValueType::BOOL, FL_(wwOneTimeKey), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwOneTimeKey));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwSwitchTime_, &wwSwitchTime_,
@@ -4293,7 +4293,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_datetime)); MAKE_CF_CB(set_datetime));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaCalIntTemperature_, &ibaCalIntTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(ibaCalIntTemperature), FL_(ibaCalIntTemperature),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -4302,7 +4302,7 @@ void Thermostat::register_device_values() {
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaMinExtTemperature_, &ibaMinExtTemperature_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(ibaMinExtTemperature), FL_(ibaMinExtTemperature),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_minexttemp), MAKE_CF_CB(set_minexttemp),
@@ -4310,18 +4310,18 @@ void Thermostat::register_device_values() {
0); 0);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempsensor1_, &tempsensor1_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempsensor1), FL_(tempsensor1),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempsensor2_, &tempsensor2_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(tempsensor2), FL_(tempsensor2),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ibaDamping_, DeviceValueType::BOOL, FL_(damping), DeviceValueUOM::NONE, MAKE_CF_CB(set_damping));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dampedoutdoortemp_, DeviceValueType::INT, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dampedoutdoortemp_, DeviceValueType::INT8, FL_(dampedoutdoortemp), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&ibaBuildingType_, &ibaBuildingType_,
DeviceValueType::ENUM, DeviceValueType::ENUM,
@@ -4366,14 +4366,14 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_wwDisinfectDay)); MAKE_CF_CB(set_wwDisinfectDay));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwDisinfectHour_, &wwDisinfectHour_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(wwDisinfectHour), FL_(wwDisinfectHour),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_wwDisinfectHour), MAKE_CF_CB(set_wwDisinfectHour),
0, 0,
23); 23);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp), 60, 80); DeviceValueTAG::TAG_DHW1, &wwMaxTemp_, DeviceValueType::UINT8, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp), 60, 80);
register_device_value(DeviceValueTAG::TAG_DHW1, &wwOneTimeKey_, DeviceValueType::BOOL, FL_(wwOneTimeKey), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwOneTimeKey)); register_device_value(DeviceValueTAG::TAG_DHW1, &wwOneTimeKey_, DeviceValueType::BOOL, FL_(wwOneTimeKey), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwOneTimeKey));
register_device_value(DeviceValueTAG::TAG_DHW1, register_device_value(DeviceValueTAG::TAG_DHW1,
&wwSwitchTime_, &wwSwitchTime_,
@@ -4427,7 +4427,7 @@ void Thermostat::register_device_values() {
MAKE_CF_CB(set_hybridStrategy)); MAKE_CF_CB(set_hybridStrategy));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&switchOverTemp_, &switchOverTemp_,
DeviceValueType::INT, DeviceValueType::INT8,
FL_(switchOverTemp), FL_(switchOverTemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_switchOverTemp), MAKE_CF_CB(set_switchOverTemp),
@@ -4435,7 +4435,7 @@ void Thermostat::register_device_values() {
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&energyCostRatio_, &energyCostRatio_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(energyCostRatio), FL_(energyCostRatio),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4444,7 +4444,7 @@ void Thermostat::register_device_values() {
20); 20);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&fossileFactor_, &fossileFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(fossileFactor), FL_(fossileFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4453,7 +4453,7 @@ void Thermostat::register_device_values() {
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&electricFactor_, &electricFactor_,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(electricFactor), FL_(electricFactor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
@@ -4462,7 +4462,7 @@ void Thermostat::register_device_values() {
5); 5);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&delayBoiler_, &delayBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(delayBoiler), FL_(delayBoiler),
DeviceValueUOM::MINUTES, DeviceValueUOM::MINUTES,
MAKE_CF_CB(set_delayBoiler), MAKE_CF_CB(set_delayBoiler),
@@ -4470,7 +4470,7 @@ void Thermostat::register_device_values() {
120); 120);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&tempDiffBoiler_, &tempDiffBoiler_,
DeviceValueType::UINT, DeviceValueType::UINT8,
FL_(tempDiffBoiler), FL_(tempDiffBoiler),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
MAKE_CF_CB(set_tempDiffBoiler), MAKE_CF_CB(set_tempDiffBoiler),
@@ -4519,22 +4519,22 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
} }
if (has_flags(EMSdevice::EMS_DEVICE_FLAG_NO_WRITE)) { if (has_flags(EMSdevice::EMS_DEVICE_FLAG_NO_WRITE)) {
register_device_value(tag, &hc->selTemp, DeviceValueType::SHORT, seltemp_divider, FL_(selRoomTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->selTemp, DeviceValueType::INT16, seltemp_divider, FL_(selRoomTemp), DeviceValueUOM::DEGREES);
} else { } else {
register_device_value(tag, &hc->selTemp, DeviceValueType::SHORT, seltemp_divider, FL_(selRoomTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 0, 30); register_device_value(tag, &hc->selTemp, DeviceValueType::INT16, seltemp_divider, FL_(selRoomTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_temp), 0, 30);
} }
register_device_value(tag, &hc->roomTemp, DeviceValueType::SHORT, roomtemp_divider, FL_(roomTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->roomTemp, DeviceValueType::INT16, roomtemp_divider, FL_(roomTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &hc->climate, DeviceValueType::ENUM, FL_(enum_climate), FL_(haclimate), DeviceValueUOM::NONE, nullptr, 5, 30); register_device_value(tag, &hc->climate, DeviceValueType::ENUM, FL_(enum_climate), FL_(haclimate), DeviceValueUOM::NONE, nullptr, 5, 30);
switch (model) { switch (model) {
case EMSdevice::EMS_DEVICE_FLAG_RC10: case EMSdevice::EMS_DEVICE_FLAG_RC10:
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode6), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode6), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp));
register_device_value(tag, &hc->reducehours, DeviceValueType::UINT, FL_(reducehours), DeviceValueUOM::HOURS, MAKE_CF_CB(set_reducehours)); register_device_value(tag, &hc->reducehours, DeviceValueType::UINT8, FL_(reducehours), DeviceValueUOM::HOURS, MAKE_CF_CB(set_reducehours));
register_device_value(tag, &hc->reduceminutes, DeviceValueType::USHORT, FL_(reduceminutes), DeviceValueUOM::MINUTES); register_device_value(tag, &hc->reduceminutes, DeviceValueType::UINT16, FL_(reduceminutes), DeviceValueUOM::MINUTES);
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC100: case EMSdevice::EMS_DEVICE_FLAG_RC100:
case EMSdevice::EMS_DEVICE_FLAG_RC300: case EMSdevice::EMS_DEVICE_FLAG_RC300:
@@ -4546,29 +4546,29 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
} }
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype), FL_(modetype), DeviceValueUOM::NONE);
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(ecotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ecotemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(ecotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ecotemp));
register_device_value( register_device_value(
tag, &hc->manualtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp)); tag, &hc->manualtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp));
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(comforttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_comforttemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(comforttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_comforttemp));
register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 10, 30); register_device_value(tag, &hc->summertemp, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 10, 30);
register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp)); register_device_value(tag, &hc->designtemp, DeviceValueType::UINT8, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp));
register_device_value(tag, &hc->offsettemp, DeviceValueType::INT, FL_(offsettemp), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_offsettemp)); register_device_value(tag, &hc->offsettemp, DeviceValueType::INT8, FL_(offsettemp), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_offsettemp));
register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp)); register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT8, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp));
register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp)); register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT8, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp));
register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, FL_(roominfluence), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_roominfluence)); register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT8, FL_(roominfluence), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_roominfluence));
register_device_value(tag, register_device_value(tag,
&hc->roominfl_factor, &hc->roominfl_factor,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(roominfl_factor), FL_(roominfl_factor),
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_roominfl_factor)); MAKE_CF_CB(set_roominfl_factor));
register_device_value(tag, &hc->curroominfl, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(curroominfl), DeviceValueUOM::DEGREES_R); register_device_value(tag, &hc->curroominfl, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(curroominfl), DeviceValueUOM::DEGREES_R);
register_device_value( register_device_value(
tag, &hc->nofrostmode, DeviceValueType::ENUM, FL_(enum_nofrostmode1), FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrostmode)); tag, &hc->nofrostmode, DeviceValueType::ENUM, FL_(enum_nofrostmode1), FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrostmode));
register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp)); register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT8, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp));
register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, FL_(targetflowtemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT8, FL_(targetflowtemp), DeviceValueUOM::DEGREES);
register_device_value( register_device_value(
tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype)); tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype));
register_device_value( register_device_value(
@@ -4592,16 +4592,16 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, register_device_value(tag,
&hc->tempautotemp, &hc->tempautotemp,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(tempautotemp), FL_(tempautotemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_tempautotemp), MAKE_CF_CB(set_tempautotemp),
-1, -1,
30); 30);
register_device_value(tag, &hc->remoteseltemp, DeviceValueType::INT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(remoteseltemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->remoteseltemp, DeviceValueType::INT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(remoteseltemp), DeviceValueUOM::DEGREES);
// a command is only accepted from the remote device, not from ems-esp. // a command is only accepted from the remote device, not from ems-esp.
register_device_value(tag, &hc->fastHeatup, DeviceValueType::UINT, FL_(fastheatup), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_fastheatup)); register_device_value(tag, &hc->fastHeatup, DeviceValueType::UINT8, FL_(fastheatup), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_fastheatup));
register_device_value(tag, register_device_value(tag,
&hc->switchonoptimization, &hc->switchonoptimization,
DeviceValueType::BOOL, DeviceValueType::BOOL,
@@ -4609,53 +4609,53 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_switchonoptimization)); MAKE_CF_CB(set_switchonoptimization));
register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode1), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode)); register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode1), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode));
register_device_value(tag, &hc->noreducetemp, DeviceValueType::INT, FL_(noreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_noreducetemp)); register_device_value(tag, &hc->noreducetemp, DeviceValueType::INT8, FL_(noreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_noreducetemp));
register_device_value(tag, &hc->reducetemp, DeviceValueType::INT, FL_(reducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_reducetemp)); register_device_value(tag, &hc->reducetemp, DeviceValueType::INT8, FL_(reducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_reducetemp));
register_device_value(tag, &hc->wwprio, DeviceValueType::BOOL, FL_(wwprio), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwprio)); register_device_value(tag, &hc->wwprio, DeviceValueType::BOOL, FL_(wwprio), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwprio));
register_device_value(tag, &hc->cooling, DeviceValueType::BOOL, FL_(hpcooling), DeviceValueUOM::NONE, MAKE_CF_CB(set_cooling)); register_device_value(tag, &hc->cooling, DeviceValueType::BOOL, FL_(hpcooling), DeviceValueUOM::NONE, MAKE_CF_CB(set_cooling));
register_device_value(tag, &hc->coolingon, DeviceValueType::BOOL, FL_(coolingOn), DeviceValueUOM::NONE); register_device_value(tag, &hc->coolingon, DeviceValueType::BOOL, FL_(coolingOn), DeviceValueUOM::NONE);
register_device_value(tag, &hc->hpmode, DeviceValueType::ENUM, FL_(enum_hpmode), FL_(hpmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_hpmode)); register_device_value(tag, &hc->hpmode, DeviceValueType::ENUM, FL_(enum_hpmode), FL_(hpmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_hpmode));
register_device_value(tag, &hc->dewoffset, DeviceValueType::UINT, FL_(dewoffset), DeviceValueUOM::K, MAKE_CF_CB(set_dewoffset), 2, 10); register_device_value(tag, &hc->dewoffset, DeviceValueType::UINT8, FL_(dewoffset), DeviceValueUOM::K, MAKE_CF_CB(set_dewoffset), 2, 10);
register_device_value(tag, &hc->roomtempdiff, DeviceValueType::UINT, FL_(roomtempdiff), DeviceValueUOM::K, MAKE_CF_CB(set_roomtempdiff)); register_device_value(tag, &hc->roomtempdiff, DeviceValueType::UINT8, FL_(roomtempdiff), DeviceValueUOM::K, MAKE_CF_CB(set_roomtempdiff));
register_device_value(tag, &hc->hpminflowtemp, DeviceValueType::UINT, FL_(hpminflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_hpminflowtemp)); register_device_value(tag, &hc->hpminflowtemp, DeviceValueType::UINT8, FL_(hpminflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_hpminflowtemp));
register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control1), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control)); register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control1), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control));
register_device_value(tag, register_device_value(tag,
&hc->remotetemp, &hc->remotetemp,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(remotetemp), FL_(remotetemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_remotetemp), MAKE_CF_CB(set_remotetemp),
-1, -1,
101); 101);
register_device_value(tag, &hc->remotehum, DeviceValueType::UINT, FL_(remotehum), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_remotehum), -1, 101); register_device_value(tag, &hc->remotehum, DeviceValueType::UINT8, FL_(remotehum), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_remotehum), -1, 101);
register_device_value(tag, &hc->heatondelay, DeviceValueType::UINT, FL_(heatondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatondelay), 1, 48); register_device_value(tag, &hc->heatondelay, DeviceValueType::UINT8, FL_(heatondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatondelay), 1, 48);
register_device_value(tag, &hc->heatoffdelay, DeviceValueType::UINT, FL_(heatoffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatoffdelay), 1, 48); register_device_value(tag, &hc->heatoffdelay, DeviceValueType::UINT8, FL_(heatoffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatoffdelay), 1, 48);
register_device_value(tag, &hc->instantstart, DeviceValueType::UINT, FL_(instantstart), DeviceValueUOM::K, MAKE_CF_CB(set_instantstart), 1, 10); register_device_value(tag, &hc->instantstart, DeviceValueType::UINT8, FL_(instantstart), DeviceValueUOM::K, MAKE_CF_CB(set_instantstart), 1, 10);
register_device_value(tag, &hc->boost, DeviceValueType::BOOL, FL_(boost), DeviceValueUOM::NONE, MAKE_CF_CB(set_boost)); register_device_value(tag, &hc->boost, DeviceValueType::BOOL, FL_(boost), DeviceValueUOM::NONE, MAKE_CF_CB(set_boost));
register_device_value(tag, &hc->boosttime, DeviceValueType::UINT, FL_(boosttime), DeviceValueUOM::HOURS, MAKE_CF_CB(set_boosttime)); register_device_value(tag, &hc->boosttime, DeviceValueType::UINT8, FL_(boosttime), DeviceValueUOM::HOURS, MAKE_CF_CB(set_boosttime));
break; break;
case EMSdevice::EMS_DEVICE_FLAG_CRF: case EMSdevice::EMS_DEVICE_FLAG_CRF:
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode5), FL_(mode), DeviceValueUOM::NONE); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode5), FL_(mode), DeviceValueUOM::NONE);
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype5), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype5), FL_(modetype), DeviceValueUOM::NONE);
register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, FL_(targetflowtemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT8, FL_(targetflowtemp), DeviceValueUOM::DEGREES);
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC20: case EMSdevice::EMS_DEVICE_FLAG_RC20:
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value( register_device_value(
tag, &hc->manualtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp)); tag, &hc->manualtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp));
register_device_value( register_device_value(
tag, &hc->nofrosttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(offtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_offtemp)); tag, &hc->nofrosttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(offtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_offtemp));
register_device_value( register_device_value(
tag, &hc->daylowtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daylowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daylowtemp)); tag, &hc->daylowtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daylowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daylowtemp));
register_device_value( register_device_value(
tag, &hc->daymidtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daymidtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daymidtemp)); tag, &hc->daymidtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daymidtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daymidtemp));
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(dayhightemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(dayhightemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp2), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp2), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp));
register_device_value( register_device_value(
tag, &hc->switchtime1, DeviceValueType::STRING, FL_(tpl_switchtime1), FL_(switchtime), DeviceValueUOM::NONE, MAKE_CF_CB(set_switchtime1)); tag, &hc->switchtime1, DeviceValueType::STRING, FL_(tpl_switchtime1), FL_(switchtime), DeviceValueUOM::NONE, MAKE_CF_CB(set_switchtime1));
break; break;
@@ -4663,45 +4663,45 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE);
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp));
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode3), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode3), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp)); register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT8, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp));
register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp)); register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT8, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp));
register_device_value(tag, register_device_value(tag,
&hc->tempautotemp, &hc->tempautotemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(tempautotemp), FL_(tempautotemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_tempautotemp)); MAKE_CF_CB(set_tempautotemp));
register_device_value( register_device_value(
tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype)); tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype));
register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 10, 30); register_device_value(tag, &hc->summertemp, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 10, 30);
register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE); register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE);
register_device_value(tag, &hc->remotetemp, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->remotetemp, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(remotetemp), DeviceValueUOM::DEGREES);
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC25: case EMSdevice::EMS_DEVICE_FLAG_RC25:
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE);
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp));
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode3), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode3), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp)); register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT8, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp));
register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp)); register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT8, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp));
register_device_value(tag, register_device_value(tag,
&hc->tempautotemp, &hc->tempautotemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(tempautotemp), FL_(tempautotemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_tempautotemp)); MAKE_CF_CB(set_tempautotemp));
register_device_value( register_device_value(
tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype)); tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype));
register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25); register_device_value(tag, &hc->summertemp, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25);
register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE); register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE);
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC30: case EMSdevice::EMS_DEVICE_FLAG_RC30:
@@ -4709,8 +4709,8 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->holiday, DeviceValueType::STRING, FL_(tpl_holidays), FL_(holidays), DeviceValueUOM::NONE, MAKE_CF_CB(set_holiday)); register_device_value(tag, &hc->holiday, DeviceValueType::STRING, FL_(tpl_holidays), FL_(holidays), DeviceValueUOM::NONE, MAKE_CF_CB(set_holiday));
register_device_value(tag, &hc->vacation, DeviceValueType::STRING, FL_(tpl_holidays), FL_(vacations), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacation)); register_device_value(tag, &hc->vacation, DeviceValueType::STRING, FL_(tpl_holidays), FL_(vacations), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacation));
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode2), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode2), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, &hc->pause, DeviceValueType::UINT, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause)); register_device_value(tag, &hc->pause, DeviceValueType::UINT8, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause));
register_device_value(tag, &hc->party, DeviceValueType::UINT, FL_(party), DeviceValueUOM::HOURS, MAKE_CF_CB(set_party)); register_device_value(tag, &hc->party, DeviceValueType::UINT8, FL_(party), DeviceValueUOM::HOURS, MAKE_CF_CB(set_party));
register_device_value( register_device_value(
tag, &hc->switchtime1, DeviceValueType::STRING, FL_(tpl_switchtime1), FL_(switchtime1), DeviceValueUOM::NONE, MAKE_CF_CB(set_switchtime1)); tag, &hc->switchtime1, DeviceValueType::STRING, FL_(tpl_switchtime1), FL_(switchtime1), DeviceValueUOM::NONE, MAKE_CF_CB(set_switchtime1));
register_device_value( register_device_value(
@@ -4719,43 +4719,43 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode)); tag, &hc->controlmode, DeviceValueType::ENUM, FL_(enum_controlmode2), FL_(controlmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_controlmode));
register_device_value(tag, register_device_value(tag,
&hc->holidaytemp, &hc->holidaytemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(holidaytemp), FL_(holidaytemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_holidaytemp)); MAKE_CF_CB(set_holidaytemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp2), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(nighttemp2), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nighttemp));
register_device_value( register_device_value(
tag, &hc->daylowtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daylowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daylowtemp)); tag, &hc->daylowtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daylowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daylowtemp));
register_device_value( register_device_value(
tag, &hc->daymidtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daymidtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daymidtemp)); tag, &hc->daymidtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daymidtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daymidtemp));
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(dayhightemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(dayhightemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp));
register_device_value( register_device_value(
tag, &hc->manualtemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp)); tag, &hc->manualtemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(manualtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_manualtemp));
register_device_value( register_device_value(
tag, &hc->nofrosttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(offtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_offtemp)); tag, &hc->nofrosttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(offtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_offtemp));
break; break;
case EMSdevice::EMS_DEVICE_FLAG_RC30_N: case EMSdevice::EMS_DEVICE_FLAG_RC30_N:
case EMSdevice::EMS_DEVICE_FLAG_RC35: case EMSdevice::EMS_DEVICE_FLAG_RC35:
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode3), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype3), FL_(modetype), DeviceValueUOM::NONE);
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp), 10, 30); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(daytemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_daytemp), 10, 30);
register_device_value(tag, register_device_value(tag,
&hc->nighttemp, &hc->nighttemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(nighttemp), FL_(nighttemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_nighttemp), MAKE_CF_CB(set_nighttemp),
10, 10,
30); 30);
register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp), 30, 90); register_device_value(tag, &hc->designtemp, DeviceValueType::UINT8, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp), 30, 90);
register_device_value(tag, register_device_value(tag,
&hc->offsettemp, &hc->offsettemp,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(offsettemp), FL_(offsettemp),
DeviceValueUOM::DEGREES_R, DeviceValueUOM::DEGREES_R,
@@ -4764,24 +4764,24 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
5); 5);
register_device_value(tag, register_device_value(tag,
&hc->holidaytemp, &hc->holidaytemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(holidaytemp), FL_(holidaytemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_holidaytemp), MAKE_CF_CB(set_holidaytemp),
5, 5,
30); 30);
register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, FL_(targetflowtemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT8, FL_(targetflowtemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25); register_device_value(tag, &hc->summertemp, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25);
register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE); register_device_value(tag, &hc->summermode, DeviceValueType::ENUM, FL_(enum_summer), FL_(summermode), DeviceValueUOM::NONE);
register_device_value(tag, &hc->holidaymode, DeviceValueType::BOOL, FL_(holidaymode), DeviceValueUOM::NONE); register_device_value(tag, &hc->holidaymode, DeviceValueType::BOOL, FL_(holidaymode), DeviceValueUOM::NONE);
register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp), -20, 10); register_device_value(tag, &hc->nofrosttemp, DeviceValueType::INT8, FL_(nofrosttemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_nofrosttemp), -20, 10);
register_device_value( register_device_value(
tag, &hc->nofrostmode, DeviceValueType::ENUM, FL_(enum_nofrostmode), FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrostmode)); tag, &hc->nofrostmode, DeviceValueType::ENUM, FL_(enum_nofrostmode), FL_(nofrostmode), DeviceValueUOM::NONE, MAKE_CF_CB(set_nofrostmode));
register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT, FL_(roominfluence), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_roominfluence), 0, 10); register_device_value(tag, &hc->roominfluence, DeviceValueType::UINT8, FL_(roominfluence), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_roominfluence), 0, 10);
register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp), 5, 70); register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT8, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp), 5, 70);
register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp), 30, 90); register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT8, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp), 30, 90);
register_device_value(tag, &hc->flowtempoffset, DeviceValueType::UINT, FL_(flowtempoffset), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_flowtempoffset), 0, 20); register_device_value(tag, &hc->flowtempoffset, DeviceValueType::UINT8, FL_(flowtempoffset), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_flowtempoffset), 0, 20);
register_device_value( register_device_value(
tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype)); tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype));
register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode)); register_device_value(tag, &hc->reducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(reducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_reducemode));
@@ -4791,25 +4791,25 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->holiday, DeviceValueType::STRING, FL_(tpl_holidays), FL_(holidays), DeviceValueUOM::NONE, MAKE_CF_CB(set_holiday)); register_device_value(tag, &hc->holiday, DeviceValueType::STRING, FL_(tpl_holidays), FL_(holidays), DeviceValueUOM::NONE, MAKE_CF_CB(set_holiday));
register_device_value(tag, &hc->vacation, DeviceValueType::STRING, FL_(tpl_holidays), FL_(vacations), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacation)); register_device_value(tag, &hc->vacation, DeviceValueType::STRING, FL_(tpl_holidays), FL_(vacations), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacation));
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode2), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode2), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, &hc->pause, DeviceValueType::UINT, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause), 0, 99); register_device_value(tag, &hc->pause, DeviceValueType::UINT8, FL_(pause), DeviceValueUOM::HOURS, MAKE_CF_CB(set_pause), 0, 99);
register_device_value(tag, &hc->party, DeviceValueType::UINT, FL_(party), DeviceValueUOM::HOURS, MAKE_CF_CB(set_party), 0, 99); register_device_value(tag, &hc->party, DeviceValueType::UINT8, FL_(party), DeviceValueUOM::HOURS, MAKE_CF_CB(set_party), 0, 99);
register_device_value(tag, register_device_value(tag,
&hc->tempautotemp, &hc->tempautotemp,
DeviceValueType::UINT, DeviceValueType::UINT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(tempautotemp), FL_(tempautotemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_tempautotemp), MAKE_CF_CB(set_tempautotemp),
0, 0,
30); 30);
register_device_value(tag, &hc->noreducetemp, DeviceValueType::INT, FL_(noreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_noreducetemp), -31, 10); register_device_value(tag, &hc->noreducetemp, DeviceValueType::INT8, FL_(noreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_noreducetemp), -31, 10);
register_device_value(tag, &hc->reducetemp, DeviceValueType::INT, FL_(reducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_reducetemp), -20, 10); register_device_value(tag, &hc->reducetemp, DeviceValueType::INT8, FL_(reducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_reducetemp), -20, 10);
register_device_value(tag, &hc->vacreducetemp, DeviceValueType::INT, FL_(vacreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_vacreducetemp), -20, 10); register_device_value(tag, &hc->vacreducetemp, DeviceValueType::INT8, FL_(vacreducetemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_vacreducetemp), -20, 10);
register_device_value( register_device_value(
tag, &hc->vacreducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(vacreducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacreducemode)); tag, &hc->vacreducemode, DeviceValueType::ENUM, FL_(enum_reducemode), FL_(vacreducemode), DeviceValueUOM::NONE, MAKE_CF_CB(set_vacreducemode));
register_device_value(tag, register_device_value(tag,
&hc->remotetemp, &hc->remotetemp,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(remotetemp), FL_(remotetemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
@@ -4832,12 +4832,12 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode)); register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype4), FL_(modetype), DeviceValueUOM::NONE); register_device_value(tag, &hc->modetype, DeviceValueType::ENUM, FL_(enum_modetype4), FL_(modetype), DeviceValueUOM::NONE);
register_device_value( register_device_value(
tag, &hc->daytemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(heattemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heattemp)); tag, &hc->daytemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(heattemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_heattemp));
register_device_value( register_device_value(
tag, &hc->nighttemp, DeviceValueType::UINT, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(ecotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ecotemp)); tag, &hc->nighttemp, DeviceValueType::UINT8, DeviceValueNumOp::DV_NUMOP_DIV2, FL_(ecotemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_ecotemp));
register_device_value(tag, register_device_value(tag,
&hc->nofrosttemp, &hc->nofrosttemp,
DeviceValueType::INT, DeviceValueType::INT8,
DeviceValueNumOp::DV_NUMOP_DIV2, DeviceValueNumOp::DV_NUMOP_DIV2,
FL_(nofrosttemp), FL_(nofrosttemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
@@ -4846,15 +4846,15 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode4), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program)); register_device_value(tag, &hc->program, DeviceValueType::ENUM, FL_(enum_progMode4), FL_(program), DeviceValueUOM::NONE, MAKE_CF_CB(set_program));
register_device_value(tag, register_device_value(tag,
&hc->remotetemp, &hc->remotetemp,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(remotetemp), FL_(remotetemp),
DeviceValueUOM::DEGREES, DeviceValueUOM::DEGREES,
MAKE_CF_CB(set_remotetemp), MAKE_CF_CB(set_remotetemp),
-1, -1,
101); 101);
register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT, FL_(targetflowtemp), DeviceValueUOM::DEGREES); register_device_value(tag, &hc->targetflowtemp, DeviceValueType::UINT8, FL_(targetflowtemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &hc->summertemp, DeviceValueType::UINT, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25); register_device_value(tag, &hc->summertemp, DeviceValueType::UINT8, FL_(summertemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_summertemp), 9, 25);
register_device_value(tag, &hc->roomsensor, DeviceValueType::ENUM, FL_(enum_roomsensor), FL_(roomsensor), DeviceValueUOM::NONE, MAKE_CF_CB(set_roomsensor)); register_device_value(tag, &hc->roomsensor, DeviceValueType::ENUM, FL_(enum_roomsensor), FL_(roomsensor), DeviceValueUOM::NONE, MAKE_CF_CB(set_roomsensor));
register_device_value(tag, &hc->holidaymode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(holidaymode), DeviceValueUOM::NONE, MAKE_CF_CB(set_holidaymode)); register_device_value(tag, &hc->holidaymode, DeviceValueType::ENUM, FL_(enum_mode4), FL_(holidaymode), DeviceValueUOM::NONE, MAKE_CF_CB(set_holidaymode));
register_device_value(tag, register_device_value(tag,
@@ -4864,12 +4864,12 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
DeviceValueUOM::NONE, DeviceValueUOM::NONE,
MAKE_CF_CB(set_switchonoptimization)); MAKE_CF_CB(set_switchonoptimization));
register_device_value(tag, &hc->fastHeatup, DeviceValueType::ENUM, FL_(enum_heatup), FL_(heatup), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatup)); register_device_value(tag, &hc->fastHeatup, DeviceValueType::ENUM, FL_(enum_heatup), FL_(heatup), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatup));
register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp), 5, 70); register_device_value(tag, &hc->minflowtemp, DeviceValueType::UINT8, FL_(minflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_minflowtemp), 5, 70);
register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp), 30, 90); register_device_value(tag, &hc->maxflowtemp, DeviceValueType::UINT8, FL_(maxflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_maxflowtemp), 30, 90);
register_device_value(tag, &hc->designtemp, DeviceValueType::UINT, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp), 30, 90); register_device_value(tag, &hc->designtemp, DeviceValueType::UINT8, FL_(designtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_designtemp), 30, 90);
register_device_value( register_device_value(
tag, &hc->roominfluence, DeviceValueType::ENUM, FL_(enum_roominfluence), FL_(roominfluence), DeviceValueUOM::NONE, MAKE_CF_CB(set_roominfl_mode)); tag, &hc->roominfluence, DeviceValueType::ENUM, FL_(enum_roominfluence), FL_(roominfluence), DeviceValueUOM::NONE, MAKE_CF_CB(set_roominfl_mode));
register_device_value(tag, &hc->roominfl_factor, DeviceValueType::UINT, FL_(roominfl_factor), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_roominfl_factor)); register_device_value(tag, &hc->roominfl_factor, DeviceValueType::UINT8, FL_(roominfl_factor), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_roominfl_factor));
register_device_value( register_device_value(
tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype1), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype)); tag, &hc->heatingtype, DeviceValueType::ENUM, FL_(enum_heatingtype1), FL_(heatingtype), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatingtype));
register_device_value( register_device_value(

16
src/devices/ventilation.cpp
View File

@@ -34,19 +34,19 @@ Ventilation::Ventilation(uint8_t device_type, uint8_t device_id, uint8_t product
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
&outFresh_, &outFresh_,
DeviceValueType::SHORT, DeviceValueType::INT16,
DeviceValueNumOp::DV_NUMOP_DIV10, DeviceValueNumOp::DV_NUMOP_DIV10,
FL_(outFresh), FL_(outFresh),
DeviceValueUOM::DEGREES); DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &inFresh_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(inFresh), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &inFresh_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(inFresh), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &outEx_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(outEx), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &outEx_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(outEx), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &inEx_, DeviceValueType::SHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(inEx), DeviceValueUOM::DEGREES); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &inEx_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(inEx), DeviceValueUOM::DEGREES);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ventInSpeed_, DeviceValueType::UINT, FL_(ventInSpeed), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ventInSpeed_, DeviceValueType::UINT8, FL_(ventInSpeed), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ventOutSpeed_, DeviceValueType::UINT, FL_(ventOutSpeed), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &ventOutSpeed_, DeviceValueType::UINT8, FL_(ventOutSpeed), DeviceValueUOM::PERCENT);
register_device_value( register_device_value(
DeviceValueTAG::TAG_DEVICE_DATA, &mode_, DeviceValueType::ENUM, FL_(enum_ventMode), FL_(ventMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_ventMode)); DeviceValueTAG::TAG_DEVICE_DATA, &mode_, DeviceValueType::ENUM, FL_(enum_ventMode), FL_(ventMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_ventMode));
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &voc_, DeviceValueType::USHORT, FL_(airquality), DeviceValueUOM::NONE); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &voc_, DeviceValueType::UINT16, FL_(airquality), DeviceValueUOM::NONE);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &humidity_, DeviceValueType::UINT, FL_(airHumidity), DeviceValueUOM::PERCENT); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &humidity_, DeviceValueType::UINT8, FL_(airHumidity), DeviceValueUOM::PERCENT);
register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &bypass_, DeviceValueType::BOOL, FL_(bypass), DeviceValueUOM::NONE, MAKE_CF_CB(set_bypass)); register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &bypass_, DeviceValueType::BOOL, FL_(bypass), DeviceValueUOM::NONE, MAKE_CF_CB(set_bypass));
} }

60
src/devices/water.cpp
View File

@@ -40,27 +40,27 @@ Water::Water(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_telegram_type(0x07E0, "SM100wwStatus2", true, MAKE_PF_CB(process_SM100wwStatus2)); register_telegram_type(0x07E0, "SM100wwStatus2", true, MAKE_PF_CB(process_SM100wwStatus2));
register_telegram_type(0x07AD, "SM100ValveStatus", false, MAKE_PF_CB(process_SM100ValveStatus)); register_telegram_type(0x07AD, "SM100ValveStatus", false, MAKE_PF_CB(process_SM100ValveStatus));
// device values... // device values...
register_device_value(tag, &wwTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwTemp2_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwStorageTemp1), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp2_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwStorageTemp1), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwColdTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwColdTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &wwColdTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwColdTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwTemp_5_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp5), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp_5_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp5), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwRetTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &wwRetTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(retTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE); register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE);
register_device_value(tag, &wwMaxTemp_, DeviceValueType::UINT, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp)); register_device_value(tag, &wwMaxTemp_, DeviceValueType::UINT8, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp));
register_device_value(tag, &wwSelTemp_, DeviceValueType::UINT, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwSelTemp)); register_device_value(tag, &wwSelTemp_, DeviceValueType::UINT8, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwSelTemp));
register_device_value(tag, &wwRedTemp_, DeviceValueType::UINT, FL_(wwRedTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRedTemp)); register_device_value(tag, &wwRedTemp_, DeviceValueType::UINT8, FL_(wwRedTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRedTemp));
register_device_value(tag, &wwHotTemp_, DeviceValueType::UINT, FL_(wwHotTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwHotTemp)); register_device_value(tag, &wwHotTemp_, DeviceValueType::UINT8, FL_(wwHotTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwHotTemp));
register_device_value(tag, &wwDailyTemp_, DeviceValueType::UINT, FL_(wwDailyTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDailyTemp)); register_device_value(tag, &wwDailyTemp_, DeviceValueType::UINT8, FL_(wwDailyTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDailyTemp));
register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp)); register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT8, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp));
register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc)); register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc));
register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode)); register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_freq), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode));
register_device_value(tag, &wwCircTc_, DeviceValueType::BOOL, FL_(wwCircTc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircTc)); register_device_value(tag, &wwCircTc_, DeviceValueType::BOOL, FL_(wwCircTc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircTc));
register_device_value(tag, &wwKeepWarm_, DeviceValueType::BOOL, FL_(wwKeepWarm), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwKeepWarm)); register_device_value(tag, &wwKeepWarm_, DeviceValueType::BOOL, FL_(wwKeepWarm), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwKeepWarm));
register_device_value(tag, &wwStatus2_, DeviceValueType::ENUM, FL_(enum_wwStatus2), FL_(wwStatus2), DeviceValueUOM::NONE); register_device_value(tag, &wwStatus2_, DeviceValueType::ENUM, FL_(enum_wwStatus2), FL_(wwStatus2), DeviceValueUOM::NONE);
register_device_value(tag, &wwPumpMod_, DeviceValueType::UINT, FL_(wwPumpMod), DeviceValueUOM::PERCENT); register_device_value(tag, &wwPumpMod_, DeviceValueType::UINT8, FL_(wwPumpMod), DeviceValueUOM::PERCENT);
register_device_value(tag, &wwFlow_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwFlow), DeviceValueUOM::LMIN); register_device_value(tag, &wwFlow_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwFlow), DeviceValueUOM::LMIN);
register_device_value(tag, &wwRetValve_, DeviceValueType::UINT, FL_(valveReturn), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_wwRetValve)); register_device_value(tag, &wwRetValve_, DeviceValueType::UINT8, FL_(valveReturn), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_wwRetValve));
register_device_value(tag, &wwDeltaTRet_, DeviceValueType::UINT, FL_(deltaTRet), DeviceValueUOM::K, MAKE_CF_CB(set_wwDeltaTRet)); register_device_value(tag, &wwDeltaTRet_, DeviceValueType::UINT8, FL_(deltaTRet), DeviceValueUOM::K, MAKE_CF_CB(set_wwDeltaTRet));
register_device_value(tag, &errorDisp_, DeviceValueType::ENUM, FL_(enum_errorDisp), FL_(errorDisp), DeviceValueUOM::NONE, MAKE_CF_CB(set_errorDisp)); register_device_value(tag, &errorDisp_, DeviceValueType::ENUM, FL_(enum_errorDisp), FL_(errorDisp), DeviceValueUOM::NONE, MAKE_CF_CB(set_errorDisp));
} else if (device_id >= EMSdevice::EMS_DEVICE_ID_DHW1 && device_id <= EMSdevice::EMS_DEVICE_ID_DHW2) { } else if (device_id >= EMSdevice::EMS_DEVICE_ID_DHW1 && device_id <= EMSdevice::EMS_DEVICE_ID_DHW2) {
@@ -69,14 +69,14 @@ Water::Water(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_telegram_type(0x313 + dhw_, "MMPLUSConfigMessage_WWC", true, MAKE_PF_CB(process_MMPLUSConfigMessage_WWC)); register_telegram_type(0x313 + dhw_, "MMPLUSConfigMessage_WWC", true, MAKE_PF_CB(process_MMPLUSConfigMessage_WWC));
// register_telegram_type(0x33B + type_offset, "MMPLUSSetMessage_WWC", true, MAKE_PF_CB(process_MMPLUSSetMessage_WWC)); // register_telegram_type(0x33B + type_offset, "MMPLUSSetMessage_WWC", true, MAKE_PF_CB(process_MMPLUSSetMessage_WWC));
// device values... // device values...
register_device_value(tag, &wwTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwStatus_, DeviceValueType::INT, FL_(wwTempStatus), DeviceValueUOM::NONE); register_device_value(tag, &wwStatus_, DeviceValueType::INT8, FL_(wwTempStatus), DeviceValueUOM::NONE);
register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE); register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE);
register_device_value(tag, &wwMaxTemp_, DeviceValueType::UINT, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp)); register_device_value(tag, &wwMaxTemp_, DeviceValueType::UINT8, FL_(wwMaxTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwMaxTemp));
register_device_value(tag, &wwDiffTemp_, DeviceValueType::INT, FL_(wwDiffTemp), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwDiffTemp)); register_device_value(tag, &wwDiffTemp_, DeviceValueType::INT8, FL_(wwDiffTemp), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwDiffTemp));
register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp)); register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT8, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp));
register_device_value(tag, &wwRedTemp_, DeviceValueType::UINT, FL_(wwRedTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRedTemp)); register_device_value(tag, &wwRedTemp_, DeviceValueType::UINT8, FL_(wwRedTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRedTemp));
register_device_value(tag, &wwRequiredTemp_, DeviceValueType::UINT, FL_(wwRequiredTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRequiredTemp)); register_device_value(tag, &wwRequiredTemp_, DeviceValueType::UINT8, FL_(wwRequiredTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwRequiredTemp));
register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc)); register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc));
register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode)); register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode));
} else if (device_id == 0x40) { // flags == EMSdevice::EMS_DEVICE_FLAG_IPM, special DHW pos 10 } else if (device_id == 0x40) { // flags == EMSdevice::EMS_DEVICE_FLAG_IPM, special DHW pos 10
@@ -87,15 +87,15 @@ Water::Water(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
register_telegram_type(0x33, "UBAParameterWW", true, MAKE_PF_CB(process_IPMParameterWW)); register_telegram_type(0x33, "UBAParameterWW", true, MAKE_PF_CB(process_IPMParameterWW));
// register_telegram_type(0x10D, "wwNTCStatus", false, MAKE_PF_CB(process_wwNTCStatus)); // register_telegram_type(0x10D, "wwNTCStatus", false, MAKE_PF_CB(process_wwNTCStatus));
// device values... // device values...
register_device_value(tag, &wwSelTemp_, DeviceValueType::UINT, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwSelTemp)); register_device_value(tag, &wwSelTemp_, DeviceValueType::UINT8, FL_(wwSelTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwSelTemp));
register_device_value(tag, &wwTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwTemp2_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp2), DeviceValueUOM::DEGREES); register_device_value(tag, &wwTemp2_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(wwCurTemp2), DeviceValueUOM::DEGREES);
register_device_value(tag, &HydrTemp_, DeviceValueType::USHORT, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hydrTemp), DeviceValueUOM::DEGREES); register_device_value(tag, &HydrTemp_, DeviceValueType::UINT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(hydrTemp), DeviceValueUOM::DEGREES);
register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE); register_device_value(tag, &wwPump_, DeviceValueType::BOOL, FL_(wwPump), DeviceValueUOM::NONE);
register_device_value(tag, &wwFlowTempOffset_, DeviceValueType::UINT, FL_(wwFlowTempOffset), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwFlowTempOffset)); register_device_value(tag, &wwFlowTempOffset_, DeviceValueType::UINT8, FL_(wwFlowTempOffset), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwFlowTempOffset));
register_device_value(tag, &wwHystOn_, DeviceValueType::INT, FL_(wwHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwHystOn)); register_device_value(tag, &wwHystOn_, DeviceValueType::INT8, FL_(wwHystOn), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwHystOn));
register_device_value(tag, &wwHystOff_, DeviceValueType::INT, FL_(wwHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwHystOff)); register_device_value(tag, &wwHystOff_, DeviceValueType::INT8, FL_(wwHystOff), DeviceValueUOM::DEGREES_R, MAKE_CF_CB(set_wwHystOff));
register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp)); register_device_value(tag, &wwDisinfectionTemp_, DeviceValueType::UINT8, FL_(wwDisinfectionTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwDisinfectionTemp));
register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc)); register_device_value(tag, &wwCirc_, DeviceValueType::BOOL, FL_(wwCirc), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCirc));
register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode)); register_device_value(tag, &wwCircMode_, DeviceValueType::ENUM, FL_(enum_wwCircMode), FL_(wwCircMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwCircMode));
} }

115
src/emsdevice.cpp
View File

@@ -519,16 +519,16 @@ void EMSdevice::add_device_value(uint8_t tag, // to b
if (type == DeviceValueType::STRING) { if (type == DeviceValueType::STRING) {
*(char *)(value_p) = {'\0'}; // this is important for string functions like strlen() to work later *(char *)(value_p) = {'\0'}; // this is important for string functions like strlen() to work later
} else if (type == DeviceValueType::INT) { } else if (type == DeviceValueType::INT8) {
*(int8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_INT_DUMMY : EMS_VALUE_DEFAULT_INT; *(int8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_INT8_DUMMY : EMS_VALUE_DEFAULT_INT8;
} else if (type == DeviceValueType::UINT) { } else if (type == DeviceValueType::UINT8) {
*(uint8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_UINT_DUMMY : EMS_VALUE_DEFAULT_UINT; *(uint8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_UINT8_DUMMY : EMS_VALUE_DEFAULT_UINT8;
} else if (type == DeviceValueType::SHORT) { } else if (type == DeviceValueType::INT16) {
*(int16_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_SHORT_DUMMY : EMS_VALUE_DEFAULT_SHORT; *(int16_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_INT16_DUMMY : EMS_VALUE_DEFAULT_INT16;
} else if (type == DeviceValueType::USHORT) { } else if (type == DeviceValueType::UINT16) {
*(uint16_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_USHORT_DUMMY : EMS_VALUE_DEFAULT_USHORT; *(uint16_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_UINT16_DUMMY : EMS_VALUE_DEFAULT_UINT16;
} else if ((type == DeviceValueType::ULONG) || (type == DeviceValueType::TIME)) { } else if ((type == DeviceValueType::UINT24) || (type == DeviceValueType::TIME) || (type == DeviceValueType::UINT32)) {
*(uint32_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_ULONG_DUMMY : EMS_VALUE_DEFAULT_ULONG; *(uint32_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_UINT24_DUMMY : EMS_VALUE_DEFAULT_UINT24;
} else if (type == DeviceValueType::BOOL) { } else if (type == DeviceValueType::BOOL) {
*(int8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_BOOL_DUMMY : EMS_VALUE_DEFAULT_BOOL; // bool is uint8_t, but other initial value *(int8_t *)(value_p) = System::test_set_all_active() ? EMS_VALUE_DEFAULT_BOOL_DUMMY : EMS_VALUE_DEFAULT_BOOL; // bool is uint8_t, but other initial value
} else if (type == DeviceValueType::ENUM) { } else if (type == DeviceValueType::ENUM) {
@@ -789,27 +789,26 @@ void EMSdevice::publish_value(void * value_p) const {
} }
break; break;
} }
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
Helpers::render_value(payload, *(uint16_t *)(value_p), num_op, fahrenheit); Helpers::render_value(payload, *(uint16_t *)(value_p), num_op, fahrenheit);
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
Helpers::render_value(payload, *(uint8_t *)(value_p), num_op, fahrenheit); Helpers::render_value(payload, *(uint8_t *)(value_p), num_op, fahrenheit);
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
Helpers::render_value(payload, *(int16_t *)(value_p), num_op, fahrenheit); Helpers::render_value(payload, *(int16_t *)(value_p), num_op, fahrenheit);
break; break;
case DeviceValueType::INT: case DeviceValueType::INT8:
Helpers::render_value(payload, *(int8_t *)(value_p), num_op, fahrenheit); Helpers::render_value(payload, *(int8_t *)(value_p), num_op, fahrenheit);
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
Helpers::render_value(payload, *(uint32_t *)(value_p), num_op, fahrenheit); case DeviceValueType::TIME:
case DeviceValueType::UINT32:
Helpers::render_value(payload, *(uint32_t *)(value_p), num_op);
break; break;
case DeviceValueType::BOOL: case DeviceValueType::BOOL:
Helpers::render_boolean(payload, (bool)*(uint8_t *)(value_p)); Helpers::render_boolean(payload, (bool)*(uint8_t *)(value_p));
break; break;
case DeviceValueType::TIME:
Helpers::render_value(payload, *(uint32_t *)(value_p), num_op);
break;
case DeviceValueType::STRING: case DeviceValueType::STRING:
if (Helpers::hasValue((char *)(value_p))) { if (Helpers::hasValue((char *)(value_p))) {
strlcpy(payload, (char *)(value_p), sizeof(payload)); strlcpy(payload, (char *)(value_p), sizeof(payload));
@@ -920,18 +919,20 @@ void EMSdevice::generate_values_web(JsonObject output) {
// note, the nested if's is necessary due to the way the ArduinoJson templates are pre-processed by the compiler // note, the nested if's is necessary due to the way the ArduinoJson templates are pre-processed by the compiler
fahrenheit = !EMSESP::system_.fahrenheit() ? 0 : (dv.uom == DeviceValueUOM::DEGREES) ? 2 : (dv.uom == DeviceValueUOM::DEGREES_R) ? 1 : 0; fahrenheit = !EMSESP::system_.fahrenheit() ? 0 : (dv.uom == DeviceValueUOM::DEGREES) ? 2 : (dv.uom == DeviceValueUOM::DEGREES_R) ? 1 : 0;
if ((dv.type == DeviceValueType::INT) && Helpers::hasValue(*(int8_t *)(dv.value_p))) { if ((dv.type == DeviceValueType::INT8) && Helpers::hasValue(*(int8_t *)(dv.value_p))) {
obj["v"] = Helpers::transformNumFloat(*(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if ((dv.type == DeviceValueType::UINT) && Helpers::hasValue(*(uint8_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::UINT8) && Helpers::hasValue(*(uint8_t *)(dv.value_p))) {
obj["v"] = Helpers::transformNumFloat(*(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if ((dv.type == DeviceValueType::SHORT) && Helpers::hasValue(*(int16_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::INT16) && Helpers::hasValue(*(int16_t *)(dv.value_p))) {
obj["v"] = Helpers::transformNumFloat(*(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if ((dv.type == DeviceValueType::USHORT) && Helpers::hasValue(*(uint16_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::UINT16) && Helpers::hasValue(*(uint16_t *)(dv.value_p))) {
obj["v"] = Helpers::transformNumFloat(*(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if ((dv.type == DeviceValueType::ULONG) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::UINT24) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) {
obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p); obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p);
} else if ((dv.type == DeviceValueType::TIME) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::TIME) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) {
obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p); obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p);
} else if ((dv.type == DeviceValueType::UINT32) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) {
obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p);
} else { } else {
obj["v"] = ""; // must have a value for sorting to work obj["v"] = ""; // must have a value for sorting to work
} }
@@ -1027,15 +1028,15 @@ void EMSdevice::generate_values_web_customization(JsonArray output) {
// handle Integers and Floats // handle Integers and Floats
else { else {
if (dv.type == DeviceValueType::INT) { if (dv.type == DeviceValueType::INT8) {
obj["v"] = Helpers::transformNumFloat(*(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if (dv.type == DeviceValueType::UINT) { } else if (dv.type == DeviceValueType::UINT8) {
obj["v"] = Helpers::transformNumFloat(*(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if (dv.type == DeviceValueType::SHORT) { } else if (dv.type == DeviceValueType::INT16) {
obj["v"] = Helpers::transformNumFloat(*(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if (dv.type == DeviceValueType::USHORT) { } else if (dv.type == DeviceValueType::UINT16) {
obj["v"] = Helpers::transformNumFloat(*(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit); obj["v"] = Helpers::transformNumFloat(*(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit);
} else if (dv.type == DeviceValueType::ULONG) { } else if (dv.type == DeviceValueType::UINT24 || dv.type == DeviceValueType::UINT32) {
obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p); obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p);
} else if (dv.type == DeviceValueType::TIME) { } else if (dv.type == DeviceValueType::TIME) {
obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p); obj["v"] = dv.numeric_operator > 0 ? *(uint32_t *)(dv.value_p) / dv.numeric_operator : *(uint32_t *)(dv.value_p);
@@ -1243,24 +1244,28 @@ void EMSdevice::dump_value_info() {
Serial.print(']'); Serial.print(']');
break; break;
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
Serial.print("ushort"); Serial.print("uint16");
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
Serial.print("uint"); Serial.print("uint8");
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
Serial.print("short"); Serial.print("int16");
break; break;
case DeviceValueType::INT: case DeviceValueType::INT8:
Serial.print("int"); Serial.print("int8");
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
Serial.print("ulong"); Serial.print("uint24");
break;
case DeviceValueType::UINT32:
Serial.print("uint32");
break; break;
case DeviceValueType::BOOL: case DeviceValueType::BOOL:
@@ -1335,11 +1340,12 @@ void EMSdevice::dump_value_info() {
if (dv.has_cmd) { if (dv.has_cmd) {
switch (dv.type) { switch (dv.type) {
case DeviceValueType::INT: case DeviceValueType::INT8:
case DeviceValueType::UINT: case DeviceValueType::UINT8:
case DeviceValueType::SHORT: case DeviceValueType::INT16:
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
case DeviceValueType::UINT32:
snprintf(entityid, sizeof(entityid), "number.%s", entity_with_tag); snprintf(entityid, sizeof(entityid), "number.%s", entity_with_tag);
break; break;
case DeviceValueType::BOOL: case DeviceValueType::BOOL:
@@ -1433,35 +1439,36 @@ bool EMSdevice::get_value_info(JsonObject output, const char * cmd, const int8_t
break; break;
} }
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
if (Helpers::hasValue(*(uint16_t *)(dv.value_p))) { if (Helpers::hasValue(*(uint16_t *)(dv.value_p))) {
json[value] = serialized(Helpers::render_value(val, *(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[value] = serialized(Helpers::render_value(val, *(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} }
json[type] = F_(number); json[type] = F_(number);
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
if (Helpers::hasValue(*(uint8_t *)(dv.value_p))) { if (Helpers::hasValue(*(uint8_t *)(dv.value_p))) {
json[value] = serialized(Helpers::render_value(val, *(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[value] = serialized(Helpers::render_value(val, *(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} }
json[type] = F_(number); json[type] = F_(number);
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
if (Helpers::hasValue(*(int16_t *)(dv.value_p))) { if (Helpers::hasValue(*(int16_t *)(dv.value_p))) {
json[value] = serialized(Helpers::render_value(val, *(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[value] = serialized(Helpers::render_value(val, *(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} }
json[type] = F_(number); json[type] = F_(number);
break; break;
case DeviceValueType::INT: case DeviceValueType::INT8:
if (Helpers::hasValue(*(int8_t *)(dv.value_p))) { if (Helpers::hasValue(*(int8_t *)(dv.value_p))) {
json[value] = serialized(Helpers::render_value(val, *(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[value] = serialized(Helpers::render_value(val, *(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} }
json[type] = F_(number); json[type] = F_(number);
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
case DeviceValueType::UINT32:
if (Helpers::hasValue(*(uint32_t *)(dv.value_p))) { if (Helpers::hasValue(*(uint32_t *)(dv.value_p))) {
json[value] = serialized(Helpers::render_value(val, *(uint32_t *)(dv.value_p), dv.numeric_operator)); json[value] = serialized(Helpers::render_value(val, *(uint32_t *)(dv.value_p), dv.numeric_operator));
} }
@@ -1678,15 +1685,15 @@ bool EMSdevice::generate_values(JsonObject output, const uint8_t tag_filter, con
: (dv.uom == DeviceValueUOM::DEGREES_R) ? 1 : (dv.uom == DeviceValueUOM::DEGREES_R) ? 1
: 0; : 0;
char val[10] = {'\0'}; char val[10] = {'\0'};
if (dv.type == DeviceValueType::INT) { if (dv.type == DeviceValueType::INT8) {
json[name] = serialized(Helpers::render_value(val, *(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[name] = serialized(Helpers::render_value(val, *(int8_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} else if (dv.type == DeviceValueType::UINT) { } else if (dv.type == DeviceValueType::UINT8) {
json[name] = serialized(Helpers::render_value(val, *(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[name] = serialized(Helpers::render_value(val, *(uint8_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} else if (dv.type == DeviceValueType::SHORT) { } else if (dv.type == DeviceValueType::INT16) {
json[name] = serialized(Helpers::render_value(val, *(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[name] = serialized(Helpers::render_value(val, *(int16_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} else if (dv.type == DeviceValueType::USHORT) { } else if (dv.type == DeviceValueType::UINT16) {
json[name] = serialized(Helpers::render_value(val, *(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit)); json[name] = serialized(Helpers::render_value(val, *(uint16_t *)(dv.value_p), dv.numeric_operator, fahrenheit));
} else if (dv.type == DeviceValueType::ULONG) { } else if (dv.type == DeviceValueType::UINT24 || dv.type == DeviceValueType::UINT32) {
json[name] = serialized(Helpers::render_value(val, *(uint32_t *)(dv.value_p), dv.numeric_operator)); json[name] = serialized(Helpers::render_value(val, *(uint32_t *)(dv.value_p), dv.numeric_operator));
} else if ((dv.type == DeviceValueType::TIME) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) { } else if ((dv.type == DeviceValueType::TIME) && Helpers::hasValue(*(uint32_t *)(dv.value_p))) {
uint32_t time_value = *(uint32_t *)(dv.value_p); uint32_t time_value = *(uint32_t *)(dv.value_p);

42
src/emsdevicevalue.cpp
View File

@@ -220,22 +220,21 @@ bool DeviceValue::hasValue() const {
case DeviceValueType::ENUM: case DeviceValueType::ENUM:
has_value = Helpers::hasValue(*(uint8_t *)(value_p)); has_value = Helpers::hasValue(*(uint8_t *)(value_p));
break; break;
case DeviceValueType::INT: case DeviceValueType::INT8:
has_value = Helpers::hasValue(*(int8_t *)(value_p)); has_value = Helpers::hasValue(*(int8_t *)(value_p));
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
has_value = Helpers::hasValue(*(uint8_t *)(value_p)); has_value = Helpers::hasValue(*(uint8_t *)(value_p));
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
has_value = Helpers::hasValue(*(int16_t *)(value_p)); has_value = Helpers::hasValue(*(int16_t *)(value_p));
break; break;
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
has_value = Helpers::hasValue(*(uint16_t *)(value_p)); has_value = Helpers::hasValue(*(uint16_t *)(value_p));
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
has_value = Helpers::hasValue(*(uint32_t *)(value_p));
break;
case DeviceValueType::TIME: case DeviceValueType::TIME:
case DeviceValueType::UINT32:
has_value = Helpers::hasValue(*(uint32_t *)(value_p)); has_value = Helpers::hasValue(*(uint32_t *)(value_p));
break; break;
case DeviceValueType::CMD: case DeviceValueType::CMD:
@@ -272,45 +271,40 @@ bool DeviceValue::get_min_max(int16_t & dv_set_min, uint32_t & dv_set_max) {
dv_set_min = 0; dv_set_min = 0;
dv_set_max = 0; dv_set_max = 0;
if (type == DeviceValueType::USHORT) { if (type == DeviceValueType::UINT16) {
dv_set_min = Helpers::transformNumFloat(0, numeric_operator, fahrenheit); dv_set_min = Helpers::transformNumFloat(0, numeric_operator, fahrenheit);
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_USHORT_NOTSET - 1, numeric_operator, fahrenheit); dv_set_max = Helpers::transformNumFloat(EMS_VALUE_UINT16_NOTSET - 1, numeric_operator, fahrenheit);
return true; return true;
} }
if (type == DeviceValueType::SHORT) { if (type == DeviceValueType::INT16) {
dv_set_min = Helpers::transformNumFloat(-EMS_VALUE_SHORT_NOTSET + 1, numeric_operator, fahrenheit); dv_set_min = Helpers::transformNumFloat(-EMS_VALUE_INT16_NOTSET + 1, numeric_operator, fahrenheit);
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_SHORT_NOTSET - 1, numeric_operator, fahrenheit); dv_set_max = Helpers::transformNumFloat(EMS_VALUE_INT16_NOTSET - 1, numeric_operator, fahrenheit);
return true; return true;
} }
if (type == DeviceValueType::UINT) { if (type == DeviceValueType::UINT8) {
if (uom == DeviceValueUOM::PERCENT) { if (uom == DeviceValueUOM::PERCENT) {
dv_set_max = 100; dv_set_max = 100;
} else { } else {
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_UINT_NOTSET - 1, numeric_operator, fahrenheit); dv_set_max = Helpers::transformNumFloat(EMS_VALUE_UINT8_NOTSET - 1, numeric_operator, fahrenheit);
} }
return true; return true;
} }
if (type == DeviceValueType::INT) { if (type == DeviceValueType::INT8) {
if (uom == DeviceValueUOM::PERCENT) { if (uom == DeviceValueUOM::PERCENT) {
dv_set_min = -100; dv_set_min = -100;
dv_set_max = 100; dv_set_max = 100;
} else { } else {
dv_set_min = Helpers::transformNumFloat(-EMS_VALUE_INT_NOTSET + 1, numeric_operator, fahrenheit); dv_set_min = Helpers::transformNumFloat(-EMS_VALUE_INT8_NOTSET + 1, numeric_operator, fahrenheit);
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_INT_NOTSET - 1, numeric_operator, fahrenheit); dv_set_max = Helpers::transformNumFloat(EMS_VALUE_INT8_NOTSET - 1, numeric_operator, fahrenheit);
} }
return true; return true;
} }
if (type == DeviceValueType::ULONG) { if (type == DeviceValueType::UINT24 || type == DeviceValueType::TIME || type == DeviceValueType::UINT32) {
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_ULONG_NOTSET - 1, numeric_operator); dv_set_max = Helpers::transformNumFloat(EMS_VALUE_UINT24_NOTSET - 1, numeric_operator);
return true;
}
if (type == DeviceValueType::TIME) {
dv_set_max = Helpers::transformNumFloat(EMS_VALUE_ULONG_NOTSET - 1, numeric_operator);
return true; return true;
} }

11
src/emsdevicevalue.h
View File

@@ -33,12 +33,13 @@ class DeviceValue {
public: public:
enum DeviceValueType : uint8_t { enum DeviceValueType : uint8_t {
BOOL, BOOL,
INT, INT8,
UINT, UINT8,
SHORT, INT16,
USHORT, UINT16,
ULONG, UINT24,
TIME, // same as ULONG (32 bits) TIME, // same as ULONG (32 bits)
UINT32,
ENUM, ENUM,
STRING, STRING,
CMD // special for commands only CMD // special for commands only

10
src/helpers.cpp
View File

@@ -500,11 +500,11 @@ bool Helpers::hasValue(const uint8_t & value, const uint8_t isBool) {
if (isBool == EMS_VALUE_BOOL) { if (isBool == EMS_VALUE_BOOL) {
return (value != EMS_VALUE_BOOL_NOTSET); return (value != EMS_VALUE_BOOL_NOTSET);
} }
return (value != EMS_VALUE_UINT_NOTSET); return (value != EMS_VALUE_UINT8_NOTSET);
} }
bool Helpers::hasValue(const int8_t & value) { bool Helpers::hasValue(const int8_t & value) {
return (value != EMS_VALUE_INT_NOTSET); return (value != EMS_VALUE_INT8_NOTSET);
} }
bool Helpers::hasValue(const char * value) { bool Helpers::hasValue(const char * value) {
@@ -517,15 +517,15 @@ bool Helpers::hasValue(const char * value) {
// for short these are typically 0x8300, 0x7D00 and sometimes 0x8000 // for short these are typically 0x8300, 0x7D00 and sometimes 0x8000
bool Helpers::hasValue(const int16_t & value) { bool Helpers::hasValue(const int16_t & value) {
return (abs(value) < EMS_VALUE_USHORT_NOTSET); return (abs(value) < EMS_VALUE_UINT16_NOTSET);
} }
bool Helpers::hasValue(const uint16_t & value) { bool Helpers::hasValue(const uint16_t & value) {
return (value < EMS_VALUE_USHORT_NOTSET); return (value < EMS_VALUE_UINT16_NOTSET);
} }
bool Helpers::hasValue(const uint32_t & value) { bool Helpers::hasValue(const uint32_t & value) {
return (value != EMS_VALUE_ULONG_NOTSET && value != EMS_VALUE_ULLONG_NOTSET); return (value != EMS_VALUE_UINT24_NOTSET && value != EMS_VALUE_UINT32_NOTSET);
} }
// checks if we can convert a char string to an int value // checks if we can convert a char string to an int value

39
src/mqtt.cpp
View File

@@ -574,23 +574,23 @@ void Mqtt::ha_status() {
// these are all from the heartbeat MQTT topic // these are all from the heartbeat MQTT topic
#ifndef EMSESP_STANDALONE #ifndef EMSESP_STANDALONE
if (!EMSESP::system_.ethernet_connected() || WiFi.isConnected()) { if (!EMSESP::system_.ethernet_connected() || WiFi.isConnected()) {
publish_system_ha_sensor_config(DeviceValueType::INT, "WiFi RSSI", "rssi", DeviceValueUOM::DBM); publish_system_ha_sensor_config(DeviceValueType::INT8, "WiFi RSSI", "rssi", DeviceValueUOM::DBM);
publish_system_ha_sensor_config(DeviceValueType::INT, "WiFi strength", "wifistrength", DeviceValueUOM::PERCENT); publish_system_ha_sensor_config(DeviceValueType::INT8, "WiFi strength", "wifistrength", DeviceValueUOM::PERCENT);
} }
#endif #endif
publish_system_ha_sensor_config(DeviceValueType::STRING, "EMS Bus", "bus_status", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::STRING, "EMS Bus", "bus_status", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::STRING, "Uptime", "uptime", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::STRING, "Uptime", "uptime", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Uptime (sec)", "uptime_sec", DeviceValueUOM::SECONDS); publish_system_ha_sensor_config(DeviceValueType::INT8, "Uptime (sec)", "uptime_sec", DeviceValueUOM::SECONDS);
publish_system_ha_sensor_config(DeviceValueType::BOOL, "NTP status", "ntp_status", DeviceValueUOM::CONNECTIVITY); publish_system_ha_sensor_config(DeviceValueType::BOOL, "NTP status", "ntp_status", DeviceValueUOM::CONNECTIVITY);
publish_system_ha_sensor_config(DeviceValueType::INT, "Free memory", "freemem", DeviceValueUOM::KB); publish_system_ha_sensor_config(DeviceValueType::INT8, "Free memory", "freemem", DeviceValueUOM::KB);
publish_system_ha_sensor_config(DeviceValueType::INT, "Max Alloc", "max_alloc", DeviceValueUOM::KB); publish_system_ha_sensor_config(DeviceValueType::INT8, "Max Alloc", "max_alloc", DeviceValueUOM::KB);
publish_system_ha_sensor_config(DeviceValueType::INT, "MQTT fails", "mqttfails", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "MQTT fails", "mqttfails", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Rx received", "rxreceived", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "Rx received", "rxreceived", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Rx fails", "rxfails", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "Rx fails", "rxfails", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Tx reads", "txreads", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "Tx reads", "txreads", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Tx writes", "txwrites", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "Tx writes", "txwrites", DeviceValueUOM::NONE);
publish_system_ha_sensor_config(DeviceValueType::INT, "Tx fails", "txfails", DeviceValueUOM::NONE); publish_system_ha_sensor_config(DeviceValueType::INT8, "Tx fails", "txfails", DeviceValueUOM::NONE);
} }
// add sub or pub task to the queue. // add sub or pub task to the queue.
@@ -874,11 +874,12 @@ bool Mqtt::publish_ha_sensor_config(uint8_t type, // EMSdev
// if it's a command then we can use Number, Switch, Select or Text. Otherwise stick to Sensor // if it's a command then we can use Number, Switch, Select or Text. Otherwise stick to Sensor
if (has_cmd) { if (has_cmd) {
switch (type) { switch (type) {
case DeviceValueType::INT: case DeviceValueType::INT8:
case DeviceValueType::UINT: case DeviceValueType::UINT8:
case DeviceValueType::SHORT: case DeviceValueType::INT16:
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
case DeviceValueType::UINT32:
// number - https://www.home-assistant.io/integrations/number.mqtt // number - https://www.home-assistant.io/integrations/number.mqtt
// older Domoticz does not support number, use sensor // older Domoticz does not support number, use sensor
if (discovery_type() == discoveryType::HOMEASSISTANT || discovery_type() == discoveryType::DOMOTICZ_LATEST) { if (discovery_type() == discoveryType::HOMEASSISTANT || discovery_type() == discoveryType::DOMOTICZ_LATEST) {
@@ -1151,13 +1152,13 @@ void Mqtt::add_ha_uom(JsonObject doc, const uint8_t type, const uint8_t uom, con
case DeviceValueUOM::NONE: case DeviceValueUOM::NONE:
// for device entities which have numerical values, with no UOM // for device entities which have numerical values, with no UOM
if ((type != DeviceValueType::STRING) if ((type != DeviceValueType::STRING)
&& (type == DeviceValueType::INT || type == DeviceValueType::UINT || type == DeviceValueType::SHORT || type == DeviceValueType::USHORT && (type == DeviceValueType::INT8 || type == DeviceValueType::UINT8 || type == DeviceValueType::INT16 || type == DeviceValueType::UINT16
|| type == DeviceValueType::ULONG)) { || type == DeviceValueType::UINT24 || type == DeviceValueType::UINT32)) {
doc["ic"] = F_(iconnum); // set icon doc["ic"] = F_(iconnum); // set icon
// determine if its a measurement or total increasing // determine if its a measurement or total increasing
// most of the values are measurement. for example Tx Reads will increment but can be reset to 0 after a restart // most of the values are measurement. for example Tx Reads will increment but can be reset to 0 after a restart
// all the starts are increasing, and they are ULONGs // all the starts are increasing, and they are ULONGs
if (type == DeviceValueType::ULONG) { if (type == DeviceValueType::UINT24 || type == DeviceValueType::UINT32) {
doc[sc_ha] = F_(total_increasing); doc[sc_ha] = F_(total_increasing);
} else { } else {
doc[sc_ha] = F_(measurement); // default to measurement doc[sc_ha] = F_(measurement); // default to measurement

30
src/roomcontrol.cpp
View File

@@ -23,8 +23,8 @@ namespace emsesp {
// init statics // init statics
bool Roomctrl::switch_off_[HCS] = {false, false, false, false}; bool Roomctrl::switch_off_[HCS] = {false, false, false, false};
uint32_t Roomctrl::rc_time_[HCS] = {0, 0, 0, 0}; uint32_t Roomctrl::rc_time_[HCS] = {0, 0, 0, 0};
int16_t Roomctrl::remotetemp_[HCS] = {EMS_VALUE_SHORT_NOTSET, EMS_VALUE_SHORT_NOTSET, EMS_VALUE_SHORT_NOTSET, EMS_VALUE_SHORT_NOTSET}; int16_t Roomctrl::remotetemp_[HCS] = {EMS_VALUE_INT16_NOTSET, EMS_VALUE_INT16_NOTSET, EMS_VALUE_INT16_NOTSET, EMS_VALUE_INT16_NOTSET};
uint8_t Roomctrl::remotehum_[HCS] = {EMS_VALUE_UINT_NOTSET, EMS_VALUE_UINT_NOTSET, EMS_VALUE_UINT_NOTSET, EMS_VALUE_UINT_NOTSET}; uint8_t Roomctrl::remotehum_[HCS] = {EMS_VALUE_UINT8_NOTSET, EMS_VALUE_UINT8_NOTSET, EMS_VALUE_UINT8_NOTSET, EMS_VALUE_UINT8_NOTSET};
uint8_t Roomctrl::sendtype_[HCS] = {SendType::TEMP, SendType::TEMP, SendType::TEMP, SendType::TEMP}; uint8_t Roomctrl::sendtype_[HCS] = {SendType::TEMP, SendType::TEMP, SendType::TEMP, SendType::TEMP};
uint8_t Roomctrl::type_[HCS] = {RemoteType::NONE, RemoteType::NONE, RemoteType::NONE, RemoteType::NONE}; uint8_t Roomctrl::type_[HCS] = {RemoteType::NONE, RemoteType::NONE, RemoteType::NONE, RemoteType::NONE};
@@ -35,8 +35,8 @@ void Roomctrl::set_remotetemp(const uint8_t type, const uint8_t hc, const int16_
if (!type_[hc] && !type) { if (!type_[hc] && !type) {
return; return;
} }
if (remotetemp_[hc] != EMS_VALUE_SHORT_NOTSET && temp == EMS_VALUE_SHORT_NOTSET) { // switch remote off if (remotetemp_[hc] != EMS_VALUE_INT16_NOTSET && temp == EMS_VALUE_INT16_NOTSET) { // switch remote off
remotetemp_[hc] = EMS_VALUE_SHORT_NOTSET; remotetemp_[hc] = EMS_VALUE_INT16_NOTSET;
switch_off_[hc] = true; switch_off_[hc] = true;
rc_time_[hc] = uuid::get_uptime() - SEND_INTERVAL; // send now rc_time_[hc] = uuid::get_uptime() - SEND_INTERVAL; // send now
sendtype_[hc] = SendType::TEMP; sendtype_[hc] = SendType::TEMP;
@@ -90,7 +90,7 @@ void Roomctrl::send(uint8_t addr) {
return; return;
} }
// no reply if the temperature is not set // no reply if the temperature is not set
if (!switch_off_[hc] && remotetemp_[hc] == EMS_VALUE_SHORT_NOTSET && remotehum_[hc] == EMS_VALUE_UINT_NOTSET) { if (!switch_off_[hc] && remotetemp_[hc] == EMS_VALUE_INT16_NOTSET && remotehum_[hc] == EMS_VALUE_UINT8_NOTSET) {
return; return;
} }
@@ -98,13 +98,13 @@ void Roomctrl::send(uint8_t addr) {
if (type_[hc] == RC100H) { if (type_[hc] == RC100H) {
if (sendtype_[hc] == SendType::HUMI) { // send humidity if (sendtype_[hc] == SendType::HUMI) { // send humidity
if (switch_off_[hc]) { if (switch_off_[hc]) {
remotehum_[hc] = EMS_VALUE_UINT_NOTSET; remotehum_[hc] = EMS_VALUE_UINT8_NOTSET;
} }
rc_time_[hc] = uuid::get_uptime(); rc_time_[hc] = uuid::get_uptime();
humidity(addr, 0x10, hc); humidity(addr, 0x10, hc);
sendtype_[hc] = SendType::TEMP; sendtype_[hc] = SendType::TEMP;
} else { // temperature telegram } else { // temperature telegram
if (remotehum_[hc] != EMS_VALUE_UINT_NOTSET) { if (remotehum_[hc] != EMS_VALUE_UINT8_NOTSET) {
sendtype_[hc] = SendType::HUMI; sendtype_[hc] = SendType::HUMI;
} else { } else {
rc_time_[hc] = uuid::get_uptime(); rc_time_[hc] = uuid::get_uptime();
@@ -121,7 +121,7 @@ void Roomctrl::send(uint8_t addr) {
rc_time_[hc] = uuid::get_uptime(); rc_time_[hc] = uuid::get_uptime();
temperature(addr, 0x00, hc); // send to all temperature(addr, 0x00, hc); // send to all
} }
if (remotehum_[hc] == EMS_VALUE_UINT_NOTSET && switch_off_[hc]) { if (remotehum_[hc] == EMS_VALUE_UINT8_NOTSET && switch_off_[hc]) {
switch_off_[hc] = false; switch_off_[hc] = false;
type_[hc] = RemoteType::NONE; type_[hc] = RemoteType::NONE;
} }
@@ -143,7 +143,7 @@ void Roomctrl::check(uint8_t addr, const uint8_t * data, const uint8_t length) {
return; return;
} }
// no reply if the temperature is not set // no reply if the temperature is not set
if (remotetemp_[hc] == EMS_VALUE_SHORT_NOTSET) { if (remotetemp_[hc] == EMS_VALUE_INT16_NOTSET) {
return; return;
} }
// reply to writes with write nack byte // reply to writes with write nack byte
@@ -156,9 +156,9 @@ void Roomctrl::check(uint8_t addr, const uint8_t * data, const uint8_t length) {
// empty message back if temperature not set or unknown message type // empty message back if temperature not set or unknown message type
if (data[2] == EMSdevice::EMS_TYPE_VERSION) { if (data[2] == EMSdevice::EMS_TYPE_VERSION) {
version(addr, data[0], hc); version(addr, data[0], hc);
} else if (length == 6 && remotetemp_[hc] == EMS_VALUE_SHORT_NOTSET) { } else if (length == 6 && remotetemp_[hc] == EMS_VALUE_INT16_NOTSET) {
unknown(addr, data[0], data[2], data[3]); unknown(addr, data[0], data[2], data[3]);
} else if (length == 8 && remotetemp_[hc] == EMS_VALUE_SHORT_NOTSET) { } else if (length == 8 && remotetemp_[hc] == EMS_VALUE_INT16_NOTSET) {
unknown(addr, data[0], data[3], data[5], data[6]); unknown(addr, data[0], data[3], data[5], data[6]);
} else if (data[2] == 0xAF && data[3] == 0) { } else if (data[2] == 0xAF && data[3] == 0) {
temperature(addr, data[0], hc); temperature(addr, data[0], hc);
@@ -166,7 +166,7 @@ void Roomctrl::check(uint8_t addr, const uint8_t * data, const uint8_t length) {
temperature(addr, data[0], hc); temperature(addr, data[0], hc);
} else if (length == 8 && data[2] == 0xFF && data[3] == 0 && data[5] == 3 && data[6] == 0x2B + hc) { // EMS+ temperature } else if (length == 8 && data[2] == 0xFF && data[3] == 0 && data[5] == 3 && data[6] == 0x2B + hc) { // EMS+ temperature
temperature(addr, data[0], hc); temperature(addr, data[0], hc);
} else if (length == 8 && data[2] == 0xFF && data[3] == 0 && data[5] == 3 && data[6] == 0x7B + hc && remotehum_[hc] != EMS_VALUE_UINT_NOTSET) { // EMS+ humidity } else if (length == 8 && data[2] == 0xFF && data[3] == 0 && data[5] == 3 && data[6] == 0x7B + hc && remotehum_[hc] != EMS_VALUE_UINT8_NOTSET) { // EMS+ humidity
humidity(addr, data[0], hc); humidity(addr, data[0], hc);
} else if (length == 6) { // ems query } else if (length == 6) { // ems query
unknown(addr, data[0], data[2], data[3]); unknown(addr, data[0], data[2], data[3]);
@@ -332,7 +332,7 @@ void Roomctrl::humidity(uint8_t addr, uint8_t dst, uint8_t hc) {
data[3] = 0; data[3] = 0;
data[4] = 3; data[4] = 3;
data[5] = 0x7B + hc; data[5] = 0x7B + hc;
data[6] = dew == EMS_VALUE_SHORT_NOTSET ? EMS_VALUE_INT_NOTSET : (uint8_t)((dew + 5) / 10); data[6] = dew == EMS_VALUE_INT16_NOTSET ? EMS_VALUE_INT8_NOTSET : (uint8_t)((dew + 5) / 10);
data[7] = remotehum_[hc]; data[7] = remotehum_[hc];
data[8] = (uint8_t)(dew << 8); data[8] = (uint8_t)(dew << 8);
data[9] = (uint8_t)(dew & 0xFF); data[9] = (uint8_t)(dew & 0xFF);
@@ -384,8 +384,8 @@ void Roomctrl::replyF7(uint8_t addr, uint8_t dst, uint8_t offset, uint8_t typehh
} }
int16_t Roomctrl::calc_dew(int16_t temp, uint8_t humi) { int16_t Roomctrl::calc_dew(int16_t temp, uint8_t humi) {
if (humi == EMS_VALUE_UINT_NOTSET || temp == EMS_VALUE_SHORT_NOTSET) { if (humi == EMS_VALUE_UINT8_NOTSET || temp == EMS_VALUE_INT16_NOTSET) {
return EMS_VALUE_SHORT_NOTSET; return EMS_VALUE_INT16_NOTSET;
} }
const float k2 = 17.62; const float k2 = 17.62;
const float k3 = 243.12; const float k3 = 243.12;

2
src/roomcontrol.h
View File

@@ -32,7 +32,7 @@ class Roomctrl {
static void set_remotetemp(const uint8_t type, const uint8_t hc, const int16_t temp); static void set_remotetemp(const uint8_t type, const uint8_t hc, const int16_t temp);
static void set_remotehum(const uint8_t type, const uint8_t hc, const int8_t hum); static void set_remotehum(const uint8_t type, const uint8_t hc, const int8_t hum);
static bool is_remote(const uint8_t hc) { static bool is_remote(const uint8_t hc) {
return (hc < 4 && remotetemp_[hc] != EMS_VALUE_SHORT_NOTSET); return (hc < 4 && remotetemp_[hc] != EMS_VALUE_INT16_NOTSET);
} }
private: private:

36
src/telegram.h
View File

@@ -40,30 +40,32 @@ static constexpr uint8_t EMS_VALUE_BOOL = 0xFF; // used to mark
static constexpr uint8_t EMS_VALUE_BOOL_OFF = 0x00; // boolean false static constexpr uint8_t EMS_VALUE_BOOL_OFF = 0x00; // boolean false
static constexpr uint8_t EMS_VALUE_BOOL_ON = 0x01; // boolean true. True can be 0x01 or 0xFF sometimes static constexpr uint8_t EMS_VALUE_BOOL_ON = 0x01; // boolean true. True can be 0x01 or 0xFF sometimes
static constexpr uint8_t EMS_VALUE_BOOL_NOTSET = 0xFE; // random number for booleans, that's not 0, 1 or FF static constexpr uint8_t EMS_VALUE_BOOL_NOTSET = 0xFE; // random number for booleans, that's not 0, 1 or FF
static constexpr uint8_t EMS_VALUE_UINT_NOTSET = 0xFF; // for 8-bit unsigned ints/bytes static constexpr uint8_t EMS_VALUE_UINT8_NOTSET = 0xFF; // for 8-bit unsigned ints/bytes
static constexpr int8_t EMS_VALUE_INT_NOTSET = 0x7F; // for signed 8-bit ints/bytes static constexpr int8_t EMS_VALUE_INT8_NOTSET = 0x7F; // for signed 8-bit ints/bytes
static constexpr uint16_t EMS_VALUE_USHORT_NOTSET = 0x7D00; // 32000: for 2-byte unsigned shorts static constexpr uint16_t EMS_VALUE_UINT16_NOTSET = 0x7D00; // 32000: for 2-byte unsigned shorts
static constexpr int16_t EMS_VALUE_SHORT_NOTSET = 0x7D00; // 32000: for 2-byte signed shorts static constexpr int16_t EMS_VALUE_INT16_NOTSET = 0x7D00; // 32000: for 2-byte signed shorts
static constexpr uint32_t EMS_VALUE_ULONG_NOTSET = 0x00FFFFFF; // for 3-byte longs static constexpr uint32_t EMS_VALUE_UINT24_NOTSET = 0x00FFFFFF; // for 3-byte longs
static constexpr uint32_t EMS_VALUE_ULLONG_NOTSET = 0xFFFFFFFF; // for 4-byte longs static constexpr uint32_t EMS_VALUE_UINT32_NOTSET = 0xFFFFFFFF; // for 4-byte longs
static constexpr uint8_t EMS_MAX_TELEGRAM_LENGTH = 32; // max length of a complete EMS telegram static constexpr uint8_t EMS_MAX_TELEGRAM_LENGTH = 32; // max length of a complete EMS telegram
static constexpr uint8_t EMS_MAX_TELEGRAM_MESSAGE_LENGTH = 27; // max length of message block, assuming EMS1.0 static constexpr uint8_t EMS_MAX_TELEGRAM_MESSAGE_LENGTH = 27; // max length of message block, assuming EMS1.0
#define EMS_VALUE_DEFAULT_INT EMS_VALUE_INT_NOTSET #define EMS_VALUE_DEFAULT_INT8 EMS_VALUE_INT8_NOTSET
#define EMS_VALUE_DEFAULT_UINT EMS_VALUE_UINT_NOTSET #define EMS_VALUE_DEFAULT_UINT8 EMS_VALUE_UINT8_NOTSET
#define EMS_VALUE_DEFAULT_SHORT EMS_VALUE_SHORT_NOTSET #define EMS_VALUE_DEFAULT_INT16 EMS_VALUE_INT16_NOTSET
#define EMS_VALUE_DEFAULT_USHORT EMS_VALUE_USHORT_NOTSET #define EMS_VALUE_DEFAULT_UINT16 EMS_VALUE_UINT16_NOTSET
#define EMS_VALUE_DEFAULT_ULONG EMS_VALUE_ULONG_NOTSET #define EMS_VALUE_DEFAULT_UINT24 EMS_VALUE_UINT24_NOTSET
#define EMS_VALUE_DEFAULT_UIN32 EMS_VALUE_UINT32_NOTSET
#define EMS_VALUE_DEFAULT_BOOL EMS_VALUE_BOOL_NOTSET #define EMS_VALUE_DEFAULT_BOOL EMS_VALUE_BOOL_NOTSET
#define EMS_VALUE_DEFAULT_ENUM EMS_VALUE_UINT_NOTSET #define EMS_VALUE_DEFAULT_ENUM EMS_VALUE_UINT8_NOTSET
// used when System::test_set_all_active() is set // used when System::test_set_all_active() is set
#define EMS_VALUE_DEFAULT_INT_DUMMY 11 #define EMS_VALUE_DEFAULT_INT8_DUMMY 11
#define EMS_VALUE_DEFAULT_UINT_DUMMY -12 #define EMS_VALUE_DEFAULT_UINT8_DUMMY -12
#define EMS_VALUE_DEFAULT_SHORT_DUMMY -1234 #define EMS_VALUE_DEFAULT_INT16_DUMMY -1234
#define EMS_VALUE_DEFAULT_USHORT_DUMMY 1235 #define EMS_VALUE_DEFAULT_UINT16_DUMMY 1235
#define EMS_VALUE_DEFAULT_ULONG_DUMMY 12456 #define EMS_VALUE_DEFAULT_UINT24_DUMMY 12456
#define EMS_VALUE_DEFAULT_UINT32_DUMMY 124567
#define EMS_VALUE_DEFAULT_BOOL_DUMMY 1 #define EMS_VALUE_DEFAULT_BOOL_DUMMY 1
#define EMS_VALUE_DEFAULT_ENUM_DUMMY 1 #define EMS_VALUE_DEFAULT_ENUM_DUMMY 1

12
src/temperaturesensor.cpp
View File

@@ -95,7 +95,7 @@ void TemperatureSensor::loop() {
#ifndef EMSESP_TEST #ifndef EMSESP_TEST
// don't reset if running in test mode where we simulate sensors // don't reset if running in test mode where we simulate sensors
for (auto & sensor : sensors_) { for (auto & sensor : sensors_) {
sensor.temperature_c = EMS_VALUE_SHORT_NOTSET; sensor.temperature_c = EMS_VALUE_INT16_NOTSET;
} }
#endif #endif
} }
@@ -191,7 +191,7 @@ void TemperatureSensor::loop() {
if (++scancnt_ > SCAN_MAX) { if (++scancnt_ > SCAN_MAX) {
for (auto & sensor : sensors_) { for (auto & sensor : sensors_) {
if (!sensor.read) { if (!sensor.read) {
sensor.temperature_c = EMS_VALUE_SHORT_NOTSET; sensor.temperature_c = EMS_VALUE_INT16_NOTSET;
changed_ = true; changed_ = true;
} }
sensor.read = false; sensor.read = false;
@@ -226,7 +226,7 @@ int16_t TemperatureSensor::get_temperature_c(const uint8_t addr[]) {
#ifndef EMSESP_STANDALONE #ifndef EMSESP_STANDALONE
if (!bus_.reset()) { if (!bus_.reset()) {
LOG_ERROR("Bus reset failed before reading scratchpad from %s", Sensor(addr).id().c_str()); LOG_ERROR("Bus reset failed before reading scratchpad from %s", Sensor(addr).id().c_str());
return EMS_VALUE_SHORT_NOTSET; return EMS_VALUE_INT16_NOTSET;
} }
YIELD; YIELD;
@@ -238,7 +238,7 @@ int16_t TemperatureSensor::get_temperature_c(const uint8_t addr[]) {
if (!bus_.reset()) { if (!bus_.reset()) {
LOG_ERROR("Bus reset failed after reading scratchpad from %s", Sensor(addr).id().c_str()); LOG_ERROR("Bus reset failed after reading scratchpad from %s", Sensor(addr).id().c_str());
return EMS_VALUE_SHORT_NOTSET; return EMS_VALUE_INT16_NOTSET;
} }
YIELD; YIELD;
@@ -254,7 +254,7 @@ int16_t TemperatureSensor::get_temperature_c(const uint8_t addr[]) {
scratchpad[7], scratchpad[7],
scratchpad[8], scratchpad[8],
Sensor(addr).id().c_str()); Sensor(addr).id().c_str());
return EMS_VALUE_SHORT_NOTSET; return EMS_VALUE_INT16_NOTSET;
} }
int16_t raw_value = ((int16_t)scratchpad[SCRATCHPAD_TEMP_MSB] << 8) | scratchpad[SCRATCHPAD_TEMP_LSB]; int16_t raw_value = ((int16_t)scratchpad[SCRATCHPAD_TEMP_MSB] << 8) | scratchpad[SCRATCHPAD_TEMP_LSB];
@@ -281,7 +281,7 @@ int16_t TemperatureSensor::get_temperature_c(const uint8_t addr[]) {
raw_value = ((int32_t)raw_value * 625 + 500) / 1000; // round to 0.1 raw_value = ((int32_t)raw_value * 625 + 500) / 1000; // round to 0.1
return raw_value; return raw_value;
#else #else
return EMS_VALUE_SHORT_NOTSET; return EMS_VALUE_INT16_NOTSET;
#endif #endif
} }

2
src/temperaturesensor.h
View File

@@ -63,7 +63,7 @@ class TemperatureSensor {
bool apply_customization(); bool apply_customization();
// initial values // initial values
int16_t temperature_c = EMS_VALUE_SHORT_NOTSET; int16_t temperature_c = EMS_VALUE_INT16_NOTSET;
bool read = false; bool read = false;
bool ha_registered = false; bool ha_registered = false;

26
src/test/test.cpp
View File

@@ -439,47 +439,47 @@ void Test::run_test(uuid::console::Shell & shell, const std::string & cmd, const
uint8_t message_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // message_length is 9 uint8_t message_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // message_length is 9
auto telegram = std::make_shared<Telegram>(Telegram::Operation::RX, 0x10, 0x11, 0x1234, 0, message_data, sizeof(message_data)); auto telegram = std::make_shared<Telegram>(Telegram::Operation::RX, 0x10, 0x11, 0x1234, 0, message_data, sizeof(message_data));
uint8_t uint8b = EMS_VALUE_UINT_NOTSET; uint8_t uint8b = EMS_VALUE_UINT8_NOTSET;
telegram->read_value(uint8b, 0); telegram->read_value(uint8b, 0);
shell.printfln("uint8: expecting %02X, got:%02X", 1, uint8b); shell.printfln("uint8: expecting %02X, got:%02X", 1, uint8b);
int8_t int8b = EMS_VALUE_INT_NOTSET; int8_t int8b = EMS_VALUE_INT8_NOTSET;
telegram->read_value(int8b, 0); telegram->read_value(int8b, 0);
shell.printfln("int8: expecting %02X, got:%02X", 1, int8b); shell.printfln("int8: expecting %02X, got:%02X", 1, int8b);
uint16_t uint16b = EMS_VALUE_USHORT_NOTSET; uint16_t uint16b = EMS_VALUE_UINT16_NOTSET;
telegram->read_value(uint16b, 1); telegram->read_value(uint16b, 1);
shell.printfln("uint16: expecting %02X, got:%02X", 0x0203, uint16b); shell.printfln("uint16: expecting %02X, got:%02X", 0x0203, uint16b);
int16_t int16b = EMS_VALUE_SHORT_NOTSET; int16_t int16b = EMS_VALUE_INT16_NOTSET;
telegram->read_value(int16b, 1); telegram->read_value(int16b, 1);
shell.printfln("int16: expecting %02X, got:%02X", 0x0203, int16b); shell.printfln("int16: expecting %02X, got:%02X", 0x0203, int16b);
int16_t int16b8 = EMS_VALUE_SHORT_NOTSET; int16_t int16b8 = EMS_VALUE_INT16_NOTSET;
telegram->read_value(int16b8, 1, 1); // force to 1 byte telegram->read_value(int16b8, 1, 1); // force to 1 byte
shell.printfln("int16 1 byte: expecting %02X, got:%02X", 0x02, int16b8); shell.printfln("int16 1 byte: expecting %02X, got:%02X", 0x02, int16b8);
uint32_t uint32b = EMS_VALUE_ULONG_NOTSET; uint32_t uint32b = EMS_VALUE_UINT24_NOTSET;
telegram->read_value(uint32b, 1, 3); telegram->read_value(uint32b, 1, 3);
shell.printfln("uint32 3 bytes: expecting %02X, got:%02X", 0x020304, uint32b); shell.printfln("uint32 3 bytes: expecting %02X, got:%02X", 0x020304, uint32b);
uint32b = EMS_VALUE_ULONG_NOTSET; uint32b = EMS_VALUE_UINT24_NOTSET;
telegram->read_value(uint32b, 1); telegram->read_value(uint32b, 1);
shell.printfln("uint32 4 bytes: expecting %02X, got:%02X", 0x02030405, uint32b); shell.printfln("uint32 4 bytes: expecting %02X, got:%02X", 0x02030405, uint32b);
// check out of bounds // check out of bounds
uint16_t uint16 = EMS_VALUE_USHORT_NOTSET; uint16_t uint16 = EMS_VALUE_UINT16_NOTSET;
telegram->read_value(uint16, 9); telegram->read_value(uint16, 9);
shell.printfln("uint16 out-of-bounds: was:%02X, new:%02X", EMS_VALUE_USHORT_NOTSET, uint16); shell.printfln("uint16 out-of-bounds: was:%02X, new:%02X", EMS_VALUE_UINT16_NOTSET, uint16);
uint8_t uint8oob = EMS_VALUE_UINT_NOTSET; uint8_t uint8oob = EMS_VALUE_UINT8_NOTSET;
telegram->read_value(uint8oob, 9); telegram->read_value(uint8oob, 9);
shell.printfln("uint8 out-of-bounds: was:%02X, new:%02X", EMS_VALUE_UINT_NOTSET, uint8oob); shell.printfln("uint8 out-of-bounds: was:%02X, new:%02X", EMS_VALUE_UINT8_NOTSET, uint8oob);
// check read bit // check read bit
uint8_t uint8bitb = EMS_VALUE_UINT_NOTSET; uint8_t uint8bitb = EMS_VALUE_UINT8_NOTSET;
telegram->read_bitvalue(uint8bitb, 1, 1); // value is 0x02 = 0000 0010 telegram->read_bitvalue(uint8bitb, 1, 1); // value is 0x02 = 0000 0010
shell.printfln("uint8 bit read: expecting 1, got:%d", uint8bitb); shell.printfln("uint8 bit read: expecting 1, got:%d", uint8bitb);
uint8bitb = EMS_VALUE_UINT_NOTSET; uint8bitb = EMS_VALUE_UINT8_NOTSET;
telegram->read_bitvalue(uint8bitb, 0, 0); // value is 0x01 = 0000 0001 telegram->read_bitvalue(uint8bitb, 0, 0); // value is 0x01 = 0000 0001
shell.printfln("uint8 bit read: expecting 1, got:%d", uint8bitb); shell.printfln("uint8 bit read: expecting 1, got:%d", uint8bitb);

71
src/web/WebCustomEntityService.cpp
View File

@@ -93,16 +93,17 @@ StateUpdateResult WebCustomEntity::update(JsonObject root, WebCustomEntity & web
if (entityItem.value_type == DeviceValueType::BOOL) { if (entityItem.value_type == DeviceValueType::BOOL) {
entityItem.value = EMS_VALUE_DEFAULT_BOOL; entityItem.value = EMS_VALUE_DEFAULT_BOOL;
} else if (entityItem.value_type == DeviceValueType::INT) { } else if (entityItem.value_type == DeviceValueType::INT8) {
entityItem.value = EMS_VALUE_DEFAULT_INT; entityItem.value = EMS_VALUE_DEFAULT_INT8;
} else if (entityItem.value_type == DeviceValueType::UINT) { } else if (entityItem.value_type == DeviceValueType::UINT8) {
entityItem.value = EMS_VALUE_DEFAULT_UINT; entityItem.value = EMS_VALUE_DEFAULT_UINT8;
} else if (entityItem.value_type == DeviceValueType::SHORT) { } else if (entityItem.value_type == DeviceValueType::INT16) {
entityItem.value = EMS_VALUE_DEFAULT_SHORT; entityItem.value = EMS_VALUE_DEFAULT_INT16;
} else if (entityItem.value_type == DeviceValueType::USHORT) { } else if (entityItem.value_type == DeviceValueType::UINT16) {
entityItem.value = EMS_VALUE_DEFAULT_USHORT; entityItem.value = EMS_VALUE_DEFAULT_UINT16;
} else if (entityItem.value_type == DeviceValueType::ULONG || entityItem.value_type == DeviceValueType::TIME) { } else if (entityItem.value_type == DeviceValueType::UINT24 || entityItem.value_type == DeviceValueType::TIME
entityItem.value = EMS_VALUE_DEFAULT_ULONG; || entityItem.value_type == DeviceValueType::UINT32) {
entityItem.value = EMS_VALUE_DEFAULT_UINT24;
} }
if (entityItem.factor == 0) { if (entityItem.factor == 0) {
@@ -159,9 +160,9 @@ bool WebCustomEntityService::command_setvalue(const char * value, const std::str
return false; return false;
} }
int v = f / entityItem.factor; int v = f / entityItem.factor;
if (entityItem.value_type == DeviceValueType::UINT || entityItem.value_type == DeviceValueType::INT) { if (entityItem.value_type == DeviceValueType::UINT8 || entityItem.value_type == DeviceValueType::INT8) {
EMSESP::send_write_request(entityItem.type_id, entityItem.device_id, entityItem.offset, v, 0); EMSESP::send_write_request(entityItem.type_id, entityItem.device_id, entityItem.offset, v, 0);
} else if (entityItem.value_type == DeviceValueType::USHORT || entityItem.value_type == DeviceValueType::SHORT) { } else if (entityItem.value_type == DeviceValueType::UINT16 || entityItem.value_type == DeviceValueType::INT16) {
uint8_t v1[2] = {(uint8_t)(v >> 8), (uint8_t)(v & 0xFF)}; uint8_t v1[2] = {(uint8_t)(v >> 8), (uint8_t)(v & 0xFF)};
EMSESP::send_write_request(entityItem.type_id, entityItem.device_id, entityItem.offset, v1, 2, 0); EMSESP::send_write_request(entityItem.type_id, entityItem.device_id, entityItem.offset, v1, 2, 0);
} else { } else {
@@ -199,33 +200,34 @@ void WebCustomEntityService::render_value(JsonObject output, CustomEntityItem en
} }
} }
break; break;
case DeviceValueType::INT: case DeviceValueType::INT8:
if ((int8_t)entity.value != EMS_VALUE_INT_NOTSET) { if ((int8_t)entity.value != EMS_VALUE_INT8_NOTSET) {
std::string v = Helpers::render_value(payload, entity.factor * (int8_t)entity.value, 2); std::string v = Helpers::render_value(payload, entity.factor * (int8_t)entity.value, 2);
output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v); output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v);
} }
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
if ((uint8_t)entity.value != EMS_VALUE_UINT_NOTSET) { if ((uint8_t)entity.value != EMS_VALUE_UINT8_NOTSET) {
std::string v = Helpers::render_value(payload, entity.factor * (uint8_t)entity.value, 2); std::string v = Helpers::render_value(payload, entity.factor * (uint8_t)entity.value, 2);
output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v); output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v);
} }
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
if ((int16_t)entity.value != EMS_VALUE_SHORT_NOTSET) { if ((int16_t)entity.value != EMS_VALUE_INT16_NOTSET) {
std::string v = Helpers::render_value(payload, entity.factor * (int16_t)entity.value, 2); std::string v = Helpers::render_value(payload, entity.factor * (int16_t)entity.value, 2);
output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v); output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v);
} }
break; break;
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
if ((uint16_t)entity.value != EMS_VALUE_USHORT_NOTSET) { if ((uint16_t)entity.value != EMS_VALUE_UINT16_NOTSET) {
std::string v = Helpers::render_value(payload, entity.factor * (uint16_t)entity.value, 2); std::string v = Helpers::render_value(payload, entity.factor * (uint16_t)entity.value, 2);
output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v); output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v);
} }
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
case DeviceValueType::TIME: case DeviceValueType::TIME:
if (entity.value != EMS_VALUE_ULONG_NOTSET) { case DeviceValueType::UINT32:
if (entity.value != EMS_VALUE_UINT24_NOTSET) {
std::string v = Helpers::render_value(payload, entity.factor * entity.value, 2); std::string v = Helpers::render_value(payload, entity.factor * entity.value, 2);
output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v); output[name] = add_uom ? serialized(v + ' ' + EMSdevice::uom_to_string(entity.uom)) : serialized(v);
} }
@@ -510,29 +512,30 @@ void WebCustomEntityService::generate_value_web(JsonObject output) {
l.add(Helpers::render_boolean(s, true, true)); l.add(Helpers::render_boolean(s, true, true));
break; break;
} }
case DeviceValueType::INT: case DeviceValueType::INT8:
if ((int8_t)entity.value != EMS_VALUE_INT_NOTSET) { if ((int8_t)entity.value != EMS_VALUE_INT8_NOTSET) {
obj["v"] = Helpers::transformNumFloat(entity.factor * (int8_t)entity.value, 0); obj["v"] = Helpers::transformNumFloat(entity.factor * (int8_t)entity.value, 0);
} }
break; break;
case DeviceValueType::UINT: case DeviceValueType::UINT8:
if ((uint8_t)entity.value != EMS_VALUE_UINT_NOTSET) { if ((uint8_t)entity.value != EMS_VALUE_UINT8_NOTSET) {
obj["v"] = Helpers::transformNumFloat(entity.factor * (uint8_t)entity.value, 0); obj["v"] = Helpers::transformNumFloat(entity.factor * (uint8_t)entity.value, 0);
} }
break; break;
case DeviceValueType::SHORT: case DeviceValueType::INT16:
if ((int16_t)entity.value != EMS_VALUE_SHORT_NOTSET) { if ((int16_t)entity.value != EMS_VALUE_INT16_NOTSET) {
obj["v"] = Helpers::transformNumFloat(entity.factor * (int16_t)entity.value, 0); obj["v"] = Helpers::transformNumFloat(entity.factor * (int16_t)entity.value, 0);
} }
break; break;
case DeviceValueType::USHORT: case DeviceValueType::UINT16:
if ((uint16_t)entity.value != EMS_VALUE_USHORT_NOTSET) { if ((uint16_t)entity.value != EMS_VALUE_UINT16_NOTSET) {
obj["v"] = Helpers::transformNumFloat(entity.factor * (uint16_t)entity.value, 0); obj["v"] = Helpers::transformNumFloat(entity.factor * (uint16_t)entity.value, 0);
} }
break; break;
case DeviceValueType::ULONG: case DeviceValueType::UINT24:
case DeviceValueType::TIME: case DeviceValueType::TIME:
if (entity.value != EMS_VALUE_ULONG_NOTSET) { case DeviceValueType::UINT32:
if (entity.value != EMS_VALUE_UINT24_NOTSET) {
obj["v"] = Helpers::transformNumFloat(entity.factor * entity.value, 0); obj["v"] = Helpers::transformNumFloat(entity.factor * entity.value, 0);
} }
break; break;
@@ -557,7 +560,7 @@ void WebCustomEntityService::generate_value_web(JsonObject output) {
// fetch telegram, called from emsesp::fetch // fetch telegram, called from emsesp::fetch
void WebCustomEntityService::fetch() { void WebCustomEntityService::fetch() {
EMSESP::webCustomEntityService.read([&](WebCustomEntity & webEntity) { customEntityItems = &webEntity.customEntityItems; }); EMSESP::webCustomEntityService.read([&](WebCustomEntity & webEntity) { customEntityItems = &webEntity.customEntityItems; });
const uint8_t len[] = {1, 1, 1, 2, 2, 3, 3}; const uint8_t len[] = {1, 1, 1, 2, 2, 3, 3, 4};
for (auto & entity : *customEntityItems) { for (auto & entity : *customEntityItems) {
if (entity.device_id > 0 && entity.type_id > 0) { // ths excludes also RAM type if (entity.device_id > 0 && entity.type_id > 0) { // ths excludes also RAM type
@@ -589,7 +592,7 @@ bool WebCustomEntityService::get_value(std::shared_ptr<const Telegram> telegram)
bool has_change = false; bool has_change = false;
EMSESP::webCustomEntityService.read([&](WebCustomEntity & webEntity) { customEntityItems = &webEntity.customEntityItems; }); EMSESP::webCustomEntityService.read([&](WebCustomEntity & webEntity) { customEntityItems = &webEntity.customEntityItems; });
// read-length of BOOL, INT, UINT, SHORT, USHORT, ULONG, TIME // read-length of BOOL, INT, UINT, SHORT, USHORT, ULONG, TIME
const uint8_t len[] = {1, 1, 1, 2, 2, 3, 3}; const uint8_t len[] = {1, 1, 1, 2, 2, 3, 3, 4};
for (auto & entity : *customEntityItems) { for (auto & entity : *customEntityItems) {
if (entity.value_type == DeviceValueType::STRING && telegram->type_id == entity.type_id && telegram->src == entity.device_id if (entity.value_type == DeviceValueType::STRING && telegram->type_id == entity.type_id && telegram->src == entity.device_id
&& telegram->offset <= entity.offset && (telegram->offset + telegram->message_length) >= (entity.offset + (uint8_t)entity.factor)) { && telegram->offset <= entity.offset && (telegram->offset + telegram->message_length) >= (entity.offset + (uint8_t)entity.factor)) {