kallistoapi 2.0.1__py3-none-any.whl

kallistoapi/__init__.py

@@ -0,0 +1 @@
+#kallistointegrationtest/support$ protoc --python_out=. kallistoapi/config.proto

kallistoapi/bluetooth_gatt.py

@@ -0,0 +1,199 @@
+import threading
+
+from bleak import BleakClient, BleakScanner
+import asyncio
+# from pydbus import SystemBus
+
+class BluetoothGatt:
+    def __init__(self):
+        self._client = None
+        self._mac = "none"
+
+        # bleak runs in async, we need to have a way to run the loop in parallel to pythons
+        # sync calls. so we let the loop run in a thread
+        self._bleak_loop_thread = None
+        self._bleak_client_loop = None
+        self._bleak_loop_thread_started = threading.Event()
+        self._start_bleak_loop_thread()
+
+        self.context = None
+        self.notify_dict = {}
+        self.service_handlers = {}
+
+        self.disconnect_handler = None
+
+    def connect(self, mac_address: str, disconnect_callback=None):
+    # if self.is_device_connected(mac_address):
+    #            print(f"Device {mac_address} is already connected")
+    #        return False
+
+        if self.is_connected():
+            if mac_address == self._mac:
+                return True
+            print(f"disconnecting from {self._mac}")
+            self.disconnect()
+
+        self._mac = mac_address
+
+        self.disconnect_handler = disconnect_callback
+        if not self._await_bleak_loop(self._connect(self._mac), 60):
+            self.disconnect_handler = None
+            print("connection timed out")
+            return False
+        self._discover_services()
+        return True
+
+    def disconnect(self):
+        return self._await_bleak_loop(self._disconnect())
+
+#    def is_device_connected(self, mac_address):
+#        dbus_path = "/org/bluez/hci0/dev_" + mac_address.replace(":", "_")
+#        bus = SystemBus()
+#        mngr = bus.get("org.bluez", "/")
+#        objects = mngr.GetManagedObjects()
+#        device = objects.get(dbus_path, {}).get("org.bluez.Device1")
+#        return device.get("Connected", False) if device else False
+#
+    def scan_for_devices(self):
+        return self._await_bleak_loop(self._scan_for_devices())
+
+    def detect_services(self):
+        return self._await_bleak_loop(self._detect_services())
+
+    def read_gatt_characteristics(self, characteristic_uuid):
+        return self._await_bleak_loop(self._read_gatt_characteristics(characteristic_uuid))
+
+    def get_service(self, characteristic_uuid):
+        return self._client.services.get_service(characteristic_uuid)
+
+    def start_gatt_notify(self, characteristic_uuid, notify_cb):
+        return self._await_bleak_loop(self._start_gatt_notify(characteristic_uuid, notify_cb))
+
+    def stop_gatt_notify(self, characteristic_uuid):
+        return self._await_bleak_loop(self._stop_gatt_notify(characteristic_uuid))
+
+    def write_gatt_characteristics(self, characteristic_uuid, data):
+        return self._await_bleak_loop(self._write_gatt_characteristics(characteristic_uuid, data))
+
+    def get_mac_address(self):
+        return self._mac
+
+    def is_connected(self):
+        if self._client is None:
+            return False
+        return self._client.is_connected
+
+    def get_uuid_from_handle(self, handle):
+        if handle in self.service_handlers:
+            return self.service_handlers[handle]
+        else:
+            return None
+
+    ###############################
+    # internal functions
+    def _discover_services(self):
+        for service in self._client.services:
+            for characteristic in service.characteristics:
+                self.service_handlers[characteristic.handle] = characteristic.uuid
+
+    ###############################
+    # async functions
+
+    def _start_bleak_loop_thread(self):
+        self._bleak_thread = threading.Thread(target=self._run_bleak_loop_thread)
+        self._bleak_thread.daemon = True
+        self._bleak_thread.start()
+        # finally wait for the thread to have properly started
+        self._bleak_loop_thread_started.wait()
+
+    def _run_bleak_loop_thread(self):
+        self._bleak_client_loop = asyncio.new_event_loop()
+        self._bleak_loop_thread_started.set()
+        self._bleak_client_loop.run_forever()
+
+    def _await_bleak_loop(self, coro, timeout=10):
+        future = asyncio.run_coroutine_threadsafe(coro, self._bleak_client_loop)
+        try:
+            return future.result(timeout)
+        except asyncio.TimeoutError:
+            print("Timeout waiting for bluetooth operation")
+            return False
+
+    async def _connect(self, mac_address):
+        self._client = BleakClient(mac_address, disconnected_callback=self._disconnect_handler)
+        if self._client is None:
+            print(f"Failed to create client for {mac_address}")
+            return False
+        try:
+            await self._client.connect()
+        except Exception as e:
+            print(f"Failed to connect to {mac_address}: {e}")
+            return False
+        if self._client.is_connected:
+            print(f"Connected to {mac_address}")
+            self._mac = mac_address
+            return True
+        else:
+            self._mac = "none"
+            print(f"Failed to connect to {mac_address}")
+            return False
+
+    async def _disconnect(self):
+        if self._client:
+            await self._client.disconnect()
+            print(f"Disconnected successfully")
+        else:
+            print("No device to disconnect")
+
+    def _disconnect_handler(self, client):
+        print(f"Device disconnected: {self._mac}")
+        if self.disconnect_handler is not None:
+            self.disconnect_handler()
+        return
+
+    @staticmethod
+    async def _scan_for_devices():
+        devices = await BleakScanner.discover(timeout=3.0)
+#        for device in devices:
+#            print(f"Device found: {device.name} ({device.address})")
+        return devices
+
+    async def _detect_services(self):
+        if not self.is_connected():
+            print("Not connected")
+            return {}
+
+        # This implicitly fetches services
+        services = self._client.services
+
+        s = {}
+        for service in services:
+            s[service.uuid] = {}
+            for char in service.characteristics:
+                s[service.uuid][char.uuid] = {
+                    "uuid": char.uuid,
+                    "description": char.description,
+                    "properties": char.properties,
+                }
+        return s
+
+    # characteristics
+    async def _read_gatt_characteristics(self, characteristic_uuid):
+        return await self._client.read_gatt_char(characteristic_uuid)
+
+    async def _write_gatt_characteristics(self, characteristic_uuid, data):
+        return await self._client.write_gatt_char(characteristic_uuid, data)
+
+    async def _get_mtu(self):
+        return await self._client._acquire_mtu()
+
+    # notification
+    def _notify_callback(self, sender, data):
+        print(f"{sender}: {data}")
+        self.context.notify_dict.update({"uuid": data})
+
+    async def _start_gatt_notify(self, characteristic_uuid, notify_cb):
+        return await self._client.start_notify(characteristic_uuid, notify_cb)
+
+    async def _stop_gatt_notify(self, characteristic_uuid):
+        return await self._client.stop_notify(characteristic_uuid)

kallistoapi/config_pb2.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: kallistoapi/config.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x18kallistoapi/config.proto\x12\rsensry.api.v1\"m\n GlobalConfigEnabledFeaturesClass\"I\n\x04Type\x12\x0f\n\x0b\x62\x65\x61\x63on_mode\x10\x00\x12\x13\n\x0fradio_time_sync\x10\x01\x12\x1b\n\x17vibration_approximation\x10\x02\"G\n\x0bUIModeClass\"8\n\x04Type\x12\x08\n\x04none\x10\x00\x12\x0c\n\x08periodic\x10\x01\x12\x0b\n\x07sw_sync\x10\x02\x12\x0b\n\x07hw_sync\x10\x03\"K\n\x19TransformationMethodClass\".\n\x04Type\x12\x08\n\x04mean\x10\x00\x12\n\n\x06median\x10\x01\x12\x07\n\x03max\x10\x02\x12\x07\n\x03min\x10\x03\"g\n\rTimesyncClass\"!\n\rTimestampType\x12\x07\n\x03tai\x10\x00\x12\x07\n\x03utc\x10\x01\"3\n\x11InterpolationMode\x12\x08\n\x04none\x10\x00\x12\t\n\x05liner\x10\x01\x12\t\n\x05\x63ubic\x10\x02\"g\n\x0e\x45xtensionClass\"U\n\tBoardType\x12\x08\n\x04none\x10\x00\x12\n\n\x06hf_gas\x10\x01\x12\x0f\n\x0bmicrostrain\x10\x02\x12\x0f\n\x0btemperature\x10\x03\x12\x10\n\x0cthermocouple\x10\x04\"\x9a\x03\n\x06\x43onfig\x12\x31\n\tmeta_info\x18\xff\x01 \x01(\x0b\x32\x1d.sensry.api.v1.ConfigMetaInfo\x12\x38\n\x13global_config_label\x18\x02 \x01(\x0b\x32\x1b.sensry.api.v1.GlobalConfig\x12\x32\n\rsensor_config\x18\x03 \x01(\x0b\x32\x1b.sensry.api.v1.SensorConfig\x12\x42\n\x15transformation_config\x18\x04 \x01(\x0b\x32#.sensry.api.v1.TransformationConfig\x12\x38\n\x10\x65xtension_config\x18\x05 \x01(\x0b\x32\x1e.sensry.api.v1.ExtensionConfig\x12\x36\n\x0ftimesync_config\x18\x06 \x01(\x0b\x32\x1d.sensry.api.v1.TimesyncConfig\x12\x39\n\x11ui_manager_config\x18\x07 \x01(\x0b\x32\x1e.sensry.api.v1.UIManagerConfig\"=\n\x0e\x43onfigMetaInfo\x12\x16\n\x0e\x63onfig_version\x18\x01 \x02(\r\x12\x13\n\nconfig_crc\x18\xff\x01 \x02(\r\"@\n\x0fUIManagerConfig\x12-\n\x04mode\x18\x01 \x02(\x0e\x32\x1f.sensry.api.v1.UIModeClass.Type\"\x86\x01\n\x0cGlobalConfig\x12\x13\n\x0b\x64\x65vice_name\x18\x01 \x01(\t\x12\x11\n\tlog_level\x18\x02 \x01(\x05\x12N\n\x10\x65nabled_features\x18\x03 \x03(\x0e\x32\x34.sensry.api.v1.GlobalConfigEnabledFeaturesClass.Type\"\xbd\x01\n\x0eTimesyncConfig\x12\x1b\n\x13prolongation_offset\x18\x01 \x02(\x05\x12\x42\n\x0etimestamp_type\x18\x02 \x02(\x0e\x32*.sensry.api.v1.TimesyncClass.TimestampType\x12J\n\x12interpolation_mode\x18\x03 \x02(\x0e\x32..sensry.api.v1.TimesyncClass.InterpolationMode\"\xcc\x02\n\x0cSensorConfig\x12/\n\x08\x64\x65\x66\x61ults\x18\x01 \x01(\x0b\x32\x1d.sensry.api.v1.SensorDefaults\x12\x31\n\tvibration\x18\x02 \x01(\x0b\x32\x1e.sensry.api.v1.VibrationConfig\x12\x35\n\x0btemperature\x18\x03 \x01(\x0b\x32 .sensry.api.v1.TemperatureConfig\x12\x36\n\x0bmicrostrain\x18\x04 \x01(\x0b\x32!.sensry.api.v1.ADCExtentionConfig\x12\x30\n\x05pt100\x18\x05 \x01(\x0b\x32!.sensry.api.v1.ADCExtentionConfig\x12\x37\n\x0cthermocouple\x18\x06 \x01(\x0b\x32!.sensry.api.v1.ADCExtentionConfig\"5\n\x0eSensorDefaults\x12\x15\n\rsampling_rate\x18\x01 \x02(\x05\x12\x0c\n\x04unit\x18\x02 \x02(\t\"$\n\x0fVibrationConfig\x12\x11\n\tthreshold\x18\x01 \x02(\x02\"R\n\x11TemperatureConfig\x12\x15\n\rsampling_rate\x18\x01 \x01(\x05\x12\x0c\n\x04unit\x18\x02 \x01(\t\x12\x18\n\x10\x63\x61libration_mode\x18\x03 \x01(\r\"{\n\x14TransformationConfig\x12\r\n\x05scale\x18\x01 \x02(\x02\x12\x0e\n\x06offset\x18\x02 \x01(\x02\x12\x0f\n\x07\x66ilters\x18\x03 \x03(\t\x12\x33\n\x06\x63ustom\x18\x04 \x01(\x0b\x32#.sensry.api.v1.TransformationCustom\"j\n\x14TransformationCustom\x12\x13\n\x0bwindow_size\x18\x01 \x02(\x05\x12=\n\x06method\x18\x02 \x02(\x0e\x32-.sensry.api.v1.TransformationMethodClass.Type\"X\n\x0f\x45xtensionConfig\x12\x45\n\x14\x65xtension_board_type\x18\x01 \x02(\x0e\x32\'.sensry.api.v1.ExtensionClass.BoardType\"\xf3\x01\n\x0f\x41\x64\x63\x44riverConfig\x12\x1a\n\x12samples_per_second\x18\x01 \x01(\r\x12\r\n\x05v_ref\x18\x02 \x01(\r\x12\x18\n\x10\x63ontiniouse_mode\x18\x03 \x01(\r\x12\x10\n\x08\x61\x64\x63_gain\x18\x04 \x01(\r\x12\x10\n\x08meas_cur\x18\x05 \x01(\r\x12\x17\n\x0fmeas_cur_output\x18\x06 \x01(\r\x12\x14\n\x0c\x64ifferential\x18\x07 \x01(\r\x12\x10\n\x08idac1_ch\x18\x08 \x01(\r\x12\x10\n\x08idac2_ch\x18\t \x01(\r\x12\x11\n\tinput_pos\x18\n \x01(\r\x12\x11\n\tinput_neg\x18\x0b \x01(\r\"H\n\x11\x41\x44\x43SensorWireMode\"3\n\x04Type\x12\x0c\n\x08two_wire\x10\x00\x12\x0e\n\nthree_wire\x10\x01\x12\r\n\tfour_wire\x10\x02\"\x9a\x02\n\x13\x41\x44\x43SensorItemConfig\x12\x15\n\rover_sampling\x18\x02 \x01(\r\x12 \n\x18oversampling_interval_us\x18\x03 \x01(\r\x12\x12\n\nresolution\x18\x04 \x01(\r\x12\r\n\x05r_ref\x18\x05 \x01(\x02\x12\x0e\n\x06offset\x18\x06 \x01(\x02\x12\x18\n\x10\x61\x64\x63_quantization\x18\x07 \x01(\x02\x12\x0f\n\x07lp_coof\x18\x08 \x01(\x02\x12\x38\n\twire_mode\x18\t \x01(\x0e\x32%.sensry.api.v1.ADCSensorWireMode.Type\x12\x32\n\nadc_config\x18\n \x03(\x0b\x32\x1e.sensry.api.v1.AdcDriverConfig\"s\n\x12\x41\x44\x43\x45xtentionConfig\x12\x16\n\x0e\x65nable_sensors\x18\x01 \x01(\r\x12\x11\n\tperiod_us\x18\x02 \x01(\r\x12\x32\n\x06\x63onfig\x18\x03 \x03(\x0b\x32\".sensry.api.v1.ADCSensorItemConfig')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'kallistoapi.config_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _GLOBALCONFIGENABLEDFEATURESCLASS._serialized_start=43
+  _GLOBALCONFIGENABLEDFEATURESCLASS._serialized_end=152
+  _GLOBALCONFIGENABLEDFEATURESCLASS_TYPE._serialized_start=79
+  _GLOBALCONFIGENABLEDFEATURESCLASS_TYPE._serialized_end=152
+  _UIMODECLASS._serialized_start=154
+  _UIMODECLASS._serialized_end=225
+  _UIMODECLASS_TYPE._serialized_start=169
+  _UIMODECLASS_TYPE._serialized_end=225
+  _TRANSFORMATIONMETHODCLASS._serialized_start=227
+  _TRANSFORMATIONMETHODCLASS._serialized_end=302
+  _TRANSFORMATIONMETHODCLASS_TYPE._serialized_start=256
+  _TRANSFORMATIONMETHODCLASS_TYPE._serialized_end=302
+  _TIMESYNCCLASS._serialized_start=304
+  _TIMESYNCCLASS._serialized_end=407
+  _TIMESYNCCLASS_TIMESTAMPTYPE._serialized_start=321
+  _TIMESYNCCLASS_TIMESTAMPTYPE._serialized_end=354
+  _TIMESYNCCLASS_INTERPOLATIONMODE._serialized_start=356
+  _TIMESYNCCLASS_INTERPOLATIONMODE._serialized_end=407
+  _EXTENSIONCLASS._serialized_start=409
+  _EXTENSIONCLASS._serialized_end=512
+  _EXTENSIONCLASS_BOARDTYPE._serialized_start=427
+  _EXTENSIONCLASS_BOARDTYPE._serialized_end=512
+  _CONFIG._serialized_start=515
+  _CONFIG._serialized_end=925
+  _CONFIGMETAINFO._serialized_start=927
+  _CONFIGMETAINFO._serialized_end=988
+  _UIMANAGERCONFIG._serialized_start=990
+  _UIMANAGERCONFIG._serialized_end=1054
+  _GLOBALCONFIG._serialized_start=1057
+  _GLOBALCONFIG._serialized_end=1191
+  _TIMESYNCCONFIG._serialized_start=1194
+  _TIMESYNCCONFIG._serialized_end=1383
+  _SENSORCONFIG._serialized_start=1386
+  _SENSORCONFIG._serialized_end=1718
+  _SENSORDEFAULTS._serialized_start=1720
+  _SENSORDEFAULTS._serialized_end=1773
+  _VIBRATIONCONFIG._serialized_start=1775
+  _VIBRATIONCONFIG._serialized_end=1811
+  _TEMPERATURECONFIG._serialized_start=1813
+  _TEMPERATURECONFIG._serialized_end=1895
+  _TRANSFORMATIONCONFIG._serialized_start=1897
+  _TRANSFORMATIONCONFIG._serialized_end=2020
+  _TRANSFORMATIONCUSTOM._serialized_start=2022
+  _TRANSFORMATIONCUSTOM._serialized_end=2128
+  _EXTENSIONCONFIG._serialized_start=2130
+  _EXTENSIONCONFIG._serialized_end=2218
+  _ADCDRIVERCONFIG._serialized_start=2221
+  _ADCDRIVERCONFIG._serialized_end=2464
+  _ADCSENSORWIREMODE._serialized_start=2466
+  _ADCSENSORWIREMODE._serialized_end=2538
+  _ADCSENSORWIREMODE_TYPE._serialized_start=2487
+  _ADCSENSORWIREMODE_TYPE._serialized_end=2538
+  _ADCSENSORITEMCONFIG._serialized_start=2541
+  _ADCSENSORITEMCONFIG._serialized_end=2823
+  _ADCEXTENTIONCONFIG._serialized_start=2825
+  _ADCEXTENTIONCONFIG._serialized_end=2940
+# @@protoc_insertion_point(module_scope)

kallistoapi/kallisto_battery_service.py

@@ -0,0 +1,168 @@
+import struct
+import json
+
+import struct
+import json
+from datetime import datetime, timezone
+
+class BatteryConfig:
+    def __init__(self, command, mode=None, value=None):
+        """
+        :param command: 0x01 = shutdown, 0x02 = reboot
+        :param mode: 0x01 = offset (value is int), 0x02 = absolute time (value is datetime)
+        :param value: int (for offset), or datetime (for absolute time)
+        """
+        self.command = command
+        self.mode = mode
+
+        if self.mode == 0x02 and isinstance(value, datetime):
+            # Convert to UTC before encoding
+            utc_dt = value.astimezone(timezone.utc)
+            self.value = self._datetime_to_cts_bytes(utc_dt)
+        else:
+            self.value = value
+
+    def _datetime_to_cts_bytes(self, dt: datetime) -> bytes:
+        year = dt.year
+        month = dt.month
+        day = dt.day
+        hour = dt.hour
+        minute = dt.minute
+        second = dt.second
+        day_of_week = dt.isoweekday()  # Monday = 1, Sunday = 7
+        fractions256 = 0
+        adjust_reason = 0
+
+        return struct.pack('<HBBBBBB2B',
+                           year,
+                           month,
+                           day,
+                           hour,
+                           minute,
+                           second,
+                           day_of_week,
+                           fractions256,
+                           adjust_reason)
+
+    def to_bytes(self):
+        result = bytearray()
+        result.append(self.command)
+
+        if self.mode is not None:
+            result.append(self.mode)
+
+            if self.mode == 0x01 and isinstance(self.value, int):
+                result += struct.pack('<I', self.value)
+            elif self.mode == 0x02 and isinstance(self.value, (bytes, bytearray)) and len(self.value) == 10:
+                result += self.value
+            else:
+                raise ValueError("Invalid value format for the given mode")
+
+        return bytes(result)
+
+    @staticmethod
+    def from_bytes(data):
+        if len(data) < 1:
+            raise ValueError("Data too short")
+
+        command = data[0]
+
+        if len(data) == 1:
+            return BatteryConfig(command)
+
+        mode = data[1]
+
+        if mode == 0x01 and len(data) >= 6:
+            value = struct.unpack('<I', data[2:6])[0]
+        elif mode == 0x02 and len(data) >= 12:
+            value = data[2:12]  # leave as raw bytes
+        else:
+            raise ValueError("Invalid or incomplete data for the specified mode")
+
+        return BatteryConfig(command, mode, value)
+
+    def to_dict(self):
+        data = {
+            'command': self.command,
+            'mode': self.mode
+        }
+
+        if self.mode == 0x01:
+            data['value'] = self.value
+        elif self.mode == 0x02:
+            data['value'] = list(self.value) if self.value else None
+
+        return data
+
+    @staticmethod
+    def from_dict(data):
+        value = data.get('value')
+        if isinstance(value, list):  # CTS bytes in list form
+            value = bytes(value)
+        return BatteryConfig(data['command'], data.get('mode'), value)
+
+    def save_to_json(self, filepath):
+        with open(filepath, 'w') as f:
+            json.dump(self.to_dict(), f, indent=4)
+
+    @staticmethod
+    def load_from_json(filepath):
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+        return BatteryConfig.from_dict(data)
+
+
+
+class BatteryHandler:
+    def serialize(self, config):
+        """Serializes a MicrostrainConfig object to bytes."""
+        return config.to_bytes()
+
+    def deserialize(self, data):
+        """Deserializes bytes to a MicrostrainConfig object."""
+        return BatteryConfig.from_bytes(data)
+
+    def set_battery_config(self, json_filepath):
+        """
+        Loads configuration from a JSON file, serializes it to bytes,
+        and returns the serialized configuration.
+        """
+        config = BatteryConfig.load_from_json(json_filepath)
+        serialized_config = config.to_bytes()
+
+        print(f"Microstrain config with serialized value {serialized_config.hex()}")
+        return serialized_config
+
+    def get_battery_config(self, data):
+        """
+        Deserializes binary data to a MicrostrainConfig object
+        and converts it to a dictionary.
+        """
+        config = BatteryConfig.from_bytes(data)
+        return config.to_dict()
+
+    def unpack_battery_samples(self, buffers: list[bytes]):
+        return buffers
+
+if __name__ == "__main__":
+    from datetime import datetime, timedelta
+    # Schedule shutdown untill tomorrow 08:30
+    future_time = datetime.now().replace(hour=8, minute=30, second=0, microsecond=0) + timedelta(days=1)
+
+    config = BatteryConfig(command=0x01, mode=0x02, value=future_time)
+    payload = config.to_bytes()
+
+    print(payload.hex())  # Output binary payload in hex format
+
+    handler = BatteryHandler()
+    # Serialize and Deserialize to Bytes
+    serialized = handler.serialize(config)
+    print("Serialized:", serialized)
+
+    deserialized = handler.deserialize(serialized)
+    print("Deserialized:", deserialized.__dict__)
+
+    # Save to JSON and Load from JSON
+    config.save_to_json("battery_config.json")
+    loaded_config = BatteryConfig.load_from_json("battery_config.json")
+    print("Loaded from JSON:", loaded_config.__dict__)

kallistoapi/kallisto_helper.py

@@ -0,0 +1,57 @@
+
+def get_conf_uuid(name):
+    uuid_map = {
+        "log_global_conf": "00002021-702b-69b5-b243-d6094a2b0e24",
+        "log_start_cond": "00002022-702b-69b5-b243-d6094a2b0e24",
+        "log_mem_ctrl": "00002024-702b-69b5-b243-d6094a2b0e24",
+        "log_mem_stat": "00002025-702b-69b5-b243-d6094a2b0e24",
+        "log_temp_dump": "00002101-702b-69b5-b243-d6094a2b0e24",
+        "log_temp_conf": "00002104-702b-69b5-b243-d6094a2b0e24",
+        "log_vibration_dump": "00002111-702b-69b5-b243-d6094a2b0e24",
+        "log_vibration_conf": "00002114-702b-69b5-b243-d6094a2b0e24",
+        "vibration_conf": "00001022-702b-69b5-b243-d6094a2b0e24"
+    }
+    if name not in uuid_map:
+        raise Exception("unknown requested UUID")
+
+    return uuid_map[name]
+
+
+def get_compare_value(name):
+    uuid_map = {
+        "log_global_disable": bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+        "log_global_enable": bytearray([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+        "log_vibration_disable": bytearray([0x00]),
+        "log_vibration_enable": bytearray([0x01]),
+        "log_vibration_dump": bytearray([0x02]),
+        "log_manual_trigger": bytearray([0x00]),
+        "log_timestamp_trigger": bytearray([0x01, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, ]),
+
+    }
+    if name not in uuid_map:
+        raise Exception("unknown requested UUID")
+
+    return uuid_map[name]
+
+
+def log_dumping_callback(sender, data):
+    print(f"{sender}: {data}")
+
+
+def log_vibration_callback(context, sender, data):
+    print(f"{sender}: {data}")
+    context.vibration_dump = data
+
+def kallisto_connect(context, mac_address):
+    if mac_address == "default":
+        mac_address = context.default_mac
+
+    if context.ble_manager.connect(mac_address):
+        return True
+    context.ble_manager.scan_for_devices()
+
+    if context.ble_manager.connect(mac_address):
+        return True
+
+    print(f"failed again to connect device {mac_address}")
+    return False