[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,6 +1,7 @@
 import abc
 import struct
 import math
+import numpy
 from typing import Optional, TypeVar, Generic, Tuple, Dict, List, AnyStr
 from datetime import datetime
 
@@ -853,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__()
@@ -868,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
@@ -892,6 +895,10 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         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]
@@ -915,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),
@@ -946,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)
@@ -1335,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__()
@@ -1359,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)
@@ -1367,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
@@ -1383,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)
@@ -1416,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:
@@ -1477,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
@@ -1494,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)
 
@@ -1521,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/library.py

@@ -1130,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

@@ -93,12 +93,23 @@ class Condition():
     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']
@@ -113,4 +124,13 @@ class Condition():
         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

@@ -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()
@@ -166,6 +170,9 @@ class Project(threading.Thread):
                   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)
@@ -183,6 +190,7 @@ class Project(threading.Thread):
           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:
@@ -217,6 +225,9 @@ 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:
@@ -226,6 +237,8 @@ class Project(threading.Thread):
       # 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:

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

@@ -24,20 +24,25 @@ class Task:
     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:
@@ -205,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())
   

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]:
@@ -1025,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:
@@ -1340,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)

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;",

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,6 +1105,15 @@
         "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": {
@@ -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;",

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,6 +1105,15 @@
         "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": {
@@ -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;",

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,6 +1105,15 @@
         "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": {

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,6 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
+    "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,6 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
+    "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,6 +439,23 @@
         "1XD2;1X02;4B>ve;2B>vf;2B>cn"
       ]
     },
+    "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')"