Source code for AFL.automation.loading.PressureController

import logging
import threading
import time


logger = logging.getLogger(__name__)


[docs] class PressureController(): ''' Abstract superclass for pressure controllers that provides timed dispensing ''' def _log(self, level, message): """Use the attached API logger, including from dispensing threads.""" app_logger = getattr(getattr(self, 'app', None), 'logger', None) getattr(app_logger if app_logger is not None else logger, level)(message)
[docs] def timed_dispense(self,dispense_pressure,dispense_time,block=True): ''' Perform a pressure dispense at pressure `dispense_pressure`, stopping after `dispense_time`. This dispense can be interrupted by calling self.stop(). ''' self._log( 'info', f'Starting timed pressure dispense: pressure={dispense_pressure}, ' f'duration={dispense_time} s, block={block}. Applying pressure command.', ) self.active_callback = threading.Timer(dispense_time,self.stop) self.set_P(dispense_pressure) self._log('info', 'Timed dispense pressure command completed; starting stop timer.') self.active_callback.start() while not self.active_callback.is_alive(): time.sleep(0.01) self._log('info', f'Timed dispense stop timer is running; pressure will be reset after {dispense_time} s.') if block: self.blockUntilStatusStopped() self._log('info', 'Blocking timed pressure dispense completed.')
[docs] def blockUntilStatusStopped(self,pollingdelay=0.2): ''' block execution until the controller finishes a dispense ''' if self.active_callback is not None: status = self.active_callback.is_alive() else: status = False while status: time.sleep(pollingdelay) status = self.active_callback.is_alive()
[docs] def dispenseRunning(self): ''' Returns true if a timed dispense is running, false otherwise. ''' if self.active_callback is not None: return self.active_callback.is_alive() else: return False
[docs] def ramp_dispense(self,dispense_start_pressure, dispense_stop_pressure, dispense_time,const_time = 0,block=True): ''' Perform a pressure dispense with a linear ramp in pressure between `dispense_start_pressure` and `dispense_stop_pressure`, stopping after `dispense_time`. This dispense can be interrupted by calling self.stop(). If const_time is set, the last `const_time` seconds of the dispense will be at constant pressure, with the ramp occurring in the remaining time. ''' self._log( 'info', f'Starting ramp pressure dispense: start_pressure={dispense_start_pressure}, ' f'stop_pressure={dispense_stop_pressure}, duration={dispense_time} s, ' f'ramp_duration={dispense_time - const_time} s, hold_duration={const_time} s, block={block}.', ) self.start_time = time.time() self.stop_flag = threading.Event() self.active_callback = threading.Thread(target= self._ramp_pressure,args=(dispense_start_pressure,dispense_stop_pressure,dispense_time,const_time,self.stop_flag)) self._log('info', f'Applying initial ramp pressure command={dispense_start_pressure}.') self.set_P(dispense_start_pressure) self._log('info', 'Initial ramp pressure command completed; starting ramp thread.') self.active_callback.start() while not self.active_callback.is_alive(): time.sleep(0.01) self._log('info', 'Pressure ramp thread is running.') if block: self.blockUntilStatusStopped() self._log('info', 'Blocking ramp pressure dispense completed.')
def _ramp_pressure(self,dispense_start_pressure,dispense_stop_pressure,dispense_time,const_time,stop_flag): try: pressure_ramp_rate = (dispense_stop_pressure - dispense_start_pressure) / (dispense_time-const_time) elapsed_time = time.time() - self.start_time last_log_time = None while elapsed_time<dispense_time and not stop_flag.is_set(): actual_elapsed = time.time() - self.start_time elapsed_time = min(actual_elapsed, (dispense_time - const_time)) pressure = dispense_start_pressure + pressure_ramp_rate * elapsed_time self.set_P(pressure) if last_log_time is None or actual_elapsed - last_log_time >= 5.0: phase = 'ramping' if actual_elapsed < dispense_time - const_time else 'holding' self._log( 'info', f'Pressure ramp progress: elapsed={actual_elapsed:.1f} s, ' f'configured duration={dispense_time} s, phase={phase}, ' f'commanded_pressure={pressure:g}. Actual pressure is not read back.', ) last_log_time = actual_elapsed time.sleep(0.05) reason = 'external stop flag' if stop_flag.is_set() else 'ramp loop completed' self._log('info', f'Pressure ramp ending: reason={reason}; resetting pressure to zero.') self.stop() except Exception as exc: self._log('error', f'Pressure ramp thread failed: {type(exc).__name__}: {exc}') raise
[docs] def stop(self): ''' Abort the current timed dispense action. ''' self._log( 'info', f'Stopping pressure dispense; callback running={self.dispenseRunning()}', ) try: self._log('info', 'Pressure stop: commanding pressure=0.') self.set_P(0) self._log('info', 'Pressure stop: zero-pressure command completed.') try: self.active_callback.cancel() self._log('info', 'Pressure stop: timed dispense callback cancelled.') except AttributeError: # this is a ramp thread, not a timer self._log('info', 'Pressure stop: signalling ramp thread to stop, then reapplying pressure=0.') self.stop_flag.set() time.sleep(0.05) self.set_P(0) self._log('info', 'Pressure stop: ramp stop flag set and zero-pressure command completed.') except Exception as exc: self._log('error', f'Pressure stop failed: {type(exc).__name__}: {exc}') raise