test data

[debug] fix final data loss & flag stop after writer write
[update] update file name of elite library
2022-08-02 14:16:22 +08:00 · 2022-07-29 11:11:46 +08:00 · 2022-07-26 13:14:37 +08:00 · 2022-07-13 10:03:40 +08:00 · 2022-07-06 16:23:12 +08:00 · 2022-07-05 18:20:32 +08:00
35 changed files with 6818 additions and 1723 deletions
@@ -1,5 +1,7 @@
 .DS_Store
 *.cpython-37.opt-2.pyc
+*.cpython-39-arm-linux-gnueabihf.so
+*.
 *.pyc
 */__pycache__
 /.vscode
@@ -4,7 +4,7 @@ New goal on pi4 without kotlin and django, and with only one dataserver.
 # Installation
 ### Get Raspbrain into SD card

-###### Download Raspbian Buster Lite
+###### Download Raspbian Bullseye Lite

 >https://www.raspberrypi.org/downloads/raspberry-pi-os/

@@ -14,7 +14,7 @@ New goal on pi4 without kotlin and django, and with only one dataserver.
 lsblk

 # copy data to sd card
-sudo dd bs=4M if=yyyy-mm-dd-raspbian-buster.img of=/dev/sdX conv=fsync status=progress
+sudo dd bs=4M if=yyyy-mm-dd-raspios-bullseye-armhf-lite.img of=/dev/sdX conv=fsync status=progress

 # enable ssh on first boot
 add ssh.txt in boot folder
@@ -77,18 +77,22 @@ add ssh.txt in boot folder


 ###### Install dependencies
-    sudo apt-get install vim git wiringpi build-essential libi2c-dev i2c-tools python-dev libffi-dev python3-pip postgresql
+    sudo apt-get install vim git wiringpi build-essential libi2c-dev i2c-tools python-dev libffi-dev python3-pip postgresql npm
+
+###### wiringpi conflict
+need to install wiringpi:  https://github.com/WiringPi/WiringPi
+install instructions:  https://github.com/WiringPi/WiringPi/blob/master/INSTALL

 ### Setup project
-###### Clone project
+###### Clone data server project
 ```
 cd ~
-git clone https://gitlab.com/bioproscientific/bioprorelife.git
+git clone https://gitlab.com/wisetop/controller/wisetopdataserver.git
 ```

 ###### Install python dependencies
 ```
-cd ~/bioprorelife
+ cd ~/wisetopdataserver
 pip3 install -r requirements.txt
 ```
 ##### Packages version
@@ -112,14 +116,14 @@ psycopg2                      2.8.5

 ###### Build C extension
 ```
-cd ~/bioprorelife/python/biopro/ext/
+cd ~/wisetopdataserver/python/biopro/ext/
 rm -rf *.so build
 python3 setup.py build_ext --inplace
 ```

 ###### Check setup-uart file
 ```
-cd ~/bioprorelife
+cd ~/wisetopdataserver/
 sudo vim ./run-setup-uart.sh
 ```
 ##### Modify the code as following
@@ -149,44 +153,72 @@ sudo raspi-config
 reboot
 ```

+###### Set pi password
+```
+$cd ~
+$passwd
+Current password:raspberry
+New password:5k6zj454778225
+Retype new password:5k6zj454778225
+```
+
 ###### Auto run program when device start
 ```
 sudo vim /etc/rc.local
 ```
-add the code following as:
+###### add the code following as:
 ```
-sudo -H -u pi nohup /home/pi/bioprorelife/run-data-server.sh > /home/pi/.data_server.out &
+sudo -H -u pi nohup /home/pi/wisetopdataserver/run-data-server.sh > /home/pi/.data_server.out &
+#sudo -H -u pi nohup /home/pi/wisetopdataserver/run-data-server.sh > /home/pi/.wisetop_data_$now.out &
 ```
+##### /etc/rc.local
+```
+_IP=$(hostname -I) || true
+if [ "$_IP" ]; then
+  printf "My IP address is %s\n" "$_IP"
+fi

+now=$(date +'%F_%T')
+
+sudo nohup systemctl restart apache2
+sudo nohup systemctl restart mosquitto
+
+nohup node /home/pi/wisetopapiserver/dist/app.js > /home/pi/.api_server.out &
+
+sleep 5
+
+sudo -H -u pi nohup /home/pi/wisetopdataserver/run-data-server.sh > /home/pi/.data_server.out &
+#sudo -H -u pi nohup /home/pi/wisetopdataserver/run-data-server.sh > /home/pi/.wisetop_data_$now.out &
+
+exit 0
+```
 ### MQTT broker install

-1. Install mosquitto
-```
-sudo apt-get install mosquitto mosquitto-clients
-```
+###### 1.Install mosquitto
+$sudo apt-get install mosquitto mosquitto-clients
+
+
+###### 2.Enable Remote Access
+$sudo vim /etc/mosquitto/conf.d/default.conf

-2. Enable Remote Access
-```
-sudo vim /etc/mosquitto/conf.d/default.conf
-```
 add the code following as:
 ```
 listener 1883
 protocol mqtt
 listener 8083
 protocol websockets
+allow_anonymous true
 ```
-restart mqtt broker
-```
-sudo systemctl restart mosquitto
-```
+###### 3.restart mqtt broker
+$sudo systemctl restart mosquitto

-3. Robust MQTT
+###### 4.Robust MQTT
 create mosquitto_restart.sh
-```
-cd ~
-sudo vim mosquitto_restart.sh
-```
+
+$cd ~
+$sudo vim mosquitto_restart.sh
+
+
 add the code following as:
 ```
 if [ "`ps -aux | grep /usr/sbin/mosquitto | wc -l`" == "1" ]
@@ -200,25 +232,129 @@ fi
 echo "$SERVICE is currently running" >> /home/ubuntu/cron.log
 exit 0
 ```
-add mosquitto_restart.sh to root routing
-```
-sudo chmod +x mosquitto_restart.sh
-sudo  -i
-crontab -e
-```
+###### 5.add mosquitto_restart.sh to root routing
+$sudo chmod +x mosquitto_restart.sh
+$sudo  -i
+$crontab -e
+
 add the code following as:
 ```
 */5 * * * * /home/pi/mosquitto_restart.sh
 ```
-3. Auto run MQTT broker when when pi-start
-```
-sudo vim /etc/rc.local
-```
+###### 6.Auto run MQTT broker when when pi-start
+$sudo vim /etc/rc.local
+
 add the code following as:
 ```
 sudo nohup systemctl restart mosquitto
 ```

-### Setup routed wireless access point
+### Setting up a Routed Wireless Access Point
+###### 1.Install AP and Management Software
+$sudo apt install hostapd
+$sudo systemctl unmask hostapd
+$sudo systemctl enable hostapd
+$sudo apt install dnsmasq
+$sudo DEBIAN_FRONTEND=noninteractive apt install -y netfilter-persistent iptables-persistent
+
+###### 2.Set up the Network Router
+$sudo nano /etc/dhcpcd.conf
+```
+interface wlan0
+    static ip_address=192.168.2.1/24
+    nohook wpa_supplicant
+```
+$sudo nano /etc/sysctl.d/routed-ap.conf
+```
+# Enable IPv4 routing
+net.ipv4.ip_forward=1
+```
+
+$sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
+$sudo netfilter-persistent save
+$sudo mv /etc/dnsmasq.conf /etc/dnsmasq.conf.orig
+
+
+$sudo nano /etc/dnsmasq.conf
+
+```
+interface=wlan0 # Listening interface
+dhcp-range=192.168.2.2,192.168.2.255,255.255.255.0,24h
+                # Pool of IP addresses served via DHCP
+domain=wlan     # Local wireless DNS domain
+address=/gw.wlan/192.168.2.1
+                # Alias for this router
+```
+###### 3.Ensure Wireless Operation
+$sudo rfkill unblock wlan
+
+###### 4.Configure the AP Software
+$sudo nano /etc/hostapd/hostapd.conf
+
+```
+country_code=TW
+interface=wlan0
+ssid=WTP_NONE
+hw_mode=g
+channel=7
+macaddr_acl=0
+auth_algs=1
+ignore_broadcast_ssid=0
+wpa=2
+wpa_passphrase=00000000
+wpa_key_mgmt=WPA-PSK
+wpa_pairwise=TKIP
+rsn_pairwise=CCMP
+
+# 802.11n support
+ieee80211n=1
+# make raspberry pi dongle fast
+wme_enabled=1
+# ht_capab: HT capabilities, enable 40MHz
+ht_capab=[HT40+][SHORT-GI-40]
+```
+###### 5.Running the new Wireless AP
+$sudo systemctl reboot
+
+
+### Set web site
+$sudo vim ./sites-available/000-default.conf
+```
+<VirtualHost *:8080> #80------>8080
+        # The ServerName directive sets the request scheme, hostname and port that
+        # the server uses to identify itself. This is used when creating
+        # redirection URLs. In the context of virtual hosts, the ServerName
+        # specifies what hostname must appear in the request's Host: header to
+        # match this virtual host. For the default virtual host (this file) this
+        # value is not decisive as it is used as a last resort host regardless.
+        # However, you must set it for any further virtual host explicitly.
+        #ServerName www.example.com
+
+        ServerAdmin webmaster@localhost
+        DocumentRoot /var/www/html
+
+        # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
+        # error, crit, alert, emerg.
+        # It is also possible to configure the loglevel for particular
+        # modules, e.g.
+        #LogLevel info ssl:warn
+
+        ErrorLog ${APACHE_LOG_DIR}/error.log
+        CustomLog ${APACHE_LOG_DIR}/access.log combined
+
+        # For most configuration files from conf-available/, which are
+        # enabled or disabled at a global level, it is possible to
+        # include a line for only one particular virtual host. For example the
+        # following line enables the CGI configuration for this host only
+        # after it has been globally disabled with "a2disconf".
+        #Include conf-available/serve-cgi-bin.conf
+</VirtualHost>
+
+<VirtualHost *:80>
+    ServerAdmin bioprovue@localhost
+    DocumentRoot /var/www/bioprovuebuild
+</VirtualHost>
+```
+
 ##### raspberry website document:
 > https://www.raspberrypi.org/documentation/configuration/wireless/access-point-routed.md
@@ -1578,10 +1578,13 @@ class ControlAPI(metaclass=Router):
        raise NotImplementedError()
    
    def run_project(self, project) -> bool:
-        print('create_project', project)
-        self._project_manager.create(project)
-        return False
+        raise NotImplementedError()

+    def get_running_project(self) -> bool:
+        raise NotImplementedError()
+    
+    def stop_project(self, project) -> bool:
+        raise NotImplementedError()

 # noinspection PyAbstractClass
 class ControlClient(SocketClient, ControlAPI, metaclass=SocketClientMacro(ControlAPI)):
@@ -6,6 +6,8 @@ from datetime import datetime

 from biopro.recording import RecordingData, RecordingFileDataFormat

+import numpy as np
+
 # from biopro.util.console import hex_line

 T = TypeVar('T')
@@ -881,12 +883,17 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
    def decode(self, data: bytes) -> Optional[RecordingData]:
        if len(data) < 18:
            return None
-
+        voltage = 0
        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
-        voltage = struct.unpack('<i', data[12:16])[0]  # unit: uV
+        ch2 = 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]
@@ -945,18 +952,18 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
        ret.append_data(1, voltage)
        ret.append_data(2, impedance)
        ret.append_data(3, cycle_number)
-        ret.append_data(4, battery)
-        ret.append_data(5, elite_notify_times)
-        ret.append_data(6, mem_cnt)
+        # ret.append_data(4, battery)
+        # ret.append_data(5, elite_notify_times)
+        # ret.append_data(6, mem_cnt)

-        # memoryboard information
-        ret.append_data(7, ram_num)
-        ret.append_data(8, broken_flag)
-        try:
-            ret.append_data(9, mem_wrong_information)
-            # print('append_data success, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))
-        except:
-            print('append_data fail, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))
+        # # memoryboard information
+        # ret.append_data(7, ram_num)
+        # ret.append_data(8, broken_flag)
+        # try:
+        #     ret.append_data(9, mem_wrong_information)
+        #     # print('append_data success, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))
+        # except:
+        #     print('append_data fail, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))


    
@@ -1396,39 +1403,33 @@ class EISZeroOneDataDecoder(RecDataDecoder):
            hsrtia_a.append(struct.unpack('>i', cali_coeff[index+1:index+5])[0]/1e8)
            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_d.append(struct.unpack('>B', cali_coeff[index+13:index+14])[0])

            #Lv[1] 20k
            index = 80
            hsrtia_a.append(struct.unpack('>i', cali_coeff[index+1:index+5])[0]/1e8)
            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_d.append(struct.unpack('>B', cali_coeff[index+13:index+14])[0])

            #Lv[2] 5k
            index = 100
            hsrtia_a.append(struct.unpack('>i', cali_coeff[index+1:index+5])[0]/1e8)
            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_d.append(struct.unpack('>B', cali_coeff[index+13:index+14])[0])

            #Lv[3] 200R
            index = 120
            hsrtia_a.append(struct.unpack('>i', cali_coeff[index+1:index+5])[0]/1e8)
            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_d.append(struct.unpack('>B', cali_coeff[index+13:index+14])[0])

            # 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)
-            # hsrtia_d.append(struct.unpack('>I', cali_coeff[index+13:index+17])[0]/1e6)

            # print('cutoff_freq', cutoff_freq)
            # print('hsrtia_a', hsrtia_a)
            # print('hsrtia_b', hsrtia_b)
            # print('hsrtia_c', hsrtia_c)
-            # print('hsrtia_d', hsrtia_d)
            # print('phase_para_a', phase_para_a)
            # print('phase_para_b', phase_para_b)

@@ -1585,10 +1586,10 @@ class EISZeroOneDataDecoder(RecDataDecoder):

        ret = RecordingData(self.device, int(time_stamp * 1000 / 2), 0)
        if (self._mode == 0):                           #EIS Mode
-            ret.append_data(3, cycle_number)
            ret.append_data(0, ch1)                     #Raw Imag  
            ret.append_data(1, ch2)                     #Raw Real
            ret.append_data(2, ch3 * 10)                #Frequency [mHz]
+            ret.append_data(3, cycle_number)
            ret.append_data(4, round(imag_after_cal))   #Z_imag [Ohm]
            ret.append_data(5, round(real_after_cal))   #Z_real [Ohm]
            ret.append_data(6, round(impedance))        #Impedance [Ohm]
@@ -1597,10 +1598,10 @@ class EISZeroOneDataDecoder(RecDataDecoder):
            ret.append_data(9, gain)                    #Gain Level

        else:                                           #CV Mode
-            ret.append_data(3, cycle_number)
            ret.append_data(0, ch1)                     #Iin     [nA]
            ret.append_data(1, ch2)                     #Vset    [nV]
            ret.append_data(2, ch3)                     #Vout    [nV]
+            ret.append_data(3, cycle_number)

        if cycle_number != self._cycle_number:
            # notify cycle_number change
@@ -653,15 +653,9 @@ class DeviceInstruction:

    VIS_CC_ZERO = 0x40

-    VIS_ASK = 0x30
-    """ask in virtual instruction"""
-
    VIS_STI = 0xC0
    """stimulation on virtual instruction"""

-    VIS_FUH = 0x90
-    """flush virtual instruction"""
-
    VIS_INT = 0x60
    """interrupt virtual instruction"""

@@ -750,8 +744,6 @@ class DeviceCommonInstruction:
            return '_sync(False)', '_notify(False)', 'VIS_INT'
        elif instruction == cls.CLOSE:
            return '_sync(False)', '_notify(False)', 'VIS_INT'
-        elif instruction == cls.FLUSH:
-            return 'VIS_FUH',
        elif instruction == cls.CALL:
            return 'VIS_CAL',
        elif instruction == cls.VIS_DEVICE_DETECT:
@@ -4,6 +4,7 @@ from biopro.util.text import part_suffix
 from . import *
 from .expression import *

+import json

 class DeviceParameterError(RuntimeError):
    __slots__ = ()
@@ -309,6 +310,8 @@ class ParameterValueDomain(ParameterDomain, metaclass=abc.ABCMeta):
                return f

    def valid_para(self, value: Any) -> bool:
+        if isinstance(value, list):
+            return True
        f, t = self.range
        return f <= float(value) < t

@@ -489,8 +492,12 @@ class ParameterCollectionValueOperator(metaclass=abc.ABCMeta):

    @classmethod
    def parse(cls, expr: Union[int, str]) -> 'ParameterCollectionValueOperator':
+        # parse epression then create value_operator
        if isinstance(expr, int):
            return SingleValueOperator(None, expr)
+        
+        elif isinstance(expr, list):
+            return CollectValueOperator((0, len(expr)), expr)

        elif expr == '*':
            return AddAllValueOperator
@@ -498,6 +505,10 @@ class ParameterCollectionValueOperator(metaclass=abc.ABCMeta):
        elif expr == ':=':
            return CollectValueOperator((None, None), [])

+        elif '[' in expr and ']' in expr:
+            v = json.loads(expr)
+            return CollectValueOperator((0, len(v)), v)
+
        elif '=' in expr:
            a, v = part_suffix(expr, '=')

@@ -508,6 +519,7 @@ class ParameterCollectionValueOperator(metaclass=abc.ABCMeta):
                    return CollectValueOperator((None, None), v)

                else:
+                    # get list length (old way)
                    a, b = part_suffix(a, ':')
                    a = int(a) if len(a) else None
                    b = int(b) if len(b) else None
@@ -602,8 +614,8 @@ class ParameterCollectionDomain(ParameterDomain, metaclass=abc.ABCMeta):
    def __init__(self, domain: ParameterDomain):
        super().__init__()

-        if isinstance(domain, ParameterCollectionDomain):
-            raise RuntimeError('cannot compose with parameter collection domain')
+        # if isinstance(domain, ParameterCollectionDomain):
+        #     raise RuntimeError('cannot compose with parameter collection domain')

        self._domain = domain

@@ -725,6 +737,7 @@ class ParameterListDomain(ParameterCollectionDomain):
        if oper == AddAllValueOperator:
            raise ValueError("list parameter cannot accept '*' (all) value")

+        # d: domain, sz: lsit length, i: slice(a, b), v: list value
        d = self.element_domain
        sz = len(target)
        i = oper.index(sz)
@@ -119,7 +119,10 @@ class DeviceConfigurationEncoder:
                e.write(b'L\0')

            else:
-                parameter_type = cls._value_type(value[0])
+                parameter_type = cls._value_type(max(value))
+                for v in value:
+                    if isinstance(v, int) and v < 0:
+                        parameter_type = parameter_type.lower()
                e.write(b'L')
                e.write(parameter_type.encode())
                e.u8(sz)
@@ -153,7 +156,8 @@ class DeviceConfigurationEncoder:
        if isinstance(value, bool):
            e.u8(1 if value else 0)

-        elif isinstance(value, str):
+        elif isinstance(value, str) or isinstance(value, list):
+            value = str(value)
            e.encode_string(value)

        elif isinstance(value, int):
@@ -170,7 +174,7 @@ class DeviceConfigurationEncoder:
        if isinstance(value, bool):
            return '?'

-        elif isinstance(value, str):
+        elif isinstance(value, str) or isinstance(value, list):
            return 'p'

        elif isinstance(value, int):
@@ -510,9 +510,10 @@ class DeviceParameter(JsonSerialize):
        :param para: parameter name
        :param oper: operator expression
        """
+        # parse operator return CollectValueOperator instance
        if not isinstance(oper, ParameterCollectionValueOperator):
            oper = ParameterCollectionValueOperator.parse(oper)
-
+        
        table = self._library.parameter_table
        info = table[para]
        domain = info.domain
@@ -528,6 +529,7 @@ class DeviceParameter(JsonSerialize):
            old = list(target)

        try:
+            # replace target with new oper
            domain.oper_para(target, oper, self._context)
        except RuntimeError as e:
            raise IllegalParameterValueError(para, str(oper)) from e
@@ -1012,6 +1014,10 @@ class CompletedDevice(Device):
    def device_id(self) -> int:
        return self._device_id

+    @property
+    def memory_board(self) -> int:
+        return self._device_id
+
    @property
    def device_name(self) -> str:
        return self._device.device_name
@@ -1130,7 +1136,8 @@ class CompletedDevice(Device):
                self._master.log_warn('on_change instruction not found : ' + on_change)

            else:
-                self.call_instruction(on_change)
+                if self._status == 1:
+                    self.call_instruction(on_change)

    # device instruction call

@@ -1273,15 +1280,20 @@ class CompletedDevice(Device):

    def as_json(self) -> JSON_OBJECT:
        return {
+            'id': self.device_id,
+            'name': self.device_name,
+            'status': self._status,
            'device_id':       self.device_id,
            'device_name':     self.device_name,
            'device_address':  list(self.mac_address),
            'device_status': self._status,
+            'mac_address': self.mac_address_in_str,
+            'memory_board': self.memory_board,
+            'serial_number':   self.serial_number.as_json(),
+            'version':  self.device_version,
            'battery':         self.battery,
            'parent':          self.parent,
            'recording_file_name':      self.recording_file_name,
-            'device_version':  self.device_version,
-            'serial_number':   self.serial_number.as_json(),
            'library_name':    self._library.name,
            'library_version': str(self._library.version),
            'configuration':   self.configuration.as_json(list_hide=True),
@@ -76,6 +76,8 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):

    def set_pin_mem_req(self, value: bool):
        channel = self.select
+        # if self._pin_mem_req_value[channel] == value:
+        #     print('last_req_sig[channel] == value', channel, self._pin_mem_req_value[channel], value, datetime.now())
        self.pin_mem_req.output(value)
        self._pin_mem_req_value[channel] = value

@@ -118,13 +118,13 @@ class Selector:
        self._p2.output(p[2])

        # if (value == 4 and self._last_sel != 6):
-        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel)
+        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel, datetime.now())
        # elif (value == 5 and self._last_sel != 4):
-        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel)
+        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel, datetime.now())
        # elif (value == 7 and self._last_sel != 5):
-        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel)
+        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel, datetime.now())
        # elif (value == 6 and self._last_sel != 7):
-        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel)
+        #     print('mem_sel is not use gray code, value:', value, ', last value:', self._last_sel, datetime.now())
            
        self._last_sel = value

@@ -29,16 +29,18 @@ class Project(threading.Thread):
    self._end_time = None

    self._id = None
-    self._uuid = uuid4()
+    self._uuid = str(uuid4())
    self._name = None
    self._desc = None
    self._device = None
    self._complete_device = []
-    self._status = None
+    self._status = 0

    self._instruction_set = Instruction()
    self._stop_flag  = False

+    self._task_manager = None
+
    self.setup_project(project)
    self.setup_device(self._device)
  
@@ -49,6 +51,8 @@ class Project(threading.Thread):

      if key == 'task':
        self._task_manager = TaskManager(project['task'])
+      elif key == 'uuid':
+        pass
      else:
        setattr(self, key, value)
      
@@ -107,17 +111,17 @@ class Project(threading.Thread):
  
  @property
  def task_list(self):
-    return self.task_manager.task_list
+    return self._task_manager.export_task_list

-  
  @property
  def mqtt_thread(self):
    return self._mqtt_thread

  def run(self):
+      self._status = 1
      self._start_time = time()
-
-      self.mqtt_thread.broadcast_command('project:' + self._name + ' start_at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+      self.mqtt_thread.broadcast_command('project:' + self._name + ' start at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+      
      while not self._stop_flag :
        # check running task first
        delay_time = 0
@@ -165,7 +169,6 @@ class Project(threading.Thread):
        
        # check project done then close project
        if self.check_project_done() == True:
-          self.mqtt_thread.broadcast_command('project:project ' + str(self._name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
          print('project stop at', datetime.now())
          self.close()
        
@@ -176,9 +179,19 @@ class Project(threading.Thread):
    # TODO
    pass

-  def close(self):
+  def stop(self):
+    self._task_manager.running_task.stop()
+    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._status = 2
    self._end_time = time()
    self._stop_flag  = True
+    self.mqtt_thread.broadcast_command('project:project ' + str(self._name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+
+  def close(self):
+    self._status = 2
+    self._end_time = time()
+    self._stop_flag  = True
+    self.mqtt_thread.broadcast_command('project:project ' + str(self._name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])

  def check_project_done(self):
    for task in self._task_manager.task_list:
@@ -191,19 +204,21 @@ class Project(threading.Thread):
    # if no running task
    if self._task_manager.running_task == None:
      return False
-    device_list = self._task_manager.running_task.device
-    for device in device_list:
+
+    for device in self._task_manager.running_task.device:
      if self._complete_device[device].status == 1:
        return False
    return True
  
  def as_json(self):
-    return {
+    data = {
      'id': self._id,
      'name': self._name,
      'uuid': self._uuid,
      'desc': self._desc,
      'status': self._status,
      'device': self._device,
-      'task_list': self.task_list,
+      'task': self.task_list,
+      'running_task': self._task_manager.running_task.as_json()
    }
+    return data
@@ -23,11 +23,17 @@ class ProjectManager():
      self._project_list[index].stop()
      del self._project_list[index]

-    def get(self):
-      return self._project_list
+    def get(self, project_uuid = None):
+      if project_uuid == None:
+        return self._project_list
+      else:
+        for project in self._project_list:
+          if project.uuid == project_uuid:
+            return project

-    def run(self, project):
+    def run_project(self, project):
      project.start()

-    def stop(self, project):
-      project.stop()
+    def stop_project(self, project):
+      _project = self.get(project)
+      _project.stop()
@@ -28,6 +28,10 @@ class TaskManager():
    def task_list(self):
      return self._task_list

+    @property
+    def export_task_list(self):
+      return [d.as_json() for d in self._task_list]
+
    @property
    def prev_task(self):
      return self._prev_task
@@ -20,6 +20,11 @@ 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:
@@ -1015,7 +1020,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')
+                 '_mini_create_not_done', '_data_all')

    def __init__(self, meta: RecordingMetaFile, device_id, database = None):
        self._meta = meta
@@ -1075,6 +1080,8 @@ class RecordingFileWriter:
        self._data_time_ch = {}
        self._id_db_save = {}

+        self._data_all = {}
+
        # mini data
        self._data_mini_ch = {}

@@ -1131,14 +1138,17 @@ class RecordingFileWriter:
        self._splitting_size = 0
        return None

-    def close(self):
-        # if self._recording_file is not None:
-        #     self._recording_file.close()
-        #     self._recording_file = None
-        print('close1')
+    def close(self, mqtt_thread):
        self._close = True
        if len(self._recording_file_dict) > 0:
            for ch in self._data_db.keys():
+                if len(self._data_rl[ch]) > 0:
+                    self._data_rl[ch].append(str(int(self._time_now)))
+                    mes = ' '.join(self._data_rl[ch])
+                    mqtt_thread[ch].on_message(mes)
+                    self._data_rl[ch].clear()
+                    self._send_data[ch] = False
+
                if self._recording_file_dict[ch]._status:
                    _data = ' '.join(self._data_db[ch])
                    self._raw_save['data'][ch] = _data
@@ -1224,17 +1234,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])
-                    # self._data_mqtt_ch[c] = self._data_rl[c].copy()
-                    # self._data_mqtt_ch[c].append(str(int(t)))
+                    # print('message1', mes)
                    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
@@ -1247,40 +1257,35 @@ 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))
-                    # self._data_time_ch[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])
                    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])

-                            # _first_time = self._data_time_ch_for_rl[c][0]
-                            # _last_time = self._data_time_ch_for_rl[c][-1]
+                            # print('_max, _max_index, _min, _min_index', _max, _max_index, _min, _min_index)

                            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()
@@ -1289,9 +1294,6 @@ 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:])) )
@@ -1313,6 +1315,13 @@ 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)
@@ -1360,6 +1369,7 @@ 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] = {}
@@ -1373,6 +1383,37 @@ 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():
@@ -0,0 +1,108 @@
+"""
+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
@@ -117,6 +117,9 @@ class DataServer(SocketServer, DataAPI):
        self.database_process = DataBaseProcess('data_server', self.log_verbose, self._queue_db, self._queue_ds_dict, self._queue_msg)
        self.database_process.start()

+        # self._no_data_total_duration = 0
+        # self._recv_memory_cost_time = 0
+
    @logging_info
    def setup(self):
        self._available_channel.clear()
@@ -666,7 +669,17 @@ class DataServer(SocketServer, DataAPI):
                print("q size= ", self._configurations[device]._queue_rec.qsize())

            self._configurations[device].put_rec_queue(data)
+            # self._no_data_total_duration = 0
            ret = True
+        # else:
+        #     time_diff = time() - self._recv_memory_cost_time
+        #     self._no_data_total_duration += time_diff
+        #     if self._no_data_total_duration > 1:
+        #         print('data is None', device, datetime.now(), self._no_data_total_duration)
+        #         print("sync.get_pin_mem_req() != sync.get_pin_ram_sel()")
+        #         print("no~", sync.select, sync.get_pin_mem_req(), sync.get_pin_ram_sel(), datetime.now())
+        #         print()
+        # self._recv_memory_cost_time = time()

        return ret

@@ -69,7 +69,8 @@ class DataBaseProcess(Process):

        self._data_raw_create_sql_str = None
        self._data_raw_update_sql_str = None
-        self._data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s), end_time=%s, size=%s where id = %s'
+        self._data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s) where id = %s'
+        self._new_data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s), end_time=%s, size=%s where id = %s'
        self._data_mini_recording_sql_str = 'UPDATE "public"."%s_recording_data_minis" SET data_mean = concat(data_mean, %s) where id = %s'

    @property
@@ -384,7 +385,7 @@ class DataBaseProcess(Process):
                para_list.append([_channel, _data_dict[_channel] + '"***"', _end_time_dict[_channel], _size_dict[_channel], _id_dict[_channel]])
            with self._psql_conn as conn:
                with conn.cursor() as sql_cursor:
-                    execute_batch(sql_cursor, self._data_raw_recording_sql_str, para_list)
+                    execute_batch(sql_cursor, self._new_data_raw_recording_sql_str, para_list)
        except psycopg2.Error as e:
            print('recording error', e)
        return None
@@ -1014,9 +1014,20 @@ class ControlServer(SocketServer, ControlServerAPI):

    @logging_info
    def run_project(self, project) -> bool:
-        project = self._project_manager.create(project)
-        self._project_manager.run(project)
-        return False
+        if project is not None:
+            project = self._project_manager.create(project)
+            self._project_manager.run_project(project)
+        return  project.as_json()
+    
+    @logging_info
+    def stop_project(self, project) -> bool:
+        if project is not None:
+            self._project_manager.stop_project(project)
+        return True
+
+    @logging_info
+    def get_running_project(self) -> bool:
+        return   self._project_manager.get()

    @logging_info
    def device_internal_command(self, device: int, oper: str, value: Any) -> bool:
@@ -105,6 +105,9 @@ class RecordingProcess(Process):
        self._mem_tailer_len = 6
        self._single_data_len = self._elite_data_len + self._mem_header_len + self._mem_tailer_len

+        self._decoder = self.data_format()
+        self._start_time = time()
+
    def ensure_data_format(self) -> DataDecodeFormat:
        if isinstance(self._data_format, (str, bytes)):
            self._data_format = DataDecodeFormat.parse(self._data_format)
@@ -133,9 +136,9 @@ class RecordingProcess(Process):
            decoder._prev_data = self._prev_data
            decoder._prev_delta_time = self._prev_delta_time
            decoder._prev_time_stamp = self._prev_time_stamp
-        # elif isinstance(decoder, I4V4Z4T4DataDecoder):
+        elif isinstance(decoder, I4V4Z4T4DataDecoder):
            # get cycle_time from meta file
-            # decoder._mode = self._meta_file.configuration.MODE
+            decoder._mode = self._meta_file.configuration.get_parameter('MODE')
            # decoder._cycle_start_time = self._cycle_start_time
        elif isinstance(decoder, NeuliveThreeOneDataDecoder):
            # get amp_gain from meta file
@@ -151,9 +154,8 @@ class RecordingProcess(Process):
            decoder._prev_time_stamp = self._prev_time_stamp
        elif isinstance(decoder, EISZeroOneDataDecoder):
            # get amp_gain from meta file
-
-            decoder._ac_amp = self._meta_file.configuration.get_parameter('AC_AMP')
            decoder._mode = self._meta_file.configuration.get_parameter('MODE')
+            decoder._ac_amp = self._meta_file.configuration.get_parameter('AC_AMP')
            decoder._freq_start = self._meta_file.configuration.get_parameter('FREQ_START')
            decoder._freq_stop = self._meta_file.configuration.get_parameter('FREQ_STOP')

@@ -200,14 +202,13 @@ class RecordingProcess(Process):
                self._isTimeOut = True
        self._timer = current_time

-        decoder = self.data_format()
        # print('sync_data')
        # print('data',data)

        # print('server/data', self._prev_delta_time,self._prev_time_stamp, self._prev_data)

        if data is None or len(data) == 0:
-            result = decoder.decode(b'')
+            result = self._decoder.decode(b'')
            if result is not None:
                ret = result

@@ -221,31 +222,19 @@ class RecordingProcess(Process):
            for offset, section in self._foreach_data_section(data):
            # for section in self._neu_foreach_data_section(data):

-                result = decoder.decode(section)
+                result = self._decoder.decode(section)
                # if self._isTimeOut:
                #     try:
                #         print('result: ', result.data_size)
                #     except:
                #         pass

-                try:
-                    if isinstance(decoder, I4V4Z4T4DataDecoder) or isinstance(decoder, EISZeroOneDataDecoder):
-                        if decoder.isFinishMode is not None and decoder.isFinishMode() == 1:
-                            self._queue_msg.put(['ds', self._device, 'interrupt'])
-                            # content = {}
-                            # content['header'] = 'device_instruction/0'
-                            # content['device'] = result.device
-                            # content['instruction'] = 'interrupt'
-                            # self._mqtt_thread.publish('device_instruction',json_stringify(content), True)
-                            # self.server.stop_sync(self.device)
-                except RuntimeError as e:
-                    print(e)
-
                if result is not None:
                    ##
                    if len(self._mqtt_send_data_ch_level) == 0:
                        for ch in result.channels():
                            self._mqtt_send_data_ch_level[ch] = MqttDataMessageHandler(self._mqtt_thread, 'data_server/device_data_stream/' + str(result.device) + '/' + str(ch) ) 
+                            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
@@ -257,9 +246,27 @@ class RecordingProcess(Process):
                self._writer.channels_update(ret[0].channels())
            self._writer.write(ret, self._mqtt_send_data_ch_level)
        # print('write time: ', time() - ctime1)
-
        # print(ret)

+        try:
+            time_duration = self._meta_file.configuration.get_parameter('TIME_DURATION')
+            if time_duration and time_duration is not 0 and time() - self._start_time >= time_duration:
+                self._queue_msg.put(['ds', self._device, 'interrupt'])
+                return None
+
+            if isinstance(self._decoder, I4V4Z4T4DataDecoder) or isinstance(self._decoder, EISZeroOneDataDecoder):
+                if self._decoder.isFinishMode is not None and self._decoder.isFinishMode() == 1:
+                    self._queue_msg.put(['ds', self._device, 'interrupt'])
+                    return None
+                    # content = {}
+                    # content['header'] = 'device_instruction/0'
+                    # content['device'] = result.device
+                    # content['instruction'] = 'interrupt'
+                    # self._mqtt_thread.publish('device_instruction',json_stringify(content), True)
+                    # self.server.stop_sync(self.device)
+        except RuntimeError as e:
+            print(e)
+
        del ret
        del data
        return 
@@ -297,8 +304,8 @@ class RecordingProcess(Process):
                    self._last_cnt[7] = head_counter - 1
                last_data_cnt = self._last_cnt[7]

-            # dont save to section when head or id is wrong
-            if (head != 255 or device_id != device):
+           # dont save to section when head or id is wrong
+            if (head != 255 or device_id != device or head_counter > 255 or head_counter < 0):
                save = False
                last_data_cnt = last_data_cnt + 1

@@ -349,13 +356,14 @@ class RecordingProcess(Process):

        if colum_total == 1:
            print('this ram data < 3 records, colum_total = ', colum_total)
-            print('raw_data[0]', raw_data[0])
-            return save
+            print('raw_data[0]', list(raw_data[0]))
+            save = True
+            # return save

        elif colum_total == 2:
            print('this ram data < 3 records, colum_total = ', colum_total)
-            print('raw_data[0]', raw_data[0])
-            print('raw_data[1]', raw_data[1])
+            print('raw_data[0]', list(raw_data[0]))
+            print('raw_data[1]', list(raw_data[1]))
            if (raw_data[col + 1][1] - raw_data[col][1] == 1) or (raw_data[col][1] == 255 and raw_data[col + 1][1] == 0):
                save = True

@@ -599,7 +607,7 @@ class RecordingProcess(Process):

    def final_write(self):
        if self._writer is not None:
-            return self._writer.close()
+            return self._writer.close(self._mqtt_send_data_ch_level)
        else:
            return False
    
@@ -1,5 +1,5 @@
 {
-  "name": "EliteZM02",
+  "name": "Elite_EDC_1.4",
  "version": "1.2.30",
  "match_rule": {
    "local_name_pattern": "Elite.*",
@@ -1,5 +1,5 @@
 {
-  "name": "EliteZM15",
+  "name": "Elite_EDC_1.5",
  "version": "1.2.30",
  "match_rule": {
    "local_name_pattern": "Elite.*",
@@ -9,6 +9,7 @@
    "minor_version_number": 6
  },
  "constant": {
+    "TIME_MAX": 100000,
    "VOLT_MAX": 65536,
    "Const_Current_Range": 1500001,
    "BLE_WRITE_MAX": 255
@@ -17,7 +18,7 @@
    "DPV_e_init": {
      "description": "DPV initial voltage ",
      "record_meta": true,
-      "initial":20000,
+      "initial": 20000,
      "domain": [
        50001
      ],
@@ -28,7 +29,7 @@
    "DPV_e_final": {
      "description": "DPV final voltage",
      "record_meta": true,
-      "initial":30000,
+      "initial": 30000,
      "domain": [
        50001
      ],
@@ -39,7 +40,7 @@
    "DPV_e_1": {
      "description": "DPV voltage return 1",
      "record_meta": true,
-      "initial":35000,
+      "initial": 35000,
      "domain": [
        50001
      ],
@@ -50,7 +51,7 @@
    "DPV_e_2": {
      "description": "DPV voltage return 2",
      "record_meta": true,
-      "initial":15000,
+      "initial": 15000,
      "domain": [
        50001
      ],
@@ -61,7 +62,7 @@
    "DPV_amp": {
      "description": "DPV pulse amplitude",
      "record_meta": true,
-      "initial":25125,
+      "initial": 25125,
      "domain": [
        50001
      ],
@@ -72,7 +73,7 @@
    "DPV_pul_width": {
      "description": "DPV pulse width",
      "record_meta": true,
-      "initial":50,
+      "initial": 50,
      "domain": [
        1000001
      ],
@@ -83,7 +84,7 @@
    "DPV_increment": {
      "description": "DPV increment",
      "record_meta": true,
-      "initial":25025,
+      "initial": 25025,
      "domain": [
        50001
      ],
@@ -94,7 +95,7 @@
    "DPV_step_time": {
      "description": "DPV step time = time of one period",
      "record_meta": true,
-      "initial":500,
+      "initial": 500,
      "domain": [
        1000001
      ],
@@ -105,7 +106,7 @@
    "DPV_notify_rate": {
      "description": "DPV sample rate",
      "record_meta": true,
-      "initial":1000,
+      "initial": 1000,
      "domain": [
        1001
      ],
@@ -113,10 +114,24 @@
        "expression": "VALUE"
      }
    },
+    "DPV_curr_rec": {
+      "description": "DPV current recording period start",
+      "record_meta": true,
+      "initial": [
+        25,
+        100
+      ],
+      "domain": {
+        "list": [
+          101
+        ]
+      },
+      "value": "VALUE"
+    },
    "DPV_curr_rec_min": {
      "description": "DPV current recording period start",
      "record_meta": true,
-      "initial":25,
+      "initial": 25,
      "domain": [
        101
      ],
@@ -127,7 +142,7 @@
    "DPV_curr_rec_max": {
      "description": "DPV current recording period end",
      "record_meta": true,
-      "initial":100,
+      "initial": 100,
      "domain": [
        101
      ],
@@ -138,11 +153,8 @@
    "DPV_pulse_option": {
      "description": "Invert of pulse option",
      "record_meta": true,
-      "initial": 0,
-      "value": [
-        0,
-        1
-      ]
+      "domain": "bool",
+      "initial": false
    },
    "DPV_mode": {
      "description": "AUTO: 0 / ADVANCED: 1/ ENGINEERING: 2",
@@ -157,16 +169,29 @@
    "DPV_engineering_enable": {
      "description": "Engineering mode switch",
      "record_meta": true,
-      "initial": 0,
-      "value": [
-        0,
-        1
-      ]
+      "domain": "bool",
+      "initial": false
+    },
+    "V_initial": {
+      "description": "Pulse Mode Segment Voltage",
+      "record_meta": true,
+      "initial": [
+        50000,
+        25000,
+        25000,
+        25000
+      ],
+      "domain": {
+        "list": [
+          50001
+        ]
+      },
+      "value": "VALUE"
    },
    "V_initial_0": {
      "description": "Pulse Mode Segment Voltage 0",
      "record_meta": true,
-      "initial":50000,
+      "initial": 50000,
      "domain": [
        50001
      ],
@@ -177,7 +202,7 @@
    "V_initial_1": {
      "description": "Pulse Mode Segment Voltage 1",
      "record_meta": true,
-      "initial":25000,
+      "initial": 25000,
      "domain": [
        50001
      ],
@@ -188,7 +213,7 @@
    "V_initial_2": {
      "description": "Pulse Mode Segment Voltage 2",
      "record_meta": true,
-      "initial":25000,
+      "initial": 25000,
      "domain": [
        50001
      ],
@@ -199,7 +224,7 @@
    "V_initial_3": {
      "description": "Pulse Mode Segment Voltage 3",
      "record_meta": true,
-      "initial":25000,
+      "initial": 25000,
      "domain": [
        50001
      ],
@@ -207,10 +232,26 @@
        "expression": "VALUE"
      }
    },
+    "t_pulse": {
+      "description": "Pulse Mode Segment Duration",
+      "record_meta": true,
+      "initial": [
+        750,
+        9250,
+        1000,
+        1000
+      ],
+      "domain": {
+        "list": [
+          1000001
+        ]
+      },
+      "value": "VALUE"
+    },
    "t_pulse_0": {
      "description": "Pulse Mode Segment Duration 0",
      "record_meta": true,
-      "initial":750,
+      "initial": 750,
      "domain": [
        1000001
      ],
@@ -221,7 +262,7 @@
    "t_pulse_1": {
      "description": "Pulse Mode Segment Duration 1",
      "record_meta": true,
-      "initial":9250,
+      "initial": 9250,
      "domain": [
        1000001
      ],
@@ -232,7 +273,7 @@
    "t_pulse_2": {
      "description": "Pulse Mode Segment Duration 2",
      "record_meta": true,
-      "initial":1000,
+      "initial": 1000,
      "domain": [
        1000001
      ],
@@ -243,7 +284,7 @@
    "t_pulse_3": {
      "description": "Pulse Mode Segment Duration 3",
      "record_meta": true,
-      "initial":1000,
+      "initial": 1000,
      "domain": [
        1000001
      ],
@@ -251,10 +292,40 @@
        "expression": "VALUE"
      }
    },
+    "CURR_REC": {
+      "description": "Pulse Mode Current Recording Period",
+      "record_meta": true,
+      "initial": [
+        [
+          35,
+          90
+        ],
+        [
+          35,
+          99
+        ],
+        [
+          35,
+          95
+        ],
+        [
+          35,
+          95
+        ]
+      ],
+      "domain": {
+        "list": {
+          "list": [
+            100
+          ]
+        }
+      },
+      "value": "VALUE"
+    },
    "CURR_REC_START_0": {
      "description": "Pulse Mode Current Recording Period Start",
      "record_meta": true,
-      "initial":35,
+      "initial": 35,
      "domain": [
        100
      ],
@@ -265,7 +336,7 @@
    "CURR_REC_START_1": {
      "description": "Pulse Mode Current Recording Period Start",
      "record_meta": true,
-      "initial":35,
+      "initial": 35,
      "domain": [
        100
      ],
@@ -276,7 +347,7 @@
    "CURR_REC_START_2": {
      "description": "Pulse Mode Current Recording Period Start",
      "record_meta": true,
-      "initial":35,
+      "initial": 35,
      "domain": [
        100
      ],
@@ -287,7 +358,7 @@
    "CURR_REC_START_3": {
      "description": "Pulse Mode Current Recording Period Start",
      "record_meta": true,
-      "initial":35,
+      "initial": 35,
      "domain": [
        100
      ],
@@ -298,7 +369,7 @@
    "CURR_REC_END_0": {
      "description": "Pulse Mode Current Recording Period End",
      "record_meta": true,
-      "initial":90,
+      "initial": 90,
      "domain": [
        100
      ],
@@ -309,7 +380,7 @@
    "CURR_REC_END_1": {
      "description": "Pulse Mode Current Recording Period End",
      "record_meta": true,
-      "initial":99,
+      "initial": 99,
      "domain": [
        100
      ],
@@ -320,7 +391,7 @@
    "CURR_REC_END_2": {
      "description": "Pulse Mode Current Recording Period End",
      "record_meta": true,
-      "initial":95,
+      "initial": 95,
      "domain": [
        100
      ],
@@ -331,7 +402,7 @@
    "CURR_REC_END_3": {
      "description": "Pulse Mode Current Recording Period End",
      "record_meta": true,
-      "initial":95,
+      "initial": 95,
      "domain": [
        100
      ],
@@ -339,6 +410,40 @@
        "expression": "VALUE"
      }
    },
+    "segment_ui_order": {
+      "description": "Pulse Mode Segment Order",
+      "record_meta": true,
+      "initial": [
+        0,
+        1,
+        -1,
+        -1
+      ],
+      "domain": {
+        "list": [
+          -1,
+          6
+        ]
+      },
+      "value": "VALUE"
+    },
+    "segment_order": {
+      "description": "Pulse Mode Segment Order",
+      "record_meta": true,
+      "initial": [
+        0,
+        1,
+        -1,
+        -1
+      ],
+      "domain": {
+        "list": [
+          -1,
+          6
+        ]
+      },
+      "value": "VALUE"
+    },
    "segment_ui_order_0": {
      "description": "Pulse Mode Segment UI Order 0, value: segment ID + 1",
      "record_meta": true,
@@ -478,13 +583,14 @@
        "Constant Current",
        "Cyclic Voltammetry",
        "Linear Sweep Voltammetry",
-        "Chronoamperometric Graph",
+        "Chronoamperometric",
        "Cali DAC - test",
        "Cali ADC - test",
        "Dev Mode",
        "Open Circuit Potential",
        "Pulse Sensing",
-	      "Differential Pulse Voltammetry (DPV)"
+        "Differential Pulse Voltammetry (DPV)",
+        "Chronopotentiometry"
      ]
    },
    "VOLT_ORIGIN": {
@@ -644,7 +750,7 @@
    },
    "CURRNET_LIMIT_VALUE": {
      "description": "Current value Setting",
-      "initial":1500000,
+      "initial": 1500000,
      "domain": [
        "Const_Current_Range"
      ],
@@ -685,6 +791,15 @@
        "expression": "VALUE"
      }
    },
+    "CC_CP_SPEED": {
+      "description": "charge speed for CC and CP mode",
+      "initial": 1,
+      "value": [
+        "low",
+        "normal",
+        "high"
+      ]
+    },
    "ADC_LEVEL_I_15": {
      "description": "ADC level",
      "record_meta": true,
@@ -762,6 +877,17 @@
        "s",
        "ms"
      ]
+    },
+    "TIME_DURATION": {
+      "description": "Run duration",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
    }
  },
  "instruction": {
@@ -812,7 +938,8 @@
          "7": "set_adc_gain_I",
          "8": "set_adc_gain_I",
          "9": "set_adc_gain_I",
-          "13": "set_adc_gain_I"
+          "13": "set_adc_gain_I",
+          "16": "set_adc_gain_I"
        }
      },
      {
@@ -827,7 +954,8 @@
          "7": "set_adc_gain_Vin",
          "8": "set_adc_gain_Vin",
          "9": "set_adc_gain_Vin",
-          "13": "set_adc_gain_Vin"
+          "13": "set_adc_gain_Vin",
+          "16": "set_adc_gain_Vin"
        }
      },
      {
@@ -845,7 +973,8 @@
          "9": "curve_const_vscan",
          "13": "curve_ocp",
          "14": "curve_pulse_sensing",
-          "15": "curve_dpv"
+          "15": "curve_dpv",
+          "16": "curve_cp"
        }
      },
      {
@@ -1043,6 +1172,7 @@
        "vb": "Const_Current_value",
        "vc": "VOLTSTOP_MAX",
        "vd": "VOLTSTOP_MIN",
+        "ve": "CC_CP_SPEED",
        "pa": "ADC_LEVEL_I_15",
        "pb": "ADC_LEVEL_V_IN_15",
        "pc": "DAC_LEVEL_V_OUT_15",
@@ -1054,7 +1184,31 @@
        "B>va;4B>vb;2B>vc;2B>vd;",
        "4b>pa;4b>pb;",
        "4b>pc;4b>pd;",
-        "2B>pe"
+        "2B>pe;",
+        "4b>0b0001;4b>ve"
+      ]
+    },
+    "curve_cp": {
+      "type": "RIS",
+      "parameter": {
+        "va": "Charge",
+        "vb": "Const_Current_value",
+        "vc": "VOLTSTOP_MAX",
+        "vd": "VOLTSTOP_MIN",
+        "ve": "CC_CP_SPEED",
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pc": "DAC_LEVEL_V_OUT_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
+      "data": [
+        "X07;",
+        "B>va;4B>vb;2B>vc;2B>vd;",
+        "4b>pa;4b>pb;",
+        "4b>pc;4b>pd;",
+        "2B>pe;",
+        "4b>0b0000;4b>ve"
      ]
    },
    "curve_cv3": {
@@ -1180,58 +1334,67 @@
    },
    "curve_pulse_sensing": [
      {
-        "expression": "segment_ui_order_0",
+        "expression": "segment_ui_order[0]",
        "when": {
-          "1": "pul_sen_segment_0",
-          "2": "pul_sen_segment_1",
-          "3": "pul_sen_segment_2",
-          "4": "pul_sen_segment_3"
+          "0": "pul_sen_segment_0",
+          "1": "pul_sen_segment_1",
+          "2": "pul_sen_segment_2",
+          "3": "pul_sen_segment_3"
        }
      },
      {
-        "expression": "segment_ui_order_1",
+        "expression": "segment_ui_order[1]",
        "when": {
-          "1": "pul_sen_segment_0",
-          "2": "pul_sen_segment_1",
-          "3": "pul_sen_segment_2",
-          "4": "pul_sen_segment_3"
+          "0": "pul_sen_segment_0",
+          "1": "pul_sen_segment_1",
+          "2": "pul_sen_segment_2",
+          "3": "pul_sen_segment_3"
        }
      },
      {
-        "expression": "segment_ui_order_2",
+        "expression": "segment_ui_order[2]",
        "when": {
-          "1": "pul_sen_segment_0",
-          "2": "pul_sen_segment_1",
-          "3": "pul_sen_segment_2",
-          "4": "pul_sen_segment_3"
+          "0": "pul_sen_segment_0",
+          "1": "pul_sen_segment_1",
+          "2": "pul_sen_segment_2",
+          "3": "pul_sen_segment_3"
        }
      },
      {
-        "expression": "segment_ui_order_3",
+        "expression": "segment_ui_order[3]",
        "when": {
-          "1": "pul_sen_segment_0",
-          "2": "pul_sen_segment_1",
-          "3": "pul_sen_segment_2",
-          "4": "pul_sen_segment_3"
+          "0": "pul_sen_segment_0",
+          "1": "pul_sen_segment_1",
+          "2": "pul_sen_segment_2",
+          "3": "pul_sen_segment_3"
        }
      },
      "pul_sen_start"
    ],
    "pul_sen_start": {
      "type": "RIS",
+      "parameter": {
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pc": "DAC_LEVEL_V_OUT_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
      "data": [
        "1X0D;",
-        "1XFF"
+        "1XFF",
+        "4b>pa;4b>pb;",
+        "4b>pc;4b>pd"
      ]
    },
    "pul_sen_segment_0": {
      "type": "RIS",
      "parameter": {
-        "va": "V_initial_0",
-        "vb": "t_pulse_0",
-        "vc": "CURR_REC_START_0",
-        "vd": "CURR_REC_END_0",
-        "ve": "segment_order_0 - 1",
+        "va": "V_initial[0]",
+        "vb": "t_pulse[0]",
+        "vc": "CURR_REC[0][0]",
+        "vd": "CURR_REC[0][1]",
+        "ve": "segment_order.index(segment_order[0])",
        "pa": "ADC_LEVEL_I_15",
        "pb": "ADC_LEVEL_V_IN_15",
        "pc": "DAC_LEVEL_V_OUT_15",
@@ -1247,11 +1410,11 @@
    "pul_sen_segment_1": {
      "type": "RIS",
      "parameter": {
-        "va": "V_initial_1",
-        "vb": "t_pulse_1",
-        "vc": "CURR_REC_START_1",
-        "vd": "CURR_REC_END_1",
-        "ve": "segment_order_1 - 1",
+        "va": "V_initial[1]",
+        "vb": "t_pulse[1]",
+        "vc": "CURR_REC[1][0]",
+        "vd": "CURR_REC[1][1]",
+        "ve": "segment_order.index(segment_order[1])",
        "pa": "ADC_LEVEL_I_15",
        "pb": "ADC_LEVEL_V_IN_15",
        "pc": "DAC_LEVEL_V_OUT_15",
@@ -1267,11 +1430,11 @@
    "pul_sen_segment_2": {
      "type": "RIS",
      "parameter": {
-        "va": "V_initial_2",
-        "vb": "t_pulse_2",
-        "vc": "CURR_REC_START_2",
-        "vd": "CURR_REC_END_2",
-        "ve": "segment_order_2 - 1",
+        "va": "V_initial[2]",
+        "vb": "t_pulse[2]",
+        "vc": "CURR_REC[2][0]",
+        "vd": "CURR_REC[2][1]",
+        "ve": "segment_order.index(segment_order[2])",
        "pa": "ADC_LEVEL_I_15",
        "pb": "ADC_LEVEL_V_IN_15",
        "pc": "DAC_LEVEL_V_OUT_15",
@@ -1287,11 +1450,11 @@
    "pul_sen_segment_3": {
      "type": "RIS",
      "parameter": {
-        "va": "V_initial_3",
-        "vb": "t_pulse_3",
-        "vc": "CURR_REC_START_3",
-        "vd": "CURR_REC_END_3",
-        "ve": "segment_order_3 - 1",
+        "va": "V_initial[3]",
+        "vb": "t_pulse[3]",
+        "vc": "CURR_REC[3][0]",
+        "vd": "CURR_REC[3][1]",
+        "ve": "segment_order.index(segment_order[3])",
        "pa": "ADC_LEVEL_I_15",
        "pb": "ADC_LEVEL_V_IN_15",
        "pc": "DAC_LEVEL_V_OUT_15",
@@ -1304,9 +1467,7 @@
        "2B>va;4B>vb;1B>vc;1B>vd;1B>ve"
      ]
    },
-
-
-    "curve_dpv":[
+    "curve_dpv": [
      {
        "expression": "DPV_mode",
        "when": {
@@ -1354,8 +1515,8 @@
      "parameter": {
        "va": "DPV_step_time",
        "vb": "DPV_notify_rate",
-        "vc": "DPV_curr_rec_min",
-        "vd": "DPV_curr_rec_max"
+        "vc": "DPV_curr_rec[0]",
+        "vd": "DPV_curr_rec[1]"
      },
      "data": [
        "1X0E;",
@@ -1365,14 +1526,20 @@
    },
    "dpv_auto_mode_ins_final": {
      "type": "RIS",
+      "parameter": {
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pc": "DAC_LEVEL_V_OUT_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
      "data": [
        "1X0E;",
-        "1XFF"
+        "1XFF;",
+        "4b>pa;4b>pb;",
+        "4b>pc;4b>pd"
      ]
    },
-
-
-
    "dpv_advanced_mode": [
      "dpv_advanced_mode_ins_1",
      "dpv_advanced_mode_ins_2",
@@ -1412,8 +1579,8 @@
      "parameter": {
        "va": "DPV_step_time",
        "vb": "DPV_notify_rate",
-        "vc": "DPV_curr_rec_min",
-        "vd": "DPV_curr_rec_max"
+        "vc": "DPV_curr_rec[0]",
+        "vd": "DPV_curr_rec[1]"
      },
      "data": [
        "1X10;",
@@ -1437,9 +1604,18 @@
    },
    "dpv_advanced_mode_ins_final": {
      "type": "RIS",
+      "parameter": {
+        "pa": "ADC_LEVEL_I_15",
+        "pb": "ADC_LEVEL_V_IN_15",
+        "pc": "DAC_LEVEL_V_OUT_15",
+        "pd": "CTRL_HIGH_Z_15",
+        "pe": "SAMPLE_RATE"
+      },
      "data": [
        "1X10;",
-        "1XFF"
+        "1XFF;",
+        "4b>pa;4b>pb;",
+        "4b>pc;4b>pd"
      ]
    },
    "dpv_engineering_mode": [
@@ -1457,8 +1633,6 @@
    "dpv_engineering_mode_advanced": [
      "dpv_advanced_mode"
    ],
-
-
    "VIS_CC_ZERO": [
      "_data_format('I4V4Z4T4')",
      "_disable_cache(False)",
@@ -1499,6 +1673,4 @@
      ]
    }
  }
-}
-
-
+}
@@ -1,5 +1,5 @@
 {
-  "name": "EliteEIS",
+  "name": "Elite_EIS_1.0",
  "version": "1.2.30",
  "match_rule": {
    "local_name_pattern": "Elite.*",
@@ -11,9 +11,21 @@
  "constant": {
    "FREQ_MAX": 4294967296,
    "VOLT_MAX": 65536,
-    "BLE_WRITE_MAX": 255
+    "BLE_WRITE_MAX": 255,
+    "TIME_MAX": 100000
  },
  "parameters": {
+    "TIME_DURATION": {
+      "description": "Run duration",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
    "CHANNEL": {
      "derzteription": "record channels",
      "record_meta": true,
@@ -48,20 +60,34 @@
      "description": "working mode",
      "record_meta": true,
      "value": [
-          "EIS CURVE",
-          "Cyclic Voltammetry",
-          "Dev Mode"
+        "EIS CURVE",
+        "Cyclic Voltammetry",
+        "Dev Mode"
      ]
    },
+    "FREQ": {
+      "description": "DPV current recording period start",
+      "record_meta": true,
+      "initial": [
+        13422819,
+        7
+      ],
+      "domain": {
+        "list": [
+          "FREQ_MAX"
+        ]
+      },
+      "value": "VALUE"
+    },
    "FREQ_START": {
      "description": "Start of Freq Scan",
      "record_meta": true,
      "initial": 13422819,
      "domain": [
-          "FREQ_MAX"
+        "FREQ_MAX"
      ],
      "value": {
-          "expression": "VALUE"
+        "expression": "VALUE"
      }
    },
    "FREQ_STOP": {
@@ -69,10 +95,10 @@
      "record_meta": true,
      "initial": 7,
      "domain": [
-          "FREQ_MAX"
+        "FREQ_MAX"
      ],
      "value": {
-          "expression": "VALUE"
+        "expression": "VALUE"
      }
    },
    "DELAY": {
@@ -91,21 +117,21 @@
      "record_meta": true,
      "initial": 8,
      "value": [
-          2,
-          4,
-          8,
-          16
+        2,
+        4,
+        8,
+        16
      ]
    },
    "DC_BIAS": {
      "description": "DC voltage bias in mV",
      "record_meta": true,
-      "initial": 15000,
+      "initial": 25000,
      "domain": [
-          35001
+        "VOLT_MAX"
      ],
      "value": {
-          "expression": "VALUE"
+        "expression": "VALUE"
      }
    },
    "AC_AMP": {
@@ -113,7 +139,7 @@
      "record_meta": true,
      "initial": 25,
      "domain": [
-          2048
+        2048
      ]
    },
    "SCALE": {
@@ -121,8 +147,8 @@
      "record_meta": true,
      "initial": 0,
      "value": [
-          0,
-          1
+        0,
+        1
      ]
    },
    "PPD": {
@@ -130,7 +156,7 @@
      "record_meta": true,
      "initial": 10,
      "domain": [
-          11
+        11
      ]
    },
    "RTIA": {
@@ -138,11 +164,11 @@
      "record_meta": true,
      "initial": 4,
      "value": [
-          0,
-          1,
-          2,
-          3,
-          4
+        0,
+        1,
+        2,
+        3,
+        4
      ]
    },
    "ADC_VALUE_I": {
@@ -154,10 +180,10 @@
      "record_meta": true,
      "initial": 10000,
      "domain": [
-          100001
+        100001
      ],
      "value": {
-          "expression": "VALUE"
+        "expression": "VALUE"
      }
    },
    "CTRL_HIGH_Z_15": {
@@ -242,9 +268,9 @@
    "BLE_WRITE": {
      "description": "send msg to elite",
      "domain": {
-          "list": [
+        "list": [
          "BLE_WRITE_MAX"
-          ]
+        ]
      },
      "initial": "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
      "value": "VALUE"
@@ -259,7 +285,7 @@
      {
        "expression": "MODE",
        "when": {
-        "*": "start_data"
+          "*": "start_data"
        }
      }
    ],
@@ -339,8 +365,8 @@
    "curve_eis": {
      "type": "RIS",
      "parameter": {
-        "fa": "FREQ_START",
-        "fb": "FREQ_STOP",
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
        "dp": "DELAY",
        "dc": "DC_BIAS",
        "am": "AC_AMP",
@@ -356,8 +382,8 @@
    "curve_eis_para2": {
      "type": "RIS",
      "parameter": {
-        "fa": "FREQ_START",
-        "fb": "FREQ_STOP",
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
        "dp": "DELAY",
        "dc": "DC_BIAS",
        "am": "AC_AMP",
@@ -430,4 +456,4 @@
      "_cdr('20X>ADC_VALUE_I')"
    ]
  }
-}
+}
@@ -0,0 +1,459 @@
+{
+  "name": "Elite_EIS_1.1",
+  "version": "1.2.30",
+  "match_rule": {
+    "local_name_pattern": "Elite.*",
+    "major_product_number": 0,
+    "minor_product_number": 4,
+    "major_version_number": 1,
+    "minor_version_number": 1
+  },
+  "constant": {
+    "FREQ_MAX": 4294967296,
+    "VOLT_MAX": 65536,
+    "BLE_WRITE_MAX": 255,
+    "TIME_MAX": 100000
+  },
+  "parameters": {
+    "TIME_DURATION": {
+      "description": "Run duration",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CHANNEL": {
+      "derzteription": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "CHANNEL_LABEL": {
+      "description": "channel label",
+      "record_meta": true,
+      "domain": "property",
+      "value": "['current', 'voltage', 'impedance']"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 1000,
+      "domain": [
+        1001
+      ],
+      "value": {
+        "expression": "VALUE"
+      },
+      "on_change": "set_sample_rate"
+    },
+    "AMP_GAIN": {
+      "description": "amp gain",
+      "record_meta": true,
+      "domain": "constant",
+      "value": 1
+    },
+    "MODE": {
+      "description": "working mode",
+      "record_meta": true,
+      "value": [
+        "EIS CURVE",
+        "Cyclic Voltammetry",
+        "Dev Mode"
+      ]
+    },
+    "FREQ": {
+      "description": "DPV current recording period start",
+      "record_meta": true,
+      "initial": [
+        13422819,
+        7
+      ],
+      "domain": {
+        "list": [
+          "FREQ_MAX"
+        ]
+      },
+      "value": "VALUE"
+    },
+    "FREQ_START": {
+      "description": "Start of Freq Scan",
+      "record_meta": true,
+      "initial": 13422819,
+      "domain": [
+        "FREQ_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "FREQ_STOP": {
+      "description": "End of Freq Scan",
+      "record_meta": true,
+      "initial": 7,
+      "domain": [
+        "FREQ_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "DELAY": {
+      "description": "Wait x peroid before start taking measurements",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        101
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "AVERAGE_NUM": {
+      "description": "Number of sample used for average funciton",
+      "record_meta": true,
+      "initial": 8,
+      "value": [
+        2,
+        4,
+        8,
+        16
+      ]
+    },
+    "DC_BIAS": {
+      "description": "DC voltage bias in mV",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "AC_AMP": {
+      "description": "AC Amplitude in mV",
+      "record_meta": true,
+      "initial": 25,
+      "domain": [
+        2048
+      ]
+    },
+    "SCALE": {
+      "description": "Point spacing pattern",
+      "record_meta": true,
+      "initial": 0,
+      "value": [
+        0,
+        1
+      ]
+    },
+    "PPD": {
+      "description": "Point per decades",
+      "record_meta": true,
+      "initial": 10,
+      "domain": [
+        11
+      ]
+    },
+    "RTIA": {
+      "description": "High speed tia gain",
+      "record_meta": true,
+      "initial": 4,
+      "value": [
+        0,
+        1,
+        2,
+        3,
+        4
+      ]
+    },
+    "ADC_VALUE_I": {
+      "description": "ADC value current value",
+      "domain": "int"
+    },
+    "Scan_Rate": {
+      "description": "Voltage Scan Rate",
+      "record_meta": true,
+      "initial": 10000,
+      "domain": [
+        100001
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CTRL_HIGH_Z_15": {
+      "description": "ctrl highZ level",
+      "record_meta": true,
+      "initial": 1,
+      "value": [
+        "On",
+        "Off"
+      ],
+      "on_change": "set_ctrl_highZ"
+    },
+    "ADC_LEVEL_I_15": {
+      "description": "ADC level",
+      "record_meta": true,
+      "initial": 4,
+      "value": [
+        "0",
+        "1",
+        "2",
+        "3",
+        "auto"
+      ],
+      "on_change": "set_adc_gain_I"
+    },
+    "ADC_LEVEL_V_IN_15": {
+      "description": "ADC level",
+      "record_meta": true,
+      "initial": 3,
+      "value": [
+        "0",
+        "1",
+        "2",
+        "auto"
+      ],
+      "on_change": "set_adc_gain_Vin"
+    },
+    "VOLT_INITIAL": {
+      "description": "Initial Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "VOLT_MAX": {
+      "description": "Max Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "VOLT_MIN": {
+      "description": "Min Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CYCLE_NUMBER": {
+      "description": "CV cycle number",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        65536
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "BLE_WRITE": {
+      "description": "send msg to elite",
+      "domain": {
+        "list": [
+          "BLE_WRITE_MAX"
+        ]
+      },
+      "initial": "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+      "value": "VALUE"
+    },
+    "BLE_READ": {
+      "description": "receive msg from elite",
+      "domain": "int"
+    }
+  },
+  "instruction": {
+    "start": [
+      {
+        "expression": "MODE",
+        "when": {
+          "*": "start_data"
+        }
+      }
+    ],
+    "start_data": [
+      "data_format_cali",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "1": "set_adc_gain_I"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "1": "set_adc_gain_Vin"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "curve_eis",
+          "1": "curve_cv3"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "curve_eis_para2",
+          "1": "curve_cv3_para2"
+        }
+      },
+      "_sync(True)",
+      "VIS_STI"
+    ],
+    "data_format": [
+      "_data_format('EISZeroOne')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "data_format_cali": [
+      "_data_format_cali('EISZeroOne')"
+    ],
+    "set_sample_rate": {
+      "type": "RIS",
+      "parameter": {
+        "va": "SAMPLE_RATE"
+      },
+      "data": [
+        "XE0;2B>va"
+      ]
+    },
+    "set_adc_gain_I": {
+      "type": "RIS",
+      "data": [
+        "XE1;X05;B>ADC_LEVEL_I_15"
+      ]
+    },
+    "set_adc_gain_Vin": {
+      "type": "RIS",
+      "data": [
+        "XE1;X06;B>ADC_LEVEL_V_IN_15"
+      ]
+    },
+    "set_ctrl_highZ": {
+      "type": "RIS",
+      "data": [
+        "XE1;X03;B>CTRL_HIGH_Z_15"
+      ]
+    },
+    "curve_eis": {
+      "type": "RIS",
+      "parameter": {
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
+        "dp": "DELAY",
+        "dc": "DC_BIAS",
+        "am": "AC_AMP",
+        "an": "AVERAGE_NUM",
+        "rt": "RTIA",
+        "pp": "PPD",
+        "sp": "SCALE"
+      },
+      "data": [
+        "1XD1;1X01;4B>fa;4B>fb;2B>dp"
+      ]
+    },
+    "curve_eis_para2": {
+      "type": "RIS",
+      "parameter": {
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
+        "dp": "DELAY",
+        "dc": "DC_BIAS",
+        "am": "AC_AMP",
+        "an": "AVERAGE_NUM",
+        "rt": "RTIA",
+        "pp": "PPD",
+        "sp": "SCALE"
+      },
+      "data": [
+        "1XD1;1X02;2B>dc;2B>am;B>an;B>rt;2B>pp;B>sp"
+      ]
+    },
+    "curve_cv3": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_INITIAL",
+        "vb": "VOLT_MAX",
+        "vc": "VOLT_MIN",
+        "ve": "Scan_Rate",
+        "vf": "SAMPLE_RATE",
+        "cn": "CYCLE_NUMBER"
+      },
+      "data": [
+        "1XD2;1X01;2B>va;2B>vb;2B>vc;"
+      ]
+    },
+    "curve_cv3_para2": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_INITIAL",
+        "vb": "VOLT_MAX",
+        "vc": "VOLT_MIN",
+        "ve": "Scan_Rate",
+        "vf": "SAMPLE_RATE",
+        "cn": "CYCLE_NUMBER"
+      },
+      "data": [
+        "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"
+    ],
+    "ble_instru_send": [
+      "ble_write",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "ble_write": {
+      "type": "RIS",
+      "data": [
+        "XFF;",
+        "1B>BLE_WRITE[0];1B>BLE_WRITE[1];1B>BLE_WRITE[2];1B>BLE_WRITE[3];",
+        "1B>BLE_WRITE[4];1B>BLE_WRITE[5];1B>BLE_WRITE[6];1B>BLE_WRITE[7];",
+        "1B>BLE_WRITE[8];1B>BLE_WRITE[9];1B>BLE_WRITE[10];1B>BLE_WRITE[11];",
+        "1B>BLE_WRITE[12];1B>BLE_WRITE[13];1B>BLE_WRITE[14];1B>BLE_WRITE[15];",
+        "1B>BLE_WRITE[16];"
+      ]
+    },
+    "dev_version": [
+      "CIS_VERSION",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "dev_battery": [
+      "CIS_VOLT",
+      "_cdr('20X>ADC_VALUE_I')"
+    ]
+  }
+}
@@ -0,0 +1,459 @@
+{
+  "name": "Elite_EIS_MINI_1.0",
+  "version": "1.2.30",
+  "match_rule": {
+    "local_name_pattern": "Elite.*",
+    "major_product_number": 0,
+    "minor_product_number": 4,
+    "major_version_number": 1,
+    "minor_version_number": 2
+  },
+  "constant": {
+    "FREQ_MAX": 4294967296,
+    "VOLT_MAX": 65536,
+    "BLE_WRITE_MAX": 255,
+    "TIME_MAX": 100000
+  },
+  "parameters": {
+    "TIME_DURATION": {
+      "description": "Run duration",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        "TIME_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CHANNEL": {
+      "derzteription": "record channels",
+      "record_meta": true,
+      "domain": "property",
+      "value": "[0, 1, 2]"
+    },
+    "CHANNEL_LABEL": {
+      "description": "channel label",
+      "record_meta": true,
+      "domain": "property",
+      "value": "['current', 'voltage', 'impedance']"
+    },
+    "SAMPLE_RATE": {
+      "description": "data sampling rate",
+      "record_meta": true,
+      "initial": 1000,
+      "domain": [
+        1001
+      ],
+      "value": {
+        "expression": "VALUE"
+      },
+      "on_change": "set_sample_rate"
+    },
+    "AMP_GAIN": {
+      "description": "amp gain",
+      "record_meta": true,
+      "domain": "constant",
+      "value": 1
+    },
+    "MODE": {
+      "description": "working mode",
+      "record_meta": true,
+      "value": [
+        "EIS CURVE",
+        "Cyclic Voltammetry",
+        "Dev Mode"
+      ]
+    },
+    "FREQ": {
+      "description": "DPV current recording period start",
+      "record_meta": true,
+      "initial": [
+        13422819,
+        7
+      ],
+      "domain": {
+        "list": [
+          "FREQ_MAX"
+        ]
+      },
+      "value": "VALUE"
+    },
+    "FREQ_START": {
+      "description": "Start of Freq Scan",
+      "record_meta": true,
+      "initial": 13422819,
+      "domain": [
+        "FREQ_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "FREQ_STOP": {
+      "description": "End of Freq Scan",
+      "record_meta": true,
+      "initial": 7,
+      "domain": [
+        "FREQ_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "DELAY": {
+      "description": "Wait x peroid before start taking measurements",
+      "record_meta": true,
+      "initial": 0,
+      "domain": [
+        101
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "AVERAGE_NUM": {
+      "description": "Number of sample used for average funciton",
+      "record_meta": true,
+      "initial": 8,
+      "value": [
+        2,
+        4,
+        8,
+        16
+      ]
+    },
+    "DC_BIAS": {
+      "description": "DC voltage bias in mV",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "AC_AMP": {
+      "description": "AC Amplitude in mV",
+      "record_meta": true,
+      "initial": 25,
+      "domain": [
+        2048
+      ]
+    },
+    "SCALE": {
+      "description": "Point spacing pattern",
+      "record_meta": true,
+      "initial": 0,
+      "value": [
+        0,
+        1
+      ]
+    },
+    "PPD": {
+      "description": "Point per decades",
+      "record_meta": true,
+      "initial": 10,
+      "domain": [
+        11
+      ]
+    },
+    "RTIA": {
+      "description": "High speed tia gain",
+      "record_meta": true,
+      "initial": 4,
+      "value": [
+        0,
+        1,
+        2,
+        3,
+        4
+      ]
+    },
+    "ADC_VALUE_I": {
+      "description": "ADC value current value",
+      "domain": "int"
+    },
+    "Scan_Rate": {
+      "description": "Voltage Scan Rate",
+      "record_meta": true,
+      "initial": 10000,
+      "domain": [
+        100001
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CTRL_HIGH_Z_15": {
+      "description": "ctrl highZ level",
+      "record_meta": true,
+      "initial": 1,
+      "value": [
+        "On",
+        "Off"
+      ],
+      "on_change": "set_ctrl_highZ"
+    },
+    "ADC_LEVEL_I_15": {
+      "description": "ADC level",
+      "record_meta": true,
+      "initial": 4,
+      "value": [
+        "0",
+        "1",
+        "2",
+        "3",
+        "auto"
+      ],
+      "on_change": "set_adc_gain_I"
+    },
+    "ADC_LEVEL_V_IN_15": {
+      "description": "ADC level",
+      "record_meta": true,
+      "initial": 3,
+      "value": [
+        "0",
+        "1",
+        "2",
+        "auto"
+      ],
+      "on_change": "set_adc_gain_Vin"
+    },
+    "VOLT_INITIAL": {
+      "description": "Initial Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "VOLT_MAX": {
+      "description": "Max Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "VOLT_MIN": {
+      "description": "Min Voltage of Scan",
+      "record_meta": true,
+      "initial": 25000,
+      "domain": [
+        "VOLT_MAX"
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "CYCLE_NUMBER": {
+      "description": "CV cycle number",
+      "record_meta": true,
+      "initial": 1,
+      "domain": [
+        65536
+      ],
+      "value": {
+        "expression": "VALUE"
+      }
+    },
+    "BLE_WRITE": {
+      "description": "send msg to elite",
+      "domain": {
+        "list": [
+          "BLE_WRITE_MAX"
+        ]
+      },
+      "initial": "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
+      "value": "VALUE"
+    },
+    "BLE_READ": {
+      "description": "receive msg from elite",
+      "domain": "int"
+    }
+  },
+  "instruction": {
+    "start": [
+      {
+        "expression": "MODE",
+        "when": {
+          "*": "start_data"
+        }
+      }
+    ],
+    "start_data": [
+      "data_format_cali",
+      "_notify(True)",
+      {
+        "expression": "MODE",
+        "when": {
+          "1": "set_adc_gain_I"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "1": "set_adc_gain_Vin"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "curve_eis",
+          "1": "curve_cv3"
+        }
+      },
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "curve_eis_para2",
+          "1": "curve_cv3_para2"
+        }
+      },
+      "_sync(True)",
+      "VIS_STI"
+    ],
+    "data_format": [
+      "_data_format('EISZeroOne')",
+      {
+        "expression": "MODE",
+        "when": {
+          "0": "_disable_cache(True)",
+          "1": "_disable_cache(True)",
+          "*": "_disable_cache(False)"
+        }
+      }
+    ],
+    "data_format_cali": [
+      "_data_format_cali('EISZeroOne')"
+    ],
+    "set_sample_rate": {
+      "type": "RIS",
+      "parameter": {
+        "va": "SAMPLE_RATE"
+      },
+      "data": [
+        "XE0;2B>va"
+      ]
+    },
+    "set_adc_gain_I": {
+      "type": "RIS",
+      "data": [
+        "XE1;X05;B>ADC_LEVEL_I_15"
+      ]
+    },
+    "set_adc_gain_Vin": {
+      "type": "RIS",
+      "data": [
+        "XE1;X06;B>ADC_LEVEL_V_IN_15"
+      ]
+    },
+    "set_ctrl_highZ": {
+      "type": "RIS",
+      "data": [
+        "XE1;X03;B>CTRL_HIGH_Z_15"
+      ]
+    },
+    "curve_eis": {
+      "type": "RIS",
+      "parameter": {
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
+        "dp": "DELAY",
+        "dc": "DC_BIAS",
+        "am": "AC_AMP",
+        "an": "AVERAGE_NUM",
+        "rt": "RTIA",
+        "pp": "PPD",
+        "sp": "SCALE"
+      },
+      "data": [
+        "1XD1;1X01;4B>fa;4B>fb;2B>dp"
+      ]
+    },
+    "curve_eis_para2": {
+      "type": "RIS",
+      "parameter": {
+        "fa": "FREQ[0]",
+        "fb": "FREQ[1]",
+        "dp": "DELAY",
+        "dc": "DC_BIAS",
+        "am": "AC_AMP",
+        "an": "AVERAGE_NUM",
+        "rt": "RTIA",
+        "pp": "PPD",
+        "sp": "SCALE"
+      },
+      "data": [
+        "1XD1;1X02;2B>dc;2B>am;B>an;B>rt;2B>pp;B>sp"
+      ]
+    },
+    "curve_cv3": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_INITIAL",
+        "vb": "VOLT_MAX",
+        "vc": "VOLT_MIN",
+        "ve": "Scan_Rate",
+        "vf": "SAMPLE_RATE",
+        "cn": "CYCLE_NUMBER"
+      },
+      "data": [
+        "1XD2;1X01;2B>va;2B>vb;2B>vc;"
+      ]
+    },
+    "curve_cv3_para2": {
+      "type": "RIS",
+      "parameter": {
+        "va": "VOLT_INITIAL",
+        "vb": "VOLT_MAX",
+        "vc": "VOLT_MIN",
+        "ve": "Scan_Rate",
+        "vf": "SAMPLE_RATE",
+        "cn": "CYCLE_NUMBER"
+      },
+      "data": [
+        "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"
+    ],
+    "ble_instru_send": [
+      "ble_write",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "ble_write": {
+      "type": "RIS",
+      "data": [
+        "XFF;",
+        "1B>BLE_WRITE[0];1B>BLE_WRITE[1];1B>BLE_WRITE[2];1B>BLE_WRITE[3];",
+        "1B>BLE_WRITE[4];1B>BLE_WRITE[5];1B>BLE_WRITE[6];1B>BLE_WRITE[7];",
+        "1B>BLE_WRITE[8];1B>BLE_WRITE[9];1B>BLE_WRITE[10];1B>BLE_WRITE[11];",
+        "1B>BLE_WRITE[12];1B>BLE_WRITE[13];1B>BLE_WRITE[14];1B>BLE_WRITE[15];",
+        "1B>BLE_WRITE[16];"
+      ]
+    },
+    "dev_version": [
+      "CIS_VERSION",
+      "_cdr('20X>ADC_VALUE_I')"
+    ],
+    "dev_battery": [
+      "CIS_VOLT",
+      "_cdr('20X>ADC_VALUE_I')"
+    ]
+  }
+}
@@ -1,12 +1,12 @@
 {
-  "name": "EliteZM_pulsefly",
+  "name": "Elite_MEGAFLY_0.1",
  "version": "1.2.30",
  "match_rule": {
    "local_name_pattern": "Elite.*",
    "major_product_number": 0,
-    "minor_product_number": 2,
+    "minor_product_number": 6,
    "major_version_number": 1,
-    "minor_version_number": 7
+    "minor_version_number": 0
  },
  "constant": {
    "ADC_CHANNEL_NUMBER": [
@@ -1,5 +1,5 @@
 {
-  "name": "Elite_TRI",
+  "name": "Elite_TRIG_0.1",
  "version": "1.2.30",
  "match_rule": {
    "local_name_pattern": "Trigger.*",
@@ -1,221 +0,0 @@
-{
-  "name": "Elite",
-  "version": "0.1",
-  "match_rule": {
-    "local_name_pattern": "Elite.*",
-    "major_product_number": 0,
-    "minor_product_number": 1,
-    "major_version_number": 0,
-    "minor_version_number": 1
-  },
-  "constant": {
-    "REC_CHANNEL_COUNT": 16,
-    "STI_CHANNEL_COUNT": 15,
-    "ADC_SAMPLE_RATE_LIST": [
-      15,
-      25,
-      40,
-      50,
-      100,
-      250,
-      500,
-      1000,
-      2500,
-      4000,
-      5000
-    ],
-    "STI_FREQ_LIST": [
-      15,
-      25,
-      40,
-      50,
-      100,
-      250,
-      500,
-      1000,
-      2500,
-      4000,
-      5000
-    ]
-  },
-  "parameters": {
-    "MODE": {
-      "description": "working mode",
-      "value": [
-        "Recording Mode",
-        "Stimulation Mode",
-        "Artifact Mode"
-      ]
-    },
-    "CHANNEL": {
-      "description": "record channels",
-      "record_meta": true,
-      "domain": {
-        "set": [
-          "REC_CHANNEL_COUNT"
-        ]
-      }
-    },
-    "SAMPLE_RATE": {
-      "alias": "ADC_RATE",
-      "description": "sampling rate",
-      "record_meta": true,
-      "domain": [
-        "len(ADC_SAMPLE_RATE_LIST)"
-      ],
-      "value": "ADC_SAMPLE_RATE_LIST[VALUE]"
-    },
-    "AMP_GAIN": {
-      "description": "",
-      "record_meta": true,
-      "value": [
-        400,
-        1000,
-        2000
-      ]
-    },
-    "LOW_FREQ_BAND": {
-      "description": "",
-      "record_meta": true,
-      "domain": [
-        7
-      ]
-    },
-    "STI_MODE": {
-      "description": "stimulation mode",
-      "value": [
-        "Positive Pulse",
-        "Negative Pulse",
-        "Pos to Neg Pulse",
-        "Neg to Pos Pulse",
-        "Arbitrary Waveform"
-      ]
-    },
-    "STI_VOLT": {
-      "description": "stimulation voltage",
-      "domain": [
-        32
-      ],
-      "value": "2 + 3 * VALUE / 31"
-    },
-    "STI_FREQ": {
-      "description": "stimulation frequency",
-      "domain": [
-        "len(STI_FREQ_LIST)"
-      ],
-      "value": "STI_FREQ_LIST[VALUE]"
-    },
-    "STI_PMOS": {
-      "description": "stimulation PMOS channel",
-      "initial": 0,
-      "domain": [
-        "STI_CHANNEL_COUNT"
-      ],
-      "guard": "STI_PMOS != STI_NMOS"
-    },
-    "STI_NMOS": {
-      "description": "stimulation NMOS channel",
-      "initial": "STI_CHANNEL_COUNT - 1",
-      "domain": [
-        "STI_CHANNEL_COUNT"
-      ],
-      "guard": "STI_PMOS != STI_NMOS"
-    },
-    "CHOPPER": {
-      "description": "",
-      "domain": "bool"
-    },
-    "FAST_SETTLE": {
-      "description": "",
-      "domain": "bool"
-    }
-  },
-  "instruction": {
-    "start": [
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "start_recording",
-          "1": "start_stimulation",
-          "2": "start_artifact"
-        }
-      },
-      "VIS_STI"
-    ],
-    "start_recording": [
-      {
-        "expression": "len(CHANNEL) > 0",
-        "raise": "no recording channel"
-      },
-      "data_format",
-      "_notify(True)",
-      "start_recording0",
-      "_sync(True)"
-    ],
-    "start_artifact": [
-      {
-        "expression": "len(CHANNEL) > 0",
-        "raise": "no recording channel"
-      },
-      "data_format",
-      "_notify(True)",
-      "start_artifact0",
-      "_sync(True)"
-    ],
-    "data_format": [
-      "_data_format('TDC4VAF2')"
-    ],
-    "start_recording0": {
-      "type": "RIS",
-      "foreach-parameter": {
-        "parameter": "CHANNEL",
-        "variable": [
-          "a",
-          "b",
-          "c",
-          "d"
-        ]
-      },
-      "data": [
-        "3b110#recording header;2b<AMP_GAIN;3b<LOW_FREQ_BAND",
-        "4b>SAMPLE_RATE;1ba?;1bb?;1bc?;1bd?",
-        "4b<a?:0;4b<b?:0",
-        "4b<c?:0;4b<d?:0"
-      ]
-    },
-    "start_artifact0": {
-      "type": "RIS",
-      "foreach-parameter": {
-        "parameter": "CHANNEL",
-        "variable": [
-          "a",
-          "b",
-          "c",
-          "d"
-        ]
-      },
-      "data": [
-        "3b100#artifact mode header;2b0;3b001",
-        "4b>SAMPLE_RATE;1ba?;1bb?;1bc?;1bd?",
-        "4b<a?:0;4b<b?:0",
-        "4b<c?:0;4b<d?:0"
-      ]
-    },
-    "start_stimulation": [
-      "start_stimulation0"
-    ],
-    "start_stimulation0": {
-      "type": "RIS",
-      "guard": {
-        "expression": "STI_PMOS != STI_NMOS",
-        "raise": "same N/PMos channel"
-      },
-      "data": [
-        "3b111#stimulation header;2b0;3bSTI_MODE",
-        "4b>STI_FREQ;1bCHOPPER;1bFAST_SETTLE;2b0",
-        "4b<STI_PMOS;4b<STI_NMOS",
-        "5b<STI_VOLT;3b0"
-      ]
-    }
-  }
-}
@@ -1,220 +0,0 @@
-{
-  "name": "Elite_Legacy",
-  "version": "0.0.0",
-  "match_rule": {
-    "major_product_number": 0,
-    "minor_product_number": 0,
-    "major_version_number": 0,
-    "minor_version_number": 0
-  },
-  "constant": {
-    "REC_CHANNEL_COUNT": 16,
-    "STI_CHANNEL_COUNT": 15,
-    "ADC_SAMPLE_RATE_LIST": [
-      15,
-      25,
-      40,
-      50,
-      100,
-      250,
-      500,
-      1000,
-      2500,
-      4000,
-      5000
-    ],
-    "STI_FREQ_LIST": [
-      15,
-      25,
-      40,
-      50,
-      100,
-      250,
-      500,
-      1000,
-      2500,
-      4000,
-      5000
-    ]
-  },
-  "parameters": {
-    "MODE": {
-      "description": "working mode",
-      "value": [
-        "Recording Mode",
-        "Stimulation Mode",
-        "Artifact Mode"
-      ]
-    },
-    "CHANNEL": {
-      "description": "record channels",
-      "record_meta": true,
-      "domain": {
-        "set": [
-          "REC_CHANNEL_COUNT"
-        ]
-      }
-    },
-    "SAMPLE_RATE": {
-      "alias": "ADC_RATE",
-      "description": "sampling rate",
-      "record_meta": true,
-      "domain": [
-        "len(ADC_SAMPLE_RATE_LIST)"
-      ],
-      "value": "ADC_SAMPLE_RATE_LIST[VALUE]"
-    },
-    "AMP_GAIN": {
-      "description": "",
-      "record_meta": true,
-      "value": [
-        400,
-        1000,
-        2000
-      ]
-    },
-    "LOW_FREQ_BAND": {
-      "description": "",
-      "record_meta": true,
-      "domain": [
-        7
-      ]
-    },
-    "STI_MODE": {
-      "description": "stimulation mode",
-      "value": [
-        "Positive Pulse",
-        "Negative Pulse",
-        "Pos to Neg Pulse",
-        "Neg to Pos Pulse",
-        "Arbitrary Waveform"
-      ]
-    },
-    "STI_VOLT": {
-      "description": "stimulation voltage",
-      "domain": [
-        32
-      ],
-      "value": "2 + 3 * VALUE / 31"
-    },
-    "STI_FREQ": {
-      "description": "stimulation frequency",
-      "domain": [
-        "len(STI_FREQ_LIST)"
-      ],
-      "value": "STI_FREQ_LIST[VALUE]"
-    },
-    "STI_PMOS": {
-      "description": "stimulation PMOS channel",
-      "initial": 0,
-      "domain": [
-        "STI_CHANNEL_COUNT"
-      ],
-      "guard": "STI_PMOS != STI_NMOS"
-    },
-    "STI_NMOS": {
-      "description": "stimulation NMOS channel",
-      "initial": "STI_CHANNEL_COUNT - 1",
-      "domain": [
-        "STI_CHANNEL_COUNT"
-      ],
-      "guard": "STI_PMOS != STI_NMOS"
-    },
-    "CHOPPER": {
-      "description": "",
-      "domain": "bool"
-    },
-    "FAST_SETTLE": {
-      "description": "",
-      "domain": "bool"
-    }
-  },
-  "instruction": {
-    "start": [
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "start_recording",
-          "1": "start_stimulation",
-          "2": "start_artifact"
-        }
-      },
-      "VIS_STI"
-    ],
-    "start_recording": [
-      {
-        "expression": "len(CHANNEL) > 0",
-        "raise": "no recording channel"
-      },
-      "data_format",
-      "_notify(True)",
-      "start_recording0",
-      "_sync(True)"
-    ],
-    "start_artifact": [
-      {
-        "expression": "len(CHANNEL) > 0",
-        "raise": "no recording channel"
-      },
-      "data_format",
-      "_notify(True)",
-      "start_artifact0",
-      "_sync(True)"
-    ],
-    "data_format": [
-      "_data_format('TC4VAF2')"
-    ],
-    "start_recording0": {
-      "type": "RIS",
-      "foreach-parameter": {
-        "parameter": "CHANNEL",
-        "variable": [
-          "a",
-          "b",
-          "c",
-          "d"
-        ]
-      },
-      "data": [
-        "3b110#recording header;2b<AMP_GAIN;3b<LOW_FREQ_BAND",
-        "4b>SAMPLE_RATE;1ba?;1bb?;1bc?;1bd?",
-        "4b<a?:0;4b<b?:0",
-        "4b<c?:0;4b<d?:0"
-      ]
-    },
-    "start_artifact0": {
-      "type": "RIS",
-      "foreach-parameter": {
-        "parameter": "CHANNEL",
-        "variable": [
-          "a",
-          "b",
-          "c",
-          "d"
-        ]
-      },
-      "data": [
-        "3b100#artifact mode header;2b0;3b001",
-        "4b>SAMPLE_RATE;1ba?;1bb?;1bc?;1bd?",
-        "4b<a?:0;4b<b?:0",
-        "4b<c?:0;4b<d?:0"
-      ]
-    },
-    "start_stimulation": [
-      "start_stimulation0"
-    ],
-    "start_stimulation0": {
-      "type": "RIS",
-      "guard": {
-        "expression": "STI_PMOS != STI_NMOS",
-        "raise": "same N/PMos channel"
-      },
-      "data": [
-        "3b111#stimulation header;2b0;3bSTI_MODE",
-        "4b>STI_FREQ;1bCHOPPER;1bFAST_SETTLE;2b0",
-        "4b<STI_PMOS;4b<STI_NMOS",
-        "5b<STI_VOLT;3b0"
-      ]
-    }
-  }
-}
@@ -1,343 +0,0 @@
-{
-  "name": "EliteZM",
-  "version": "1.2.30",
-  "match_rule": {
-    "local_name_pattern": "Elite-ZM.+",
-    "major_product_number": 0,
-    "minor_product_number": 2,
-    "major_version_number": 1,
-    "minor_version_number": 2
-  },
-  "constant": {
-    "ADC_CHANNEL_NUMBER": [
-      12,
-      13,
-      14,
-      15
-    ],
-    "VOLT_MAX": 65536,
-    "STEP_MAX": 100,
-    "Const_Current_Range": 1500001
-  },
-  "parameters": {
-    "CHANNEL": {
-      "description": "record channels",
-      "record_meta": true,
-      "domain": "property",
-      "value": "[0, 1, 2]"
-    },
-    "CHANNEL_LABEL": {
-      "description": "channel label",
-      "record_meta": true,
-      "domain": "property",
-      "value": "['current', 'voltage', 'impedance']"
-    },
-    "SAMPLE_RATE": {
-      "description": "data sampling rate",
-      "record_meta": true,
-      "value": [
-        100,
-        10,
-        5,
-        1,
-        0.1,
-        0.01
-      ],
-      "on_change": "set_sample_rate"
-    },
-    "AMP_GAIN": {
-      "description": "amp gain",
-      "record_meta": true,
-      "domain": "constant",
-      "value": 1
-    },
-    "MODE": {
-      "description": "working mode",
-      "record_meta": true,
-      "value": [
-        "I-V Curve",
-        "Cyclic Voltammetry",
-        "Function Generator",
-        "R-T Curve",
-        "V-T Curve",
-        "I-T Curve",
-        "ADC test",
-        "Constant Current"
-      ]
-    },
-    "VOLT_ORIGIN": {
-      "description": "Origin Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE) * 0x0001"
-      }
-    },
-    "VOLT_FINAL": {
-      "description": "The last Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": " (VALUE) * 0x0001"
-      }
-    },
-    "VOLT_STEP": {
-      "description": "Voltage Step",
-      "record_meta": true,
-      "initial": 0,
-      "domain": [
-        "STEP_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE + 1) * 0x0001"
-      }
-    },
-    "STEP_TIME": {
-      "description": "How much time between two step",
-      "record_meta": true,
-      "initial": 1,
-      "value": [
-        0.5,
-        1.0,
-        2.0
-      ]
-    },
-    "CYCLE_NUMBER": {
-      "description": "CV cycle number",
-      "record_meta": true,
-      "initial": 0,
-      "domain": [
-        200
-      ],
-      "value": {
-        "expression": "VALUE + 1"
-      }
-    },
-    "DAC_VOLT": {
-      "description": "DAC output Voltage",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        65536
-      ]
-    },
-    "ADC_CHANNEL": {
-      "description": "read ADC data",
-      "record_meta": true,
-      "value": [
-        "ANA0",
-        "ANA1",
-        "ANA2",
-        "ANA3"
-      ]
-    },
-    "ADC_LEVEL": {
-      "description": "ADC level",
-      "record_meta": true,
-      "initial": 3,
-      "value": [
-        "200k",
-        "10k",
-        "200R",
-        "auto"
-      ],
-      "on_change": "set_adc_gain"
-    },
-    "Resister_LEVEL": {
-      "description": "Resister_LEVEL",
-      "record_meta": true,
-      "initial": 3,
-      "value": [
-        "Small",
-        "Middle",
-        "Large",
-        "Auto"
-      ],
-      "on_change": "set_Resister_level"
-    },
-    "ADC_VALUE_V": {
-      "description": "ADC value voltage value",
-      "domain": "int"
-    },
-    "ADC_VALUE_I": {
-      "description": "ADC value current value",
-      "domain": "int"
-    },
-    "Const_Current_unit": {
-      "description": "Constant Current unit Setting",
-      "initial": 1,
-      "value": [
-        "uA",
-        "mA"
-      ]
-    },
-    "Const_Current_value": {
-      "description": "Constant Current value Setting",
-      "initial": 0,
-      "domain": [
-        "Const_Current_Range"
-      ],
-      "value": {
-        "expression": "(VALUE) * 0x00000001"
-      }
-    },
-    "Charge": {
-      "description": "Charge battery or not",
-      "initial": 0,
-      "value": [
-        "Charge",
-        "Discharge"
-      ]
-    },
-    "Const_Current_VStop": {
-      "description": "Constant Current Stopping Voltage",
-      "initial": 0,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE) * 0x0001"
-      }
-    }
-  },
-  "instruction": {
-    "start": [
-      {
-        "expression": "MODE",
-        "when": {
-          "2": "start_fun_gen",
-          "6": "adc_test",
-          "*": "start_data"
-        }
-      }
-    ],
-    "start_fun_gen": [
-      "data_format",
-      "func_gen",
-      "VIS_STI"
-    ],
-    "adc_test": [
-      "adc_test0",
-      "_cdr('1X;4X>ADC_VALUE_I;4X>ADC_VALUE_V')"
-    ],
-    "start_data": [
-      "data_format",
-      "_notify(True)",
-      "set_sample_rate",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "curve_iv",
-          "1": "curve_cv",
-          "3": "curve_zt",
-          "4": "curve_vt",
-          "5": "curve_it",
-          "7": "const_current"
-        }
-      },
-      "_sync(True)",
-      "VIS_STI"
-    ],
-    "data_format": [
-      "_data_format('I4V4Z4T4')",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "_disable_cache(True)",
-          "1": "_disable_cache(True)",
-          "*": "_disable_cache(False)"
-        }
-      }
-    ],
-    "curve_iv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN) * 0x0001",
-        "vb": "(VOLT_FINAL) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12"
-      },
-      "data": [
-        "1X10;2B>va;2B>vb;2B>dv;B>dt"
-      ]
-    },
-    "curve_cv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN) * 0x0001",
-        "vb": "(VOLT_FINAL) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12",
-        "cn": "CYCLE_NUMBER+1"
-      },
-      "data": [
-        "1X20;2B>va;2B>vb;2B>dv;B>dt;B>cn"
-      ]
-    },
-    "func_gen": {
-      "type": "RIS",
-      "parameter": {
-        "v": "(DAC_VOLT) * 0x0001"
-      },
-      "data": [
-        "X30;2B>v"
-      ]
-    },
-    "curve_zt": {
-      "type": "RIS",
-      "data": [
-        "X40"
-      ]
-    },
-    "curve_vt": {
-      "type": "RIS",
-      "data": [
-        "X50"
-      ]
-    },
-    "curve_it": {
-      "type": "RIS",
-      "data": [
-        "X60"
-      ]
-    },
-    "adc_test0": {
-      "type": "RIS",
-      "data": [
-        "X90;B>ADC_LEVEL;B>ADC_CHANNEL"
-      ]
-    },
-    "set_sample_rate": {
-      "type": "RIS",
-      "data": [
-        "X70;B>SAMPLE_RATE"
-      ]
-    },
-    "set_adc_gain": {
-      "type": "RIS",
-      "data": [
-        "X80;B>ADC_LEVEL"
-      ]
-    },
-    "set_Resister_level": {
-      "type": "RIS",
-      "data": [
-        "XE0;B>Resister_LEVEL"
-      ]
-    },
-    "const_current": {
-      "type": "RIS",
-      "data": [
-        "XD0;B>Charge;2X>Const_Current_VStop;4X>Const_Current_value"
-      ]
-    }
-  }
-}
-
-
@@ -1,320 +0,0 @@
-{
-  "name": "EliteZML",
-  "version": "1.2.30",
-  "match_rule": {
-    "local_name_pattern": "Elite-ZM.+",
-    "major_product_number": 0,
-    "minor_product_number": 2,
-    "major_version_number": 1,
-    "minor_version_number": 4
-  },
-  "constant": {
-    "ADC_CHANNEL_NUMBER": [
-      12,
-      13,
-      14,
-      15
-    ],
-    "VOLT_MAX": 65536,
-    "STEP_MAX": 100,
-    "Const_Current_Range": 3000001
-  },
-  "parameters": {
-    "CHANNEL": {
-      "description": "record channels",
-      "record_meta": true,
-      "domain": "property",
-      "value": "[0, 1, 2]"
-    },
-    "CHANNEL_LABEL": {
-      "description": "channel label",
-      "record_meta": true,
-      "domain": "property",
-      "value": "['current', 'voltage', 'impedance']"
-    },
-    "SAMPLE_RATE": {
-      "description": "data sampling rate",
-      "record_meta": true,
-      "value": [
-        100,
-        10,
-        5,
-        1,
-        0.1,
-        0.01
-      ],
-      "on_change": "set_sample_rate"
-    },
-    "AMP_GAIN": {
-      "description": "amp gain",
-      "record_meta": true,
-      "domain": "constant",
-      "value": 1
-    },
-    "MODE": {
-      "description": "working mode",
-      "record_meta": true,
-      "value": [
-        "I-V Curve",
-        "Cyclic Voltammetry",
-        "Function Generator",
-        "R-T Curve",
-        "V-T Curve",
-        "I-T Curve",
-        "ADC test",
-        "Constant Current"
-      ]
-    },
-    "VOLT_ORIGIN": {
-      "description": "Origin Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE + 1) * 0x0001"
-      }
-    },
-    "VOLT_FINAL": {
-      "description": "The last Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": " (VALUE + 1) * 0x0001"
-      }
-    },
-    "VOLT_STEP": {
-      "description": "Voltage Step",
-      "record_meta": true,
-      "initial": 0,
-      "domain": [
-        "STEP_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE + 1) * 0x0001"
-      }
-    },
-    "STEP_TIME": {
-      "description": "How much time between two step",
-      "record_meta": true,
-      "initial": 1,
-      "value": [
-        0.5,
-        1.0,
-        2.0
-      ]
-    },
-    "CYCLE_NUMBER": {
-      "description": "CV cycle number",
-      "record_meta": true,
-      "domain": [
-        200
-      ],
-      "value": {
-        "expression": "VALUE + 1"
-      }
-    },
-    "DAC_VOLT": {
-      "description": "DAC output Voltage",
-      "record_meta": true,
-      "domain": [
-        65536
-      ]
-    },
-    "ADC_CHANNEL": {
-      "description": "read ADC data",
-      "record_meta": true,
-      "value": [
-        "ANA0",
-        "ANA1",
-        "ANA2",
-        "ANA3"
-      ]
-    },
-    "ADC_LEVEL": {
-      "description": "ADC level",
-      "record_meta": true,
-      "value": [
-        "200k",
-        "10k",
-        "200R",
-        "auto"
-      ],
-      "on_change": "set_adc_gain"
-    },
-    "Resister_LEVEL": {
-      "description": "Resister_LEVEL",
-      "record_meta": true,
-      "value": [
-        "Small",
-        "Middle",
-        "Large",
-        "Auto"
-      ],
-      "on_change": "set_Resister_level"
-    },
-    "ADC_VALUE_V": {
-      "description": "ADC value voltage value",
-      "domain": "int"
-    },
-    "ADC_VALUE_I": {
-      "description": "ADC value current value",
-      "domain": "int"
-    },
-    "Const_Current_unit": {
-      "description": "Constant Current unit Setting",
-      "value": [
-        "uA",
-        "mA"
-      ]
-    },
-    "Const_Current_value": {
-      "description": "Constant Current value Setting",
-      "initial": 1500000,
-      "domain": [
-        "Const_Current_Range"
-      ],
-      "value": {
-        "expression": "(VALUE) * 0x00000001"
-      }
-    }
-  },
-  "instruction": {
-    "start": [
-      {
-        "expression": "MODE",
-        "when": {
-          "2": "start_fun_gen",
-          "6": "adc_test",
-          "*": "start_data"
-        }
-      }
-    ],
-    "start_fun_gen": [
-      "data_format",
-      "func_gen",
-      "VIS_STI"
-    ],
-    "adc_test": [
-      "adc_test0",
-      "_cdr('1X;4X>ADC_VALUE_I;4X>ADC_VALUE_V')"
-    ],
-    "start_data": [
-      "data_format",
-      "_notify(True)",
-      "set_sample_rate",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "curve_iv",
-          "1": "curve_cv",
-          "3": "curve_zt",
-          "4": "curve_vt",
-          "5": "curve_it",
-          "7": "const_current"
-        }
-      },
-      "_sync(True)",
-      "VIS_STI"
-    ],
-    "data_format": [
-      "_data_format('I4V4Z4T4')",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "_disable_cache(True)",
-          "1": "_disable_cache(True)",
-          "*": "_disable_cache(False)"
-        }
-      }
-    ],
-    "curve_iv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN + 1) * 0x0001",
-        "vb": "(VOLT_FINAL + 1) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12"
-      },
-      "data": [
-        "1X10;2B>va;2B>vb;2B>dv;B>dt"
-      ]
-    },
-    "curve_cv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN + 1) * 0x0001",
-        "vb": "(VOLT_FINAL + 1) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12",
-        "cn": "CYCLE_NUMBER+1"
-      },
-      "data": [
-        "1X20;2B>va;2B>vb;2B>dv;B>dt;B>CYCLE_NUMBER"
-      ]
-    },
-    "func_gen": {
-      "type": "RIS",
-      "parameter": {
-        "v": "(DAC_VOLT) * 0x0001"
-      },
-      "data": [
-        "X30;2B>v"
-      ]
-    },
-    "curve_zt": {
-      "type": "RIS",
-      "data": [
-        "X40"
-      ]
-    },
-    "curve_vt": {
-      "type": "RIS",
-      "data": [
-        "X50"
-      ]
-    },
-    "curve_it": {
-      "type": "RIS",
-      "data": [
-        "X60"
-      ]
-    },
-    "adc_test0": {
-      "type": "RIS",
-      "data": [
-        "X90;B>ADC_LEVEL;B>ADC_CHANNEL"
-      ]
-    },
-    "set_sample_rate": {
-      "type": "RIS",
-      "data": [
-        "X70;B>SAMPLE_RATE"
-      ]
-    },
-    "set_adc_gain": {
-      "type": "RIS",
-      "data": [
-        "X80;B>ADC_LEVEL"
-      ]
-    },
-    "set_Resister_level": {
-      "type": "RIS",
-      "data": [
-        "XE0;B>Resister_LEVEL"
-      ]
-    },
-    "const_current": {
-      "type": "RIS",
-      "data": [
-        "XD0;4X>Const_Current_value"
-      ]
-    }
-  }
-}
-
-
@@ -1,320 +0,0 @@
-{
-  "name": "EliteZMS",
-  "version": "1.2.30",
-  "match_rule": {
-    "local_name_pattern": "Elite-ZM.+",
-    "major_product_number": 0,
-    "minor_product_number": 2,
-    "major_version_number": 1,
-    "minor_version_number": 3
-  },
-  "constant": {
-    "ADC_CHANNEL_NUMBER": [
-      12,
-      13,
-      14,
-      15
-    ],
-    "VOLT_MAX": 65536,
-    "STEP_MAX": 100,
-    "Const_Current_Range": 3000001
-  },
-  "parameters": {
-    "CHANNEL": {
-      "description": "record channels",
-      "record_meta": true,
-      "domain": "property",
-      "value": "[0, 1, 2]"
-    },
-    "CHANNEL_LABEL": {
-      "description": "channel label",
-      "record_meta": true,
-      "domain": "property",
-      "value": "['current', 'voltage', 'impedance']"
-    },
-    "SAMPLE_RATE": {
-      "description": "data sampling rate",
-      "record_meta": true,
-      "value": [
-        100,
-        10,
-        5,
-        1,
-        0.1,
-        0.01
-      ],
-      "on_change": "set_sample_rate"
-    },
-    "AMP_GAIN": {
-      "description": "amp gain",
-      "record_meta": true,
-      "domain": "constant",
-      "value": 1
-    },
-    "MODE": {
-      "description": "working mode",
-      "record_meta": true,
-      "value": [
-        "I-V Curve",
-        "Cyclic Voltammetry",
-        "Function Generator",
-        "R-T Curve",
-        "V-T Curve",
-        "I-T Curve",
-        "ADC test",
-        "Constant Current"
-      ]
-    },
-    "VOLT_ORIGIN": {
-      "description": "Origin Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE + 1) * 0x0001"
-      }
-    },
-    "VOLT_FINAL": {
-      "description": "The last Voltage of Scan",
-      "record_meta": true,
-      "initial": 25000,
-      "domain": [
-        "VOLT_MAX"
-      ],
-      "value": {
-        "expression": " (VALUE + 1) * 0x0001"
-      }
-    },
-    "VOLT_STEP": {
-      "description": "Voltage Step",
-      "record_meta": true,
-      "initial": 0,
-      "domain": [
-        "STEP_MAX"
-      ],
-      "value": {
-        "expression": "(VALUE + 1) * 0x0001"
-      }
-    },
-    "STEP_TIME": {
-      "description": "How much time between two step",
-      "record_meta": true,
-      "initial": 1,
-      "value": [
-        0.5,
-        1.0,
-        2.0
-      ]
-    },
-    "CYCLE_NUMBER": {
-      "description": "CV cycle number",
-      "record_meta": true,
-      "domain": [
-        200
-      ],
-      "value": {
-        "expression": "VALUE + 1"
-      }
-    },
-    "DAC_VOLT": {
-      "description": "DAC output Voltage",
-      "record_meta": true,
-      "domain": [
-        65536
-      ]
-    },
-    "ADC_CHANNEL": {
-      "description": "read ADC data",
-      "record_meta": true,
-      "value": [
-        "ANA0",
-        "ANA1",
-        "ANA2",
-        "ANA3"
-      ]
-    },
-    "ADC_LEVEL": {
-      "description": "ADC level",
-      "record_meta": true,
-      "value": [
-        "200k",
-        "10k",
-        "200R",
-        "auto"
-      ],
-      "on_change": "set_adc_gain"
-    },
-    "Resister_LEVEL": {
-      "description": "Resister_LEVEL",
-      "record_meta": true,
-      "value": [
-        "Small",
-        "Middle",
-        "Large",
-        "Auto"
-      ],
-      "on_change": "set_Resister_level"
-    },
-    "ADC_VALUE_V": {
-      "description": "ADC value voltage value",
-      "domain": "int"
-    },
-    "ADC_VALUE_I": {
-      "description": "ADC value current value",
-      "domain": "int"
-    },
-    "Const_Current_unit": {
-      "description": "Constant Current unit Setting",
-      "value": [
-        "uA",
-        "mA"
-      ]
-    },
-    "Const_Current_value": {
-      "description": "Constant Current value Setting",
-      "initial": 1500000,
-      "domain": [
-        "Const_Current_Range"
-      ],
-      "value": {
-        "expression": "(VALUE) * 0x00000001"
-      }
-    }
-  },
-  "instruction": {
-    "start": [
-      {
-        "expression": "MODE",
-        "when": {
-          "2": "start_fun_gen",
-          "6": "adc_test",
-          "*": "start_data"
-        }
-      }
-    ],
-    "start_fun_gen": [
-      "data_format",
-      "func_gen",
-      "VIS_STI"
-    ],
-    "adc_test": [
-      "adc_test0",
-      "_cdr('1X;4X>ADC_VALUE_I;4X>ADC_VALUE_V')"
-    ],
-    "start_data": [
-      "data_format",
-      "_notify(True)",
-      "set_sample_rate",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "curve_iv",
-          "1": "curve_cv",
-          "3": "curve_zt",
-          "4": "curve_vt",
-          "5": "curve_it",
-          "7": "const_current"
-        }
-      },
-      "_sync(True)",
-      "VIS_STI"
-    ],
-    "data_format": [
-      "_data_format('I4V4Z4T4')",
-      {
-        "expression": "MODE",
-        "when": {
-          "0": "_disable_cache(True)",
-          "1": "_disable_cache(True)",
-          "*": "_disable_cache(False)"
-        }
-      }
-    ],
-    "curve_iv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN + 1) * 0x0001",
-        "vb": "(VOLT_FINAL + 1) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12"
-      },
-      "data": [
-        "1X10;2B>va;2B>vb;2B>dv;B>dt"
-      ]
-    },
-    "curve_cv": {
-      "type": "RIS",
-      "parameter": {
-        "va": "(VOLT_ORIGIN + 1) * 0x0001",
-        "vb": "(VOLT_FINAL + 1) * 0x0001",
-        "dv": "(VOLT_STEP + 1) * 0x0001",
-        "dt": "STEP_TIME * 0x12",
-        "cn": "CYCLE_NUMBER+1"
-      },
-      "data": [
-        "1X20;2B>va;2B>vb;2B>dv;B>dt;B>CYCLE_NUMBER"
-      ]
-    },
-    "func_gen": {
-      "type": "RIS",
-      "parameter": {
-        "v": "(DAC_VOLT) * 0x0001"
-      },
-      "data": [
-        "X30;2B>v"
-      ]
-    },
-    "curve_zt": {
-      "type": "RIS",
-      "data": [
-        "X40"
-      ]
-    },
-    "curve_vt": {
-      "type": "RIS",
-      "data": [
-        "X50"
-      ]
-    },
-    "curve_it": {
-      "type": "RIS",
-      "data": [
-        "X60"
-      ]
-    },
-    "adc_test0": {
-      "type": "RIS",
-      "data": [
-        "X90;B>ADC_LEVEL;B>ADC_CHANNEL"
-      ]
-    },
-    "set_sample_rate": {
-      "type": "RIS",
-      "data": [
-        "X70;B>SAMPLE_RATE"
-      ]
-    },
-    "set_adc_gain": {
-      "type": "RIS",
-      "data": [
-        "X80;B>ADC_LEVEL"
-      ]
-    },
-    "set_Resister_level": {
-      "type": "RIS",
-      "data": [
-        "XE0;B>Resister_LEVEL"
-      ]
-    },
-    "const_current": {
-      "type": "RIS",
-      "data": [
-        "XD0;4X>Const_Current_value"
-      ]
-    }
-  }
-}
-
-
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+ find /home/pi -maxdepth 1 -type f -iname '*.out' -mtime +30 -delete
Author	SHA1	Message	Date
peterlu14	c894bf7c6f	test data	2022-08-02 14:16:22 +08:00
peterlu14	0b7a650b95	[debug] fix final data loss & flag stop after writer write	2022-07-29 11:11:46 +08:00
Roy	bffaff310b	[update] update file name of elite library	2022-07-26 13:14:37 +08:00
Roy	06bf262d59	[update] new device library for elite eis1.1 mini	2022-07-13 10:03:40 +08:00
Roy	b2f9d98336	[update] update elite device library	2022-07-06 16:23:12 +08:00
Roy	a6b523404b	[update] update elite device library	2022-07-05 18:20:32 +08:00
peterlu14	6c232b3b07	[update] fix struct.pack type error support signed int & max number type	2022-06-22 15:23:44 +08:00
peterlu14	cfc2bf1d83	Merge remote-tracking branch 'origin/rel/v.1.6.4/read_ram_debug' into rel/v.1.6.5/restruct_data_format	2022-06-22 13:18:03 +08:00
Roy	2b60e68197	[update] update eis decoder code	2022-06-22 13:11:57 +08:00
peterlu14	efb5e9aeb6	[update] add list struct update in new way & fix list parameter not valid & collection nested error & fixed encoder struct bytes wrong (singed, unsigned)	2022-06-17 19:54:42 +08:00
peterlu14	b4d88a0e67	[update] change elite pulse sensing paramter in array	2022-06-17 19:51:05 +08:00
peterlu14	6029ff6fe1	[update] FREQ & DPV_curr_rec max_min to array and add update array format	2022-06-15 16:48:23 +08:00
Roy	6efc5e1097	[update] hide log message	2022-06-10 17:36:13 +08:00
Roy	a23394d3d1	Merge branch 'dev/eis_parameter_bug' into rel/v.1.6.4/read_ram_debug	2022-06-10 17:31:45 +08:00
Roy	c96f76f438	[update] read RAM data bug	2022-06-10 17:22:10 +08:00
Roy	f0f1c9fc49	[update] update eis json	2022-06-10 17:20:58 +08:00
peterlu14	512c80af40	[update] add new info id,name,status,mac_address,memory_board	2022-06-06 18:52:12 +08:00
Roy	499964b287	[update] fix TIME_DURATION in eis devlib	2022-05-23 17:42:12 +08:00
Roy	16f12d40bf	[update] improve cp and cc mode - speed and resistance value	2022-05-20 12:11:56 +08:00
peterlu14	63c1ba8efb	[update] update decorder mode in I4V4Z4T4	2022-05-18 16:16:17 +08:00
Roy	4a28348db4	[update] fix cp mode instruction and decoder	2022-05-18 11:06:23 +08:00
peterlu14	64dfe87d05	[update] remove decorder rebuild problem & add new parameter to control time duration	2022-05-18 10:19:08 +08:00
peterlu14	f7a5a867a4	[update] fix memory counter	2022-05-06 13:50:09 +08:00
peterlu14	1accaa9b9f	[update] delete logger	2022-05-06 11:25:30 +08:00
peterlu14	b810e35fb2	Merge branch 'feature/get-running-project-flow' into rel/v1.6.1/cp_mode	2022-05-06 10:39:51 +08:00
peterlu14	82c9d2b0e3	[update] add clean logger script	2022-05-06 10:39:47 +08:00
peterlu14	e5a3f33b9f	[update] add cp mode	2022-05-06 10:36:17 +08:00
peterlu14	1dd4ae2ce4	[update] add stop project api & fix uuid problem & get all projects & as_json problem	2022-05-04 18:07:05 +08:00
peterlu14	515cc9f7a2	[update] fix stop close writer losing data problem	2022-04-29 17:18:48 +08:00
peterlu14	9b92249fdb	Merge branch 'feature/project' into rel/v1.6.0/highz	2022-04-27 14:01:07 +08:00
peterlu14	adcc13b4de	[update] idle device not sending instruction	2022-04-27 13:26:05 +08:00
Roy	5228290eac	[update] fix 1.5re.json about highz	2022-04-27 13:16:29 +08:00
LuoYiTing	034b7976cd	Update README.md	2022-04-25 03:55:34 +00:00