-testing

python/biopro/device/device_cc2650.py

@@ -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')

python/biopro/device/manager.py

@@ -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:

python/biopro/devlib/data.py

@@ -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]
 

python/biopro/devlib/expression.py

@@ -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))

python/biopro/devlib/instruction.py

@@ -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))

python/biopro/impl/ext_mem.py

@@ -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

python/biopro/server/main.py

@@ -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')

python/res/devlib/json/Elite_TRIG_0.1.devlib.json

@@ -58,7 +58,7 @@
       "value": "VALUE"
     },
     "CYCLE": {
-      "initial": [1, 1, 1, 1, 1, 1, 1, 1],
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
       "domain": {
         "list": [
           0, 65535
@@ -332,7 +332,6 @@
     "MODE": {
       "description": "working mode",
       "record_meta": true,
-      "initial": 3,
       "value": [
         "Analog Current Control (ACC)",
         "Idle",