Overly long data attribute received as 0 #3561

anotherjulien · 2024-11-28T21:08:25Z

anotherjulien
Nov 28, 2024

Hello folks,

I'm working on a custom quirk for a variant of a Tuya DIN power meter ("_TZE200_rhblgy0z", "TS0601").
I've based most of the work on #3098.

However, where this variant differs is in the energy data, it still comes in the 0x0201 attribute on the 0xef00 cluster, but the data is weirdly long and needs to be processed.

2024-11-28 15:04:12.835 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Received ZCL frame: b'\t\xb2\x02\n\xd8\x01\x02\x00\x04\x00\x00z\xab\x02\x02\x00\x04\x00\x00\x00\x00'
2024-11-28 15:04:12.835 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Decoded ZCL frame header: ZCLHeader(frame_control=FrameControl<0x09>(frame_type=<FrameType.CLUSTER_COMMAND: 1>, is_manufacturer_specific=0, direction=<Direction.Server_to_Client: 1>, disable_default_response=0, reserved=0, *is_cluster=True, *is_general=False), tsn=178, command_id=2, *direction=<Direction.Server_to_Client: 1>)
2024-11-28 15:04:12.836 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Decoded ZCL frame: TuyaVar01ManufClusterDinPower:set_data_response(param=Command(status=10, tsn=216, command_id=513, function=0, data=[4, 0, 0, 122, 171, 2, 2, 0, 4, 0, 0, 0, 0]))
2024-11-28 15:04:12.836 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Received command 0x02 (TSN 178): set_data_response(param=Command(status=10, tsn=216, command_id=513, function=0, data=[4, 0, 0, 122, 171, 2, 2, 0, 4, 0, 0, 0, 0]))
2024-11-28 15:04:12.836 DEBUG (MainThread) [zhaquirks.tuya] [0x2192:1:0xef00] Received value [0, 0, 122, 171, 2, 2, 0, 4, 0, 0, 0, 0] for attribute 0x0201 (command 0x0002)
2024-11-28 15:04:12.836 DEBUG (MainThread) [zha.zigbee.cluster_handlers] [0x2192:1:0xef00]: cluster_handler[tuya_manufacturer] attribute_updated - cluster[Tuya Manufacturer Specicific] attr[energy_delivered] value[0]
2024-11-28 15:04:12.837 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Sending reply header: ZCLHeader(frame_control=FrameControl<0x10>(frame_type=<FrameType.GLOBAL_COMMAND: 0>, is_manufacturer_specific=False, direction=<Direction.Client_to_Server: 0>, disable_default_response=1, reserved=0, *is_cluster=False, *is_general=True), tsn=178, command_id=<GeneralCommand.Default_Response: 11>, *direction=<Direction.Client_to_Server: 0>)
2024-11-28 15:04:12.838 DEBUG (MainThread) [zigpy.zcl] [0x2192:1:0xef00] Sending reply: Default_Response(command_id=2, status=<Status.SUCCESS: 0>)

The data block [0, 0, 122, 171, 2, 2, 0, 4, 0, 0, 0, 0] is 96 bits long.
The part I'm interested in is the 122, 171 which represents the total energy delivered.
Should it work correctly, a 'simple' ((value & 0x0000FFFF0000000000000000) >> 64) /100 would give me what I want.
But when I receive that data in my overridden _update_attribute, the value is 0.

I'm not sure if it's because the data block is longer than the biggest unsigned int in zigpy/types/basic.py (which is 64 bits)
In this case, if I set the attribute type to uint64_t, does the FixedIntType class chops the last 32bits?
Does it give up a send 0?
Should I locally define a uint96_t the same way it's defined in zigpy/types/basic.py?

Thanks for any pointer! I'm pulling my hair out!

Answered by prairiesnpr

Nov 30, 2024

Ok, so looking at the Z2M converter, it looks like that's actually a string?

See: https://github.com/Koenkk/zigbee-herdsman-converters/blob/8e3ed7c41eaa4d008d7c459ee98c8353b96423bc/src/devices/tuya.ts#L6222

Then: https://github.com/Koenkk/zigbee-herdsman-converters/blob/8e3ed7c41eaa4d008d7c459ee98c8353b96423bc/src/lib/tuya.ts#L622

Maybe try t.CharacterString similar to this?

View full answer

prairiesnpr · 2024-11-30T13:40:31Z

prairiesnpr
Nov 30, 2024

Can you post a link to your full quirk?

1 reply

anotherjulien Nov 30, 2024
Author

Sure, here it is:

"""Tuya Din Power Meter."""
import logging
from zigpy.profiles import zgp, zha
import zigpy.types as t
from zigpy.zcl.clusters.general import Basic, GreenPowerProxy, Groups, Ota, Scenes, Time
from zigpy.zcl.clusters.homeautomation import ElectricalMeasurement
from zigpy.zcl.clusters.smartenergy import Metering

from zhaquirks import Bus, LocalDataCluster
from zhaquirks.const import (
    DEVICE_TYPE,
    ENDPOINTS,
    INPUT_CLUSTERS,
    MODELS_INFO,
    OUTPUT_CLUSTERS,
    PROFILE_ID,
)
from zhaquirks.tuya import TuyaManufClusterAttributes, TuyaOnOff, TuyaSwitch

TUYA_TOTAL_ENERGY_ATTR = 0x0211 #energy
TUYA_CURRENT_ATTR = 0x0212 #current
TUYA_POWER_ATTR = 0x0213 #power
TUYA_VOLTAGE_ATTR = 0x0214 #voltaje
TUYA_DIN_SWITCH_ATTR = 0x0101 #switch

SWITCH_EVENT = "switch_event"

"""Hiking Power Meter Attributes"""
HIKING_DIN_SWITCH_ATTR = 0x0110
HIKING_TOTAL_ENERGY_DELIVERED_ATTR = 0x0201
HIKING_TOTAL_ENERGY_RECEIVED_ATTR = 0x0266
HIKING_VOLTAGE_CURRENT_ATTR = 0x0006
HIKING_POWER_ATTR = 0x0267
HIKING_FREQUENCY_ATTR = 0x0269
HIKING_POWER_FACTOR_ATTR = 0x026F
HIKING_TOTAL_REACTIVE_ATTR = 0x026D
HIKING_REACTIVE_POWER_ATTR = 0x026E

"""Var01 Power Meter Attributes"""
TUYA_VAR01_TOTAL_ENERGY_DELIVERED_ATTR = 0x0201
TUYA_VAR01_VOLTAGE_CURRENT_ATTR = 0x0006

_LOGGER = logging.getLogger(__name__)

class TuyaManufClusterDinPower(TuyaManufClusterAttributes):
    """Manufacturer Specific Cluster of the Tuya Power Meter device."""

    attributes = {
        TUYA_TOTAL_ENERGY_ATTR: ("energy", t.uint32_t, True),
        TUYA_CURRENT_ATTR: ("current", t.int16s, True),
        TUYA_POWER_ATTR: ("power", t.uint16_t, True),
        TUYA_VOLTAGE_ATTR: ("voltage", t.uint16_t, True),
        TUYA_DIN_SWITCH_ATTR: ("switch", t.uint8_t, True),
    }

    def _update_attribute(self, attrid, value):
        super()._update_attribute(attrid, value)
        if attrid == TUYA_TOTAL_ENERGY_ATTR:
            self.endpoint.smartenergy_metering.energy_deliver_reported(value / 100)
        elif attrid == TUYA_CURRENT_ATTR:
            self.endpoint.electrical_measurement.current_reported(value)
        elif attrid == TUYA_POWER_ATTR:
            self.endpoint.electrical_measurement.power_reported(value / 10)
        elif attrid == TUYA_VOLTAGE_ATTR:
            self.endpoint.electrical_measurement.voltage_reported(value / 10)
        elif attrid == TUYA_DIN_SWITCH_ATTR:
            self.endpoint.device.switch_bus.listener_event(
                SWITCH_EVENT, self.endpoint.endpoint_id, value
            )


class TuyaPowerMeasurement(LocalDataCluster, ElectricalMeasurement):
    """Custom class for power, voltage and current measurement."""

    cluster_id = ElectricalMeasurement.cluster_id

    POWER_ID = 0x050B
    VOLTAGE_ID = 0x0505
    CURRENT_ID = 0x0508
    REACTIVE_POWER_ID = 0x050E
    AC_FREQUENCY_ID = 0x0300
    TOTAL_REACTIVE_POWER_ID = 0x0305
    POWER_FACTOR_ID = 0x0510

    AC_VOLTAGE_MULTIPLIER = 0x0600
    AC_VOLTAGE_DIVISOR = 0x0601
    AC_CURRENT_MULTIPLIER = 0x0602
    AC_CURRENT_DIVISOR = 0x0603
    AC_FREQUENCY_MULTIPLIER = 0x0400
    AC_FREQUENCY_DIVISOR = 0x0401

    _CONSTANT_ATTRIBUTES = {
        AC_VOLTAGE_MULTIPLIER: 1,
        AC_VOLTAGE_DIVISOR: 10,
        AC_CURRENT_MULTIPLIER: 1,
        AC_CURRENT_DIVISOR: 1000,
        AC_FREQUENCY_MULTIPLIER: 1,
        AC_FREQUENCY_DIVISOR: 100,
    }

    def voltage_reported(self, value):
        """Voltage reported."""
        self._update_attribute(self.VOLTAGE_ID, value)

    def power_reported(self, value):
        """Power reported."""
        self._update_attribute(self.POWER_ID, value)

    def power_factor_reported(self, value):
        """Power Factor reported."""
        self._update_attribute(self.POWER_FACTOR_ID, value)

    def reactive_power_reported(self, value):
        """Reactive Power reported."""
        self._update_attribute(self.REACTIVE_POWER_ID, value)

    def current_reported(self, value):
        """Ampers reported."""
        self._update_attribute(self.CURRENT_ID, value)

    def frequency_reported(self, value):
        """AC Frequency reported."""
        self._update_attribute(self.AC_FREQUENCY_ID, value)

    def reactive_energy_reported(self, value):
        """Summation Reactive Energy reported."""
        self._update_attribute(self.TOTAL_REACTIVE_POWER_ID, value)


class TuyaElectricalMeasurement(LocalDataCluster, Metering):
    """Custom class for total energy measurement."""

    cluster_id = Metering.cluster_id

    CURRENT_DELIVERED_ID = 0x0000
    CURRENT_RECEIVED_ID = 0x0001
    #CURRENT_TIER1_DELIVERED_ID = 0x0100
    POWER_WATT = 0x0000

    """Setting unit of measurement."""
    _CONSTANT_ATTRIBUTES = {0x0300: POWER_WATT}

    def energy_deliver_reported(self, value):
        """Summation Energy Deliver reported."""
        self._update_attribute(self.CURRENT_DELIVERED_ID, value)

    def energy_receive_reported(self, value):
        """Summation Energy Receive reported."""
        self._update_attribute(self.CURRENT_RECEIVED_ID, value)

    #def energy_tier1_deliver_reported(self, value):
    #    """Summation Energy Tier1 Receive reported."""
    #    self._update_attribute(self.CURRENT_TIER1_DELIVERED_ID, value)

class HikingManufClusterDinPower(TuyaManufClusterAttributes):
    """Manufacturer Specific Cluster of the Hiking Power Meter device."""

    attributes = {
        HIKING_DIN_SWITCH_ATTR: ("switch", t.uint8_t, True),
        HIKING_TOTAL_ENERGY_DELIVERED_ATTR: ("energy_delivered", t.uint32_t, True),
        HIKING_TOTAL_ENERGY_RECEIVED_ATTR: ("energy_received", t.uint16_t, True),
        HIKING_VOLTAGE_CURRENT_ATTR: ("voltage_current", t.uint32_t, True),
        HIKING_POWER_ATTR: ("power", t.uint16_t, True),
        HIKING_FREQUENCY_ATTR: ("frequency", t.uint16_t, True),
        HIKING_TOTAL_REACTIVE_ATTR: ("total_reactive_energy", t.int32s, True),
        HIKING_REACTIVE_POWER_ATTR: ("reactive_power", t.int16s, True),
        HIKING_POWER_FACTOR_ATTR: ("power_factor", t.uint16_t, True),
    }

    def _update_attribute(self, attrid, value):
        super()._update_attribute(attrid, value)
        if attrid == HIKING_DIN_SWITCH_ATTR:
            self.endpoint.device.switch_bus.listener_event(SWITCH_EVENT, 16, value)
        elif attrid == HIKING_TOTAL_ENERGY_DELIVERED_ATTR:
            self.endpoint.smartenergy_metering.energy_deliver_reported(value / 100)
        elif attrid == HIKING_TOTAL_ENERGY_RECEIVED_ATTR:
            self.endpoint.smartenergy_metering.energy_receive_reported(value / 100)
        elif attrid == HIKING_VOLTAGE_CURRENT_ATTR:
            self.endpoint.electrical_measurement.current_reported(value >> 16)
            self.endpoint.electrical_measurement.voltage_reported(
                (value & 0x0000FFFF) / 10
            )
        elif attrid == HIKING_POWER_ATTR:
            self.endpoint.electrical_measurement.power_reported(value)
        elif attrid == HIKING_FREQUENCY_ATTR:
            self.endpoint.electrical_measurement.frequency_reported(value)
        elif attrid == HIKING_TOTAL_REACTIVE_ATTR:
            self.endpoint.electrical_measurement.reactive_energy_reported(value)
        elif attrid == HIKING_REACTIVE_POWER_ATTR:
            self.endpoint.electrical_measurement.reactive_power_reported(value)
        elif attrid == HIKING_POWER_FACTOR_ATTR:
            self.endpoint.electrical_measurement.power_factor_reported(value / 10)

class TuyaVar01ManufClusterDinPower(TuyaManufClusterAttributes):
    """Manufacturer Specific Cluster of the MatSee Power Meter device."""

    attributes = {
        HIKING_DIN_SWITCH_ATTR: ("switch", t.uint8_t, True),
        TUYA_VAR01_TOTAL_ENERGY_DELIVERED_ATTR: ("energy_delivered", t.uint64_t, True),
        TUYA_VAR01_VOLTAGE_CURRENT_ATTR: ("voltage_current", t.uint64_t, True),
    }

    def _update_attribute(self, attrid, value):
        super()._update_attribute(attrid, value)
        if attrid == HIKING_DIN_SWITCH_ATTR:
            self.endpoint.device.switch_bus.listener_event(SWITCH_EVENT, 16, value)
        elif attrid == TUYA_VAR01_TOTAL_ENERGY_DELIVERED_ATTR:
            energy = (value & 0x0000FFFF0000000000000000) >> 64
            self.endpoint.smartenergy_metering.energy_deliver_reported(energy /100)
        elif attrid == TUYA_VAR01_VOLTAGE_CURRENT_ATTR:
            power = value & 0x000000000000FFFF
            current = (value & 0x000000FFFF000000) >> 24
            tension = value >> 48
            self.endpoint.electrical_measurement.power_reported(power)
            self.endpoint.electrical_measurement.current_reported(current)
            self.endpoint.electrical_measurement.voltage_reported(tension)


class TuyaPowerMeter(TuyaSwitch):
    """Tuya power meter device."""

    def __init__(self, *args, **kwargs):
        """Init device."""
        self.switch_bus = Bus()
        super().__init__(*args, **kwargs)

    signature = {
        # "node_descriptor": "<NodeDescriptor byte1=1 byte2=64 mac_capability_flags=142 manufacturer_code=4098
        #                       maximum_buffer_size=82 maximum_incoming_transfer_size=82 server_mask=11264
        #                       maximum_outgoing_transfer_size=82 descriptor_capability_field=0>",
        # device_version=1
        # input_clusters=[0x0000, 0x0004, 0x0005, 0xef00]
        # output_clusters=[0x000a, 0x0019]
        MODELS_INFO: [
            ("_TZE200_byzdayie", "TS0601"),
            ("_TZE200_ewxhg6o9", "TS0601"),
        ],
        ENDPOINTS: {
            # <SimpleDescriptor endpoint=1 profile=260 device_type=51
            # device_version=1
            # input_clusters=[0, 4, 5, 61184]
            # output_clusters=[10, 25]>
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaManufClusterAttributes.cluster_id,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            }
        },
    }

    replacement = {
        ENDPOINTS: {
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaManufClusterDinPower,
                    TuyaPowerMeasurement,
                    TuyaElectricalMeasurement,
                    TuyaOnOff,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            }
        }
    }


class HikingPowerMeter(TuyaSwitch):
    """Hiking Power Meter Device - DDS238-2."""

    signature = {
        # "node_descriptor": "<NodeDescriptor byte1=1 byte2=64 mac_capability_flags=142 manufacturer_code=4098
        #                       maximum_buffer_size=82 maximum_incoming_transfer_size=82 server_mask=11264
        #                       maximum_outgoing_transfer_size=82 descriptor_capability_field=0>",
        # device_version=1
        # input_clusters=[0x0000, 0x0004, 0x0005, 0xef00]
        # output_clusters=[0x000a, 0x0019]
        MODELS_INFO: [("_TZE200_bkkmqmyo", "TS0601")],
        ENDPOINTS: {
            # <SimpleDescriptor endpoint=1 profile=260 device_type=51
            # device_version=1
            # input_clusters=[0, 4, 5, 61184]
            # output_clusters=[10, 25]>
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaManufClusterAttributes.cluster_id,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            }
        },
    }

    replacement = {
        ENDPOINTS: {
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    HikingManufClusterDinPower,
                    TuyaElectricalMeasurement,
                    TuyaPowerMeasurement,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            },
            16: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    TuyaOnOff,
                ],
                OUTPUT_CLUSTERS: [],
            },
        }
    }

class TuyaVar01PowerMeter(TuyaSwitch):
    """WhiteLabel Power Meter Device - TAC2161C"""

    def __init__(self, *args, **kwargs):
        """Init device."""
        self.switch_bus = Bus()
        super().__init__(*args, **kwargs)

    signature = {
        # "node_descriptor": "<NodeDescriptor byte1=1 byte2=64 mac_capability_flags=142 manufacturer_code=4098
        #                       maximum_buffer_size=82 maximum_incoming_transfer_size=82 server_mask=11264
        #                       maximum_outgoing_transfer_size=82 descriptor_capability_field=0>",
        # device_version=1
        # input_clusters=[0x0000, 0x0004, 0x0005, 0xef00]
        # output_clusters=[0x000a, 0x0019]
        MODELS_INFO: [("_TZE200_rhblgy0z", "TS0601")],
        ENDPOINTS: {
            # <SimpleDescriptor endpoint=1 profile=260 device_type=51
            # device_version=1
            # input_clusters=[0, 4, 5, 61184]
            # output_clusters=[10, 25]>
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaManufClusterAttributes.cluster_id,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            },
            242: {
                PROFILE_ID: zgp.PROFILE_ID,
                DEVICE_TYPE: zgp.DeviceType.PROXY_BASIC,
                INPUT_CLUSTERS: [],
                OUTPUT_CLUSTERS: [GreenPowerProxy.cluster_id],
            },
        },
    }

    replacement = {
        ENDPOINTS: {
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaVar01ManufClusterDinPower,
                    TuyaElectricalMeasurement,
                    TuyaPowerMeasurement,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            },
            242: {
                PROFILE_ID: zgp.PROFILE_ID,
                DEVICE_TYPE: zgp.DeviceType.PROXY_BASIC,
                INPUT_CLUSTERS: [],
                OUTPUT_CLUSTERS: [GreenPowerProxy.cluster_id],
            },
        }
    }

prairiesnpr · 2024-11-30T14:40:32Z

prairiesnpr
Nov 30, 2024

Ok, so looking at the Z2M converter, it looks like that's actually a string?

See: https://github.com/Koenkk/zigbee-herdsman-converters/blob/8e3ed7c41eaa4d008d7c459ee98c8353b96423bc/src/devices/tuya.ts#L6222

Then: https://github.com/Koenkk/zigbee-herdsman-converters/blob/8e3ed7c41eaa4d008d7c459ee98c8353b96423bc/src/lib/tuya.ts#L622

Maybe try t.CharacterString similar to this?

0 replies

anotherjulien · 2024-11-30T19:36:11Z

anotherjulien
Nov 30, 2024
Author

You're right, it appears to be a CharacterString !
Oddly enough, compared to the z2m implementation, here energy is a CharacterString while the combined voltage/power/current is a uint64_twhile in z2m it's the opposite...
Anyway, thank you!
Now I'm off to learn how to do the bitwise operations I need on this :-)

0 replies

anotherjulien · 2024-12-01T15:28:30Z

anotherjulien
Dec 1, 2024
Author

Addendum:

While poking around with types, I've stumbled upon the TuyaData type in zhaquirks.tuya.
With this type, I can retrieve the bytearray directly through value.raw.
It allows me to directly manipulate the bytearray which is a lot easier.
I've also found that the first 4 bytes in the attribute are 'delivered energy' and the last 4 are 'received energy'. (The 4 in the middle are unknown but seem to always be \x02\x02\x00\x04)

So, for anyone finding this on their quest for solutions, here is what differs in my quirk vs the stock ts0601_din_power.py

from zhaquirks.tuya import TuyaManufClusterAttributes, TuyaData, TuyaOnOff, TuyaSwitch

"""Var01 Power Meter Attributes"""
TUYA_VAR01_TOTAL_ENERGY_ATTR = 0x0201
TUYA_VAR01_VOLTAGE_CURRENT_ATTR = 0x0006

class TuyaVar01ManufClusterDinPower(TuyaManufClusterAttributes):
    """Manufacturer Specific Cluster of the MatSee Power Meter device."""

    attributes = {
        TUYA_VAR01_TOTAL_ENERGY_ATTR: ("energy_delivered", TuyaData, True),
        TUYA_VAR01_TOTAL_ENERGY_ATTR: ("energy_received", TuyaData, True),
        TUYA_VAR01_VOLTAGE_CURRENT_ATTR: ("voltage_current", t.uint64_t, True),
    }

    def _update_attribute(self, attrid, value):
        super()._update_attribute(attrid, value)
        if attrid == TUYA_VAR01_TOTAL_ENERGY_ATTR:
            energy_delivered = int.from_bytes(value.raw[1:5], byteorder='big', signed=False)
            energy_received = int.from_bytes(value.raw[9:], byteorder='big', signed=False)
            self.endpoint.smartenergy_metering.energy_deliver_reported(energy_delivered /100)
            self.endpoint.smartenergy_metering.energy_receive_reported(energy_received /100)
        elif attrid == TUYA_VAR01_VOLTAGE_CURRENT_ATTR:
            power = value & 0x000000000000FFFF
            current = (value & 0x000000FFFF000000) >> 24
            tension = value >> 48
            self.endpoint.electrical_measurement.power_reported(power)
            self.endpoint.electrical_measurement.current_reported(current)
            self.endpoint.electrical_measurement.voltage_reported(tension)

class TuyaVar01PowerMeter(TuyaSwitch):
    """WhiteLabel Power Meter Device - TAC2161C"""

    def __init__(self, *args, **kwargs):
        """Init device."""
        self.switch_bus = Bus()
        super().__init__(*args, **kwargs)

    signature = {
        # "node_descriptor": "<NodeDescriptor byte1=1 byte2=64 mac_capability_flags=142 manufacturer_code=4098
        #                       maximum_buffer_size=82 maximum_incoming_transfer_size=82 server_mask=11264
        #                       maximum_outgoing_transfer_size=82 descriptor_capability_field=0>",
        # device_version=1
        # input_clusters=[0x0000, 0x0004, 0x0005, 0xef00]
        # output_clusters=[0x000a, 0x0019]
        MODELS_INFO: [("_TZE200_rhblgy0z", "TS0601")],
        ENDPOINTS: {
            # <SimpleDescriptor endpoint=1 profile=260 device_type=51
            # device_version=1
            # input_clusters=[0, 4, 5, 61184]
            # output_clusters=[10, 25]>
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaManufClusterAttributes.cluster_id,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            },
            242: {
                PROFILE_ID: zgp.PROFILE_ID,
                DEVICE_TYPE: zgp.DeviceType.PROXY_BASIC,
                INPUT_CLUSTERS: [],
                OUTPUT_CLUSTERS: [GreenPowerProxy.cluster_id],
            },
        },
    }

    replacement = {
        ENDPOINTS: {
            1: {
                PROFILE_ID: zha.PROFILE_ID,
                DEVICE_TYPE: zha.DeviceType.SMART_PLUG,
                INPUT_CLUSTERS: [
                    Basic.cluster_id,
                    Groups.cluster_id,
                    Scenes.cluster_id,
                    TuyaVar01ManufClusterDinPower,
                    TuyaElectricalMeasurement,
                    TuyaPowerMeasurement,
                ],
                OUTPUT_CLUSTERS: [Time.cluster_id, Ota.cluster_id],
            },
            242: {
                PROFILE_ID: zgp.PROFILE_ID,
                DEVICE_TYPE: zgp.DeviceType.PROXY_BASIC,
                INPUT_CLUSTERS: [],
                OUTPUT_CLUSTERS: [GreenPowerProxy.cluster_id],
            },
        }
    }

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Overly long data attribute received as 0 #3561

{{title}}

Replies: 4 comments 1 reply

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Overly long data attribute received as 0 #3561

anotherjulien Nov 28, 2024

Replies: 4 comments · 1 reply

prairiesnpr Nov 30, 2024

anotherjulien Nov 30, 2024 Author

prairiesnpr Nov 30, 2024

anotherjulien Nov 30, 2024 Author

anotherjulien Dec 1, 2024 Author

anotherjulien
Nov 28, 2024

Replies: 4 comments 1 reply

prairiesnpr
Nov 30, 2024

anotherjulien Nov 30, 2024
Author

prairiesnpr
Nov 30, 2024

anotherjulien
Nov 30, 2024
Author

anotherjulien
Dec 1, 2024
Author