Wording

Heerkog · Heerkog · commit e740a590cd2a · 2025-08-01T13:22:00.000+02:00
diff --git a/hid_services.py b/hid_services.py
@@ -690,7 +690,7 @@ def save_service_characteristics(self, handles):
         self.characteristics[h_d1] = ("HID reference", struct.pack("<BB", 1, 1))                                        # HID reference: id=1, type=input.
         self.characteristics[h_proto] = ("HID protocol mode", b"\x01")                                                  # HID protocol mode: report.
 
-    # Overwrite super to notify central of a hid report.
+    # Overwrite super to notify client of a hid report.
     def notify_hid_report(self):
         if self.is_connected():
             b = self.button1 + self.button2 * 2 + self.button3 * 4 + self.button4 * 8 + self.button5 * 16 + self.button6 * 32 + self.button7 * 64 + self.button8 * 128
@@ -817,13 +817,13 @@ def save_service_characteristics(self, handles):
         self.characteristics[h_d1] = ("HID reference", struct.pack("<BB", 1, 1))                                        # HID reference: id=1, type=input.
         self.characteristics[h_proto] = ("HID protocol mode", b"\x01")                                                  # HID protocol mode: report.
 
-    # Overwrite super to notify central of a hid report
+    # Overwrite super to notify client of a hid report
     def notify_hid_report(self):
         if self.is_connected():
             b = self.button1 + self.button2 * 2 + self.button3
             state = struct.pack("Bbbb", b, self.x, self.y, self.w)                                                      # Pack the mouse state as described by the input report.
             self.characteristics[self.h_rep] = ("HID report", state)
-            self._ble.gatts_notify(self.conn_handle, self.h_rep, state)                                                 # Notify central by writing to the report handle.
+            self._ble.gatts_notify(self.conn_handle, self.h_rep, state)                                                 # Notify client by writing to the report handle.
             print("Notify with report: ", struct.unpack("Bbbb", state))
 
     # Set the mouse axes values.
@@ -925,12 +925,12 @@ def __init__(self, name="Bluetooth Keyboard"):
         self.services.append(self.HIDS)                                                                                 # Append to list of service descriptions.
 
     # Interrupt request callback function
-    # Overwrite super to catch keyboard report write events by the central.
+    # Overwrite super to catch keyboard report write events by the client.
     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.
             if attr_handle == self.h_repout:
-                print("Keyboard changed by Central")
+                print("Keyboard changed by client")
                 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.
@@ -968,20 +968,20 @@ def save_service_characteristics(self, handles):
         self.characteristics[h_d2] = ("HID output reference", struct.pack("<BB", 1, 2))                                 # HID reference: id=1, type=output.
         self.characteristics[h_proto] = ("HID protocol mode", b"\x01")                                                  # HID protocol mode: report.
 
-    # Overwrite super to notify central of a hid report.
+    # Overwrite super to notify client 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])
             self.characteristics[self.h_rep] = ("HID input report", state)
-            self._ble.gatts_notify(self.conn_handle, self.h_rep, state)                                                 # Notify central by writing to the report handle.
+            self._ble.gatts_notify(self.conn_handle, self.h_rep, state)                                                 # Notify client by writing to the report handle.
             print("Notify with report: ", struct.unpack("8B", state))
 
-    # Set the modifier bits, notify to send the modifiers to central.
+    # Set the modifier bits, notify to send the modifiers to client.
     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.
+    # Press keys, notify to send the keys to client.
     # 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]
diff --git a/readme.md b/readme.md
@@ -145,7 +145,7 @@ The library consists of five classes with the following functions:
   * `start_advertising()` (Starts Bluetooth advertisement)
   * `stop_advertising()` (Stops Bluetooth advertisement)
   * `is_running()` (Returns `True` if services are running, otherwise `False`)
-  * `is_connected()` (Returns `True` if a central is connected, otherwise `False`)
+  * `is_connected()` (Returns `True` if a client is connected, otherwise `False`)
   * `is_advertising()` (Returns `True` if advertising, otherwise `False`)
   * `set_state(state)` (Sets one of the `HumanInterfaceDevice` constants `DEVICE_STOPPED`, `DEVICE_IDLE`, `DEVICE_ADVERTISING`, or `DEVICE_CONNECTED`. Doesn't change the actual function. Used internally)
   * `get_state()` (Returns one of the `HumanInterfaceDevice` constants `DEVICE_STOPPED`, `DEVICE_IDLE`, `DEVICE_ADVERTISING`, or `DEVICE_CONNECTED`)
@@ -164,22 +164,22 @@ The library consists of five classes with the following functions:
   * `set_passkey(passkey)` (Set the passkey to use for pairing)
   * `set_keystore(keystore)` (Sets the key store to use from `hid_keystores.py`. Default `JSONKeyStore`)
   * `set_battery_level(level)` (Sets the battery level internally)
-  * `notify_battery_level()` (Notifies the central of the current battery level. Call after setting battery level)
+  * `notify_battery_level()` (Notifies the client of the current battery level. Call after setting battery level)
   * `notify_hid_report()` (Function for subclasses to override)
 
 * `Joystick` (subclass of `HumanInterfaceDevice`, implements joystick service)
   * `__init__(name)` (Initialize the joystick)
   * `start()` (Starts the HID service using joystick characteristics. Calls `HumanInterfaceDevice.start()`)
   * `write_service_characteristics(handles)` (Writes the joystick HID service characteristics. Calls `HumanInterfaceDevice.write_service_characteristics(handles)`)
-  * `notify_hid_report()` (Notifies the central of the internal HID joystick status)
+  * `notify_hid_report()` (Notifies the client of the internal HID joystick status)
   * `set_axes(x, y)` (Sets the joystick axes internally)
   * `set_buttons(b1, b2, b3, b4, b5, b6, b7, b8)` (Sets the joystick buttons internally)
 
 * `Mouse` (subclass of `HumanInterfaceDevice`, implements mouse service)
   * `__init__(name)` (Initialize the mouse)
   * `start()` (Starts the HID service using mouse characteristics. Calls `HumanInterfaceDevice.start()`)
   * `write_service_characteristics(handles)` (Writes the mouse HID service characteristics.  Calls `HumanInterfaceDevice.write_service_characteristics(handles)`)
-  * `notify_hid_report()` (Notifies the central of the internal HID mouse status)
+  * `notify_hid_report()` (Notifies the client of the internal HID mouse status)
   * `set_axes(x, y)` (Sets the mouse axes movement internally)
   * `set_wheel(w)` (Sets the mouse wheel movement internally)
   * `set_buttons(b1, b2, b3)` (Sets the mouse buttons internally)
@@ -188,7 +188,7 @@ The library consists of five classes with the following functions:
   * `__init__(name)`  (Initialize the keyboard)
   * `start()` (Starts the HID service using keyboard characteristics. Calls `HumanInterfaceDevice.start()`)
   * `write_service_characteristics(handles)` (Writes the keyboard HID service characteristics.  Calls `HumanInterfaceDevice.write_service_characteristics(handles)`)
-  * `notify_hid_report()` (Notifies the central of the internal HID keyboard status)
+  * `notify_hid_report()` (Notifies the client of the internal HID keyboard status)
   * `set_modifiers(right_gui, right_alt, right_shift, right_control, left_gui, left_alt, left_shift, left_control)` (Sets the keyboard modifier keys internally)
   * `set_keys(k0, k1, k2, k3, k4, k5)` (Sets a list of key codes to press internally. Call without keys to release.)
   * `ble_irq(event, data)` (Internal callback function that catches BLE keyboard interrupt requests)
