├── .gitignore
├── example_off.py
├── example_on.py
├── kelvin.png
├── example_simulator.py
├── lifx
    ├── __init__.py
    ├── enums.py
    ├── simulator.py
    ├── lifx.py
    ├── network.py
    └── packet.py
├── example_candle.py
├── example_image.py
├── example_intro.py
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc


--------------------------------------------------------------------------------
/example_off.py:
--------------------------------------------------------------------------------
1 | import lifx
2 | 
3 | lifx.Lifx().off()
4 | 


--------------------------------------------------------------------------------
/example_on.py:
--------------------------------------------------------------------------------
1 | import lifx
2 | 
3 | lifx.Lifx().on()
4 | 


--------------------------------------------------------------------------------
/kelvin.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arrian/lifx-python/HEAD/kelvin.png


--------------------------------------------------------------------------------
/example_simulator.py:
--------------------------------------------------------------------------------
1 | from lifx.simulator import Simulator
2 | 
3 | # This simulates the behaviour of a LIFX lightbulb locally.
4 | 
5 | simulator = Simulator(bulb_label = b'Example Bulb')
6 | simulator.start()


--------------------------------------------------------------------------------
/lifx/__init__.py:
--------------------------------------------------------------------------------
 1 | __all__ = ['packet', 'network', 'simulator', 'enums', 'lifx']
 2 | 
 3 | from .enums import *
 4 | from .packet import *
 5 | from .network import Network
 6 | from .simulator import Simulator
 7 | from .lifx import Lifx
 8 | 
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------
/example_candle.py:
--------------------------------------------------------------------------------
 1 | from time import sleep
 2 | import random
 3 | import lifx
 4 | 
 5 | lights = lifx.Lifx()
 6 | lights.on()
 7 | 
 8 | while True:
 9 | 	lights.set_colour(random.randint(7000, 7500), 40000, random.randint(2200, 3000), 1000, random.randint(80, 180))
10 | 	sleep(random.random() / 2)
11 | 
12 | 


--------------------------------------------------------------------------------
/example_image.py:
--------------------------------------------------------------------------------
 1 | # This example demonstrates setting the bulb colour to sampled pixels from an image.
 2 | # Pillow (https://github.com/python-pillow/Pillow) or PIL is required to load images.
 3 | from PIL import Image
 4 | 
 5 | import lifx
 6 | import colorsys
 7 | from time import sleep
 8 | 
 9 | # Connect to the bulb and ensure it is on
10 | lights = lifx.Lifx()
11 | lights.on()
12 | 
13 | # Load the image
14 | im = Image.open('kelvin.png')
15 | pix = im.load()
16 | 
17 | # Loop through the pixels
18 | for i in range(0,im.size[1]):
19 | 	for j in range(0,im.size[0]):
20 | 		rgb = pix[j,i]
21 | 		hsv = colorsys.rgb_to_hsv(rgb[0] / 256.0, rgb[1] / 256.0, rgb[2] / 256.0)
22 | 
23 | 		lights.set_colour(hsv[0] * 60000, hsv[1] * 60000, hsv[2] * 60000, 1000, 200)
24 | 
25 | 		print('rgb' + str(rgb))
26 | 
27 | 		sleep(0.02)
28 | 
29 | 


--------------------------------------------------------------------------------
/lifx/enums.py:
--------------------------------------------------------------------------------
 1 | 
 2 | class Service:
 3 |     UDP = 1
 4 |     TCP = 2
 5 | 
 6 | class ResetSwitchPosition:
 7 |     UP = 0
 8 |     DOWN = 1
 9 | 
10 | class Interface:
11 |     SOFT_AP = 1
12 |     STATION = 2
13 | 
14 | class WifiStatus:
15 |     CONNECTING = 0
16 |     CONNECTED = 1
17 |     FAILED = 2
18 |     OFF = 3
19 | 
20 | class SecurityProtocol:
21 |     OPEN = 1
22 |     WEP_PSK = 2
23 |     WPA_TKIP_PSK = 3
24 |     WPA_AES_PSK = 4
25 |     WPA2_AES_PSK = 5
26 |     WPA2_TKIP_PSK = 6
27 |     WPA2_MIXED_PSK = 7      
28 | 
29 | class Power:
30 |     OFF = 0
31 |     ON = 0xffff
32 | 
33 | class Waveform:
34 |     SAW = 0
35 |     SINE = 1
36 |     HALF_SINE = 2
37 |     TRIANGLE = 3
38 |     PULSE = 4
39 | 
40 | class Colour:
41 |     RED = 0
42 |     ORANGE = 5000
43 |     YELLOW = 8000
44 |     GREEN = 18000
45 |     BLUE = 42720
46 | 
47 | class Brightness:
48 |     OFF = 0
49 |     DIM = 1000
50 |     MOOD = 2500
51 |     NORMAL = 6000
52 |     FULL = 65000
53 | 
54 | 
55 | 


--------------------------------------------------------------------------------
/example_intro.py:
--------------------------------------------------------------------------------
 1 | from time import sleep
 2 | import lifx
 3 | 
 4 | # Create the LIFX connection
 5 | lights = lifx.Lifx()
 6 | 
 7 | # Turn on the lights
 8 | lights.on()
 9 | 
10 | # Set all the lights to green
11 | lights.set_colour(lifx.Colour.GREEN)
12 | 
13 | # You can also be more specific with your colour settings: hue, saturation, brightness, kelvin, transition_duration
14 | lights.set_colour(0, 10000, 10000, 1000, 5000)
15 | 
16 | # Get the lights' colours
17 | print(lights.get_colours())
18 | 
19 | # Get the lights' labels
20 | print(lights.get_labels())
21 | 
22 | # Get the lights' internal time
23 | print(lights.get_time())
24 | 
25 | # Get the wifi information
26 | print(lights.get_wifi_info())
27 | 
28 | # Get the available access points
29 | print(lights.get_access_points())
30 | 
31 | # Asynchronous print all LIFX network packets and continue.
32 | # Pass any function here that takes a one packet type argument.
33 | lights.monitor(lights.print_packet)
34 | 
35 | while True:
36 | 	sleep(1)
37 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # LIFX Python Library
 2 | 
 3 | This project aims to be a simple to use comprehensive python library for interaction with LIFX lightbulbs. Currently both Python 2 and Python 3 are supported.
 4 | 
 5 | ## Usage
 6 | 
 7 |  ```python
 8 | 
 9 | from time import sleep
10 | import lifx
11 | 
12 | # Create the LIFX connection
13 | lights = lifx.Lifx()
14 | 
15 | # Turn on the lights
16 | lights.on()
17 | 
18 | # Set all the lights to green
19 | lights.set_colour(lifx.Colour.GREEN)
20 | 
21 | # You can also be more specific with your colour settings: hue, saturation, brightness, kelvin, transition_duration
22 | lights.set_colour(0, 10000, 10000, 1000, 5000)
23 | 
24 | # Get the lights' colours
25 | print(lights.get_colours())
26 | 
27 | # Get the lights' labels
28 | print(lights.get_labels())
29 | 
30 | # Get the lights' internal time
31 | print(lights.get_time())
32 | 
33 | # Get the wifi information
34 | print(lights.get_wifi_info())
35 | 
36 | # Get the available access points
37 | print(lights.get_access_points())
38 | 
39 | # Asynchronous print all LIFX network packets and continue.
40 | # Pass any function here that takes one argument.
41 | lights.monitor(lights.print_packet)
42 | 
43 | while True:
44 | 	sleep(1)
45 | 
46 |  ```


--------------------------------------------------------------------------------
/lifx/simulator.py:
--------------------------------------------------------------------------------
 1 | from .packet import *
 2 | from .network import Network
 3 | import string
 4 | import random
 5 | import threading
 6 | import os
 7 | 
 8 | try:
 9 |     import queue
10 | except ImportError:
11 |     import Queue as queue # backwards compatibility for Python 2
12 | 
13 | class Simulator:
14 |     """ 
15 |     Simulates a LIFX bulb locally.
16 |     """
17 |     network = None
18 |     broadcast_queue = queue.Queue()
19 | 
20 |     def __init__(self, network = None, listen_port = 56700, mac_address = b'\xd0s\xd5\x00\xd4\xc3', hue = 0, saturation = 10000, brightness = 10000, kelvin = 1000, dim = 0, power = 1, wifi_info = (1.0, 0, 0, 10), wifi_firmware_state = (0, 0, 0), access_point = (0, b'Dummy Network', 0, 10, 10), bulb_label = b'LIFX Bulb Emulator #' + os.urandom(4), bulb_tags = [b'dummy1', b'dummy2']):
21 |         self.network = network
22 |         self.listen_port = listen_port
23 |         self.mac_address = mac_address
24 |         self.hue = hue
25 |         self.saturation = saturation
26 |         self.brightness = brightness
27 |         self.kelvin = kelvin
28 |         self.dim = dim
29 |         self.power = power
30 |         self.wifi_info = wifi_info
31 |         self.wifi_firmware_state = wifi_firmware_state
32 |         self.access_point = access_point
33 |         self.bulb_label = bulb_label
34 |         self.bulb_tags = bulb_tags
35 | 
36 |         if self.network is None:
37 |             self.network = Network(False)
38 | 
39 |     def start(self):
40 |         self.broadcast_pan()
41 |         self.broadcast_status()
42 |         self.broadcast_firmware_state()
43 |         self.listen()
44 | 
45 |     def broadcast_pan(self):
46 |         print('Broadcasting PAN update.')
47 |         self.broadcast_queue.put(Packet.AsBulb(PacketType.PAN_GATEWAY, self.mac_address, self.mac_address, 1, self.listen_port))
48 |         threading.Timer(10, self.broadcast_pan).start()
49 | 
50 |     def broadcast_status(self):
51 |         print('Broadcasting light status update.')
52 |         self.broadcast_queue.put(Packet.AsBulb(PacketType.LIGHT_STATUS, self.mac_address, self.mac_address, self.hue, self.saturation, self.brightness, self.kelvin, self.dim, self.power, self.bulb_label, len(self.bulb_tags)))
53 |         threading.Timer(20, self.broadcast_status).start()
54 | 
55 |     def broadcast_firmware_state(self):
56 |         print('Broadcasting mesh firmware state update.')
57 | 
58 |         threading.Timer(20, self.broadcast_firmware_state).start()
59 | 
60 |     #listens and responds to requests
61 |     def listen(self):
62 |         while True:
63 |             while not self.broadcast_queue.empty():
64 |                 packet = self.broadcast_queue.get()
65 |                 print(str(packet))
66 |                 self.network.broadcast(packet)
67 |             self.network.listen_sync(PacketType.GET_PAN_GATEWAY, 1, 1)
68 | 
69 |     def get_time(self):
70 |         int(round(time.time()))
71 | 
72 | 
73 | 
74 | 


--------------------------------------------------------------------------------
/lifx/lifx.py:
--------------------------------------------------------------------------------
  1 | from .enums import *
  2 | from .packet import *
  3 | from .network import Network
  4 | 
  5 | # Wraps network providing a simpler API.
  6 | class Lifx:
  7 | 
  8 |     network = None
  9 | 
 10 |     def __init__(self):
 11 |         self.network = Network()
 12 | 
 13 |     def on(self):
 14 |         self.set_on(True)
 15 | 
 16 |     def off(self):
 17 |         self.set_on(False)
 18 | 
 19 |     def set_on(self, on):
 20 |         self.network.send(PacketType.SET_POWER_STATE, Power.ON if on else Power.OFF)
 21 | 
 22 |     def is_on(self):
 23 |         self.network.send(PacketType.GET_POWER_STATE)
 24 |         header, payload = self.network.listen_sync(PacketType.POWER_STATE, 1).get_data()
 25 | 
 26 |         if payload is not None:
 27 |             return payload.onoff 
 28 |         return None
 29 | 
 30 |     def set_colour(self, hue, saturation = 30000, brightness = 30000, kelvin = 1000, duration = 500):
 31 |         self.network.send(PacketType.SET_LIGHT_COLOUR, 0, hue, saturation, brightness, kelvin, duration)
 32 | 
 33 |     def get_colours(self):
 34 |         self.network.send(PacketType.GET_LIGHT_STATE)
 35 |         header, payload = self.network.listen_sync(PacketType.LIGHT_STATUS, 1).get_data()
 36 | 
 37 |         if payload is not None:
 38 |             return payload.hue, payload.saturation, payload.brightness, payload.kelvin, payload.dim, payload.power, payload.build_label, payload.tags
 39 |         return None, None, None, None, None, None, None, None
 40 | 
 41 |     def get_wifi_info(self):
 42 |         self.network.send(PacketType.GET_WIFI_INFO)
 43 |         header, payload = self.network.listen_sync(PacketType.WIFI_INFO, 1).get_data()
 44 | 
 45 |         if payload is not None:
 46 |             return payload.signal, payload.tx, payload.rx, payload.mcu_temperature 
 47 |         return None, None, None, None
 48 | 
 49 |     def get_labels(self):
 50 |         self.network.send(PacketType.GET_BULB_LABEL)
 51 |         packets = map(Packet.get_data, self.network.listen_sync(PacketType.BULB_LABEL, 10))
 52 |         
 53 |         print(" ".join(map(str,[p[1].label.decode("utf-8") for p in packets])))
 54 |         #if payload is not None:
 55 |         #    pass
 56 |             #return payload.label.decode("utf-8")
 57 |         return None
 58 | 
 59 |     def get_access_points(self):
 60 |         self.network.send(PacketType.GET_ACCESS_POINTS)
 61 |         packets = map(Packet.get_data, self.network.listen_sync(PacketType.ACCESS_POINT, 10))
 62 |         print(" ".join(map(str,[p[1].ssid.split(b'\0',1)[0].decode("utf-8") for p in packets])))
 63 |         #if payload is not None:
 64 |         #    pass
 65 |             #return payload.interface, payload.ssid.split(b'\0',1)[0].decode("utf-8"), payload.security_protocol, payload.strength, payload.channel
 66 |         return [(None, None, None, None, None)]
 67 | 
 68 |     def get_time(self):
 69 |         self.network.send(PacketType.GET_TIME)
 70 |         header, payload = self.network.listen_sync(PacketType.TIME_STATE, 1).get_data()
 71 | 
 72 |         if payload is not None:
 73 |             return payload.time / 1000000000
 74 |         return None
 75 | 
 76 |     def get_version(self):
 77 |         self.network.send(PacketType.GET_VERSION)
 78 |         header, payload = self.network.listen_sync(PacketType.VERSION_STATE, 1).get_data()
 79 | 
 80 |         if payload is not None:
 81 |             return payload.vendor, payload.product, payload.version
 82 |         return None, None, None
 83 | 
 84 |     def get_lights_by_tag(self, tag):
 85 |         pass
 86 | 
 87 |     def get_light_by_name(self, name):
 88 |         pass
 89 | 
 90 |     def reboot(self):
 91 |         self.network.send(PacketType.REBOOT)
 92 | 
 93 |     # Get the wrapped network object to perform lower level calls
 94 |     def get_network(self):
 95 |         return self.network
 96 | 
 97 |     # Monitors packets calling func when packet received
 98 |     def monitor(self, func):
 99 |         self.network.listen_async(func)
100 | 
101 |     def print_packet(self, packet):
102 |         if packet is None:
103 |             print('Packet could not be parsed.\n')
104 |         else:
105 |             print(str(packet) + '\n')
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/lifx/network.py:
--------------------------------------------------------------------------------
  1 | import socket
  2 | import struct
  3 | from time import time, sleep
  4 | import select
  5 | from threading import Thread
  6 | 
  7 | from .packet import *
  8 | 
  9 | # handle tcp not supported
 10 | import errno
 11 | from socket import error as socket_error
 12 | 
 13 | 
 14 | class Network:
 15 |     connection = None
 16 |     port = 56700
 17 |     ip = '0.0.0.0'
 18 |     broadcast_ip = '255.255.255.255'
 19 |     target = bytearray(6)
 20 |     site = bytearray(6)
 21 |     receive_size = 2048
 22 |     timeout = 2
 23 |     address = None
 24 | 
 25 |     def __init__(self, connect = True):
 26 |         if connect:
 27 |             self.connect()
 28 | 
 29 |     def to_mac(self, addr):
 30 |         return ':'.join('%02x' % b for b in addr)
 31 | 
 32 |     def check_connection(self):
 33 |         if self.connection is None:
 34 |             self.connect()
 35 |         if self.connection is None:
 36 |             raise Exception('Failed to connect.')
 37 | 
 38 |     def connect(self):
 39 |         udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 40 |         udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
 41 |         udp.bind((self.ip, self.port))
 42 |         print(udp.getsockname())
 43 | 
 44 |         p = Packet.ToBulb(PacketType.GET_PAN_GATEWAY, self.target, self.site, None)
 45 |         udp.sendto(bytes(p.get_bytes()), (self.broadcast_ip, self.port))
 46 |         
 47 |         for x in range(10):
 48 |             try:
 49 |                 udp.settimeout(self.timeout)
 50 |                 data, self.address = udp.recvfrom(self.receive_size)
 51 |                 packet = Packet.FromBulb(data)
 52 |                 if packet is not None:
 53 |                     header,payload = packet.get_data()
 54 |                     if header.code is PacketType.PAN_GATEWAY.code:
 55 |                         break
 56 |             except socket.timeout:
 57 |                 raise Exception('Handshake timed out.')
 58 | 
 59 |         if header.code is not PacketType.PAN_GATEWAY.code:
 60 |             connection = None
 61 |             raise Exception('Connection failed. Could not determine the gateway.')
 62 | 
 63 |         print('Found light at %s:%s' % (self.address[0],self.address[1]))
 64 | 
 65 |         self.site = header.site
 66 |         try:
 67 |             tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 68 |             tcp.settimeout(self.timeout)
 69 |             tcp.connect(self.address)
 70 |             tcp.setblocking(0)
 71 |             self.connection = tcp
 72 |             print('Using tcp')
 73 |         except socket_error as serr:
 74 |             if serr.errno != errno.ECONNREFUSED:
 75 |                 raise serr
 76 |             self.connection = udp # latest versions of firmware >= 1.2 do not support tcp? fall back to udp
 77 |             print('Using udp')
 78 | 
 79 |     def disconnect(self):
 80 |         if self.connection is not None:
 81 |             self.connection.close()
 82 |             self.connection = None
 83 | 
 84 |     def send(self, packet_type, *data):
 85 |         self.check_connection()
 86 |         packet = Packet.ToBulb(packet_type, self.target, self.site, *data).get_bytes()
 87 | 
 88 |         if self.connection.type is socket.SOCK_DGRAM:
 89 |             self.connection.sendto(packet, self.address)
 90 |         else:
 91 |             self.connection.sendall(packet)
 92 | 
 93 |     def receive(self, timeout = 1):
 94 |         self.check_connection()
 95 |         ready = select.select([self.connection], [], [], timeout)
 96 |         if ready[0]:
 97 |             data = self.connection.recv(self.receive_size)
 98 |             return Packet.FromBulb(data)
 99 |         return None
100 | 
101 |     def broadcast(self, packet):
102 |         broadcast_connection = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
103 |         broadcast_connection.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
104 |         broadcast_connection.bind((self.ip, 0))
105 |         broadcast_connection.sendto(bytes(packet.get_bytes()), (self.broadcast_ip, self.port))
106 |         broadcast_connection.close()
107 | 
108 |     # asynchronous method to call recv_func whenever a packet is received.
109 |     def listen_async(self, recv_func, packet_filter = None, max_packets = None):
110 |         self.check_connection()
111 | 
112 |         def perform_recv(val):
113 |             packet_count = 0
114 |             while max_packets is None or packet_count < max_packets:
115 |                 packet = self.receive()
116 |                 if packet is not None and (packet_filter is None or packet_filter.code is packet.packet_type.code):
117 |                     recv_func(packet)
118 |                 packet_count += 1
119 | 
120 |         thread = Thread(target = perform_recv, args = (10, ))
121 |         thread.start()
122 | 
123 |     # Synchronous method to get the first of the specified packets.
124 |     # Packet filter is a single packet code or a list of packet codes.
125 |     def listen_sync(self, packet_filter, num_packets = 1, timeout = 2):
126 |         self.check_connection()
127 |         start_time = time()
128 | 
129 |         packets = []
130 | 
131 |         while True:
132 |             packet = self.receive()
133 |             if packet is not None and (packet.packet_type.code is packet_filter.code or (isinstance(packet_filter, list) and packet.packet_type.code in packet_filter)):
134 |                 if num_packets == 1:
135 |                     return packet
136 |                 else:
137 |                     packets.append(packet)
138 | 
139 |             if timeout is not None and time() > start_time + timeout:
140 |                 break
141 |         if num_packets == 1:
142 |             return None
143 |         return packets
144 | 
145 | 
146 | 
147 | 


--------------------------------------------------------------------------------
/lifx/packet.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | from collections import namedtuple
  3 | from struct import pack, unpack, calcsize
  4 | 
  5 | class PacketDirection:
  6 |     FROM_BULB, TO_BULB = range(2)
  7 | 
  8 | class PacketTypeDef(object):
  9 | 
 10 |     def __init__(self, text, code, payload, fmt, direction):
 11 |         self.text = text
 12 |         self.code = code
 13 |         self.payload = payload
 14 |         self.fmt = fmt
 15 |         self.direction = direction
 16 | 
 17 |     def __str__(self):
 18 |         return("%s Packet - %d" % (self.text, self.code))
 19 | 
 20 | class PacketTypeDefFromBulb(PacketTypeDef):
 21 |     def __init__(self, text, code, payload, fmt):
 22 |         super(PacketTypeDefFromBulb, self).__init__(text, code, payload, fmt, PacketDirection.FROM_BULB)
 23 | 
 24 | class PacketTypeDefToBulb(PacketTypeDef):
 25 |     def __init__(self, text, code, payload, fmt):
 26 |         super(PacketTypeDefToBulb, self).__init__(text, code, payload, fmt, PacketDirection.TO_BULB)
 27 | 
 28 | class PacketType:
 29 | 
 30 |     # Network
 31 |     GET_PAN_GATEWAY = PacketTypeDefToBulb('Get PAN Gateway', 0x02, None, None)
 32 |     PAN_GATEWAY = PacketTypeDefFromBulb('PAN Gateway', 0x03, 'service port', '<bI') # note port is little endian
 33 | 
 34 |     # Power
 35 |     GET_POWER_STATE = PacketTypeDefToBulb('Get Power State', 0x14, None, None)
 36 |     SET_POWER_STATE = PacketTypeDefToBulb('Set Power State', 0x15, 'onoff', '<H')
 37 |     POWER_STATE = PacketTypeDefFromBulb('Power State', 0x16, 'onoff', '<H')
 38 | 
 39 |     # Wireless
 40 |     GET_WIFI_INFO = PacketTypeDefToBulb('Get Wifi Info', 0x10, None, None)
 41 |     WIFI_INFO = PacketTypeDefFromBulb('Wifi Info', 0x11, 'signal tx rx mcu_temperature', '<fiih')
 42 |     GET_WIFI_FIRMWARE_STATE = PacketTypeDefToBulb('Get Wifi Firmware State', 0x12, None, None)
 43 |     WIFI_FIRMWARE_STATE = PacketTypeDefFromBulb('Wifi Firmware State', 0x13, 'build install version', '<QQI')
 44 |     GET_WIFI_STATE = PacketTypeDefToBulb('Get Wifi State', 0x12d, 'interface', '<b')
 45 |     SET_WIFI_STATE = PacketTypeDefToBulb('Set Wifi State', 0x12e, 'interface wifi_state ip4_address ip6_address', '<bb4b16b')
 46 |     WIFI_STATE = PacketTypeDefFromBulb('Wifi State', 0x12f, 'interface wifi_state ip4_address ip6_address', '<bb4b16b')
 47 |     GET_ACCESS_POINTS = PacketTypeDefToBulb('Get Access Points', 0x130, None, None)
 48 |     SET_ACCESS_POINT = PacketTypeDefToBulb('Set Access Points', 0x131, 'interface ssid password security_protocol', '<b32s64sb')
 49 |     ACCESS_POINT = PacketTypeDefFromBulb('Accesss Points', 0x132, 'interface ssid security_protocol strength channel', '<b32sbHH')
 50 | 
 51 |     # Labels and Tags
 52 |     GET_BULB_LABEL = PacketTypeDefToBulb('Get Bulb Label', 0x17, None, None)
 53 |     SET_BULB_LABEL = PacketTypeDefToBulb('Set Bulb Label', 0x18, 'label', '<32s')
 54 |     BULB_LABEL = PacketTypeDefFromBulb('Bulb Label', 0x19, 'label', '<32s')
 55 |     GET_TAGS = PacketTypeDefToBulb('Get Tags', 0x1a, None, None)
 56 |     SET_TAGS = PacketTypeDefToBulb('Set Tags', 0x1b, 'tags', '<Q')
 57 |     TAGS = PacketTypeDefFromBulb('Tags', 0x1c, 'tags', 'Q')
 58 |     GET_TAG_LABELS = PacketTypeDefToBulb('Get Tag Labels', 0x1d, 'tags', '<Q')
 59 |     SET_TAG_LABELS = PacketTypeDefToBulb('Set Tag Labels', 0x1e, 'tags label', '<Q32s')
 60 |     TAG_LABELS = PacketTypeDefFromBulb('Tag Labels', 0x1f, 'tags label', '<Q32s')
 61 | 
 62 |     # Colour
 63 |     GET_LIGHT_STATE = PacketTypeDefToBulb('Get Light State', 0x65, None, None)
 64 |     SET_LIGHT_COLOUR = PacketTypeDefToBulb('Set Light Colour', 0x66, 'stream hue saturation brightness kelvin duration', '<bHHHHI')
 65 |     SET_WAVEFORM = PacketTypeDefToBulb('Set Waveform', 0x67, 'stream transient hue saturation brightness kelvin period cycles duty_cycles waveform', '<b?HHHHIfHb')
 66 |     SET_DIM_ABSOLUTE = PacketTypeDefToBulb('Set Dim Absolute', 0x68, 'brightness duration', '<hI')
 67 |     SET_DIM_RELATIVE = PacketTypeDefToBulb('Set Dim Relative', 0x69, 'brightness duration', '<iI')
 68 |     #SET_LIGHT_RGBW = PacketTypeDefToBulb('Set Light RGBW', 0x, 'red green blue white', '<HHHH')
 69 |     LIGHT_STATUS = PacketTypeDefFromBulb('Light Status', 0x6b, 'hue saturation brightness kelvin dim power build_label tags', '<HHHHhH32sQ')
 70 | 
 71 |     # Time
 72 |     GET_TIME = PacketTypeDefToBulb('Get Time', 0x04, None, None)
 73 |     SET_TIME = PacketTypeDefToBulb('Set Time', 0x05, 'time', '<Q') # note time is little endian
 74 |     TIME_STATE = PacketTypeDefFromBulb('Time State', 0x06, 'time', '<Q') # note time is little endian
 75 | 
 76 |     #Debug
 77 |     GET_RESET_SWITCH = PacketTypeDefToBulb('Get Reset Switch', 0x07, None, None)
 78 |     RESET_SWITCH_STATE = PacketTypeDefFromBulb('Reset Switch State', 0x08, 'position', '<H')
 79 |     #GET_DUMMY_LOAD = PacketTypeDefToBulb('Get Dummy Load', 0x09, '', '')
 80 |     #SET_DUMMY_LOAD = PacketTypeDefToBulb('Set Dummy Load', 0x0a, '', '')
 81 |     #DUMMY_LOAD = PacketTypeDefFromBulb('Dummy Load', 0x0b, '', '')
 82 |     GET_MESH_INFO = PacketTypeDefToBulb('Get Mesh Info', 0x0c, None, None)
 83 |     MESH_INFO = PacketTypeDefFromBulb('Mesh Info', 0x0d, 'signal tx rx mcu_temperature', '<fiih') # note signal, tx and rx are little endian
 84 |     GET_MESH_FIRMWARE = PacketTypeDefToBulb('Get Mesh Firmware', 0x0e, None, None)
 85 |     MESH_FIRMWARE_STATE = PacketTypeDefFromBulb('Mesh Firmware State', 0x0f, 'build install version', '<QQI')
 86 |     GET_VERSION = PacketTypeDefToBulb('Get Version', 0x20, None, None)
 87 |     VERSION_STATE = PacketTypeDefFromBulb('Version State', 0x21, 'vendor product version', '<III')
 88 |     GET_INFO = PacketTypeDefToBulb('Get Info', 0x22, None, None)
 89 |     INFO = PacketTypeDefFromBulb('Info', 0x23, 'time uptime downtime', '<QQQ')
 90 |     GET_MCU_RAIL_VOLTAGE = PacketTypeDefToBulb('Get MCU Rail Voltage', 0x24, None, None)
 91 |     MCU_RAIL_VOLTAGE = PacketTypeDefFromBulb('MCU Rail Voltage', 0x25, 'voltage', '<I')
 92 |     REBOOT = PacketTypeDefToBulb('Reboot', 0x26, None, None)
 93 |     SET_FACTORY_TEST_MODE = PacketTypeDefToBulb('Set Factory Test Mode', 0x27, 'on', '<b')
 94 |     DISABLE_FACTORY_TEST_MODE = PacketTypeDefToBulb('Disable Factory Test Mode', 0x28, None, None)
 95 |     #GET_TEMPERATURE = PacketTypeDefToBulb('Get Temperature', 0x, None, None)
 96 |     #TEMPERATURE = PacketTypeDefToBulb('Temperature', 0x, 'temperature', '<h')
 97 | 
 98 | class PacketCode:
 99 | 
100 |     mapper = dict([(getattr(PacketType, attr).code, attr) for attr in dir(PacketType) if not callable(attr) and not attr.startswith("__")])
101 | 
102 |     @classmethod
103 |     def get_packet_type(class_, code):
104 |         attr = class_.mapper.get(code, None)
105 |         if attr is not None:
106 |             return getattr(PacketType, attr)
107 |         return None
108 | 
109 | class Packet:
110 | 
111 |     # payload follows. need to fix later: protocol={12 bits protocol, 
112 |     # 1 bit addressable, 1 bit tagged, 2 bits reserved}, acknowledge
113 |     # ={1 bit acknowledge, 15 bits reserved}
114 |     header = 'size protocol reserved1 target reserved2 site acknowledge timestamp code reserved3' 
115 |     
116 |     header_fmt = '<HHI6sH6sHQHH'
117 |     header_size = 36
118 |     protocol = 0x3400 # 0x5400 = bulb protocol
119 |     protocol_bulb = 0x5400
120 | 
121 |     def __init__(self, packet_type, header_data, payload_data, header_bytes, payload_bytes):
122 |         self.packet_type = packet_type
123 |         self.header_data = header_data
124 |         self.payload_data = payload_data
125 |         self.header_bytes = header_bytes
126 |         self.payload_bytes = payload_bytes
127 | 
128 |     def __str__(self):
129 |         return(self.packet_type.text + '\n' + str(self.get_data()))
130 | 
131 |     @classmethod
132 |     def AsBulb(cls, packet_type, address, site, *payload_data):
133 |         packet = Packet.ToBulb(packet_type, address, site, *payload_data)
134 |         packet.protocol = packet.protocol_bulb # the bulb uses a different protocol value
135 |         return packet
136 | 
137 |     @classmethod
138 |     def ToBulb(cls, packet_type, target, site, *payload_data):
139 |         payload_bytes = b""
140 |         if payload_data is not None and packet_type.fmt is not None:
141 |             payload_bytes = pack(packet_type.fmt, *payload_data)
142 | 
143 | 
144 |         # Some version specfic stuff to handle the fact that python 2 pack takes
145 |         # strings whereas python 3 pack takes bytearrays.
146 |         target_vs = target
147 |         site_vs = site
148 |         if sys.version_info < (3, 0):
149 |             target_vs = str(target_vs)
150 |             site_vs = str(site_vs)
151 | 
152 |         header_data = (cls.header_size + len(payload_bytes), cls.protocol, 0, target_vs, 0, site_vs, 0, 0, packet_type.code, 0)
153 |         header_bytes = pack(cls.header_fmt, *header_data)
154 |         return cls(packet_type, header_data, payload_data, header_bytes, payload_bytes)
155 | 
156 |     @classmethod
157 |     def FromBulb(cls, byte_data):
158 |         header_bytes = byte_data[:cls.header_size]
159 | 
160 |         if(len(header_bytes) < cls.header_size):
161 |             raise Exception('Data too short at %d. Must be more than %d.' % (len(header_bytes), cls.header_size))
162 | 
163 |         PacketData = namedtuple('PacketHeader', cls.header)
164 |         header_data = PacketData._make(unpack(cls.header_fmt, header_bytes))
165 | 
166 |         payload_bytes = byte_data[cls.header_size:]
167 |         payload_bytes = payload_bytes[:(header_data.size - cls.header_size)]
168 | 
169 |         if payload_bytes is None or len(byte_data) == cls.header_size:
170 |             payload_bytes = b""
171 | 
172 |         packet_type = PacketCode.get_packet_type(header_data.code)
173 |         if packet_type is None:
174 |             raise Exception('No packet type defined.')
175 | 
176 |         payload_data = None
177 |         if packet_type.fmt is not None:
178 |             if calcsize(packet_type.fmt) is not len(payload_bytes):
179 |                 raise Exception('Payload is not the correct length. For packet type %d, length required is %d but got payload length of %d.' % (packet_type.code, calcsize(packet_type.fmt), len(payload_bytes)))
180 | 
181 |             PacketPayload = namedtuple('PacketPayload', packet_type.payload)
182 |             payload_data = PacketPayload._make(unpack(packet_type.fmt, payload_bytes))
183 | 
184 |         return cls(packet_type, header_data, payload_data, header_bytes, payload_bytes)
185 | 
186 |     def get_data(self):
187 |         return self.header_data, self.payload_data
188 | 
189 |     def get_bytes(self):
190 |         return self.header_bytes + self.payload_bytes
191 | 


--------------------------------------------------------------------------------