- Add device mapping memory board No.

- Add reset_trigger function with parameter device
- Add api reset_trigger and device_alert to handle alerting problems

python/biopro/controller.py

@@ -1595,6 +1595,12 @@ class ControlAPI(metaclass=Router):
     def show_device_data(self, device) -> bool:
         raise NotImplementedError()
 
+    def reset_trigger(self, device) -> bool:
+        raise NotImplementedError()
+    
+    def device_alert(self, device) -> bool:
+        raise NotImplementedError()
+
 # noinspection PyAbstractClass
 class ControlClient(SocketClient, ControlAPI, metaclass=SocketClientMacro(ControlAPI)):
     """Connect to controller server through the socket.

python/biopro/data.py

@@ -139,6 +139,12 @@ class DataAPI(metaclass=abc.ABCMeta):
         :param device: device ID
         """
         pass
+    
+    @abc.abstractmethod
+    def reset_trigger(self, device):
+        """reset trigger
+        """
+        pass
 
 
 # noinspection PyAbstractClass
@@ -204,6 +210,9 @@ class DataClient(SocketClient, DataAPI, metaclass=SocketClientMacro(DataAPI)):
     
     def show_data(self, device: int):
         self.send_command('show_data', device)
+    
+    def reset_trigger(self, device):
+        self.send_command('reset_trigger', device)
 
     @staticmethod
     def _to_device_id(*device: Union[int, Device]) -> Tuple[int, ...]:

python/biopro/device/device_cc2650.py

@@ -483,13 +483,14 @@ 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:
@@ -2034,22 +2035,32 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
         ins.append(0xF1)
         self._interface.flush_input()
 
-        try:
-            self.log_verbose('[CC2650]', 'scan_callback att_write','0x'+str.upper(ins.hex()))
-            self._cc2650.send("bytes", bytes(ins))
-
-        except SerialTimeoutException:
-            self.log_verbose('[CC2650]', 'scan_callback send fail')
-
-        else:
+        for _ in range(5):
             try:
-                scan_response = self._cc2650.recv_uart(0.01)
+                self.log_verbose('[CC2650]', 'scan_callback att_write','0x'+str.upper(ins.hex()))
+                self._cc2650.send("bytes", bytes(ins))
 
-            except RecvTimeout:
-                self.log_verbose('[CC2650]', 'scan_callback response timeout, no device')
-                return False
+            except SerialTimeoutException:
+                self.log_verbose('[CC2650]', 'scan_callback send fail, rescan')
+                continue
+
+            else:
+                try:
+                    scan_response = self._cc2650.recv_uart(0.01)
+
+                except RecvTimeout:
+                    self.log_verbose('[CC2650]', 'scan_callback response timeout, no device, rescan')
+                    continue
+
+                else:
+                    if scan_response is None:
+                        self.log_verbose('[CC2650]', 'scan_callback response is None, rescan')
+                        continue
+                    else:
+                        break
 
         if scan_response is None:
+            self.log_verbose('[CC2650]', 'scan_callback response is None--2')
             return False
 
         scan_response_hex = ''.join(format(i, '02X') for i in scan_response)
@@ -2175,12 +2186,18 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
 
         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)
 
-        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)
+        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 connected == True:
             # CC2650Device(device_id, master, scan_response) is a slave device
@@ -2202,7 +2219,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
         ins.append(0xF1)
         self._interface.flush_input()
 
-        for _ in range(5): 
+        for retry in range(5): 
             try:
                 self.log_verbose('[CC2650]', 'disconnect att_write','0x'+str.upper(ins.hex()))
                 self._cc2650.send("bytes", bytes(ins))
@@ -2216,6 +2233,30 @@ 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
@@ -2248,6 +2289,7 @@ 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]
@@ -2569,21 +2611,34 @@ class CC2650MultiMasterCentralDevice(CC2650MasterDevice, Synchronized):
 
         master = None
 
-        for master in self._foreach_empty_master():
-            m = self._cc2650[master]
-            d = self._device[master]
+        # for master in self._foreach_empty_master():
+        #     m = self._cc2650[master]
+        #     d = self._device[master]
 
-            if direct_connect is True and d is None:
-                break
+        #     if direct_connect is True and d is None:
+        #         break
 
-            elif response in m.found() and d is None:
-                break
+        #     elif response in m.found() and d is None:
+        #         break
 
+        # else:
+        #     if master is None:
+        #         raise RuntimeError('cannot connect any more device')
+        #     else:
+        #         raise RuntimeError('rescan please')
+
+        mac_address = address_str(response.mac_address)
+
+        if mac_address == 'A4:DA:32:D4:E6:CD':
+            master = 4
+        elif mac_address == 'A4:DA:32:D4:E8:5F':
+            master = 5
+        elif mac_address == 'A4:DA:32:D4:E7:E5':
+            master = 6
+        elif mac_address == 'A4:DA:32:D4:EF:D8':
+            master = 7
         else:
-            if master is None:
-                raise RuntimeError('cannot connect any more device')
-            else:
-                raise RuntimeError('rescan please')
+            master = 4
 
         #
         self.log_verbose('use', master)

python/biopro/devlib/data.py

@@ -854,7 +854,8 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
 
     __slots__ = ('_message', '_cycle_number', '_start_return_data', '_time_stamp',
                  '_total_time_stamp', '_mode', '_cycle_start_time',
-                 '_mode_stop', '_show_data')
+                 '_mode_stop', '_show_data', 
+                 '_last_mem_wrong_information', '_last_mem_cnt', '_last_elite_notify_times')
 
     def __init__(self):
         super().__init__()
@@ -871,6 +872,10 @@ 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
@@ -935,6 +940,19 @@ 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/instruction.py

@@ -794,6 +794,7 @@ 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/devlib/library.py

@@ -968,11 +968,10 @@ class CompletedDevice(Device):
     """
     __slots__ = ('_master', '_device_id', '_device', '_library', '_context',
                  '_parameter', '_configuration', '_lock', '_feature_mask',
-                 '_cache_battery', '_cache_battery_timestamp', '_coeff', '_status', '_occupied_by_project')
+                 '_cache_battery', '_cache_battery_timestamp', '_coeff', '_status', '_occupied_by_project', '_alert', '_alert_time')
 
     def __init__(self, master: MasterDevice, library: DeviceLibrary, device_id: int, device: Device):
         """
-
         :param master: owner master device
         :param library: device library
         :param device_id: device id
@@ -1009,6 +1008,8 @@ class CompletedDevice(Device):
         self._cache_battery: Optional[int] = None
         self._cache_battery_timestamp: Optional[float] = None
         self._coeff = b''
+        self._alert = False
+        self._alert_time = None
 
     # device property for information
 
@@ -1092,6 +1093,22 @@ class CompletedDevice(Device):
     def occupied_by_project(self, new_occupied_by_project):
         self._occupied_by_project = new_occupied_by_project
 
+    @property
+    def alert(self) -> str:
+        return self._alert
+    
+    @alert.setter
+    def alert(self, new_alert) -> str:
+       self._alert =  new_alert
+    
+    @property
+    def alert_time(self) -> str:
+        return self._alert_time
+    
+    @alert_time.setter
+    def alert_time(self, new_alert_time) -> str:
+        self._alert_time = new_alert_time
+
     # device parameter getter/setter
 
     def parameters(self) -> List[str]:
@@ -1315,6 +1332,8 @@ class CompletedDevice(Device):
             'library_version': str(self._library.version),
             'occupied_by_project': self._occupied_by_project,
             'configuration':   self.configuration.as_json(list_hide=True),
+            'alert': self.alert,
+            'alert_time': str(self.alert_time),
         }
 
     def __repr__(self):

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_0011  # 67
+DEFAULT_REGISTER_VALUE = 0b0100_0001  # 0x41
 MEM_SIZE = 0x1000
 
 _SLEEP_TIME_ = 0.001
@@ -457,6 +457,16 @@ 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
@@ -493,28 +503,31 @@ class ExtMemManager:
 
             ret[channel] = tuple(r)
 
+        print('ret=', ret)
         return ret
 
     @staticmethod
-    def is_no_device(result: Tuple[Optional[int], Optional[int]]) -> bool:
+    def is_memory_test_fail(result: Tuple[Optional[int], Optional[int]], channel: int) -> int:
         r1, r2 = result
-        return (r1 is None or r2 is None) and (r1 is None or r1 == 0) and (r2 is None or r2 == 0)
+        r1_check = False
+        r2_check = False
 
-    @staticmethod
-    def is_memory_test_fail(result: Tuple[Optional[int], Optional[int]]) -> int:
-        r1, r2 = result
+        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('--------------------')
 
-        if r1 is None or r2 is None:
+        if r1_check and r2_check:
+            return 0
+        else:
             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()
@@ -522,12 +535,14 @@ class ExtMemManager:
         ret = []
 
         for channel, result in enumerate(result):
-            if self.is_no_device(result):
-                continue
-
-            if self.is_memory_test_fail(result) != 0:
+            if self.is_memory_test_fail(result, channel) != 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/recording/file.py

@@ -22,6 +22,8 @@ import random
 
 from copy import copy
 
+import numpy as np
+
 def json_stringify(o) -> str:
     return _json_stringify(o, separators=(',', ':'))
 
@@ -1026,7 +1028,8 @@ class RecordingFileWriter:
                  '_mini_scale_list', '_time_real_time', '_data_rl', '_data_db',
                  '_raw_save', '_mini_save', '_data_time_ch', '_data_value_ch_for_rl',
                  '_data_time_ch_for_rl', '_device_id', '_send_data', '_data_mqtt_ch', '_id_db_save', '_raw_create_not_done',
-                 '_mini_create_not_done')
+                 '_mini_create_not_done', '_trigger_time', '_trigger_time_save', '_threshold', '_threshold_percent', '_first_average')
+        
 
     def __init__(self, meta: RecordingMetaFile, device_id, database = None):
         self._meta = meta
@@ -1110,6 +1113,11 @@ class RecordingFileWriter:
         self._raw_create_not_done = True
         self._mini_create_not_done = True
 
+        self._trigger_time = 0
+        self._trigger_time_save = 0
+        self._threshold = 0
+        self._threshold_percent = 0
+        self._first_average = 0
 
     @property
     def meta_file(self) -> RecordingMetaFile:
@@ -1235,9 +1243,21 @@ class RecordingFileWriter:
             ret.append(str(_max))
         return ret
 
-    def get_data_iter(self, d, mqtt_thread):
+    def get_data_iter(self, d, mqtt_thread, mqtt_thread_1):
         # print('****d size', d.data_size)
         for t, c, v in d.entry_iter():
+            if c == 2:
+                # print(t,c,v, self._threshold, self._trigger_time)
+                # print(time(), time() - self._trigger_time)
+                if v > self._threshold:
+                   self._trigger_time_save = time()
+                if (time() - self._trigger_time_save) > self._trigger_time and self._trigger_time_save != 0 and self._trigger_time != 0:
+                    self._trigger_time_save = time()
+                    content = {
+                        'header': 'device_alert/0',
+                        'device':  self._device_id,
+                    }
+                    mqtt_thread_1.publish('device_alert', json_stringify(content), inter = True)
             if c in self._data_db:
                 ### send real-time
                 if len(self._data_rl[c]) > 0 and self._send_data[c]:
@@ -1330,7 +1350,7 @@ class RecordingFileWriter:
         return
     
     # @calculate_time(1)
-    def write(self, data: Union[bytes, RecordingData, List[bytes], List[RecordingData]], mqtt_thread) -> int:
+    def write(self, data: Union[bytes, RecordingData, List[bytes], List[RecordingData]], mqtt_thread, mqtt_thread_1) -> int:
         # check size
         ths = self.splitting_threshold_size
         tht = self.splitting_threshold_time
@@ -1386,7 +1406,7 @@ class RecordingFileWriter:
                                 'dec': 0,
                             }
                 
-                self.get_data_iter(d, mqtt_thread)
+                self.get_data_iter(d, mqtt_thread, mqtt_thread_1)
 
             if len(self._recording_file_dict) > 0:
                 for ch in self._data_db.keys():
@@ -1416,6 +1436,15 @@ class RecordingFileWriter:
             if len(self._recording_file_dict) > 0:
                 for ch in self._data_db.keys():
                     if self._time_now - self._time[ch] > 5000000:
+                        if ch == 2:
+                            if self._first_average == 0:
+                                a = np.array(self._data_db[ch], dtype=np.int64)
+                                b = np.where(a % 2 == 1)[0]
+                                c = a[b]
+                                if len(c) != 0:
+                                    self._first_average = sum(c)/ len(c)
+                                    # print(c, self._first_average, self._threshold_percent)
+                                    self._threshold = self._first_average * (1 - (self._threshold_percent / 100))
                         if self._recording_file_dict[ch]._status:
                             _data = ' '.join(self._data_db[ch])
                             write_sz = self._recording_file_dict[ch].write(_data, self._channel_list)

python/biopro/server/data.py

@@ -717,6 +717,10 @@ class DataServer(SocketServer, DataAPI):
     
     def show_data(self, device):
         self._configurations[device].put_rec_queue('show_data')
+    
+    def reset_trigger(self, device):
+        if self._configurations.get(device, None) != None:
+            self._configurations[device].put_rec_queue('reset_trigger')
 
 class DataRuntime(metaclass=abc.ABCMeta):
     __slots__ = ('_server', '_device', '_meta_file', '_data_format',

python/biopro/server/main.py

@@ -868,7 +868,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_1.1'):
+            if connect_device.library.name.startswith('Elite_EIS'):
                 # update calibration version
                 connect_device._device.update_cali_version()
                 # check if is first time or calibration version is different
@@ -1178,6 +1178,8 @@ class ControlServer(SocketServer, ControlServerAPI):
                     # unset file info, but keep file path cache
                     self.file_manager.unset(device.device_id)
                     device.status = 0
+                    device.alert = False
+                    device.alert_time = None
 
 
     # server provide method implement : websocket broadcast functions
@@ -1398,6 +1400,25 @@ class ControlServer(SocketServer, ControlServerAPI):
             if client is not None:
                 with client:
                     client.show_data(device)
+        
+        @logging_info
+        def reset_trigger(self, device) -> bool:
+            device = self.device_manager.get_device(device)
+            client = self.data_server.client()
+            if client is not None:
+                with client:
+                    device.alert = False
+                    device.alert_time = None
+                    client.reset_trigger(device.device_id)
+                self.broadcast_command('refresh')
+
+        @logging_info
+        def device_alert(self, device) -> bool:
+            device = self.device_manager.get_device(device)
+            device.alert = True
+            if device.alert_time == None:
+                device.alert_time = datetime.now()
+                self.broadcast_command('refresh')
 
 class _RandomCrashThread(ServerThread):
     def __init__(self):

python/biopro/server/recording.py

@@ -111,6 +111,10 @@ class RecordingProcess(Process):
         self._decoder = self.data_format()
         self._start_time = time()
 
+        self._writer = RecordingFileWriter(self._meta_file, self._device, self._database)
+        self._writer._threshold_percent =  self._meta_file.configuration.get_parameter('THRESHOLD')
+        self._writer._trigger_time = self._meta_file.configuration.get_parameter('TRIGGER_TIME')
+
     def ensure_data_format(self) -> DataDecodeFormat:
         if isinstance(self._data_format, (str, bytes)):
             self._data_format = DataDecodeFormat.parse(self._data_format)
@@ -187,6 +191,8 @@ class RecordingProcess(Process):
                 return False
             elif q == 'show_data':
                 self._decoder._show_data = not self._decoder._show_data
+            elif q == 'reset_trigger':
+                self._writer._trigger_time_save = time()
             else:
                 self.rec_update()
                 self.sync_data(q)
@@ -245,7 +251,8 @@ class RecordingProcess(Process):
         if self._writer is not None and len(ret) > 0:
             if len(self._writer.channel_list) == 0:
                 self._writer.channels_update(ret[0].channels())
-            self._writer.write(ret, self._mqtt_send_data_ch_level)
+            self._writer.write(ret, self._mqtt_send_data_ch_level, self._mqtt_thread)
+            # print('count', self._writer._count)
         # print('write time: ', time() - ctime1)
         # print(ret)
 
@@ -585,7 +592,6 @@ class RecordingProcess(Process):
         self._is_close = False
         if self._mqtt_thread is not None:
             self._mqtt_thread.start()
-        self._writer = RecordingFileWriter(self._meta_file, self._device, self._database)
         self.routine()
 
     def routine(self) -> None:

python/res/devlib/json/Elite_EDC_1.5.devlib.json

@@ -43,6 +43,28 @@
       },
       "value": "VALUE"
     },
+    "TRIGGER_TIME": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "THRESHOLD": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        1000
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "DPV_e_init": {
       "description": "DPV initial voltage ",
       "record_meta": true,

python/res/devlib/json/Elite_EDC_1.5r2.devlib.json

@@ -931,6 +931,28 @@
         "ms"
       ]
     },
+    "TRIGGER_TIME": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "THRESHOLD": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        1000
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "TIME_DURATION": {
       "description": "Run duration",
       "record_meta": true,

python/res/devlib/json/Elite_EDC_1.5re.devlib.json

@@ -931,6 +931,28 @@
         "ms"
       ]
     },
+    "TRIGGER_TIME": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "THRESHOLD": {
+      "description": "threshold ohm",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        1000
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "TIME_DURATION": {
       "description": "Run duration",
       "record_meta": true,

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

@@ -9,9 +9,189 @@
     "minor_version_number": 0
   },
   "constant": {
-    "TIME_MAX": 100000
+    "TIME_MAX": 100000,
+    "BLE_WRITE_MAX": 255,
+    "MODE_ALL_OUTPUT": 15,
+    "ELITE_CH_PR0": 0,
+    "ELITE_CH_D0": 1,
+    "ELITE_CH_A0": 2,
+    "ELITE_CH_A2": 3,
+    "ELITE_CH_A3": 4,
+    "ELITE_CH_A1": 5,
+    "ELITE_CH_D1": 6,
+    "ELITE_CH_PR1": 7,
+    "PR0": 0,
+    "PR1": 1,
+    "D0": 2,
+    "D1": 3,
+    "A0": 4,
+    "A1": 5,
+    "A2": 6,
+    "A3": 7
   },
   "parameters": {
+    "USED": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_EARLY": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_EARLY": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "CYCLE": {
+      "initial": [1, 1, 1, 1, 1, 1, 1, 1],
+      "domain": {
+        "list": [
+          0, 65535
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_MID0": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_MID1": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_MID2": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_MID3": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_MID0": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_MID1": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_MID2": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_MID3": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "T_LATE": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 86400000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "V_LATE": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "CURRENT": {
+      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "domain": {
+        "list": [
+          0, 50000
+        ]
+      },
+      "value": "VALUE"
+    },
+    "OUTPUT_5V": {
+      "initial": [false, false, false, false, false, false, false, false],
+      "domain": {
+        "list": [
+          0, 2
+        ]
+      },
+      "value": "VALUE"
+    },
+    "ADC_VALUE_I": {
+      "description": "ADC value current value",
+      "domain": "int"
+    },
+    "BLE_WRITE": {
+      "description": "send msg to elite",
+      "domain": {
+        "list": [
+          "BLE_WRITE_MAX"
+        ]
+      },
+      "initial": "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+      "value": "VALUE"
+    },
+    "BLE_READ": {
+      "description": "receive msg from elite",
+      "domain": "int"
+    },
     "TIME_DURATION": {
       "description": "timer",
       "record_meta": true,
@@ -152,16 +332,14 @@
     "MODE": {
       "description": "working mode",
       "record_meta": true,
+      "initial": 3,
       "value": [
         "Analog Current Control (ACC)",
-        "Idle"
+        "Idle",
+        "Dev Mode",
+        "Trigger"
       ]
     },
-
-
-
-
-
     "CHANNEL": {
       "description": "delete it",
       "record_meta": true,
@@ -220,7 +398,8 @@
       {
         "expression": "MODE",
         "when": {
-          "0": "curve_acc"
+          "0": "curve_acc",
+          "3": "trig_timer_mode"
         }
       },
       "_sync(True)",
@@ -245,6 +424,21 @@
       "CIS_VOLT",
       "_cdr('20X>ADC_VALUE_I')"
     ],
+    "ble_instru_send": [
+      "ble_write",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "ble_write": {
+      "type": "RIS",
+      "data": [
+        "XFF;",
+        "1B>BLE_WRITE[0];1B>BLE_WRITE[1];1B>BLE_WRITE[2];1B>BLE_WRITE[3];",
+        "1B>BLE_WRITE[4];1B>BLE_WRITE[5];1B>BLE_WRITE[6];1B>BLE_WRITE[7];",
+        "1B>BLE_WRITE[8];1B>BLE_WRITE[9];1B>BLE_WRITE[10];1B>BLE_WRITE[11];",
+        "1B>BLE_WRITE[12];1B>BLE_WRITE[13];1B>BLE_WRITE[14];1B>BLE_WRITE[15];",
+        "1B>BLE_WRITE[16];"
+      ]
+    },
     "curve_acc": {
       "type": "RIS",
       "parameter": {
@@ -307,6 +501,677 @@
       "data": [
         "XE2;X02;X03;2B>ACC_a_out3_current;1B>ACC_a_out3"
       ]
+    },
+    "trig_timer_mode": [
+      "trig_timer_mode_set_mode",
+      {
+        "expression": "USED[PR0]",
+        "when": {
+          "True": "trig_timer_mode_set_PR0"
+        }
+      },
+      {
+        "expression": "USED[PR1]",
+        "when": {
+          "True": "trig_timer_mode_set_PR1"
+        }
+      },
+      {
+        "expression": "USED[D0]",
+        "when": {
+          "True": "trig_timer_mode_set_D0"
+        }
+      },
+      {
+        "expression": "USED[D1]",
+        "when": {
+          "True": "trig_timer_mode_set_D1"
+        }
+      },
+      {
+        "expression": "USED[A0]",
+        "when": {
+          "True": "trig_timer_mode_set_A0"
+        }
+      },
+      {
+        "expression": "USED[A1]",
+        "when": {
+          "True": "trig_timer_mode_set_A1"
+        }
+      },
+      {
+        "expression": "USED[A2]",
+        "when": {
+          "True": "trig_timer_mode_set_A2"
+        }
+      },
+      {
+        "expression": "USED[A3]",
+        "when": {
+          "True": "trig_timer_mode_set_A3"
+        }
+      }
+    ],
+
+    "trig_timer_mode_set_mode": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT"
+      },
+      "data": [
+        "1B>mode;",
+        "1XFF;"
+      ]
+    },
+
+    "trig_timer_mode_set_PR0": [
+      "trig_timer_mode_set_PR0_para1",
+      "trig_timer_mode_set_PR0_para2",
+      "trig_timer_mode_set_PR0_para3"
+    ],
+    "trig_timer_mode_set_PR0_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR0",
+        "para_sequence": 1,
+        "used": "USED[PR0]",
+        "v_early": "V_EARLY[PR0]",
+        "v_late": "V_LATE[PR0]",
+        "v_mid0": "V_MID0[PR0]",
+        "v_mid1": "V_MID1[PR0]",
+        "v_mid2": "V_MID2[PR0]",
+        "v_mid3": "V_MID3[PR0]",
+        "cycle": "CYCLE[PR0]",
+        "t_early": "T_EARLY[PR0]",
+        "t_late": "T_LATE[PR0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_PR0_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR0",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[PR0]",
+        "t_mid1": "T_MID1[PR0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_PR0_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR0",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[PR0]",
+        "t_mid3": "T_MID3[PR0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+
+    "trig_timer_mode_set_PR1": [
+      "trig_timer_mode_set_PR1_para1",
+      "trig_timer_mode_set_PR1_para2",
+      "trig_timer_mode_set_PR1_para3"
+    ],
+    "trig_timer_mode_set_PR1_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR1",
+        "para_sequence": 1,
+        "used": "USED[PR1]",
+        "v_early": "V_EARLY[PR1]",
+        "v_late": "V_LATE[PR1]",
+        "v_mid0": "V_MID0[PR1]",
+        "v_mid1": "V_MID1[PR1]",
+        "v_mid2": "V_MID2[PR1]",
+        "v_mid3": "V_MID3[PR1]",
+        "cycle": "CYCLE[PR1]",
+        "t_early": "T_EARLY[PR1]",
+        "t_late": "T_LATE[PR1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_PR1_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR1",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[PR1]",
+        "t_mid1": "T_MID1[PR1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_PR1_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_PR1",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[PR1]",
+        "t_mid3": "T_MID3[PR1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+
+    "trig_timer_mode_set_D0": [
+      "trig_timer_mode_set_D0_para1",
+      "trig_timer_mode_set_D0_para2",
+      "trig_timer_mode_set_D0_para3",
+      "trig_timer_mode_set_D0_para4"
+    ],
+    "trig_timer_mode_set_D0_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D0",
+        "para_sequence": 1,
+        "used": "USED[D0]",
+        "v_early": "V_EARLY[D0]",
+        "v_late": "V_LATE[D0]",
+        "v_mid0": "V_MID0[D0]",
+        "v_mid1": "V_MID1[D0]",
+        "v_mid2": "V_MID2[D0]",
+        "v_mid3": "V_MID3[D0]",
+        "cycle": "CYCLE[D0]",
+        "t_early": "T_EARLY[D0]",
+        "t_late": "T_LATE[D0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_D0_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D0",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[D0]",
+        "t_mid1": "T_MID1[D0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_D0_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D0",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[D0]",
+        "t_mid3": "T_MID3[D0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_D0_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D0",
+        "para_sequence": 4,
+        "d0_as_5v_en": "OUTPUT_5V[D0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "1B>d0_as_5v_en;"
+      ]
+    },
+
+    "trig_timer_mode_set_D1": [
+      "trig_timer_mode_set_D1_para1",
+      "trig_timer_mode_set_D1_para2",
+      "trig_timer_mode_set_D1_para3",
+      "trig_timer_mode_set_D1_para4"
+    ],
+    "trig_timer_mode_set_D1_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D1",
+        "para_sequence": 1,
+        "used": "USED[D1]",
+        "v_early": "V_EARLY[D1]",
+        "v_late": "V_LATE[D1]",
+        "v_mid0": "V_MID0[D1]",
+        "v_mid1": "V_MID1[D1]",
+        "v_mid2": "V_MID2[D1]",
+        "v_mid3": "V_MID3[D1]",
+        "cycle": "CYCLE[D1]",
+        "t_early": "T_EARLY[D1]",
+        "t_late": "T_LATE[D1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_D1_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D1",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[D1]",
+        "t_mid1": "T_MID1[D1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_D1_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D1",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[D1]",
+        "t_mid3": "T_MID3[D1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_D1_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_D1",
+        "para_sequence": 4,
+        "d0_as_5v_en": "OUTPUT_5V[D1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "1B>d0_as_5v_en;"
+      ]
+    },
+
+    "trig_timer_mode_set_A0": [
+      "trig_timer_mode_set_A0_para1",
+      "trig_timer_mode_set_A0_para2",
+      "trig_timer_mode_set_A0_para3",
+      "trig_timer_mode_set_A0_para4"
+    ],
+    "trig_timer_mode_set_A0_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A0",
+        "para_sequence": 1,
+        "used": "USED[A0]",
+        "v_early": "V_EARLY[A0]",
+        "v_late": "V_LATE[A0]",
+        "v_mid0": "V_MID0[A0]",
+        "v_mid1": "V_MID1[A0]",
+        "v_mid2": "V_MID2[A0]",
+        "v_mid3": "V_MID3[A0]",
+        "cycle": "CYCLE[A0]",
+        "t_early": "T_EARLY[A0]",
+        "t_late": "T_LATE[A0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_A0_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A0",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[A0]",
+        "t_mid1": "T_MID1[A0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_A0_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A0",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[A0]",
+        "t_mid3": "T_MID3[A0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_A0_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A0",
+        "para_sequence": 4,
+        "current": "CURRENT[A0]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "2B>current;"
+      ]
+    },
+
+    "trig_timer_mode_set_A1": [
+      "trig_timer_mode_set_A1_para1",
+      "trig_timer_mode_set_A1_para2",
+      "trig_timer_mode_set_A1_para3",
+      "trig_timer_mode_set_A1_para4"
+    ],
+    "trig_timer_mode_set_A1_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A1",
+        "para_sequence": 1,
+        "used": "USED[A1]",
+        "v_early": "V_EARLY[A1]",
+        "v_late": "V_LATE[A1]",
+        "v_mid0": "V_MID0[A1]",
+        "v_mid1": "V_MID1[A1]",
+        "v_mid2": "V_MID2[A1]",
+        "v_mid3": "V_MID3[A1]",
+        "cycle": "CYCLE[A1]",
+        "t_early": "T_EARLY[A1]",
+        "t_late": "T_LATE[A1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_A1_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A1",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[A1]",
+        "t_mid1": "T_MID1[A1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_A1_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A1",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[A1]",
+        "t_mid3": "T_MID3[A1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_A1_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A1",
+        "para_sequence": 4,
+        "current": "CURRENT[A1]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "2B>current;"
+      ]
+    },
+
+    "trig_timer_mode_set_A2": [
+      "trig_timer_mode_set_A2_para1",
+      "trig_timer_mode_set_A2_para2",
+      "trig_timer_mode_set_A2_para3",
+      "trig_timer_mode_set_A2_para4"
+    ],
+    "trig_timer_mode_set_A2_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A2",
+        "para_sequence": 1,
+        "used": "USED[A2]",
+        "v_early": "V_EARLY[A2]",
+        "v_late": "V_LATE[A2]",
+        "v_mid0": "V_MID0[A2]",
+        "v_mid1": "V_MID1[A2]",
+        "v_mid2": "V_MID2[A2]",
+        "v_mid3": "V_MID3[A2]",
+        "cycle": "CYCLE[A2]",
+        "t_early": "T_EARLY[A2]",
+        "t_late": "T_LATE[A2]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_A2_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A2",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[A2]",
+        "t_mid1": "T_MID1[A2]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_A2_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A2",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[A2]",
+        "t_mid3": "T_MID3[A2]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_A2_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A2",
+        "para_sequence": 4,
+        "current": "CURRENT[A2]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "2B>current;"
+      ]
+    },
+
+    "trig_timer_mode_set_A3": [
+      "trig_timer_mode_set_A3_para1",
+      "trig_timer_mode_set_A3_para2",
+      "trig_timer_mode_set_A3_para3",
+      "trig_timer_mode_set_A3_para4"
+    ],
+    "trig_timer_mode_set_A3_para1": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A3",
+        "para_sequence": 1,
+        "used": "USED[A3]",
+        "v_early": "V_EARLY[A3]",
+        "v_late": "V_LATE[A3]",
+        "v_mid0": "V_MID0[A3]",
+        "v_mid1": "V_MID1[A3]",
+        "v_mid2": "V_MID2[A3]",
+        "v_mid3": "V_MID3[A3]",
+        "cycle": "CYCLE[A3]",
+        "t_early": "T_EARLY[A3]",
+        "t_late": "T_LATE[A3]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "5b>0;1b>v_late;1b>v_early;1b>used;",
+        "4b>0;1b>v_mid3;1b>v_mid2;1b>v_mid1;1b>v_mid0;",
+        "2B>cycle;4B>t_early;4B>t_late;"
+      ]
+    },
+    "trig_timer_mode_set_A3_para2": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A3",
+        "para_sequence": 2,
+        "t_mid0": "T_MID0[A3]",
+        "t_mid1": "T_MID1[A3]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid0;4B>t_mid1;"
+      ]
+    },
+    "trig_timer_mode_set_A3_para3": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A3",
+        "para_sequence": 3,
+        "t_mid2": "T_MID2[A3]",
+        "t_mid3": "T_MID3[A3]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "4B>t_mid2;4B>t_mid3;"
+      ]
+    },
+    "trig_timer_mode_set_A3_para4": {
+      "type": "RIS",
+      "parameter": {
+        "mode": "MODE_ALL_OUTPUT",
+        "elite_ch": "ELITE_CH_A3",
+        "para_sequence": 4,
+        "current": "CURRENT[A3]"
+      },
+      "data": [
+        "1B>mode;",
+        "1B>elite_ch;",
+        "1B>para_sequence;",
+        "2B>current;"
+      ]
     }
+
   }
 }