From cf214f04244e2bedcbda48f52bd7c1ba80c7424d Mon Sep 17 00:00:00 2001
From: Cort <cort@cortscorner.net>
Date: Fri, 9 Aug 2024 11:27:11 +0800
Subject: [PATCH] Updated hid_services to work with 1.23.0

---
 public/editor.html                |   2 +-
 public/extensions/hid_services.py | 717 ++++++++++++------------------
 public/js/extensions.js           |   2 +-
 3 files changed, 292 insertions(+), 429 deletions(-)

diff --git a/public/editor.html b/public/editor.html
index cf19ac0..7f183b5 100644
--- a/public/editor.html
+++ b/public/editor.html
@@ -106,7 +106,7 @@
   <script src="js/mqtt.js?v=0978b11e"></script>
   <script src="js/PythonSerial.js?v=7a9e26e4"></script>
   <script src="js/serial.js?v=1c57815a"></script>
-  <script src="js/extensions.js?v=26ae4204"></script>
+  <script src="js/extensions.js?v=d69b54bb"></script>
 
   <script src="js/main.js?v=52f13e93"></script>
 
diff --git a/public/extensions/hid_services.py b/public/extensions/hid_services.py
index a035fb8..fadd112 100644
--- a/public/extensions/hid_services.py
+++ b/public/extensions/hid_services.py
@@ -29,13 +29,6 @@
 F_READ_WRITE = bluetooth.FLAG_READ | bluetooth.FLAG_WRITE
 F_READ_NOTIFY = bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY
 
-ATT_F_READ = 0x01
-ATT_F_WRITE = 0x02
-
-# Advertising payloads are repeated packets of the following form:
-#   1 byte data length (N + 1)
-#   1 byte type (see constants below)
-#   N bytes type-specific data
 _ADV_TYPE_FLAGS = const(0x01)
 _ADV_TYPE_NAME = const(0x09)
 _ADV_TYPE_UUID16_COMPLETE = const(0x3)
@@ -46,7 +39,6 @@
 _ADV_TYPE_UUID128_MORE = const(0x6)
 _ADV_TYPE_APPEARANCE = const(0x19)
 
-# IRQ peripheral role event codes
 _IRQ_CENTRAL_CONNECT = const(1)
 _IRQ_CENTRAL_DISCONNECT = const(2)
 _IRQ_GATTS_WRITE = const(3)
@@ -89,9 +81,14 @@
 _PASSKEY_ACTION_DISP = const(3)
 _PASSKEY_ACTION_NUMCMP = const(4)
 
-class Advertiser:
+_GATTS_NO_ERROR = const(0x00)
+_GATTS_ERROR_READ_NOT_PERMITTED = const(0x02)
+_GATTS_ERROR_WRITE_NOT_PERMITTED = const(0x03)
+_GATTS_ERROR_INSUFFICIENT_AUTHENTICATION = const(0x05)
+_GATTS_ERROR_INSUFFICIENT_AUTHORIZATION = const(0x08)
+_GATTS_ERROR_INSUFFICIENT_ENCRYPTION = const(0x0f)
 
-    # Generate a payload to be passed to gap_advertise(adv_data=...).
+class Advertiser:
     def advertising_payload(self, limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
         payload = bytearray()
 
@@ -117,7 +114,6 @@ def _append(adv_type, value):
                 elif len(b) == 16:
                     _append(_ADV_TYPE_UUID128_COMPLETE, b)
 
-        # See org.bluetooth.characteristic.gap.appearance.xml
         if appearance:
             _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))
 
@@ -149,25 +145,21 @@ def decode_services(self, payload):
             services.append(bluetooth.UUID(u))
         return services
 
-    # Init as generic HID device (960 = generic HID appearance value)
     def __init__(self, ble, services=[UUID(0x1812)], appearance=const(960), name="Generic HID Device"):
         self._ble = ble
         self._payload = self.advertising_payload(name=name, services=services, appearance=appearance)
 
         self.advertising = False
 
-    # Start advertising at 100000 interval
     def start_advertising(self):
         if not self.advertising:
             self._ble.gap_advertise(100000, adv_data=self._payload)
 
-    # Stop advertising by setting interval of 0
     def stop_advertising(self):
         if self.advertising:
             self._ble.gap_advertise(0, adv_data=self._payload)
 
 
-# Class that represents a general HID device services
 class HumanInterfaceDevice(object):
     DEVICE_STOPPED = const(0)
     DEVICE_IDLE = const(1)
@@ -181,105 +173,124 @@ def __init__(self, device_name="Generic HID Device"):
         self.conn_handle = None
         self.state_change_callback = None
         self.io_capability = _IO_CAPABILITY_NO_INPUT_OUTPUT
-        self.bond = False
-        self.le_secure = False
+        self.bond = True
+        self.le_secure = True
+
+        self.encrypted = False
+        self.authenticated = False
+        self.bonded = False
+        self.key_size = 0
+
+        self.passkey = 1234
+        self.keys = {}
+
+        self.load_secrets()
 
         self.device_name = device_name
-        self.service_uuids = [UUID(0x180A), UUID(0x180F), UUID(0x1812)]  # Service UUIDs: DIS, BAS, HIDS
-        self.device_appearance = 960                                     # Generic HID Appearance
-        self.battery_level = 100
+        self.service_uuids = [UUID(0x180A), UUID(0x180F), UUID(0x1812)]
+        self.device_appearance = 960
 
         self.model_number = "1"
         self.serial_number = "1"
         self.firmware_revision = "1"
         self.hardware_revision = "1"
-        self.software_revision = "1"
+        self.software_revision = "2"
         self.manufacture_name = "Homebrew"
-        self.pnp_manufacturer_source = 0x01     # Bluetooth uuid list
-        self.pnp_manufacturer_uuid = 0xFE61     # 0xFEB2 for Microsoft, 0xFE61 for Logitech, 0xFD65 for Razer
-        self.pnp_product_id = 0x01              # ID 1
-        self.pnp_product_version = 0x0123       # Version 1.2.3
 
-        self.DIS = (                            # Device Information Service description
-            UUID(0x180A),                       # Device Information
+        self.pnp_manufacturer_source = 0x01
+        self.pnp_manufacturer_uuid = 0xFE61
+        self.pnp_product_id = 0x01
+        self.pnp_product_version = 0x0123
+
+        self.battery_level = 100
+
+        self.DIS = (
+            UUID(0x180A),
             (
-                (UUID(0x2A24), F_READ),         # Model number string
-                (UUID(0x2A25), F_READ),         # Serial number string
-                (UUID(0x2A26), F_READ),         # Firmware revision string
-                (UUID(0x2A27), F_READ),         # Hardware revision string
-                (UUID(0x2A28), F_READ),         # Software revision string
-                (UUID(0x2A29), F_READ),         # Manufacturer name string
-                (UUID(0x2A50), F_READ),         # PnP ID
+                (UUID(0x2A24), F_READ),
+                (UUID(0x2A25), F_READ),
+                (UUID(0x2A26), F_READ),
+                (UUID(0x2A27), F_READ),
+                (UUID(0x2A28), F_READ),
+                (UUID(0x2A29), F_READ),
+                (UUID(0x2A50), F_READ),
             ),
         )
-        self.BAS = (                            # Battery Service description
-            UUID(0x180F),                       # Device Information
+
+        self.BAS = (
+            UUID(0x180F),
             (
-                (UUID(0x2A19), F_READ_NOTIFY),  # Battery level
+                (UUID(0x2A19), F_READ_NOTIFY),
             ),
         )
 
-        self.services = [self.DIS, self.BAS]    # List of service descriptions, append HIDS
+        self.services = [self.DIS, self.BAS]
 
         self.HID_INPUT_REPORT = None
 
-        # Passkey for pairing
-        # Only used when io capability allows so
-        self.passkey = 1234
-
-        # Key store for bonding
-        self.keys = {}
-
-        # Load known keys
-        self.load_secrets()
-
-    # Interrupt request callback function
     def ble_irq(self, event, data):
-        if event == _IRQ_CENTRAL_CONNECT:              # Central connected
-            self.conn_handle, _, _ = data              # Save the handle
-            self.set_state(HumanInterfaceDevice.DEVICE_CONNECTED)     # (HIDS specification only allow one central to be connected)
-        elif event == _IRQ_CENTRAL_DISCONNECT:         # Central disconnected
-            self.conn_handle = None                    # Discard old handle
+        if event == _IRQ_CENTRAL_CONNECT:
+            self.conn_handle, _, _ = data
+            self.set_state(HumanInterfaceDevice.DEVICE_CONNECTED)
+        elif event == _IRQ_CENTRAL_DISCONNECT:
             conn_handle, addr_type, addr = data
+            self.conn_handle = None
             self.set_state(HumanInterfaceDevice.DEVICE_IDLE)
-        elif event == _IRQ_MTU_EXCHANGED:              # MTU was set
+            self.encrypted = False
+            self.authenticated = False
+            self.bonded = False
+        elif event == _IRQ_GATTS_READ_REQUEST:
+            conn_handle, attr_handle = data
+            if conn_handle != self.conn_handle:
+                return _GATTS_ERROR_READ_NOT_PERMITTED
+            elif self.bond and not self.bonded:
+                return _GATTS_ERROR_INSUFFICIENT_AUTHORIZATION
+            elif self.io_capability > _IO_CAPABILITY_NO_INPUT_OUTPUT and not self.authenticated:
+                return _GATTS_ERROR_INSUFFICIENT_AUTHENTICATION
+            elif self.le_secure and (not self.encrypted or self.key_size < 16):
+                return _GATTS_ERROR_INSUFFICIENT_ENCRYPTION
+            else:
+                return _GATTS_NO_ERROR
+        elif event == _IRQ_GATTS_INDICATE_DONE:
+            conn_handle, value_handle, status = data
+        elif event == _IRQ_MTU_EXCHANGED:
             conn_handle, mtu = data
-        elif event == _IRQ_CONNECTION_UPDATE:          # Connection parameters were updated
-            self.conn_handle, _, _, _, _ = data        # The new parameters
-        elif event == _IRQ_ENCRYPTION_UPDATE:          # Encryption updated
-            conn_handle, encrypted, authenticated, bonded, key_size = data
-        elif event == _IRQ_PASSKEY_ACTION:             # Passkey actions: accept connection or show/enter passkey
+            self._ble.config(mtu=mtu)
+        elif event == _IRQ_CONNECTION_UPDATE:
+            self.conn_handle, conn_interval, conn_latency, supervision_timeout, status = data
+            return None
+        elif event == _IRQ_ENCRYPTION_UPDATE:
+            conn_handle, self.encrypted, self.authenticated, self.bonded, self.key_size = data
+        elif event == _IRQ_PASSKEY_ACTION:
             conn_handle, action, passkey = data
-            if action == _PASSKEY_ACTION_NUMCMP:       # Do we accept this connection?
+            if action == _PASSKEY_ACTION_NUMCMP:
                 accept = False
-                if self.passkey_callback is not None:  # Is callback function set?
-                    accept = self.passkey_callback()   # Call callback for input
+                if self.passkey_callback is not None:
+                    accept = self.passkey_callback()
                 self._ble.gap_passkey(conn_handle, action, accept)
-            elif action == _PASSKEY_ACTION_DISP:       # Show our passkey
+            elif action == _PASSKEY_ACTION_DISP:
                 self._ble.gap_passkey(conn_handle, action, self.passkey)
-            elif action == _PASSKEY_ACTION_INPUT:      # Enter passkey
+            elif action == _PASSKEY_ACTION_INPUT:
                 pk = None
-                if self.passkey_callback is not None:  # Is callback function set?
-                    pk = self.passkey_callback()       # Call callback for input
+                if self.passkey_callback is not None:
+                    pk = self.passkey_callback()
                 self._ble.gap_passkey(conn_handle, action, pk)
-        elif event == _IRQ_GATTS_INDICATE_DONE:
-            conn_handle, value_handle, status = data
-        elif event == _IRQ_SET_SECRET:                 # Set secret for bonding
+        elif event == _IRQ_SET_SECRET:
             sec_type, key, value = data
             key = sec_type, bytes(key)
             value = bytes(value) if value else None
-            if value is None:                          # If value is empty, and
-                if key in self.keys:                   # If key is known then
-                    del self.keys[key]                 # Forget key
-                    self.save_secrets()                # Save bonding information
+            if value is None:
+                if key in self.keys:
+                    del self.keys[key]
+                    self.save_secrets()
                     return True
                 else:
                     return False
             else:
-                self.keys[key] = value                 # Remember key/value
-                self.save_secrets()                    # Save bonding information
+                self.keys[key] = value
+                self.save_secrets()
             return True
-        elif event == _IRQ_GET_SECRET:                 # Get secret for bonding
+        elif event == _IRQ_GET_SECRET:
             sec_type, index, key = data
             if key is None:
                 i = 0
@@ -292,72 +303,44 @@ def ble_irq(self, event, data):
             else:
                 key = sec_type, bytes(key)
                 return self.keys.get(key, None)
-        elif event == _IRQ_GATTS_READ_REQUEST:
-            conn_handle, attr_handle = data
-            self._ble.gatts_notify(conn_handle, attr_handle, struct.pack("<B", 0))
         else:
             pass
 
-    # Start the service
-    # Must be overwritten by subclass, and called in
-    # the overwritten function by using super(Subclass, self).start()
-    # io_capability determines whether and how passkeys are used
     def start(self):
         if self.device_state is HumanInterfaceDevice.DEVICE_STOPPED:
-            # Set interrupt request callback function
             self._ble.irq(self.ble_irq)
-
-            # Turn on BLE radio
             self._ble.active(1)
 
-            # Configure BLE interface
-            # Set GAP device name
             self._ble.config(gap_name=self.device_name)
-
-            # Configure MTU
             self._ble.config(mtu=23)
 
-            # Allow bonding
-            if self.bond:  # calling this on ESP32 is unsupported
-                self._ble.config(bond=True)
-
-            if self.le_secure:  # calling these on ESP32 is unsupported
-                # Require secure pairing
-                self._ble.config(le_secure=True)
-                # Require man in the middle protection
-                self._ble.config(mitm=True)
-                # Set our input/output capabilities
+            try:
+                self._ble.config(bond=self.bond)
+                self._ble.config(le_secure=self.le_secure)
+                self._ble.config(mitm=self.le_secure)
                 self._ble.config(io=self.io_capability)
+            except:
+                pass
 
             self.set_state(HumanInterfaceDevice.DEVICE_IDLE)
 
-    # After registering the DIS and BAS services, write their characteristic values
-    # Must be overwritten by subclass, and called in
-    # the overwritten function by using
-    # super(Subclass, self).write_service_characteristics(handles)
     def write_service_characteristics(self, handles):
-        # Get handles to service characteristics
-        # These correspond directly to self.DIS and sel.BAS
         (h_mod, h_ser, h_fwr, h_hwr, h_swr, h_man, h_pnp) = handles[0]
         (self.h_bat,) = handles[1]
 
-        def string_pack(in_str):
-            return struct.pack(str(len(in_str))+"s", in_str.encode('UTF-8'))
-
-        # Write service characteristics
-        self._ble.gatts_write(h_mod, string_pack(self.model_number))
-        self._ble.gatts_write(h_ser, string_pack(self.serial_number))
-        self._ble.gatts_write(h_fwr, string_pack(self.firmware_revision))
-        self._ble.gatts_write(h_hwr, string_pack(self.hardware_revision))
-        self._ble.gatts_write(h_swr, string_pack(self.software_revision))
-        self._ble.gatts_write(h_man, string_pack(self.manufacture_name))
-        # "<B" is now "<BHHH" basis https://www.bluetooth.com/wp-content/uploads/Sitecore-Media-Library/Gatt/Xml/Characteristics/org.bluetooth.characteristic.pnp_id.xml
+        def string_pack(in_str, nr_bytes):
+            return struct.pack(str(nr_bytes)+"s", in_str.encode('UTF-8'))
+
+        self._ble.gatts_write(h_mod, string_pack(self.model_number, 24))
+        self._ble.gatts_write(h_ser, string_pack(self.serial_number, 16))
+        self._ble.gatts_write(h_fwr, string_pack(self.firmware_revision, 8))
+        self._ble.gatts_write(h_hwr, string_pack(self.hardware_revision, 16))
+        self._ble.gatts_write(h_swr, string_pack(self.software_revision, 8))
+        self._ble.gatts_write(h_man, string_pack(self.manufacture_name, 36))
         self._ble.gatts_write(h_pnp, struct.pack("<BHHH", self.pnp_manufacturer_source, self.pnp_manufacturer_uuid, self.pnp_product_id, self.pnp_product_version))
 
-        # Battery level
         self._ble.gatts_write(self.h_bat, struct.pack("<B", self.battery_level))
 
-    # Stop the service
     def stop(self):
         if self.device_state is not HumanInterfaceDevice.DEVICE_STOPPED:
             if self.device_state is HumanInterfaceDevice.DEVICE_ADVERTISING:
@@ -371,7 +354,6 @@ def stop(self):
 
             self.set_state(HumanInterfaceDevice.DEVICE_STOPPED)
 
-    # Load bonding keys from json file
     def load_secrets(self):
         try:
             with open("keys.json", "r") as file:
@@ -381,7 +363,6 @@ def load_secrets(self):
         except:
             pass
 
-    # Save bonding keys from json file
     def save_secrets(self):
         try:
             with open("keys.json", "w") as file:
@@ -402,7 +383,6 @@ def is_connected(self):
     def is_advertising(self):
         return self.device_state is HumanInterfaceDevice.DEVICE_ADVERTISING
 
-    # Set a new state and notify the user's callback function
     def set_state(self, state):
         self.device_state = state
         if self.state_change_callback is not None:
@@ -411,11 +391,6 @@ def set_state(self, state):
     def get_state(self):
         return self.device_state
 
-    # Set a callback function to get notifications of state changes, i.e.
-    # - Device stopped
-    # - Device idle
-    # - Device advertising
-    # - Device connected
     def set_state_change_callback(self, callback):
         self.state_change_callback = callback
 
@@ -442,7 +417,6 @@ def get_appearance(self):
     def get_battery_level(self):
         return self.battery_level
 
-    # Sets the value for the battery level
     def set_battery_level(self, level):
         if level > 100:
             self.battery_level = 100
@@ -451,121 +425,86 @@ def set_battery_level(self, level):
         else:
             self.battery_level = level
 
-    # Set device information
-    # Must be called before calling Start()
-    # Variables must be Strings
     def set_device_information(self, manufacture_name="Homebrew", model_number="1", serial_number="1"):
         self.manufacture_name = manufacture_name
         self.model_number = model_number
         self.serial_number = serial_number
 
-    # Set device revision
-    # Must be called before calling Start()
-    # Variables must be Strings
     def set_device_revision(self, firmware_revision="1", hardware_revision="1", software_revision="1"):
         self.firmware_revision = firmware_revision
         self.hardware_revision = hardware_revision
         self.software_revision = software_revision
 
-    # Set device pnp information
-    # Must be called before calling Start()
-    # Must use the following format:
-    #   pnp_manufacturer_source: 0x01 for manufacturers uuid from the Bluetooth uuid list OR 0x02 from the USBs id list
-    #   pnp_manufacturer_uuid: 0xFEB2 for Microsoft, 0xFE61 for Logitech, 0xFD65 for Razer with source 0x01
-    #   pnp_product_id: One byte, user defined
-    #   pnp_product_version: Two bytes, user defined, format as 0xJJMN which corresponds to version JJ.M.N
     def set_device_pnp_information(self, pnp_manufacturer_source=0x01, pnp_manufacturer_uuid=0xFE61, pnp_product_id=0x01, pnp_product_version=0x0123):
         self.pnp_manufacturer_source = pnp_manufacturer_source
         self.pnp_manufacturer_uuid = pnp_manufacturer_uuid
         self.pnp_product_id = pnp_product_id
         self.pnp_product_version = pnp_product_version
 
-    # Set whether to use Bluetooth bonding
     def set_bonding(self, bond):
         self.bond = bond
 
-    # Set whether to use LE secure pairing
     def set_le_secure(self, le_secure):
         self.le_secure = le_secure
 
-    # Set input/output capability of this device
-    # Determines the pairing procedure, e.g., accept connection/passkey entry/just works
-    # Must be called before calling Start()
-    # Must use the following values:
-    #   _IO_CAPABILITY_DISPLAY_ONLY
-    #   _IO_CAPABILITY_DISPLAY_YESNO
-    #   _IO_CAPABILITY_KEYBOARD_ONLY
-    #   _IO_CAPABILITY_NO_INPUT_OUTPUT
-    #   _IO_CAPABILITY_KEYBOARD_DISPLAY
     def set_io_capability(self, io_capability):
         self.io_capability = io_capability
 
-    # Set callback function for pairing events
-    # Depending on the I/O capability used, the callback function should return either a
-    # - boolean to accept or deny a connection, or a
-    # - passkey that was displayed by the main
     def set_passkey_callback(self, passkey_callback):
         self.passkey_callback = passkey_callback
 
-    # Set the passkey used during pairing when entering a passkey at the main
     def set_passkey(self, passkey):
         self.passkey = passkey
 
-    # Notifies the central by writing to the battery level handle
     def notify_battery_level(self):
         if self.is_connected():
             self._ble.gatts_notify(self.conn_handle, self.h_bat, struct.pack("<B", self.battery_level))
 
-    # Notifies the central of the HID state
-    # Must be overwritten by subclass
     def notify_hid_report(self):
         return
 
 # Class that represents the Joystick service
 class Joystick(HumanInterfaceDevice):
     def __init__(self, name="Bluetooth Joystick"):
-        super(Joystick, self).__init__(name)  # Set up the general HID services in super
-        self.device_appearance = 963          # Device appearance ID, 963 = joystick
+        super(Joystick, self).__init__(name)
+        self.device_appearance = 963
 
-        self.HIDS = (                         # Service description: describes the service and how we communicate
-            UUID(0x1812),                     # Human Interface Device
+        self.HIDS = (
+            UUID(0x1812),
             (
-                (UUID(0x2A4A), F_READ),       # HID information
-                (UUID(0x2A4B), F_READ),       # HID report map
-                (UUID(0x2A4C), F_WRITE),      # HID control point
-                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4E), F_READ_WRITE), # HID protocol mode
+                (UUID(0x2A4A), F_READ),
+                (UUID(0x2A4B), F_READ),
+                (UUID(0x2A4C), F_WRITE),
+                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4E), F_READ_WRITE),
             ),
         )
 
-        # fmt: off
-        self.HID_INPUT_REPORT = bytes([    # Report Description: describes what we communicate
-            0x05, 0x01,                    # USAGE_PAGE (Generic Desktop)
-            0x09, 0x04,                    # USAGE (Joystick)
-            0xa1, 0x01,                    # COLLECTION (Application)
-            0x85, 0x01,                    #   REPORT_ID (1)
-            0xa1, 0x00,                    #   COLLECTION (Physical)
-            0x09, 0x30,                    #     USAGE (X)
-            0x09, 0x31,                    #     USAGE (Y)
-            0x15, 0x81,                    #     LOGICAL_MINIMUM (-127)
-            0x25, 0x7f,                    #     LOGICAL_MAXIMUM (127)
-            0x75, 0x08,                    #     REPORT_SIZE (8)
-            0x95, 0x02,                    #     REPORT_COUNT (2)
-            0x81, 0x02,                    #     INPUT (Data,Var,Abs)
-            0x05, 0x09,                    #     USAGE_PAGE (Button)
-            0x29, 0x08,                    #     USAGE_MAXIMUM (Button 8)
-            0x19, 0x01,                    #     USAGE_MINIMUM (Button 1)
-            0x95, 0x08,                    #     REPORT_COUNT (8)
-            0x75, 0x01,                    #     REPORT_SIZE (1)
-            0x25, 0x01,                    #     LOGICAL_MAXIMUM (1)
-            0x15, 0x00,                    #     LOGICAL_MINIMUM (0)
-            0x81, 0x02,                    #     Input (Data, Variable, Absolute)
-            0xc0,                          #   END_COLLECTION
-            0xc0                           # END_COLLECTION
+        self.HID_INPUT_REPORT = bytes([
+            0x05, 0x01,
+            0x09, 0x04,
+            0xa1, 0x01,
+            0x85, 0x01,
+            0xa1, 0x00,
+            0x09, 0x30,
+            0x09, 0x31,
+            0x15, 0x81,
+            0x25, 0x7f,
+            0x75, 0x08,
+            0x95, 0x02,
+            0x81, 0x02,
+            0x05, 0x09,
+            0x29, 0x08,
+            0x19, 0x01,
+            0x95, 0x08,
+            0x75, 0x01,
+            0x25, 0x01,
+            0x15, 0x00,
+            0x81, 0x02,
+            0xc0,
+            0xc0
         ])
-        # fmt: on
 
-        # Define the initial joystick state
         self.x = 0
         self.y = 0
 
@@ -578,50 +517,35 @@ def __init__(self, name="Bluetooth Joystick"):
         self.button7 = 0
         self.button8 = 0
 
-        self.services = [self.DIS, self.BAS, self.HIDS]  # List of service descriptions
+        self.services = [self.DIS, self.BAS, self.HIDS]
 
-    # Overwrite super to register HID specific service
-    # Call super to register DIS and BAS services
     def start(self):
-        super(Joystick, self).start()  # Start super
+        super(Joystick, self).start()
 
-        # Register services and get read/write handles for all services
         handles = self._ble.gatts_register_services(self.services)
-        # Write the values for the characteristics
         self.write_service_characteristics(handles)
 
-        # Create an Advertiser
-        # Only advertise the top level service, i.e., the HIDS
         self.adv = Advertiser(self._ble, [UUID(0x1812)], self.device_appearance, self.device_name)
 
-    # Overwrite super to write HID specific characteristics
-    # Call super to write DIS and BAS characteristics
     def write_service_characteristics(self, handles):
         super(Joystick, self).write_service_characteristics(handles)
 
-        # Get the handles from the hids, the third service after DIS and BAS
-        # These correspond directly to self.HIDS
         (h_info, h_hid, _, self.h_rep, h_d1, h_proto,) = handles[2]
 
-        # Pack the initial joystick state as described by the input report
         b = self.button1 + self.button2 * 2 + self.button3 * 4 + self.button4 * 8 + self.button5 * 16 + self.button6 * 32 + self.button7 * 64 + self.button8 * 128
         state = struct.pack("bbB", self.x, self.y, b)
 
-        # Write service characteristics
-        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")     # HID info: ver=1.1, country=0, flags=normal
-        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)    # HID input report map
-        self._ble.gatts_write(self.h_rep, state)               # HID report
-        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))  # HID reference: id=1, type=input
-        self._ble.gatts_write(h_proto, b"\x01")                # HID protocol mode: report
+        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")
+        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)
+        self._ble.gatts_write(self.h_rep, state)
+        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))
+        self._ble.gatts_write(h_proto, b"\x01")
 
-    # Overwrite super to notify central of a hid report
     def notify_hid_report(self):
         if self.is_connected():
-            # Pack the joystick state as described by the input report
             b = self.button1 + self.button2 * 2 + self.button3 * 4 + self.button4 * 8 + self.button5 * 16 + self.button6 * 32 + self.button7 * 64 + self.button8 * 128
             state = struct.pack("bbB", self.x, self.y, b)
 
-            # Notify central by writing to the report handle
             while True:
                 try:
                     self._ble.gatts_notify(self.conn_handle, self.h_rep, state)
@@ -665,88 +589,85 @@ def send_buttons(self, b1=0, b2=0, b3=0, b4=0, b5=0, b6=0, b7=0, b8=0):
 # Class that represents the Mouse service
 class Mouse(HumanInterfaceDevice):
     def __init__(self, name="Bluetooth Mouse", type="rel"):
-        super(Mouse, self).__init__(name)     # Set up the general HID services in super
-        self.device_appearance = 962          # Device appearance ID, 962 = mouse
+        super(Mouse, self).__init__(name)
+        self.device_appearance = 962
 
-        self.HIDS = (                         # Service description: describes the service and how we communicate
-            UUID(0x1812),                     # Human Interface Device
+        self.HIDS = (
+            UUID(0x1812),
             (
-                (UUID(0x2A4A), F_READ),       # HID information
-                (UUID(0x2A4B), F_READ),       # HID report map
-                (UUID(0x2A4C), F_WRITE),      # HID control point
-                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4E), F_READ_WRITE), # HID protocol mode
+                (UUID(0x2A4A), F_READ),
+                (UUID(0x2A4B), F_READ),
+                (UUID(0x2A4C), F_WRITE),
+                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4E), F_READ_WRITE),
             ),
         )
 
-        # fmt: off
         self.type = type
         if type == "rel":
-            self.HID_INPUT_REPORT = bytes([    # Report Description: describes what we communicate
-                0x05, 0x01,                    # USAGE_PAGE (Generic Desktop)
-                0x09, 0x02,                    # USAGE (Mouse)
-                0xa1, 0x01,                    # COLLECTION (Application)
-                0x85, 0x01,                    #   REPORT_ID (1)
-                0x09, 0x01,                    #   USAGE (Pointer)
-                0xa1, 0x00,                    #   COLLECTION (Physical)
-                0x05, 0x09,                    #         Usage Page (Buttons)
-                0x19, 0x01,                    #         Usage Minimum (1)
-                0x29, 0x03,                    #         Usage Maximum (3)
-                0x15, 0x00,                    #         Logical Minimum (0)
-                0x25, 0x01,                    #         Logical Maximum (1)
-                0x95, 0x03,                    #         Report Count (3)
-                0x75, 0x01,                    #         Report Size (1)
-                0x81, 0x02,                    #         Input(Data, Variable, Absolute); 3 button bits
-                0x95, 0x01,                    #         Report Count(1)
-                0x75, 0x05,                    #         Report Size(5)
-                0x81, 0x03,                    #         Input(Constant);                 5 bit padding
-                0x05, 0x01,                    #         Usage Page (Generic Desktop)
-                0x09, 0x30,                    #         Usage (X)
-                0x09, 0x31,                    #         Usage (Y)
-                0x09, 0x38,                    #         Usage (Wheel)
-                0x15, 0x81,                    #         Logical Minimum (-127)
-                0x25, 0x7F,                    #         Logical Maximum (127)
-                0x75, 0x08,                    #         Report Size (8)
-                0x95, 0x03,                    #         Report Count (3)
-                0x81, 0x06,                    #         Input(Data, Variable, Relative); 3 position bytes (X,Y,Wheel)
-                0xc0,                          #   END_COLLECTION
-                0xc0                           # END_COLLECTION
+            self.HID_INPUT_REPORT = bytes([
+                0x05, 0x01,
+                0x09, 0x02,
+                0xa1, 0x01,
+                0x85, 0x01,
+                0x09, 0x01,
+                0xa1, 0x00,
+                0x05, 0x09,
+                0x19, 0x01,
+                0x29, 0x03,
+                0x15, 0x00,
+                0x25, 0x01,
+                0x95, 0x03,
+                0x75, 0x01,
+                0x81, 0x02,
+                0x95, 0x01,
+                0x75, 0x05,
+                0x81, 0x03,
+                0x05, 0x01,
+                0x09, 0x30,
+                0x09, 0x31,
+                0x09, 0x38,
+                0x15, 0x81,
+                0x25, 0x7F,
+                0x75, 0x08,
+                0x95, 0x03,
+                0x81, 0x06,
+                0xc0,
+                0xc0
             ])
         else:
-            self.HID_INPUT_REPORT = bytes([    # Report Description: describes what we communicate
-                0x05, 0x01,                    # USAGE_PAGE (Generic Desktop)
-                0x09, 0x02,                    # USAGE (Mouse)
-                0xa1, 0x01,                    # COLLECTION (Application)
-                0x85, 0x01,                    #   REPORT_ID (1)
-                0x09, 0x01,                    #   USAGE (Pointer)
-                0xa1, 0x00,                    #   COLLECTION (Physical)
-                0x05, 0x09,                    #         Usage Page (Buttons)
-                0x19, 0x01,                    #         Usage Minimum (1)
-                0x29, 0x03,                    #         Usage Maximum (3)
-                0x15, 0x00,                    #         Logical Minimum (0)
-                0x25, 0x01,                    #         Logical Maximum (1)
-                0x95, 0x03,                    #         Report Count (3)
-                0x75, 0x01,                    #         Report Size (1)
-                0x81, 0x02,                    #         Input(Data, Variable, Absolute); 3 button bits
-                0x95, 0x01,                    #         Report Count(1)
-                0x75, 0x05,                    #         Report Size(5)
-                0x81, 0x03,                    #         Input(Constant);                 5 bit padding
-                0x05, 0x01,                    #         Usage Page (Generic Desktop)
-                0x09, 0x30,                    #         Usage (X)
-                0x09, 0x31,                    #         Usage (Y)
-                0x16, 0x00, 0x00,              #         Logical Minimum (0)
-                0x26, 0xFF, 0x7F,              #         Logical Maximum (32767)
-                0x36, 0x00, 0x00,              #         Physical Minimum (0)
-                0x46, 0xFF, 0x7F,              #         Physical Maximum (32767)
-                0x75, 0x10,                    #         Report Size (16)
-                0x95, 0x02,                    #         Report Count (2)
-                0x81, 0x02,                    #         Input(Data, Variable, Absolute);
-                0xc0,                          #   END_COLLECTION
-                0xc0                           # END_COLLECTION
+            self.HID_INPUT_REPORT = bytes([
+                0x05, 0x01,
+                0x09, 0x02,
+                0xa1, 0x01,
+                0x85, 0x01,
+                0x09, 0x01,
+                0xa1, 0x00,
+                0x05, 0x09,
+                0x19, 0x01,
+                0x29, 0x03,
+                0x15, 0x00,
+                0x25, 0x01,
+                0x95, 0x03,
+                0x75, 0x01,
+                0x81, 0x02,
+                0x95, 0x01,
+                0x75, 0x05,
+                0x81, 0x03,
+                0x05, 0x01,
+                0x09, 0x30,
+                0x09, 0x31,
+                0x16, 0x00, 0x00,
+                0x26, 0xFF, 0x7F,
+                0x36, 0x00, 0x00,
+                0x46, 0xFF, 0x7F,
+                0x75, 0x10,
+                0x95, 0x02,
+                0x81, 0x02,
+                0xc0,
+                0xc0
             ])
-        # fmt: on
 
-        # Define the initial mouse state
         self.x = 0
         self.y = 0
         self.w = 0
@@ -758,46 +679,32 @@ def __init__(self, name="Bluetooth Mouse", type="rel"):
         self.button2 = 0
         self.button3 = 0
 
-        self.services = [self.DIS, self.BAS, self.HIDS]  # List of service descriptions
+        self.services = [self.DIS, self.BAS, self.HIDS]
 
-    # Overwrite super to register HID specific service
-    # Call super to register DIS and BAS services
     def start(self):
         super(Mouse, self).start()  # Start super
 
-        # Register services and get read/write handles for all services
         handles = self._ble.gatts_register_services(self.services)
-        # Write the values for the characteristics
         self.write_service_characteristics(handles)
 
-        # Create an Advertiser
-        # Only advertise the top level service, i.e., the HIDS
         self.adv = Advertiser(self._ble, [UUID(0x1812)], self.device_appearance, self.device_name)
 
-    # Overwrite super to write HID specific characteristics
-    # Call super to write DIS and BAS characteristics
     def write_service_characteristics(self, handles):
         super(Mouse, self).write_service_characteristics(handles)
 
-        # Get the handles from the hids, the third service after DIS and BAS
-        # These correspond directly to self.HIDS
         (h_info, h_hid, _, self.h_rep, h_d1, h_proto,) = handles[2]
 
-        # Pack the initial mouse state as described by the input report
         b = self.button1 + self.button2 * 2 + self.button3 * 4
         state = struct.pack("Bbbb", b, self.x, self.y, self.w)
 
-        # Write service characteristics
-        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")     # HID info: ver=1.1, country=0, flags=normal
-        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)    # HID input report map
-        self._ble.gatts_write(self.h_rep, state)               # HID report
-        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))  # HID reference: id=1, type=input
-        self._ble.gatts_write(h_proto, b"\x01")                # HID protocol mode: report
+        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")
+        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)
+        self._ble.gatts_write(self.h_rep, state)
+        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))
+        self._ble.gatts_write(h_proto, b"\x01")
 
-    # Overwrite super to notify central of a hid report
     def notify_hid_report(self):
         if self.is_connected():
-            # Pack the mouse state as described by the input report
             if self.type == 'rel':
                 b = self.button1 + self.button2 * 2 + self.button3
                 state = struct.pack("Bbbb", b, self.x, self.y, self.w)
@@ -805,7 +712,6 @@ def notify_hid_report(self):
                 b = self.button1 + self.button2 * 2 + self.button3
                 state = struct.pack("<Bhh", b, self.x_a, self.y_a)
 
-            # Notify central by writing to the report handle
             while True:
                 try:
                     self._ble.gatts_notify(self.conn_handle, self.h_rep, state)
@@ -857,117 +763,97 @@ def send_abs(self, x, y):
 # Class that represents the Keyboard service
 class Keyboard(HumanInterfaceDevice):
     def __init__(self, name="Bluetooth Keyboard"):
-        super(Keyboard, self).__init__(name)  # Set up the general HID services in super
-        self.device_appearance = 961          # Device appearance ID, 961 = keyboard
+        super(Keyboard, self).__init__(name)
+        self.device_appearance = 961
 
-        self.HIDS = (                         # Service description: describes the service and how we communicate
-            UUID(0x1812),                     # Human Interface Device
+        self.HIDS = (
+            UUID(0x1812),
             (
-                (UUID(0x2A4A), F_READ),       # HID information
-                (UUID(0x2A4B), F_READ),       # HID report map
-                (UUID(0x2A4C), F_WRITE),      # HID control point
-                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4D), F_READ_WRITE, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4E), F_READ_WRITE), # HID protocol mode
+                (UUID(0x2A4A), F_READ),
+                (UUID(0x2A4B), F_READ),
+                (UUID(0x2A4C), F_WRITE),
+                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4D), F_READ_WRITE, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4E), F_READ_WRITE),
             ),
         )
 
-        # fmt: off
-        self.HID_INPUT_REPORT = bytes([    # Report Description: describes what we communicate
-            0x05, 0x01,                    # USAGE_PAGE (Generic Desktop)
-            0x09, 0x06,                    # USAGE (Keyboard)
-            0xa1, 0x01,                    # COLLECTION (Application)
-            0x85, 0x01,                    #     REPORT_ID (1)
-            0x75, 0x01,                    #     Report Size (1)
-            0x95, 0x08,                    #     Report Count (8)
-            0x05, 0x07,                    #     Usage Page (Key Codes)
-            0x19, 0xE0,                    #     Usage Minimum (224)
-            0x29, 0xE7,                    #     Usage Maximum (231)
-            0x15, 0x00,                    #     Logical Minimum (0)
-            0x25, 0x01,                    #     Logical Maximum (1)
-            0x81, 0x02,                    #     Input (Data, Variable, Absolute); Modifier byte
-            0x95, 0x01,                    #     Report Count (1)
-            0x75, 0x08,                    #     Report Size (8)
-            0x81, 0x01,                    #     Input (Constant); Reserved byte
-            0x95, 0x05,                    #     Report Count (5)
-            0x75, 0x01,                    #     Report Size (1)
-            0x05, 0x08,                    #     Usage Page (LEDs)
-            0x19, 0x01,                    #     Usage Minimum (1)
-            0x29, 0x05,                    #     Usage Maximum (5)
-            0x91, 0x02,                    #     Output (Data, Variable, Absolute); LED report
-            0x95, 0x01,                    #     Report Count (1)
-            0x75, 0x03,                    #     Report Size (3)
-            0x91, 0x01,                    #     Output (Constant); LED report padding
-            0x95, 0x06,                    #     Report Count (6)
-            0x75, 0x08,                    #     Report Size (8)
-            0x15, 0x00,                    #     Logical Minimum (0)
-            0x25, 0x65,                    #     Logical Maximum (101)
-            0x05, 0x07,                    #     Usage Page (Key Codes)
-            0x19, 0x00,                    #     Usage Minimum (0)
-            0x29, 0x65,                    #     Usage Maximum (101)
-            0x81, 0x00,                    #     Input (Data, Array); Key array (6 bytes)
-            0xc0                           # END_COLLECTION
+        self.HID_INPUT_REPORT = bytes([
+            0x05, 0x01,
+            0x09, 0x06,
+            0xa1, 0x01,
+            0x85, 0x01,
+            0x75, 0x01,
+            0x95, 0x08,
+            0x05, 0x07,
+            0x19, 0xE0,
+            0x29, 0xE7,
+            0x15, 0x00,
+            0x25, 0x01,
+            0x81, 0x02,
+            0x95, 0x01,
+            0x75, 0x08,
+            0x81, 0x01,
+            0x95, 0x05,
+            0x75, 0x01,
+            0x05, 0x08,
+            0x19, 0x01,
+            0x29, 0x05,
+            0x91, 0x02,
+            0x95, 0x01,
+            0x75, 0x03,
+            0x91, 0x01,
+            0x95, 0x06,
+            0x75, 0x08,
+            0x15, 0x00,
+            0x25, 0x65,
+            0x05, 0x07,
+            0x19, 0x00,
+            0x29, 0x65,
+            0x81, 0x00,
+            0xc0
         ])
-        # fmt: on
 
-        # Define the initial keyboard state
-        self.modifiers = 0             # 8 bits signifying Right GUI(Win/Command), Right ALT/Option, Right Shift, Right Control, Left GUI, Left ALT, Left Shift, Left Control
-        self.keypresses = [0x00] * 6   # 6 keys to hold
+        self.modifiers = 0
+        self.keypresses = [0x00] * 6
 
-        # Callback function for keyboard messages from central
         self.kb_callback = None
 
-        self.services = [self.DIS, self.BAS, self.HIDS]  # List of service descriptions
+        self.services = [self.DIS, self.BAS, self.HIDS]
 
-    # Interrupt request callback function
-    # Overwrite super to catch keyboard report write events by the central
     def ble_irq(self, event, data):
-        if event == _IRQ_GATTS_WRITE:                   # If a client has written to a characteristic or descriptor.
-            conn_handle, attr_handle = data             # Get the handle to the characteristic that was written
-            report = self._ble.gatts_read(attr_handle)  # Read the report
-            bytes = struct.unpack("B", report)          # Unpack the report
-            if self.kb_callback is not None:            # Call the callback function
+        if event == _IRQ_GATTS_WRITE:
+            conn_handle, attr_handle = data
+            report = self._ble.gatts_read(attr_handle)
+            bytes = struct.unpack("B", report)
+            if self.kb_callback is not None:
                 self.kb_callback(bytes)
-        else:                                           # Else let super handle the event
+        else:
             super(Keyboard, self).ble_irq(event, data)
 
-    # Overwrite super to register HID specific service
-    # Call super to register DIS and BAS services
     def start(self):
         super(Keyboard, self).start()  # Start super
 
-        # Register services and get read/write handles for all services
         handles = self._ble.gatts_register_services(self.services)
-        # Write the values for the characteristics
         self.write_service_characteristics(handles)
 
-        # Create an Advertiser
-        # Only advertise the top level service, i.e., the HIDS
         self.adv = Advertiser(self._ble, [UUID(0x1812)], self.device_appearance, self.device_name)
 
-    # Overwrite super to write HID specific characteristics
-    # Call super to write DIS and BAS characteristics
     def write_service_characteristics(self, handles):
         super(Keyboard, self).write_service_characteristics(handles)
 
-        # Get the handles from the hids, the third service after DIS and BAS
-        # These correspond directly to self.HIDS
         (h_info, h_hid, _, self.h_rep, h_d1, self.h_repout, h_d2, h_proto,) = handles[2]
 
-        # Write service characteristics
-        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")     # HID info: ver=1.1, country=0, flags=normal
-        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)    # HID input report map
-        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))  # HID reference: id=1, type=input
-        self._ble.gatts_write(h_d2, struct.pack("<BB", 1, 2))  # HID reference: id=1, type=output
-        self._ble.gatts_write(h_proto, b"\x01")                # HID protocol mode: report
+        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")
+        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)
+        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))
+        self._ble.gatts_write(h_d2, struct.pack("<BB", 1, 2))
+        self._ble.gatts_write(h_proto, b"\x01")
 
-    # Overwrite super to notify central of a hid report
     def notify_hid_report(self):
         if self.is_connected():
-            # Pack the Keyboard state as described by the input report
             state = struct.pack("8B", self.modifiers, 0, self.keypresses[0], self.keypresses[1], self.keypresses[2], self.keypresses[3], self.keypresses[4], self.keypresses[5])
 
-            # Notify central by writing to the report handle
             while True:
                 try:
                     self._ble.gatts_notify(self.conn_handle, self.h_rep, state)
@@ -975,17 +861,12 @@ def notify_hid_report(self):
                 except:
                     time.sleep_ms(10)
 
-    # Set the modifier bits, notify to send the modifiers to central
     def set_modifiers(self, right_gui=0, right_alt=0, right_shift=0, right_control=0, left_gui=0, left_alt=0, left_shift=0, left_control=0):
         self.modifiers = (right_gui << 7) + (right_alt << 6) + (right_shift << 5) + (right_control << 4) + (left_gui << 3) + (left_alt << 2) + (left_shift << 1) + left_control
 
-    # Press keys, notify to send the keys to central
-    # This will hold down the keys, call set_keys() without arguments and notify again to release
     def set_keys(self, k0=0x00, k1=0x00, k2=0x00, k3=0x00, k4=0x00, k5=0x00):
         self.keypresses = [k0, k1, k2, k3, k4, k5]
 
-    # Set a callback function that gets notified on keyboard changes
-    # Should take a tuple with the report bytes
     def set_kb_callback(self, kb_callback):
         self.kb_callback = kb_callback
 
@@ -1058,22 +939,21 @@ def send_string(self, st):
 # Class that represents the Consumer Control service
 class ConsumerControl(HumanInterfaceDevice):
     def __init__(self, name="Bluetooth CCD"):
-        super(ConsumerControl, self).__init__(name)  # Set up the general HID services in super
-        self.device_appearance = 384          # Device appearance ID, 384 = remote control
+        super(ConsumerControl, self).__init__(name)
+        self.device_appearance = 384
 
-        self.HIDS = (                         # Service description: describes the service and how we communicate
-            UUID(0x1812),                     # Human Interface Device
+        self.HIDS = (
+            UUID(0x1812),
             (
-                (UUID(0x2A4A), F_READ),       # HID information
-                (UUID(0x2A4B), F_READ),       # HID report map
-                (UUID(0x2A4C), F_WRITE),      # HID control point
-                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4D), F_READ_WRITE, ((UUID(0x2908), ATT_F_READ),)),  # HID report / reference
-                (UUID(0x2A4E), F_READ_WRITE), # HID protocol mode
+                (UUID(0x2A4A), F_READ),
+                (UUID(0x2A4B), F_READ),
+                (UUID(0x2A4C), F_WRITE),
+                (UUID(0x2A4D), F_READ_NOTIFY, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4D), F_READ_WRITE, ((UUID(0x2908), 0x03),)),
+                (UUID(0x2A4E), F_READ_WRITE),
             ),
         )
 
-        # fmt: off
         self.HID_INPUT_REPORT = bytes([    # Report Description: describes what we communicate
             0x05, 0x0C,                    # USAGE_PAGE (Consumer)
             0x09, 0x01,                    # USAGE (Consumer Control)
@@ -1088,49 +968,34 @@ def __init__(self, name="Bluetooth CCD"):
             0x81, 0x00,                    #     Input (Data, Array)
             0xc0                           # END_COLLECTION
         ])
-        # fmt: on
 
         self.keypress = 0x00
 
-        self.services = [self.DIS, self.BAS, self.HIDS]  # List of service descriptions
+        self.services = [self.DIS, self.BAS, self.HIDS]
 
-    # Overwrite super to register HID specific service
-    # Call super to register DIS and BAS services
     def start(self):
         super(ConsumerControl, self).start()  # Start super
 
-        # Register services and get read/write handles for all services
         handles = self._ble.gatts_register_services(self.services)
-        # Write the values for the characteristics
         self.write_service_characteristics(handles)
 
-        # Create an Advertiser
-        # Only advertise the top level service, i.e., the HIDS
         self.adv = Advertiser(self._ble, [UUID(0x1812)], self.device_appearance, self.device_name)
 
-    # Overwrite super to write HID specific characteristics
-    # Call super to write DIS and BAS characteristics
     def write_service_characteristics(self, handles):
         super(ConsumerControl, self).write_service_characteristics(handles)
 
-        # Get the handles from the hids, the third service after DIS and BAS
-        # These correspond directly to self.HIDS
         (h_info, h_hid, _, self.h_rep, h_d1, self.h_repout, h_d2, h_proto,) = handles[2]
 
-        # Write service characteristics
-        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")     # HID info: ver=1.1, country=0, flags=normal
-        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)    # HID input report map
-        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))  # HID reference: id=1, type=input
-        self._ble.gatts_write(h_d2, struct.pack("<BB", 1, 2))  # HID reference: id=1, type=output
-        self._ble.gatts_write(h_proto, b"\x01")                # HID protocol mode: report
+        self._ble.gatts_write(h_info, b"\x01\x01\x00\x02")
+        self._ble.gatts_write(h_hid, self.HID_INPUT_REPORT)
+        self._ble.gatts_write(h_d1, struct.pack("<BB", 1, 1))
+        self._ble.gatts_write(h_d2, struct.pack("<BB", 1, 2))
+        self._ble.gatts_write(h_proto, b"\x01")
 
-    # Overwrite super to notify central of a hid report
     def notify_hid_report(self):
         if self.is_connected():
-            # Pack the Keyboard state as described by the input report
             state = struct.pack("<h", self.keypress)
 
-            # Notify central by writing to the report handle
             while True:
                 try:
                     self._ble.gatts_notify(self.conn_handle, self.h_rep, state)
@@ -1138,8 +1003,6 @@ def notify_hid_report(self):
                 except:
                     time.sleep_ms(10)
 
-    # Press keys, notify to send the keys to central
-    # This will hold down the keys, call set_keys() without arguments and notify again to release
     def set_key(self, key=0x00):
         self.keypress = key
 
diff --git a/public/js/extensions.js b/public/js/extensions.js
index 133f304..0c98be2 100644
--- a/public/js/extensions.js
+++ b/public/js/extensions.js
@@ -589,7 +589,7 @@ var extensions = new function() {
       id: 'hid_services',
       name: 'Bluetooth LE Human Interface Devices',
       files: [
-        ['hid_services.py', 'extensions/hid_services.py?v=a4f25ed2'],
+        ['hid_services.py', 'extensions/hid_services.py?v=f07a95e0'],
       ],
       description:
         '<p>' +