- Add new function data_raw_recording_bytea

- Change data type from string to binary

python/biopro/device/device_cc2650.py

@@ -429,20 +429,17 @@ 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)
-        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)
+
+        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.
@@ -2273,10 +2270,7 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
         ins = bytearray()
 
         ins.append(0x06)
-        if len(data) + 2 > 255:
-            ins.append(255)
-        else:
-            ins.append(len(data)+2) #length = handle + C0C0XXXX(data len) + F1 
+        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,9 +836,6 @@ class DeviceManager(MasterDevice, Synchronized):
         elif func == InternalInstruction.PREDEFINED_IDLE:
             self._idle(device, *para)
 
-        elif func == InternalInstruction.PREDEFINED_COUNTDOWN:
-            self._countdown(device, *para)
-
         elif isinstance(device, DebugDevice):
             if func == InternalInstruction.PREDEFINED_NOTIFY:
                 return True
@@ -861,11 +858,6 @@ class DeviceManager(MasterDevice, Synchronized):
         self._handler.device_internal_command(device.device_id,
                                                 InternalInstruction.PREDEFINED_IDLE,
                                                 None)
-    
-    def _countdown(self, device: Device, expr: AnyStr):
-        self._handler.device_internal_command(device.device_id,
-                                                InternalInstruction.PREDEFINED_COUNTDOWN,
-                                                expr)
 
     def _device_data_format_cali(self, device: Device, expr: str, cali: bytes = None):
         if cali is None:

python/biopro/devlib/device.py

@@ -689,13 +689,11 @@ 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, cls.TYP_ALL):
+        if ins_type not in (cls.TYP_RIS, cls.TYP_VIS, cls.TYP_CIS, cls.TYP_IIS):
             raise ValueError('unknown instruction type : ' + str(ins_type))
 
     @classmethod
@@ -706,8 +704,6 @@ class DeviceInstruction:
             return cls.TYP_VIS
         elif ins_type == 'CIS':
             return cls.TYP_CIS
-        elif ins_type == 'ALL':
-            return cls.TYP_ALL
         else:
             raise RuntimeError('unknown instruction type : ' + ins_type)
 

python/biopro/devlib/domain.py

@@ -120,9 +120,6 @@ class ParameterDomain(JsonSerialize, metaclass=abc.ABCMeta):
         elif json == 'int':
             return ParameterIntDomain
 
-        elif json == 'float':
-            return ParameterFloatDomain
-
         elif json == 'property':
             return ParameterPropertyDomain
 
@@ -294,25 +291,6 @@ 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 """
@@ -323,7 +301,7 @@ class ParameterValueDomain(ParameterDomain, metaclass=abc.ABCMeta):
         if initial is None:
             return self.range[0]
         else:
-            initial = initial
+            initial = int(initial)
             f, t = self.range
 
             if f <= initial < t:
@@ -764,7 +742,6 @@ 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
@@ -803,11 +780,8 @@ class ParameterListDomain(ParameterCollectionDomain):
 
             if isinstance(v, int):
                 v = [v]
-            target[len(v):] = []
-            if isinstance(d, ParameterFloatDomainType):
-                target[i] = [float(i) for i in v]
-            else:
-                target[i] = v
+
+            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,7 +880,8 @@ class WhenExpression(ComplexExpression[T]):
 
     def value(self, context: Scope) -> Union[str, T]:
         value = super().value(context)
-        key = str(int(value))
+
+        key = str(value)
 
         if key in self._when:
             return self._when[key].value(context.child(VALUE=value))

python/biopro/devlib/header.py

@@ -5,13 +5,6 @@ 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
@@ -451,12 +444,6 @@ 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,5 +1,4 @@
 import re
-import struct
 from random import randint
 from time import sleep
 from typing import Sequence, Tuple
@@ -285,7 +284,6 @@ class InternalInstruction(SingleInstruction):
     PREDEFINED_CDR = '_cdr'
     PREDEFINED_DISABLE_CACHE = '_disable_cache'
     PREDEFINED_IDLE = '_idle'
-    PREDEFINED_COUNTDOWN = '_countdown'
 
     PREDEFINED = (
         PREDEFINED_SLEEP,
@@ -298,7 +296,6 @@ class InternalInstruction(SingleInstruction):
         PREDEFINED_CDR,
         PREDEFINED_DISABLE_CACHE,
         PREDEFINED_IDLE,
-        PREDEFINED_COUNTDOWN
     )
 
     __slots__ = ('_expr', '_para')
@@ -378,7 +375,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.
@@ -591,7 +588,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**
@@ -685,7 +682,7 @@ class InstructionContent(JsonSerialize):
 
             return ins_type(width, expr, **ins_argv, comment=comment)
 
-# tag1
+
 class InstructionDataContent(InstructionContent):
     """
     **json format**
@@ -746,7 +743,6 @@ 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()
             
@@ -754,33 +750,24 @@ class InstructionDataContent(InstructionContent):
             value = 1
         elif self.value(context) == 'false':
             value = 0
-        elif isinstance(self.value(context), list):
-            value = self.value(context)
         else:
-            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)
+            value = int(self.value(context))
 
         if self._width.bytes_unit:
             if self._width.size == 1:
                 buffer.append(value)
 
             else:
-                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
+                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 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:
@@ -1125,7 +1112,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,7 +359,6 @@ 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()
 
@@ -523,7 +522,6 @@ 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)
@@ -1130,21 +1128,13 @@ 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
-                if isinstance(value, str):
-                    if "." in value:
-                        value = float(value)
-                    else:
-                        value = int(value)
+                value = int(value)
             except ValueError as e:
                 # value float
                 self._parameter.set_parameter(name, value)

python/biopro/devlib/parameter.py

@@ -433,7 +433,6 @@ 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
@@ -618,7 +617,6 @@ class ParameterInfo(JsonSerialize):
             return []
 
         elif isinstance(self._value, ComplexExpression):
-            print('cast_value_dependency', self._value.dependency)
             return self._value.dependency
 
         else:

python/biopro/recording/file.py

@@ -866,11 +866,13 @@ class RecordingFile:
 
     # def write(self, content: Union[bytes, RecordingData]) -> int:
     def write(self, content: str, channels: list) -> int:
-        if not isinstance(content, str):
-            raise RuntimeError('wrong data format : ' + repr(self._data_format))
+        # print('count_size', content, channels)
+        # if not isinstance(content, str):
+        #     raise RuntimeError('wrong data format : ' + repr(self._data_format))
 
         self._meta_file.update_channels(channels)
         sz = sys.getsizeof(content)
+        # print('sz', sz)
         self._size += sz
         return sz
 
@@ -1154,15 +1156,15 @@ class RecordingFileWriter:
                     self._send_data[ch] = False
 
                 if self._recording_file_dict[ch]._status:
-                    _data = ' '.join(self._data_db[ch])
-                    self._raw_save['data'][ch] = _data
+                    _data = self._data_db[ch]
+                    self._raw_save['data'][ch] = copy(_data)
                     self._raw_save['id'][ch] = self._recording_file_dict[ch]._id_db
                     self._recording_file_dict[ch].write(_data, self._channel_list)
                     self._recording_file_dict[ch].close(self._time_now)
                     self._meta._size += self._recording_file_dict[ch]._size
             # self._data_db.clear()
             if self._database is not None:
-                self._database.put_queue(['data_raw_recording', self._raw_save['id'], self._channel_list, self._raw_save['data'], self._id_db_save])
+                self._database.put_queue(['data_raw_recording_bytea', self._raw_save['id'], self._channel_list, self._raw_save['data'], self._id_db_save])
                 # self._database.put_queue(['data_raw_recording', self._raw_save['id'], self._channel_list, self._raw_save['data']])
             self._recording_file_dict.clear()
         for scale in self._mini_scale_list:
@@ -1324,8 +1326,8 @@ class RecordingFileWriter:
                                 #     self._data_mini_ch[c]['10000']['random'].append( str(self._data_mini_ch[c]['1000']['random'][random.randint(-10,-1)]) )
                                 #     self._data_mini_ch[c]['1000']['dec'] = int(len(self._data_mini_ch[c]['1000']['mean']) / 10)
                     # add normal data
-                    self._data_db[c].append(str(int(t)))
-                    self._data_db[c].append(str(v))
+                    self._data_db[c].append(int(t))
+                    self._data_db[c].append(v)
                     self._time_now = int(t)
         return
     
@@ -1417,9 +1419,9 @@ class RecordingFileWriter:
                 for ch in self._data_db.keys():
                     if self._time_now - self._time[ch] > 5000000:
                         if self._recording_file_dict[ch]._status:
-                            _data = ' '.join(self._data_db[ch])
+                            _data = self._data_db[ch]
                             write_sz = self._recording_file_dict[ch].write(_data, self._channel_list)
-                            self._raw_save['data'][ch] = _data
+                            self._raw_save['data'][ch] = copy(_data)
                             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
@@ -1446,9 +1448,15 @@ class RecordingFileWriter:
 
                 if data_save is True:
                     if self._database is not None:
-                        recording_input = ['data_raw_recording_new', copy(self._raw_save['id']), copy(self._channel_list), copy(self._raw_save['data']), copy(self._raw_save['end_time']), copy(self._raw_save['size'])]
+                        recording_input = ['data_raw_recording_bytea', copy(self._raw_save['id']), copy(self._channel_list), copy(self._raw_save['data']), copy(self._raw_save['end_time']), copy(self._raw_save['size'])]
                         self._database.put_queue(recording_input)
                         self._meta.update_subfile_time_size(database = self._database)
+
+                # if data_save is True:
+                #     if self._database is not None:
+                #         recording_input = ['data_raw_recording_new', copy(self._raw_save['id']), copy(self._channel_list), copy(self._raw_save['data']), copy(self._raw_save['end_time']), copy(self._raw_save['size'])]
+                #         self._database.put_queue(recording_input)
+                        
                 if mini_save is True:
                     if self._database is not None:
                         for scale in self._mini_scale_list:

python/biopro/server/database.py

@@ -70,7 +70,7 @@ class DataBaseProcess(Process):
         self._data_raw_create_sql_str = None
         self._data_raw_update_sql_str = None
         self._data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s) where id = %s'
-        self._new_data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s), end_time=%s, size=%s where id = %s'
+        self._new_data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET bytea_data = bytea_data || %s, end_time=%s, size=%s where id = %s'
         self._data_mini_recording_sql_str = 'UPDATE "public"."%s_recording_data_minis" SET data_mean = concat(data_mean, %s) where id = %s'
 
     @property
@@ -325,6 +325,7 @@ class DataBaseProcess(Process):
 
     # @calculate_time()
     def data_raw_create(self, _data_dict, _channel_list, device_id):
+        print('data_raw_create', _data_dict, _channel_list, device_id)
         if self._data_raw_create_sql_str == None:
             sql_str_list = []
             key_list = _data_dict[_channel_list[0]].keys()
@@ -582,3 +583,17 @@ class DataBaseProcess(Process):
             self._queue_ds[int(device_id)].put(['project_id', int(sql_cursor.fetchone()[0])])
             self._psql_conn.commit()
             sql_cursor.close()
+    
+    def data_raw_recording_bytea(self, _id_dict, _channel_list, _data_dict, _end_time_dict, _size_dict):
+        # print('data_raw_recording_bytea', _id_dict, _channel_list, _data_dict, _end_time_dict, _size_dict)
+        try:
+            para_list = []
+            for _channel in _channel_list:
+                bytes_data = b''.join([int.to_bytes(i, 8, 'big', signed=True) for i in _data_dict[_channel]])
+                para_list.append([_channel, bytes_data, _end_time_dict[_channel], _size_dict[_channel], _id_dict[_channel]])
+            with self._psql_conn as conn:
+                with conn.cursor() as sql_cursor:
+                    execute_batch(sql_cursor, self._new_data_raw_recording_sql_str, para_list)
+        except psycopg2.Error as e:
+            print('recording error', e)
+        return None

python/biopro/server/main.py

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

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

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

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

@@ -1,12 +1,12 @@
 {
-  "name": "Elite_EDC_1.5r2",
+  "name": "Elite_EDC_1.5re",
   "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": 8
+    "minor_version_number": 7
   },
   "constant": {
     "TIME_MAX": 100000,

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

@@ -31,7 +31,7 @@
   },
   "parameters": {
     "USED": {
-      "initial": [false, false, false, false, false, false, false, false],
+      "initial": [true, true, true, false, false, false, false, false],
       "domain": {
         "list": [
           0, 2
@@ -40,7 +40,7 @@
       "value": "VALUE"
     },
     "T_EARLY": {
-      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "initial": [5000, 5000, 5000, 0, 0, 0, 0, 0],
       "domain": {
         "list": [
           0, 86400000
@@ -49,7 +49,7 @@
       "value": "VALUE"
     },
     "V_EARLY": {
-      "initial": [false, false, false, false, false, false, false, false],
+      "initial": [true, false, false, false, false, false, false, false],
       "domain": {
         "list": [
           0, 2
@@ -58,7 +58,7 @@
       "value": "VALUE"
     },
     "CYCLE": {
-      "initial": [1, 1, 1, 1, 1, 1, 1, 1],
+      "initial": [10, 10, 10, 1, 1, 1, 1, 1],
       "domain": {
         "list": [
           0, 65535
@@ -67,7 +67,7 @@
       "value": "VALUE"
     },
     "T_MID0": {
-      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "initial": [30000, 30000, 30000, 0, 0, 0, 0, 0],
       "domain": {
         "list": [
           0, 86400000
@@ -76,7 +76,7 @@
       "value": "VALUE"
     },
     "T_MID1": {
-      "initial": [0, 0, 0, 0, 0, 0, 0, 0],
+      "initial": [30000, 30000, 30000, 0, 0, 0, 0, 0],
       "domain": {
         "list": [
           0, 86400000
@@ -103,7 +103,7 @@
       "value": "VALUE"
     },
     "V_MID0": {
-      "initial": [false, false, false, false, false, false, false, false],
+      "initial": [true, true, false, false, false, false, false, false],
       "domain": {
         "list": [
           0, 2
@@ -112,7 +112,7 @@
       "value": "VALUE"
     },
     "V_MID1": {
-      "initial": [false, false, false, false, false, false, false, false],
+      "initial": [false, false, true, false, false, false, false, false],
       "domain": {
         "list": [
           0, 2
@@ -337,6 +337,8 @@
         "Analog Current Control (ACC)",
         "Idle",
         "Dev Mode",
+        "Protocal 1",
+        "Protocal 2",
         "Trigger"
       ]
     },
@@ -399,7 +401,9 @@
         "expression": "MODE",
         "when": {
           "0": "curve_acc",
-          "3": "trig_timer_mode"
+          "3": "trig_timer_mode",
+          "4": "trig_timer_mode",
+          "5": "trig_timer_mode"
         }
       },
       "_sync(True)",

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

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

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

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

update_db_package.sh

@@ -35,4 +35,10 @@ sudo su -c "psql -d postgres -c \"ALTER TABLE devices ALTER COLUMN calibration D
 sudo su -c "psql -d postgres -c \"ALTER TABLE devices ALTER COLUMN calibration TYPE bytea USING calibration::bytea;\"" postgres
 
 # add column project in recording_data_metas
-sudo su -c "psql -d postgres -c \"ALTER TABLE devices ADD COLUMN IF NOT EXISTS calibration_version Int4 DEFAULT -1;\"" postgres
+sudo su -c "psql -d postgres -c \"ALTER TABLE devices ADD COLUMN IF NOT EXISTS calibration_version Int4 DEFAULT -1;\"" postgres
+
+# add column bytea_data column in 0-32_recording_data_raws
+for i in {0..32}
+do
+  sudo su -c "psql -d postgres -c \"ALTER TABLE \\\"${i}_recording_data_raws\\\" ADD COLUMN IF NOT EXISTS bytea_data BYTEA DEFAULT ''::bytea;\"" postgres
+done