[update] add data_show function print device data

python/biopro/controller.py

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

python/biopro/data.py

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

python/biopro/devlib/data.py

@@ -853,7 +853,7 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
 
     __slots__ = ('_message', '_cycle_number', '_start_return_data', '_time_stamp',
                  '_total_time_stamp', '_mode', '_cycle_start_time',
-                 '_mode_stop')
+                 '_mode_stop', '_show_data')
 
     def __init__(self):
         super().__init__()
@@ -868,6 +868,8 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         self._mode = 0
         self._cycle_start_time = []
 
+        self._show_data = False
+
     @property
     def name(self) -> str:
         return self.NAME
@@ -915,9 +917,10 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
                 print("error timeStamp full data:", list(data), datetime.now(), '\n')
                 return None
             else:
-                # print('|', time_stamp, '|', delta, '|', int(time_stamp * 1000 / 2),
-                #       '|', current, '|', voltage, '|', impedance,
-                #       '|', cycle_number, '|', finishMode, '@', str(self.device))
+                if self._show_data:
+                    print('|', time_stamp, '|', delta, '|', int(time_stamp * 1000 / 2),
+                        '|', current, '|', voltage, '|', impedance,
+                        '|', cycle_number, '|', finishMode, '@', str(self.device))
 
                 # print('|', '{:10}'.format(time_stamp),
                 #       '|', '{:4}'.format(delta),

python/biopro/devlib/library.py

@@ -1105,8 +1105,6 @@ class CompletedDevice(Device):
         return self._configuration.get_parameter(name, False)
     
     def set_multi_parameters(self, parameter):
-        if len(parameter) == 0:
-            return
         for (name, value) in parameter[0].items():
             if name != 'target':
                 self.set_parameter(name, value)

python/biopro/project/condition.py

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

python/biopro/project/project.py

@@ -24,7 +24,7 @@ class Project(threading.Thread):
     self._project = project
     self._device_manager = device_manager
     self._mqtt_thread = mqttThread
-    self._time_interval = 0.1
+    self._time_interval = 1
     self._start_time = None
     self._end_time = None
 
@@ -139,39 +139,23 @@ class Project(threading.Thread):
               project_start_time = self._start_time,
               delay_time = delay_time,
               running_task= self._task_manager.running_task,
-              previous_task =  self._task_manager.prev_task,
-              self_task = task
+              previous_task =  self._task_manager.prev_task
             )
             # print('match_condition_list', match_condition_list)
             for condition in match_condition_list:
-              # print('\ncondition.type: ', condition.type)
               match_action_list = task.get_match_action(condition.id)
-              # print('match_action_list', match_action_list)
               for action in match_action_list:
-                # print('action type', action.type)
-                # print('match_action_list len: ', len(match_action_list))
+                # print('match_action', action.type, action.target)
                 if action.type == 'start' and task.status != 1:
                   self._task_manager.set_running_task(task)
-                  # Trace
                   self.mqtt_thread.broadcast_command('project:task ' + task.name + ' start at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
-                elif action.type == 'cycle' and task.status != 1:
-                  # TODO: directly goto next without swich cycle as running task
-                  """ if task._cycle_count < task._cycle - 1:
-                    task._cycle_count += 1
-                    cycle_target = self._task_manager.task_list[task._cycle_next - 1] # TODO: not sure deep or shallow
-                    cycle_target.reset()
-                    task = cycle_target """
-                  self._task_manager.set_running_task(task)
-                elif action.type == 'stop' and len(self._task_manager.running_task.parameter_set) == 0:
-                  self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
-                  self._task_manager.running_task.stop()
 
                 device = self._complete_device[action.target]
                 task_info = task.get_task_info(action)
                 instruction_set = getattr(self._instruction_set, action.type, None)
-                # print('instruction_set', instruction_set, '\n', action.type)
-                # if instruction_set != None and task.cycle == -1:
-                if instruction_set != None and len(task.parameter_set) > 0:
+                # print('instruction_set',instruction_set)
+                
+                if instruction_set != None:
                   for instruction in instruction_set:
                     args = list(map(lambda arg: task_info[arg], instruction['arguments']))
                     threading.Thread(target=getattr(device, instruction['method'])(*args))
@@ -180,8 +164,7 @@ class Project(threading.Thread):
 
         # check task not running then stop
         if self.check_running_task_not_run() == True:
-          if self._task_manager.running_task.cycle == -1:
-            self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
+          self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
           self._task_manager.running_task.stop()
         
         # check project done then close project
@@ -221,12 +204,7 @@ class Project(threading.Thread):
     # if no running task
     if self._task_manager.running_task == None:
       return False
-    
-    for key in self._task_manager.running_task.action:
-      # print('action key', key, self._task_manager.running_task, self._task_manager.running_task.action[key])
-      if len(self._task_manager.running_task.parameter_set) == 0 and self._task_manager.running_task.action[key]['type'] == 'stop':
-        return False
-      
+
     for device in self._task_manager.running_task.device:
       if self._complete_device[device].status == 1:
         return False

python/biopro/project/task.py

@@ -15,9 +15,6 @@ class Task:
     self._name = None
     self._parent = None
     self._cycle = None
-    self._cycle_count = 0
-    self._cycle_next = None
-    self._cycle_next_uuid = None
     self._device = None
     self._event = None
     self._trigger = None
@@ -103,31 +100,6 @@ class Task:
   @cycle.setter
   def cycle(self, new_cycle):
     self._cycle = new_cycle
-
-  # TODO: not sure needed?
-  @property
-  def cycle_count(self) -> int:
-    return self._cycle_count
-  
-  @cycle_count.setter
-  def cycle_count(self, new_cycle_count):
-    self._cycle_count = new_cycle_count
-    
-  @property
-  def cycle_next(self) -> str:
-    return self._cycle_next
-  
-  @cycle_next.setter
-  def cycle_next(self, new_cycle_next):
-    self._cycle_next = new_cycle_next
-
-  @property
-  def cycle_next_uuid(self) -> str:
-    return self._cycle_next_uuid
-  
-  @cycle_next_uuid.setter
-  def cycle_next_uuid(self, new_cycle_next_uuid):
-    self._cycle_next_uuid = new_cycle_next_uuid
   
   @property
   def device(self) -> dict:
@@ -235,10 +207,6 @@ class Task:
   
   def stop(self):
     self.status = 2
-  
-  def reset(self):
-    self.status = -1
-    # self.status = 0
 
   def get_match_action_list(self, match_condition_list):
     return map(lambda condition: [x for x in self._action_list if condition.id in x.get_condition_list()], match_condition_list)
@@ -273,9 +241,6 @@ class Task:
       'name': self.name,
       'parent': self.parent,
       'cycle': self.cycle,
-      'cycle_count': self.cycle_count,
-      'cycle_next': self.cycle_next,
-      'cycle_next_uuid': self.cycle_next_uuid,
       'device': self.device,
       'event': self.event,
       'trigger': self.trigger,

python/biopro/project/task_manager.py

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

python/biopro/server/data.py

@@ -699,6 +699,9 @@ class DataServer(SocketServer, DataAPI):
                 self.mqtt_thread.publish('device_instruction', json_stringify(content), inter = True)
 
         return True
+    
+    def show_data(self, device):
+        self._configurations[device].put_rec_queue('show_data')
 
 class DataRuntime(metaclass=abc.ABCMeta):
     __slots__ = ('_server', '_device', '_meta_file', '_data_format',

python/biopro/server/main.py

@@ -1015,7 +1015,6 @@ class ControlServer(SocketServer, ControlServerAPI):
     @logging_info
     def run_project(self, project) -> bool:
         if project is not None:
-            # print(project)
             project = self._project_manager.create(project)
             self._project_manager.run_project(project)
         return  project.as_json()
@@ -1340,6 +1339,13 @@ class ControlServer(SocketServer, ControlServerAPI):
         def _hardware_send_test_set(self, options: Dict[str, str]) -> bool:
             # TODO write options files
             return False
+        
+        @logging_info
+        def show_device_data(self, device: int):
+            client = self.data_server.client()
+            if client is not None:
+                with client:
+                    client.show_data(device)
 
 class _RandomCrashThread(ServerThread):
     def __init__(self):

python/biopro/server/recording.py

@@ -185,6 +185,8 @@ class RecordingProcess(Process):
                 self.final_write()
                 self.is_closed = True
                 return False
+            elif q == 'show_data':
+                self._decoder._show_data = not self._decoder._show_data
             else:
                 self.rec_update()
                 self.sync_data(q)