[ST Edge] Zigbee Illuminance Measurement

I have tried my Xiaomi Mijia Smart Light Sensor with the zigbee-illuminance-sensor driver, which pairs the device with the driver successfully, however the illuminance value doesn’t seem to change in the app nor do any values show up in the device logs for the illuminance values.

When checking the history tab on the device screen in the app no values are shown here also.

There’s currently an issue with the illuminanceMeasurement default handlers, this prevents the creation of the events.
This is already reported, if you want to use a Driver with this capability you should define your own handlers for now.

Thanks and apologies I had not noticed this in the reported bugs.

I did try creating a device handler based on the custom groovy DTH however I couldn’t get it to report anything either.
My experience with these drivers is very minimal, still trying to understand how all the prices fit together

Don’t worry @Benjamin_Ginders, you can post your questions and we can go solving them while you continue your tests.

Thanks I appreciate your support.

So far from what I understand, the main 2 components of configuring a device to SmartThings is:

  1. Capabilities - which is basically a library of functions in the form of JSON files

  2. Drivers - which map the device functions to the capabilities, also mapping actions and display tiles.

So for the current illuminance driver is it the driver which is faulty or the capabilities or something else?

Within the driver there are several files, for the basic case of an illuminance Sensor with just lux variables being passed I would have the following:

Config.yml - gives the driver a name/ package ID along with opening the device communication type e.g. ZIGBEE ZWAVE…

Fingerprint.yml - which provides the identification of the device and its capabilities either listed with codes or names e.g. illuminanceMeasurement or 0x0400
and LUMI.LUX… OR 0106/0104

INIT.lua - which provides the device commands receives and sends also mapping fingerprint items to actions

Test-luminamce-sensor/ Xiaomi-luminance-sensor - which adds the ability to add multiple device configurations e.g. Xiaomi, LUMI and Philips.

Is this correct?
If that is correct what files would I need to adjust to map a new handler… Is it a new capability or the LUA files

You need to:

  • Import the corresponding cluster:
local clusters = require "st.zigbee.zcl.clusters"
local IlluminanceMeasurement = clusters.IlluminanceMeasurement
  • Create the function that will handle the events, taking, for example, the default handler:
function illuminance_attr_handler(driver, device, value, zb_rx)
  local lux_value = math.floor(10 ^ ((value.value - 1) / 10000))
  device:emit_event_for_endpoint(zb_rx.address_header.src_endpoint.value, capabilities.illuminanceMeasurement.illuminance(lux_value))
end

There, the Math.pow() is replaced as that’s the one causing an error.

local mydriver = {
    supported_capabilities = { ... },
    zigbee_handlers = {
        global = {},
        cluster = {},
        attr = {
            [IlluminanceMeasurement.ID] = {
                [IlluminanceMeasurement.attributes.MeasuredValue.ID] = illuminance_attr_handler
            }
        }
    }
 }

Let me know if you have any questions.

@nayelyz is this all to be added to the init.lua.

just tried adding and I get a fatal error in the logs:
FATAL Zigbee Illuminance Sensor Lua: runtime error: [string “init.lua”]:43: attempt to index a nil value (global ‘zigbee_illuminance_driver’)

EDIT:

after correcting a few bugs, I am now getting logs for the device but no illuminance measurements:

Ok, do you see any logs of the reporting configuration from the illuminanceMeasurement cluster?
If not, please add the doConfigure lifecycle as in this example, just ommit the “driver specific behavior” so it would look like this:

local function configure_device(self, device)
    device:configure()
end

Check if after this, there are is a TX message of the reporting configuration and if you receive the RX message of “success”

I am getting the below RX messages

ok, that’s before making the change I suggested?

It seems the reporting configuration is not being sent, you should see a similar message to the one below, a sample from the temperatureMeasurement cluster:

Apologies for the delay in response, I have had a busy week at work.

Progress, I can now see battery reports but I cannot see the illuminance still.

Below is the init.lua from the src folder:

local capabilities = require "st.capabilities"
local ZigbeeDriver = require "st.zigbee"
local defaults = require "st.zigbee.defaults"
local constants = require "st.zigbee.constants"


local zigbee_illuminance_driver = {
  supported_capabilities = {
    capabilities.illuminanceMeasurement,
    capabilities.battery,
  },
sub_drivers = {
                require("lumi-lux")
              }
    }

defaults.register_for_default_handlers(zigbee_illuminance_driver, zigbee_illuminance_driver.supported_capabilities)
local driver = ZigbeeDriver("zigbee-illuminance", zigbee_illuminance_driver)
driver:run(false)

And here is the init.lua for the sub driver:

local constants = require "st.zigbee.constants"
local clusters = require "st.zigbee.zcl.clusters"
local capabilities = require "st.capabilities"
local battery_defaults = require "st.zigbee.defaults.battery_defaults"
local log = require "log"

local function configure_device(self, device)
  device:configure()
end

local  XIAOMI_ILLUMINANCE_SENSOR_FINGERPRINTS = {
    {mfr = "LUMI", model = "lumi.sen_ill.mgl01"},
    {mfr = "XIAOMI", model = "lumi.sen_ill.mgl01"},
    {mfr = "LUMI", model = "lumi.sen_ill"},
    {mfr = "XIAOMI", model = "lumi.sen_ill"}
}

local is_xiaomi_illuminance = function(opts, driver, device)
    for _, fingerprint in ipairs(XIAOMI_ILLUMINANCE_SENSOR_FINGERPRINTS) do
        if device:get_manufacturer() == fingerprint.mfr and device:get_model() == fingerprint.model then
            return true
        end
    end
    return true
end


local function illuminance_attr_handler(driver, device, value, zb_rx)
  log.debug("illuminance_attr_handler " .. tostring(value))

  local lux_value = value.value --math.floor(10 ^ ((value.value - 1) / 10000))
  device:emit_event_for_endpoint(zb_rx.address_header.src_endpoint.value, capabilities.illuminanceMeasurement.illuminance(lux_value))
end

local function battery_attr_handler(driver, device, value, zb_rx)
    log.debug("battery_attr_handler value is " .. tostring())
    device:emit_event(capabilities.battery.battery(55)) 
end

local function device_added(self, device)
    device:refresh()
end

local lumi_illuminance_handler = {
  NAME = "Lumi Illuminance Handler",
  lifecycle_handlers = {
    init = battery_defaults.build_linear_voltage_init(2.1, 3.0),
    doConfigure = configure_device
  },
  zigbee_handlers = {
    attr = {
      [clusters.IlluminanceMeasurement.ID]= {
        [clusters.IlluminanceMeasurement.attributes.MeasuredValue.ID] = illuminance_attr_handler
      },
      [clusters.Basic.ID] = {
        [0xFF01] = battery_attr_handler 
      }
    }
  },
  can_handle = is_xiaomi_illuminance
} 
return lumi_illuminance_handler 

For the logs I am seeing the following:

2021-09-10T21:17:33.837578612+00:00 TRACE Zigbee Illuminance Sensor  Setup driver zigbee-illuminance with lifecycle handlers:
DeviceLifecycleDispatcher: zigbee-illuminance
  default_handlers:
    infoChanged:
    driverSwitched:
    removed:
    added:
    init:
    doConfigure:
  child_dispatchers:
    DeviceLifecycleDispatcher: zigbee-illuminance -> Lumi Illuminance Handler
      default_handlers:
        init:
        doConfigure:
      child_dispatchers:

2021-09-10T21:17:33.844228945+00:00 TRACE Zigbee Illuminance Sensor  Setup driver zigbee-illuminance with Capability handlers:
CapabilityCommandDispatcher: zigbee-illuminance
  default_handlers:
    refresh:
      refresh
  child_dispatchers:
    CapabilityCommandDispatcher: zigbee-illuminance -> Lumi Illuminance Handler
      default_handlers:
      child_dispatchers:

2021-09-10T21:17:33.854522612+00:00 TRACE Zigbee Illuminance Sensor  Setup driver zigbee-illuminance with Zigbee handlers:
ZigbeeMessageDispatcher: zigbee-illuminance
  default_handlers:
    attr:
      ZclClusterAttributeValueHandler: cluster: PowerConfiguration, attribute: BatteryVoltage
      ZclClusterAttributeValueHandler: cluster: PowerConfiguration, attribute: BatteryPercentageRemaining
      ZclClusterAttributeValueHandler: cluster: IlluminanceMeasurement, attribute: MeasuredValue
    global:
    cluster:
    zdo:
  child_dispatchers:
    ZigbeeMessageDispatcher: zigbee-illuminance -> Lumi Illuminance Handler
      default_handlers:
        attr:
          ZclClusterAttributeValueHandler: cluster: Basic, attribute: 0xFF01
          ZclClusterAttributeValueHandler: cluster: IlluminanceMeasurement, attribute: MeasuredValue
        global:
        cluster:
        zdo:
      child_dispatchers:

2021-09-10T21:17:33.903933612+00:00 TRACE Zigbee Illuminance Sensor  Received event with handler _resync
2021-09-10T21:17:33.910001945+00:00 TRACE Zigbee Illuminance Sensor  Received event with handler environment_info
2021-09-10T21:17:33.924586612+00:00 TRACE Zigbee Illuminance Sensor  Found DeviceLifecycleDispatcher handler in zigbee-illuminance -> Lumi Illuminance Handler
2021-09-10T21:17:33.931271945+00:00 DEBUG Zigbee Illuminance Sensor  Lumi Aqara Illuminance Sensor device thread event handled
2021-09-10T21:17:33.937628945+00:00 TRACE Zigbee Illuminance Sensor  Received event with handler _resync
2021-09-10T21:17:33.943220279+00:00 TRACE Zigbee Illuminance Sensor  Received event with handler environment_info
2021-09-10T21:17:33.949361612+00:00 DEBUG Zigbee Illuminance Sensor  Z-Wave hub node ID environment changed.
2021-09-10T21:17:53.872575281+00:00 TRACE Zigbee Illuminance Sensor  Received event with handler capability
2021-09-10T21:17:53.884203281+00:00 INFO Zigbee Illuminance Sensor  <ZigbeeDevice: 2504b279-2583-48da-ba07-331622ac5954 [0xD77A] (Lumi Aqara Illuminance Sensor)> received command: {"component":"main","args":[],"command":"refresh","positional_args":[],"capability":"refresh"}
2021-09-10T21:17:53.891019281+00:00 TRACE Zigbee Illuminance Sensor  Found CapabilityCommandDispatcher handler in zigbee-illuminance
2021-09-10T21:17:53.903138614+00:00 INFO Zigbee Illuminance Sensor  <ZigbeeDevice: 2504b279-2583-48da-ba07-331622ac5954 [0xD77A] (Lumi Aqara Illuminance Sensor)> sending Zigbee message: < ZigbeeMessageTx || Uint16: 0x0000, < AddressHeader || src_addr: 0x0000, src_endpoint: 0x01, dest_addr: 0xD77A, dest_endpoint: 0x01, profile: 0x0104, cluster: PowerConfiguration >, < ZCLMessageBody || < ZCLHeader || frame_ctrl: 0x00, seqno: 0x00, ZCLCommandId: 0x00 >, < ReadAttribute || AttributeId: 0x0020 > > >

and my folder layout is:

zigbee-illuminance-sensor

  • profiles
    • lluminance-battery.yml
  • src
    • lumi-lux
      • init.lua
    • test
      • test-illuminance-sensor.lua
  • init.lua
  • config.yml
    -fingerprint.yml

Are they all the logs?

I see only one TX message for the PowerConfiguration cluster to read the attribute 0x0020. Do you receive a value in the battery capability?

Try to add this in the subdriver:

--This goes in the imports section
local zcl_clusters = require "st.zigbee.zcl.clusters"
local lightMeasurement = zcl_clusters.IlluminanceMeasurement

--this in the do_configure function before device:configure()
device:send(device_management.build_bind_request(device, lightMeasurement.ID, self.environment_info.hub_zigbee_eui))
device:send(lightMeasurement.attributes.MeasuredValue:configure_reporting(device, minReportingInterval, maxReportingInterval, reportingChange))

Thanks @nayelyz I will give that a try.

Yes I am receiving battery values successful on in the logs and the device screen in the app.

But nothing for the illuminance at all, will see if this change works though.

Did you get this device working?

The engineering team mentioned that the issue with the Illuminance Measurement library should be solved in the newest version (0.39).
Do you have any issues related, @mvevitsis?

Still never got this working even with the default driver, not sure if I am missing something or if @nayelyz can soot anything in the legacy dth.

The legacy DTH was written by @jsconstantelos

import physicalgraph.zigbee.zcl.DataType

metadata {
    definition (name: "My Xiaomi Mijia Smart Light Sensor", namespace: "jsconstantelos", author: "jsconstantelos", mnmn: "SmartThingsCommunity", vid: "a3fe3c0d-1f51-3d51-9309-566ba1219b4f", ocfDeviceType: "x.com.st.d.sensor.light") {
        capability "Illuminance Measurement"
        capability "Configuration"
        capability "Refresh"
        capability "Battery"
        capability "Sensor"
        capability "Health Check"
    }

	preferences {
		input "forceConfig", "boolean", title: "Toggle ONCE to force device configuration (any position will force a config)"
	}

	fingerprint profileId: "0104", inClusters: "0000,0400,0003,0001", outClusters: "0003", manufacturer: "AQARA", model: "lumi.sen_ill.agl01", deviceJoinName: "Xiaomi Mijia Smart Home Light Sensor"
	fingerprint profileId: "0104", inClusters: "0000,0400,0003,0001", outClusters: "0003", manufacturer: "LUMI", model: "lumi.sen_ill.mgl01", deviceJoinName: "Xiaomi Mijia Smart Home Light Sensor"
    fingerprint profileId: "0104", inClusters: "0000,0400,0003,0001", outClusters: "0003", manufacturer: "XIAOMI", model: "lumi.sen_ill.mgl01", deviceJoinName: "Xiaomi Mijia Smart Home Light Sensor"

}

def parse(String description) {
//	log.debug "Incoming data from device : $description"
    if (description?.startsWith("catchall:")) {
		def descMap = zigbee.parseDescriptionAsMap(description)
		log.debug "Raw Data : $description"
	}
    if (description?.startsWith("read attr -")) {
		def descMap = zigbee.parseDescriptionAsMap(description)
		if (descMap.cluster == "0001" && descMap.attrId == "0020") {
            def vBatt = Integer.parseInt(descMap.value,16) / 10
            def pct = (vBatt - 2.1) / (3 - 2.1)
            def roundedPct = Math.round(pct * 100)
            if (roundedPct <= 0) roundedPct = 1
            def batteryValue = Math.min(100, roundedPct)
            sendEvent("name": "battery", "value": batteryValue, "displayed": true, isStateChange: true)
		} else {
        	log.debug "UNKNOWN Cluster and Attribute : $description"
        }
	}
    if (description?.startsWith("illuminance:")) {
        def raw = ((description - "illuminance: ").trim()) as int
        def lux = Math.round(zigbee.lux(raw as Integer)).toString()
        sendEvent("name": "illuminance", "value": lux, "unit": "lux", "displayed": true, isStateChange: true)
	}
}

def installed() {
	configure()
}

def updated() {
	configure()
}

def refresh() {
	log.debug "Refreshing values..."
	[
        "st rattr 0x${device.deviceNetworkId} 1 0x001 0", "delay 200",
        "st rattr 0x${device.deviceNetworkId} 1 0x400 0", "delay 200"
	]
}

def configure() {
	log.debug "Configuration starting..."
	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID, offlinePingable: "1"])
    log.debug "...bindings..."
	[
		"zdo bind 0x${device.deviceNetworkId} 1 1 0x000 {${device.zigbeeId}} {}", "delay 1000",	// basic cluster
        "zdo bind 0x${device.deviceNetworkId} 1 1 0x001 {${device.zigbeeId}} {}", "delay 1000",	// power cluster
		"zdo bind 0x${device.deviceNetworkId} 1 1 0x003 {${device.zigbeeId}} {}", "delay 1000",	// identify cluster
		"zdo bind 0x${device.deviceNetworkId} 1 1 0x400 {${device.zigbeeId}} {}", "delay 1000",	// illuminance cluster
		"send 0x${device.deviceNetworkId} 1 1"
	]
    log.debug "...reporting intervals..."
    [
        zigbee.configureReporting(0x0001, 0x0020, 0x20, 60, 3600, 0x01), "delay 1000",	// power cluster (get battery voltage every hour, or if it changes)
        zigbee.configureReporting(0x0400, 0x0000, 0x21, 10, 3600, 0x15)					// illuminance cluster (min report time 10 seconds, max 3600 seconds, raw amount of change 21 (0x15))
	]
}
1 Like

This works for me.

In the configuration or infoChanged if you have preferences:
Preference values are in minutes and in Lux
You can change it for fixed values.

        local maxTime = device.preferences.illuMaxTime * 60
        local changeRep = math.floor(10000 * (math.log((device.preferences.illuChangeRep + 1), 10)))
        --print("Illuminance change reportable >>>>>>>>", changeRep)
        print ("Illumin maxTime & changeRep: ", maxTime, changeRep)
        device:send(device_management.build_bind_request(device, zcl_clusters.IlluminanceMeasurement.ID, self.environment_info.hub_zigbee_eui))
        device:send(zcl_clusters.IlluminanceMeasurement.attributes.MeasuredValue:configure_reporting(device, 60, maxTime, changeRep))  

In the emit event handler:

--- illuminance_measurement_defaults
local function illuminance_measurement_defaults(driver, device, value, zb_rx)
  -- local lux_value = math.floor(math.pow(10, (value.value - 1) / 10000))  --- defualt librarie edge lua
  local lux_value = math.floor(10 ^ ((value.value - 1) / 10000))
  device:emit_event_for_endpoint(zb_rx.address_header.src_endpoint.value, capabilities.illuminanceMeasurement.illuminance(lux_value))
end

in the Template Attr handle:

  zigbee_handlers = {
    attr = {
        [zcl_clusters.IlluminanceMeasurement.ID] = {
          [zcl_clusters.IlluminanceMeasurement.attributes.MeasuredValue.ID] = illuminance_measurement_defaults
        }
    },
},
2 Likes

Another related issue is that ocfDeviceType: “x.com.st.d.sensor.light” is always greyed out on the tile view even though this is a sensor with no on/off state.
This sounds to me like the illuminance measurement capability does not have properly defined states (there should be no inactive state, only an active one)

@nayelyz
@erickv

I also tried using a vid without the refresh action on the tile view, same deal.

Thanks @Mariano_Colmenarejo that is great. Did you use a sub driver or just include in the init.lua also did you add the battery configuration to display battery levels.

Hi @Benjamin_Ginders,

Seeing the code you put in the previous post, it can be put in the subdriver, but I would make some changes.

For the battery I think it is best to use the xiaomi_utils.lua library.
This library make the configuration, the battery calculation and emit the event. For xiaomi temperature sensor it is working fine.

For illuminance, if device use the standard cluster you would not need a subdriver, simply add the Lifecycle doConfigure and run the configuration with the values you want. If you later want to add interval settings, reports in preferences, it can be done easily later.

This is what i would do

init.lua:

local capabilities = require "st.capabilities"
local ZigbeeDriver = require "st.zigbee"
local defaults = require "st.zigbee.defaults"
local constants = require "st.zigbee.constants"
local clusters = require "st.zigbee.zcl.clusters"
local device_management = require "st.zigbee.device_management"
local xiaomi_utils = require "xiaomi_utils"

local function do_configure(self, device)
  -- configure Illuminance reports
  --Maxt time interval 600 sec
  local maxTime = 600
  -- Reportable change 5 lux
  local changeRep = math.floor(10000 * (math.log((5 + 1), 10)))
  print ("Illuminance maxTime y changeRep: ",maxTime, changeRep )
  device:send(device_management.build_bind_request(device, clusters.IlluminanceMeasurement.ID, self.environment_info.hub_zigbee_eui))
  device:send(clusters.IlluminanceMeasurement.attributes.MeasuredValue:configure_reporting(device, 60, maxTime, changeRep))
  device:configure()
end
---illuminance_measurement_defaults
local function illuminance_measurement_defaults(driver, device, value, zb_rx)
  --local lux_value = math.floor(math.pow(10, (value.value - 1) / 10000))  --- defualt librarie edge lua
  local lux_value = math.floor(10 ^ ((value.value - 1) / 10000))
  device:emit_event_for_endpoint(zb_rx.address_header.src_endpoint.value, capabilities.illuminanceMeasurement.illuminance(lux_value))
end

local zigbee_illuminance_driver = {
  supported_capabilities = {
    capabilities.illuminanceMeasurement,
    capabilities.battery,
  },
  lifecycle_handlers = {
    doConfigure = do_configure,
  },
  zigbee_handlers = {
    attr = {
      [clusters.basic_id] = {
        [0xFF02] = xiaomi_utils.battery_handler,
        [0xFF01] = xiaomi_utils.battery_handler
      },
      [clusters.IlluminanceMeasurement.ID] = {
        [clusters.IlluminanceMeasurement.attributes.MeasuredValue.ID] = illuminance_measurement_defaults
      }
    },
  },
}

--------- driver run ------
defaults.register_for_default_handlers(zigbee_illuminance_driver, zigbee_illuminance_driver.supported_capabilities)
local driver = ZigbeeDriver("zigbee-illuminance", zigbee_illuminance_driver)
driver:run()

Make a file with name “xiaomi_utils” in scr folder. Are from Zach Varberg, SmartThings:
or copyfrom his github link
https://github.com/varzac/EdgeDrivers/tree/master/xiaomi-sensor/src

-- Copyright 2021 Zach Varberg, SmartThings
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
--     http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
local data_types = require "st.zigbee.data_types"
local capabilities = require "st.capabilities"
local buf = require "st.buf"

local xiaomi_utils = {}

xiaomi_utils.xiaomi_custom_data_type = {
  deserialize = function(data_buf)
    local out = {
      items = {}
    }
    while data_buf:remain() > 0 do
      local index = data_types.Uint8.deserialize(data_buf)
      local data_type = data_types.ZigbeeDataType.deserialize(data_buf)
      local data = data_types.parse_data_type(data_type.value, data_buf)
      out.items[#out.items + 1] = {
        index = index,
        data_type = data_type,
        data = data,
      }
    end
    return out
  end,
}


xiaomi_utils.emit_battery_event = function(self, device, battery_record)
  local raw_bat_volt = (battery_record.value / 1000)
  local raw_bat_perc = (raw_bat_volt - 2.5) * 100 / (3.0 - 2.5)
  local bat_perc = math.floor(math.max(math.min(raw_bat_perc, 100), 0))
  device:emit_event(capabilities.battery.battery(bat_perc))
end

xiaomi_utils.battery_handler = function(self, device, value)
  if value.ID == data_types.CharString.ID then
    local bytes = value.value
    local message_buf = buf.Reader(bytes)
    local xiaomi_data_type = xiaomi_utils.xiaomi_custom_data_type.deserialize(message_buf)
    for i, item in ipairs(xiaomi_data_type.items) do
      if item.data_type.value == data_types.Uint16.ID then
        xiaomi_utils.emit_battery_event(self, device, item.data)
        return
      end
    end
  elseif value.ID == data_types.Structure.ID then
    for i, record in ipairs(value.elements) do
      if record.data_type.value == data_types.Uint16.ID then
        xiaomi_utils.emit_battery_event(self, device, record.data)
        return
      end
    end
  end
end

return xiaomi_utils

If the configuratin works fine you must see log similar to this:
Cofiguration sent to device:

2021-12-21T16:39:40.648401266+00:00 PRINT Zigbee Sensor Illuminance maxTime y changeRep: 600 12041
2021-12-21T16:39:40.661478266+00:00 INFO Zigbee Sensor <ZigbeeDevice: a683d001-effc-4048-9381-0d9d22476fdc [0xD7DD] (Sensor)> sending Zigbee message: < ZigbeeMessageTx || Uint16: 0x0000, < AddressHeader || src_addr: 0x0000, src_endpoint: 0x01, dest_addr: 0xD7DD, dest_endpoint: 0x08, profile: 0x0000, cluster: 0x0021 >, < ZDOMessageBody || < ZDOHeader || seqno: 0x00 >, < BindRequest || src_address: 00124B001BAC6626, src_endpoint: 0x08, cluster: IlluminanceMeasurement, dest_addr_mode: 0x03, dest_address: D052A8727F4F0001, dest_endpoint: 0x01 > > >
2021-12-21T16:39:40.691325516+00:00 INFO Zigbee Sensor <ZigbeeDevice: a683d001-effc-4048-9381-0d9d22476fdc [0xD7DD] (Sensor)> sending Zigbee message: < ZigbeeMessageTx || Uint16: 0x0000, < AddressHeader || src_addr: 0x0000, src_endpoint: 0x01, dest_addr: 0xD7DD, dest_endpoint: 0x08, profile: 0x0104, cluster: IlluminanceMeasurement >, < ZCLMessageBody || < ZCLHeader || frame_ctrl: 0x00, seqno: 0x00, ZCLCommandId: 0x06 >, < ConfigureReporting || < AttributeReportingConfiguration || direction: 0x00, attr_id: 0x0000, DataType: Uint16, minimum_reporting_interval: 0x003C, maximum_reporting_interval: 0x0384, reportable_change: 0x2F09 > > > >

Device Configuration response:

2021-12-21T16:39:42.936992473+00:00 INFO Zigbee Sensor <ZigbeeDevice: a683d001-effc-4048-9381-0d9d22476fdc [0xD7DD] (Sensor)> received Zigbee message: < ZigbeeMessageRx || type: 0x00, < AddressHeader || src_addr: 0xD7DD, src_endpoint: 0x08, dest_addr: 0x0000, dest_endpoint: 0x01, profile: 0x0104, cluster: IlluminanceMeasurement >, lqi: 0xFF, rssi: -24, body_length: 0x0004, < ZCLMessageBody || < ZCLHeader || frame_ctrl: 0x18, seqno: 0x75, ZCLCommandId: 0x07 >, < ConfigureReportingReponse || ZclStatus: SUCCESS > > >

1 Like