wip

Author: Marc Hofmann

.vscode/launch.json

@@ -9,7 +9,7 @@
       "type": "debugpy",
       "request": "launch",
       "program": "__main__.py",
-      // "module": "examples.dyscom.example_dyscom_get",
+      // "module": "examples.dyscom.example_dyscom_write_csv",
       "justMyCode": false,
       // "args": ["COM3"],
       "console": "integratedTerminal"

__main__.py

@@ -1,12 +1,20 @@
 """Test program how to use library without installing the library,
 DO NOT USE THIS FILE, USE EXAMPLES INSTEAD"""
 
+from timeit import default_timer as timer
+
 import logging
 import sys
 import asyncio
 
 from science_mode_4.device_i24 import DeviceI24
 from science_mode_4.device_p24 import DeviceP24
+from science_mode_4.dyscom.ads129x.ads129x_config_register_1 import Ads129xOutputDataRate, Ads129xPowerMode
+from science_mode_4.dyscom.dyscom_get_operation_mode import PacketDyscomGetAckOperationMode
+from science_mode_4.dyscom.dyscom_send_live_data import PacketDyscomSendLiveData
+from science_mode_4.dyscom.dyscom_types import DyscomFilterType, DyscomGetType, DyscomInitParams, DyscomPowerModulePowerType, DyscomPowerModuleType, DyscomSignalType
+from science_mode_4.protocol.commands import Commands
+from science_mode_4.protocol.types import ResultAndError
 from science_mode_4.utils import logger
 from science_mode_4.utils.serial_port_connection import SerialPortConnection
 from science_mode_4.utils.usb_connection import UsbConnection
@@ -16,12 +24,8 @@
 async def main() -> int:
     """Main function"""
 
-    # Serial
-    # 2025-04-22 15:38 - DEBUG - Outgoing data, length: 12, bytes: F0 81 55 81 59 81 4E 81 0C 04 3E 0F
-    # 2025-04-22 15:38 - DEBUG - Incoming data, length: 13, bytes: F0 81 55 81 58 81 D1 81 0A 04 43 00 0F
-    # USB
-    # 2025-04-22 15:45 - DEBUG - Outgoing data, length: 12, bytes: F0 81 55 81 59 81 4E 81 0C 04 3E 0F
-    # 2025-04-22 15:45 - DEBUG - Incoming data, length: 13, bytes: F0 81 55 81 58 81 D1 81 0A 04 43 00 0F
+    logger().disabled = True
+
     logger().setLevel(logging.DEBUG)
     # devices = SerialPortConnection.list_science_mode_device_ports()
     # connection = SerialPortConnection(devices[0].device)
@@ -32,10 +36,69 @@ async def main() -> int:
 
     device = DeviceI24(connection)
     await device.initialize()
-    general = device.get_layer_general()
-    print(f"Device id: {general.device_id}")
-    print(f"Firmware version: {general.firmware_version}")
-    print(f"Science mode version: {general.science_mode_version}")
+    # get dyscom layer to call dyscom level commands
+    dyscom = device.get_layer_dyscom()
+
+    # call enable measurement power module for measurement
+    await dyscom.power_module(DyscomPowerModuleType.MEASUREMENT, DyscomPowerModulePowerType.SWITCH_ON)
+    # call init with 4k sample rate and enable signal types
+    init_params = DyscomInitParams()
+    init_params.filter = DyscomFilterType.PREDEFINED_FILTER_2
+    init_params.signal_type = [DyscomSignalType.BI, DyscomSignalType.EMG_1,\
+                            DyscomSignalType.EMG_2, DyscomSignalType.BREATHING, DyscomSignalType.TEMPERATURE]
+    init_params.register_map_ads129x.config_register_1.output_data_rate = Ads129xOutputDataRate.HR_MODE_4_KSPS__LP_MODE_2_KSPS
+    init_params.register_map_ads129x.config_register_1.power_mode = Ads129xPowerMode.HIGH_RESOLUTION
+    await dyscom.init(init_params)
+
+    # start dyscom measurement
+    await dyscom.start()
+
+    start_time = timer()
+    total_count = 0
+
+    # loop for some time
+    for x in range(1000):
+        # check operation mode from time to time, this function is not waiting for response
+        # so we have to handle it by ourself later
+        if x % 100 == 0:
+            dyscom.send_get_operation_mode()
+
+        live_data_counter = 0
+        while True:
+            # process all available packages
+            ack = dyscom.packet_buffer.get_packet_from_buffer(live_data_counter == 0)
+            if ack:
+                # because there are multiple get commands, we need to additionally check kind,
+                # which is always associated DyscomGetType
+                if ack.command == Commands.DL_GET_ACK and ack.kind == DyscomGetType.OPERATION_MODE:
+                    om_ack: PacketDyscomGetAckOperationMode = ack
+                    print(f"Operation mode {om_ack.operation_mode.name}")
+                    # check if measurement is still active
+                    if om_ack.result_error != ResultAndError.NO_ERROR:
+                        break
+                elif ack.command == Commands.DL_SEND_LIVE_DATA:
+                    live_data_counter += 1
+                    total_count += 1
+
+                    sld: PacketDyscomSendLiveData = ack
+                    if sld.status_error:
+                        print(f"SendLiveData status error {sld.samples}")
+                        break
+
+            else:
+                # print(f"Live data acknowledges per iteration {live_data_counter}")
+                break
+
+        # await asyncio.sleep(0.01)
+
+    # print stats
+    end_time = timer()
+    print(f"Samples: {total_count}, duration: {end_time - start_time}, sample rate: {total_count / (end_time - start_time)}")
+
+    # stop measurement
+    await dyscom.stop()
+    # turn power module off
+    await dyscom.power_module(DyscomPowerModuleType.MEASUREMENT, DyscomPowerModulePowerType.SWITCH_OFF)
 
     connection.close()
 

pyproject.toml

@@ -20,7 +20,8 @@ license-files = [
   "LICENSE"
 ]
 dependencies = [
-  "pyserial >= 3.5",
+  "pyserial",
+  "pyusb"
 ]
 
 [project.urls]

src/science_mode_4/utils/usb_connection.py

@@ -32,6 +32,7 @@ def __init__(self, device: usb.core.Device):
         self._device = device
         self._out_endpoint: usb.core.Endpoint = None
         self._in_endpoint: usb.core.Endpoint = None
+        self._in_endpoint_buffer_size = 128 * 64
         self._is_open = False
 
 
@@ -40,16 +41,18 @@ def open(self):
         self._device.set_configuration()
         # get an endpoint instance
         cfg = self._device.get_active_configuration()
-        intf = cfg[(1,0)]
+        # Interface 0: CDC Communication
+        # Interface 1: CDC Data
+        interface: usb.core.Interface = cfg[(1,0)]
 
         # match the first OUT endpoint
         self._out_endpoint = usb.util.find_descriptor(
-            intf,
-            custom_match = lambda e: (print(e) or usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT))
+            interface,
+            custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_OUT)
         # match the first IN endpoint
         self._in_endpoint = usb.util.find_descriptor(
-            intf,
-            custom_match = lambda e: (print(e) or usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN))
+            interface,
+            custom_match = lambda e: usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN)
 
         self._is_open = True
 
@@ -68,8 +71,25 @@ def write(self, data: bytes):
 
 
     def clear_buffer(self):
-        pass
+        # there is no way to clear the buffer from in endpoint, so
+        # read all data and discard it
+        self._read_intern()
 
 
     def _read_intern(self) -> bytes:
-        return bytes(self._in_endpoint.read(self._in_endpoint.wMaxPacketSize))
+        data = bytes()
+        try:
+            while True:
+                # Read up to endpoint's max packet size (64 bytes in this case)
+                tmp = self._in_endpoint.read(self._in_endpoint_buffer_size)
+                data += bytes(tmp)
+                if len(tmp) < self._in_endpoint_buffer_size:
+                    break
+        except usb.core.USBError as e:
+            if e.errno == 10060:
+                # Timeout error (no data available)
+                pass
+            else:
+                raise
+
+        return data