-testing

2023-06-14 12:08:04 +08:00
8 changed files with 91 additions and 134 deletions
@@ -163,14 +163,12 @@ def is_headstage_device(info: cc2650.GapEvt_DeviceInformation) -> Optional[Devic
                                           version_info[3],
                                           version_info[4],
                                           version_info[5])
-
        return DeviceResponseInfo(local_name.decode(), serial_number, info.address, battery=battery_percentage)

    elif company_code[:2] == b'HS':
        # legacy device

        serial_number = DeviceSerialNumber(0, 0, 0, 0, 0, 0)
-
        return DeviceResponseInfo(local_name.decode(), serial_number, info.address)

    else:
@@ -200,7 +198,7 @@ def is_headstage_device_central_version(device_mac: ADDRESS = EMPTY_ADDRESS,
                                           version_info[3],
                                           version_info[4],
                                           version_info[5])
-
+        print('***********', version_info, device_mac)
        return DeviceResponseInfo(local_name,
                                  serial_number,
                                  device_mac,
@@ -483,19 +481,17 @@ class CC2650Device(Device):
                day = struct.unpack('<B', data[4:5])[0]
                hour = struct.unpack('<B', data[5:6])[0]
                minute = struct.unpack('<B', data[6:7])[0]
-                # mac1 = struct.unpack('<B', data[7:8])[0]
-                # mac2 = struct.unpack('<B', data[8:9])[0]
-                # mac1 = "%02X" % mac1
-                # mac2 = "%02X" % mac2
+                mac1 = struct.unpack('<B', data[7:8])[0]
+                mac2 = struct.unpack('<B', data[8:9])[0]
+                mac1 = "%02X" % mac1
+                mac2 = "%02X" % mac2

                self._device_version = str(year) + '/' + str(month) + '/' + str(day) + " " + str(hour) + ":" + str(
-                    minute)
-                    #  + " | " + str(mac1) + ":" + str(mac2)
+                    minute) + " | " + str(mac1) + ":" + str(mac2)

    @property
    def battery(self) -> int:
-        if self._start_flag == False:
-            self.update_battery_info()
+        self.update_battery_info()
        return self._battery

    @property
@@ -2149,7 +2145,6 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
        connected = False
        connect_response = None
        ins = bytearray()
-
        ins.append(0x05)
        ins.append(0x08) #length
        ins.append(addr_type)
@@ -2161,7 +2156,6 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
        ins.append(address[5])
        ins.append(0xF1)
        self._interface.flush_input()
-
        for retry in range(5):
            try:
                self.log_verbose('[CC2650]', 'connect att_write', '0x'+str.upper(ins.hex()))
@@ -2175,7 +2169,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
                try:
                    connect_response = self._cc2650.recv_uart(2)
                except RecvTimeout:
-                    # self.log_verbose('[CC2650]', 'connect response timeout')
+                    self.log_verbose('[CC2650]', 'connect response timeout')
                    if retry < 5:
                        self.log_verbose('[CC2650]', 'connect retry')
                        continue
@@ -2183,23 +2177,15 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
                    break

        if connect_response is None:
-            self.log_verbose('[CC2650]', 'connect response timeout')
            return False
-
        pack_len = connect_response[0]
        connect_ack = connect_response[1:pack_len+1]
-        if pack_len == 1:
-            if connect_ack[0] == 3:
-                connected = True
-                connect_response_hex = ''.join(format(i, '02X') for i in connect_response)
-                self.log_verbose('[CC2650]', 'connect success', '0x'+connect_response_hex)

-        elif pack_len == 4:
-            if connect_ack[0] == 46 and connect_ack[1] == 80 and \
-            connect_ack[2] == 48 and connect_ack[3] == 4:
-                connected = True
-                connect_response_hex = ''.join(format(i, '02X') for i in connect_response)
-                self.log_verbose('[CC2650]', 'connect success', '0x'+connect_response_hex)
+        if connect_ack[0] == 46 and connect_ack[1] == 80 and \
+           connect_ack[2] == 48 and connect_ack[3] == 4:
+            connected = True
+            connect_response_hex = ''.join(format(i, '02X') for i in connect_response)
+            self.log_verbose('[CC2650]', 'connect success', '0x'+connect_response_hex)

        if connected == True:
            # CC2650Device(device_id, master, scan_response) is a slave device
@@ -2209,8 +2195,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
            self.log_verbose('[CC2650]', DEVICE_CONNECTED, address_s)
            return ret

-        connect_response_hex = ''.join(format(i, '02X') for i in connect_response)
-        self.log_verbose('[CC2650]', 'connect fail', '0x'+connect_response_hex)
+        self.log_verbose('[CC2650]', 'connect fail')
        return False

    @synchronized
@@ -2222,7 +2207,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
        ins.append(0xF1)
        self._interface.flush_input()

-        for retry in range(5): 
+        for _ in range(5): 
            try:
                self.log_verbose('[CC2650]', 'disconnect att_write','0x'+str.upper(ins.hex()))
                self._cc2650.send("bytes", bytes(ins))
@@ -2236,30 +2221,6 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
                self.reset_hardware()
                self.log_verbose('[CC2650]', 'disconnect success')
                return True
-        #         try:
-        #             disconnect_response = self._cc2650.recv_uart(0.01)
-        #             print(disconnect_response)
-
-        #         except RecvTimeout:
-        #             self.log_verbose('[CC2650]', 'disconnect response timeout')
-        #             if retry < 5:
-        #                 self.log_verbose('[CC2650]', 'connect retry')
-        #                 continue
-        #         else:
-        #             break
-        
-        # if disconnect_response is None:
-        #     return False
-
-        # pack_len = disconnect_response[0]
-        # disconnect_ack = disconnect_response[1:pack_len+1]
-
-        # if disconnect_ack == [3]:
-        #     disconnect_response_hex = ''.join(format(i, '02X') for i in disconnect_response)
-        #     self.log_verbose('[CC2650]', 'disconnect success', '0x'+disconnect_response_hex)
-        #     self.reset_internal()
-        #     self.reset_hardware()
-        #     return True

        self.log_verbose('[CC2650]', 'disconnect fail')
        return False
@@ -2292,7 +2253,6 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
                self.log_verbose('[CC2650]', 'write_characteristic response timeout')

        if write_response is None:
-            self.log_verbose('[CC2650]', 'write_characteristic fail')
            return False
                
        pack_len = write_response[0]
@@ -2609,15 +2569,15 @@ class CC2650MultiMasterCentralDevice(CC2650MasterDevice, Synchronized):

        return ret

-    def connect(self, response: DeviceResponseInfo, direct_connect: bool = False) -> Device:
+    def connect(self, response: DeviceResponseInfo, direct_connect: bool = True) -> Device:
        self.log_verbose('connect')

        master = None
-
+        print('self._foreach_empty_master()', self._foreach_empty_master())
        for master in self._foreach_empty_master():
            m = self._cc2650[master]
            d = self._device[master]
-
+            print('master', master, d, m)
            if direct_connect is True and d is None:
                break

@@ -2628,22 +2588,27 @@ class CC2650MultiMasterCentralDevice(CC2650MasterDevice, Synchronized):
            if master is None:
                raise RuntimeError('cannot connect any more device')
            else:
+                print('456')
                raise RuntimeError('rescan please')

        #
+        master = 4
        self.log_verbose('use', master)
        m = self._cc2650[master]
        d = self._device[master]
+        print('4')

        if d is not None:
            raise RuntimeError('cc2650 has connected a device')

        with self:
+            print('5')
            self._interface.flush()
            self._selector.select(master)

            sleep(0.0001)
            d = m.connect(response, direct_connect)
+            print('6')

            if d is None:
                raise RuntimeError('connect failed, retry please')
@@ -683,12 +683,12 @@ class DeviceManager(MasterDevice, Synchronized):
        address = address_str(response.mac_address)
        self.log_info(DEVICE_CONNECTING, address)

-        response = self.found_device(response)
+        # response = self.found_device(response)

-        ''' device not found'''
-        if response is None:
-            self.log_warn(DEVICE_CONNECT_FAIL, address, DEVICE_NOT_FOUND)
-            return None
+        # ''' device not found'''
+        # if response is None:
+        #     self.log_warn(DEVICE_CONNECT_FAIL, address, DEVICE_NOT_FOUND)
+        #     return None
            # raise RuntimeError(DEVICE_NOT_FOUND, address)

        # get device library
@@ -718,7 +718,9 @@ class DeviceManager(MasterDevice, Synchronized):
                                     serial_number=response.serial_number)
            else:
                try:
+                    print('here!!!!!!!!!!!!!!!!!!!!!!!', response)
                    device = self._centralMaster.connect(response)
+                    print('connect', device)

                    device = CompletedDevice(self, library, device.device_id, device)
                except Exception as e:
@@ -854,8 +854,7 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):

    __slots__ = ('_message', '_cycle_number', '_start_return_data', '_time_stamp',
                 '_total_time_stamp', '_mode', '_cycle_start_time',
-                 '_mode_stop', '_show_data', 
-                 '_last_mem_wrong_information', '_last_mem_cnt', '_last_elite_notify_times')
+                 '_mode_stop', '_show_data')

    def __init__(self):
        super().__init__()
@@ -872,10 +871,6 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):

        self._show_data = False

-        self._last_mem_wrong_information = -1
-        self._last_mem_cnt = -1
-        self._last_elite_notify_times = -1
-
    @property
    def name(self) -> str:
        return self.NAME
@@ -940,19 +935,6 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
        # self._show_data = True

        mem_wrong_information = struct.unpack('<i', data[43:47])[0] # mem_wrong_information = green retry, green wrong, red retry, red wrong
-        
-        if mem_wrong_information != self._last_mem_wrong_information:
-            print(datetime.now(), 'device', str(self.device), 'mem_wrong_information[43:47]:', data[43:47], mem_wrong_information, self._last_mem_wrong_information, flush = True)
-        if mem_cnt != self._last_mem_cnt+1:
-            if not (mem_cnt == 0 and self._last_mem_cnt == 255):
-                print(datetime.now(), 'device', str(self.device), 'mem_cnt:', mem_cnt, 'self._last_mem_cnt:', self._last_mem_cnt, flush = True)
-        if (elite_notify_times != self._last_elite_notify_times+1) and not (elite_notify_times == 0 and self._last_elite_notify_times == 0):
-            if not (elite_notify_times == 0 and self._last_elite_notify_times == 255):
-                print(datetime.now(), 'device', str(self.device), 'elite_notify_times:', elite_notify_times, 'self._elite_notify_times:', self._last_elite_notify_times, flush = True)
-        self._last_mem_wrong_information = mem_wrong_information
-        self._last_mem_cnt = mem_cnt
-        self._last_elite_notify_times = elite_notify_times
-
        ram_num = data[47]
        broken_flag = data[-1]

@@ -532,6 +532,7 @@ class ComplexExpression(Expression[T]):
    @classmethod
    def parse(cls, json: JSON_OBJECT) -> Union['ComplexExpression', UndeterminedExpression]:
        expression = _get(json, 'expression', str, _truncate(json), nullable=True)
+        print('expression parse', expression, json)

        if expression is None:
            # un-determined expression
@@ -879,9 +880,13 @@ class WhenExpression(ComplexExpression[T]):
        self._when: Dict[str, Expression[T]] = when

    def value(self, context: Scope) -> Union[str, T]:
+        print('value', context)
        value = super().value(context)

+
        key = str(value)
+        print('value1', key,value)
+        print('when', self._when)

        if key in self._when:
            return self._when[key].value(context.child(VALUE=value))
@@ -404,7 +404,9 @@ class ListInstruction(Instruction, ImmutableListNode[Union[Instruction, Expressi
        ImmutableListNode.__init__(self, list(ins))

    def eval_instruction(self, context: Scope) -> Iterable['SingleInstruction']:
+        print('eval_instruction', context)
        for ins in self:
+            print(ins)
            # foreach instructions

            # ins type could be Union[str, Expression]
@@ -794,7 +796,6 @@ class InstructionDataContent(InstructionContent):
                    offset += 1

                else:
-                    buffer.extend([0]*(self._width.size-len(buffer)))
                    for i in range(self._width.size):
                        if self._width.little_endian:
                            value |= (buffer[offset] << (1 * i))
@@ -13,7 +13,7 @@ MSM_REG_WRITE = 0x01
 MEM_INS_WRITE = 0x02
 MEM_INS_READ = 0x03
 MEM_REG_READ = 0x05
-DEFAULT_REGISTER_VALUE = 0b0100_0001  # 0x41
+DEFAULT_REGISTER_VALUE = 0b0100_0011  # 67
 MEM_SIZE = 0x1000

 _SLEEP_TIME_ = 0.001
@@ -457,16 +457,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):

        self._spi.send_byte(tx)

-    def test_ram(self, channel: int):
-        spi_MOSI = [MEM_INS_WRITE, 0, 0, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
-        self._spi.send_byte(spi_MOSI)
-        print('device:', channel, 'spi_MOSI:',spi_MOSI)
-
-        spi_MISO = [0] * len(spi_MOSI)
-        spi_MISO[0:3] = [MEM_INS_READ, 0, 0]
-        spi_MISO = self._spi.send_byte(spi_MISO)
-        print('device:', channel, 'spi_MISO:', spi_MISO)
-
 class ExtMemManager:
    def __init__(self, ext_mem: MultiExtMemSpiInterface):
        self._ext_mem = ext_mem
@@ -503,31 +493,28 @@ class ExtMemManager:

            ret[channel] = tuple(r)

-        print('ret=', ret)
        return ret

    @staticmethod
-    def is_memory_test_fail(result: Tuple[Optional[int], Optional[int]], channel: int) -> int:
+    def is_no_device(result: Tuple[Optional[int], Optional[int]]) -> bool:
        r1, r2 = result
-        r1_check = False
-        r2_check = False
+        return (r1 is None or r2 is None) and (r1 is None or r1 == 0) and (r2 is None or r2 == 0)

-        if r1 is not None and r1 != 0:
-            if (r1 & 0b11000001 == DEFAULT_REGISTER_VALUE & 0b11000001):
-                r1_check = True
-                print('device:', channel, 'ram0 ready')
-        
-        if r2 is not None and r2 != 0:
-            if (r2 & 0b11000001 == DEFAULT_REGISTER_VALUE & 0b11000001):
-                r2_check = True
-                print('device:', channel, 'ram1 ready')
-                print('--------------------')
+    @staticmethod
+    def is_memory_test_fail(result: Tuple[Optional[int], Optional[int]]) -> int:
+        r1, r2 = result

-        if r1_check and r2_check:
-            return 0
-        else:
+        if r1 is None or r2 is None:
            return 1

+        if r1 is not None and r1 > 0 and r1 != DEFAULT_REGISTER_VALUE:
+            return 2
+
+        if r2 is not None and r2 > 0 and r2 != DEFAULT_REGISTER_VALUE:
+            return 3
+
+        return 0
+
    def get_available_channel(self, result: List[Tuple[Optional[int], Optional[int]]] = None) -> List[int]:
        if result is None:
            result = self.get_ext_mem_register()
@@ -535,14 +522,12 @@ class ExtMemManager:
        ret = []

        for channel, result in enumerate(result):
-            if self.is_memory_test_fail(result, channel) != 0:
+            if self.is_no_device(result):
+                continue
+
+            if self.is_memory_test_fail(result) != 0:
                continue

            ret.append(channel)

-        # test ram
-        # for channel in self._ext_mem.foreach():
-        #     if channel == 4 or channel == 5:
-        #         self._ext_mem.test_ram(channel)
-
        return ret
@@ -329,6 +329,30 @@ class ControlServer(SocketServer, ControlServerAPI):
        finally:
            self.led_thread.set_state(LED.AVAILABLE)

+            # version_info = [0, 2, 1, 7, 23, 2]
+            # serial_number = DeviceSerialNumber(version_info[0],
+            #                             version_info[1],
+            #                             version_info[2],
+            #                             version_info[3],
+            #                             version_info[4],
+            #                             version_info[5])
+            # response = DeviceResponseInfo('Elite-EDC', serial_number, (164, 218, 50, 212, 231, 12), addr_type=0)
+            # print('setup done', response)
+            # ret = self.device_manager.connect(response)
+            # print('ret', ret)
+
+            version_info = [0, 5, 1, 0, 23, 5]
+            serial_number = DeviceSerialNumber(version_info[0],
+                                        version_info[1],
+                                        version_info[2],
+                                        version_info[3],
+                                        version_info[4],
+                                        version_info[5])
+            response = DeviceResponseInfo('Elite-EDC', serial_number, (164, 218, 50, 212, 238, 89), addr_type=0)
+            print('setup done', response)
+            ret = self.device_manager.connect(response)
+            print('ret', ret)
+
    def _setup_get_available_channel(self) -> Optional[List[int]]:
        client = self.data_server.client()

@@ -558,7 +582,6 @@ class ControlServer(SocketServer, ControlServerAPI):
            response = content
        else:
            response = to_device_info(content)
-
        try:
            ret = self.device_manager.connect(response)
        except DeviceInstructionError as e:
@@ -868,7 +891,7 @@ class ControlServer(SocketServer, ControlServerAPI):
        mac_address = address_str(connect_device.mac_address)
        device = Device.get_device({"mac_address": mac_address})
        try:
-            if connect_device.library.name.startswith('Elite_EIS'):
+            if connect_device.library.name.startswith('Elite_EIS_1.1'):
                # update calibration version
                connect_device._device.update_cali_version()
                # check if is first time or calibration version is different
@@ -1398,7 +1421,6 @@ class ControlServer(SocketServer, ControlServerAPI):
            if client is not None:
                with client:
                    client.show_data(device)
-
 class _RandomCrashThread(ServerThread):
    def __init__(self):
        super().__init__('Crash')
@@ -31,7 +31,7 @@
  },
  "parameters": {
    "USED": {
-      "initial": [true, true, true, false, false, false, false, false],
+      "initial": [false, false, false, false, false, false, false, false],
      "domain": {
        "list": [
          0, 2
@@ -40,7 +40,7 @@
      "value": "VALUE"
    },
    "T_EARLY": {
-      "initial": [5000, 5000, 5000, 0, 0, 0, 0, 0],
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
      "domain": {
        "list": [
          0, 86400000
@@ -49,7 +49,7 @@
      "value": "VALUE"
    },
    "V_EARLY": {
-      "initial": [true, false, false, false, false, false, false, false],
+      "initial": [false, false, false, false, false, false, false, false],
      "domain": {
        "list": [
          0, 2
@@ -58,7 +58,7 @@
      "value": "VALUE"
    },
    "CYCLE": {
-      "initial": [10, 10, 10, 1, 1, 1, 1, 1],
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
      "domain": {
        "list": [
          0, 65535
@@ -67,7 +67,7 @@
      "value": "VALUE"
    },
    "T_MID0": {
-      "initial": [30000, 30000, 30000, 0, 0, 0, 0, 0],
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
      "domain": {
        "list": [
          0, 86400000
@@ -76,7 +76,7 @@
      "value": "VALUE"
    },
    "T_MID1": {
-      "initial": [30000, 30000, 30000, 0, 0, 0, 0, 0],
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
      "domain": {
        "list": [
          0, 86400000
@@ -103,7 +103,7 @@
      "value": "VALUE"
    },
    "V_MID0": {
-      "initial": [true, true, false, false, false, false, false, false],
+      "initial": [false, false, false, false, false, false, false, false],
      "domain": {
        "list": [
          0, 2
@@ -112,7 +112,7 @@
      "value": "VALUE"
    },
    "V_MID1": {
-      "initial": [false, false, true, false, false, false, false, false],
+      "initial": [false, false, false, false, false, false, false, false],
      "domain": {
        "list": [
          0, 2
@@ -332,13 +332,10 @@
    "MODE": {
      "description": "working mode",
      "record_meta": true,
-      "initial": 3,
      "value": [
        "Analog Current Control (ACC)",
        "Idle",
        "Dev Mode",
-        "Protocal 1",
-        "Protocal 2",
        "Trigger"
      ]
    },
@@ -401,9 +398,7 @@
        "expression": "MODE",
        "when": {
          "0": "curve_acc",
-          "3": "trig_timer_mode",
-          "4": "trig_timer_mode",
-          "5": "trig_timer_mode"
+          "3": "trig_timer_mode"
        }
      },
      "_sync(True)",