[update] update cali value

python/biopro/controller.py

@@ -1585,6 +1585,12 @@ class ControlAPI(metaclass=Router):
     
     def stop_project(self, project) -> bool:
         raise NotImplementedError()
+    
+    def set_project(self, project, content) -> bool:
+        raise NotImplementedError()
+    
+    def show_device_data(self, device) -> bool:
+        raise NotImplementedError()
 
 # noinspection PyAbstractClass
 class ControlClient(SocketClient, ControlAPI, metaclass=SocketClientMacro(ControlAPI)):

python/biopro/data.py

@@ -130,6 +130,14 @@ class DataAPI(metaclass=abc.ABCMeta):
     def hardware_test(self) -> JSON_OBJECT:
         """"""
         pass
+    
+    @abc.abstractmethod
+    def show_data(self, device: Union[int, Device]):
+        """show device data
+
+        :param device: device ID
+        """
+        pass
 
 
 # noinspection PyAbstractClass
@@ -191,6 +199,9 @@ 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 show_data(self, device: int):
+        self.send_command('show_data', device)
 
     @staticmethod
     def _to_device_id(*device: Union[int, Device]) -> Tuple[int, ...]:

python/biopro/device/device_cc2650.py

@@ -662,7 +662,7 @@ class CC2650Device(Device):
         elif device_type == 'EISZeroOne':
             i = 0
             request_times = 0
-            while i < 7:
+            while i < 13:
                 try:
                     # send
                     code = self._encode_instruction(DeviceInstruction.TYP_CIS, DeviceInstruction.CIS_CALI, i)

python/biopro/devlib/data.py

@@ -1,13 +1,12 @@
 import abc
 import struct
 import math
+import numpy
 from typing import Optional, TypeVar, Generic, Tuple, Dict, List, AnyStr
 from datetime import datetime
 
 from biopro.recording import RecordingData, RecordingFileDataFormat
 
-import numpy as np
-
 # from biopro.util.console import hex_line
 
 T = TypeVar('T')
@@ -855,7 +854,7 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
 
     __slots__ = ('_message', '_cycle_number', '_start_return_data', '_time_stamp',
                  '_total_time_stamp', '_mode', '_cycle_start_time',
-                 '_mode_stop')
+                 '_mode_stop', '_show_data')
 
     def __init__(self):
         super().__init__()
@@ -870,6 +869,8 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         self._mode = 0
         self._cycle_start_time = []
 
+        self._show_data = False
+
     @property
     def name(self) -> str:
         return self.NAME
@@ -887,17 +888,17 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         mem_cnt = data[1]
         time_stamp: float = struct.unpack('<I', data[4:8])[0]  # unit: ms 0x18030000
         current = struct.unpack('<i', data[8:12])[0]  # unit: nA
-        ch2 = struct.unpack('<i', data[12:16])[0]  # unit: uV
+        voltage = struct.unpack('<i', data[12:16])[0]  # unit: uV
         impedance = struct.unpack('<i', data[16:20])[0]  # unit: mOm
-        if self._mode == 16:
-            voltage = impedance - ch2
-        else:
-            voltage = ch2
 
         cycle_number = struct.unpack('<H', data[20:22])[0]
         finish_mode_falg = data[22]
         battery = struct.unpack('<i', data[23:27])[0]
         elite_notify_times = data[27]
+        notify_one = struct.unpack('<i', data[28:32])[0]
+        notify_two = struct.unpack('<i', data[32:36])[0]
+        notify_three = struct.unpack('<i', data[36:40])[0]
+        # self._show_data = True
 
         mem_wrong_information = struct.unpack('<i', data[43:47])[0] # mem_wrong_information = green retry, green wrong, red retry, red wrong
         ram_num = data[47]
@@ -921,9 +922,11 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
                 print("error timeStamp full data:", list(data), datetime.now(), '\n')
                 return None
             else:
-                # print('|', time_stamp, '|', delta, '|', int(time_stamp * 1000 / 2),
-                #       '|', current, '|', voltage, '|', impedance,
-                #       '|', cycle_number, '|', finishMode, '@', str(self.device))
+                if self._show_data:
+                    print('|', time_stamp, '|', delta, '|', int(time_stamp * 1000 / 2),
+                        '|', current, '|', voltage, '|', impedance, '|', cycle_number, 
+                        '|', notify_one, '|', notify_two, '|', notify_three, 
+                        '|', finishMode, '@', str(self.device))
 
                 # print('|', '{:10}'.format(time_stamp),
                 #       '|', '{:4}'.format(delta),
@@ -952,6 +955,9 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         ret.append_data(1, voltage)
         ret.append_data(2, impedance)
         ret.append_data(3, cycle_number)
+        ret.append_data(4, notify_one)
+        ret.append_data(5, notify_two)
+        ret.append_data(6, notify_three)
         # ret.append_data(4, battery)
         # ret.append_data(5, elite_notify_times)
         # ret.append_data(6, mem_cnt)
@@ -1341,7 +1347,7 @@ class EISZeroOneDataDecoder(RecDataDecoder):
                  '_total_time_stamp', '_mode', '_cycle_start_time',
                  '_mode_stop', '_last_time_stamp', '_last_delta', '_cali_coeff',
                  'cali_coeff', '_ac_amp', '_mode', '_freq_start', '_freq_stop',
-                 '_freq_direction', '_last_phase', '_first_phase_flag')
+                 '_freq_direction', '_last_phase', '_first_phase_flag', '_show_data')
 
     def __init__(self, cali_coeff: bytes = None):
         super().__init__()
@@ -1365,6 +1371,8 @@ class EISZeroOneDataDecoder(RecDataDecoder):
         self._cali_coeff: Optional[bytes] = None
         self.cali_coeff: Optional[List[Tuple[int, int]]] = None
 
+        self._show_data = False
+
         if cali_coeff is not None:
             self._cali_coeff = cali_coeff
             self.cali_coeff = self._decode_cali_coeff(cali_coeff)
@@ -1373,12 +1381,27 @@ class EISZeroOneDataDecoder(RecDataDecoder):
     def _decode_cali_coeff(cali_coeff: bytes) -> Optional[List[Tuple[int, int]]]:
         if cali_coeff != b'':
             cali_table = []
-            phase_para_a = []
-            phase_para_b = []
             hsrtia_a = []
             hsrtia_b = []
             hsrtia_c = []
             hsrtia_d = []
+            phase_coeff = []
+            phase_offset = []
+            
+            # phase_coeff = [[0]*4 for i in range(4)]
+            # phase_offset = [[0]*4 for i in range(4)]
+
+            phase_coeff = numpy.zeros([4, 4], dtype = int)
+            phase_offset = numpy.zeros([4, 4], dtype = int)  
+
+            ########################################
+            # phase_coeff
+            # [[gain0, g1, g2, g3] ----->最高頻
+            #  [gain0, g1, g2, g3] ----->中頻
+            #  [gain0, g1, g2, g3] ----->低頻
+            #  [gain0, g1, g2, g3] ----->最低頻
+            # ]
+            #######################################
 
             # print('cali_coeff', cali_coeff)
             cutoff_freq = struct.unpack('>I', cali_coeff[1:5])[0] * 100     #4
@@ -1389,15 +1412,19 @@ class EISZeroOneDataDecoder(RecDataDecoder):
             # hsrtia_160k = struct.unpack('>I', cali_coeff[8:12])[0]         #4
 
             index = 20
-            for i in range(index, index+16, 8):
-                phase_para_a.append(struct.unpack('>i', cali_coeff[i+1:i+5])[0])
-                phase_para_b.append(struct.unpack('>i', cali_coeff[i+5:i+9])[0])
-
+            g = 0
+            phase_coeff[0][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[0][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[1][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[1][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
             index = 40
-            for i in range(index, index+16, 8):
-                phase_para_a.append(struct.unpack('>i', cali_coeff[i+1:i+5])[0])
-                phase_para_b.append(struct.unpack('>i', cali_coeff[i+5:i+9])[0]) 
-
+            g = 0
+            phase_coeff[2][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[2][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[3][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[3][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
             #Lv[0] 160k
             index = 60
             hsrtia_a.append(struct.unpack('>i', cali_coeff[index+1:index+5])[0]/1e8)
@@ -1422,18 +1449,58 @@ class EISZeroOneDataDecoder(RecDataDecoder):
             hsrtia_b.append(struct.unpack('>i', cali_coeff[index+5:index+9])[0]/1e8)
             hsrtia_c.append(struct.unpack('>i', cali_coeff[index+9:index+13])[0]/1e4)
 
-            # hsrtia_a.append(struct.unpack('>I', cali_coeff[index+1:index+5])[0])
-            # hsrtia_b.append(struct.unpack('>I', cali_coeff[index+5:index+9])[0]/1e6)
-            # hsrtia_c.append(struct.unpack('>I', cali_coeff[index+9:index+13])[0]/1e5)
+            index = 140
+            g = 1
+            phase_coeff[0][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[0][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[1][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[1][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
+            index = 160
+            g = 1
+            phase_coeff[2][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[2][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[3][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[3][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
+            index = 180
+            g = 2
+            phase_coeff[0][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[0][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[1][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[1][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
+            index = 200
+            g = 2
+            phase_coeff[2][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[2][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[3][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[3][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
+            index = 220
+            g = 3
+            phase_coeff[0][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[0][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[1][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[1][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
+            
+            index = 240
+            g = 3
+            phase_coeff[2][g] = struct.unpack('>i', cali_coeff[index+1:index+5])[0]
+            phase_offset[2][g] = struct.unpack('>i', cali_coeff[index+5:index+9])[0]
+            phase_coeff[3][g] = struct.unpack('>i', cali_coeff[index+9:index+13])[0]
+            phase_offset[3][g] = struct.unpack('>i', cali_coeff[index+13:index+17])[0]
 
             # print('cutoff_freq', cutoff_freq)
             # print('hsrtia_a', hsrtia_a)
             # print('hsrtia_b', hsrtia_b)
             # print('hsrtia_c', hsrtia_c)
-            # print('phase_para_a', phase_para_a)
-            # print('phase_para_b', phase_para_b)
+            # print('phase_coeff')
+            # print(phase_coeff)
+            # print('phase_offset')
+            # print(phase_offset)
 
-            cali_table.append((cutoff_freq, phase_para_a, phase_para_b, hsrtia_a, hsrtia_b, hsrtia_c, hsrtia_d))
+            cali_table.append((cutoff_freq, phase_coeff, phase_offset, hsrtia_a, hsrtia_b, hsrtia_c, hsrtia_d))
 
             return cali_table
         else:
@@ -1483,13 +1550,12 @@ class EISZeroOneDataDecoder(RecDataDecoder):
                 return None
             else:
                 if self.cali_coeff is not None and self._mode == 0:
-                    phase_para_a = []
-                    phase_para_b = []
                     hsrtia_a = []
                     hsrtia_b = []
                     hsrtia_c = []
                     hsrtia_d = []
-                    cutoff_freq, phase_para_a, phase_para_b, hsrtia_a, hsrtia_b, hsrtia_c, hsrtia_d = self.cali_coeff[0]
+                    cutoff_freq, phase_coeff, phase_offset, hsrtia_a, hsrtia_b, hsrtia_c, hsrtia_d = self.cali_coeff[0]
+
                     voltage_amp = round(self._ac_amp * 800 / 2047) # use UI value
                     if (self._freq_start > self._freq_stop):
                         self._freq_direction = 0
@@ -1500,6 +1566,7 @@ class EISZeroOneDataDecoder(RecDataDecoder):
                     img = ch1
                     real = ch2
                     freq = ch3
+                    fre_idx = 0
 
                     voltage_mag = math.sqrt(img ** 2 + real ** 2) * (1 + freq ** 2 / cutoff_freq ** 2)
 
@@ -1527,56 +1594,56 @@ class EISZeroOneDataDecoder(RecDataDecoder):
                         raw_phase = math.atan(img / real) * 180 / math.pi + 180
 
                     if (freq >= 1000000): # 10000 Hz
-                        i = 0
+                        fre_idx = 0
                     elif (freq >= 10000): # 100 Hz
-                        i = 1
+                        fre_idx = 1
                     elif (freq >= 1000): # 10 Hz
-                        i = 2
+                        fre_idx = 2
                     elif (freq >= 1): # 0.01 Hz
-                        i = 3
+                        fre_idx = 3
                     
-                    ideal_raw_phase = phase_para_a[i] /1e10 * freq + phase_para_b[i] / 1e6
+                    ideal_raw_phase = phase_coeff[fre_idx][gain] /1e10 * freq + phase_offset[fre_idx][gain] / 1e6
 
                     phase = raw_phase - ideal_raw_phase
 
                     if (self._first_phase_flag):
                         self._last_phase = phase
                         self._first_phase_flag = 0
-                    elif (abs(phase - self._last_phase) >= 200):
+                    elif (abs(phase - self._last_phase) >= 90):
                         phase -= 360
                         self._last_phase = phase
 
                     imag_after_cal = impedance * math.sin(round(phase) * math.pi / 180)
                     real_after_cal = impedance * math.cos(round(phase) * math.pi / 180)
 
-
-                if (self._mode == 0):
-                    # print('|', '{:10}'.format(time_stamp),
-                    #     '|', '{:5}'.format(delta),
-                    #     '|', '{:6}'.format(ch1),
-                    #     '|', '{:6}'.format(ch2),
-                    #     '|', '{:8}'.format(ch3 / 100),
-                    #     '|', '{:6}'.format(round(voltage_mag)),
-                    #     '|', '{:5}'.format(int(imag_after_cal)),
-                    #     '|', '{:5}'.format(int(real_after_cal)),
-                    #     '|', '{:5}'.format(round(impedance)),
-                    #     '|', '{:5}'.format(round(phase, 1)),
-                    #     '|', '{:5}'.format(round(current, 3)),
-                    #     '|', '{:1}'.format(gain),
-                    #     '|', '{:1}'.format(finishMode),
-                    #     '@', str(self.device), '|')
-                    pass
-                else:
-                    # print('|', '{:10}'.format(time_stamp),
-                    #     '|', '{:5}'.format(delta),
-                    #     '|', '{:5}'.format(ch1),
-                    #     '|', '{:5}'.format(ch2),
-                    #     '|', '{:5}'.format(ch3),
-                    #     '|', '{:5}'.format(cycle_number),
-                    #     '|', '{:1}'.format(gain),
-                    #     '|', '{:1}'.format(finishMode),
-                    #     '@', str(self.device), '|')
-                    pass
+                if self._show_data:
+                    if (self._mode == 0):
+                        print('|', '{:10}'.format(time_stamp),
+                            '|', '{:5}'.format(delta),
+                            '|', '{:6}'.format(ch1),
+                            '|', '{:6}'.format(ch2),
+                            '|', '{:8}'.format(ch3 / 100),
+                            '|', '{:6}'.format(round(voltage_mag)),
+                            '|', '{:5}'.format(int(imag_after_cal)),
+                            '|', '{:5}'.format(int(real_after_cal)),
+                            '|', '{:5}'.format(round(impedance)),
+                            '|', '{:5}'.format(round(phase, 1)),
+                            '|', '{:5}'.format(round(current, 3)),
+                            '|', '{:1}'.format(gain),
+                            '|', '{:1}'.format(finishMode),
+                            '@', str(self.device), '|')
+                        pass
+                    else:
+                        print('|', '{:10}'.format(time_stamp),
+                            '|', '{:5}'.format(delta),
+                            '|', '{:5}'.format(ch1),
+                            '|', '{:5}'.format(ch2),
+                            '|', '{:5}'.format(ch3),
+                            '|', '{:5}'.format(cycle_number),
+                            '|', '{:1}'.format(gain),
+                            '|', '{:1}'.format(finishMode),
+                            '@', str(self.device), '|')
+                        pass
 
         if finishMode == True:
             print("finishMode full data:", list(data), datetime.now())

python/biopro/devlib/device.py

@@ -651,8 +651,6 @@ class DeviceInstruction:
     VIS_DEVICE_DONE = 0x20
     """identify device done"""
 
-    VIS_CC_ZERO = 0x40
-
     VIS_STI = 0xC0
     """stimulation on virtual instruction"""
 
@@ -726,7 +724,6 @@ class DeviceCommonInstruction:
     STOP_STIMULATE = "stop_stimulate"
     VIS_DEVICE_DETECT = 'VIS_DEVICE_DETECT'
     VIS_DEVICE_DONE = 'VIS_DEVICE_DONE'
-    VIS_CC_ZERO = 'VIS_CC_ZERO'
     CIS_VOLT = 'CIS_VOLT'
     CIS_VERSION = 'CIS_VERSION'
 
@@ -750,8 +747,6 @@ class DeviceCommonInstruction:
             return 'VIS_DEVICE_DETECT',
         elif instruction == cls.VIS_DEVICE_DONE:
             return 'VIS_DEVICE_DONE',
-        elif instruction == cls.VIS_CC_ZERO:
-            return 'VIS_CC_ZERO',
         elif instruction == cls.RECORD:
             return 'VIS_STARTR',
         elif instruction == cls.RECORD_ALL:

python/biopro/devlib/library.py

@@ -1105,6 +1105,8 @@ class CompletedDevice(Device):
         return self._configuration.get_parameter(name, False)
     
     def set_multi_parameters(self, parameter):
+        if len(parameter) == 0:
+            return
         for (name, value) in parameter[0].items():
             if name != 'target':
                 self.set_parameter(name, value)
@@ -1128,6 +1130,11 @@ class CompletedDevice(Device):
                 self._parameter.set_parameter(name, value)
                 # raise RuntimeError('illegal parameter value : ' + value) from e
             else:
+                if name == 'MODE':
+                    if self.library_name.startswith('Elite_EDC'):
+                        self.set_parameter('CTRL_HIGH_Z_15', self.get_parameter('HIGHZ_TABLE')[value])
+                        self.set_parameter('TIME_DURATION', 0)
+
                 self._parameter.set_parameter(name, value)
 
         on_change = info.on_change

python/biopro/impl/ext_mem.py

@@ -35,7 +35,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                  '_pin_ram_sel_value', '_pin_mem_sel_value', '_pin_mem_req_value',
                  '_read_green_times','_read_red_times',
                  '_elite_data_len', '_mem_header_len', '_mem_tailer_len', '_single_data_len',
-                 '_head_wrong_cnt')
+                 '_head_wrong_cnt', '_pin_busy_value')
 
     def __init__(self,
                  select: Selector,
@@ -50,11 +50,11 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         self._single_data_len = self._elite_data_len + self._mem_header_len + self._mem_tailer_len
 
         # buffer
-        self._tx_buffer_header = [0] * 19
+        self._tx_buffer_header = [0] * 64
         self._tx_buffer_data = [0] * (self._single_data_len * 10 + 3)
 
         # memory control pin
-        self.pin_busy = OutputPin.get_used(P3Pin.MEM_BZY, True)
+        self.pin_busy: Optional[InputPin] = InputPin.get_used(P3Pin.MEM_BZY)
         self.pin_mem_req = OutputPin.get_used(P3Pin.MEM_REQ, False)
         self.pin_mem_sel = OutputPin.get_used(P3Pin.MEM_RST, True) # MEM_RST -> actually which memory board is assign
         self.pin_ram_sel: Optional[InputPin] = InputPin.get_used(P3Pin.MEM_SEL) # MEM_SEL -> actually is RAM_SEL, which RAM is assign
@@ -62,6 +62,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         self._pin_ram_sel_value = [bool(self.pin_ram_sel) for _ in range(Selector.SIZE)]
         self._pin_mem_sel_value = [bool(self.pin_mem_sel) for _ in range(Selector.SIZE)]
         self._pin_mem_req_value = [bool(self.pin_mem_req) for _ in range(Selector.SIZE)]
+        self._pin_busy_value = [bool(self.pin_busy) for _ in range(Selector.SIZE)]
 
         self._read_green_times = 0
         self._read_red_times = 0
@@ -98,6 +99,14 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             self._pin_ram_sel_value[channel] = True
         return self._pin_ram_sel_value[channel]
 
+    def get_pin_busy(self):
+        channel = self.select
+        if self.pin_busy.input() == 0:
+            self._pin_busy_value[channel] = False
+        else:
+            self._pin_busy_value[channel] = True
+        return self._pin_busy_value[channel]
+
     @property
     def select(self) -> int:
         return self._selector.channel
@@ -216,7 +225,9 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         return
 
     def recv_memory(self, device: int) -> Optional[bytes]:
-        self.pin_busy.output(False)
+        # self.pin_busy.output(False)
+
+        print('mem_req==ram_sel,[', self._pin_mem_req_value[device], ',', self._pin_ram_sel_value[device], ']')
 
         rx = []
 
@@ -300,6 +311,9 @@ 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)
@@ -415,9 +429,9 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         except BaseException as e:
             print(e)
 
-        finally:
-            # print("\n")
-            self.pin_busy.output(True)
+        # finally:
+        #     # print("\n")
+        #     self.pin_busy.output(True)
 
         return bytes(rx)
 

python/biopro/project/action.py

@@ -24,3 +24,11 @@ class Action():
     @property
     def condition(self):
         return self._condition
+    
+    def as_json(self):
+        return {
+            'id': self._id,
+            'type': self._type,
+            'target': self._target,
+            'condition': self._condition
+        }

python/biopro/project/condition.py

@@ -56,7 +56,8 @@ class Condition():
         return getattr(self, self.type)(**kwargs)
        
     def absolute_time(self, **kwargs):
-        now = int(time())
+        # now = int(time())
+        now = round(time(), 1)
         time_condition = round(self.datetime_to_timestamp(self.str_to_datetime(self._value)))
 
         return self.compareWith(self.comparsion, now, time_condition)
@@ -65,8 +66,9 @@ class Condition():
         project_start_time = kwargs['project_start_time']
         delay_time = kwargs['delay_time']
 
-        time_diff = int(time() - project_start_time - delay_time)
-        return self.compareWith(self.comparsion, time_diff, int(self._value))
+        # time_diff = int(time() - project_start_time - delay_time)
+        time_diff = round(time() - project_start_time - delay_time, 1)
+        return self.compareWith(self.comparsion, time_diff, round(int(self._value), 1))
     
     def after_task_run(self, **kwargs):
         # print('relative_time_from_task', kwargs,kwargs['task_start_time'],kwargs['delay_time'])
@@ -75,22 +77,60 @@ class Condition():
         task_start_time = kwargs['task_start_time'][-1]
         delay_time = kwargs['delay_time']
 
-        time_diff = int(time() - task_start_time - delay_time)
-        # print('time_diff',  time_diff)
-        return self.compareWith(self.comparsion, time_diff, int(self._value))
+        time_diff = round(time() - task_start_time - delay_time, 1)
+        return self.compareWith(self.comparsion, time_diff, round(int(self._value), 1))
     
     def device(self, **kwargs):
         print('device')
     
-    def previous_task_done(self, **kwargs):
+    """ def previous_task_done(self, **kwargs):
         running_task = kwargs['running_task']
         if running_task.status == 2 and self._active == False:
             self._active = True
             return True
+        return False """
+
+    def previous_task_done(self, **kwargs):
+        running_task = kwargs['running_task']
+        self_task = kwargs['self_task']
+        # if running_task != None and self_task != None:
+        # print('\nprevious_task_done: ', running_task.status, ' ', self._active)
+        if running_task != self_task:
+            if running_task == None:
+                return True
+            if running_task.status == 2 and self._active == False:
+                # self._active = True
+                return True
         return False
 
+    def until_button_trigger(self, **kwargs):
+        running_task = kwargs['running_task']
+        if running_task != None:
+            if running_task.button_trigger == True:
+                running_task.button_trigger = False
+                return True
+        return False 
+    
+    """ def cycle(self, **kwargs):
+        running_task = kwargs['running_task']
+        self_task = kwargs['self_task']
+        if running_task != self_task:
+            if running_task.status == 2 and self._active == False:
+                # self._active = True
+                return True
+        return False """
+
     def str_to_datetime(self, time_str):
         return datetime.strptime(time_str,'%Y-%m-%dT%H:%M')
 
     def datetime_to_timestamp(self, date):
-        return datetime.timestamp(date)
+        return datetime.timestamp(date)
+
+    def as_json(self):
+        return {
+            'id': self._id,
+            'type': self._type,
+            'comparsion': self._comparsion,
+            'value': self._value,
+            'active': self._active
+        }

python/biopro/project/instruction.py

@@ -22,6 +22,7 @@ class Instruction():
     
         self._start_instruction = list(map(lambda ins: self._instruction_set[ins] ,['set_file_name', 'set_parent', 'set_parameter', 'call_instruction']))
         self._stop_instruction = list(map(lambda ins: self._instruction_set[ins] ,['call_instruction']))
+        self._idle_instruction = []
     
     @property
     def start(self) -> list:
@@ -29,4 +30,8 @@ class Instruction():
     
     @property
     def stop(self) -> list:
-        return self._stop_instruction
+        return self._stop_instruction
+
+    @property
+    def idle(self) -> list:
+        return self.idle_instruction

python/biopro/project/project.py

@@ -24,7 +24,7 @@ class Project(threading.Thread):
     self._project = project
     self._device_manager = device_manager
     self._mqtt_thread = mqttThread
-    self._time_interval = 1
+    self._time_interval = 0.1
     self._start_time = None
     self._end_time = None
 
@@ -117,6 +117,10 @@ class Project(threading.Thread):
   def mqtt_thread(self):
     return self._mqtt_thread
 
+  @property
+  def running_task(self):
+    return self._task_manager.running_task
+
   def run(self):
       self._status = 1
       self._start_time = time()
@@ -139,23 +143,42 @@ class Project(threading.Thread):
               project_start_time = self._start_time,
               delay_time = delay_time,
               running_task= self._task_manager.running_task,
-              previous_task =  self._task_manager.prev_task
+              previous_task =  self._task_manager.prev_task,
+              self_task = task
             )
             # print('match_condition_list', match_condition_list)
             for condition in match_condition_list:
+              # print('\ncondition.type: ', condition.type)
               match_action_list = task.get_match_action(condition.id)
+              # print('match_action_list', match_action_list)
               for action in match_action_list:
-                # print('match_action', action.type, action.target)
+                # print('action type', action.type)
+                # print('match_action_list len: ', len(match_action_list))
                 if action.type == 'start' and task.status != 1:
                   self._task_manager.set_running_task(task)
+                  # Trace
                   self.mqtt_thread.broadcast_command('project:task ' + task.name + ' start at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+                elif action.type == 'cycle' and task.status != 1:
+                  # TODO: directly goto next without swich cycle as running task
+                  """ if task._cycle_count < task._cycle - 1:
+                    task._cycle_count += 1
+                    cycle_target = self._task_manager.task_list[task._cycle_next - 1] # TODO: not sure deep or shallow
+                    cycle_target.reset()
+                    task = cycle_target """
+                  self._task_manager.set_running_task(task)
+                elif action.type == 'stop' and len(self._task_manager.running_task.parameter_set) == 0:
+                  self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+                  self._task_manager.running_task.stop()
+
+                elif action.type == 'idle':
+                  self._task_manager.running_task.stop()
 
                 device = self._complete_device[action.target]
                 task_info = task.get_task_info(action)
                 instruction_set = getattr(self._instruction_set, action.type, None)
-                # print('instruction_set',instruction_set)
-                
-                if instruction_set != None:
+                # print('instruction_set', instruction_set, '\n', action.type)
+                # if instruction_set != None and task.cycle == -1:
+                if instruction_set != None and len(task.parameter_set) > 0:
                   for instruction in instruction_set:
                     args = list(map(lambda arg: task_info[arg], instruction['arguments']))
                     threading.Thread(target=getattr(device, instruction['method'])(*args))
@@ -164,8 +187,10 @@ class Project(threading.Thread):
 
         # check task not running then stop
         if self.check_running_task_not_run() == True:
-          self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+          if self._task_manager.running_task.cycle == -1:
+            self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
           self._task_manager.running_task.stop()
+          # self._task_manager.set_running_task(task)
         
         # check project done then close project
         if self.check_project_done() == True:
@@ -200,17 +225,30 @@ class Project(threading.Thread):
         return False
     return True
   
+  def set_content(self, content):
+    self.running_task.button_trigger = True
+  
   def check_running_task_not_run(self):
     # if no running task
     if self._task_manager.running_task == None:
       return False
-
+    
+    for key in self._task_manager.running_task.action:
+      # print('action key', key, self._task_manager.running_task, self._task_manager.running_task.action[key])
+      if len(self._task_manager.running_task.parameter_set) == 0 and self._task_manager.running_task.action[key]['type'] == 'stop':
+        return False
+      if len(self._task_manager.running_task.parameter_set) == 0 and self._task_manager.running_task.action[key]['type'] == 'idle':
+        return False
+      
     for device in self._task_manager.running_task.device:
       if self._complete_device[device].status == 1:
         return False
     return True
   
   def as_json(self):
+    running_task = None
+    if self._task_manager.running_task is not None:
+      running_task = self._task_manager.running_task.as_json()
     data = {
       'id': self._id,
       'name': self._name,
@@ -219,6 +257,6 @@ class Project(threading.Thread):
       'status': self._status,
       'device': self._device,
       'task': self.task_list,
-      'running_task': self._task_manager.running_task.as_json()
+      'running_task': running_task
     }
     return data

python/biopro/project/project_manager.py

@@ -37,3 +37,7 @@ class ProjectManager():
     def stop_project(self, project):
       _project = self.get(project)
       _project.stop()
+    
+    def set_project(self, project_uuid, content):
+      _project = self.get(project_uuid)
+      _project.set_content(content)

python/biopro/project/task.py

@@ -15,26 +15,34 @@ class Task:
     self._name = None
     self._parent = None
     self._cycle = None
+    self._cycle_count = 0
+    self._cycle_next = None
+    self._cycle_next_uuid = None
     self._device = None
     self._event = None
     self._trigger = None
     self._parameter_set = None
     self._condition = None
     self._action = None
-    # -1: initial 0: start(idle), 1: running, 2: close(idle)
+    # -1: init 0: start(idle), 1: run, 2: close(idle)
     self._status = 0
     self._next = None
 
+    # action & condition info
     self._condition_list: List[Condition] = []
     self._action_list: List[Action] = []
     self._instruction_list = []
     self._record_list = []
 
+    # time info
     self._start_time = []
     self._idle_time = []
     self._end_time = []
     self._period = None
 
+    # trigger info
+    self._button_trigger = False
+
     self.load_task(task)
   
   def load_task(self, task) -> None:
@@ -100,6 +108,31 @@ class Task:
   @cycle.setter
   def cycle(self, new_cycle):
     self._cycle = new_cycle
+
+  # TODO: not sure needed?
+  @property
+  def cycle_count(self) -> int:
+    return self._cycle_count
+  
+  @cycle_count.setter
+  def cycle_count(self, new_cycle_count):
+    self._cycle_count = new_cycle_count
+    
+  @property
+  def cycle_next(self) -> str:
+    return self._cycle_next
+  
+  @cycle_next.setter
+  def cycle_next(self, new_cycle_next):
+    self._cycle_next = new_cycle_next
+
+  @property
+  def cycle_next_uuid(self) -> str:
+    return self._cycle_next_uuid
+  
+  @cycle_next_uuid.setter
+  def cycle_next_uuid(self, new_cycle_next_uuid):
+    self._cycle_next_uuid = new_cycle_next_uuid
   
   @property
   def device(self) -> dict:
@@ -177,6 +210,14 @@ class Task:
   def end_time(self) -> List:
     return self._end_time
   
+  @property
+  def button_trigger(self) -> List:
+    return self._button_trigger
+  
+  @button_trigger.setter
+  def button_trigger(self, button_trigger):
+    self._button_trigger = button_trigger
+  
   def new_start_time(self):
     self._start_time.append(time())
   
@@ -207,6 +248,10 @@ class Task:
   
   def stop(self):
     self.status = 2
+  
+  def reset(self):
+    self.status = -1
+    # self.status = 0
 
   def get_match_action_list(self, match_condition_list):
     return map(lambda condition: [x for x in self._action_list if condition.id in x.get_condition_list()], match_condition_list)
@@ -241,6 +286,9 @@ class Task:
       'name': self.name,
       'parent': self.parent,
       'cycle': self.cycle,
+      'cycle_count': self.cycle_count,
+      'cycle_next': self.cycle_next,
+      'cycle_next_uuid': self.cycle_next_uuid,
       'device': self.device,
       'event': self.event,
       'trigger': self.trigger,

python/biopro/project/task_manager.py

@@ -57,7 +57,8 @@ class TaskManager():
         task = Task(task) 
         self._task_list.append(task)
     
-    def set_running_task(self, task):
+    # original version
+    """ def set_running_task(self, task):
       try:
         # if there is task running & same task active ,then reject
         if self._running_task != None and self._running_task.uuid == task.uuid:
@@ -80,6 +81,44 @@ class TaskManager():
           _task = next((task for task in self._task_list if task.uuid == task_uuid), None)
           if _task != None:
             self._next_task.append(_task)
+      except RuntimeError as e:
+        print(e) """
+
+    def set_running_task(self, task):
+      try:
+        # if there is task running & same task active ,then reject
+        if self._running_task != None and self._running_task.uuid == task.uuid:
+          # print('set_running_task return false: ', self._running_task.name)
+          return False
+
+        # save running task
+        self._prev_task = self._running_task
+        # clear next task list
+        self._next_task.clear()
+        self._running_task = task
+        self._running_task.run()
+
+        if self._prev_task != None:
+          # if previous task is still running, then need to close
+          if self._prev_task.status == 1:
+            self._prev_task.stop()
+          print('prev', 'run', self._prev_task.name, self._running_task.name)
+
+        # print(f'!!@#!set_running_task\n\n\n{task._cycle_count}\n{task._cycle}\n\n\n')
+        if task._cycle_count < task._cycle - 1:
+          task._cycle_count += 1
+          # use uuid to get the cycle next task
+          cycle_target = [_task_next for _task_next in self._task_list if _task_next.uuid == task._cycle_next_uuid]
+          # cycle_target = self._task_list[task._cycle_next - 1]  # original use index version
+          cycle_target[0].reset()
+          self._next_task.append(cycle_target[0])
+        else:
+          task._cycle_count = 0
+          for task_uuid in self._running_task.next:
+            _task = next((task for task in self._task_list if task.uuid == task_uuid), None)
+            if _task != None:
+              _task.reset()
+              self._next_task.append(_task)
       except RuntimeError as e:
         print(e)
 

python/biopro/recording/file.py

@@ -20,11 +20,6 @@ from statistics import mean
 import random
 # from numba import jit
 
-from .lttb import largest_triangle_three_buckets
-import math
-
-from scipy import signal
-
 from copy import copy
 
 def json_stringify(o) -> str:
@@ -1020,7 +1015,7 @@ class RecordingFileWriter:
                  '_mini_scale_list', '_time_real_time', '_data_rl', '_data_db',
                  '_raw_save', '_mini_save', '_data_time_ch', '_data_value_ch_for_rl',
                  '_data_time_ch_for_rl', '_device_id', '_send_data', '_data_mqtt_ch', '_id_db_save', '_raw_create_not_done',
-                 '_mini_create_not_done', '_data_all')
+                 '_mini_create_not_done')
 
     def __init__(self, meta: RecordingMetaFile, device_id, database = None):
         self._meta = meta
@@ -1080,8 +1075,6 @@ class RecordingFileWriter:
         self._data_time_ch = {}
         self._id_db_save = {}
 
-        self._data_all = {}
-
         # mini data
         self._data_mini_ch = {}
 
@@ -1234,17 +1227,17 @@ class RecordingFileWriter:
     def get_data_iter(self, d, mqtt_thread):
         # print('****d size', d.data_size)
         for t, c, v in d.entry_iter():
-            # print(t,c,v)
             if c in self._data_db:
-                self._data_all[c].append([int(t), v])
                 ### send real-time
                 if len(self._data_rl[c]) > 0 and self._send_data[c]:
                     self._data_rl[c].append(str(int(t)))
                     mes = ' '.join(self._data_rl[c])
-                    # print('message1', mes)
+                    # self._data_mqtt_ch[c] = self._data_rl[c].copy()
+                    # self._data_mqtt_ch[c].append(str(int(t)))
                     mqtt_thread[c].on_message(mes)
                     self._data_rl[c].clear()
                     self._send_data[c] = False
+                ### send real-time
                 
                 sample_rate_rl = 1
                 # rec data
@@ -1257,35 +1250,40 @@ class RecordingFileWriter:
                     self._data_value_ch[c].append(int(v))
                     self._data_value_ch_for_rl[c].append(int(v))
                     self._data_time_ch_for_rl[c].append(int(t))
-                    # print('self._data_value_ch[c]', self._data_value_ch[c])
-                    # print('self._data_value_ch_for_rl[c]', self._data_value_ch_for_rl[c])
-                    # print('self._data_time_ch_for_rl[c]', self._data_time_ch_for_rl[c])
+                    # self._data_time_ch[c].append(int(t))
                     for scale in self._mini_scale_list:
                         if self._data_mini_ch[c][str(scale)]['start_time'] is None:
                             self._data_mini_ch[c][str(scale)]['start_time'] = str(int(t))
                     
-                    # print('len(self._data_value_ch_for_rl[c])', len(self._data_value_ch_for_rl[c]))
-                    # print('sample_rate_rl:', sample_rate_rl)
                     if len(self._data_value_ch_for_rl[c]) >= sample_rate_rl:
                         if len(self._data_value_ch_for_rl[c]) == 1:
                             if len(self._data_rl[c]) == 0:
                                 self._data_rl[c].append(str(int(t)))
+                            # self._data_rl[c].append(str(self._data_time_ch_for_rl[c][0]))
                             self._data_rl[c].append(str(self._data_value_ch_for_rl[c][0]))
                         else:
                             if len(self._data_rl[c]) == 0:
                                 self._data_rl[c].append(str(int(t)))
+                            # self._data_rl[c].append(str(self._data_time_ch_for_rl[c][0]))
+                            # self._data_rl[c].append(str(self._data_value_ch_for_rl[c][0]))
                             _max = max(self._data_value_ch_for_rl[c])
                             _max_index = self._data_value_ch_for_rl[c].index(_max)
                             _min = min(self._data_value_ch_for_rl[c])
                             _min_index = self._data_value_ch_for_rl[c].index(_min)
+                            # _mean = mean(self._data_value_ch_for_rl[c])
 
-                            # print('_max, _max_index, _min, _min_index', _max, _max_index, _min, _min_index)
+                            # _first_time = self._data_time_ch_for_rl[c][0]
+                            # _last_time = self._data_time_ch_for_rl[c][-1]
 
                             if _max_index < _min_index:
+                                # self._data_rl[c].append(str(_first_time))
                                 self._data_rl[c].append(str(_max))
+                                # self._data_rl[c].append(str(_last_time))
                                 self._data_rl[c].append(str(_min))
                             else:
+                                # self._data_rl[c].append(str(_first_time))
                                 self._data_rl[c].append(str(_min))
+                                # self._data_rl[c].append(str(_last_time))
                                 self._data_rl[c].append(str(_max))
 
                         self._data_value_ch_for_rl[c].clear()
@@ -1294,6 +1292,9 @@ class RecordingFileWriter:
                     # mini picture
                     if len(self._data_value_ch[c]) >= 10:
                         self._data_mini_ch[c]['10']['mean'].append( int(mean(self._data_value_ch[c][0:9])) )
+                        # self._data_mini_ch[c]['10']['random'].append( str(self._data_value_ch[c][random.randint(0,9)]) )
+                        # _bar = self.get_bar(self._data_value_ch[c], None)
+                        # self._data_mini_ch[c]['10']['bar'].extend(_bar)
                         self._data_value_ch[c].clear()
                         if int(len(self._data_mini_ch[c]['10']['mean']) / 10) - self._data_mini_ch[c]['10']['dec'] > 0:
                             self._data_mini_ch[c]['100']['mean'].append( int(mean(self._data_mini_ch[c]['10']['mean'][-10:])) )
@@ -1315,13 +1316,6 @@ class RecordingFileWriter:
                     self._data_db[c].append(str(int(t)))
                     self._data_db[c].append(str(v))
                     self._time_now = int(t)
-        # print('self._data_rl',self._data_rl)
-        # print('self._data_db', self._data_db)
-        # print('self._data_value_ch', self._data_value_ch)
-        # print('self._data_value_ch_for_rl', self._data_value_ch_for_rl)
-        # print('self._data_time_ch_for_rl', self._data_time_ch_for_rl)
-        # print('self._data_time_ch', self._data_time_ch)
-        # print('self._id_db_save', self._id_db_save)
         return
     
     # @calculate_time(1)
@@ -1369,7 +1363,6 @@ class RecordingFileWriter:
                         self._data_db[ch] = []
                         self._time[ch] = 0
                         self._time_real_time[ch] = 0
-                        self._data_all[ch] = []
                 if len(self._data_mini_ch) == 0:
                     for ch in self._channel_list:
                         self._data_mini_ch[ch] = {}
@@ -1383,37 +1376,6 @@ class RecordingFileWriter:
                             }
                 
                 self.get_data_iter(d, mqtt_thread)
-            
-            print('data', len(self._data_all[0]))
-
-            test = []
-
-            # for ch in self._data_all:
-            #     if len(self._data_all[ch]) <= 1000:
-            #         print('math.ceil(len(self._data_all[ch]) / 10) + 1', math.ceil(len(self._data_all[ch]) / 10) + 1)
-            #         test = largest_triangle_three_buckets(self._data_all[ch], math.ceil(len(self._data_all[ch]) / 10) + 1)
-            #     else:
-            #         self._data_all[ch] = largest_triangle_three_buckets(self._data_all[ch], 1000)
-            #         test = self._data_all[ch]
-                
-            #     print('test', test)
-            #     a = [' '.join(list(map(str, b))) for b in test]
-            #     print('a', a)
-            #     mes = ' '.join(a)
-            #     mqtt_thread[50+ch].on_message(mes)
-
-            for ch in self._data_all:
-                if len(self._data_all[ch]) <= 1000:
-                    self._data_all[ch] = signal.savgol_filter(self._data_all[ch], 32, 3)
-                else:
-                    self._data_all[ch] = signal.savgol_filter(self._data_all[ch], 32, 3)
-                
-                print('test', test)
-                a = [' '.join(list(map(str, b))) for b in self._data_all[ch]]
-                print('a', a)
-                mes = ' '.join(a)
-                mqtt_thread[50+ch].on_message(mes)
-            
 
             if len(self._recording_file_dict) > 0:
                 for ch in self._data_db.keys():

python/biopro/recording/lttb.py

@@ -1,108 +0,0 @@
-"""
-The MIT License (MIT)
-Copyright (c) 2015 Olivier Devoisin
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
-
-import math
-
-class LttbException(Exception):
-    pass
-
-
-def largest_triangle_three_buckets(data, threshold):
-    """
-    Return a downsampled version of data.
-    Parameters
-    ----------
-    data: list of lists/tuples
-        data must be formated this way: [[x,y], [x,y], [x,y], ...]
-                                    or: [(x,y), (x,y), (x,y), ...]
-    threshold: int
-        threshold must be >= 2 and <= to the len of data
-    Returns
-    -------
-    data, but downsampled using threshold
-    """
-
-    # Check if data and threshold are valid
-    if not isinstance(data, list):
-        raise LttbException("data is not a list")
-    if not isinstance(threshold, int) or threshold <= 2 or threshold >= len(data):
-        raise LttbException("threshold not well defined")
-    for i in data:
-        if not isinstance(i, (list, tuple)) or len(i) != 2:
-            raise LttbException("datapoints are not lists or tuples")
-
-    # Bucket size. Leave room for start and end data points
-    every = (len(data) - 2) / (threshold - 2)
-
-    a = 0  # Initially a is the first point in the triangle
-    next_a = 0
-    max_area_point = (0, 0)
-
-    sampled = [data[0]]  # Always add the first point
-
-    for i in range(0, threshold - 2):
-        # Calculate point average for next bucket (containing c)
-        avg_x = 0
-        avg_y = 0
-        avg_range_start = int(math.floor((i + 1) * every) + 1)
-        avg_range_end = int(math.floor((i + 2) * every) + 1)
-        avg_rang_end = avg_range_end if avg_range_end < len(data) else len(data)
-
-        avg_range_length = avg_rang_end - avg_range_start
-
-        while avg_range_start < avg_rang_end:
-            avg_x += data[avg_range_start][0]
-            avg_y += data[avg_range_start][1]
-            avg_range_start += 1
-
-        avg_x /= avg_range_length
-        avg_y /= avg_range_length
-
-        # Get the range for this bucket
-        range_offs = int(math.floor((i + 0) * every) + 1)
-        range_to = int(math.floor((i + 1) * every) + 1)
-
-        # Point a
-        point_ax = data[a][0]
-        point_ay = data[a][1]
-
-        max_area = -1
-
-        while range_offs < range_to:
-            # Calculate triangle area over three buckets
-            area = math.fabs(
-                (point_ax - avg_x)
-                * (data[range_offs][1] - point_ay)
-                - (point_ax - data[range_offs][0])
-                * (avg_y - point_ay)
-            ) * 0.5
-
-            if area > max_area:
-                max_area = area
-                max_area_point = data[range_offs]
-                next_a = range_offs  # Next a is this b
-            range_offs += 1
-
-        sampled.append(max_area_point)  # Pick this point from the bucket
-        a = next_a  # This a is the next a (chosen b)
-
-    sampled.append(data[len(data) - 1])  # Always add last
-
-    return sampled

python/biopro/server/data.py

@@ -646,6 +646,7 @@ class DataServer(SocketServer, DataAPI):
     def whether_to_record(self, device):
         # if user click "start", return True; if user click "stop", return False;
         if device in self._configurations.keys() and self._configurations[device] is not None:
+            # print(self._configurations.keys(), ',', device, datetime.now())
             return True
         else:
             return False
@@ -654,6 +655,9 @@ class DataServer(SocketServer, DataAPI):
         ret = False
         sync = self.get_spi_obj()
 
+        busy = sync.get_pin_busy()
+        print('pin_busy=', busy, device, datetime.now())
+
         if sync.get_pin_mem_req() == sync.get_pin_ram_sel():
             spi_data = sync.recv_memory(device)
             signal = sync.get_pin_mem_req()
@@ -662,6 +666,7 @@ class DataServer(SocketServer, DataAPI):
 
         else:
             data = None
+            print('data=None, mem_req!=ram_sel, [', sync.get_pin_mem_req(), ', ', sync.get_pin_ram_sel(), ']', device, datetime.now())
 
         if data is not None:
             if self._configurations[device].queue_flag:
@@ -699,6 +704,9 @@ class DataServer(SocketServer, DataAPI):
                 self.mqtt_thread.publish('device_instruction', json_stringify(content), inter = True)
 
         return True
+    
+    def show_data(self, device):
+        self._configurations[device].put_rec_queue('show_data')
 
 class DataRuntime(metaclass=abc.ABCMeta):
     __slots__ = ('_server', '_device', '_meta_file', '_data_format',

python/biopro/server/main.py

@@ -819,12 +819,18 @@ class ControlServer(SocketServer, ControlServerAPI):
         return True
 
     @logging_info
-    def device_battery(self) -> List[int]:
-        device_list = self.device_manager.list_device()
-        if len(device_list) > 0:
-            battery_list = list(map(lambda x: self.device_manager.get_device(x).battery, device_list))
-
-        return battery_list
+    def device_battery(self, device:int) -> List[int]:
+        battery = {}
+        if device == 'all':
+            device_list = self.device_manager.list_device()
+            if len(device_list) > 0:
+                battery = list(map(lambda x: {"device": x.memory_board, "battery":self.device_manager.get_device(x).battery}, device_list))
+        else:
+            battery = {
+                "device": device,
+                "battery": self.device_manager.get_device(device).battery
+            }
+        return battery
 
     @logging_info
     def device_parent(self, device: int, content: Optional[str] = None) -> List[int]:
@@ -1015,6 +1021,7 @@ class ControlServer(SocketServer, ControlServerAPI):
     @logging_info
     def run_project(self, project) -> bool:
         if project is not None:
+            # print(project)
             project = self._project_manager.create(project)
             self._project_manager.run_project(project)
         return  project.as_json()
@@ -1024,6 +1031,12 @@ class ControlServer(SocketServer, ControlServerAPI):
         if project is not None:
             self._project_manager.stop_project(project)
         return True
+    
+    @logging_info
+    def set_project(self, project, content) -> bool:
+        if project is not None:
+            self._project_manager.set_project(project, content)
+        return True
 
     @logging_info
     def get_running_project(self) -> bool:
@@ -1339,6 +1352,13 @@ class ControlServer(SocketServer, ControlServerAPI):
         def _hardware_send_test_set(self, options: Dict[str, str]) -> bool:
             # TODO write options files
             return False
+        
+        @logging_info
+        def show_device_data(self, device: int):
+            client = self.data_server.client()
+            if client is not None:
+                with client:
+                    client.show_data(device)
 
 class _RandomCrashThread(ServerThread):
     def __init__(self):

python/biopro/server/recording.py

@@ -185,6 +185,8 @@ class RecordingProcess(Process):
                 self.final_write()
                 self.is_closed = True
                 return False
+            elif q == 'show_data':
+                self._decoder._show_data = not self._decoder._show_data
             else:
                 self.rec_update()
                 self.sync_data(q)
@@ -234,7 +236,6 @@ class RecordingProcess(Process):
                     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) ) 
-                            self._mqtt_send_data_ch_level[50+ch] = MqttDataMessageHandler(self._mqtt_thread, 'data_server/device_data_stream/' + str(result.device) + '/' + str(ch+50) ) 
                     ret.append(result)
                 else:
                     continue

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

@@ -1203,7 +1203,7 @@
         "pe": "SAMPLE_RATE"
       },
       "data": [
-        "X07;",
+        "X0C;",
         "B>va;4B>vb;2B>vc;2B>vd;",
         "4b>pa;4b>pb;",
         "4b>pc;4b>pd;",
@@ -1633,16 +1633,6 @@
     "dpv_engineering_mode_advanced": [
       "dpv_advanced_mode"
     ],
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "set_adc_gain_I",
-      "set_adc_gain_Vin",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

python/res/devlib/json/Elite_EDC_1.4.devlib.json

@@ -492,14 +492,6 @@
         "1XC0;1X02;4B>ve;2B>vf;4B>vg;B>cn"
       ]
     },
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "curve_cv3_high_cycle": {
       "type": "RIS",
       "parameter": {

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

@@ -15,6 +15,33 @@
     "BLE_WRITE_MAX": 255
   },
   "parameters": {
+    "HIGHZ_TABLE": {
+      "initial": [
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1
+      ],
+      "domain": {
+        "list": [
+          100
+        ]
+      },
+      "value": "VALUE"
+    },
     "DPV_e_init": {
       "description": "DPV initial voltage ",
       "record_meta": true,
@@ -671,6 +698,17 @@
       },
       "on_change": "set_para_DAC_VOLT"
     },
+    "DAC_VOLT_SCROLL": {
+      "description": "DAC scroll output Voltage",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        65536
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "ADC_VALUE_I": {
       "description": "ADC value current value",
       "domain": "int"
@@ -836,6 +874,18 @@
       ],
       "on_change": "set_dac_gain_Vout"
     },
+    "DAC_VOLT_BUTTON": {
+      "description": "DAC volt",
+      "record_meta": true,
+      "initial": 1,
+      "value": [
+        "10000",
+        "25000",
+        "50000",
+        "60000"
+      ],
+      "on_change": "cali_Vout"
+    },
     "CTRL_HIGH_Z_15": {
       "description": "ctrl highZ level",
       "record_meta": true,
@@ -851,7 +901,8 @@
       "initial": 0,
       "value": [
         "Iin",
-        "Vin"
+        "Vin",
+        "Vout"
       ]
     },
     "BLE_WRITE": {
@@ -912,11 +963,13 @@
       "_notify(True)",
       "set_adc_gain_I",
       "set_adc_gain_Vin",
+      "set_dac_gain_Vout",
       {
         "expression": "ADC_DAC_CHANNEL_15",
         "when": {
           "0": "cali_Iin",
-          "1": "cali_Vin"
+          "1": "cali_Vin",
+          "2": "cali_Vout"
         }
       },
       "_sync(True)",
@@ -1007,12 +1060,6 @@
         "XE0;2B>va"
       ]
     },
-    "set_dac_gain_Vout": {
-      "type": "RIS",
-      "data": [
-        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
-      ]
-    },
     "set_adc_gain_I": {
       "type": "RIS",
       "data": [
@@ -1025,6 +1072,12 @@
         "XE1;X01;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "set_dac_gain_Vout": {
+      "type": "RIS",
+      "data": [
+        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
+      ]
+    },
     "set_ctrl_highZ": {
       "type": "RIS",
       "data": [
@@ -1052,13 +1105,22 @@
         "XF1;B>ADC_DAC_CHANNEL_15;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "cali_Vout": {
+      "type": "RIS",
+      "parameter": {
+        "v": "DAC_VOLT_BUTTON"
+      },
+      "data": [
+        "XF1;B>ADC_DAC_CHANNEL_15;B>v"
+      ]
+    },
     "curve_iv": {
       "type": "RIS",
       "parameter": {
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
         "pc": "DAC_LEVEL_V_OUT_15",
@@ -1079,7 +1141,7 @@
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "ve": "CYCLE_NUMBER",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
@@ -1203,7 +1265,7 @@
         "pe": "SAMPLE_RATE"
       },
       "data": [
-        "X07;",
+        "X0C;",
         "B>va;4B>vb;2B>vc;2B>vd;",
         "4b>pa;4b>pb;",
         "4b>pc;4b>pd;",
@@ -1633,16 +1695,6 @@
     "dpv_engineering_mode_advanced": [
       "dpv_advanced_mode"
     ],
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "set_adc_gain_I",
-      "set_adc_gain_Vin",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

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

@@ -15,6 +15,33 @@
     "BLE_WRITE_MAX": 255
   },
   "parameters": {
+    "HIGHZ_TABLE": {
+      "initial": [
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1
+      ],
+      "domain": {
+        "list": [
+          100
+        ]
+      },
+      "value": "VALUE"
+    },
     "DPV_e_init": {
       "description": "DPV initial voltage ",
       "record_meta": true,
@@ -671,6 +698,17 @@
       },
       "on_change": "set_para_DAC_VOLT"
     },
+    "DAC_VOLT_SCROLL": {
+      "description": "DAC scroll output Voltage",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        65536
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "ADC_VALUE_I": {
       "description": "ADC value current value",
       "domain": "int"
@@ -836,6 +874,18 @@
       ],
       "on_change": "set_dac_gain_Vout"
     },
+    "DAC_VOLT_BUTTON": {
+      "description": "DAC volt",
+      "record_meta": true,
+      "initial": 1,
+      "value": [
+        "10000",
+        "25000",
+        "50000",
+        "60000"
+      ],
+      "on_change": "cali_Vout"
+    },
     "CTRL_HIGH_Z_15": {
       "description": "ctrl highZ level",
       "record_meta": true,
@@ -851,7 +901,8 @@
       "initial": 0,
       "value": [
         "Iin",
-        "Vin"
+        "Vin",
+        "Vout"
       ]
     },
     "BLE_WRITE": {
@@ -912,11 +963,13 @@
       "_notify(True)",
       "set_adc_gain_I",
       "set_adc_gain_Vin",
+      "set_dac_gain_Vout",
       {
         "expression": "ADC_DAC_CHANNEL_15",
         "when": {
           "0": "cali_Iin",
-          "1": "cali_Vin"
+          "1": "cali_Vin",
+          "2": "cali_Vout"
         }
       },
       "_sync(True)",
@@ -1007,12 +1060,6 @@
         "XE0;2B>va"
       ]
     },
-    "set_dac_gain_Vout": {
-      "type": "RIS",
-      "data": [
-        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
-      ]
-    },
     "set_adc_gain_I": {
       "type": "RIS",
       "data": [
@@ -1025,6 +1072,12 @@
         "XE1;X01;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "set_dac_gain_Vout": {
+      "type": "RIS",
+      "data": [
+        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
+      ]
+    },
     "set_ctrl_highZ": {
       "type": "RIS",
       "data": [
@@ -1052,13 +1105,22 @@
         "XF1;B>ADC_DAC_CHANNEL_15;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "cali_Vout": {
+      "type": "RIS",
+      "parameter": {
+        "v": "DAC_VOLT_BUTTON"
+      },
+      "data": [
+        "XF1;B>ADC_DAC_CHANNEL_15;B>v"
+      ]
+    },
     "curve_iv": {
       "type": "RIS",
       "parameter": {
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
         "pc": "DAC_LEVEL_V_OUT_15",
@@ -1079,7 +1141,7 @@
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "ve": "CYCLE_NUMBER",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
@@ -1203,7 +1265,7 @@
         "pe": "SAMPLE_RATE"
       },
       "data": [
-        "X07;",
+        "X0C;",
         "B>va;4B>vb;2B>vc;2B>vd;",
         "4b>pa;4b>pb;",
         "4b>pc;4b>pd;",
@@ -1633,16 +1695,6 @@
     "dpv_engineering_mode_advanced": [
       "dpv_advanced_mode"
     ],
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "set_adc_gain_I",
-      "set_adc_gain_Vin",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

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

@@ -15,6 +15,33 @@
     "BLE_WRITE_MAX": 255
   },
   "parameters": {
+    "HIGHZ_TABLE": {
+      "initial": [
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1
+      ],
+      "domain": {
+        "list": [
+          100
+        ]
+      },
+      "value": "VALUE"
+    },
     "DPV_e_init": {
       "description": "DPV initial voltage ",
       "record_meta": true,
@@ -671,6 +698,17 @@
       },
       "on_change": "set_para_DAC_VOLT"
     },
+    "DAC_VOLT_SCROLL": {
+      "description": "DAC scroll output Voltage",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        65536
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "ADC_VALUE_I": {
       "description": "ADC value current value",
       "domain": "int"
@@ -836,6 +874,18 @@
       ],
       "on_change": "set_dac_gain_Vout"
     },
+    "DAC_VOLT_BUTTON": {
+      "description": "DAC volt",
+      "record_meta": true,
+      "initial": 1,
+      "value": [
+        "10000",
+        "25000",
+        "50000",
+        "60000"
+      ],
+      "on_change": "cali_Vout"
+    },
     "CTRL_HIGH_Z_15": {
       "description": "ctrl highZ level",
       "record_meta": true,
@@ -851,7 +901,8 @@
       "initial": 0,
       "value": [
         "Iin",
-        "Vin"
+        "Vin",
+        "Vout"
       ]
     },
     "BLE_WRITE": {
@@ -912,11 +963,13 @@
       "_notify(True)",
       "set_adc_gain_I",
       "set_adc_gain_Vin",
+      "set_dac_gain_Vout",
       {
         "expression": "ADC_DAC_CHANNEL_15",
         "when": {
           "0": "cali_Iin",
-          "1": "cali_Vin"
+          "1": "cali_Vin",
+          "2": "cali_Vout"
         }
       },
       "_sync(True)",
@@ -1007,12 +1060,6 @@
         "XE0;2B>va"
       ]
     },
-    "set_dac_gain_Vout": {
-      "type": "RIS",
-      "data": [
-        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
-      ]
-    },
     "set_adc_gain_I": {
       "type": "RIS",
       "data": [
@@ -1025,6 +1072,12 @@
         "XE1;X01;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "set_dac_gain_Vout": {
+      "type": "RIS",
+      "data": [
+        "XE1;X02;B>DAC_LEVEL_V_OUT_15"
+      ]
+    },
     "set_ctrl_highZ": {
       "type": "RIS",
       "data": [
@@ -1052,13 +1105,22 @@
         "XF1;B>ADC_DAC_CHANNEL_15;B>ADC_LEVEL_V_IN_15"
       ]
     },
+    "cali_Vout": {
+      "type": "RIS",
+      "parameter": {
+        "v": "DAC_VOLT_BUTTON"
+      },
+      "data": [
+        "XF1;B>ADC_DAC_CHANNEL_15;B>v"
+      ]
+    },
     "curve_iv": {
       "type": "RIS",
       "parameter": {
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
         "pc": "DAC_LEVEL_V_OUT_15",
@@ -1079,7 +1141,7 @@
         "va": "VOLT_ORIGIN",
         "vb": "VOLT_FINAL",
         "vc": "VOLT_STEP",
-        "vd": "STEP_TIME * 0x12",
+        "vd": "STEP_TIME",
         "ve": "CYCLE_NUMBER",
         "pa": "ADC_LEVEL_I_15",
         "pb": "ADC_LEVEL_V_IN_15",
@@ -1203,7 +1265,7 @@
         "pe": "SAMPLE_RATE"
       },
       "data": [
-        "X07;",
+        "X0C;",
         "B>va;4B>vb;2B>vc;2B>vd;",
         "4b>pa;4b>pb;",
         "4b>pc;4b>pd;",
@@ -1633,16 +1695,6 @@
     "dpv_engineering_mode_advanced": [
       "dpv_advanced_mode"
     ],
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "set_adc_gain_I",
-      "set_adc_gain_Vin",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

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

@@ -62,6 +62,7 @@
       "value": [
         "EIS CURVE",
         "Cyclic Voltammetry",
+        "Chronoamperometric",
         "Dev Mode"
       ]
     },
@@ -265,6 +266,17 @@
         "expression": "VALUE"
       }
     },
+    "VOLT_VSCAN": {
+      "description": "Voltage of VScan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "BLE_WRITE": {
       "description": "send msg to elite",
       "domain": {
@@ -295,20 +307,23 @@
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_I"
+          "1": "set_adc_gain_I",
+          "2": "set_adc_gain_I"
         }
       },
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_Vin"
+          "1": "set_adc_gain_Vin",
+          "2": "set_adc_gain_Vin"
         }
       },
       {
         "expression": "MODE",
         "when": {
           "0": "curve_eis",
-          "1": "curve_cv3"
+          "1": "curve_cv3",
+          "2": "curve_const_vscan"
         }
       },
       {
@@ -424,14 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
-    "VIS_CC_ZERO": [
-      "_data_format('EISZeroOne')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
+    "curve_const_vscan": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_VSCAN",
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
+      "data": [
+        "1XD3;",
+        "2B>va;",
+        "4b>pa;4b>pb;",
+        "4b>0;4b>pd;",
+        "2B>pe"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

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

@@ -62,6 +62,7 @@
       "value": [
         "EIS CURVE",
         "Cyclic Voltammetry",
+        "Chronoamperometric",
         "Dev Mode"
       ]
     },
@@ -69,7 +70,7 @@
       "description": "DPV current recording period start",
       "record_meta": true,
       "initial": [
-        13422819,
+        13333333,
         7
       ],
       "domain": {
@@ -265,6 +266,17 @@
         "expression": "VALUE"
       }
     },
+    "VOLT_VSCAN": {
+      "description": "Voltage of VScan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "BLE_WRITE": {
       "description": "send msg to elite",
       "domain": {
@@ -295,20 +307,23 @@
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_I"
+          "1": "set_adc_gain_I",
+          "2": "set_adc_gain_I"
         }
       },
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_Vin"
+          "1": "set_adc_gain_Vin",
+          "2": "set_adc_gain_Vin"
         }
       },
       {
         "expression": "MODE",
         "when": {
           "0": "curve_eis",
-          "1": "curve_cv3"
+          "1": "curve_cv3",
+          "2": "curve_const_vscan"
         }
       },
       {
@@ -424,14 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
-    "VIS_CC_ZERO": [
-      "_data_format('EISZeroOne')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
+    "curve_const_vscan": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_VSCAN",
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
+      "data": [
+        "1XD3;",
+        "2B>va;",
+        "4b>pa;4b>pb;",
+        "4b>0;4b>pd;",
+        "2B>pe"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

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

@@ -62,6 +62,7 @@
       "value": [
         "EIS CURVE",
         "Cyclic Voltammetry",
+        "Chronoamperometric",
         "Dev Mode"
       ]
     },
@@ -265,6 +266,17 @@
         "expression": "VALUE"
       }
     },
+    "VOLT_VSCAN": {
+      "description": "Voltage of VScan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
     "BLE_WRITE": {
       "description": "send msg to elite",
       "domain": {
@@ -295,20 +307,23 @@
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_I"
+          "1": "set_adc_gain_I",
+          "2": "set_adc_gain_I"
         }
       },
       {
         "expression": "MODE",
         "when": {
-          "1": "set_adc_gain_Vin"
+          "1": "set_adc_gain_Vin",
+          "2": "set_adc_gain_Vin"
         }
       },
       {
         "expression": "MODE",
         "when": {
           "0": "curve_eis",
-          "1": "curve_cv3"
+          "1": "curve_cv3",
+          "2": "curve_const_vscan"
         }
       },
       {
@@ -424,14 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
-    "VIS_CC_ZERO": [
-      "_data_format('EISZeroOne')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
+    "curve_const_vscan": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_VSCAN",
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
+      "data": [
+        "1XD3;",
+        "2B>va;",
+        "4b>pa;4b>pb;",
+        "4b>0;4b>pd;",
+        "2B>pe"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

python/res/devlib/json/Elite_MEGAFLY_0.1.devlib.json

@@ -1426,14 +1426,6 @@
         "X80;X03;B>CTRL_HIGH_Z_15"
       ]
     },
-    "VIS_CC_ZERO": [
-      "_data_format('I4V4Z4T4')",
-      "_disable_cache(False)",
-      "_notify(True)",
-      "VIS_CC_ZERO",
-      "_sync(True)",
-      "VIS_STI"
-    ],
     "pulse_fly": [
       "sti_mode",
       "gas1_mode",