Add config options and improve accuracy of final height

rhyst · rhyst · commit cfab5a7d75f7 · 2020-06-01T10:19:39.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,3 @@
 ref/
 venv/
+config.yaml
diff --git a/README.md b/README.md
@@ -1,2 +1,83 @@
 # idasen-controller
-Script to control the Ikea Idasen standing desk
+
+The Idasen is a Linak standing desk sold by Ikea. It can be controlled by a physical switch on the desk or via bluetooth using an phone app. This is a script to control the Idasen via bluetooth from a computer.
+
+## Set up
+
+### Prerequisites
+
+The desk should be connected and paired to the computer.
+
+### Install
+
+Install the Python requirements found in `requirements.text`.
+
+### Configuration
+
+Configuration can either be provided with a file, or via command line arguments. Use `--help` to see the command line arguments help. Edit `config.yaml` if you prefer your config to be in a file.
+
+Config options:
+
+- `mac_address` - The MAC address of the desk. This is required.
+- `stand_height` - The standing height from the floor of the desk in mm. Default `1040`.
+- `sit_height` - The standing height from the floor of the desk in mm. Default `683`.
+- `adapter_name` - The adapter name for the bluetooth adapter to use for the connection. Default `hci0`
+
+Device MAC addresses can be found using `blueoothctl` and blueooth adapter names can be found with `hcitool dev` on linux.
+
+## Usage
+
+### Command Line
+
+To print the current desk height:
+
+```
+python3 main.py
+
+```
+
+Assuming the config file is populated to move the desk to standing position:
+
+```
+python3 main.py --stand
+```
+
+Assuming the config file is populated to move the desk to sitting position:
+
+```
+python3 main.py --sit
+```
+
+### Albert Launcher
+
+I use the [albert](https://github.com/albertlauncher/albert) launcher along with two `.desktop` files to allow me to trigger this script from the launcher. An example of a desktop file for this is:
+
+```
+[Desktop Entry]
+Name=Desk - Sit
+Exec=/home/user/idasen-controller/venv/bin/python /home/user/idasen-controller/main.py --sit
+Icon=/home/user/idasen-controller/sit-icon.png
+Type=Application
+Comment=Lower desk to sitting height.
+
+```
+
+## Desk Internals
+
+### Connection and Commands
+
+Connecting and pairing can be done by any bluetooth device and there is no authentication. Once connected the desk communicates using Bluetooth LE, using the GATT protocol. GATT is quite complex and I do not understand much of it but the useful bit is that the desk advertises some `characteristics` which are addresses that bytes can be written to and read from. There's various other things like `services` and `descriptors` but they were not relevant to getting this working.
+
+Python has several packages available for communicating over GATT so the only tricky bit is working out what each of the characteristics do and what data they want. It seems like in general they're expecting quite simple data to be exchanged.
+
+The desk is from Ikea but it is a rebranded Linak device, and Linak publish an app to control it. I was able to examine the app to find out missing information. This included mapping the characteristic UUIDs to functionality (the two important ones being the characteristic that accepts commands to control the desk, and the characteristic that broadcasts the current height of the desk), and also finding out the command codes and the format they needed to be in.
+
+For example to move the desk up you encode `71` into bytes as an unsigned little endian short and write that to the characteristic identified by the UUID `99fa0002-338a-1024-8a49-009c0215f78a`. The other command codes are similar short numbers. For some reason there is another characteristic (reference input) that accepts up/down/stop commands but it requires signed little endian shorts. I don't understand why it is like this.
+
+### Behaviour
+
+Sending move commands to the desk seems to make the motors run for about one second in the desired direction. If another move command is sent within that second then the motion continues with no slowing or stopping. If no move command is recieved in that second then the motor slows down towards the end and then stops. If you send a move command late, then there will some stuttering as the desk may have already started to slow the motors. You can stop the motion part way through by sending a stop command though it sometimes does not respond immediately. As the desk moves it sends notifications of the current height to a characteristic. This can be monitored to work out when to stop moving, but it also seems to be a little bit slow and the final notified value is often not the same as the actual final value if a measuremment is made at rest.
+
+The height values the desk provides are in 10ths of a millimetre, and correspond to the height above the desks lowest setting i.e. if you lower the desk as far as it will go then the desk will report its height as being zero. The minimum raw height value is zero and the maximum height is 6500. This corresponds to a range of 620mm to 1270mm off the floor.
+
+The desk appears to be pretty good at not doing anything stupid if you send it stupid commands. It won't try to go below the minimum height or above the maximum height and it doesn't do much if you send lots of commands in quick succession. The usual hit detection works, and it will stop moving if it hits an object and will not respond to further commands until a stop command is sent.
diff --git a/config.yaml b/config.yaml
@@ -0,0 +1,4 @@
+mac_address: AA:AA:AA:AA:AA:AA
+stand_height: 1040
+sit_height: 683
+adapter_name: hci0
diff --git a/main.py b/main.py
@@ -1,24 +1,103 @@
+#!python3
 import gatt
 import struct
 import argparse
+import os
+import yaml
+
+UUID_HEIGHT = '99fa0021-338a-1024-8a49-009c0215f78a'
+UUID_COMMAND = '99fa0002-338a-1024-8a49-009c0215f78a'
+UUID_REFERENCE_INPUT = '99fa0031-338a-1024-8a49-009c0215f78a'
+
+COMMAND_UP = struct.pack("<H", 71)
+COMMAND_DOWN = struct.pack("<H", 70)
+COMMAND_STOP = struct.pack("<H", 255)
+
+COMMAND_REFERENCE_INPUT_STOP = struct.pack("<H", 32769)
+COMMAND_REFERENCE_INPUT_UP = struct.pack("<H", 32768)
+COMMAND_REFERENCE_INPUT_DOWN = struct.pack("<H", 32767)
+
+# Height of the desk at it's lowest (in mm)
+# I assume this is the same for all Idasen desks
+BASE_HEIGHT = 620
+MAX_HEIGHT = 1270  # 6500
+
+# Default config
+config = {
+    "mac_address": None,
+    "stand_height": BASE_HEIGHT + 420,
+    "sit_height": BASE_HEIGHT + 63,
+    "adapter_name": 'hci0',
+    "sit": False,
+    "stand": False
+}
+
+# Overwrite from config.yaml
+config_file = {}
+config_file_path = os.path.join(os.path.dirname(
+    os.path.realpath(__file__)), 'config.yaml')
+if (config_file_path):
+    with open(config_file_path, 'r') as stream:
+        try:
+            config_file = yaml.safe_load(stream)
+        except yaml.YAMLError as exc:
+            print("Reading config.yaml failed")
+            exit(1)
+config.update(config_file)
+
+# Overwrite from command line args
+parser = argparse.ArgumentParser(description='')
+parser.add_argument('--mac-address', dest='mac_address',
+                    type=str, help="Mac address of the Idasen desk")
+parser.add_argument('--stand-height', dest='stand_height', type=int,
+                    help="The height the desk should be at when standing")
+parser.add_argument('--sit-height', dest='sit_height', type=int,
+                    help="The height the desk should be at when sitting")
+parser.add_argument('--adapter', dest='adapter_name', type=str,
+                    help="The bluetooth adapter device name")
+parser.add_argument('--sit', dest='sit', action='store_true',
+                    help="Move the desk to sitting height")
+parser.add_argument('--stand', dest='stand', action='store_true',
+                    help="Move the desk to standing height")
 
+args = {k: v for k, v in vars(parser.parse_args()).items() if v is not None}
+config.update(args)
 
-STAND_HEIGHT = 4402
-SIT_HEIGHT = 630
+if not config['mac_address']:
+    parser.error("Mac address must be provided")
 
-parser = argparse.ArgumentParser(description='')
-parser.add_argument('--stand', dest='stand', action='store_true')
-parser.set_defaults(stand=False)
-args = parser.parse_args()
+if config['sit'] and config['stand']:
+    parser.error("Only one of --sit and --stand can be used")
+
+if config['sit_height'] >= config['stand_height']:
+    parser.error("Sit height must be less than stand height")
+
+if config['sit_height'] < BASE_HEIGHT:
+    parser.error("Sit height must be greater than {}".format(BASE_HEIGHT))
+
+if config['stand_height'] > MAX_HEIGHT:
+    parser.error("Stand height must be less than {}".format(MAX_HEIGHT))
+
+
+def mmToRaw(mm):
+    return (mm - BASE_HEIGHT) * 10
+
+
+def rawToMM(raw):
+    return (raw / 10) + BASE_HEIGHT
+
+
+config['stand_height_raw'] = mmToRaw(config['stand_height'])
+config['sit_height_raw'] = mmToRaw(config['sit_height'])
 
-# Pick your adapter
-manager = gatt.DeviceManager(adapter_name='hci0')
 
-class AnyDevice(gatt.Device):
-    def __init__(self, mac_address, manager):
+class Desk(gatt.Device):
+    def __init__(self, mac_address, manager, config):
+        self.config = config
         self.direction = None
-        self.target = None
         self.height = None
+        self.target = None
+        self.count = 0
         super().__init__(mac_address, manager)
 
     def connect_succeeded(self):
@@ -36,58 +115,103 @@ def disconnect_succeeded(self):
     def services_resolved(self):
         super().services_resolved()
 
+        if self.config['sit']:
+            self.target = self.config['sit_height_raw']
+        if self.config['stand']:
+            self.target = self.config['stand_height_raw']
+
         for service in self.services:
             for characteristic in service.characteristics:
-                if characteristic.uuid == '99fa0021-338a-1024-8a49-009c0215f78a':
-                    # raw = characteristic.read_value()
-                    # print("Inital height: {}".format(int.from_bytes(bytes([int(raw[0])]) + bytes([int(raw[1])]), 'little')))
-                    characteristic.enable_notifications()
-                    characteristic.read_value()
-                if characteristic.uuid == '99fa0002-338a-1024-8a49-009c0215f78a':
-                    self.command = characteristic
+                if characteristic.uuid == UUID_HEIGHT:
+                    self.height_characteristic = characteristic
+                    self.height_characteristic.enable_notifications()
+                    # Reading the value triggers self.characteristic_value_updated
+                    self.height_characteristic.read_value()
+                if characteristic.uuid == UUID_COMMAND:
+                    self.command_characteristic = characteristic
+                if characteristic.uuid == UUID_REFERENCE_INPUT:
+                    self.reference_input_characteristic = characteristic
 
     def characteristic_value_updated(self, characteristic, value):
-        height, speed = struct.unpack("<HH", value)
-        print("Height change: {}".format(height))
-        self.height = height
-        #if self.has_reached_target():
-            #self.command.write_value(struct.pack("<H", 255))
-        if not self.direction:
-            self.move_to_target()
+        if characteristic.uuid == UUID_HEIGHT:
+            height, speed = struct.unpack("<HH", value)
+            self.count += 1
+            self.height = height
+
+            # No target specified so print current height
+            if not self.target:
+                print("Current height: {}mm".format(rawToMM(height)))
+                self.stop()
+                return
+
+            # Initialise by setting the movement direction and asking to send
+            # move commands
+            if not self.direction:
+                print("Initial height: {}mm".format(rawToMM(height)))
+                self.direction = "UP" if self.target > self.height else "DOWN"
+                self.move_to_target()
+
+            # If already moving then stop if we have reached the target
+            if self.has_reached_target():
+                print("Stopping at height: {}mm (target: {}mm)".format(
+                    rawToMM(height), rawToMM(self.target)))
+                self.stop()
+            # Or resend the movement command if we have not yet reached the
+            # target.
+            # Each movement command seems to run the desk motors for about 1
+            # second if uninterrupted and the height value is updated about 16
+            # times.
+            # Resending the command on the 12th update seems a good balance
+            # between helping to avoid overshoots and preventing stutterinhg
+            # (the motor seems to slow if no new move command has been sent)
+            elif self.count == 12:
+                self.count = 0
+                self.move_to_target()
 
     def characteristic_write_value_succeeded(self, characteristic):
-        self.move_to_target()
+        if characteristic.uuid == UUID_COMMAND and self.target:
+            pass
+        if characteristic.uuid == UUID_REFERENCE_INPUT:
+            pass
 
     def characteristic_write_value_failed(self, characteristic, error):
         print("Error ", error)
+        self.stop()
 
     def has_reached_target(self):
-        return (self.direction == "DOWN" and self.height <= self.target) or (self.direction == "UP" and self.height >= self.target)
-
-    def set_target(self, target):
-        self.target = target
-        self.direction = None
+        # The notified height values seem a bit behind so try to stop before
+        # reaching the target value to prevent overshooting
+        return (abs(self.height - self.target) <= 20)
 
     def move_to_target(self):
-        if not self.direction: 
-            self.direction = "UP" if self.target > self.height else "DOWN"
         if self.has_reached_target():
-            self.command.write_value(struct.pack("<H", 255))
-            manager.stop()
+            return
         elif self.direction == "DOWN" and self.height > self.target:
-            self.command.write_value(struct.pack("<H", 70))
+            self.move_down()
         elif self.direction == "UP" and self.height < self.target:
-            self.command.write_value(struct.pack("<H", 71))
+            self.move_up()
 
-device = AnyDevice(mac_address='E8:5B:5B:24:22:E4', manager=manager)
-device.connect()
-if args.stand:
-    device.set_target(STAND_HEIGHT)
-else:
-    device.set_target(SIT_HEIGHT)
+    def move_up(self):
+        self.command_characteristic.write_value(COMMAND_UP)
+
+    def move_down(self):
+        self.command_characteristic.write_value(COMMAND_DOWN)
+
+    def stop(self):
+        # This emulates the behaviour of the app. Stop commands are sent to both
+        # Reference Input and Command characteristics.
+        self.command_characteristic.write_value(COMMAND_STOP)
+        self.reference_input_characteristic.write_value(
+            COMMAND_REFERENCE_INPUT_STOP)
+        manager.stop()
 
+
+manager = gatt.DeviceManager(adapter_name=config['adapter_name'])
+device = Desk(mac_address=config['mac_address'],
+              manager=manager, config=config)
+device.connect()
 try:
     manager.run()
 except KeyboardInterrupt:
+    device.stop()
     manager.stop()
-    print("\rExiting")
diff --git a/ref/scratch b/ref/scratch
diff --git a/requirements.txt b/requirements.txt
