I wrote this during my adventures of getting zigpy to do stuff. Perhaps it could be useful as an example program. I can create a PR if you give some guidance of where the file should go. Feedback on how to improve it is also welcome.

import asyncio
import logging
import zigpy

# Change bellows to a different module if your radio does not use a
# Silicon Labs chip
from bellows.zigbee.application import ControllerApplication

# Some shortcut names for convenience
from zigpy.zcl.clusters.general import OnOff as OnOffCluster
from zigpy.zcl.clusters.general import LevelControl as LevelControlCluster

# Change these to suit your system
database_path = "zigbee.db"
device_path = "/dev/ttyUSB1"

# Note: You will need to get your zigbee devices into pairing mode in order
# for them to join the network.  The method for that varies by device.  The
# Zigbee2MQTT device database has useful information, for example:
#   https://www.zigbee2mqtt.io/devices/LED2201G8.html

class MainListener:
	"""Monitors new devices and adds them to the light switch"""

	def __init__(self, switch):
		self.switch = switch

	def device_initialized(self, dev):
		"""Called when a device is fully initialized and all of its endpoints
		and clusters are available for inspection."""

		self.switch.process_device(dev)

class OnOffListener:
	"""Listens to on/off commands from button devices and forwards them to
	the light switch object"""

	def __init__(self, switch):
		self.switch = switch

	def cluster_command(self, tsn, cmd, args):
		cmd_defs = OnOffCluster.ServerCommandDefs
		if cmd==cmd_defs.off.id:
			asyncio.create_task(self.switch.turn_off())
		elif cmd==cmd_defs.on.id:
			asyncio.create_task(self.switch.turn_on())

class LevelListener:
	"""Listens to level control commands from control devices and forwards them
	to the light switch object"""

	def __init__(self, switch):
		self.switch = switch

	def cluster_command(self, tsn, cmd, args):
		cmd_defs = LevelControlCluster.ServerCommandDefs
		if cmd==cmd_defs.move.id or cmd==cmd_defs.move_with_on_off.id:
			asyncio.create_task(self.switch.adjust_level(args.move_mode, args.rate, cmd==cmd_defs.move_with_on_off.id))
		elif cmd==cmd_defs.stop.id or cmd==cmd_defs.stop_with_on_off.id:
			asyncio.create_task(self.switch.stop_level(cmd==cmd_defs.stop_with_on_off.id))

class LightSwitch:
	"""Controls lights (or other devices with on/off and level controls) based
	on commands from control devices"""

	def __init__(self):
		self.onoff_clusters = []
		self.onoff_listener = OnOffListener(self)

		self.level_clusters = []
		self.level_listener = LevelListener(self)

		# 254 is the maximum level value allowed by the Zigbee spec
		self.current_level = 254

	def process_device(self, dev):
		"""Enumerates the endpoints and clusters on a device to see if it has
		anything interesting for us"""

		print("Got device {} {} {}".format(dev.name, dev.manufacturer, dev.model))
		for ep in dev.endpoints.values():
			# The endpoints dict also contains the ZDO object which has a
			# completely different interface
			if type(ep)!=zigpy.endpoint.Endpoint:
				continue

			# In clusters are inputs for the device so we can send commands
			# to them
			for clus in ep.in_clusters.values():
				if clus.cluster_id==OnOffCluster.cluster_id:
					print("  Found on/off control")
					self.onoff_clusters.append(clus)
				elif clus.cluster_id==LevelControlCluster.cluster_id:
					print("  Found level control")
					self.level_clusters.append(clus)
					asyncio.create_task(self.read_level(clus))

			# Out clusters are outputs from the device and provide events we
			# can listen to
			for clus in ep.out_clusters.values():
				if clus.cluster_id==OnOffCluster.cluster_id:
					print("  Listening to on/off events")
					clus.add_listener(self.onoff_listener)
				elif clus.cluster_id==LevelControlCluster.cluster_id:
					print("  Listening to level events")
					clus.add_listener(self.level_listener)

	async def read_level(self, clus):
		success, failure = await clus.read_attributes(["current_level"])
		level = success.get("current_level")
		if level is not None:
			self.current_level = level
			print("Current level is {}".format(self.current_level))

	async def turn_off(self):
		print("Turning off")
		for clus in self.onoff_clusters:
			await clus.off()

	async def turn_on(self):
		print("Turning on")
		for clus in self.onoff_clusters:
			await clus.on()

	async def adjust_level(self, mode, rate, with_onoff):
		print("Adjusting level {} with rate {}".format(mode._name_, rate))
		for clus in self.level_clusters:
			if with_onoff:
				await clus.move_with_on_off(mode, rate)
			else:
				await clus.move(mode, rate)

	async def stop_level(self, with_onoff):
		print("Stopping level adjustment")
		for clus in self.level_clusters:
			if with_onoff:
				await clus.stop_with_on_off()
			else:
				await clus.stop()
		for clus in self.level_clusters:
			await self.read_level(clus)

async def main():
	# Create the controller application.  This will automatically connect to the
	# radio and create a network.  Known devices are stored in the database so
	# they can be used on subsequence runs of the program.
	app = await ControllerApplication.new(config={
			"database_path": database_path,
			"device": {
				"path": device_path
			}
		}, auto_form=True)
	try:
		# Create and add the main listener
		switch = LightSwitch()
		app.add_listener(MainListener(switch))

		# Immediately process any existing devices
		for dev in app.devices.values():
			switch.process_device(dev)

		# Allow new devices to join the network for a minute
		async def permit_join():
			print("Allowing devices to join")
			await app.permit(60)
			await asyncio.sleep(60)
			print("Join period ended")
		asyncio.create_task(permit_join())

		# Run the event loop forever by awaiting a future which will never get
		# a result
		await asyncio.get_running_loop().create_future()
	except asyncio.exceptions.CancelledError:
		# Pressing Ctrl-C will cause a CancelledError to be raised
		pass

	# If the app is not shutdown, the process will hang waiting for a background
	# thread to finish
	await app.shutdown()

# Get some basic information from zigpy printed to the console.  Changing the
# level to DEBUG can be useful to discover what kinds of events your control
# devices send but will produce a lot of spam.
logging.basicConfig(level=logging.INFO)

# Start the application
asyncio.run(main())

Zigpy application examples #1087

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions