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)