- Fixed parameter value string error

- Fix Pel_2.0 parameters

python/biopro/device/device_cc2650.py

@@ -429,17 +429,20 @@ class CC2650Device(Device):
                     self._start_flag = False
 
     def _encode_instruction(self, ins_type: int, ins_oper: int, *instruction: int) -> bytes:
+        # print('_encode_instruction', ins_type, ins_oper, instruction)
         length = len(instruction)
         if length == 1 and instruction[0] < 0:
             return struct.pack('2B1b',
                            (ins_type & 0xF0) | (self.device_id & 0x0F),
                            (ins_oper & 0xFF),
                            *instruction)
-
-        return struct.pack('%dB' % (length + 2),
-                           (ins_type & 0xF0) | (self.device_id & 0x0F),
-                           (ins_oper & 0xFF),
-                           *instruction)
+        if ins_type == None:
+            return struct.pack('%dB' % length, *instruction)
+        else:
+            return struct.pack('%dB' % (length + 2),
+                            (ins_type & 0xF0) | (self.device_id & 0x0F),
+                            (ins_oper & 0xFF),
+                            *instruction)
 
     def _decode_data(self, ins_oper: int, data: bytes) -> bytes:
         """CIS data decoder.
@@ -483,17 +486,19 @@ 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:
-        self.update_battery_info()
+        if self._start_flag == False:
+            self.update_battery_info()
         return self._battery
 
     @property
@@ -2173,7 +2178,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
@@ -2181,16 +2186,23 @@ 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)
 
-        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
@@ -2200,7 +2212,8 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
             self.log_verbose('[CC2650]', DEVICE_CONNECTED, address_s)
             return ret
 
-        self.log_verbose('[CC2650]', 'connect fail')
+        connect_response_hex = ''.join(format(i, '02X') for i in connect_response)
+        self.log_verbose('[CC2650]', 'connect fail', '0x'+connect_response_hex)
         return False
 
     @synchronized
@@ -2212,7 +2225,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))
@@ -2226,6 +2239,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
@@ -2236,7 +2273,10 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
         ins = bytearray()
 
         ins.append(0x06)
-        ins.append(len(data)+2) #length = handle + C0C0XXXX(data len) + F1 
+        if len(data) + 2 > 255:
+            ins.append(255)
+        else:
+            ins.append(len(data)+2) #length = handle + C0C0XXXX(data len) + F1 
         ins.append(handle)
         ins.extend(data)
         ins.append(0xF1)
@@ -2258,6 +2298,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]

python/biopro/device/manager.py

@@ -836,6 +836,9 @@ class DeviceManager(MasterDevice, Synchronized):
         elif func == InternalInstruction.PREDEFINED_IDLE:
             self._idle(device, *para)
 
+        elif func == InternalInstruction.PREDEFINED_COUNTDOWN:
+            self._countdown(device, *para)
+
         elif isinstance(device, DebugDevice):
             if func == InternalInstruction.PREDEFINED_NOTIFY:
                 return True
@@ -858,6 +861,11 @@ class DeviceManager(MasterDevice, Synchronized):
         self._handler.device_internal_command(device.device_id,
                                                 InternalInstruction.PREDEFINED_IDLE,
                                                 None)
+    
+    def _countdown(self, device: Device, expr: AnyStr):
+        self._handler.device_internal_command(device.device_id,
+                                                InternalInstruction.PREDEFINED_COUNTDOWN,
+                                                expr)
 
     def _device_data_format_cali(self, device: Device, expr: str, cali: bytes = None):
         if cali is None:

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/device.py

@@ -689,11 +689,13 @@ class DeviceInstruction:
     TYP_IIS = -1
     """internal instruction"""
 
+    TYP_ALL = None
+
     __slots__ = ()
 
     @classmethod
     def valid_ins_type(cls, ins_type: int):
-        if ins_type not in (cls.TYP_RIS, cls.TYP_VIS, cls.TYP_CIS, cls.TYP_IIS):
+        if ins_type not in (cls.TYP_RIS, cls.TYP_VIS, cls.TYP_CIS, cls.TYP_IIS, cls.TYP_ALL):
             raise ValueError('unknown instruction type : ' + str(ins_type))
 
     @classmethod
@@ -704,6 +706,8 @@ class DeviceInstruction:
             return cls.TYP_VIS
         elif ins_type == 'CIS':
             return cls.TYP_CIS
+        elif ins_type == 'ALL':
+            return cls.TYP_ALL
         else:
             raise RuntimeError('unknown instruction type : ' + ins_type)
 

python/biopro/devlib/domain.py

@@ -120,6 +120,9 @@ class ParameterDomain(JsonSerialize, metaclass=abc.ABCMeta):
         elif json == 'int':
             return ParameterIntDomain
 
+        elif json == 'float':
+            return ParameterFloatDomain
+
         elif json == 'property':
             return ParameterPropertyDomain
 
@@ -291,6 +294,25 @@ class ParameterIntDomainType(ParameterTypeDomain):
 
 ParameterIntDomain = ParameterIntDomainType()
 
+class ParameterFloatDomainType(ParameterTypeDomain):
+    __slots__ = ()
+
+    def init_para(self, initial: Optional[Any] = None) -> float:
+        print('ParameterFloatDomainType')
+        if initial is None:
+            return 0
+        else:
+            return float(initial)
+
+    def valid_para(self, value: int) -> bool:
+        return True
+
+    def __str__(self):
+        return "float"
+
+
+ParameterFloatDomain = ParameterFloatDomainType()
+
 
 class ParameterValueDomain(ParameterDomain, metaclass=abc.ABCMeta):
     """limited/ranged P value domain """
@@ -301,7 +323,7 @@ class ParameterValueDomain(ParameterDomain, metaclass=abc.ABCMeta):
         if initial is None:
             return self.range[0]
         else:
-            initial = int(initial)
+            initial = initial
             f, t = self.range
 
             if f <= initial < t:
@@ -742,6 +764,7 @@ class ParameterListDomain(ParameterCollectionDomain):
         sz = len(target)
         i = oper.index(sz)
         v = oper.value(d)
+        # print('ParameterListDomain', d, sz, i, v, str(d) == 'float', type(d))
 
         if i is None and v is None:
             pass
@@ -780,8 +803,11 @@ class ParameterListDomain(ParameterCollectionDomain):
 
             if isinstance(v, int):
                 v = [v]
-
-            target[i] = v
+            target[len(v):] = []
+            if isinstance(d, ParameterFloatDomainType):
+                target[i] = [float(i) for i in v]
+            else:
+                target[i] = v
 
     def _valid_list_limit(self, target: List[Any], inc: int) -> bool:
         if self._limit is not None:

python/biopro/devlib/expression.py

@@ -880,8 +880,7 @@ class WhenExpression(ComplexExpression[T]):
 
     def value(self, context: Scope) -> Union[str, T]:
         value = super().value(context)
-
-        key = str(value)
+        key = str(int(value))
 
         if key in self._when:
             return self._when[key].value(context.child(VALUE=value))

python/biopro/devlib/header.py

@@ -5,6 +5,13 @@ from .device import *
 from .instruction import *
 from .parameter import *
 
+def convert_to_float(lst):
+    # Check if the element is a list (for handling nested lists)
+    if isinstance(lst, list):
+        return [convert_to_float(x) for x in lst]
+    else:
+        # If it's not a list, convert it to float
+        return float(lst)
 
 class MatchRule(JsonSerialize, metaclass=abc.ABCMeta):
     """Device matching rule. Program use this table to find correct library according to the response information from
@@ -444,6 +451,12 @@ class DefaultLibraryLoader:
 
         elif guard is not None:
             guard = ListGuardExpression([GuardExpression.parse(guard)])
+        
+        if "float" in str(domain):
+            initial = convert_to_float(initial)
+
+        # print('!@#$%^&')
+        # print(name, domain, initial, value, value_set)
 
         return ParameterInfo(name, domain,
                              initial=initial,

python/biopro/devlib/instruction.py

@@ -1,4 +1,5 @@
 import re
+import struct
 from random import randint
 from time import sleep
 from typing import Sequence, Tuple
@@ -284,6 +285,7 @@ class InternalInstruction(SingleInstruction):
     PREDEFINED_CDR = '_cdr'
     PREDEFINED_DISABLE_CACHE = '_disable_cache'
     PREDEFINED_IDLE = '_idle'
+    PREDEFINED_COUNTDOWN = '_countdown'
 
     PREDEFINED = (
         PREDEFINED_SLEEP,
@@ -296,6 +298,7 @@ class InternalInstruction(SingleInstruction):
         PREDEFINED_CDR,
         PREDEFINED_DISABLE_CACHE,
         PREDEFINED_IDLE,
+        PREDEFINED_COUNTDOWN
     )
 
     __slots__ = ('_expr', '_para')
@@ -375,7 +378,7 @@ class InternalInstruction(SingleInstruction):
 
         parser.parse_instruction(context, data)
 
-
+# tag2
 class ListInstruction(Instruction, ImmutableListNode[Union[Instruction, Expression[str]]]):
     """Instruction group, allow the name of the instruction or a expression it.
     If instruction name is ``None``, ignore it.
@@ -588,7 +591,7 @@ class InstructionContentWidth:
 
         return InstructionContentWidth(z, t, signed_value=s is not None, little_endian=e == '<'), x
 
-
+# The start from the json file parse
 class InstructionContent(JsonSerialize):
     """
     **json format**
@@ -682,7 +685,7 @@ class InstructionContent(JsonSerialize):
 
             return ins_type(width, expr, **ins_argv, comment=comment)
 
-
+# tag1
 class InstructionDataContent(InstructionContent):
     """
     **json format**
@@ -743,6 +746,7 @@ class InstructionDataContent(InstructionContent):
                 return ret[index]
 
     def build_instruction(self, context: Scope, buffer: List[int], shift: int = 0) -> int:
+        # print('build_instruction', context, buffer, shift, self.value(context))
         if self._width.is_array:
             raise NotImplementedError()
             
@@ -750,24 +754,33 @@ class InstructionDataContent(InstructionContent):
             value = 1
         elif self.value(context) == 'false':
             value = 0
+        elif isinstance(self.value(context), list):
+            value = self.value(context)
         else:
-            value = int(self.value(context))
+            value = self.value(context)
+        # print('value', value, type(value))
+        # print('self._width.bytes_unit', self._width.bytes_unit)
+        # print('self._width.size', self._width.size)
 
         if self._width.bytes_unit:
             if self._width.size == 1:
                 buffer.append(value)
 
             else:
-                tmp = []
-                for _ in range(self._width.size):
-                    tmp.append(value & 0xFF)
-                    value >>= 8
-
-                if self._width.little_endian:
-                    buffer.extend(tmp)
-                else:
-                    buffer.extend(tmp[::-1])
+                if isinstance(self.value(context), list):
+                    buffer.extend(value)
+                elif isinstance(value, int):
+                    tmp = []
+                    for _ in range(self._width.size):
+                        tmp.append(value & 0xFF)
+                        value >>= 8
 
+                    if self._width.little_endian:
+                        buffer.extend(tmp)
+                    else:
+                        buffer.extend(tmp[::-1])
+                elif isinstance(value, float):
+                    buffer.extend(struct.pack('>f', value))
             return 8
 
         else:
@@ -794,6 +807,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))
@@ -1111,7 +1125,7 @@ class SendInstruction(SingleInstruction):
         else:
             for scope in self._foreach_parameter.for_scope(context):
                 yield ResolvedSendInstruction(self, self._build_instruction(scope))
-
+    # tag3
     def _build_instruction(self, context: Scope) -> List[int]:
         buffer = []
         shift = 0

python/biopro/devlib/library.py

@@ -359,6 +359,7 @@ class DeviceParameter(JsonSerialize):
 
         # initial parameter table
         for para_info in library.parameter_table.values():
+            # print('DeviceParameter', para_info)
             try:
                 para_value = para_info.init_para()
 
@@ -522,6 +523,7 @@ class DeviceParameter(JsonSerialize):
             raise RuntimeError('not a collection parameter ' + para)
 
         target = self._parameter[para]
+        # print(table, info, domain, target, str(domain) == '[float]', oper)
 
         if isinstance(target, set):
             old = set(target)
@@ -1128,13 +1130,21 @@ class CompletedDevice(Device):
         :param value: new parameter P value
         """
         info = self._library.parameter_table[name]
+        # print('info', info.domain, info.domain == 'float',  info.domain == '[float]')
 
         if isinstance(info.domain, ParameterCollectionDomain):
             self._parameter.oper_parameter(name, value)
+        elif isinstance(info.domain, ParameterFloatDomainType):
+            self._parameter.set_parameter(name, float(value))
         else:
             try:
+                value = value
                 # value int
-                value = int(value)
+                if isinstance(value, str):
+                    if "." in value:
+                        value = float(value)
+                    else:
+                        value = int(value)
             except ValueError as e:
                 # value float
                 self._parameter.set_parameter(name, value)

python/biopro/devlib/parameter.py

@@ -433,6 +433,7 @@ class ParameterInfo(JsonSerialize):
         return self._on_change
 
     def init_para(self) -> Any:
+        # print('initial', self._name, self._initial)
         """
         :return: initial P value
         :raises value: illegal initial value
@@ -617,6 +618,7 @@ class ParameterInfo(JsonSerialize):
             return []
 
         elif isinstance(self._value, ComplexExpression):
+            print('cast_value_dependency', self._value.dependency)
             return self._value.dependency
 
         else:

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/server/main.py

@@ -2,6 +2,8 @@ from time import sleep
 from typing import Iterable
 from datetime import datetime
 import json
+import threading
+from time import time
 
 import biopro.impl.vcgencmd as vcg
 from biopro.data import DataServerOptions, DataAPI
@@ -868,7 +870,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
@@ -1093,6 +1095,34 @@ class ControlServer(SocketServer, ControlServerAPI):
             device.status = 1
             return True
 
+        elif oper == InternalInstruction.PREDEFINED_COUNTDOWN:
+            if value == 'PULSE_OUTPUT':
+                continue_mode = device.get_parameter('CONTINUE_MODE')
+                if continue_mode == 0:
+                    stop_time = device.get_parameter('STOP_TIME')
+                    # Function to send the instruction
+                    def send_instruction():
+                        device.call_instruction('deactive_electrode')
+
+                    # Function to wait for 30 seconds and then execute the instruction
+                    def delayed_execution(stop_time):
+                        sleep(stop_time)
+                        send_instruction()
+                        device.set_parameter('ACTIVATE_ELECTRODE', 0)
+                        self.mqtt_thread.broadcast_command('device_refresh')
+
+                    # Create a thread for the delayed execution
+                    thread = threading.Thread(target=delayed_execution, args=(stop_time,))
+
+                    # Start the thread
+                    thread.start()
+
+                    # Main program continues without waiting for the thread
+                    # print("Main program continues...")
+                    # print('COUNTDOWN!!!', device, oper, value)
+                    # print(device.get_parameter(value), device.get_parameter_value(value))
+            return True
+
         else:
             return False
 

python/res/devlib/json/CPG_1.1.devlib.json

@@ -0,0 +1,343 @@
+{
+  "name": "CPG",
+  "version": "1.2.30",
+  "match_rule": {
+    "local_name_pattern": "Elite-CPG.*",
+    "major_product_number": 0,
+    "minor_product_number": 8,
+    "major_version_number": 0,
+    "minor_version_number": 1
+  },
+  "constant": {
+    "TIME_MAX": 100000,
+    "VOLT_MAX": 65536,
+    "Const_Current_Range": 1500001,
+    "BLE_WRITE_MAX": 255
+  },
+  "parameters": {
+    "ADC_VALUE_I": {
+      "description": "ADC value current value",
+      "domain": "int"
+    },
+    "FREQUENCY": {
+      "description": "FREQUENCY",
+      "record_meta": true,
+      "initial": [80, 0],
+      "domain": {
+        "list": [1000000]
+      }
+    },
+    "AMPLITUDE": {
+      "description": "AMPLITUDE",
+      "record_meta": true,
+      "initial": [1, 1],
+      "domain": {
+        "list": "float"
+      }
+    },
+    "PULSE_WIDTH": {
+      "description": "PULSE_WIDTH",
+      "record_meta": true,
+     "initial": [250, 250],
+      "domain": {
+        "list": [1000000]
+      }
+    },
+    "PATTERN_MODE": {
+      "description": "SELECT_ELECTRODE",
+      "record_meta": true,
+     "initial": [1, 0],
+      "domain": {
+        "list": "float"
+      }
+    },
+    "CONTINUE_MODE": {
+      "description": "CONTINUE_MODE",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [2],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "STOP_TIME": {
+      "description": "STOP_TIME",
+      "record_meta": true,
+      "initial": 30,
+      "domain": [1000000],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "ELECTRODE_SELECTOR": {
+      "description": "ELECTRODE_SELECTOR",
+      "record_meta": true,
+      "initial": [true,false,true,false],
+      "domain": {
+        "list": [2]
+      }
+    },
+    "WORKING_ELECTRODE": {
+      "description": "WORKING_ELECTRODE",
+      "record_meta": true,
+      "initial": [0, 0, 0, 0],
+      "domain": {
+        "list": "float"
+      }
+    },
+    "PATTERN_SELECTOR": {
+      "description": "PATTERN_SELECTOR",
+      "record_meta": true,
+      "initial": [0, 0, 1, 1],
+      "domain": {
+        "list": "float"
+      }
+    },
+    "ACTIVATE_ELECTRODE": {
+      "description": "PATTERN_SELECTOR",
+      "record_meta": true,
+      "initial": 0,
+      "domain": "float"
+    },
+
+    "CHANNEL": {
+      "description": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "CHANNEL_LABEL": {
+      "description": "channel label",
+      "record_meta": true,
+      "domain": "property",
+      "value": "['current', 'voltage', 'impedance']"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 1000,
+      "domain": [
+        1001
+      ],
+      "value": {
+        "expression": "VALUE"
+      },
+      "on_change": "set_sample_rate"
+    },
+    "AMP_GAIN": {
+      "description": "amp gain",
+      "record_meta": true,
+      "domain": "constant",
+      "value": 1
+    },
+    "MODE": {
+      "description": "working mode",
+      "record_meta": true,
+      "initial": 0,
+      "value": [
+        "Electrical stimulation",
+        "Dev Mode"
+      ]
+    },
+    "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_UNIT": {
+      "description": "Duration unit",
+      "initial": 2,
+      "value": [
+        "h",
+        "m",
+        "s",
+        "ms"
+      ]
+    },
+    "TIME_DURATION": {
+      "description": "Run duration",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    }
+  },
+  "instruction": {
+    "output": [
+      "active_electrode",
+      "_countdown('PULSE_OUTPUT')"
+    ],
+    "active_electrode": {
+      "type": "RIS",
+      "parameter": {
+        "ch0": "ELECTRODE_SELECTOR[0]",
+        "ch1": "ELECTRODE_SELECTOR[1]",
+        "ch2": "ELECTRODE_SELECTOR[2]",
+        "ch3": "ELECTRODE_SELECTOR[3]",
+        "Amp1": {
+          "expression": "PATTERN_SELECTOR[0]",
+          "when": {
+            "0": "AMPLITUDE[0]",
+            "1": "AMPLITUDE[1]"
+          }
+        },
+        "Freq1": {
+          "expression": "PATTERN_SELECTOR[0]",
+          "when": {
+            "0": "FREQUENCY[0]",
+            "1": "FREQUENCY[1]"
+          }
+        },
+        "Pulse1": {
+          "expression": "PATTERN_SELECTOR[0]",
+          "when": {
+            "0": "PULSE_WIDTH[0]",
+            "1": "PULSE_WIDTH[1]"
+          }
+        },
+        "Amp2": {
+          "expression": "PATTERN_SELECTOR[2]",
+          "when": {
+            "0": "AMPLITUDE[0]",
+            "1": "AMPLITUDE[1]"
+          }
+        },
+        "Freq2": {
+          "expression": "PATTERN_SELECTOR[2]",
+          "when": {
+            "0": "FREQUENCY[0]",
+            "1": "FREQUENCY[1]"
+          }
+        },
+        "Pulse2": {
+          "expression": "PATTERN_SELECTOR[2]",
+          "when": {
+            "0": "PULSE_WIDTH[0]",
+            "1": "PULSE_WIDTH[1]"
+          }
+        }
+      },
+      "data": [
+        "1XFF;1X02;1XA0;",
+        "1bch0;1bch1;6b000000;",
+        "4BAmp1;4BPulse1;4BFreq1;",
+        "2b00;1bch2;1bch3;4b0000;",
+        "4BAmp2;4BPulse2;4BFreq2;",
+        "4BSTOP_TIME;",
+        "1bch0;1bch1;1bch2;1bch3;4b0000;"
+      ]
+    },
+    "deactive_electrode": {
+      "type": "RIS",
+      "parameter": {
+        "ch0": "ELECTRODE_SELECTOR[0]",
+        "ch1": "ELECTRODE_SELECTOR[1]",
+        "ch2": "ELECTRODE_SELECTOR[2]",
+        "ch3": "ELECTRODE_SELECTOR[3]"
+      },
+      "data": [
+        "1XFF;1X02;1XA1;",
+        "1bch0;1bch1;1bch2;1bch3;4b0000;"
+      ]
+    },
+    "resume_electrode_0": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X06;4b1000;4b0000;"
+      ]
+    },
+    "resume_electrode_1": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X06;4b0100;4b0000;"
+      ]
+    },
+    "resume_electrode_2": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X06;4b0010;4b0000;"
+      ]
+    },
+    "resume_electrode_3": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X06;4b0001;4b0000;"
+      ]
+    },
+    "suspend_electrode_0": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X05;4b1000;4b0000;"
+      ]
+    },
+    "suspend_electrode_1": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X05;4b0100;4b0000;"
+      ]
+    },
+    "suspend_electrode_2": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X05;4b0010;4b0000;"
+      ]
+    },
+    "suspend_electrode_3": {
+      "type": "RIS",
+      "data": [
+        "1XFF;1X02;1X05;4b0001;4b0000;"
+      ]
+    },
+    "idle": [
+      "_idle()"
+    ],
+    "data_format": [
+      "_data_format('I4V4Z4T4')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "ble_instru_send": [
+      "ble_write",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "ble_write": {
+      "type": "ALL",
+      "data": [
+        "255X>BLE_WRITE;"
+      ]
+    },
+    "dev_version": [
+      "CIS_VERSION",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "dev_battery": [
+      "CIS_VOLT",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "set_para_DAC_VOLT": {
+      "type": "RIS",
+      "data": [
+        "XE2;X01;2B>DAC_VOLT"
+      ]
+    }
+  }
+}

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

@@ -1,12 +1,12 @@
 {
-  "name": "Elite_EDC_1.5re",
+  "name": "Elite_EDC_1.5r2",
   "version": "1.2.30",
   "match_rule": {
     "local_name_pattern": "Elite.*",
     "major_product_number": 0,
     "minor_product_number": 2,
     "major_version_number": 1,
-    "minor_version_number": 7
+    "minor_version_number": 8
   },
   "constant": {
     "TIME_MAX": 100000,

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

@@ -10,9 +10,170 @@
   },
   "constant": {
     "TIME_MAX": 100000,
-    "BLE_WRITE_MAX": 255
+    "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"
@@ -171,10 +332,12 @@
     "MODE": {
       "description": "working mode",
       "record_meta": true,
+      "initial": 3,
       "value": [
         "Analog Current Control (ACC)",
         "Idle",
-        "Dev Mode"
+        "Dev Mode",
+        "Trigger"
       ]
     },
     "CHANNEL": {
@@ -235,7 +398,8 @@
       {
         "expression": "MODE",
         "when": {
-          "0": "curve_acc"
+          "0": "curve_acc",
+          "3": "trig_timer_mode"
         }
       },
       "_sync(True)",
@@ -337,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;"
+      ]
     }
+
   }
 }

python/res/devlib/json/PEL_1.0.devlib.json

@@ -0,0 +1,122 @@
+{
+    "name": "PEL_1.0",
+    "version": "1.2.30",
+    "match_rule": {
+      "local_name_pattern": "Elite-PEL.*",
+      "major_product_number": 0,
+      "minor_product_number": 7,
+      "major_version_number": 0,
+      "minor_version_number": 0
+    },
+    "constant": {
+      "TIME_MAX": 100000,
+      "VOLT_MAX": 65536,
+      "Const_Current_Range": 1500001,
+      "BLE_WRITE_MAX": 255
+    },
+    "parameters": {
+      "CHANNEL": {
+        "description": "record channels",
+        "record_meta": true,
+        "domain": "property",
+        "value": "[0, 1, 2]"
+      },
+      "SAMPLE_RATE": {
+        "description": "data sampling rate",
+        "record_meta": true,
+        "initial": 1000,
+        "domain": [
+          1001
+        ],
+        "value": {
+          "expression": "VALUE"
+        },
+        "on_change": "set_sample_rate"
+      },
+      "AMP_GAIN": {
+        "description": "amp gain",
+        "record_meta": true,
+        "domain": "constant",
+        "value": 1
+      },
+      "PATTERN_SWITCH": {
+        "description": "switch of pattern",
+        "initial": 1,
+        "domain": [
+          2
+        ],
+        "value": {
+          "expression": "VALUE"
+        }
+      },
+      "PULSE": {
+        "description": "Pulse Mode Segment Duration 2",
+        "record_meta": true,
+        "initial": [
+          0,
+          0,
+          0
+        ],
+        "domain": {
+          "list": [
+            66536
+          ]
+        },
+        "value": {
+          "expression": "VALUE"
+        }
+      },
+      "PATTERN": {
+        "description": "Pulse Mode Segment Duration 2",
+        "record_meta": true,
+        "initial": 1,
+        "domain": [
+          44
+        ],
+        "value": {
+          "expression": "VALUE"
+        }
+      }
+    },
+    "instruction": {
+      "start": [
+        "pulse_e_load"
+      ],
+      "pulse_e_load": [
+        {
+          "expression": "PATTERN_SWITCH",
+          "when": {
+            "0": "pattern",
+            "1": "manual"
+          }
+        }
+      ],
+      "manual": {
+        "type": "RIS",
+        "parameter": {
+          "pa": "PULSE[0]",
+          "pb": "PULSE[1]",
+          "pc": "PULSE[2]"
+        },
+        "data": [
+          "XFF;",
+          "X62;",
+          "4b1;4b>pa;4b>pb;4b>pc;"
+        ]
+      },
+      "pattern": {
+        "type": "RIS",
+        "parameter": {
+          "pa": "PATTERN"
+        },
+        "data": [
+          "XFF;X62;",
+          "4b>0;12b>pa;"
+        ]
+      },
+      "ble_instru_send": [
+        "ble_write",
+        "_cdr('20X>ADC_VALUE_I')"
+      ]
+    }
+  }

python/res/devlib/json/PEL_2.0.devlib.json

@@ -0,0 +1,155 @@
+{
+    "name": "PEL_2.0",
+    "version": "1.2.30",
+    "match_rule": {
+      "local_name_pattern": "Elite-PEL.*",
+      "major_product_number": 0,
+      "minor_product_number": 7,
+      "major_version_number": 0,
+      "minor_version_number": 1
+    },
+    "constant": {
+      "TIME_MAX": 100000,
+      "VOLT_MAX": 65536,
+      "Const_Current_Range": 1500001,
+      "BLE_WRITE_MAX": 255
+    },
+    "parameters": {
+      "CHANNEL": {
+        "description": "record channels",
+        "record_meta": true,
+        "domain": "property",
+        "value": "[0, 1, 2]"
+      },
+      "SAMPLE_RATE": {
+        "description": "data sampling rate",
+        "record_meta": true,
+        "initial": 1000,
+        "domain": [
+          1001
+        ],
+        "value": {
+          "expression": "VALUE"
+        },
+        "on_change": "set_sample_rate"
+      },
+      "AMP_GAIN": {
+        "description": "amp gain",
+        "record_meta": true,
+        "domain": "constant",
+        "value": 1
+      },
+      "MODE": {
+        "description": "working mode",
+        "record_meta": true,
+        "initial": 0,
+        "value": [
+          "Select Resistor Mode",
+          "Dev Mode"
+        ]
+      },
+      "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"
+      },
+      "ADC_VALUE_I": {
+        "description": "ADC value current value",
+        "domain": "int"
+      },
+      "PATTERN_SWITCH": {
+        "description": "switch of pattern",
+        "initial": 1,
+        "domain": [
+          2
+        ],
+        "value": {
+          "expression": "VALUE"
+        }
+      },
+      "PULSE": {
+        "description": "Pulse Mode Segment Duration 2",
+        "record_meta": true,
+        "initial": [
+          0,
+          0,
+          0
+        ],
+        "domain": {
+          "list": [
+            66536
+          ]
+        },
+        "value": {
+          "expression": "VALUE"
+        }
+      },
+      "PATTERN": {
+        "description": "Pulse Mode Segment Duration 2",
+        "record_meta": true,
+        "initial": 1,
+        "domain": [
+          44
+        ],
+        "value": {
+          "expression": "VALUE"
+        }
+      }
+    },
+    "instruction": {
+      "start": [
+        "pulse_e_load"
+      ],
+      "pulse_e_load": [
+        {
+          "expression": "PATTERN_SWITCH",
+          "when": {
+            "0": "pattern",
+            "1": "manual"
+          }
+        }
+      ],
+      "manual": {
+        "type": "RIS",
+        "parameter": {
+          "pa": "PULSE[0]",
+          "pb": "PULSE[1]",
+          "pc": "PULSE[2]"
+        },
+        "data": [
+          "XFF;",
+          "X62;",
+          "4b1;4b>pa;4b>pb;4b>pc;"
+        ]
+      },
+      "pattern": {
+        "type": "RIS",
+        "parameter": {
+          "pa": "PATTERN"
+        },
+        "data": [
+          "XFF;X62;",
+          "4b>0;12b>pa;"
+        ]
+      },
+     "ble_instru_send": [
+      "ble_write",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "ble_write": {
+      "type": "ALL",
+      "data": [
+        "255X>BLE_WRITE;"
+      ]
+    }
+  }
+}