ADDED __init__.py
Index: __init__.py
==================================================================
--- /dev/null
+++ __init__.py
@@ -0,0 +1,599 @@
+#! /usr/bin/env python3
+
+import random
+import time
+import math
+
+class remote:
+ _remote_type_alias_map = {
+ 'fut089': 'rgb+cct'
+ }
+ _remote_type_parameters_map = {
+ 'rgbw': {
+ 'channels': [9, 40, 71],
+ 'syncword': [0x258B, 0x147A],
+ 'features': [
+ 'can_set_brightness',
+ 'has_brightness',
+ 'has_white',
+ 'has_color'
+ ],
+ 'brightness_range': [0, 25],
+ 'button_map': {
+ 'slider': 0x00,
+ 'on': 0x01,
+ 'white': 0x11,
+ 'off': 0x02,
+ 'night': 0x12,
+ 'zone_on:1': 0x03,
+ 'zone_on:2': 0x05,
+ 'zone_on:3': 0x07,
+ 'zone_on:4': 0x09,
+ 'zone_white:1': 0x13,
+ 'zone_white:2': 0x15,
+ 'zone_white:3': 0x17,
+ 'zone_white:4': 0x19,
+ 'zone_off:1': 0x04,
+ 'zone_off:2': 0x06,
+ 'zone_off:3': 0x08,
+ 'zone_off:4': 0x0A,
+ 'zone_night:1': 0x14,
+ 'zone_night:2': 0x16,
+ 'zone_night:3': 0x18,
+ 'zone_night:4': 0x1A,
+ 'speed_up': 0x0B,
+ 'speed_down': 0x0C,
+ 'change_color_mode': 0x0D,
+ 'zone_set_brightness': 0x0E,
+ 'set_color': 0x0F
+ }
+ },
+ 'cct': {
+ 'channels': [4, 39, 74],
+ 'syncword': [0x55AA, 0x050A],
+ 'brightness_range': [0, 9],
+ 'temperature_output_range': [0, 9],
+ 'temperature_input_range': [3000, 9000],
+ 'features': [
+ 'has_max_brightness',
+ 'has_brightness',
+ 'has_temperature',
+ 'is_white'
+ ],
+ 'button_map': {
+ 'on': 0x05,
+ 'off': 0x09,
+ 'max': 0x15,
+ 'night': 0x19,
+ 'zone_on:1': 0x08,
+ 'zone_on:2': 0x0D,
+ 'zone_on:3': 0x07,
+ 'zone_on:4': 0x02,
+ 'zone_max:1': 0x18,
+ 'zone_max:2': 0x1D,
+ 'zone_max:3': 0x17,
+ 'zone_max:4': 0x12,
+ 'zone_off:1': 0x0B,
+ 'zone_off:2': 0x03,
+ 'zone_off:3': 0x0A,
+ 'zone_off:4': 0x06,
+ 'zone_night:1': 0x1B,
+ 'zone_night:2': 0x13,
+ 'zone_night:3': 0x1A,
+ 'zone_night:4': 0x16,
+ 'brightness_up': 0x0C,
+ 'brightness_down': 0x04,
+ 'temperature_up': 0x0E,
+ 'temperature_down': 0x0F
+ }
+ },
+ 'rgb+cct': {
+ 'channels': [8, 39, 70],
+ 'syncword': [0x1809, 0x7236]
+ },
+ 'rgb': {
+ 'channels': [3, 38, 73],
+ 'syncword': [0xBCCD, 0x9AAB]
+ },
+ 'fut020': {
+ 'channels': [6, 41, 76],
+ 'syncword': [0xAA55, 0x50A0]
+ }
+ }
+
+ def __init__(self, radio, remote_type, remote_id, message_id = None, config = None):
+ if not radio.initialize():
+ raise ValueError('Radio initialization failed')
+
+ # Pull in the config for this remote type
+ self._config = self._get_type_parameters(remote_type)
+
+ # Allow the user to specify some more parameters
+ if config is not None:
+ self._config.update(config)
+
+ # Store parameters
+ self._radio = radio
+ self._type = remote_type
+ self._id = remote_id
+
+ # Initialize the message ID for this remote
+ if message_id is None:
+ self._message_id = random.randint(0, 255)
+ else:
+ self._message_id = message_id
+
+ return None
+
+ def _scale_int(self, input_value, input_range_low, input_range_high, output_range_low, output_range_high):
+ input_range = input_range_high - input_range_low
+ output_range = output_range_high - output_range_low
+
+ input_value = input_value - input_range_low
+
+ output = input_value * (output_range / input_range)
+
+ output = output + output_range_low
+
+ output = int(output + 0.5)
+ return output
+
+ def _debug(self, message):
+ print("MILITE DEBUG: " + message)
+ return None
+
+ def _get_type_parameters(self, remote_type):
+ config = self._remote_type_parameters_map[remote_type]
+
+ # Supply default config values
+ if 'retries' not in config:
+ config['retries'] = 3
+ if 'delay' not in config:
+ config['delay'] = 0.1
+
+ setattr(self, '_compute_button_message', getattr(self, '_compute_button_message_' + remote_type))
+ setattr(self, '_parse_button_message', getattr(self, '_parse_button_message_' + remote_type))
+
+ return config
+
+ def _compute_button_and_zone_from_button_id(self, button_id):
+ button_info = {}
+ button_info['button'] = 'unknown=' + str(button_id)
+ for button_name, button_value in self._config['button_map'].items():
+ if button_value == button_id:
+ button_info['button'] = button_name
+ break
+
+ # If the button name has a zone, split it out into its own parameter
+ if button_info['button'].find(':') != -1:
+ button_name_zone = button_info['button'].split(':')
+ button_info['button'] = button_name_zone[0]
+ button_info['zone'] = int(button_name_zone[1])
+
+ return button_info
+
+ def _compute_button_message_cct(self, button_info):
+ remote_id = button_info['remote_id']
+ message_id = button_info['message_id']
+
+ # Header consists of magic (0x5A), follow by 16-bit remote ID
+ header = [0x5A, (remote_id >> 8) & 0xff, remote_id & 0xff]
+
+ # Determine zone, default to all
+ zone = button_info.get('zone', 0)
+
+ # Some buttons need to be converted to zones
+ button_name = button_info['button']
+ if button_name in ['zone_on', 'zone_off', 'zone_max', 'zone_night']:
+ button_name = button_name + ':' + str(zone)
+
+ # Look up the button
+ button_id = self._config['button_map'][button_name]
+
+ # Compute message body
+ body = [zone, button_id, message_id]
+
+ # Compute message trailer
+ ## Include a CRC, for good measure ?
+ crc = 0
+ for byte in header + body:
+ crc = crc + byte
+ crc = crc & 0xff
+ trailer = [crc]
+
+ message = header + body + trailer
+
+ return message
+
+ def _parse_button_message_cct(self, button_message):
+ button_info = {}
+
+ # Verify the header -- if it is not valid, return None
+ if button_message[0] != 0x5A:
+ return None
+
+ # Parse out common parts of the message
+ button_info['remote_id'] = (button_message[1] << 8) | button_message[2]
+ button_info['zone'] = button_message[3]
+ button_info['message_id'] = button_message[5]
+
+ # Remove the all zone
+ if button_info['zone'] == 0:
+ del button_info['zone']
+
+ # Map the button ID to a button name
+ button_id = button_message[4]
+ button_info.update(self._compute_button_and_zone_from_button_id(button_id))
+
+ return button_info
+
+ def _compute_button_message_rgbw(self, button_info):
+ remote_id = button_info['remote_id']
+ message_id = button_info['message_id']
+
+ # Allow setting brightness for all zones
+ if button_info['button'] == 'set_brightness':
+ button_info['button'] = 'zone_set_brightness'
+ if 'zone' in button_info:
+ del button_info['zone']
+
+ # Header consists of magic (0xB0), follow by 16-bit remote ID
+ header = [0xB0, (remote_id >> 8) & 0xff, remote_id & 0xff]
+
+ # Default value for most buttons, since they do not need it
+ brightness = 0
+ color = 0
+
+ # Some buttons need to be converted to zones
+ button_name = button_info['button']
+ if button_name in ['zone_on', 'zone_off', 'zone_white', 'zone_night']:
+ button_name = button_name + ':' + str(button_info['zone'])
+
+ button_id = self._config['button_map'][button_name]
+
+ # Brightness and Color buttons should also set the appropriate
+ # parameters
+ if button_info['button'] == 'zone_set_brightness':
+ ## Brightness is a range of [0..25] (26 steps)
+ ## Shifted 3 bitsleft
+ brightness = button_info['brightness']
+ if brightness < 0:
+ brightness = 0
+ elif brightness > 25:
+ brightness = 25
+
+ brightness = 31 - ((brightness + 15) % 32)
+
+ brightness = brightness << 3
+
+ if 'zone' in button_info:
+ brightness = brightness | button_info['zone']
+
+ elif button_info['button'] == 'set_color':
+ color = button_info['color']
+
+ # Compute message
+ body = [color, brightness, button_id, message_id]
+
+ # Compute whole message
+ message = header + body
+
+ return message
+
+ def _parse_button_message_rgbw(self, button_message):
+ button_info = {}
+
+ # Verify the header -- if it is not valid, return None
+ if button_message[0] != 0xB0:
+ return None
+
+ # Parse out common parts of the message
+ button_info['remote_id'] = (button_message[1] << 8) | button_message[2]
+ button_info['color'] = button_message[3]
+ button_info['brightness'] = button_message[4]
+ button_info['message_id'] = button_message[6]
+
+ # Map the button ID to a button name
+ button_id = button_message[5]
+
+ button_info.update(self._compute_button_and_zone_from_button_id(button_id))
+
+ if button_info['button'] == 'zone_set_brightness':
+ brightness = button_info['brightness']
+ zone = brightness & 0b111
+ if zone != 0:
+ button_info['zone'] = zone
+ else:
+ button_info['button'] = 'set_brightness'
+
+ # Compute brightness value, there are 26 brightness steps, [16, 0][31, 23]
+ brightness = brightness >> 3
+ brightness = 31 - ((brightness + 15) % 32)
+ button_info['brightness'] = brightness
+
+ return button_info
+
+ def _get_next_message_id(self):
+ # Determine next message ID
+ self._message_id = (self._message_id + 1) & 0xff
+ return self._message_id
+
+ def _send_button(self, button_info):
+ # Configure radio parameters
+ self._radio.set_syncword(self._config['syncword'])
+
+ # Include the remote ID unless one was supplied
+ if 'remote_id' not in button_info:
+ button_info['remote_id'] = self._id
+
+ # Get the next message ID for this remote
+ if 'message_id' not in button_info:
+ message_id = self._get_next_message_id()
+ button_info['message_id'] = message_id
+ else:
+ self._message_id = button_info['message_id']
+
+ # Compute message
+ message = self._compute_button_message(button_info)
+
+ # Transmit
+ self._debug("Sending {}={} n={} times with a {}s delay".format(button_info, message, self._config['retries'], self._config['delay']))
+ self._radio.multi_transmit(message, self._config['channels'], self._config['retries'], self._config['delay'])
+
+ return True
+
+ def _set_brightness(self, brightness, zone = None):
+ if zone is None:
+ message = {'button': 'set_brightness'}
+ else:
+ message = {
+ 'button': 'zone_set_brightness',
+ 'zone': zone
+ }
+
+ message['brightness'] = brightness
+
+ return self._send_button(message)
+
+ def _step_value(self, target_value, target_range_min, target_range_max, button_prefix, zone):
+ # Step all the way to the nearest extreme before moving it to
+ # where it should be
+ target_range = target_range_max - target_range_min + 1
+ midpoint = (target_range / 2) + target_range_min
+
+ # Move to the "initial" value where we force the value
+ # to the extreme, then move it to its final value
+ initial_steps = target_range
+ if target_value < midpoint:
+ initial_direction = 'down'
+ final_direction = 'up'
+ initial_value = target_range_min
+ else:
+ initial_direction = 'up'
+ final_direction = 'down'
+ initial_value = target_range_max
+
+ # If this remote has a "max" feature, use that instead of stepping
+ use_max_button = False
+ if initial_value == target_range_max:
+ if 'has_max_{}'.format(button_prefix) in self._config['features']:
+ use_max_button = True
+
+ if use_max_button:
+ self._debug("[INITIAL] Going to max {}".format(button_prefix))
+ getattr(self, "max_{}".format(button_prefix))(zone)
+ else:
+ # Otherwise, step it
+ for step in range(initial_steps):
+ self._debug("[INITIAL] Stepping {} {}".format(button_prefix, initial_direction))
+ self._send_button({'button': "{}_{}".format(button_prefix, initial_direction)})
+
+ # Now that we have forced the value to the extreme, move in
+ # steps from that value to the desired value
+ if initial_value < target_value:
+ final_steps = target_value - initial_value
+ else:
+ final_steps = initial_value - target_value
+
+ for step in range(final_steps):
+ self._debug("[FINAL] Stepping {} {}".format(button_prefix, final_direction))
+ self._send_button({'button': "{}_{}".format(button_prefix, final_direction)})
+
+ return True
+
+ def _step_brightness(self, brightness, brightness_min, brightness_max, zone = None):
+ # Select the appropriate zone before sending the steps
+ # to ensure they reach the correct bulbs
+ self.on(zone)
+ time.sleep(0.1)
+ return self._step_value(brightness, brightness_min, brightness_max, 'brightness', zone)
+
+ def _step_temperature(self, temperature, temperature_min, temperature_max, zone = None):
+ # Select the appropriate zone before sending the steps
+ # to ensure they reach the correct bulbs
+ self.on(zone)
+ time.sleep(0.1)
+ return self._step_value(temperature, temperature_min, temperature_max, 'temperature', zone)
+
+ def _rgb_to_hue(self, r, g, b):
+ r = r / 255.0
+ g = g / 255.0
+ b = b / 255.0
+
+ cmax = max(r, max(g, b))
+ cmin = min(r, min(g, b))
+ diff = cmax - cmin
+
+ if cmax == cmin:
+ h = 0
+ elif cmax == r:
+ h = (60 * ((g - b) / diff) + 360) % 360
+ elif cmax == g:
+ h = (60 * ((b - r) / diff) + 120) % 360
+ elif cmax == b:
+ h = (60 * ((r - g) / diff) + 240) % 360
+
+ return h
+
+ def _rgb_to_color(self, rgb):
+ r = (rgb >> 16) & 0xff
+ g = (rgb >> 8) & 0xff
+ b = rgb & 0xff
+
+ if r == g and g == b:
+ return (r * -1) - 1
+
+ h = self._rgb_to_hue(r, g, b)
+
+ color = ((h / 360.0) * 255.0) + 26
+
+ color = int(color + 0.5)
+
+ self._debug("RGB = \x1b[38;2;%i;%i;%im%06x\x1b[0m; Hue = %s; Color = %i" % (r, g, b, rgb, str(h * 360), color))
+
+ return color
+
+ def rgb_to_color(self, rgb):
+ return self._rgb_to_color(rgb)
+
+ def raw_send_button(self, button_info):
+ return self._send_button(button_info)
+
+ def raw_read_button(self):
+ channel = self._config['channels'][0]
+ self._radio.set_syncword(self._config['syncword'])
+ data = self._radio.receive(channel = channel, wait = True, wait_time = 1)
+ message = self._parse_button_message(data)
+ return message
+
+ def set_brightness(self, brightness, zone = None):
+ if 'has_brightness' not in self._config['features']:
+ return False
+
+ if brightness < 0 or brightness > 255:
+ return False
+
+ self._debug("Setting brightness to {}".format(brightness))
+ if brightness == 0:
+ self._debug("Really setting to off")
+ return self.off(zone)
+
+ if brightness == 255:
+ if 'has_max_brightness' in self._config['features']:
+ return self.max_brightness(zone)
+
+ brightness_min = self._config['brightness_range'][0]
+ brightness_max = self._config['brightness_range'][1]
+
+ brightness = self._scale_int(brightness, 1, 255, self._config['brightness_range'][0], self._config['brightness_range'][1])
+
+ if 'can_set_brightness' in self._config['features']:
+ return self._set_brightness(brightness, zone)
+ else:
+ return self._step_brightness(brightness, brightness_min, brightness_max, zone)
+
+ def set_color(self, rgb, zone = None):
+ # Compute the color value from the RGB value
+ value = self._rgb_to_color(rgb)
+
+ # If the color selected is really a shade of grey, turn the
+ # bulbs white at that brightness
+ if value < 0:
+ brightness = (value + 1) * -1
+ self._debug("Brightness = {}".format(brightness))
+ if self.white(zone):
+ return self.set_brightness(brightness, zone)
+ else:
+ return False
+
+ # If the bulbs do not support color, nothing needs to be done
+ if 'has_color' not in self._config['features']:
+ return False
+
+ # Turn on the appropriate zone to select it
+ self.on(zone)
+ time.sleep(0.1)
+
+ # Press the button
+ return self._send_button({'button': 'set_color', 'color': value})
+
+ def set_temperature(self, kelvins, zone = None):
+ if 'has_temperature' not in self._config['features']:
+ return False
+
+ temperature_input_low = self._config['temperature_input_range'][0]
+ temperature_input_high = self._config['temperature_input_range'][1]
+ temperature_output_low = self._config['temperature_output_range'][0]
+ temperature_output_high = self._config['temperature_output_range'][1]
+
+ # Clamp the color temperature to something this remote supports
+ if kelvins < temperature_input_low:
+ kelvins = temperature_input_low
+ elif kelvins > temperature_input_high:
+ kelvins = temperature_input_high
+
+ temperature = self._scale_int(kelvins, temperature_input_low, temperature_input_high, temperature_output_low, temperature_output_high)
+
+ if 'can_set_temperature' in self._config['features']:
+ return self._set_temperature(temperature, zone)
+ else:
+ return self._step_temperature(temperature, temperature_output_low, temperature_output_high, zone)
+
+ def on(self, zone = None):
+ if zone is None:
+ message = {'button': 'on'}
+ else:
+ message = {
+ 'button': 'zone_on',
+ 'zone': zone
+ }
+ return self._send_button(message)
+
+ def off(self, zone = None):
+ if zone is None:
+ message = {'button': 'off'}
+ else:
+ message = {
+ 'button': 'zone_off',
+ 'zone': zone
+ }
+ return self._send_button(message)
+
+ def max_brightness(self, zone = None):
+ if 'has_max_brightness' not in self._config['features']:
+ return self.set_brightness(255, zone)
+
+ if zone is None:
+ message = {'button': 'max'}
+ else:
+ message = {
+ 'button': 'zone_max',
+ 'zone': zone
+ }
+ return self._send_button(message)
+
+ def white(self, zone = None):
+ # If the bulbs are already white, nothing needs to be done
+ if 'is_white' in self._config['features']:
+ return True
+
+ # If the bulbs do not support white, nothing needs to be done
+ if 'has_white' not in self._config['features']:
+ return False
+
+ if zone is None:
+ message = {'button': 'white'}
+ else:
+ message = {
+ 'button': 'zone_white',
+ 'zone': zone
+ }
+ return self._send_button(message)
+
+ def pair(self, zone):
+ # XXX
+ return False
+
+ def unpair(self, zone):
+ # XXX
+ return False