def setUp(self): """ """ self.prompts = [">"] self.newline = "\n" self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = CommandResponseInstrumentProtocol( self.prompts, self.newline, self.event_callback) self.protocol_fsm = ThreadSafeFSM(self.TestState, self.TestEvent, self.TestEvent.ENTER, self.TestEvent.EXIT) self.protocol_fsm.add_handler(self.TestState.TEST, self.TestEvent.TEST, lambda x: x) self.protocol._add_build_handler(self.TestEvent.TEST, self._build_simple_command) self.protocol._add_response_handler(self.TestEvent.TEST, self._parse_test_response) self.protocol._connection = Mock() self.protocol._connection.send = lambda x: self.protocol.add_to_buffer( "%s >->" % x) self.protocol.get_current_state = Mock( return_value=self.TestState.TEST) self.protocol._send_wakeup = lambda: self.protocol.add_to_buffer( "wakeup response >->") self.protocol._wakeup = functools.partial(self.protocol._wakeup, delay=0)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) handlers = { ProtocolState.UNKNOWN: [(ProtocolEvent.ENTER, self._handler_unknown_enter), (ProtocolEvent.EXIT, self._handler_unknown_exit)], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # create chunker for processing instrument samples. self._chunker = StringChunker(self.sieve_function)
def got_data(self, data): """ Callback for receiving new data from the device. """ if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS: # direct access mode if len(data) > 0: #mi_logger.debug("SBE37Protocol._got_data(): <" + data + ">") # check for echoed commands from instrument (TODO: this should only be done for telnet?) if len(self._sent_cmds) > 0: # there are sent commands that need to have there echoes filtered out oldest_sent_cmd = self._sent_cmds[0] if string.count(data, oldest_sent_cmd) > 0: # found a command echo, so remove it from data and delete the command form list data = string.replace(data, oldest_sent_cmd, "", 1) self._sent_cmds.pop(0) if len(data) > 0 and self._driver_event: self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data) # TODO: what about logging this as an event? return if len(data)>0: # Call the superclass to update line and prompt buffers. CommandResponseInstrumentProtocol.got_data(self, data) # If in streaming mode, process the buffer for samples to publish. cur_state = self.get_current_state() if cur_state == SBE37ProtocolState.AUTOSAMPLE: if SBE37_NEWLINE in self._linebuf: lines = self._linebuf.split(SBE37_NEWLINE) self._linebuf = lines[-1] for line in lines: self._extract_sample(line)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_command_get) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add sample handlers. # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = []
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_unknown_enter), (ProtocolEvent.EXIT, self._handler_unknown_exit) ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # create chunker for processing instrument samples. self._chunker = StringChunker(self.sieve_function)
def got_data(self, data): """ Callback for receiving new data from the device. """ if self.get_current_state() == ProtocolStates.DIRECT_ACCESS: # direct access mode if len(data) > 0: log.debug("mavs4InstrumentProtocol._got_data(): <" + data + ">") if self._driver_event: self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data) # TODO: what about logging this as an event? return if len(data)>0: # Call the superclass to update line and prompt buffers. CommandResponseInstrumentProtocol.got_data(self, data) # If in streaming mode, process the buffer for samples to publish. cur_state = self.get_current_state() if cur_state == ProtocolStates.AUTOSAMPLE: if INSTRUMENT_NEWLINE in self._linebuf: lines = self._linebuf.split(INSTRUMENT_NEWLINE) self._linebuf = lines[-1] for line in lines: self._extract_sample(line)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The sbe26plus newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample_start) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.INIT_PARAMS, self._handler_command_init_params) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() # Add build handlers for device commands. # Add response handlers for device commands. # Add sample handlers. # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] # self._chunker = StringChunker(Protocol.sieve_function) self._payload_cache = {}
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.AUTOSAMPLE: [ (ProtocolEvent.ENTER, self._handler_autosample_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample), (ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample), (ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the metadata dictionaries self._build_command_dict() self._build_driver_dict() # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # set up scheduled event handling self.initialize_scheduler() self._schedulers = []
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.HEAT_ON, self._handler_command_heat_on) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.HEAT_OFF, self._handler_command_heat_off) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() # Add build handlers for device commands. self._add_build_handler(InstrumentCommand.HEAT_ON, self._build_heat_on_command) self._add_build_handler(InstrumentCommand.HEAT_OFF, self._build_heat_off_command) # Add response handlers for device commands. self._add_response_handler(InstrumentCommand.HEAT_ON, self._parse_heat_on_off_resp) self._add_response_handler(InstrumentCommand.HEAT_OFF, self._parse_heat_on_off_resp) # Add sample handlers. # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] # self._chunker = StringChunker(Protocol.sieve_function) self._heat_duration = DEFAULT_HEAT_DURATION
def __init__(self, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, None, None, driver_event) # create chunker for processing instrument samples. self._chunker = StringChunker(self.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_command_get) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add sample handlers. # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(self.sieve_function) log.info('processing particles with %d workers', POOL_SIZE) self._process_particles = True self._pending_particles = deque() self._processing_pool = multiprocessing.Pool(POOL_SIZE) self._particles_thread = Thread(target=self.particles_thread) self._particles_thread.setDaemon(True) self._particles_thread.start()
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.AUTOSAMPLE: [ (ProtocolEvent.ENTER, self._handler_autosample_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample), (ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample), (ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the metadata dictionaries self._build_command_dict() self._build_driver_dict() # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # set up scheduled event handling self.initialize_scheduler() self._schedulers = []
def got_data(self, data): """ Callback for receiving new data from the device. """ # Call the superclass to update line and promp buffers. CommandResponseInstrumentProtocol.got_data(self, data) # If in streaming mode, process the buffer for samples to publish. cur_state = self.get_current_state() if cur_state == SBE16ProtocolState.AUTOSAMPLE: if SBE16_NEWLINE in self._linebuf: lines = self._linebuf.split(SBE16_NEWLINE) self._linebuf = lines[-1] for line in lines: self._extract_sample(line)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Add build handlers for device commands. self._add_build_handler(Command.BATTERY, self._build_simple_command) # Add response handlers for device commands. self._add_response_handler(Command.BATTERY, self._parse_battery_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._chunker = StringChunker(Protocol.sieve_function) self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN)
def setUp(self): """ """ self.prompts = [">"] self.newline = "\n" self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = CommandResponseInstrumentProtocol(self.prompts, self.newline, self.event_callback) self.protocol_fsm = ThreadSafeFSM(self.TestState, self.TestEvent, self.TestEvent.ENTER, self.TestEvent.EXIT) self.protocol_fsm.add_handler(self.TestState.TEST, self.TestEvent.TEST, lambda x : x) self.protocol._add_build_handler(self.TestEvent.TEST, self._build_simple_command) self.protocol._add_response_handler(self.TestEvent.TEST, self._parse_test_response) self.protocol._connection = Mock() self.protocol._connection.send = lambda x : self.protocol.add_to_buffer("%s >->" % x) self.protocol.get_current_state = Mock(return_value=self.TestState.TEST) self.protocol._send_wakeup = lambda: self.protocol.add_to_buffer("wakeup response >->") self.protocol._wakeup = functools.partial(self.protocol._wakeup, delay=0)
def setUp(self): """ """ self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = InstrumentProtocol(self.event_callback)
def test_get_prompts(self): """ ensure prompts are returned sorted by length """ prompts = ['aa', 'bbb', 'c', 'dddd'] expected = ['dddd', 'bbb', 'aa', 'c'] class Prompts(BaseEnum): A = 'aa' B = 'bbb' C = 'c' D = 'dddd' self.protocol = CommandResponseInstrumentProtocol(prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected) self.protocol = CommandResponseInstrumentProtocol(Prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected)
def test_get_prompts(self): """ ensure prompts are returned sorted by length """ prompts = ['aa', 'bbb', 'c', 'dddd'] expected = ['dddd', 'bbb', 'aa', 'c'] class Prompts(BaseEnum): A = 'aa' B = 'bbb' C = 'c' D = 'dddd' self.protocol = CommandResponseInstrumentProtocol(prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected) self.protocol = CommandResponseInstrumentProtocol(Prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected)
def setUp(self): """ """ self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = InstrumentProtocol(self.event_callback)
def _got_data(self, data): """ The comms object fires this when data is received @param data The chunk of data that was received """ CommandResponseInstrumentProtocol._got_data(self, data) # If we are streaming, process the line buffer for samples, but it # could have header stuff come out if you just got a break! if self._protocol_fsm.get_current_state() == PARProtocolState.AUTOSAMPLE_MODE: if self.eoln in self._linebuf: lines = self._linebuf.split(self.eoln) for line in lines: if sample_regex.match(line): self._last_data_timestamp = time.time() self._driver_event(DriverAsyncEvent.SAMPLE, line) self._linebuf = self._linebuf.replace(line+self.eoln, "") # been processed
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(Protocol.sieve_function) self._build_driver_dict() self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def __init__(self, callback=None): CommandResponseInstrumentProtocol.__init__(self, Prompt, EOLN, callback) # TODO probably promote this convenience to super-class? # _timeout: Default timeout value for operations accepting an # optional timeout argument self._timeout = 30 self._last_data_timestamp = None self.eoln = EOLN self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, None, None) # UNKNOWN self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.INITIALIZE, self._handler_initialize) # COMMAND_MODE self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.GET_LAST_ENSEMBLE, self._handler_command_get_latest_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.GET_METADATA, self._handler_command_get_metadata) self._protocol_fsm.add_handler( ProtocolState.COMMAND_MODE, ProtocolEvent.RUN_RECORDER_TESTS, self._handler_command_run_recorder_tests) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.RUN_ALL_TESTS, self._handler_command_run_all_tests) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample) # AUTOSAMPLE_MODE self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE_MODE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) self._protocol_fsm.start(ProtocolState.UNKNOWN)
def __init__(self, callback=None): CommandResponseInstrumentProtocol.__init__(self, Prompt, EOLN, callback) # TODO probably promote this convenience to super-class? # _timeout: Default timeout value for operations accepting an # optional timeout argument self._timeout = 30 self._last_data_timestamp = None self.eoln = EOLN self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, None, None) # UNKNOWN self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.INITIALIZE, self._handler_initialize) # COMMAND_MODE self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.GET_LAST_ENSEMBLE, self._handler_command_get_latest_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.GET_METADATA, self._handler_command_get_metadata) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.RUN_RECORDER_TESTS, self._handler_command_run_recorder_tests) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.RUN_ALL_TESTS, self._handler_command_run_all_tests) self._protocol_fsm.add_handler(ProtocolState.COMMAND_MODE, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample) # AUTOSAMPLE_MODE self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE_MODE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) self._protocol_fsm.start(ProtocolState.UNKNOWN)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(Protocol.sieve_function) self._build_driver_dict()
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add sample handlers. # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = []
def got_data(self, paPacket): """ Callback for receiving new data from the device. """ length = paPacket.get_data_size() data = paPacket.get_data() tempLength = len(data) if length > 0: # Call the superclass to update line and prompt buffers. CommandResponseInstrumentProtocol.got_data(self, data) # If in streaming mode, process the buffer for samples to publish. cur_state = self.get_current_state() if cur_state == SBE16ProtocolState.AUTOSAMPLE: if SBE16_NEWLINE in self._linebuf: lines = self._linebuf.split(SBE16_NEWLINE) self._linebuf = lines[-1] for line in lines: sample = self._extract_sample(SBE16DataParticle, SAMPLE_REGEX, line)
def __init__(self, prompts, newline, driver_event): """ @param prompts A BaseEnum class containing instrument prompts. @param newline The SBE16 newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # This driver does not process commands, the finite state machine and handlers are stubs self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) handlers = { ProtocolState.UNKNOWN: { (ProtocolEvent.ENTER, self._handler_state_change()), (ProtocolEvent.EXIT, self._handler_pass_through()), (ProtocolEvent.DISCOVER, self._handler_unknown_discover()), }, ProtocolState.COMMAND: { (ProtocolEvent.ENTER, self._handler_state_change()), (ProtocolEvent.EXIT, self._handler_pass_through()), (ProtocolEvent.GET, self._handler_pass_through()), }, } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(self.sieve_function)
def got_data(self, paPacket): """ Callback for receiving new data from the device. The port agent object fires this when data is received @param paPacket The packet of data that was received """ paLength = paPacket.get_data_size() paData = paPacket.get_data() if self.get_current_state() == PARProtocolState.DIRECT_ACCESS: # direct access mode if paLength > 0: log.debug("SatlanticPARInstrumentProtocol.got_data(): <" + paData + ">") if self._driver_event: self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, paData) # TODO: what about logging this as an event? return if paLength > 0: CommandResponseInstrumentProtocol.got_data(self, paData) # If we are streaming, process the line buffer for samples, but it # could have header stuff come out if you just got a break! if ( self._protocol_fsm.get_current_state() == PARProtocolState.AUTOSAMPLE or self._protocol_fsm.get_current_state() == PARProtocolState.POLL ): if self.eoln in self._linebuf: lines = self._linebuf.split(self.eoln) for line in lines: if SAMPLE_REGEX.match(line): self._last_data_timestamp = time.time() # construct and publish data particles self._extract_sample(SatlanticPARDataParticle, SAMPLE_REGEX, line) self._linebuf = self._linebuf.replace(line + self.eoln, "") # been processed
def test_ring_buffer(self): """ verify command thread ring buffer rolls as expected """ prompts = ['aa', 'bbb', 'c', 'dddd'] self.protocol = CommandResponseInstrumentProtocol( prompts, '\r\n', self.event_callback) self.protocol._max_buffer_size = Mock(return_value=5) self.protocol.add_to_buffer("a") self.protocol.add_to_buffer("b") self.protocol.add_to_buffer("c") self.protocol.add_to_buffer("d") self.protocol.add_to_buffer("e") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "abcde") self.assertEqual(self.protocol._promptbuf, "abcde") self.protocol.add_to_buffer("f") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "bcdef") self.assertEqual(self.protocol._promptbuf, "bcdef") self.protocol.add_to_buffer("gh") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "defgh") self.assertEqual(self.protocol._promptbuf, "defgh")
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(Protocol.sieve_function) self._build_driver_dict() self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def __init__(self, prompts, newline, driver_event): """ @param prompts A BaseEnum class containing instrument prompts. @param newline The SBE16 newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # This driver does not process commands, the finite state machine and handlers are stubs self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) handlers = { ProtocolState.UNKNOWN: { (ProtocolEvent.ENTER, self._handler_state_change()), (ProtocolEvent.EXIT, self._handler_pass_through()), (ProtocolEvent.DISCOVER, self._handler_unknown_discover()), }, ProtocolState.COMMAND: { (ProtocolEvent.ENTER, self._handler_state_change()), (ProtocolEvent.EXIT, self._handler_pass_through()), (ProtocolEvent.GET, self._handler_pass_through()), }, } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(self.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(Protocol.sieve_function) self._build_driver_dict() self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def __init__(self, prompts, newline, driver_event): """ """ CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) self._protocol_fsm = InstrumentFSM(ProtocolStates, ProtocolEvents, ProtocolEvents.ENTER, ProtocolEvents.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolStates.UNKNOWN, ProtocolEvents.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolStates.UNKNOWN, ProtocolEvents.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolStates.UNKNOWN, ProtocolEvents.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.TEST, self._handler_command_test) self._protocol_fsm.add_handler(ProtocolStates.COMMAND, ProtocolEvents.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolStates.AUTOSAMPLE, ProtocolEvents.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolStates.AUTOSAMPLE, ProtocolEvents.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolStates.AUTOSAMPLE, ProtocolEvents.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) """ self._protocol_fsm.add_handler(ProtocolStates.TEST, ProtocolEvents.ENTER, self._handler_test_enter) self._protocol_fsm.add_handler(ProtocolStates.TEST, ProtocolEvents.EXIT, self._handler_test_exit) self._protocol_fsm.add_handler(ProtocolStates.TEST, ProtocolEvents.RUN_TEST, self._handler_test_run_tests) self._protocol_fsm.add_handler(ProtocolStates.TEST, ProtocolEvents.GET, self._handler_command_autosample_test_get) """ self._protocol_fsm.add_handler(ProtocolStates.DIRECT_ACCESS, ProtocolEvents.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolStates.DIRECT_ACCESS, ProtocolEvents.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolStates.DIRECT_ACCESS, ProtocolEvents.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolStates.DIRECT_ACCESS, ProtocolEvents.STOP_DIRECT, self._handler_direct_access_stop_direct) # Set state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolStates.UNKNOWN)
def test_ring_buffer(self): """ verify command thread ring buffer rolls as expected """ prompts = ['aa', 'bbb', 'c', 'dddd'] self.protocol = CommandResponseInstrumentProtocol(prompts, '\r\n', self.event_callback) self.protocol._max_buffer_size = Mock(return_value=5) self.protocol.add_to_buffer("a") self.protocol.add_to_buffer("b") self.protocol.add_to_buffer("c") self.protocol.add_to_buffer("d") self.protocol.add_to_buffer("e") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "abcde") self.assertEqual(self.protocol._promptbuf, "abcde") self.protocol.add_to_buffer("f") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "bcdef") self.assertEqual(self.protocol._promptbuf, "bcdef") self.protocol.add_to_buffer("gh") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "defgh") self.assertEqual(self.protocol._promptbuf, "defgh")
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_TURBO, self._handler_command_start_turbo), ], ProtocolState.SPINNING_UP: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.AT_SPEED, self._handler_spinning_up_at_speed), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.AT_SPEED: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.ERROR: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.CLEAR, self._handler_clear), (ProtocolEvent.GET, self._handler_command_get), ], ProtocolState.SPINNING_DOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOPPED, self._handler_spinning_down_stopped), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() # Add build and response handlers for device commands. for command in InstrumentCommand.list(): self._add_build_handler(command, self._generic_build_handler) self._add_response_handler(command, self._generic_response_handler) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(Protocol.sieve_function) self._max_current_count = 0 self.initialize_scheduler()
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.SCHEDULE_ACQUIRE_SAMPLE, self._handler_command_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add build handlers for device commands. self._add_build_handler(Command.GET_SAMPLE, self._build_simple_command) self._add_build_handler(Command.COMM_TEST, self._build_simple_command) # Add response handlers for device commands. # State state machine in COMMAND state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(THSPHProtocol.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.AUTOSAMPLE: [ (ProtocolEvent.ENTER, self._handler_autosample_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample), (ProtocolEvent.START_LEVELING, self._handler_start_leveling), (ProtocolEvent.STOP_LEVELING, self._handler_stop_leveling), (ProtocolEvent.NANO_TIME_SYNC, self._handler_time_sync), (ProtocolEvent.START_HEATER, self._handler_start_heater), (ProtocolEvent.STOP_HEATER, self._handler_stop_heater), (ProtocolEvent.LEVELING_TIMEOUT, self._handler_leveling_timeout), (ProtocolEvent.HEATER_TIMEOUT, self._handler_heater_timeout), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample), (ProtocolEvent.START_LEVELING, self._handler_start_leveling), (ProtocolEvent.STOP_LEVELING, self._handler_stop_leveling), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.NANO_TIME_SYNC, self._handler_time_sync), (ProtocolEvent.START_HEATER, self._handler_start_heater), (ProtocolEvent.STOP_HEATER, self._handler_stop_heater), (ProtocolEvent.LEVELING_TIMEOUT, self._handler_leveling_timeout), (ProtocolEvent.HEATER_TIMEOUT, self._handler_heater_timeout), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the metadata dictionaries self._build_param_dict() self._build_command_dict() self._build_driver_dict() # Add build handlers for device commands. for command in InstrumentCommand.list(): if command in [ InstrumentCommand.NANO_SET_RATE, InstrumentCommand.HEAT ]: self._add_build_handler(command, self._build_command_with_value) else: self._add_build_handler(command, self._build_simple_command) # # Add response handlers for device commands. for command in InstrumentCommand.list(): self._add_response_handler(command, self._generic_response_handler) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent to device to be filtered in responses for telnet DA self._sent_cmds = [] # create chunker self._chunker = StringChunker(Protocol.sieve_function) self._last_data_timestamp = 0 self.has_pps = True # set up scheduled event handling self.initialize_scheduler() self._add_scheduler_event(ScheduledJob.ACQUIRE_STATUS, ProtocolEvent.ACQUIRE_STATUS) self._add_scheduler_event(ScheduledJob.NANO_TIME_SYNC, ProtocolEvent.NANO_TIME_SYNC)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_command_sync_clock) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.FLASH_STATUS, self._handler_flash_status) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler( ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.CLOCK_SYNC, self._handler_autosample_sync_clock) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.FLASH_STATUS, self._handler_flash_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status) # We setup a new state for clock sync because then we could use the state machine so the autosample scheduler # is disabled before we try to sync the clock. Otherwise there could be a race condition introduced when we # are syncing the clock and the scheduler requests a sample. self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.ENTER, self._handler_sync_clock_enter) self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock_sync) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler( ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Add build handlers for device commands. self._add_build_handler(Command.GET_CLOCK, self._build_simple_command) self._add_build_handler(Command.SET_CLOCK, self._build_set_clock_command) self._add_build_handler(Command.D, self._build_simple_command) self._add_build_handler(Command.GO, self._build_simple_command) self._add_build_handler(Command.STOP, self._build_simple_command) self._add_build_handler(Command.FS, self._build_simple_command) self._add_build_handler(Command.STAT, self._build_simple_command) # Add response handlers for device commands. self._add_response_handler(Command.GET_CLOCK, self._parse_clock_response) self._add_response_handler(Command.SET_CLOCK, self._parse_clock_response) self._add_response_handler(Command.FS, self._parse_fs_response) self._add_response_handler(Command.STAT, self._parse_common_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._chunker = StringChunker(Protocol.sieve_function) self._add_scheduler_event(ScheduledJob.ACQUIRE_STATUS, ProtocolEvent.ACQUIRE_STATUS) self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN)
class TestUnitCommandInstrumentProtocol(MiUnitTestCase): """ Test cases for instrument protocol class. Functions in this class provide instrument protocol unit tests and provide a tutorial on use of the protocol interface. """ class TestState(BaseEnum): """ Protocol states for SBE37. Cherry picked from DriverProtocolState enum. """ TEST = "TEST" class TestEvent(BaseEnum): """ Protocol events for SBE37. Cherry picked from DriverEvent enum. """ ENTER = "ENTER" EXIT = "EXIT" TEST = "TEST" def setUp(self): """ """ self.prompts = [">"] self.newline = "\n" self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = CommandResponseInstrumentProtocol( self.prompts, self.newline, self.event_callback) self.protocol_fsm = ThreadSafeFSM(self.TestState, self.TestEvent, self.TestEvent.ENTER, self.TestEvent.EXIT) self.protocol_fsm.add_handler(self.TestState.TEST, self.TestEvent.TEST, lambda x: x) self.protocol._add_build_handler(self.TestEvent.TEST, self._build_simple_command) self.protocol._add_response_handler(self.TestEvent.TEST, self._parse_test_response) self.protocol._connection = Mock() self.protocol._connection.send = lambda x: self.protocol.add_to_buffer( "%s >->" % x) self.protocol.get_current_state = Mock( return_value=self.TestState.TEST) self.protocol._send_wakeup = lambda: self.protocol.add_to_buffer( "wakeup response >->") self.protocol._wakeup = functools.partial(self.protocol._wakeup, delay=0) def _build_simple_command(self, cmd): return "cmd...do it!" def _parse_test_response(self, resp, prompt): return "c=%s p=%s" % (resp, prompt) def event_callback(self, event, value=None): log.debug("Test event callback: %s" % event) self._events.append(event) self._trigger_count += 1 def test_cmd_response(self): """ Test getting a response from a command supplied with prompts and regexes. """ regex1 = re.compile(r'.*(do it).*') regex2 = re.compile(r'foobar') regex3 = re.compile(r'.*(do) (it).*') regex4 = re.compile(r'.*do it.*') # Normal case result = self.protocol._do_cmd_resp(self.TestEvent.TEST) self.assertEqual( result, self._parse_test_response( self._build_simple_command(None) + " >", ">")) # expected prompt cases result = self.protocol._do_cmd_resp(self.TestEvent.TEST, expected_prompt=">") self.assertEqual( result, self._parse_test_response( self._build_simple_command(None) + " >", ">")) result = self.protocol._do_cmd_resp(self.TestEvent.TEST, expected_prompt=">-") self.assertEqual( result, self._parse_test_response( self._build_simple_command(None) + " >-", ">-")) # Should time out looking for a bad prompt self.assertRaises(InstrumentTimeoutException, self.protocol._do_cmd_resp, self.TestEvent.TEST, expected_prompt="-->", timeout=.1) # regex cases result = self.protocol._do_cmd_resp(self.TestEvent.TEST, response_regex=regex1) self.assertEqual(result, self._parse_test_response("do it", "")) result = self.protocol._do_cmd_resp(self.TestEvent.TEST, response_regex=regex3) self.assertEqual(result, self._parse_test_response("doit", "")) result = self.protocol._do_cmd_resp(self.TestEvent.TEST, response_regex=regex4) self.assertEqual(result, self._parse_test_response("", "")) # Should time out looking for a bad regex self.assertRaises(InstrumentTimeoutException, self.protocol._do_cmd_resp, self.TestEvent.TEST, response_regex=regex2, timeout=.1) # combo case self.assertRaises(InstrumentProtocolException, self.protocol._do_cmd_resp, self.TestEvent.TEST, expected_prompt=">", response_regex=regex1)
class TestUnitInstrumentProtocol(MiUnitTestCase): """ Test cases for instrument protocol class. Functions in this class provide instrument protocol unit tests and provide a tutorial on use of the protocol interface. """ def setUp(self): """ """ self.callback_result = None self._trigger_count = 0 self._events = [] self.protocol = InstrumentProtocol(self.event_callback) def tearDown(self): if self.protocol._scheduler: self.protocol._scheduler._scheduler.shutdown() def event_callback(self, event, value=None): log.debug("Test event callback: %s" % event) self._events.append(event) self._trigger_count += 1 def _scheduler_callback(self): """ Callback to test the scheduler """ self._trigger_count += 1 def assert_scheduled_event_triggered(self, event_count=1): count = 0 for i in range(0, 40): count = self._trigger_count log.debug("check for triggered event, count %d" % self._trigger_count) if (count >= event_count): break time.sleep(0.3) self.assertGreater(count, 0) def test_get_prompts(self): """ ensure prompts are returned sorted by length """ prompts = ['aa', 'bbb', 'c', 'dddd'] expected = ['dddd', 'bbb', 'aa', 'c'] class Prompts(BaseEnum): A = 'aa' B = 'bbb' C = 'c' D = 'dddd' self.protocol = CommandResponseInstrumentProtocol( prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected) self.protocol = CommandResponseInstrumentProtocol( Prompts, '\r\n', self.event_callback) self.assertEqual(self.protocol._get_prompts(), expected) def test_extraction(self): sample_line = "SATPAR0229,10.01,2206748544,234\r\n" ntptime = ntplib.system_to_ntp_time(time.time()) result = self.protocol._extract_sample(PARParticle, SAMPLE_REGEX, sample_line, ntptime, publish=False) log.debug("R: %s" % result) self.assertEqual(result['stream_name'], PARParticle(None, None).data_particle_type()) # Test the format of the result in the individual driver tests. Here, # just tests that the result is there. def test_get_param_list(self): """ verify get_param_list returns correct parameter lists. """ params = ['foo', 'bar', 'baz'] for key in params: self.protocol._param_dict.add(key, r'', None, None) # All can be passed in as a string self.assertEqual( sorted(params), sorted(self.protocol._get_param_list(DriverParameter.ALL))) # All can be passed in as a single element list self.assertEqual( sorted(params), sorted(self.protocol._get_param_list([DriverParameter.ALL]))) # All can be in a list anywhere, not just the first element self.assertEqual( sorted(params), sorted(self.protocol._get_param_list(['foo', DriverParameter.ALL]))) # Bad parameters raise exceptions event when ALL is specified with self.assertRaises(InstrumentParameterException): self.assertEqual( sorted(params), sorted( self.protocol._get_param_list( ['noparam', DriverParameter.ALL]))) # An exception is raised when the param is not a list or string with self.assertRaises(InstrumentParameterException): self.protocol._get_param_list({'other': 'struct'}) # when a subset is given, the same set is returned. subset = ['bar', 'baz'] self.assertEqual(sorted(subset), sorted(self.protocol._get_param_list(subset))) # verify we can accept a tuple subset = ['bar', 'baz'] self.assertEqual(sorted(subset), sorted(self.protocol._get_param_list(('bar', 'baz')))) # An exception is raised when the param is not known with self.assertRaises(InstrumentParameterException): self.protocol._get_param_list(subset + ['boom']) # Verify we can send in a single parameter as a string, not ALL self.assertEqual(['bar'], self.protocol._get_param_list('bar')) def test_ring_buffer(self): """ verify command thread ring buffer rolls as expected """ prompts = ['aa', 'bbb', 'c', 'dddd'] self.protocol = CommandResponseInstrumentProtocol( prompts, '\r\n', self.event_callback) self.protocol._max_buffer_size = Mock(return_value=5) self.protocol.add_to_buffer("a") self.protocol.add_to_buffer("b") self.protocol.add_to_buffer("c") self.protocol.add_to_buffer("d") self.protocol.add_to_buffer("e") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "abcde") self.assertEqual(self.protocol._promptbuf, "abcde") self.protocol.add_to_buffer("f") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "bcdef") self.assertEqual(self.protocol._promptbuf, "bcdef") self.protocol.add_to_buffer("gh") self.assertEqual(len(self.protocol._linebuf), 5) self.assertEqual(len(self.protocol._promptbuf), 5) self.assertEqual(self.protocol._linebuf, "defgh") self.assertEqual(self.protocol._promptbuf, "defgh") @unittest.skip('Not Written') def test_publish_raw(self): """ Tests to see if raw data is appropriately published back out to the InstrumentAgent via the event callback. """ # build a packet # have it published by the protocol (force state if needed) # delay? # catch it in the callback # confirm it came back # compare response to original packet self.assertTrue(False) @unittest.skip('Not Written') def test_publish_parsed_data(self): """ Tests to see if parsed data is appropriately published back to the InstrumentAgent via the event callback. """ # similar to above self.assertTrue(False) @unittest.skip('Not Written') def test_publish_engineering_data(self): """ Tests to see if engineering data is appropriately published back to the InstrumentAgent via the event callback. """ # similar to above self.assertTrue(False) def test_get_running_config(self): """ Checks to see that one can successfully get the running config from an instrument protocol. """ # set some values log.debug("First param_dict: %s", self.protocol._param_dict.get_config()) self.protocol._param_dict.add("foo", r'foo=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=True, default_value=10) self.protocol._param_dict.set_default( "foo") # test hack to set w/o fetch self.protocol._param_dict.add("bar", r'bar=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=False, default_value=15) self.protocol._param_dict.set_default("bar") self.assertEquals(self.protocol._param_dict.get("foo"), 10) self.assertEquals(self.protocol._param_dict.get("bar"), 15) result = self.protocol.get_cached_config() self.assertEquals(result['foo'], 10) self.assertEquals(result['bar'], 15) self.protocol._param_dict.update("bar=20") result = self.protocol.get_cached_config() self.assertEquals(result['foo'], 10) self.assertEquals(result['bar'], 20) self.assertEquals(self.protocol._param_dict.get("bar"), 20) # get and check the running config result = self.protocol.get_cached_config() self.assertTrue(isinstance(result, dict)) self.assertEquals(result['foo'], 10) self.assertEquals(result['bar'], 20) def test_init_values(self): """ Test getting and setting the initialization value for a parameter """ self.protocol._param_dict.add("foo", r'foo=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=True, startup_param=True, default_value=10) self.protocol._param_dict.add("bar", r'bar=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=False, startup_param=True, default_value=0) self.protocol._param_dict.add("baz", r'baz=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=True, default_value=20) self.protocol._param_dict.add("bat", r'bat=(.*)', lambda match: int(match.group(1)), lambda x: str(x), startup_param=False, default_value=20) self.protocol._param_dict.add("qux", r'qux=(.*)', lambda match: int(match.group(1)), lambda x: str(x), startup_param=True) self.protocol._param_dict.add("rok", r'rok=(.*)', lambda match: int(match.group(1)), lambda x: str(x)) # set an additional value for test self.protocol._param_dict.update("qux=6666") # mark init params self.assertRaises(InstrumentParameterException, self.protocol.set_init_params, []) self.protocol.set_init_params( {DriverConfigKey.PARAMETERS: { "foo": 1111, "baz": 2222 }}) # get new startup config self.assertRaises(InstrumentProtocolException, self.protocol.get_startup_config) self.protocol.set_init_params({ DriverConfigKey.PARAMETERS: { "foo": 1111, "baz": 2222, "bat": 11, "qux": 22 } }) result = self.protocol.get_startup_config() self.assertEquals(len(result), 5) self.assertEquals(result["foo"], 1111) # init param self.assertEquals(result["bar"], 0) # init param with default value self.assertEquals(result["baz"], 2222) # non-init param, but value specified self.assertEquals(result["bat"], 11) # set param self.assertEquals(result["qux"], 22) # set param self.assertIsNone(result.get("rok")) # defined in paramdict, no config def test_apply_startup_params(self): """ Test that the apply startup parameters method exists and throws a "not implemented" exception for the base class """ self.assertRaises(NotImplementedException, self.protocol.apply_startup_params) def test_scheduler(self): """ Test to see that the scheduler can add and remove jobs properly Jobs are just queued for adding unit we call initialize_scheduler then the jobs are actually created. use an interval job to allow for testing for removal """ job_name = 'test_job' startup_config = { DriverConfigKey.SCHEDULER: { job_name: { DriverSchedulerConfigKey.TRIGGER: { DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL, DriverSchedulerConfigKey.SECONDS: 1 }, } } } self.protocol.set_init_params(startup_config) # Verify we are initialized properly self.assertIsNone(self.protocol._scheduler) self.assertEqual(self.protocol._scheduler_config, {}) self.assertEqual(self.protocol._scheduler_callback, {}) # Verify the the scheduler is created self.protocol.initialize_scheduler() self.assertIsInstance(self.protocol._scheduler, DriverScheduler) self.assertEqual(self.protocol._scheduler_config, {}) self.assertEqual(self.protocol._scheduler_callback, {}) # Now lets see some magic happen. Lets add our schedulers. Generally # This would be done as part of the protocol init, but it can happen # anytime. If the scheduler has already been initialized the # job will be started right away self.protocol._add_scheduler(job_name, self._scheduler_callback) self.assertEqual(0, self._trigger_count) self.assert_scheduled_event_triggered(event_count=3) # now remove the job and see that no events are triggered self.protocol._remove_scheduler(job_name) self._trigger_count = 0 time.sleep(2) self.assertEqual(self._trigger_count, 0) # now check that it raises exception if the removal is re-attempted try: self.protocol._remove_scheduler(job_name) except Exception as e: return self.fail("a non-existent job was erroneous removed") def test_scheduler_event(self): """ Test if we can add and trigger jobs using events instead of callbacks We will create two event triggers, foo and bar. They should come in that order. """ self.protocol._protocol_fsm = Mock() #self.protocol._fsm.on_event = Mock() dt = datetime.datetime.now() + datetime.timedelta(0, 1) foo_scheduler = 'foo' bar_scheduler = 'bar' startup_config = { DriverConfigKey.SCHEDULER: { foo_scheduler: { DriverSchedulerConfigKey.TRIGGER: { DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL, DriverSchedulerConfigKey.SECONDS: 1 } }, bar_scheduler: { DriverSchedulerConfigKey.TRIGGER: { DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL, DriverSchedulerConfigKey.SECONDS: 2 } } } } self.protocol.set_init_params(startup_config) # Verify we are initialized properly self.assertIsNone(self.protocol._scheduler) self.assertEqual(self.protocol._scheduler_config, {}) self.assertEqual(self.protocol._scheduler_callback, {}) # Verify the the scheduler is created self.protocol.initialize_scheduler() self.assertIsInstance(self.protocol._scheduler, DriverScheduler) self.assertEqual(self.protocol._scheduler_config, {}) self.assertEqual(self.protocol._scheduler_callback, {}) # Now lets see some magic happen. Lets add our schedulers. Generally # This would be done as part of the protocol init, but it can happen # anytime. If the scheduler has already been initialized the # job will be started right away foo_event = 'foo' bar_event = 'bar' self.protocol._add_scheduler_event(foo_scheduler, foo_event) self.protocol._add_scheduler_event(bar_scheduler, bar_event) self.assertEqual(0, self._trigger_count) #self.assert_scheduled_event_triggered(2) ##### Integration tests for test_scheduler in the SBE37 integration suite def test_generate_config_metadata_json(self): """ Tests generate of the metadata structure """ self.protocol._param_dict.add("foo", r'foo=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=True, default_value=10) self.protocol._param_dict.add("bar", r'bar=(.*)', lambda match: int(match.group(1)), lambda x: str(x), direct_access=False, default_value=15) self.protocol._cmd_dict.add( "cmd1", timeout=60, arguments=[CommandArgument("coeff"), CommandArgument("delay")]) # different way of creating things, possibly more clear in some cases # and allows for testing arg and command later cmd2_arg1 = CommandArgument("trigger") cmd2 = Command("cmd2", arguments=[cmd2_arg1]) self.protocol._cmd_dict.add_command(cmd2) self.protocol._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True) # Now do the real testing result = self.protocol.get_config_metadata_dict() self.assert_(isinstance(result[ConfigMetadataKey.DRIVER], dict)) self.assert_(isinstance(result[ConfigMetadataKey.COMMANDS], dict)) self.assert_(isinstance(result[ConfigMetadataKey.PARAMETERS], dict)) self.assertEquals(result[ConfigMetadataKey.DRIVER], {DriverDictKey.VENDOR_SW_COMPATIBLE: True}) # Check a few in the cmd list...the leaves in the structure are # tested in the cmd dict test cases self.assert_("cmd1" in result[ConfigMetadataKey.COMMANDS].keys()) self.assert_("cmd2" in result[ConfigMetadataKey.COMMANDS].keys()) # Check a few in the param list...the leaves in the structure are # tested in the param dict test cases self.assert_("foo" in result[ConfigMetadataKey.PARAMETERS].keys()) self.assert_("bar" in result[ConfigMetadataKey.PARAMETERS].keys()) def test_verify_muttable(self): """ Verify the verify_not_read_only works as expected. """ self.protocol._param_dict.add( 'ro', r'', None, None, visibility=ParameterDictVisibility.READ_ONLY) self.protocol._param_dict.add( 'immutable', r'', None, None, visibility=ParameterDictVisibility.IMMUTABLE) self.protocol._param_dict.add( 'rw', r'', None, None, visibility=ParameterDictVisibility.READ_WRITE) # Happy Path self.protocol._verify_not_readonly({'rw': 1}) self.protocol._verify_not_readonly({ 'rw': 1, 'immutable': 2 }, startup=True) with self.assertRaises(InstrumentParameterException): self.protocol._verify_not_readonly({'rw': 1, 'immutable': 2}) with self.assertRaises(InstrumentParameterException): self.protocol._verify_not_readonly({'rw': 1, 'ro': 2}) with self.assertRaises(InstrumentParameterException): self.protocol._verify_not_readonly({ 'rw': 1, 'ro': 2 }, startup=True)
def __init__(self, prompts, newline, driver_event): """ SBE43Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The SBE43 newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build SBE19 protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_unknown_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [(ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample), (ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample), (ProtocolEvent.GET, self._handler_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.CLOCK_SYNC, self._handler_command_clock_sync_clock), (ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status)], ProtocolState.ACQUIRING_SAMPLE: [ (ProtocolEvent.ENTER, self._handler_acquiring_sample_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_SAMPLE_ASYNC, self._handler_acquire_sample_async), ], ProtocolState.DIRECT_ACCESS: [(ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct)], ProtocolState.AUTOSAMPLE: [ (ProtocolEvent.ENTER, self._handler_autosample_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.GET, self._handler_get), (ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample), (ProtocolEvent.SCHEDULED_ACQUIRED_STATUS, self._handler_autosample_acquire_status), ] } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add build handlers for device commands, only using simple command handler. for cmd in Command.list(): if cmd == Command.SET: self._add_build_handler(Command.SET, self._build_set_command) else: self._add_build_handler(cmd, self._build_simple_command) # Add response handlers for device commands. # these are here to ensure that correct responses to the commands are received before the next command is sent self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.GET_SD, self._validate_GetSD_response) self._add_response_handler(Command.GET_HD, self._validate_GetHD_response) self._add_response_handler(Command.GET_CD, self._validate_GetCD_response) self._add_response_handler(Command.GET_CC, self._validate_GetCC_response) self._add_response_handler(Command.GET_EC, self._validate_GetEC_response) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(self.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START1, self._handler_command_start1), (ProtocolEvent.NAFREG, self._handler_command_nafreg), (ProtocolEvent.IONREG, self._handler_command_ionreg), (ProtocolEvent.POWEROFF, self._handler_command_poweroff), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.START1: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START1_COMPLETE, self._handler_start1_complete), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.WAITING_TURBO: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.START2, self._handler_waiting_turbo_start2), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.START2: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START2_COMPLETE, self._handler_start2_complete), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.WAITING_RGA: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.SAMPLE, self._handler_waiting_rga_sample), (ProtocolEvent.CALIBRATE, self._handler_waiting_rga_cal), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.SAMPLE: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.SAMPLE_COMPLETE, self._handler_sample_complete), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.CALIBRATE: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.CALIBRATE_COMPLETE, self._handler_cal_complete), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.STOPPING: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.REGEN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STANDBY, self._handler_stop), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_DIRECT, self._handler_stop), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), ], ProtocolState.ERROR: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STANDBY, self._handler_error_standby), (ProtocolEvent.CLEAR, self._handler_stop), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # response handlers for command in InstrumentCommand.list(): self._add_response_handler( command, functools.partial(self._generic_response_handler, command=command)) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() # Add build handlers for device commands. for command in InstrumentCommand.list(): if command == InstrumentCommand.SET_TELEGRAM_INTERVAL: self._add_build_handler(command, self._build_telegram_interval_command) elif command == InstrumentCommand.SAMPLE: self._add_build_handler(command, self._build_sample_command) elif command == InstrumentCommand.SET_MINUTE: self._add_build_handler(command, self._build_set_minute_command) else: self._add_build_handler(command, self._build_simple_command) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(Protocol.sieve_function) self.resetting = False
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_unknown_enter), (ProtocolEvent.EXIT, self._handler_unknown_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_command_exit), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.ACQUIRE_SAMPLE, self._handler_sample), (ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample), (ProtocolEvent.GET, self._handler_get), (ProtocolEvent.SET, self._handler_command_set), ], ProtocolState.AUTOSAMPLE: [ (ProtocolEvent.ENTER, self._handler_autosample_enter), (ProtocolEvent.ACQUIRE_SAMPLE, self._handler_sample), (ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop), (ProtocolEvent.EXIT, self._handler_autosample_exit), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_direct_access_exit), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Add build handlers for device commands - we are only using simple commands for cmd in Command.list(): self._add_build_handler(cmd, self._build_command) self._add_response_handler(cmd, self._check_command) self._add_build_handler(Command.SETUP, self._build_setup_command) self._add_response_handler(Command.READ_SETUP, self._read_setup_response_handler) # Add response handlers for device commands. # self._add_response_handler(Command.xyz, self._parse_xyz_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._chunker = StringChunker(Protocol.sieve_function) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._sent_cmds = None self.initialize_scheduler() # unit identifiers - must match the setup command (SU31 - '1') self._units = ['1', '2', '3'] self._setup = None # set by the read setup command handler for comparison to see if the config needs reset
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_SCAN, self._handler_command_start_scan), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), ], ProtocolState.SCAN: [ (ProtocolEvent.ENTER, self._handler_scan_enter), (ProtocolEvent.EXIT, self._handler_scan_exit), (ProtocolEvent.STOP_SCAN, self._handler_scan_stop_scan), (ProtocolEvent.TAKE_SCAN, self._handler_scan_take_scan), (ProtocolEvent.TIMEOUT, self._handler_scan_timeout), (ProtocolEvent.ERROR, self._handler_scan_error), ], ProtocolState.ERROR: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.CLEAR, self._handler_error_clear), (ProtocolEvent.GET, self._handler_command_get), ] } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() # Add build handlers for device commands. for command in InstrumentCommand.list(): self._add_build_handler(command, self._generic_build_handler) # Add response handlers for device commands. for command in InstrumentCommand.list(): self._add_response_handler(command, functools.partial(self._generic_response_handler, command=command)) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(Protocol.sieve_function) self.initialize_scheduler() # all calls to do_cmd_resp should expect RESPONSE_REGEX and use TIMEOUT. Freeze these arguments... self._do_cmd_resp = functools.partial(self._do_cmd_resp, response_regex=RESPONSE_REGEX, timeout=TIMEOUT) # these variables are used to track scan time and completion status # for development and performance data self.scan_start_time = 0 self.in_scan = False
def __init__(self, driver_event): CommandResponseInstrumentProtocol.__init__(self, None, None, driver_event) self._chunker = StringChunker(self.sieve_function)
def __init__(self, callback=None): CommandResponseInstrumentProtocol.__init__(self, Prompt, EOLN, callback) self._last_data_timestamp = None self._protocol_fsm = ThreadSafeFSM(SatlanticProtocolState, SatlanticProtocolEvent, SatlanticProtocolEvent.ENTER, SatlanticProtocolEvent.EXIT) self._protocol_fsm.add_handler(SatlanticProtocolState.UNKNOWN, SatlanticProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(SatlanticProtocolState.UNKNOWN, SatlanticProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status) self._protocol_fsm.add_handler(SatlanticProtocolState.COMMAND, SatlanticProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(SatlanticProtocolState.AUTOSAMPLE, SatlanticProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler( SatlanticProtocolState.AUTOSAMPLE, SatlanticProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(SatlanticProtocolState.DIRECT_ACCESS, SatlanticProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler( SatlanticProtocolState.DIRECT_ACCESS, SatlanticProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(SatlanticProtocolState.DIRECT_ACCESS, SatlanticProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) self._protocol_fsm.start(SatlanticProtocolState.UNKNOWN) self._add_response_handler(Command.GET, self._parse_get_response) self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.INVALID, self._parse_invalid_response) self._param_dict.add( Parameter.MAX_RATE, r"Maximum\ Frame\ Rate:\ (\S+).*?\s*", lambda match: match.group(1), lambda sVal: '%s' % sVal, type=ParameterDictType.STRING, display_name="Max Rate", value_description= "valid values: 0=auto, 0.125, 0.25, 0.5, 1, 2, 4, 8, 10, 12", units=Units.HERTZ, default_value='0', startup_param=True, direct_access=True) self._param_dict.add(Parameter.INIT_AT, r"Initialize Automatic Telemetry: (off|on)", lambda match: True if match.group(1) == 'on' else False, self._boolean_to_off_on, type=ParameterDictType.BOOL, display_name="Init AT", default_value=True, visibility=ParameterDictVisibility.IMMUTABLE, startup_param=True, direct_access=True) self._param_dict.add(Parameter.INIT_SM, r"Initialize Silent Mode: (off|on)", lambda match: True if match.group(1) == 'on' else False, self._boolean_to_off_on, type=ParameterDictType.BOOL, display_name="Init SM", default_value=True, visibility=ParameterDictVisibility.IMMUTABLE, startup_param=True, direct_access=True) self._param_dict.add(Parameter.NET_MODE, r"Network Mode: (off|on)", lambda match: True if match.group(1) == 'on' else False, self._boolean_to_off_on, type=ParameterDictType.BOOL, display_name="Net Mode", default_value=False, visibility=ParameterDictVisibility.IMMUTABLE, startup_param=True, direct_access=True) self._cmd_dict.add(SatlanticCapability.START_AUTOSAMPLE, display_name="Start Autosample") self._cmd_dict.add(SatlanticCapability.STOP_AUTOSAMPLE, display_name="Stop Autosample") self._cmd_dict.add(SatlanticCapability.ACQUIRE_STATUS, display_name="Acquire Status") self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True) self._chunker = StringChunker(self.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.GET, self._handler_command_get), (ProtocolEvent.SET, self._handler_command_set), (ProtocolEvent.START_TURBO, self._handler_command_start_turbo), ], ProtocolState.SPINNING_UP: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.AT_SPEED, self._handler_spinning_up_at_speed), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.AT_SPEED: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.ERROR, self._handler_error), ], ProtocolState.ERROR: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOP_TURBO, self._handler_stop_turbo), (ProtocolEvent.CLEAR, self._handler_clear), (ProtocolEvent.GET, self._handler_command_get), ], ProtocolState.SPINNING_DOWN: [ (ProtocolEvent.ENTER, self._handler_generic_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status), (ProtocolEvent.STOPPED, self._handler_spinning_down_stopped), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXIT, self._handler_generic_exit), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() # Add build and response handlers for device commands. for command in InstrumentCommand.list(): self._add_build_handler(command, self._generic_build_handler) self._add_response_handler(command, self._generic_response_handler) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(Protocol.sieve_function) self._max_current_count = 0 self.initialize_scheduler()
def __init__(self, callback=None): CommandResponseInstrumentProtocol.__init__(self, Prompt, EOLN, callback) self._protocol_fsm = InstrumentFSM(PARProtocolState, PARProtocolEvent, PARProtocolEvent.ENTER, PARProtocolEvent.EXIT) self._protocol_fsm.add_handler(PARProtocolState.UNKNOWN, PARProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(PARProtocolState.UNKNOWN, PARProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.ACQUIRE_SAMPLE, self._handler_poll_acquire_sample) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.SCHEDULED_ACQUIRE_STATUS, self._handler_acquire_status) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(PARProtocolState.COMMAND, PARProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE, PARProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE, PARProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE, PARProtocolEvent.SCHEDULED_ACQUIRE_STATUS, self._handler_autosample_acquire_status) self._protocol_fsm.add_handler(PARProtocolState.DIRECT_ACCESS, PARProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(PARProtocolState.DIRECT_ACCESS, PARProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(PARProtocolState.DIRECT_ACCESS, PARProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) self._protocol_fsm.start(PARProtocolState.UNKNOWN) self._add_response_handler(Command.GET, self._parse_get_response) self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.SAMPLE, self._parse_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_cmd_dict() self._build_driver_dict() self._param_dict.add(Parameter.MAXRATE, MAXRATE_PATTERN, lambda match: float(match.group(1)), self._float_or_int_to_string, direct_access=True, startup_param=True, init_value=4, display_name='Max Rate', description='Maximum sampling rate (0 (Auto) | 0.125 | 0.5 | 1 | 2 | 4 | 8 | 10 | 12)', type=ParameterDictType.FLOAT, units=Units.HERTZ, visibility=ParameterDictVisibility.READ_WRITE) self._param_dict.add(Parameter.INSTRUMENT, HEADER_PATTERN, lambda match: match.group(1), str, visibility=ParameterDictVisibility.IMMUTABLE, display_name='Instrument Type', description="", type=ParameterDictType.STRING, startup_param=True) self._param_dict.add(Parameter.SERIAL, HEADER_PATTERN, lambda match: match.group(1), str, visibility=ParameterDictVisibility.IMMUTABLE, display_name='Serial Number', description="", type=ParameterDictType.STRING, startup_param=True) self._param_dict.add(Parameter.FIRMWARE, HEADER_PATTERN, lambda match: match.group(1), str, visibility=ParameterDictVisibility.IMMUTABLE, display_name='Firmware Version', description="", type=ParameterDictType.STRING, startup_param=True) self._param_dict.add(Parameter.ACQUIRE_STATUS_INTERVAL, INTERVAL_TIME_REGEX, lambda match: match.group(1), str, display_name="Acquire Status Interval", description='Interval for gathering status particles.', type=ParameterDictType.STRING, units=ParameterUnits.TIME_INTERVAL, visibility=ParameterDictVisibility.READ_WRITE, default_value='00:00:00', startup_param=True) self._chunker = StringChunker(SatlanticPARInstrumentProtocol.sieve_function)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. handlers = { ProtocolState.UNKNOWN: [ (ProtocolEvent.ENTER, self._handler_unknown_enter), (ProtocolEvent.DISCOVER, self._handler_unknown_discover), ], ProtocolState.COMMAND: [ (ProtocolEvent.ENTER, self._handler_command_enter), (ProtocolEvent.INIT_PARAMS, self._handler_command_init_params), (ProtocolEvent.START_DIRECT, self._handler_command_start_direct), (ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock), (ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire), # (ProtocolEvent.ACQUIRE_STATUS, self._handler_command_status), (ProtocolEvent.CLEAR, self._handler_command_clear), (ProtocolEvent.GET, self._handler_get), (ProtocolEvent.SET, self._handler_command_set), ], ProtocolState.FLUSH: [ (ProtocolEvent.ENTER, self._handler_flush_enter), (ProtocolEvent.FLUSH, self._handler_flush_flush), (ProtocolEvent.PUMP_STATUS, self._handler_flush_pump_status), (ProtocolEvent.INSTRUMENT_FAILURE, self._handler_all_failure), ], ProtocolState.FILL: [ (ProtocolEvent.ENTER, self._handler_fill_enter), (ProtocolEvent.FILL, self._handler_fill_fill), (ProtocolEvent.PUMP_STATUS, self._handler_fill_pump_status), (ProtocolEvent.INSTRUMENT_FAILURE, self._handler_all_failure), ], ProtocolState.CLEAR: [ (ProtocolEvent.ENTER, self._handler_clear_enter), (ProtocolEvent.CLEAR, self._handler_clear_clear), (ProtocolEvent.PUMP_STATUS, self._handler_clear_pump_status), (ProtocolEvent.INSTRUMENT_FAILURE, self._handler_all_failure), ], ProtocolState.RECOVERY: [ (ProtocolEvent.ENTER, self._handler_recovery_enter), ], ProtocolState.DIRECT_ACCESS: [ (ProtocolEvent.ENTER, self._handler_direct_access_enter), (ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct), (ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct), ], } for state in handlers: for event, handler in handlers[state]: self._protocol_fsm.add_handler(state, event, handler) # Add build handlers for device commands - we are only using simple commands for cmd in McLaneCommand.list(): self._add_build_handler(cmd, self._build_command) # Add response handlers for device commands. # self._add_response_handler(McLaneCommand.BATTERY, self._parse_battery_response) # self._add_response_handler(McLaneCommand.CLOCK, self._parse_clock_response) # self._add_response_handler(McLaneCommand.PORT, self._parse_port_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._chunker = StringChunker(McLaneProtocol.sieve_function) self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._sent_cmds = None # TODO - reset next_port on mechanical refresh of the PPS filters - how is the driver notified? # TODO - need to persist state for next_port to save driver restart self.next_port = 1 # next available port self._second_attempt = False
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_command_sync_clock) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.FLASH_STATUS, self._handler_flash_status) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.CLOCK_SYNC, self._handler_autosample_sync_clock) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_get) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.FLASH_STATUS, self._handler_flash_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status) # We setup a new state for clock sync because then we could use the state machine so the autosample scheduler # is disabled before we try to sync the clock. Otherwise there could be a race condition introduced when we # are syncing the clock and the scheduler requests a sample. self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.ENTER, self._handler_sync_clock_enter) self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock_sync) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Add build handlers for device commands. self._add_build_handler(Command.GET_CLOCK, self._build_simple_command) self._add_build_handler(Command.SET_CLOCK, self._build_set_clock_command) self._add_build_handler(Command.D, self._build_simple_command) self._add_build_handler(Command.GO, self._build_simple_command) self._add_build_handler(Command.STOP, self._build_simple_command) self._add_build_handler(Command.FS, self._build_simple_command) self._add_build_handler(Command.STAT, self._build_simple_command) # Add response handlers for device commands. self._add_response_handler(Command.GET_CLOCK, self._parse_clock_response) self._add_response_handler(Command.SET_CLOCK, self._parse_clock_response) self._add_response_handler(Command.FS, self._parse_fs_response) self._add_response_handler(Command.STAT, self._parse_common_response) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_param_dict() self._build_command_dict() self._build_driver_dict() self._chunker = StringChunker(Protocol.sieve_function) self._add_scheduler_event(ScheduledJob.ACQUIRE_STATUS, ProtocolEvent.ACQUIRE_STATUS) self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC) # Start state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN)
def __init__(self, callback=None): CommandResponseInstrumentProtocol.__init__(self, Prompt, EOLN, callback) self.write_delay = WRITE_DELAY self._last_data_timestamp = None self.eoln = EOLN self._protocol_fsm = InstrumentFSM(PARProtocolState, PARProtocolEvent, PARProtocolEvent.ENTER_STATE, PARProtocolEvent.EXIT_STATE) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.AUTOSAMPLE, self._handler_command_autosample) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.COMMAND, self._handler_command_command) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.ENTER_STATE, self._handler_command_enter_state) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.POLL, self._handler_command_poll) #self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.SAMPLE, # self._handler_command_sample) self._protocol_fsm.add_handler(PARProtocolState.COMMAND_MODE, PARProtocolEvent.BREAK, self._handler_noop) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE_MODE, PARProtocolEvent.BREAK, self._handler_autosample_break) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE_MODE, PARProtocolEvent.STOP, self._handler_autosample_stop) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE_MODE, PARProtocolEvent.RESET, self._handler_reset) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE_MODE, PARProtocolEvent.COMMAND, self._handler_autosample_command) self._protocol_fsm.add_handler(PARProtocolState.AUTOSAMPLE_MODE, PARProtocolEvent.ENTER_STATE, self._handler_autosample_enter_state) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.AUTOSAMPLE, self._handler_poll_autosample) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.RESET, self._handler_reset) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.BREAK, self._handler_poll_break) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.SAMPLE, self._handler_poll_sample) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.COMMAND, self._handler_poll_command) self._protocol_fsm.add_handler(PARProtocolState.POLL_MODE, PARProtocolEvent.ENTER_STATE, self._handler_poll_enter_state) self._protocol_fsm.add_handler(PARProtocolState.UNKNOWN, PARProtocolEvent.INITIALIZE, self._handler_initialize) self._protocol_fsm.start(PARProtocolState.UNKNOWN) self._add_build_handler(Command.SET, self._build_set_command) self._add_build_handler(Command.GET, self._build_param_fetch_command) self._add_build_handler(Command.SAVE, self._build_exec_command) self._add_build_handler(Command.EXIT, self._build_exec_command) self._add_build_handler(Command.EXIT_AND_RESET, self._build_exec_command) self._add_build_handler(Command.AUTOSAMPLE, self._build_multi_control_command) self._add_build_handler(Command.RESET, self._build_control_command) self._add_build_handler(Command.BREAK, self._build_multi_control_command) self._add_build_handler(Command.SAMPLE, self._build_control_command) self._add_build_handler(Command.STOP, self._build_multi_control_command) self._add_response_handler(Command.GET, self._parse_get_response) self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.STOP, self._parse_silent_response) self._add_response_handler(Command.SAMPLE, self._parse_sample_poll_response, PARProtocolState.POLL_MODE) self._add_response_handler(Command.SAMPLE, self._parse_cmd_prompt_response, PARProtocolState.COMMAND_MODE) self._add_response_handler(Command.BREAK, self._parse_silent_response, PARProtocolState.COMMAND_MODE) self._add_response_handler(Command.BREAK, self._parse_header_response, PARProtocolState.POLL_MODE) self._add_response_handler(Command.BREAK, self._parse_header_response, PARProtocolState.AUTOSAMPLE_MODE) self._add_response_handler(Command.RESET, self._parse_silent_response, PARProtocolState.COMMAND_MODE) self._add_response_handler(Command.RESET, self._parse_reset_response, PARProtocolState.POLL_MODE) self._add_response_handler(Command.RESET, self._parse_reset_response, PARProtocolState.AUTOSAMPLE_MODE) self._param_dict.add(Parameter.TELBAUD, r'Telemetry Baud Rate:\s+(\d+) bps', lambda match : int(match.group(1)), self._int_to_string) self._param_dict.add(Parameter.MAXRATE, r'Maximum Frame Rate:\s+(\d+) Hz', lambda match : int(match.group(1)), self._int_to_string)
def __init__(self, prompts, newline, driver_event): """ Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.SCHEDULE_ACQUIRE_SAMPLE, self._handler_command_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add build handlers for device commands. self._add_build_handler(Command.GET_SAMPLE, self._build_simple_command) # State state machine in COMMAND state. self._protocol_fsm.start(ProtocolState.UNKNOWN) # commands sent to device to be filtered in responses for telnet DA self._sent_cmds = [] self._chunker = StringChunker(THSPHProtocol.sieve_function) # Set Get Sample Command and Communication Test Command for Series A as default self._get_sample_cmd = self.GET_SAMPLE_SERIES_A
def got_data(self, data): CommandResponseInstrumentProtocol.got_data(self, data) log.info("!!!!!!!!!!!!!!!!!!!got_data: data = %s" % str(data))
def __init__(self, prompts, newline, driver_event): """ SBE43Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The SBE43 newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build SBE19 protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample ) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.GET_CONFIGURATION, self._handler_command_get_configuration ) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample ) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.RESET_EC, self._handler_command_reset_ec) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct ) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_command_clock_sync_clock ) self._protocol_fsm.add_handler( ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status ) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler( ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample ) self._protocol_fsm.add_handler( ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_STATUS, self._handler_autosample_acquire_status ) self._protocol_fsm.add_handler( ProtocolState.AUTOSAMPLE, ProtocolEvent.GET_CONFIGURATION, self._handler_autosample_get_configuration ) self._protocol_fsm.add_handler( ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter ) self._protocol_fsm.add_handler( ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit ) self._protocol_fsm.add_handler( ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct ) self._protocol_fsm.add_handler( ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct ) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add build handlers for device commands. self._add_build_handler(Command.DS, self._build_simple_command) self._add_build_handler(Command.GET_CD, self._build_simple_command) self._add_build_handler(Command.GET_SD, self._build_simple_command) self._add_build_handler(Command.GET_CC, self._build_simple_command) self._add_build_handler(Command.GET_EC, self._build_simple_command) self._add_build_handler(Command.RESET_EC, self._build_simple_command) self._add_build_handler(Command.GET_HD, self._build_simple_command) self._add_build_handler(Command.START_NOW, self._build_simple_command) self._add_build_handler(Command.STOP, self._build_simple_command) self._add_build_handler(Command.TS, self._build_simple_command) self._add_build_handler(Command.SET, self._build_set_command) # Add response handlers for device commands. # these are here to ensure that correct responses to the commands are received before the next command is sent self._add_response_handler(Command.DS, self._parse_dsdc_response) self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.GET_SD, self._validate_GetSD_response) self._add_response_handler(Command.GET_HD, self._validate_GetHD_response) self._add_response_handler(Command.GET_CD, self._validate_GetCD_response) self._add_response_handler(Command.GET_CC, self._validate_GetCC_response) self._add_response_handler(Command.GET_EC, self._validate_GetEC_response) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(self.sieve_function)
def __init__(self, prompts, newline, driver_event): """ SBE43Protocol constructor. @param prompts A BaseEnum class containing instrument prompts. @param newline The SBE43 newline. @param driver_event Driver process event callback. """ # Construct protocol superclass. CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event) # Build SBE19 protocol state machine. self._protocol_fsm = InstrumentFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT) # Add event handlers for protocol state machine. self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit) self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET_CONFIGURATION, self._handler_command_get_configuration) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_command_clock_sync_clock) self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_command_get) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_STATUS, self._handler_autosample_acquire_status) self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET_CONFIGURATION, self._handler_autosample_get_configuration) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct) self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct) # Construct the parameter dictionary containing device parameters, # current parameter values, and set formatting functions. self._build_driver_dict() self._build_command_dict() self._build_param_dict() # Add build handlers for device commands. self._add_build_handler(Command.DS, self._build_simple_command) self._add_build_handler(Command.GET_CD, self._build_simple_command) self._add_build_handler(Command.GET_SD, self._build_simple_command) self._add_build_handler(Command.GET_CC, self._build_simple_command) self._add_build_handler(Command.GET_EC, self._build_simple_command) self._add_build_handler(Command.RESET_EC, self._build_simple_command) self._add_build_handler(Command.GET_HD, self._build_simple_command) self._add_build_handler(Command.START_NOW, self._build_simple_command) self._add_build_handler(Command.STOP, self._build_simple_command) self._add_build_handler(Command.TS, self._build_simple_command) self._add_build_handler(Command.SET, self._build_set_command) # Add response handlers for device commands. # these are here to ensure that correct responses to the commands are received before the next command is sent self._add_response_handler(Command.DS, self._parse_dsdc_response) self._add_response_handler(Command.SET, self._parse_set_response) self._add_response_handler(Command.GET_SD, self._validate_GetSD_response) self._add_response_handler(Command.GET_HD, self._validate_GetHD_response) self._add_response_handler(Command.GET_CD, self._validate_GetCD_response) self._add_response_handler(Command.GET_CC, self._validate_GetCC_response) self._add_response_handler(Command.GET_EC, self._validate_GetEC_response) # State state machine in UNKNOWN state. self._protocol_fsm.start(ProtocolState.UNKNOWN) self._chunker = StringChunker(self.sieve_function)