chore: comment out unnecessary print messages

2. update PELv3.0 5-channel data

python/biopro/data.py

@@ -122,6 +122,14 @@ class DataAPI(metaclass=abc.ABCMeta):
         """
         pass
 
+    @abc.abstractmethod
+    def tag(self, device: Union[int, Device], data_points: int):
+        """tag data
+
+        :param device: device IDs, empty for all
+        """
+        pass
+
     @abc.abstractmethod
     def sync_file(self):
         """sync file, write-back dirty file. """
@@ -202,6 +210,10 @@ class DataClient(SocketClient, DataAPI, metaclass=SocketClientMacro(DataAPI)):
     def stop_sync(self, *device: Union[int, Device]):
         self.send_command('stop_sync', *self._to_device_id(*device))
     
+    def tag(self, device: Union[int, Device], data_points: int):
+        device = device.device_id
+        self.send_command('tag', device, data_points)
+    
     def show_data(self, device: int):
         self.send_command('show_data', device)
 

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.
@@ -494,7 +497,8 @@ class CC2650Device(Device):
 
     @property
     def battery(self) -> int:
-        self.update_battery_info()
+        if self._start_flag == False:
+            self.update_battery_info()
         return self._battery
 
     @property
@@ -591,96 +595,8 @@ class CC2650Device(Device):
         # self.ensure_feature_support(DeviceFeature.CALIBRATION)
 
         coeff = []
-
-        if device_type == 'TDC4VAF2':
-            # neulive 1.3, 1.6
-            for i in range(24):
-                # send
-                code = self._encode_instruction(DeviceInstruction.TYP_CIS, DeviceInstruction.CIS_CALI, i)
-                self._master.write_characteristic(self.device_id, CC2650MasterDevice.COMMAND_HANDLE, code)
-
-                # receive
-                data = self._master.read_characteristic(self.device_id, CC2650MasterDevice.RETURN_HANDLE)
-                coeff.append(self._decode_data(DeviceInstruction.CIS_CALI, data))
-
-        elif device_type == 'TDC4VC':
-            i = 0
-            request_times = 0
-            while i < 4:
-                try:
-                    # print('i', i)
-                    # send
-                    code = self._encode_instruction(DeviceInstruction.TYP_CIS, DeviceInstruction.CIS_CALI, i)
-                    self._master.write_characteristic(self.device_id, CC2650MasterDevice.COMMAND_HANDLE, code)
-
-                    # receive
-                    data = self._master.read_characteristic(self.device_id,
-                                                            CC2650MasterDevice.RETURN_HANDLE)
-
-                    # print('code3', code)
-                    # print('data3', data)
-
-                    coeff.append(self._decode_data(DeviceInstruction.CIS_CALI, data))
-
-                except SendInstructionTimeoutError as e:
-                    print(e)
-                    self._master.log_warn('device', self.device_id, 'update_calibration_info no response', i)
-                    raise BaseException
-                except RuntimeError as e:
-                    print(e)
-                    self._master.log_warn('device', self.device_id, 'update_calibration_info no response - 2', i)
-                    request_times += 1
-                    if request_times > 3:
-                        self._master.reset(self.device_id)
-                        break
-                else:
-                    # print('data success')
-                    if len(data) > 0:
-                        i += 1
-                    else:
-                        request_times += 1
-                        if request_times > 3:
-                            self._master.reset(self.device_id)
-                            break
-                            
-        elif device_type == 'NeuliveThreeOne':
-            i = 0
-            request_times = 0
-            while i < 8:
-                try:
-                    # print('i', i)
-                    # send
-                    code = self._encode_instruction(DeviceInstruction.TYP_CIS, DeviceInstruction.CIS_CALI, i)
-                    self._master.write_characteristic(self.device_id, CC2650MasterDevice.COMMAND_HANDLE, code)
-
-                    # receive
-                    data = self._master.read_characteristic(self.device_id,
-                                                            CC2650MasterDevice.RETURN_HANDLE)
-
-                    coeff.append(self._decode_data(DeviceInstruction.CIS_CALI, data))
-
-                except SendInstructionTimeoutError as e:
-                    print(e)
-                    self._master.log_warn('device', self.device_id, 'update_calibration_info no response', i)
-                    raise BaseException
-                except RuntimeError as e:
-                    print(e)
-                    self._master.log_warn('device', self.device_id, 'update_calibration_info no response - 2', i)
-                    request_times += 1
-                    if request_times > 3:
-                        self._master.reset(self.device_id)
-                        break
-                else:
-                    # print('data success')
-                    if len(data) > 0:
-                        i += 1
-                    else:
-                        request_times += 1
-                        if request_times > 3:
-                            self._master.reset(self.device_id)
-                            break
-
-        elif device_type == 'EISZeroOne':
+             
+        if device_type == 'EISZeroOne':
             i = 1
             while i <= 24:
                 for _ in range(5): 
@@ -2174,7 +2090,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
@@ -2182,6 +2098,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
                     break
 
         if connect_response is None:
+            self.log_verbose('[CC2650]', 'connect response timeout')
             return False
 
         pack_len = connect_response[0]
@@ -2207,7 +2124,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
@@ -2267,7 +2185,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)

python/biopro/device/manager.py

@@ -836,6 +836,12 @@ class DeviceManager(MasterDevice, Synchronized):
         elif func == InternalInstruction.PREDEFINED_IDLE:
             self._idle(device, *para)
 
+        elif func == InternalInstruction.PREDEFINED_COUNTDOWN:
+            self._countdown(device, *para)
+
+        elif func == InternalInstruction.PREDEFINED_TAG:
+            self._tag(device, *para)
+
         elif isinstance(device, DebugDevice):
             if func == InternalInstruction.PREDEFINED_NOTIFY:
                 return True
@@ -858,6 +864,16 @@ 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 _tag(self, device: Device, expr: AnyStr):
+        self._handler.device_internal_command(device.device_id,
+                                                InternalInstruction.PREDEFINED_TAG,
+                                                expr)
 
     def _device_data_format_cali(self, device: Device, expr: str, cali: bytes = None):
         if cali is None:

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)
 
@@ -736,7 +740,7 @@ class DeviceCommonInstruction:
         if instruction == cls.RESET:
             return '_sync(False)', '_notify(False)', 'VIS_RST'
         elif instruction == cls.START:
-            return '_data_format("TDC4VAF2")', '_notify(True)', 'VIS_STI', '_sync(True)'
+            return '_notify(True)', 'VIS_STI', '_sync(True)'
         elif instruction == cls.INTERRUPT:
             return '_notify(False)', 'VIS_INT', '_sync(False)'
         elif instruction == cls.CLOSE:

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

@@ -1,84 +0,0 @@
-from .library import *
-
-DEVLIB_GENERATOR_NAME = 'GENERATOR'
-
-REC_CHANNEL_COUNT = 16
-
-MODE_LIST = [
-    "zero",
-    "sin",
-    "ramp"
-]
-
-ADC_SAMPLE_RATE_LIST = [
-    100,
-    500,
-    1000,
-    2500,
-    4000,
-    5000
-]
-
-AMP_GAIN_LIST = [
-    0.5,
-    1,
-    10,
-    100,
-    1000
-]
-
-NOISE_LIST = [
-    0,
-    0.1,
-    0.5,
-    1.0
-]
-
-DEVLIB_GENERATOR = DeviceLibrary(DEVLIB_GENERATOR_NAME, DeviceLibraryVersion(0, 6))
-
-DEVLIB_GENERATOR._file = ''
-
-_constant = ConstantScope({
-    'REC_CHANNEL_COUNT':    REC_CHANNEL_COUNT,
-    'ADC_SAMPLE_RATE_LIST': ADC_SAMPLE_RATE_LIST
-})
-
-DEVLIB_GENERATOR._constant = _constant
-
-DEVLIB_GENERATOR._para = ParameterTable({
-    'MODE':        ParameterInfo('MODE',
-                                 ParameterConstantRangeDomain(0, 3),
-                                 initial=1,
-                                 value=ArrayExpression(MODE_LIST),
-                                 description='working mode',
-                                 record_meta=True),
-    'CHANNEL':     ParameterInfo('CHANNEL',
-                                 ParameterSetDomain(ParameterConstantRangeDomain(0, REC_CHANNEL_COUNT)),
-                                 initial=[0],
-                                 description='record channels',
-                                 record_meta=True),
-    'SAMPLE_RATE': ParameterInfo('SAMPLE_RATE',
-                                 ParameterConstantRangeDomain(0, len(ADC_SAMPLE_RATE_LIST)),
-                                 value=Expression.parse('ADC_SAMPLE_RATE_LIST[VALUE]'),
-                                 description='sampling rate',
-                                 alias=['ADC_RATE'],
-                                 record_meta=True),
-    'AMP_GAIN':    ParameterInfo('AMP_GAIN',
-                                 ParameterConstantRangeDomain(0, len(AMP_GAIN_LIST)),
-                                 initial=1,
-                                 value=ArrayExpression(AMP_GAIN_LIST),
-                                 description='amp gain',
-                                 record_meta=True),
-    'NOISE':       ParameterInfo('NOISE',
-                                 ParameterConstantRangeDomain(0, len(NOISE_LIST)),
-                                 description='signal noise factor',
-                                 record_meta=True),
-})
-
-DEVLIB_GENERATOR._inst = InstructionTable({
-    'start': ListInstruction('start', [
-        GuardExpression('len(CHANNEL) > 0', 'no recording channel'),
-        "_data_format('TDC4VAF2')",
-        "_sync(True)"
-    ])
-})

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,8 @@ class InternalInstruction(SingleInstruction):
     PREDEFINED_CDR = '_cdr'
     PREDEFINED_DISABLE_CACHE = '_disable_cache'
     PREDEFINED_IDLE = '_idle'
+    PREDEFINED_COUNTDOWN = '_countdown'
+    PREDEFINED_TAG = '_tag'
 
     PREDEFINED = (
         PREDEFINED_SLEEP,
@@ -296,6 +299,8 @@ class InternalInstruction(SingleInstruction):
         PREDEFINED_CDR,
         PREDEFINED_DISABLE_CACHE,
         PREDEFINED_IDLE,
+        PREDEFINED_COUNTDOWN,
+        PREDEFINED_TAG
     )
 
     __slots__ = ('_expr', '_para')
@@ -375,7 +380,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 +593,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 +687,7 @@ class InstructionContent(JsonSerialize):
 
             return ins_type(width, expr, **ins_argv, comment=comment)
 
-
+# tag1
 class InstructionDataContent(InstructionContent):
     """
     **json format**
@@ -743,6 +748,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 +756,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:
@@ -1112,7 +1127,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/generator.py

@@ -26,10 +26,10 @@ cli options
                                   sin                   : sine save (default)
                                   ramp                  : ramp
                                   (Elite, Neulive serial)
-                                      TC4VAF2         Elite_Legacy
-                                      TDC4VAF2        Elite           Neulive
+                                      Elite_Legacy
+                                      Elite           Neulive
                                   (NeuliveSTI serial)
-                                      NeuliveSTI      NeuliveSTI1.0   TDBC4VCTH
+                                      NeuliveSTI      NeuliveSTI1.0
                                   (EliteZM serial)
                                       EliteZM         I4V4Z4T4
                                       (mode :IV, :FG, :CV, :ZT, :VT, :IT)
@@ -317,9 +317,7 @@ class RampGenerator(Generator):
 
 class DeviceGenerator(Generator):
     SUPPORT = {
-        'TC4VAF2':      ('Elite_Legacy', '0.0.0'),
         'Elite_Legacy': ('Elite_Legacy', '0.0.0'),
-        'TDC4VAF2':     ('Elite', '0.1.0'),
         'Elite':        ('Elite', '0.1.0'),
         'Neulive':      ('Neulive', '1.2.0'),
     }
@@ -374,7 +372,6 @@ class NeuliveSTIGenerator(Generator):
     SUPPORT = {
         'NeuliveSTI':    ('NeuliveSTI1.0', '1.0.0'),
         'NeuliveSTI1.0': ('NeuliveSTI1.0', '1.0.0'),
-        'TDBC4VCTH':     ('NeuliveSTI1.0', '1.0.0'),
     }
 
     __slots__ = ('voltage_drop_rate', '_voltage')
@@ -646,10 +643,10 @@ class GeneratorOptions(CliOptions):
         sin                   : sine save (default)
         ramp                  : ramp
         (Elite, Neulive serial)
-            TC4VAF2         Elite_Legacy
-            TDC4VAF2        Elite           Neulive
+            Elite_Legacy
+            Elite           Neulive
         (NeuliveSTI serial)
-            NeuliveSTI      NeuliveSTI1.0   TDBC4VCTH
+            NeuliveSTI      NeuliveSTI1.0
         (EliteZM serial)
             EliteZM         I4V4Z4T4
             (mode :IV, :FG, :CV, :ZT, :VT, :IT)

python/biopro/impl/ext_mem.py

@@ -44,7 +44,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         self._spi = HardwareImplSpiInterface(device,
                                              spi_speed=12_000_000)
 
-        self._elite_data_len = 40
+        self._elite_data_len = 120
         self._mem_header_len = 3
         self._mem_tailer_len = 6
         self._single_data_len = self._elite_data_len + self._mem_header_len + self._mem_tailer_len
@@ -201,34 +201,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
 
         return green_data_section
 
-    def _print_ram_all_data(self):
-        addr = 0
-        red_length = int(7000 / 2)
-        tx_temp = [0] * (red_length + 3)
-
-        while True:
-            tx_temp[0] = MEM_INS_READ
-            tx_temp[1] = ((addr >> 8) & 0xFF)
-            tx_temp[2] = (addr & 0xFF)
-
-            ram_data = []
-            ram_data = self._spi.send_byte(tx_temp)
-            ram_data[0:3] = [255, 255, 255]
-            print(list(ram_data), len(ram_data), addr)
-            addr += len(ram_data) - 3
-
-            if (7000 < addr + len(ram_data)):
-                del ram_data
-                break
-        print()
-
-        return
-
     def recv_memory(self, device: int) -> Optional[bytes]:
-        # self.pin_busy.output(False)
-
-        # print('mem_req==ram_sel,[', self._pin_mem_req_value[device], ',', self._pin_ram_sel_value[device], ']')
-
         rx = []
 
         try:
@@ -241,53 +214,11 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             tx_h[1] = 0
             tx_h[2] = 0
 
-
-            # -------------------------------------read one times-------------------------------------------
             data = []
             flag_print = False
 
             data = self._spi.send_byte(tx_h)
-
-            if (data[0] != 255 or data[1] != 255 or data[2] != 255):
-                self._head_wrong_cnt[device] = self._head_wrong_cnt[device] + 1
-                if (self._head_wrong_cnt[device] <= 5): # print 5 times
-                    print('data_first[0:3] != [255, 255, 255], device:', device, ',', self._head_wrong_cnt[device], 'times')
-                    print(list(data))
-
             data[0:3] = [255, 255, 255]
-            # ----------------------------------------------------------------------------------------------
-
-
-            # -------------------------------------read two times-------------------------------------------
-            # data = []
-            # data_first = []
-            # data_second = []
-            # flag_print = False
-
-            # data_first = self._spi.send_byte(tx_h)
-            # data_second = self._spi.send_byte(tx_h)
-
-            # if (data_first[0] != 255 or data_first[1] != 255 or data_first[2] != 255):
-            #     self._head_wrong_cnt[device] = self._head_wrong_cnt[device] + 1
-            #     if (self._head_wrong_cnt[device] < 10):
-            #         print('data_first[0:3] != [255, 255, 255], device:', device, ',', self._head_wrong_cnt[device], 'times')
-            #         print(list(data_first))
-
-            # if (data_second[0] != 255 or data_second[1] != 255 or data_second[2] != 255):
-            #     self._head_wrong_cnt[device] = self._head_wrong_cnt[device] + 1
-            #     if (self._head_wrong_cnt[device] < 10):
-            #         print('data_second[0:3] != [255, 255, 255], device:', device, ',', self._head_wrong_cnt[device], 'times')
-            #         print(list(data_second))
-
-            # if (data_first[3:] == data_second[3:]):
-            #     data = data_first
-            #     data[0:3] = [255, 255, 255]
-
-            # else:
-            #     data_third = self._spi.send_byte(tx_h)
-            #     print("read data_third", data_third)
-            #     data = self.compare_green_data(data_first, data_second, data_third, len(tx_h))
-            # ----------------------------------------------------------------------------------------------
 
             green_data_section = self._compare_green_data_addr_and_flag(data, device)
 
@@ -299,10 +230,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                 if length < 12:
                     print("length < 12")
                     print("green data print:", data, device, datetime.now())
-
-                # if length == 0:
-                #     self._print_ram_all_data()
-
                 return None
 
             if green_data_section[2] != 0xA5 or green_data_section[3] != 0x5A:
@@ -311,9 +238,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                 print("green data print:", data, device, datetime.now())
                 return None
 
-            # print('data=', list(data))
-            # print('Ram:', data[62])
-
             if (length >= 4000):
                 flag_print = True
                 print("green data: big length:", length)
@@ -321,7 +245,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             if (header != 255):
                 flag_print = True
                 print("green data: header is not 255: ", header)
-                # self._print_ram_all_data()
 
             if (elite_data_len != self._elite_data_len):
                 flag_print = True
@@ -338,28 +261,10 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                 tx_d[0] = MEM_INS_READ
                 tx_d[1] = ((address >> 8) & 0xFF)
                 tx_d[2] = (address & 0xFF)
-            # -------------------------------------read one times-------------------------------------------
                 data = []
                 data = self._spi.send_byte(tx_d)
                 data[0:3] = [255, 255, 255]
-            # ----------------------------------------------------------------------------------------------
 
-            # -------------------------------------read two times-------------------------------------------
-                # data = []
-                # data_first = []
-                # data_second = []
-
-                # data_first = self._spi.send_byte(tx_d)
-                # data_second = self._spi.send_byte(tx_d)
-
-                # if (data_first[3:] == data_second[3:]):
-                #     data = data_first
-                #     data[0:3] = [255, 255, 255]
-                # else:
-                #     data_third = self._spi.send_byte(tx_d)
-                #     print("read red data_third", data_third)
-                #     data = self.compare_red_data(data_first, data_second, data_third, len(tx_d))
-            # ----------------------------------------------------------------------------------------------
                 if length + 3 <= address + len(data):
                     rx.extend(data[3:3 + length - address])
                     del data
@@ -371,27 +276,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                     address += len(data) - 3
                     del data
 
-            # last_index = 0
-            # print("_[Debug] @ spi recv data rx, ram_select:", self._pin_ram_sel_value[device], ",", datetime.now())
-            # for i in range(0, len(rx), self._single_data_len):
-            #     last_index = i
-            #     # print(rx[i:i+self._single_data_len])
-            #     if i == 0:
-            #         print(rx[0:8], 'ram:', rx[47])
-
-            # if last_index != 0:
-            #     print(rx[last_index:last_index+8], 'ram:', rx[last_index+47])
-            # print()
-
-            # /* 
-            #  * red data formate:
-            #  * ramHdr, ramHdr, ramHdr,                                   (3B)
-            #  * 255, #, data_length,                                      (3B)
-            #  * data,                                                     (40B)
-            #  * red_wrong, red_retry_cnt, green_wrong, green_retry_cnt,   (4B)
-            #  * check_num,                                                (1B)
-            #  *                                                                  */
-
             # read again if check num is wrong
             index = 0
             check_number_print = False
@@ -429,10 +313,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         except BaseException as e:
             print(e)
 
-        # finally:
-        #     # print("\n")
-        #     self.pin_busy.output(True)
-
         return bytes(rx)
 
     def read_register(self) -> int:

python/biopro/recording/file.py

@@ -1237,7 +1237,10 @@ class RecordingFileWriter:
 
     def get_data_iter(self, d, mqtt_thread):
         # print('****d size', d.data_size)
-        for t, c, v in d.entry_iter():
+        for c in d['channels']:
+            t = d['time']
+            v = d['data'][c]
+
             if c in self._data_db:
                 ### send real-time
                 if len(self._data_rl[c]) > 0 and self._send_data[c]:
@@ -1252,11 +1255,11 @@ class RecordingFileWriter:
                 
                 sample_rate_rl = 1
                 # rec data
-                if c < 256:
-                    sample_rate_rl = int(d.sample_rate / ( 500 * len(self.channel_list) )) #* len(self.channel_list)
-                # others
-                else:
-                    sample_rate_rl = int(d.sample_rate_channel_upper_256 / ( 1000 * len(self.channel_list)))
+                # if c < 256:
+                #     sample_rate_rl = int(d.sample_rate / ( 500 * len(self.channel_list) )) #* len(self.channel_list)
+                # # others
+                # else:
+                #     sample_rate_rl = int(d.sample_rate_channel_upper_256 / ( 1000 * len(self.channel_list)))
                 if self._close is False:
                     self._data_value_ch[c].append(int(v))
                     self._data_value_ch_for_rl[c].append(int(v))
@@ -1415,7 +1418,7 @@ class RecordingFileWriter:
             mini_save = False
             if len(self._recording_file_dict) > 0:
                 for ch in self._data_db.keys():
-                    if self._time_now - self._time[ch] > 5000000:
+                    if self._time_now - self._time[ch] > 5000:
                         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)
@@ -1423,6 +1426,7 @@ class RecordingFileWriter:
                             self._raw_save['id'][ch] = self._recording_file_dict[ch]._id_db
                             self._raw_save['end_time'][ch] = self._time_now
                             self._raw_save['size'][ch] = self._recording_file_dict[ch]._size
+                            self._meta._size += write_sz
                             self._data_db[ch].clear()
                             self._time[ch] = self._time_now
                             self._meta._last_time = self._time_now

python/biopro/server/controller.py

@@ -673,9 +673,7 @@ class ControlServerAPI(ControlAPI,
         return None
 
     def device_update_calibration(self) -> None:
-        device_list = self.device_manager.list_device()
-        for x in device_list:
-            x.update_calibration_info('TDC4VC')
+        return None
 
     def device_update_radio_frequency(self, device: int, radio_frequency:int) -> bool:
         d = self.device_manager.get_device(device)

python/biopro/server/data.py

@@ -718,6 +718,10 @@ class DataServer(SocketServer, DataAPI):
     def show_data(self, device):
         self._configurations[device].put_rec_queue('show_data')
 
+    @logging_info
+    def tag(self, device: int, data_points: int):
+        self._configurations[device].put_rec_queue('tag_data')
+
 class DataRuntime(metaclass=abc.ABCMeta):
     __slots__ = ('_server', '_device', '_meta_file', '_data_format',
                  '_sync_started', 'sync_file_request', '_writer')
@@ -864,7 +868,7 @@ class GeneratorDataRuntime(DataRuntime):
     __slots__ = ('_generator', '_library', '_start_time')
 
     def __init__(self, server: DataServer, device: int, meta_file: RecordingMetaFile):
-        super().__init__(server, device, meta_file, NulDataDecoder.NAME)
+        super().__init__(server, device, meta_file, I4V4Z4T4DataDecoder.NAME)
 
         configuration = meta_file.configuration
         self._library = library = configuration.library
@@ -971,38 +975,7 @@ class DeviceDataRuntime(DataRuntime):
     @property
     def data_format(self) -> DataDecodeFormat:
         decoder = super().data_format
-
-        # transmit calibration gain level to decoder
-        if isinstance(decoder, TDC4VAF2DataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self.meta_file.configuration.amp_gain
-        elif isinstance(decoder, TDC4VCDataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self.meta_file.configuration.amp_gain
-            decoder._channel = self.meta_file.configuration.channel
-            decoder._adc_clock = self.meta_file.configuration.get_parameter('ADC_CLOCK')
-            # decoder._time_stamp_list = self._time_stamp_list
-            decoder._axis_ch = self.meta_file.configuration.get_parameter('AXIS_CH')
-            
-            decoder._prev_data = self._prev_data
-            decoder._prev_delta_time = self._prev_delta_time
-            decoder._prev_time_stamp = self._prev_time_stamp
-        # elif isinstance(decoder, I4V4Z4T4DataDecoder):
-            # get cycle_time from meta file
-            # decoder._mode = self.meta_file.configuration.MODE
-            # decoder._cycle_start_time = self._cycle_start_time
-        elif isinstance(decoder, NeuliveThreeOneDataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self.meta_file.configuration.amp_gain
-            decoder._channel = self.meta_file.configuration.channel
-            decoder._adc_clock = self.meta_file.configuration.get_parameter('ADC_CLOCK')
-            # decoder._time_stamp_list = self._time_stamp_list
-            decoder._axis_ch = self.meta_file.configuration.get_parameter('AXIS_CH')
-            
-            decoder._prev_data = self._prev_data
-            decoder._prev_delta_time = self._prev_delta_time
-            decoder._prev_time_stamp = self._prev_time_stamp
-        return decoder
+        return None
 
     def sync_data(self, data = None) -> Optional[List[bytes]]:
         if self._timer_of_not_send is None:

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
@@ -862,45 +864,7 @@ class ControlServer(SocketServer, ControlServerAPI):
 
     @logging_info
     def device_update_calibration(self, device: int) -> Union[bool, str]:
-        connect_device = self.device_manager.get_device(device)
-        if connect_device == None:
-            return
-        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'):
-                # update calibration version
-                connect_device._device.update_cali_version()
-                # check if is first time or calibration version is different
-                if connect_device._device._cali_version == -1 or (device.calibration_version != connect_device._device._cali_version):
-                    # get calibration info from device
-                    connect_device.calibration_info('EISZeroOne')
-                    # update_calibration_info
-                    Device.update_device(
-                        { "mac_address": mac_address }, 
-                        {
-                            'calibration': connect_device.calibration ,
-                            'calibration_version': connect_device._device._cali_version
-                        }
-                    )
-                else:
-                    connect_device._device._coeff = device.calibration
-        except BaseException as e:
-            # reset device info in db
-            DeviceAPI.updateByMac(
-                mac_address,
-                {   
-                    'connect_id': -1,
-                    'connect_status': 'idle',
-                    'auto_connect': False,
-                }
-            )
-            # disconnect device
-            self.hardware_device_disconnect(device, True)
-            print(e)
-            return False
-        else:
-            return True
+        return None
 
     @logging_info
     def device_update_radio_frequency(self, device: int, content:int) -> bool:
@@ -1093,6 +1057,36 @@ 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
+        elif oper == InternalInstruction.PREDEFINED_TAG:
+            self._device_set_tag(device, bool(value), 5)
+
         else:
             return False
 
@@ -1178,6 +1172,12 @@ class ControlServer(SocketServer, ControlServerAPI):
                     # unset file info, but keep file path cache
                     self.file_manager.unset(device.device_id)
                     device.status = 0
+        
+    def _device_set_tag(self, device: CompletedDevice, sync: bool, n: int):
+        client = self.data_server.client()
+        if client is not None:
+            with client:
+                client.tag(device, n)
 
 
     # server provide method implement : websocket broadcast functions

python/biopro/server/recording.py

@@ -95,7 +95,6 @@ class RecordingProcess(Process):
         self._prev_time_stamp = []
 
         self._isTimeOut = False
-
         # section use
         self._skip_ram_cnt = 0
         self._get_first_last_cnt = [True, True, True, True, True, True, True, True]
@@ -103,7 +102,7 @@ class RecordingProcess(Process):
         self._wrong_cnt = 0
 
         # elite data length
-        self._elite_data_len = 40
+        self._elite_data_len = 120
         self._mem_header_len = 3
         self._mem_tailer_len = 6
         self._single_data_len = self._elite_data_len + self._mem_header_len + self._mem_tailer_len
@@ -125,40 +124,14 @@ class RecordingProcess(Process):
         decoder = self.ensure_data_format()
 
         # transmit calibration gain level to decoder
-        if isinstance(decoder, TDC4VAF2DataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self._meta_file.configuration.amp_gain
-        elif isinstance(decoder, TDC4VCDataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self._meta_file.configuration.amp_gain
-            decoder._channel = self._meta_file.configuration.channel
-            decoder._adc_clock = self._meta_file.configuration.get_parameter('ADC_CLOCK')
-            # decoder._time_stamp_list = self._time_stamp_list
-            decoder._axis_ch = self._meta_file.configuration.get_parameter('AXIS_CH')
-            
-            decoder._prev_data = self._prev_data
-            decoder._prev_delta_time = self._prev_delta_time
-            decoder._prev_time_stamp = self._prev_time_stamp
-        elif isinstance(decoder, I4V4Z4T4DataDecoder):
-            # get cycle_time from meta file
+        if isinstance(decoder, I4V4Z4T4DataDecoder):
+            decoder._mode = self._meta_file.configuration.get_parameter('MODE')
+        elif isinstance(decoder, PEL_FMT1_DataDecoder):
+            decoder._mode = self._meta_file.configuration.get_parameter('MODE')
+        elif isinstance(decoder, PEL_FMT2_DataDecoder):
             decoder._mode = self._meta_file.configuration.get_parameter('MODE')
-            # decoder._cycle_start_time = self._cycle_start_time
-        elif isinstance(decoder, NeuliveThreeOneDataDecoder):
-            # get amp_gain from meta file
-            decoder.amp_gain = self._meta_file.configuration.amp_gain
-            decoder._channel = self._meta_file.configuration.channel
-            decoder._adc_clock = self._meta_file.configuration.get_parameter('ADC_CLOCK')
-            # decoder._time_stamp_list = self._time_stamp_list
-            decoder._axis_ch = self._meta_file.configuration.get_parameter('AXIS_CH')
-            decoder._accelerator_sensitivity = self._meta_file.configuration.get_parameter('ACCELERATOR_S')
-            
-            decoder._prev_data = self._prev_data
-            decoder._prev_delta_time = self._prev_delta_time
-            decoder._prev_time_stamp = self._prev_time_stamp
         elif isinstance(decoder, EISZeroOneDataDecoder):
-            # get amp_gain from meta file
             decoder._mode = self._meta_file.configuration.get_parameter('MODE')
-
         return decoder
 
     def recv_data_foreach_runtime(self) -> bool:
@@ -187,6 +160,13 @@ class RecordingProcess(Process):
                 return False
             elif q == 'show_data':
                 self._decoder._show_data = not self._decoder._show_data
+            elif q == 'tag_data':
+                sleep(0.3)
+                self._decoder._tag_data = True
+                self._decoder._count = 0
+                # print('q_size', self._queue_rec.qsize())
+                while self._queue_rec.empty() != True:
+                    self._queue_rec.get()
             else:
                 self.rec_update()
                 self.sync_data(q)
@@ -207,36 +187,32 @@ class RecordingProcess(Process):
         # print('sync_data')
         # print('data',data)
 
-        # print('server/data', self._prev_delta_time,self._prev_time_stamp, self._prev_data)
-
         if data is None or len(data) == 0:
             result = self._decoder.decode(b'')
             if result is not None:
                 ret = result
-
             else:
                 return None
 
         else:
             ret = []
-            # print('decoder data')
 
             for offset, section in self._foreach_data_section(data):
             # for section in self._neu_foreach_data_section(data):
+                d = self._decoder.decode(section)
 
-                result = self._decoder.decode(section)
                 # if self._isTimeOut:
                 #     try:
                 #         print('result: ', result.data_size)
                 #     except:
                 #         pass
 
-                if result is not None:
+                if d is not None:
                     ##
                     if len(self._mqtt_send_data_ch_level) == 0:
-                        for ch in result.channels():
-                            self._mqtt_send_data_ch_level[ch] = MqttDataMessageHandler(self._mqtt_thread, 'data_server/device_data_stream/' + str(result.device) + '/' + str(ch) ) 
-                    ret.append(result)
+                        for ch in d["channels"]:
+                            self._mqtt_send_data_ch_level[ch] = MqttDataMessageHandler(self._mqtt_thread, 'data_server/device_data_stream/' + str(d["device"]) + '/' + str(ch) ) 
+                    ret.append(d)
                 else:
                     continue
 
@@ -244,7 +220,7 @@ class RecordingProcess(Process):
         # ctime1 = time()
         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.channels_update(ret[0]['channels'])
             self._writer.write(ret, self._mqtt_send_data_ch_level)
         # print('write time: ', time() - ctime1)
         # print(ret)
@@ -254,8 +230,15 @@ class RecordingProcess(Process):
             if time_duration and time_duration is not 0 and time() - self._start_time >= time_duration:
                 self._queue_msg.put(['ds', self._device, 'interrupt'])
                 return None
+        except KeyError as e:
+            print('time duration keyerror')
+            pass
 
-            if isinstance(self._decoder, I4V4Z4T4DataDecoder) or isinstance(self._decoder, EISZeroOneDataDecoder):
+        try:
+            if isinstance(self._decoder, I4V4Z4T4DataDecoder) or \
+                isinstance(self._decoder, EISZeroOneDataDecoder) or \
+                isinstance(self._decoder, PEL_FMT1_DataDecoder) or \
+                isinstance(self._decoder, PEL_FMT2_DataDecoder):
                 if self._decoder.isFinishMode is not None and self._decoder.isFinishMode() == 1:
                     self._queue_msg.put(['ds', self._device, 'interrupt'])
                     return None
@@ -265,8 +248,9 @@ class RecordingProcess(Process):
                     # content['instruction'] = 'interrupt'
                     # self._mqtt_thread.publish('device_instruction',json_stringify(content), True)
                     # self.server.stop_sync(self.device)
-        except RuntimeError as e:
-            print(e)
+        except KeyError as e:
+            print('isFinishMode error')
+            pass
 
         del ret
         del data
@@ -277,7 +261,6 @@ class RecordingProcess(Process):
         save = True
         head = raw_data[0]
         head_counter = raw_data[1]
-        device_id = raw_data[3]
 
         try:
             # assign last_data_cnt value and handle first last_data_cnt
@@ -305,11 +288,10 @@ class RecordingProcess(Process):
                     self._last_cnt[7] = head_counter - 1
                 last_data_cnt = self._last_cnt[7]
 
-           # dont save to section when head or id is wrong
-            if (head != 255 or device_id != device or head_counter > 255 or head_counter < 0):
+           # dont save to section when head is wrong
+            if (head != 255):
                 save = False
                 last_data_cnt = last_data_cnt + 1
-
                 return save
 
             if (last_data_cnt == 255):
@@ -542,31 +524,31 @@ class RecordingProcess(Process):
             if (save == True):
                 section = raw_data[i]
 
-                check_sum = sum(section[0 : single_data_len - 1]) & 0b11111111
+                # check_sum = sum(section[0 : single_data_len - 1]) & 0b11111111
 
-                if (check_sum != section[single_data_len - 1]):
-                    print('check number not match,',
-                        list(section[0 : mem_header_len]), section[-1], '!=', check_sum, 'device:', device, ',', datetime.now())
-                    if (i-1 >= 0):
-                        print('check number not match', list(raw_data[i-1]), 'raw:', i-1)
+                # if (check_sum != section[single_data_len - 1]):
+                #     print('check number not match,',
+                #         list(section[0 : mem_header_len]), section[-1], '!=', check_sum, 'device:', device, ',', datetime.now())
+                #     if (i-1 >= 0):
+                #         print('check number not match', list(raw_data[i-1]), 'raw:', i-1)
 
-                    print('check number not match', list(raw_data[i]), 'raw:', i)
+                #     print('check number not match', list(raw_data[i]), 'raw:', i)
                     
-                    if (i+1 <= records):
-                        print('check number not match', list(raw_data[i+1]), 'raw:', i+1, '\n')
-                    section = section + b'\x01'
+                #     if (i+1 <= records):
+                #         print('check number not match', list(raw_data[i+1]), 'raw:', i+1, '\n')
+                #     section = section + b'\x01'
 
-                    print('delete data:', list(raw_data[i][0:3]), 'raw:', i, '\n')
-                    continue
-                else:
-                    section = section + b'\x00'
+                #     print('delete data:', list(raw_data[i][0:3]), 'raw:', i, '\n')
+                #     continue
+                # else:
+                #     section = section + b'\x00'
 
                 # section = section[3:]
                 yield None, section
 
             else:
                 print_flag = True
-                print('delete data:', list(raw_data[i][0:3]), 'raw:', i, '\n')
+                print('delete data:', list(raw_data[i][0:20]), 'raw:', i, '\n')
 
         # if print_flag:
         #     print('delete data context:')

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_BAT_0.1.devlib.json

@@ -1638,14 +1638,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

python/res/devlib/json/Elite_BAT_1.0.devlib.json

@@ -1638,14 +1638,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

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

@@ -1706,14 +1706,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

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,
@@ -1706,14 +1706,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

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

@@ -1706,14 +1706,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

python/res/devlib/json/Elite_EIS_1.0.devlib.json

@@ -633,14 +633,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

python/res/devlib/json/Elite_EIS_1.1.devlib.json

@@ -633,14 +633,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

python/res/devlib/json/Elite_EIS_MINI_1.0.devlib.json

@@ -633,14 +633,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "dev_version": [

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

@@ -429,14 +429,9 @@
       "_cdr('20X>ADC_VALUE_I')"
     ],
     "ble_write": {
-      "type": "RIS",
+      "type": "ALL",
       "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];"
+        "255X>BLE_WRITE;"
       ]
     },
     "curve_acc": {

python/res/devlib/json/MMM.devlib.json

@@ -0,0 +1,348 @@
+{
+  "name": "MMM_1.0",
+  "version": "1.2.30",
+  "match_rule": {
+    "local_name_pattern": "Elite-MMM.*",
+    "major_product_number": 0,
+    "minor_product_number": 9,
+    "major_version_number": 0,
+    "minor_version_number": 1
+  },
+  "constant": {
+    "TIME_MAX": 100000,
+    "VOLT_MAX": 65536,
+    "Const_Current_Range": 1500001,
+    "BLE_WRITE_MAX": 255,
+    "DROP_10MS":5,
+    "NOTIFY_DATA": 10
+  },
+  "parameters": {
+    "BAUDRATE": {
+      "description": "baudrate",
+      "record_meta": true,
+      "initial": 10000,
+      "domain": [
+        1000000
+      ],
+      "value": {
+        "expression": "VALUE"
+      },
+      "on_change": "set_sample_rate"
+    },
+    "CHANNEL": {
+      "description": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true, 
+      "initial": 100,
+      "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": [
+        "Dev Mode",
+        "Dev Mode",
+        "MMM"
+      ]
+    },
+    "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"
+      }
+    },
+    "PATTERN_MAX": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 43,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "PATTERN_MIN": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    }
+  },
+  "instruction": {
+    "start": [
+      "data_format",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "start_manual_scan_mode",
+          "1": "start_manual_scan_mode",
+          "2": "",
+          "3": "start_auto_scan_mode",
+          "4": "start_auto_scan_mode",
+          "5": "start_R_external_cali_mode"
+        }
+      },
+      "_sync(True)"
+    ],
+    "get_data": [
+      "manual_scan_mode_set_R_pattern"
+    ],
+    "stop": [
+      "_notify(False)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "stop_manual_scan_mode",
+          "1": "stop_manual_scan_mode",
+          "2": "",
+          "3": "stop_auto_scan_mode",
+          "4": "stop_auto_scan_mode",
+          "5": "stop_R_external_cali_mode"
+        }
+      },
+      "_sync(False)"
+    ],
+    "data_format": [
+      "_data_format('BMD380')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "start_manual_scan_mode": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "start_manual_scan_mode_use_pattern",
+          "1": "start_manual_scan_mode_use_bit"
+        }
+      }
+    ],
+    "start_manual_scan_mode_use_pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "start_manual_scan_mode_use_bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "manual_scan_mode_set_R_pattern": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "pattern",
+          "1": "bit"
+        }
+      }
+    ],
+    "pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_manual_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X01;X00;"
+      ]
+    },
+    "start_auto_scan_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X02;X01;",
+        "2B>PATTERN_MAX;",
+        "2B>PATTERN_MIN;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_auto_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X02;X00;"
+      ]
+    },
+    "start_R_external_cali_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X03;X01;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_R_external_cali_mode": {
+      "type": "RIS",
+      "data": [
+        "X03;X00;"
+      ]
+    },
+    "enable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X04;"
+      ]
+    },
+    "disable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X05;"
+      ]
+    },
+    "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')"
+    ]
+  }
+}

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

@@ -0,0 +1,339 @@
+{
+  "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,
+    "DROP_10MS":5,
+    "NOTIFY_DATA": 10
+  },
+  "parameters": {
+    "CHANNEL": {
+      "description": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 100,
+      "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 Pick Mode",
+        "Select Resistor Full Mode",
+        "Dev Mode",
+        "IOPH",
+        "IOPL",
+        "R-external calibration"
+      ]
+    },
+    "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"
+      }
+    },
+    "PATTERN_MAX": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 43,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "PATTERN_MIN": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    }
+  },
+  "instruction": {
+    "start": [
+      "data_format",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "start_manual_scan_mode",
+          "1": "start_manual_scan_mode",
+          "2": "",
+          "3": "start_auto_scan_mode",
+          "4": "start_auto_scan_mode",
+          "5": "start_R_external_cali_mode"
+        }
+      },
+      "_sync(True)"
+    ],
+    "get_data": [
+      "manual_scan_mode_set_R_pattern"
+    ],
+    "stop": [
+      "_notify(False)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "stop_manual_scan_mode",
+          "1": "stop_manual_scan_mode",
+          "2": "",
+          "3": "stop_auto_scan_mode",
+          "4": "stop_auto_scan_mode",
+          "5": "stop_R_external_cali_mode"
+        }
+      },
+      "_sync(False)"
+    ],
+    "data_format": [
+      "_data_format('PEL_FMT1_')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "start_manual_scan_mode": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "start_manual_scan_mode_use_pattern",
+          "1": "start_manual_scan_mode_use_bit"
+        }
+      }
+    ],
+    "start_manual_scan_mode_use_pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "start_manual_scan_mode_use_bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "manual_scan_mode_set_R_pattern": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "pattern",
+          "1": "bit"
+        }
+      }
+    ],
+    "pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_manual_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X01;X00;"
+      ]
+    },
+    "start_auto_scan_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X02;X01;",
+        "2B>PATTERN_MAX;",
+        "2B>PATTERN_MIN;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_auto_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X02;X00;"
+      ]
+    },
+    "start_R_external_cali_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X03;X01;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_R_external_cali_mode": {
+      "type": "RIS",
+      "data": [
+        "X03;X00;"
+      ]
+    },
+    "enable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X04;"
+      ]
+    },
+    "disable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X05;"
+      ]
+    },
+    "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')"
+    ]
+  }
+}

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

@@ -0,0 +1,339 @@
+{
+  "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,
+    "DROP_10MS":5,
+    "NOTIFY_DATA": 10
+  },
+  "parameters": {
+    "CHANNEL": {
+      "description": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 100,
+      "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 Pick Mode",
+        "Select Resistor Full Mode",
+        "Dev Mode",
+        "IOPH",
+        "IOPL",
+        "R-external calibration"
+      ]
+    },
+    "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"
+      }
+    },
+    "PATTERN_MAX": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 43,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "PATTERN_MIN": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    }
+  },
+  "instruction": {
+    "start": [
+      "data_format",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "start_manual_scan_mode",
+          "1": "start_manual_scan_mode",
+          "2": "",
+          "3": "start_auto_scan_mode",
+          "4": "start_auto_scan_mode",
+          "5": "start_R_external_cali_mode"
+        }
+      },
+      "_sync(True)"
+    ],
+    "get_data": [
+      "manual_scan_mode_set_R_pattern"
+    ],
+    "stop": [
+      "_notify(False)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "stop_manual_scan_mode",
+          "1": "stop_manual_scan_mode",
+          "2": "",
+          "3": "stop_auto_scan_mode",
+          "4": "stop_auto_scan_mode",
+          "5": "stop_R_external_cali_mode"
+        }
+      },
+      "_sync(False)"
+    ],
+    "data_format": [
+      "_data_format('PEL_FMT1_')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "start_manual_scan_mode": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "start_manual_scan_mode_use_pattern",
+          "1": "start_manual_scan_mode_use_bit"
+        }
+      }
+    ],
+    "start_manual_scan_mode_use_pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "start_manual_scan_mode_use_bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "manual_scan_mode_set_R_pattern": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "pattern",
+          "1": "bit"
+        }
+      }
+    ],
+    "pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_manual_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X01;X00;"
+      ]
+    },
+    "start_auto_scan_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X02;X01;",
+        "2B>PATTERN_MAX;",
+        "2B>PATTERN_MIN;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_auto_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X02;X00;"
+      ]
+    },
+    "start_R_external_cali_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X03;X01;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_R_external_cali_mode": {
+      "type": "RIS",
+      "data": [
+        "X03;X00;"
+      ]
+    },
+    "enable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X04;"
+      ]
+    },
+    "disable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X05;"
+      ]
+    },
+    "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')"
+    ]
+  }
+}

python/res/devlib/json/PEL_3.0.devlib.json

@@ -0,0 +1,339 @@
+{
+  "name": "PEL_3.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": 2
+  },
+  "constant": {
+    "TIME_MAX": 100000,
+    "VOLT_MAX": 65536,
+    "Const_Current_Range": 1500001,
+    "BLE_WRITE_MAX": 255,
+    "DROP_10MS":5,
+    "NOTIFY_DATA": 10
+  },
+  "parameters": {
+    "CHANNEL": {
+      "description": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 100,
+      "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 Pick Mode",
+        "Select Resistor Full Mode",
+        "Dev Mode",
+        "IOPH",
+        "IOPL",
+        "R-external calibration"
+      ]
+    },
+    "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"
+      }
+    },
+    "PATTERN_MAX": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 43,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "PATTERN_MIN": {
+      "description": "Pulse Mode Segment Duration 2",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        100
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    }
+  },
+  "instruction": {
+    "start": [
+      "data_format",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "start_manual_scan_mode",
+          "1": "start_manual_scan_mode",
+          "2": "",
+          "3": "start_auto_scan_mode",
+          "4": "start_auto_scan_mode",
+          "5": "start_R_external_cali_mode"
+        }
+      },
+      "_sync(True)"
+    ],
+    "get_data": [
+      "manual_scan_mode_set_R_pattern"
+    ],
+    "stop": [
+      "_notify(False)",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "stop_manual_scan_mode",
+          "1": "stop_manual_scan_mode",
+          "2": "",
+          "3": "stop_auto_scan_mode",
+          "4": "stop_auto_scan_mode",
+          "5": "stop_R_external_cali_mode"
+        }
+      },
+      "_sync(False)"
+    ],
+    "data_format": [
+      "_data_format('PEL_FMT2_')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "start_manual_scan_mode": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "start_manual_scan_mode_use_pattern",
+          "1": "start_manual_scan_mode_use_bit"
+        }
+      }
+    ],
+    "start_manual_scan_mode_use_pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "start_manual_scan_mode_use_bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X01;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "manual_scan_mode_set_R_pattern": [
+      {
+        "expression": "PATTERN_SWITCH",
+        "when": {
+          "0": "pattern",
+          "1": "bit"
+        }
+      }
+    ],
+    "pattern": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PATTERN",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X01;",
+        "16b>pa;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "bit": {
+      "type": "RIS",
+      "parameter": {
+        "pa": "PULSE[0]",
+        "pb": "PULSE[1]",
+        "pc": "PULSE[2]",
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X01;X02;",
+        "X00;X00;",
+        "4b>0;4b>pa;4b>pb;4b>pc;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_manual_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X01;X00;"
+      ]
+    },
+    "start_auto_scan_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X02;X01;",
+        "2B>PATTERN_MAX;",
+        "2B>PATTERN_MIN;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_auto_scan_mode": {
+      "type": "RIS",
+      "data": [
+        "X02;X00;"
+      ]
+    },
+    "start_R_external_cali_mode": {
+      "type": "RIS",
+      "parameter": {
+        "ca": "DROP_10MS",
+        "cb": "NOTIFY_DATA"
+      },
+      "data": [
+        "X03;X01;",
+        "16b>ca;",
+        "16b>cb;"
+      ]
+    },
+    "stop_R_external_cali_mode": {
+      "type": "RIS",
+      "data": [
+        "X03;X00;"
+      ]
+    },
+    "enable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X04;"
+      ]
+    },
+    "disable_notify": {
+      "type": "RIS",
+      "data": [
+        "XFF;XA3;X05;"
+      ]
+    },
+    "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')"
+    ]
+  }
+}