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, 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):
"""
"""
MenuInstrumentProtocol.__init__(self, prompts, newline, driver_event)
self.write_delay = WRITE_DELAY
self._last_data_timestamp = None
self.eoln = EOLN
##### Setup the state machine
self._protocol_fsm = InstrumentFSM(State, Event, Event.ENTER, Event.EXIT)
self._protocol_fsm.add_handler(State.UNCONFIGURED_MODE, Event.INITIALIZE,
self._handler_initialize)
self._protocol_fsm.add_handler(State.UNCONFIGURED_MODE, Event.DISCOVER,
self._handler_unknown_discover)
self._protocol_fsm.add_handler(State.CONTINUOUS_MODE, Event.MENU_CMD,
self._handler_continuous_menu)
self._protocol_fsm.add_handler(State.CONTINUOUS_MODE, Event.GO_CMD,
self._handler_continuous_go)
self._protocol_fsm.add_handler(State.CONTINUOUS_MODE, Event.STOP_CMD,
self._handler_continuous_stop)
# ... and so on with the operation handler listings...
# In general, naming is _handler_currentstate_eventreceived
self._protocol_fsm.add_handler(State.ROOT_MENU, Event.ENTER,
self._handler_root_menu_enter)
self._protocol_fsm.add_handler(State.ROOT_MENU, Event.CONFIG_MENU,
self._handler_root_config)
self._protocol_fsm.add_handler(State.ROOT_MENU, Event.SETUP_MENU,
self._handler_root_setup)
self._protocol_fsm.add_handler(State.ROOT_MENU, Event.FILE_MENU,
self._handler_root_file)
#
# DHE added
#
self._protocol_fsm.add_handler(State.ROOT_MENU, Event.GET,
self._handler_command_get)
# @todo ... and so on with the menu handler listings...
# these build handlers will be called by the base class during the
# navigate_and_execute sequence.
self._add_build_handler(Event.CONFIG_MENU, self._build_simple_command)
self._add_build_handler(Event.SHOW_CONFIG, self._build_simple_command)
self._add_build_handler(Event.BAUD_RATE, self._build_simple_command)
# Add response handlers for parsing command responses
self._add_response_handler(Event.SHOW_CONFIG, self._parse_show_config_menu_response)
# Construct the parameter dictionary
self._build_param_dict()
# State state machine in UNCONFIGURED state.
self._protocol_fsm.start(State.UNCONFIGURED_MODE)
"""
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.
"""
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, event_callback):
"""
Constructor for singly connected instrument drivers.
@param event_callback Callback to the driver process to send asynchronous
driver events back to the agent.
"""
InstrumentDriver.__init__(self, event_callback)
# The only and only instrument connection.
# Exists in the connected state.
self._connection = None
# The one and only instrument protocol.
self._protocol = None
# Build connection state machine.
self._connection_fsm = InstrumentFSM(DriverConnectionState,
DriverEvent,
DriverEvent.ENTER,
DriverEvent.EXIT)
# Add handlers for all events.
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.ENTER, self._handler_unconfigured_enter)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.EXIT, self._handler_unconfigured_exit)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.INITIALIZE, self._handler_unconfigured_initialize)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.CONFIGURE, self._handler_unconfigured_configure)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.ENTER, self._handler_disconnected_enter)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.EXIT, self._handler_disconnected_exit)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.INITIALIZE, self._handler_disconnected_initialize)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.CONFIGURE, self._handler_disconnected_configure)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.CONNECT, self._handler_disconnected_connect)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.ENTER, self._handler_connected_enter)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.EXIT, self._handler_connected_exit)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.DISCONNECT, self._handler_connected_disconnect)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.CONNECTION_LOST, self._handler_connected_connection_lost)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.DISCOVER, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.GET, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.SET, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.EXECUTE, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.FORCE_STATE, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.START_DIRECT, self._handler_connected_start_direct_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.STOP_DIRECT, self._handler_connected_stop_direct_event)
# Start state machine.
self._connection_fsm.start(DriverConnectionState.UNCONFIGURED)
self._pre_da_config = {}
self._startup_config = {}
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, 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)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.START_AUTOSAMPLE, self._handler_command_start_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.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.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.
#
# JML: Not in OPTAA?
#
#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
#
# JML: Not in OPTAA?
#
#self._sent_cmds = []
#
# JML: Billy sez "no chunker, no sieve"
#
#self._chunker = StringChunker(Protocol.sieve_function)
# JML: What does this do?
self._build_driver_dict()
#
# JML: Billy sez "no chunker, no sieve"
#
# @staticmethod
# def sieve_function(raw_data):
# """
# The method that splits samples
# """
#
# return_list = []
#
# return return_list
def got_raw(self, *args, **kwargs):
pass
def got_data(self, port_agent_packet):
"""
Called by the instrument connection when data is available.
Also add data to the chunker and when received call got_chunk
to publish results.
"""
data_length = port_agent_packet.get_data_length()
data = port_agent_packet.get_data()
timestamp = port_agent_packet.get_timestamp()
log.debug("Got Data: %s" % data)
log.debug("Add Port Agent Timestamp: %s" % timestamp)
unpickler = Unpickler(StringIO(data))
# Disable class unpickling, for security; record should be all
# built-in types. Note this only works with cPickle.
unpickler.find_global = None
# pkt is an antelope.Pkt.Packet object converted to a dict. Refer to
# the documentation for the Antelope Python bindings for compelete
# details.
pkt = unpickler.load()
for particle in self._particle_factory(pkt, timestamp):
self._publish_particle(particle)
def _particle_factory(self, orb_packet, port_timestamp):
"""Generate a sequence of particles from orb_packet
@returns An iterator which yields a new particle object for each sample
for each channel.
"""
# TODO Might want to verify that the channel name matches a pattern,
# e.g. the SEED standard for hydrophones.
for chan in orb_packet['channels']:
for index, sample in enumerate(chan['data']):
# Yield a new particle
# TODO don't hardcode particle class
particle = HYDLF_SampleDataParticle(
# TODO: Fix this passing raw_data as tuple hack
raw_data = (orb_packet, chan, index, sample),
port_timestamp = port_timestamp,
preferred_timestamp = DataParticleKey.INTERNAL_TIMESTAMP
)
yield particle
def _publish_particle(self, particle):
"""publish parsed particle"""
parsed_sample = particle.generate()
if self._driver_event:
self._driver_event(DriverAsyncEvent.SAMPLE, parsed_sample)
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
pass
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
# JML: Copied from OPTAA; need this?
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
# JML: Copied from OPTAA
# force to auto-sample, this instrument has no command mode
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
return (next_state, result)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
# JML: Copied from OPTAA
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
# JML: Copied wholesale from OPTAA
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
# JML: Not in OPTAA
# self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
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)
class SatlanticPARInstrumentProtocol(CommandResponseInstrumentProtocol):
"""The instrument protocol classes to deal with a Satlantic PAR sensor.
The protocol is a very simple command/response protocol with a few show
commands and a few set commands.
Note protocol state machine must be called "self._protocol_fsm"
"""
__metaclass__ = get_logging_metaclass(log_level='debug')
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 _build_cmd_dict(self):
"""
Build a command dictionary structure, load the strings for the metadata from a file if present.
"""
self._cmd_dict = ProtocolCommandDict()
self._cmd_dict.add(PARCapability.ACQUIRE_SAMPLE, display_name='Acquire Sample')
self._cmd_dict.add(PARCapability.ACQUIRE_STATUS, display_name='Acquire Status')
self._cmd_dict.add(PARCapability.START_AUTOSAMPLE, display_name='Start Autosample')
self._cmd_dict.add(PARCapability.STOP_AUTOSAMPLE, display_name='Stop Autosample')
self._cmd_dict.add(PARCapability.DISCOVER, display_name='Discover')
def _build_driver_dict(self):
"""
Build a driver dictionary structure, load the strings for the metadata from a file if present.
"""
self._driver_dict = DriverDict()
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = [SAMPLE_REGEX, MAXANDBAUDRATE_REGEX]
return_list = []
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
log.trace("sieve_function: regex found %r", raw_data[match.start():match.end()])
return return_list
def _filter_capabilities(self, events):
"""
"""
events_out = [x for x in events if PARCapability.has(x)]
return events_out
def _do_cmd(self, cmd, *args, **kwargs):
"""
Issue a command to the instrument after clearing of buffers.
@param cmd The command to execute.
@param args positional arguments to pass to the build handler.
@retval The fully built command that was sent
@raises InstrumentProtocolException if command could not be built.
"""
expected_prompt = kwargs.get('expected_prompt', None)
cmd_line = self._build_default_command(cmd, *args)
# Send command.
log.debug('_do_cmd: %s, length=%s' % (repr(cmd_line), len(cmd_line)))
if len(cmd_line) == 1:
self._connection.send(cmd_line)
else:
for char in cmd_line:
starttime = time.time()
self._connection.send(char)
while len(self._promptbuf) == 0 or char not in self._promptbuf[-1]:
time.sleep(0.0015)
if time.time() > starttime + 3:
break
# Keep for reference: This is a reliable alternative, but not fully explained & may not work in the future.
# It somehow corrects bit rate timing issues across the driver-digi-instrument network interface,
# & allows the entire line of a commands to be sent successfully.
if EOLN not in cmd_line: # Note: Direct access commands may already include an EOLN
time.sleep(0.115)
starttime = time.time()
self._connection.send(EOLN)
while EOLN not in self._promptbuf[len(cmd_line):len(cmd_line) + 2] and Prompt.ENTER_EXIT_CMD_MODE \
not in self._promptbuf[len(cmd_line):len(cmd_line) + 2]:
time.sleep(0.0015)
if time.time() > starttime + 3:
break
# Limit resend_check_value from expected_prompt to one of the two below
resend_check_value = None
if expected_prompt is not None:
for check in (Prompt.COMMAND, Prompt.SAMPLES):
if check in expected_prompt:
log.trace('_do_cmd: command: %s, check=%s' % (cmd_line, check))
resend_check_value = check
# Resend the EOLN if it did not go through the first time
starttime = time.time()
if resend_check_value is not None:
while True:
time.sleep(0.1)
if time.time() > starttime + 2:
log.debug("Sending eoln again.")
self._connection.send(EOLN)
starttime = time.time()
if resend_check_value in self._promptbuf:
break
if PARProtocolError.INVALID_COMMAND in self._promptbuf:
break
return cmd_line
def _do_cmd_no_resp(self, cmd, *args, **kwargs):
"""
Issue a command to the instrument after clearing of buffers. No response is handled as a result of the command.
Overridden: special "write delay" & command resending
reliability improvements, no need for wakeup, default build command used for all commands
@param cmd The command to execute.
@param args positional arguments to pass to the build handler.
@raises InstrumentProtocolException if command could not be built.
"""
self._do_cmd(cmd, *args, **kwargs)
def _do_cmd_resp(self, cmd, *args, **kwargs):
"""
Perform a command-response on the device. Overridden: special "write delay" & command resending
reliability improvements, no need for wakeup, default build command used for all commands
@param cmd The command to execute.
@param args positional arguments to pass to the build handler.
@param expected_prompt kwarg offering a specific prompt to look for
other than the ones in the protocol class itself.
@param response_regex kwarg with a compiled regex for the response to
match. Groups that match will be returned as a string.
Cannot be supplied with expected_prompt. May be helpful for instruments that do not have a prompt.
@retval resp_result The (possibly parsed) response result including the
first instance of the prompt matched. If a regex was used, the prompt
will be an empty string and the response will be the joined collection of matched groups.
@raises InstrumentTimeoutException if the response did not occur in time.
@raises InstrumentProtocolException if command could not be built or if response was not recognized.
"""
timeout = kwargs.get('timeout', DEFAULT_CMD_TIMEOUT)
expected_prompt = kwargs.get('expected_prompt', None)
response_regex = kwargs.get('response_regex', None)
if response_regex and not isinstance(response_regex, RE_PATTERN):
raise InstrumentProtocolException('Response regex is not a compiled pattern!')
if expected_prompt and response_regex:
raise InstrumentProtocolException('Cannot supply both regex and expected prompt!')
retry_count = 5
retry_num = 0
cmd_line = ""
result = ""
prompt = ""
for retry_num in xrange(retry_count):
# Clear line and prompt buffers for result.
self._linebuf = ''
self._promptbuf = ''
cmd_line = self._do_cmd(cmd, *args, **kwargs)
# Wait for the prompt, prepare result and return, timeout exception
if response_regex:
result_tuple = self._get_response(timeout, response_regex=response_regex,
expected_prompt=expected_prompt)
result = "".join(result_tuple)
else:
(prompt, result) = self._get_response(timeout, expected_prompt=expected_prompt)
# Confirm the entire command was sent, otherwise resend retry_count number of times
if len(cmd_line) > 1 and \
(expected_prompt is not None or
(response_regex is not None))\
and not result.startswith(cmd_line):
# and cmd_line not in result:
log.debug("_do_cmd_resp: Send command: %s failed %s attempt, result = %s.", cmd, retry_num, result)
if retry_num >= retry_count:
raise InstrumentCommandException('_do_cmd_resp: Failed %s attempts sending command: %s' %
(retry_count, cmd))
else:
break
log.debug("_do_cmd_resp: Sent command: %s, %s reattempts, expected_prompt=%s, result=%s.",
cmd_line, retry_num, expected_prompt, result)
resp_handler = self._response_handlers.get((self.get_current_state(), cmd), None) or \
self._response_handlers.get(cmd, None)
resp_result = None
if resp_handler:
resp_result = resp_handler(result, prompt)
time.sleep(0.3) # give some time for the instrument connection to keep up
return resp_result
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self):
"""
Enter unknown state.
"""
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_discover(self):
"""
Discover current state; can be COMMAND or AUTOSAMPLE.
@retval (next_state, result), (PARProtocolState.COMMAND or PARProtocolState.AUTOSAMPLE, None).
"""
try:
probe_resp = self._do_cmd_resp(Command.SAMPLE, timeout=2,
expected_prompt=[Prompt.SAMPLES, PARProtocolError.INVALID_COMMAND])
except InstrumentTimeoutException:
self._do_cmd_resp(Command.SWITCH_TO_AUTOSAMPLE, expected_prompt=Prompt.SAMPLES, timeout=15)
return PARProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING
log.trace("_handler_unknown_discover: returned: %s", probe_resp)
if probe_resp == PARProtocolError.INVALID_COMMAND:
return PARProtocolState.COMMAND, ResourceAgentState.IDLE
else:
# Put the instrument into full autosample in case it isn't already (could be in polled mode)
self._do_cmd_resp(Command.SWITCH_TO_AUTOSAMPLE, expected_prompt=Prompt.SAMPLES, timeout=15)
return PARProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self):
"""
Enter command state.
"""
# Command device to update parameters and send a config change event.
if self._init_type != InitializationType.NONE:
self._update_params()
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _update_params(self):
"""
Fetch the parameters from the device, and update the param dict.
"""
max_rate_response = self._do_cmd_resp(Command.GET, Parameter.MAXRATE, expected_prompt=Prompt.COMMAND)
self._param_dict.update(max_rate_response)
def _set_params(self, params, startup=False, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
Also called when setting parameters during startup and direct access
Issue commands to the instrument to set various parameters. If
startup is set to true that means we are setting startup values
and immutable parameters can be set. Otherwise only READ_WRITE
parameters can be set.
@param params dictionary containing parameter name and value
@param startup bool True is we are initializing, False otherwise
@raise InstrumentParameterException
"""
# Retrieve required parameter from args.
# Raise exception if no parameter provided, or not a dict.
scheduling_interval_changed = False
instrument_params_changed = False
old_config = self._param_dict.get_all()
if not isinstance(params, dict):
raise InstrumentParameterException('Set params requires a parameter dict.')
self._verify_not_readonly(params, startup)
for name, value in params.iteritems():
old_val = self._param_dict.format(name)
new_val = self._param_dict.format(name, params[name])
log.debug('Changing param %r OLD = %r, NEW %r', name, old_val, new_val)
if name == Parameter.MAXRATE:
if value not in VALID_MAXRATES:
raise InstrumentParameterException("Maxrate %s out of range" % value)
if old_val != new_val:
if self._do_cmd_resp(Command.SET, name, new_val, expected_prompt=Prompt.COMMAND):
instrument_params_changed = True
elif name == Parameter.ACQUIRE_STATUS_INTERVAL:
if old_val != new_val:
self._param_dict.set_value(name, new_val)
scheduling_interval_changed = True
elif name in [Parameter.FIRMWARE, Parameter.INSTRUMENT, Parameter.SERIAL]:
self._param_dict.set_value(name, new_val)
else:
raise InstrumentParameterException("Parameter not in dictionary: %s" % name)
if instrument_params_changed:
self._do_cmd_resp(Command.SAVE, expected_prompt=Prompt.COMMAND)
self._update_params()
if scheduling_interval_changed and not startup:
self._setup_scheduler_config()
new_config = self._param_dict.get_all()
log.debug("Updated parameter dict: old_config = %s, new_config = %s", old_config, new_config)
if new_config != old_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
for name in params.keys():
if self._param_dict.format(name, params[name]) != self._param_dict.format(name):
raise InstrumentParameterException('Failed to update parameter: %s' % name)
def _handle_scheduling_params_changed(self):
"""
Required actions when scheduling parameters change
"""
self._setup_scheduler_config()
def _setup_scheduler_config(self):
"""
Set up auto scheduler configuration.
"""
interval = self._param_dict.format(Parameter.ACQUIRE_STATUS_INTERVAL).split(':')
hours = int(interval[0])
minutes = int(interval[1])
seconds = int(interval[2])
log.debug("Setting scheduled interval to: %s %s %s", hours, minutes, seconds)
if DriverConfigKey.SCHEDULER in self._startup_config:
self._startup_config[DriverConfigKey.SCHEDULER][ScheduledJob.ACQUIRE_STATUS] = {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.HOURS: int(hours),
DriverSchedulerConfigKey.MINUTES: int(minutes),
DriverSchedulerConfigKey.SECONDS: int(seconds)}
}
else:
self._startup_config[DriverConfigKey.SCHEDULER] = {
ScheduledJob.ACQUIRE_STATUS: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.HOURS: int(hours),
DriverSchedulerConfigKey.MINUTES: int(minutes),
DriverSchedulerConfigKey.SECONDS: int(seconds)}
},
}
# Start the scheduler if it is not running
if not self._scheduler:
self.initialize_scheduler()
# First remove the scheduler, if it exists
if not self._scheduler_callback.get(ScheduledJob.ACQUIRE_STATUS) is None:
self._remove_scheduler(ScheduledJob.ACQUIRE_STATUS)
log.debug("Removed scheduler for acquire status")
# Now Add the scheduler
if hours > 0 or minutes > 0 or seconds > 0:
self._add_scheduler_event(ScheduledJob.ACQUIRE_STATUS, PARProtocolEvent.SCHEDULED_ACQUIRE_STATUS)
def _handler_command_set(self, *args, **kwargs):
"""
Handle setting data from command mode.
@param params Dict of the parameters and values to pass to the state
@retval return (next state, result)
"""
self._set_params(*args, **kwargs)
return None, None
def _handler_command_start_autosample(self):
"""
Handle getting a start autosample event when in command mode
@retval return (next state, result)
"""
self._do_cmd_resp(Command.EXIT, expected_prompt=Prompt.SAMPLES, timeout=15)
time.sleep(0.115)
self._do_cmd_resp(Command.SWITCH_TO_AUTOSAMPLE, expected_prompt=Prompt.SAMPLES, timeout=15)
return PARProtocolState.AUTOSAMPLE, (ResourceAgentState.STREAMING, None)
def _handler_command_start_direct(self):
"""
"""
return PARProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS, None)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self):
"""
Handle PARProtocolState.AUTOSAMPLE PARProtocolEvent.ENTER
@retval return (next state, result)
"""
if self._init_type != InitializationType.NONE:
self._handler_autosample_stop_autosample()
self._update_params()
self._handler_command_start_autosample()
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
return None, None
def _handler_autosample_stop_autosample(self):
"""
Handle PARProtocolState.AUTOSAMPLE stop
@retval return (next state, result)
@throw InstrumentProtocolException For hardware error
"""
try:
self._send_break()
except InstrumentException, e:
log.debug("_handler_autosample_stop_autosample error: %s", e)
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Couldn't break from autosample!")
return PARProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = []
return_list = []
matchers.append(HEATDataParticle.regex_compiled())
matchers.append(HEATCommandResponse.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _build_cmd_dict(self):
"""
Populate the command dictionary with NOAA HEAT Driver metadata information.
Currently HEAT only supports HEAT_ON and HEAT_OFF.
"""
self._cmd_dict = ProtocolCommandDict()
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
# Next 2 work together to pull 2 values out of a single line.
#
self._param_dict.add(Parameter.HEAT_DURATION,
r'Not used. This is just to satisfy the param_dict',
None,
None,
type=ParameterDictType.INT,
display_name="Heat Duration",
multi_match=False,
visibility=ParameterDictVisibility.READ_WRITE)
def add_to_buffer(self, data):
'''
Overridden because most of the data coming to this driver
isn't meant for it. I'm only adding to the buffer when
a chunk arrives (see my_add_to_buffer, below), so this
method does nothing.
@param data: bytes to add to the buffer
'''
pass
def _my_add_to_buffer(self, data):
"""
Replaces add_to_buffer. Most data coming to this driver isn't meant
for it. I'm only adding to the buffer when data meant for this
driver arrives. That is accomplished using the chunker mechanism. This
method would normally collet any data fragments that are then search by
the get_response method in the context of a synchronous command sent
from the observatory. However, because so much data arrives here that
is not applicable, the add_to_buffer method has been overridden to do
nothing.
@param data: bytes to add to the buffer
"""
# Update the line and prompt buffers.
self._linebuf += data
self._promptbuf += data
self._last_data_timestamp = time.time()
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Invoke
this driver's _my_add_to_buffer, and then pass it to extract_sample
with the appropriate particle objects and REGEXes. We need to invoke
_my_add_to_buffer, because we've overridden the base class
add_to_buffer that is called from got_data(). The reason is explained
in comments in _my_add_to_buffer.
"""
log.debug("_got_chunk_: %s", chunk)
regex = HEATCommandResponse.regex_compiled()
if regex.match(chunk):
self._my_add_to_buffer(chunk)
else:
if not self._extract_sample(HEATDataParticle,
HEATDataParticle.regex_compiled(),
chunk, timestamp):
raise InstrumentProtocolException("Unhandled chunk")
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
def _build_heat_on_command(self, cmd, *args, **kwargs):
return cmd + str(self._heat_duration) + NEWLINE
def _build_heat_off_command(self, cmd, *args, **kwargs):
return cmd + NEWLINE
def _parse_heat_on_off_resp(self, response, prompt):
log.debug("_parse_heat_on_off_resp: response: %r; prompt: %s", response, prompt)
return response.heat_command_response
def _wakeup(self, timeout, delay=1):
"""
Overriding _wakeup; does not apply to this instrument
"""
pass
def _get_response(self, timeout=10, expected_prompt=None):
"""
@param timeout The timeout in seconds
@param expected_prompt Only consider the specific expected prompt as
presented by this string
@throw InstrumentProtocolExecption on timeout
"""
# Grab time for timeout and wait for response
starttime = time.time()
response = None
regex = HEATCommandResponse.regex_compiled()
"""
Spin around for <timeout> looking for the response to arrive
"""
continuing = True
while continuing:
if regex.match(self._promptbuf):
response = HEATCommandResponse(self._promptbuf)
if response.check_heat_on_off_response(expected_prompt):
continuing = False
else:
self._promptbuf = ''
time.sleep(.1)
if time.time() > starttime + timeout:
raise InstrumentTimeoutException("in BOTPT HEAT driver._get_response()")
return ('HEAT_RESPONSE', response)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
return (ProtocolState.COMMAND, ResourceAgentState.IDLE)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = {}
result[Parameter.HEAT_DURATION] = self._heat_duration
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
params = args[0]
new_heat_duration = params[Parameter.HEAT_DURATION]
if new_heat_duration != self._heat_duration:
log.info("BOTPT HEAT Driver: setting heat duration from %d to %d", self._heat_duration, new_heat_duration)
self._heat_duration = new_heat_duration
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
else:
log.info("BOTPT HEAT Driver: heat duration already %d; not changing.", new_heat_duration)
return (next_state, result)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
def _handler_command_heat_on(self, *args, **kwargs):
"""
Turn the heater on
"""
next_state = None
result = None
"""
call _do_cmd_resp, passing our heat_duration parameter as the expected_prompt
"""
result = self._do_cmd_resp(InstrumentCommand.HEAT_ON, expected_prompt = self._heat_duration)
return (next_state, result)
def _handler_command_heat_off(self, *args, **kwargs):
"""
Turn the heater off
"""
next_state = None
result = None
"""
call _do_cmd_resp, passing our heat_duration parameter as the expected_prompt
"""
result = self._do_cmd_resp(InstrumentCommand.HEAT_OFF, expected_prompt = OFF_HEAT_DURATION)
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
def __init__(self, prompts, newline, driver_event):
"""
"""
self.write_delay = WRITE_DELAY
self._last_data_timestamp = None
self.eoln = INSTRUMENT_NEWLINE
# create short alias for Directions class
Directions = MenuInstrumentProtocol.MenuTree.Directions
# create MenuTree object
menu = MenuInstrumentProtocol.MenuTree({
SubMenues.ROOT : [],
SubMenues.SET_TIME : [Directions(InstrumentCmds.SET_TIME, InstrumentPrompts.SET_TIME)],
SubMenues.DEPLOY : [Directions(InstrumentCmds.DEPLOY_MENU, InstrumentPrompts.SUB_MENU, 20)]
})
MenuInstrumentProtocol.__init__(self, menu, prompts, newline, driver_event)
# these build handlers will be called by the base class during the
# navigate_and_execute sequence.
self._add_build_handler(InstrumentCmds.ENTER_TIME, self._build_time_command)
self._add_build_handler(InstrumentCmds.SET_TIME, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.ANSWER_YES, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.DEPLOY_MENU, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.DEPLOY_GO, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.EXIT_SUB_MENU, self._build_keypress_command)
# Add response handlers for device commands.
self._add_response_handler(InstrumentCmds.SET_TIME, self._parse_time_response)
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.GET, self._handler_get)
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.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)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
# Set state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolStates.UNKNOWN)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.START_AUTOSAMPLE, self._handler_command_start_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.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.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.
#
# JML: Not in OPTAA?
#
#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
#
# JML: Not in OPTAA?
#
#self._sent_cmds = []
#
# JML: Billy sez "no chunker, no sieve"
#
#self._chunker = StringChunker(Protocol.sieve_function)
# JML: What does this do?
self._build_driver_dict()
#
# JML: Billy sez "no chunker, no sieve"
#
# @staticmethod
# def sieve_function(raw_data):
# """
# The method that splits samples
# """
#
# return_list = []
#
# return return_list
def got_raw(self, *args, **kwargs):
pass
def got_data(self, port_agent_packet):
"""
Called by the instrument connection when data is available.
Also add data to the chunker and when received call got_chunk
to publish results.
"""
data_length = port_agent_packet.get_data_length()
data = port_agent_packet.get_data()
timestamp = port_agent_packet.get_timestamp()
log.debug("Got Data: %s" % data)
log.debug("Add Port Agent Timestamp: %s" % timestamp)
unpickler = Unpickler(StringIO(data))
# Disable class unpickling, for security; record should be all
# built-in types. Note this only works with cPickle.
unpickler.find_global = None
# pkt is an antelope.Pkt.Packet object converted to a dict. Refer to
# the documentation for the Antelope Python bindings for compelete
# details.
pkt = unpickler.load()
for particle in self._particle_factory(pkt, timestamp):
self._publish_particle(particle)
def _particle_factory(self, orb_packet, port_timestamp):
"""Generate a sequence of particles from orb_packet
@returns An iterator which yields a new particle object for each sample
for each channel.
"""
# TODO Might want to verify that the channel name matches a pattern,
# e.g. the SEED standard for hydrophones.
for chan in orb_packet['channels']:
for index, sample in enumerate(chan['data']):
# Yield a new particle
# TODO don't hardcode particle class
particle = ORB_SampleDataParticle(
# TODO: Fix this passing raw_data as tuple hack
raw_data = (orb_packet, chan, index, sample),
port_timestamp = port_timestamp,
preferred_timestamp = DataParticleKey.INTERNAL_TIMESTAMP
)
yield particle
def _publish_particle(self, particle):
"""publish parsed particle"""
parsed_sample = particle.generate()
if self._driver_event:
self._driver_event(DriverAsyncEvent.SAMPLE, parsed_sample)
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
pass
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
# JML: Copied from OPTAA; need this?
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
# JML: Copied from OPTAA
# force to auto-sample, this instrument has no command mode
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
return (next_state, result)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
# JML: Copied from OPTAA
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
# JML: Copied wholesale from OPTAA
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
# JML: Not in OPTAA
# self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.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)
# 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)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
return_list = []
return return_list
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
@retval (next_state, result), (ProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING)
"""
# force to auto-sample, this instrument has no command mode
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.AUTOSAMPLE,
ProtocolEvent.DUMP_01,
self._handler_command_autosample_dump01)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE,
ProtocolEvent.DUMP_02,
self._handler_command_autosample_dump02)
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.DUMP_01,
self._handler_command_autosample_dump01)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.DUMP_02,
self._handler_command_autosample_dump02)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.START_AUTOSAMPLE,
self._handler_command_start_autosample)
# 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.DATA_ON, self._build_command)
self._add_build_handler(InstrumentCommand.DATA_OFF,
self._build_command)
self._add_build_handler(InstrumentCommand.DUMP_SETTINGS_01,
self._build_command)
self._add_build_handler(InstrumentCommand.DUMP_SETTINGS_02,
self._build_command)
# Add response handlers for device commands.
self._add_response_handler(InstrumentCommand.DATA_ON,
self._parse_data_on_off_resp)
self._add_response_handler(InstrumentCommand.DATA_OFF,
self._parse_data_on_off_resp)
self._add_response_handler(InstrumentCommand.DUMP_SETTINGS_01,
self._parse_status_01_resp)
self._add_response_handler(InstrumentCommand.DUMP_SETTINGS_02,
self._parse_status_02_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)
# set up the regexes now so we don't have to do it repeatedly
self.data_regex = IRISDataParticle.regex_compiled()
self.cmd_rsp_regex = IRISCommandResponse.regex_compiled()
self.signon_regex = IRISStatusSignOnParticle.regex_compiled()
self.status_01_regex = IRISStatus_01_Particle.regex_compiled()
self.status_02_regex = IRISStatus_02_Particle.regex_compiled()
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = []
return_list = []
"""
would be nice to be able to do this.
matchers.append(self.data_regex)
matchers.append(self.signon_regex)
matchers.append(self.status_01_regex)
matchers.append(self.status_02_regex)
matchers.append(self.cmd_rsp_regex)
"""
"""
Not a good idea to be compiling these for every invocation of this
method; they don't change.
"""
matchers.append(IRISDataParticle.regex_compiled())
#matchers.append(IRISStatusSignOnParticle.regex_compiled())
matchers.append(IRISStatus_01_Particle.regex_compiled())
matchers.append(IRISStatus_02_Particle.regex_compiled())
matchers.append(IRISCommandResponse.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
events_out = [x for x in events if Capability.has(x)]
return events_out
def _build_cmd_dict(self):
"""
Populate the command dictionary with NOAA IRIS Driver metadata information.
Currently IRIS only supports DATA_ON and DATA_OFF.
"""
self._cmd_dict = ProtocolCommandDict()
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
pass
def add_to_buffer(self, data):
'''
Overridden because most of the data coming to this driver
isn't meant for it. I'm only adding to the buffer when
a chunk arrives (see my_add_to_buffer, below), so this
method does nothing.
@param data: bytes to add to the buffer
'''
pass
def _my_add_to_buffer(self, data):
"""
Replaces add_to_buffer. Most data coming to this driver isn't meant
for it. I'm only adding to the buffer when data meant for this
driver arrives. That is accomplished using the chunker mechanism. This
method would normally collet any data fragments that are then search by
the get_response method in the context of a synchronous command sent
from the observatory. However, because so much data arrives here that
is not applicable, the add_to_buffer method has been overridden to do
nothing.
@param data: bytes to add to the buffer
"""
# Update the line and prompt buffers.
self._linebuf += data
self._promptbuf += data
self._last_data_timestamp = time.time()
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Invoke
this driver's _my_add_to_buffer, or pass it to extract_sample
with the appropriate particle objects and REGEXes. We need to invoke
_my_add_to_buffer, because we've overridden the base class
add_to_buffer that is called from got_data(). The reason is explained
in comments in _my_add_to_buffer.
"""
log.debug("_got_chunk_: %s", chunk)
if (self.cmd_rsp_regex.match(chunk) \
#or self.signon_regex.match(chunk) \ # currently not using the signon chunk
or self.status_01_regex.match(chunk) \
or self.status_02_regex.match(chunk)):
self._my_add_to_buffer(chunk)
else:
if not self._extract_sample(IRISDataParticle, self.data_regex,
chunk, timestamp):
raise InstrumentProtocolException("Unhandled chunk")
def _build_command(self, cmd, *args, **kwargs):
command = cmd + NEWLINE
log.debug("_build_command: command is: %s", command)
return command
def _parse_data_on_off_resp(self, response, prompt):
log.debug("_parse_data_on_off_resp: response: %r; prompt: %s",
response, prompt)
return response.iris_command_response
def _parse_status_01_resp(self, response, prompt):
log.debug("_parse_status_01_resp: response: %r; prompt: %s", response,
prompt)
return response.iris_status_response
def _parse_status_02_resp(self, response, prompt):
log.debug("_parse_status_02_resp: response: %r; prompt: %s", response,
prompt)
return response.iris_status_response
def _wakeup(self, timeout, delay=1):
"""
Overriding _wakeup; does not apply to this instrument
"""
pass
def _get_response(self, timeout=10, expected_prompt=None):
"""
Overriding _get_response: this one uses regex on chunks
that have already been filtered by the chunker. An improvement
to the chunker could be metadata labeling the chunk so that we
don't have to do another match, although I don't think it is that
expensive once the chunk has been pulled out to match again
@param timeout The timeout in seconds
@param expected_prompt Only consider the specific expected prompt as
presented by this string
@throw InstrumentProtocolExecption on timeout
"""
# Grab time for timeout and wait for response
starttime = time.time()
response = None
"""
Spin around for <timeout> looking for the response to arrive
"""
continuing = True
response = "no response"
while continuing:
if self.cmd_rsp_regex.match(self._promptbuf):
response = IRISCommandResponse(self._promptbuf)
log.debug("_get_response() matched CommandResponse")
response.check_command_response(expected_prompt)
continuing = False
#elif self.signon_regex.match(self._promptbuf):
#response = IRISStatusSignOnParticle(self._promptbuf)
#log.debug("~~~~~~~~~ SignonResponse")
"""
Currently not using the signon particle.
"""
elif self.status_01_regex.match(self._promptbuf):
response = IRISStatus_01_Particle(self._promptbuf)
log.debug("_get_response() matched Status_01_Response")
response.build_response()
continuing = False
elif self.status_02_regex.match(self._promptbuf):
response = IRISStatus_02_Particle(self._promptbuf)
log.debug("_get_response() matched Status_02_Response")
response.build_response()
continuing = False
else:
self._promptbuf = ''
time.sleep(.1)
if timeout and time.time() > starttime + timeout:
raise InstrumentTimeoutException(
"in BOTPT IRIS driver._get_response()")
return ('IRIS_RESPONSE', response)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
result = self._do_cmd_resp(InstrumentCommand.DATA_OFF,
expected_prompt=IRIS_DATA_OFF)
return (ProtocolState.COMMAND, ResourceAgentState.IDLE)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
Turn the iris data off
"""
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
result = self._do_cmd_resp(InstrumentCommand.DATA_OFF,
expected_prompt=IRIS_DATA_OFF)
return (next_state, (next_agent_state, result))
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = {}
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
params = args[0]
return (next_state, result)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Turn the iris data on
"""
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
"""
call _do_cmd_resp, passing our IRIS_DATA_ON as the expected_prompt
"""
result = self._do_cmd_resp(InstrumentCommand.DATA_ON,
expected_prompt=IRIS_DATA_ON)
return (next_state, (next_agent_state, result))
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
########################################################################
# Handlers common to Command and Autosample States.
########################################################################
def _handler_command_autosample_acquire_status(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = None
log.debug("_handler_command_autosample_acquire_status")
result = self._do_cmd_resp(InstrumentCommand.DUMP_SETTINGS_01)
log.debug("DUMP_SETTINGS_01 response: %s", result)
result = self._do_cmd_resp(InstrumentCommand.DUMP_SETTINGS_02)
log.debug("DUMP_SETTINGS_02 response: %s", result)
return (next_state, (next_agent_state, result))
def _handler_command_autosample_dump01(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = None
log.debug("_handler_command_autosample_dump01")
timeout = kwargs.get('timeout')
if timeout is not None:
result = self._do_cmd_resp(InstrumentCommand.DUMP_SETTINGS_01,
timeout=timeout)
else:
result = self._do_cmd_resp(InstrumentCommand.DUMP_SETTINGS_01)
log.debug("DUMP_SETTINGS_01 response: %s", result)
return (next_state, (next_agent_state, result))
def _handler_command_autosample_dump02(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = None
log.debug("_handler_command_autosample_dump02")
result = self._do_cmd_resp(InstrumentCommand.DUMP_SETTINGS_02)
log.debug("DUMP_SETTINGS_02 response: %s", result)
return (next_state, (next_agent_state, result))
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.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)
# 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)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
return_list = []
return return_list
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
@retval (next_state, result), (ProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING)
"""
# force to auto-sample, this instrument has no command mode
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
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.AUTOSAMPLE,
ProtocolEvent.DUMP_01,
self._handler_command_autosample_dump01)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE,
ProtocolEvent.DUMP_02,
self._handler_command_autosample_dump02)
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.DUMP_01,
self._handler_command_autosample_dump01)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.DUMP_02,
self._handler_command_autosample_dump02)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.START_AUTOSAMPLE,
self._handler_command_start_autosample)
# 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.DATA_ON, self._build_command)
self._add_build_handler(InstrumentCommand.DATA_OFF,
self._build_command)
self._add_build_handler(InstrumentCommand.DUMP_SETTINGS_01,
self._build_command)
self._add_build_handler(InstrumentCommand.DUMP_SETTINGS_02,
self._build_command)
# Add response handlers for device commands.
self._add_response_handler(InstrumentCommand.DATA_ON,
self._parse_data_on_off_resp)
self._add_response_handler(InstrumentCommand.DATA_OFF,
self._parse_data_on_off_resp)
self._add_response_handler(InstrumentCommand.DUMP_SETTINGS_01,
self._parse_status_01_resp)
self._add_response_handler(InstrumentCommand.DUMP_SETTINGS_02,
self._parse_status_02_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)
# set up the regexes now so we don't have to do it repeatedly
self.data_regex = IRISDataParticle.regex_compiled()
self.cmd_rsp_regex = IRISCommandResponse.regex_compiled()
self.signon_regex = IRISStatusSignOnParticle.regex_compiled()
self.status_01_regex = IRISStatus_01_Particle.regex_compiled()
self.status_02_regex = IRISStatus_02_Particle.regex_compiled()
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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 = {}
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
return_list = []
return return_list
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add_parameter(
Parameter(ParameterName.PAYLOAD_SIZE,
int,
type=ParameterDictType.INT,
display_name="Payload Size",
startup_param = True,
direct_access = True,
default_value = 1024)
)
self._param_dict.add_parameter(
Parameter(ParameterName.SAMPLE_INTERVAL,
int,
type=ParameterDictType.INT,
display_name="Sample Interval (sec)",
startup_param = True,
direct_access = True,
default_value = 1)
)
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
return (ProtocolState.COMMAND, ResourceAgentState.IDLE)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
self._protocol_fsm.on_event(DriverEvent.INIT_PARAMS)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
self._set_params(*args, **kwargs)
log.debug("_handler_command_set: result: %s", result)
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
def _handler_command_autosample_start(self, *args, **kwargs):
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
result = None
return (next_state, (next_agent_state, result))
def _handler_command_init_params(self, *args, **kwargs):
"""
initialize parameters
"""
next_state = None
result = None
self._init_params()
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._start_packet_generator()
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit autosample state.
"""
self._stop_packet_generator()
def _handler_autosample_stop(self, *args, **kwargs):
"""
Stop autosample and switch back to command mode.
@retval (next_state, result) tuple, (ProtocolState.COMMAND,
(next_agent_state, None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command misunderstood or
incorrect prompt received.
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Helpers
########################################################################
def _start_packet_generator(self):
packet_size = self._param_dict.get(ParameterName.PAYLOAD_SIZE)
sample_interval = self._param_dict.get(ParameterName.SAMPLE_INTERVAL)
self._generate_payload_value(packet_size)
self._stop_generator_thread = False
self._generator_thread = Thread(
target=self._generate_packets,
args=(packet_size, sample_interval, self._publish_packet ))
self._generator_thread.start()
def _generate_packets(self, *args, **kwargs):
packet_size = args[0]
sample_interval = args[1]
publish_callback = args[2]
log.debug("_generate_packets, starting packet generator. packet_size: %s, sample_interval: %s", packet_size, sample_interval)
while(self._stop_generator_thread != True):
publish_callback(packet_size)
time.sleep(sample_interval)
log.debug("_generate_packets, stopping packet generator")
def _publish_packet(self, packet_size):
buf = self._get_payload_value(packet_size)
particle = TestDataParticle(buf, port_timestamp=time_to_ntp_date_time())
log.debug("_publish_packet, packet size: %d", len(buf))
self._driver_event(DriverAsyncEvent.SAMPLE, particle.generate())
def _get_payload_value(self, packet_size):
if self._payload_cache.get(packet_size):
return self._payload_cache[packet_size]
return self._generate_payload_value(packet_size)
def _generate_payload_value(self, packet_size):
log.debug("generating new value, packet size: %s", packet_size)
charlist = [random.choice(string.letters) for _ in range(packet_size)]
buf = struct.pack('%sc' % len(charlist), *charlist)
self._payload_cache[packet_size] = buf
return buf
def _stop_packet_generator(self):
log.debug("_stop_packet_generator: Signal the packet generator to stop")
self._stop_generator_thread = True
self._generator_thread.join(60)
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
startup = False
config_change = False
result = {}
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
try:
startup = args[1]
except IndexError:
pass
for (key, val) in params.iteritems():
log.debug("KEY = " + str(key) + " VALUE = " + str(val))
if self._param_dict.get(key) != val:
config_change = True
self._param_dict.set_value(key, val)
result[key] = val
if config_change:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
return result
def __init__(self, menu, 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.
MenuInstrumentProtocol.__init__(self, menu, 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.DISCOVER, self._handler_discover)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.DISCOVER, self._handler_discover)
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_autosample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.DISCOVER, self._handler_discover)
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.
self._add_build_handler(Command.BACK_MENU, self._build_menu_command)
self._add_build_handler(Command.BLANK, self._build_solo_command)
self._add_build_handler(Command.START_AUTOSAMPLE, self._build_menu_command)
self._add_build_handler(Command.CHANGE_PARAM, self._build_menu_command)
self._add_build_handler(Command.SHOW_PARAM, self._build_menu_command)
self._add_build_handler(Command.SENSOR_POWER, self._build_menu_command)
self._add_build_handler(Command.DIRECT_SET, self._build_direct_command)
self._add_build_handler(Command.CHANGE_CYCLE_TIME, self._build_menu_command)
self._add_build_handler(Command.CHANGE_VERBOSE, self._build_menu_command)
self._add_build_handler(Command.CHANGE_METADATA_RESTART, self._build_menu_command)
self._add_build_handler(Command.CHANGE_METADATA_POWERUP, self._build_menu_command)
self._add_build_handler(Command.CHANGE_RES_SENSOR_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_INST_AMP_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_EH_ISOLATION_AMP_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_HYDROGEN_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_REFERENCE_TEMP_POWER, self._build_menu_command)
# Add response handlers for device commands.
#self._add_response_handler(Command.GET, self._parse_get_response)
#self._add_response_handler(Command.SET, self._parse_get_response)
self._add_response_handler(Command.BACK_MENU, self._parse_menu_change_response)
self._add_response_handler(Command.BLANK, self._parse_menu_change_response)
self._add_response_handler(Command.SHOW_PARAM, self._parse_show_param_response)
self._add_response_handler(Command.CHANGE_CYCLE_TIME, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_VERBOSE, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_METADATA_RESTART, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_METADATA_POWERUP, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_RES_SENSOR_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_INST_AMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_EH_ISOLATION_AMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_HYDROGEN_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_REFERENCE_TEMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.DIRECT_SET, self._parse_menu_change_response)
# 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)
class Protocol(MenuInstrumentProtocol):
"""
Instrument protocol class
Subclasses MenuInstrumentProtocol
"""
def __init__(self, menu, 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.
MenuInstrumentProtocol.__init__(self, menu, 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.DISCOVER, self._handler_discover)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.DISCOVER, self._handler_discover)
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_autosample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.DISCOVER, self._handler_discover)
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.
self._add_build_handler(Command.BACK_MENU, self._build_menu_command)
self._add_build_handler(Command.BLANK, self._build_solo_command)
self._add_build_handler(Command.START_AUTOSAMPLE, self._build_menu_command)
self._add_build_handler(Command.CHANGE_PARAM, self._build_menu_command)
self._add_build_handler(Command.SHOW_PARAM, self._build_menu_command)
self._add_build_handler(Command.SENSOR_POWER, self._build_menu_command)
self._add_build_handler(Command.DIRECT_SET, self._build_direct_command)
self._add_build_handler(Command.CHANGE_CYCLE_TIME, self._build_menu_command)
self._add_build_handler(Command.CHANGE_VERBOSE, self._build_menu_command)
self._add_build_handler(Command.CHANGE_METADATA_RESTART, self._build_menu_command)
self._add_build_handler(Command.CHANGE_METADATA_POWERUP, self._build_menu_command)
self._add_build_handler(Command.CHANGE_RES_SENSOR_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_INST_AMP_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_EH_ISOLATION_AMP_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_HYDROGEN_POWER, self._build_menu_command)
self._add_build_handler(Command.CHANGE_REFERENCE_TEMP_POWER, self._build_menu_command)
# Add response handlers for device commands.
#self._add_response_handler(Command.GET, self._parse_get_response)
#self._add_response_handler(Command.SET, self._parse_get_response)
self._add_response_handler(Command.BACK_MENU, self._parse_menu_change_response)
self._add_response_handler(Command.BLANK, self._parse_menu_change_response)
self._add_response_handler(Command.SHOW_PARAM, self._parse_show_param_response)
self._add_response_handler(Command.CHANGE_CYCLE_TIME, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_VERBOSE, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_METADATA_RESTART, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_METADATA_POWERUP, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_RES_SENSOR_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_INST_AMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_EH_ISOLATION_AMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_HYDROGEN_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.CHANGE_REFERENCE_TEMP_POWER, self._parse_menu_change_response)
self._add_response_handler(Command.DIRECT_SET, self._parse_menu_change_response)
# 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)
@staticmethod
def sieve_function(raw_data):
""" The method that splits samples
"""
return_list = []
for match in SAMPLE_REGEX.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _go_to_root_menu(self):
""" Get back to the root menu, assuming we are in COMMAND mode.
Getting to command mode should be done before this method is called.
A discover will get there.
"""
log.debug("Returning to root menu...")
# Issue an enter or two off the bat to get out of any display screens
# and confirm command mode
try:
response = self._do_cmd_resp(Command.BLANK, expected_prompt=Prompt.CMD_PROMPT)
while not str(response).lstrip().endswith(Prompt.CMD_PROMPT):
response = self._do_cmd_resp(Command.BLANK,
expected_prompt=Prompt.CMD_PROMPT)
time.sleep(1)
except InstrumentTimeoutException:
raise InstrumentProtocolException("Not able to get valid command prompt. Is instrument in command mode?")
# When you get a --> prompt, do 9's until you get back to the root
response = self._do_cmd_resp(Command.BACK_MENU,
expected_prompt=MENU_PROMPTS)
while not str(response).lstrip().endswith(Prompt.MAIN_MENU):
response = self._do_cmd_resp(Command.BACK_MENU,
expected_prompt=MENU_PROMPTS)
def _filter_capabilities(self, events):
""" Define a small filter of the capabilities
@param A list of events to consider as capabilities
@retval A list of events that are actually capabilities
"""
events_out = [x for x in events if Capability.has(x)]
return events_out
def get_resource_capabilities(self, current_state=True):
"""
"""
res_cmds = self._protocol_fsm.get_events(current_state)
res_cmds = self._filter_capabilities(res_cmds)
res_params = VisibleParameters.list()
return [res_cmds, res_params]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_discover(self, *args, **kwargs):
"""
Discover current state by going to the root menu
@retval (next_state, result)
"""
next_state = None
next_agent_state = None
# Try to break in case we are in auto sample
self._send_break()
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.IDLE
self._go_to_root_menu()
return (next_state, next_agent_state)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throw InstrumentTimeoutException if the device cannot be woken.
@throw InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, params=None, *args, **kwargs):
"""
Get parameters while in the command state.
@param params List of the parameters to pass to the state
@retval returns (next_state, result) where result is a dict {}. No
agent state changes happening with Get, so no next_agent_state
@throw InstrumentParameterException for invalid parameter
"""
next_state = None
result = None
result_vals = {}
if (params == None):
raise InstrumentParameterException("GET parameter list empty!")
if (params == Parameter.ALL):
params = [Parameter.CYCLE_TIME, Parameter.EH_ISOLATION_AMP_POWER,
Parameter.HYDROGEN_POWER, Parameter.INST_AMP_POWER,
Parameter.METADATA_POWERUP, Parameter.METADATA_RESTART,
Parameter.REFERENCE_TEMP_POWER, Parameter.RES_SENSOR_POWER,
Parameter.VERBOSE]
if not isinstance(params, list):
raise InstrumentParameterException("GET parameter list not a list!")
# Do a bulk update from the instrument since they are all on one page
self._update_params()
# fill the return values from the update
for param in params:
if not Parameter.has(param):
raise InstrumentParameterException("Invalid parameter!")
result_vals[param] = self._param_dict.get(param)
result = result_vals
log.debug("Get finished, next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_command_set(self, params, *args, **kwargs):
"""Handle setting data from command mode
@param params Dict of the parameters and values to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
result_vals = {}
if ((params == None) or (not isinstance(params, dict))):
raise InstrumentParameterException()
name_values = params
for key in name_values.keys():
if not Parameter.has(key):
raise InstrumentParameterException()
# restrict operations to just the read/write parameters
if (key == Parameter.CYCLE_TIME):
self._navigate(SubMenu.CYCLE_TIME)
(unit, value) = self._from_seconds(name_values[key])
try:
self._do_cmd_resp(Command.DIRECT_SET, unit,
expected_prompt=[Prompt.CYCLE_TIME_SEC_VALUE_PROMPT,
Prompt.CYCLE_TIME_MIN_VALUE_PROMPT])
self._do_cmd_resp(Command.DIRECT_SET, value,
expected_prompt=Prompt.CHANGE_PARAM_MENU)
except InstrumentProtocolException:
self._go_to_root_menu()
raise InstrumentProtocolException("Could not set cycle time")
# Populate with actual value set
result_vals[key] = name_values[key]
# re-sync with param dict?
self._go_to_root_menu()
self._update_params()
result = result_vals
log.debug("next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_command_autosample(self, *args, **kwargs):
""" Start autosample mode """
next_state = None
next_agent_state = None
result = None
self._navigate(SubMenu.MAIN)
self._do_cmd_no_resp(Command.START_AUTOSAMPLE)
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
def _handler_command_start_direct(self):
"""
"""
next_state = None
next_agent_state = None
result = None
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
next_agent_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Autosample handlers
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample mode
"""
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_stop(self):
"""
Stop autosample mode
"""
next_state = None
next_agent_state = None
result = None
if (self._send_break()):
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Command builders
########################################################################
def _build_solo_command(self, cmd):
""" Issue a simple command that does NOT require a newline at the end to
execute. Likly used for control characters or special characters """
return COMMAND_CHAR[cmd]
def _build_menu_command(self, cmd):
""" Pick the right character and add a newline """
if COMMAND_CHAR[cmd]:
return COMMAND_CHAR[cmd]+self._newline
else:
raise InstrumentProtocolException("Unknown command character for %s" % cmd)
def _build_direct_command(self, cmd, arg):
""" Build a command where we just send the argument to the instrument.
Ignore the command part, we dont need it here as we are already in
a submenu.
"""
return "%s%s" % (arg, self._newline)
########################################################################
# Command parsers
########################################################################
def _parse_menu_change_response(self, response, prompt):
""" Parse a response to a menu change
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval The prompt that was encountered after the change
"""
log.trace("Parsing menu change response with prompt: %s", prompt)
return prompt
def _parse_show_param_response(self, response, prompt):
""" Parse the show parameter response screen """
log.trace("Parsing show parameter screen")
self._param_dict.update_many(response)
########################################################################
# Utilities
########################################################################
def _wakeup(self, timeout):
# Always awake for this instrument!
pass
def _got_chunk(self, chunk):
'''
extract samples from a chunk of data
@param chunk: bytes to parse into a sample.
'''
self._extract_sample(BarsDataParticle, SAMPLE_REGEX, chunk)
def _update_params(self):
"""Fetch the parameters from the device, and update the param dict.
@param args Unused
@param kwargs Takes timeout value
@throw InstrumentProtocolException
@throw InstrumentTimeoutException
"""
log.debug("Updating parameter dict")
old_config = self._param_dict.get_config()
self._get_config()
new_config = self._param_dict.get_config()
if (new_config != old_config):
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def _get_config(self, *args, **kwargs):
""" Get the entire configuration for the instrument
@param params The parameters and values to set
Should be a dict of parameters and values
@throw InstrumentProtocolException On a deeper issue
"""
# Just need to show the parameter screen...the parser for the command
# does the update_many()
self._go_to_root_menu()
self._navigate(SubMenu.SHOW_PARAM)
self._go_to_root_menu()
def _send_break(self, timeout=4):
"""
Execute an attempts to break out of auto sample (a few if things get garbled).
For this instrument, it is done with a ^S, a wait for a \r\n, then
another ^S within 1/2 a second
@param timeout
@retval True if 2 ^S chars were sent with a prompt in the middle, False
if not.
"""
log.debug("Sending break sequence to instrument...")
# Timing is an issue, so keep it simple, work directly with the
# couple chars instead of command/respose. Could be done that way
# though. Just more steps, logic, and delay for such a simple
# exchange
for count in range(0, 3):
self._promptbuf = ""
try:
self._connection.send("%c" % COMMAND_CHAR[Command.BREAK])
(prompt, result) = self._get_raw_response(timeout, expected_prompt=[Prompt.BREAK_ACK,
Prompt.CMD_PROMPT])
if (prompt == Prompt.BREAK_ACK):
self._connection.send("%c" % COMMAND_CHAR[Command.BREAK])
(prompt, result) = self._get_response(timeout, expected_prompt=Prompt.CMD_PROMPT)
return True
elif(prompt == Prompt.CMD_PROMPT):
return True
except InstrumentTimeoutException:
continue
log.trace("_send_break failing after several attempts")
return False
def set_readonly_values(self, *args, **kwargs):
"""Set read-only values to the instrument. This is usually (only?)
done at initialization.
@throw InstrumentProtocolException When in the wrong state or something
really bad prevents the setting of all values.
"""
# Let's give it a try in unknown state
if (self.get_current_state() != ProtocolState.COMMAND):
raise InstrumentProtocolException("Not in command state. Unable to set read-only params")
self._go_to_root_menu()
self._update_params()
for param in self._param_dict.get_visibility_list(ParameterDictVisibility.READ_ONLY):
if not Parameter.has(param):
raise InstrumentParameterException()
self._go_to_root_menu()
# Only try to change them if they arent set right as it is
log.trace("Setting read-only parameter: %s, current paramdict value: %s, init val: %s",
param, self._param_dict.get(param),
self._param_dict.get_init_value(param))
if (self._param_dict.get(param) != self._param_dict.get_init_value(param)):
if (param == Parameter.METADATA_POWERUP):
self._navigate(SubMenu.METADATA_POWERUP)
result = self._do_cmd_resp(Command.DIRECT_SET, (1+ int(self._param_dict.get_init_value(param))),
expected_prompt=Prompt.CHANGE_PARAM_MENU)
if not result:
raise InstrumentParameterException("Could not set param %s" % param)
self._go_to_root_menu()
elif (param == Parameter.METADATA_RESTART):
self._navigate(SubMenu.METADATA_RESTART)
result = self._do_cmd_resp(Command.DIRECT_SET, (1 + int(self._param_dict.get_init_value(param))),
expected_prompt=Prompt.CHANGE_PARAM_MENU)
if not result:
raise InstrumentParameterException("Could not set param %s" % param)
self._go_to_root_menu()
elif (param == Parameter.VERBOSE):
self._navigate(SubMenu.VERBOSE)
result = self._do_cmd_resp(Command.DIRECT_SET, self._param_dict.get_init_value(param),
expected_prompt=Prompt.CHANGE_PARAM_MENU)
if not result:
raise InstrumentParameterException("Could not set param %s" % param)
self._go_to_root_menu()
elif (param == Parameter.EH_ISOLATION_AMP_POWER):
result = self._navigate(SubMenu.EH_ISOLATION_AMP_POWER)
while not result:
result = self._navigate(SubMenu.EH_ISOLATION_AMP_POWER)
elif (param == Parameter.HYDROGEN_POWER):
result = self._navigate(SubMenu.HYDROGEN_POWER)
while not result:
result = self._navigate(SubMenu.HYDROGEN_POWER)
elif (param == Parameter.INST_AMP_POWER):
result = self._navigate(SubMenu.INST_AMP_POWER)
while not result:
result = self._navigate(SubMenu.INST_AMP_POWER)
elif (param == Parameter.REFERENCE_TEMP_POWER):
result = self._navigate(SubMenu.REFERENCE_TEMP_POWER)
while not result:
result = self._navigate(SubMenu.REFERENCE_TEMP_POWER)
elif (param == Parameter.RES_SENSOR_POWER):
result = self._navigate(SubMenu.RES_SENSOR_POWER)
while not result:
result = self._navigate(SubMenu.RES_SENSOR_POWER)
# re-sync with param dict?
self._go_to_root_menu()
self._update_params()
# Should be good by now, but let's double check just to be safe
for param in self._param_dict.get_visibility_list(ParameterDictVisibility.READ_ONLY):
if (param == Parameter.VERBOSE):
continue
if (self._param_dict.get(param) != self._param_dict.get_init_value(param)):
raise InstrumentProtocolException("Could not set default values!")
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict = ProtocolParameterDict()
self._param_dict.add(Parameter.CYCLE_TIME,
r'(\d+)\s+= Cycle Time \(.*\)\r\n(0|1)\s+= Minutes or Seconds Cycle Time',
lambda match : self._to_seconds(int(match.group(1)),
int(match.group(2))),
self._int_to_string,
visibility=ParameterDictVisibility.READ_WRITE,
startup_param=True,
direct_access=False,
default_value=20,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["1", Prompt.CYCLE_TIME_PROMPT]])
self._param_dict.add(Parameter.VERBOSE,
r'', # Write-only, so does it really matter?
lambda match : None,
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=1,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["2", Prompt.VERBOSE_PROMPT]])
self._param_dict.add(Parameter.METADATA_POWERUP,
r'(0|1)\s+= Metadata Print Status on Power up',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=0,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["3", Prompt.METADATA_PROMPT]])
self._param_dict.add(Parameter.METADATA_RESTART,
r'(0|1)\s+= Metadata Print Status on Restart Data Collection',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=0,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["4", Prompt.METADATA_PROMPT]])
self._param_dict.add(Parameter.RES_SENSOR_POWER,
r'(0|1)\s+= Res Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["1"]])
self._param_dict.add(Parameter.INST_AMP_POWER,
r'(0|1)\s+= Thermocouple & Hydrogen Amp Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["2"]])
self._param_dict.add(Parameter.EH_ISOLATION_AMP_POWER,
r'(0|1)\s+= eh Amp Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["3"]])
self._param_dict.add(Parameter.HYDROGEN_POWER,
r'(0|1)\s+= Hydrogen Sensor Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["4"]])
self._param_dict.add(Parameter.REFERENCE_TEMP_POWER,
r'(0|1)\s+= Reference Temperature Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["5"]])
@staticmethod
def _to_seconds(value, unit):
"""
Converts a number and a unit into seconds. Ie if "4" and "1"
comes in, it spits out 240
@param value The int value for some number of minutes or seconds
@param unit int of 0 or 1 where 0 is seconds, 1 is minutes
@return Number of seconds.
"""
if (not isinstance(value, int)) or (not isinstance(unit, int)):
raise InstrumentProtocolException("Invalid second arguments!")
if unit == 1:
return value * 60
elif unit == 0:
return value
else:
raise InstrumentProtocolException("Invalid Units!")
@staticmethod
def _from_seconds(value):
"""
Converts a number of seconds into a (unit, value) tuple.
@param value The number of seconds to convert
@retval A tuple of unit and value where the unit is 1 for seconds and 2
for minutes. If the value is 15-59, units should be returned in
seconds. If the value is over 59, the units will be returned in
a number of minutes where the seconds are rounded down to the
nearest minute.
"""
if (value < 15) or (value > 3600):
raise InstrumentParameterException("Invalid seconds value: %s" % value)
if (value < 60):
return (1, value)
else:
return (2, value // 60)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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 = {}
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
return_list = []
return return_list
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add_parameter(
Parameter(ParameterName.PAYLOAD_SIZE,
int,
type=ParameterDictType.INT,
display_name="Payload Size",
startup_param=True,
direct_access=True,
default_value=1024))
self._param_dict.add_parameter(
Parameter(ParameterName.SAMPLE_INTERVAL,
int,
type=ParameterDictType.INT,
display_name="Sample Interval (sec)",
startup_param=True,
direct_access=True,
default_value=1))
def _got_chunk(self, chunk):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
return (ProtocolState.COMMAND, ResourceAgentState.IDLE)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
self._protocol_fsm.on_event(DriverEvent.INIT_PARAMS)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
self._set_params(*args, **kwargs)
log.debug("_handler_command_set: result: %s", result)
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
def _handler_command_autosample_start(self, *args, **kwargs):
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
result = None
return (next_state, (next_agent_state, result))
def _handler_command_init_params(self, *args, **kwargs):
"""
initialize parameters
"""
next_state = None
result = None
self._init_params()
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._start_packet_generator()
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit autosample state.
"""
self._stop_packet_generator()
def _handler_autosample_stop(self, *args, **kwargs):
"""
Stop autosample and switch back to command mode.
@retval (next_state, result) tuple, (ProtocolState.COMMAND,
(next_agent_state, None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command misunderstood or
incorrect prompt received.
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Helpers
########################################################################
def _start_packet_generator(self):
packet_size = self._param_dict.get(ParameterName.PAYLOAD_SIZE)
sample_interval = self._param_dict.get(ParameterName.SAMPLE_INTERVAL)
self._generate_payload_value(packet_size)
self._stop_generator_thread = False
self._generator_thread = Thread(target=self._generate_packets,
args=(packet_size, sample_interval,
self._publish_packet))
self._generator_thread.start()
def _generate_packets(self, *args, **kwargs):
packet_size = args[0]
sample_interval = args[1]
publish_callback = args[2]
log.debug(
"_generate_packets, starting packet generator. packet_size: %s, sample_interval: %s",
packet_size, sample_interval)
while (self._stop_generator_thread != True):
publish_callback(packet_size)
time.sleep(sample_interval)
log.debug("_generate_packets, stopping packet generator")
def _publish_packet(self, packet_size):
buf = self._get_payload_value(packet_size)
particle = TestDataParticle(
buf, port_timestamp=mi.core.time.time_to_ntp_date_time())
log.debug("_publish_packet, packet size: %d", len(buf))
self._driver_event(DriverAsyncEvent.SAMPLE, particle.generate())
def _get_payload_value(self, packet_size):
if self._payload_cache.get(packet_size):
return self._payload_cache[packet_size]
return self._generate_payload_value(packet_size)
def _generate_payload_value(self, packet_size):
log.debug("generating new value, packet size: %s", packet_size)
charlist = [random.choice(string.letters) for _ in range(packet_size)]
buf = struct.pack('%sc' % len(charlist), *charlist)
self._payload_cache[packet_size] = buf
return buf
def _stop_packet_generator(self):
log.debug(
"_stop_packet_generator: Signal the packet generator to stop")
self._stop_generator_thread = True
self._generator_thread.join(60)
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
startup = False
config_change = False
result = {}
try:
params = args[0]
except IndexError:
raise InstrumentParameterException(
'Set command requires a parameter dict.')
try:
startup = args[1]
except IndexError:
pass
for (key, val) in params.iteritems():
log.debug("KEY = " + str(key) + " VALUE = " + str(val))
if self._param_dict.get(key) != val:
config_change = True
self._param_dict.set_value(key, val)
result[key] = val
if config_change:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
return result
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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()
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
raw_data_len = len(raw_data)
#log.debug("sieve_function: raw_data=<%s>, len=%d" %(raw_data.encode('hex'), raw_data_len))
return_list = []
# look for samples
for match in PACKET_REGISTRATION_REGEX.finditer(raw_data):
if match.start() + INDEX_OF_PACKET_RECORD_LENGTH + SIZEOF_PACKET_RECORD_LENGTH < raw_data_len:
packet_length = get_two_byte_value(raw_data, match.start() + INDEX_OF_PACKET_RECORD_LENGTH) + SIZEOF_CHECKSUM_PLUS_PAD
if match.start() + packet_length <= raw_data_len:
return_list.append((match.start(), match.start() + packet_length))
# look for status
for match in STATUS_REGEX.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
self._extract_sample(OPTAA_StatusDataParticle, STATUS_REGEX, chunk, timestamp)
self._extract_sample(OPTAA_SampleDataParticle, PACKET_REGISTRATION_REGEX, chunk, timestamp)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
@retval (next_state, result), (ProtocolState.COMMAND or
State.AUTOSAMPLE, None) if successful.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentStateException if the device response does not correspond to
an expected state.
"""
# force to auto-sample, this instrument has no command mode
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
return (next_state, result)
########################################################################
# Command handlers.
# just implemented to make DA possible, instrument has no actual command mode
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_get(self, *args, **kwargs):
"""
does nothing, just implemented to make framework happy
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
does nothing, just implemented to make framework happy
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_start_direct(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
return (next_state, (next_agent_state, result))
def _handler_command_start_autosample(self, *args, **kwargs):
"""
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return (next_state, (next_agent_state, result))
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_autosample_stop_autosample(self):
"""
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
next_state = None
result = None
self._do_cmd_direct(data)
return (next_state, result)
def _handler_direct_access_stop_direct(self):
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = get_logging_metaclass(log_level='debug')
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')
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
raw_data_len = len(raw_data)
return_list = []
# look for samples
for match in PACKET_REGISTRATION_REGEX.finditer(raw_data):
if match.start(
) + INDEX_OF_PACKET_RECORD_LENGTH + SIZE_OF_PACKET_RECORD_LENGTH < raw_data_len:
packet_length = get_two_byte_value(
raw_data,
match.start() +
INDEX_OF_PACKET_RECORD_LENGTH) + SIZE_OF_CHECKSUM_PLUS_PAD
if match.start() + packet_length <= raw_data_len:
return_list.append(
(match.start(), match.start() + packet_length))
# look for status
for match in STATUS_REGEX.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
# On a rare occurrence the particle sample coming in will be missing a byte
# trap the exception thrown and log an error
try:
self._extract_sample(OptaaSampleDataParticle,
PACKET_REGISTRATION_REGEX, chunk, timestamp)
self._extract_sample(OptaaStatusDataParticle, STATUS_REGEX, chunk,
timestamp)
except SampleException:
log.error("Unable to process sample (%r)", SampleException.message)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
"""
return ProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING
########################################################################
# Command handlers.
# Implemented to make DA possible, instrument has no actual command mode
########################################################################
def _handler_command_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
pass
def _handler_command_get(self, *args, **kwargs):
"""
Does nothing, implemented to make framework happy
"""
return None, None
def _handler_command_set(self, *args, **kwargs):
"""
Does nothing, implemented to make framework happy
"""
return None, None
def _handler_command_start_direct(self, *args, **kwargs):
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS,
None)
def _handler_command_start_autosample(self, *args, **kwargs):
return ProtocolState.AUTOSAMPLE, (ResourceAgentState.STREAMING, None)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
pass
def _handler_autosample_stop_autosample(self):
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
pass
def _handler_direct_access_execute_direct(self, data):
self._do_cmd_direct(data)
return None, None
def _handler_direct_access_stop_direct(self):
"""
Instead of using discover(), as is the norm, put instrument into
Command state. Instrument can only sample, even when in a command state.
"""
return DriverProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
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.WAITING,
ProtocolEvent.ENTER,
self._handler_waiting_enter)
self._protocol_fsm.add_handler(ProtocolState.WAITING,
ProtocolEvent.EXIT,
self._handler_waiting_exit)
self._protocol_fsm.add_handler(ProtocolState.WAITING,
ProtocolEvent.DISCOVER,
self._handler_waiting_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.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.ACQUIRE_STATUS,
self._handler_command_acquire_status)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_command_acquire_sample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.START_AUTOSAMPLE,
self._handler_command_start_autosample)
# the ACQUIRE_CONFIGURATION event may not be necessary
#self._protocol_fsm.add_handler(
# ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_CONFIGURATION,
# self._handler_command_acquire_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.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)
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.AUTOSAMPLE,
ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_autosample_acquire_sample)
# this state would be entered whenever an ACQUIRE_SAMPLE event
# occurred while in the AUTOSAMPLE state and will last anywhere
# from 10 seconds to 3 minutes depending on instrument and the
# type of sampling.
self._protocol_fsm.add_handler(ProtocolState.SCHEDULED_SAMPLE,
ProtocolEvent.ENTER,
self._handler_scheduled_sample_enter)
self._protocol_fsm.add_handler(ProtocolState.SCHEDULED_SAMPLE,
ProtocolEvent.EXIT,
self._handler_scheduled_sample_exit)
# this state would be entered whenever an ACQUIRE_SAMPLE event
# occurred while in either the COMMAND state (or via the
# discover transition from the UNKNOWN state with the instrument
# unresponsive) and will last anywhere from a few seconds to 3
# minutes depending on instrument and sample type.
self._protocol_fsm.add_handler(ProtocolState.POLLED_SAMPLE,
ProtocolEvent.ENTER,
self._handler_polled_sample_enter)
self._protocol_fsm.add_handler(ProtocolState.POLLED_SAMPLE,
ProtocolEvent.EXIT,
self._handler_polled_sample_exit)
# 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.
self._add_build_handler(SamiInstrumentCommand.GET_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.START_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.STOP_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.GET_CONFIG,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.SET_CONFIG,
self._build_set_config)
self._add_build_handler(SamiInstrumentCommand.ERASE_ALL,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.START,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.STOP,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.ACQUIRE_SAMPLE_SAMI,
self._build_sample_sami)
self._add_build_handler(SamiInstrumentCommand.ESCAPE_BOOT,
self._build_escape_boot)
# Add response handlers for device commands.
self._add_response_handler(SamiInstrumentCommand.GET_STATUS,
self._build_response_get_status)
self._add_response_handler(SamiInstrumentCommand.GET_CONFIG,
self._build_response_get_config)
self._add_response_handler(SamiInstrumentCommand.SET_CONFIG,
self._build_response_set_config)
self._add_response_handler(SamiInstrumentCommand.ERASE_ALL,
self._build_response_erase_all)
self._add_response_handler(SamiInstrumentCommand.ACQUIRE_SAMPLE_SAMI,
self._build_response_sample_sami)
# Add sample handlers.
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
class Protocol(InstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = META_LOGGER
def __init__(self, driver_event):
"""
Protocol constructor.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
InstrumentProtocol.__init__(self, driver_event)
# Build protocol state machine.
self._protocol_fsm = InstrumentFSM(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_AUTOSAMPLE,
self._handler_command_start_autosample),
(ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_command_start_poll),
(ProtocolEvent.CALIBRATE,
self._handler_command_start_calibrate),
(ProtocolEvent.START_NAFION,
self._handler_command_start_nafion_regen),
(ProtocolEvent.START_ION,
self._handler_command_start_ion_regen),
(ProtocolEvent.ERROR, self._handler_error),
(ProtocolEvent.POWEROFF, self._handler_command_poweroff),
(ProtocolEvent.START_MANUAL,
self._handler_command_start_manual),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_autosample_acquire_sample),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.POLL: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.ERROR: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CLEAR, self._handler_error_clear),
],
ProtocolState.CALIBRATE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.REGEN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_REGEN, self._handler_stop_regen),
(ProtocolEvent.REGEN_COMPLETE, self._handler_regen_complete),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_direct_access_exit),
(ProtocolEvent.STOP_DIRECT,
self._handler_direct_access_stop_direct),
(ProtocolEvent.EXECUTE_DIRECT,
self._handler_direct_access_execute_direct),
],
ProtocolState.MANUAL_OVERRIDE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_MANUAL,
self._handler_manual_override_stop),
(ProtocolEvent.GET_SLAVE_STATES,
self._handler_manual_get_slave_states),
],
}
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()
# 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._slave_protocols = {}
self.initialize_scheduler()
def _add_manual_override_handlers(self):
for slave in self._slave_protocols:
for event in self._slave_protocols[slave]._cmd_dict._cmd_dict:
self._protocol_fsm.add_handler(
ProtocolState.MANUAL_OVERRIDE, event,
self._build_override_handler(slave, event))
def _build_override_handler(self, slave, event):
log.debug('Building event handler for protocol: %s event: %s', slave,
event)
def inner():
return None, self._slave_protocols[slave]._protocol_fsm.on_event(
event)
return inner
def register_slave_protocol(self, name, protocol):
"""
@param name: slave protocol name
@param protocol: slave protocol instance
@return: None
"""
self._slave_protocols[name] = protocol
def _slave_protocol_event(self, event, *args, **kwargs):
"""
Handle an event from a slave protocol.
@param event: event to be processed
"""
name = kwargs.get('name')
if name is not None and name in self._slave_protocols:
# only react to slave protocol events once we have transitioned out of unknown
if self.get_current_state(
) != ProtocolState.UNKNOWN or event == DriverAsyncEvent.ERROR:
if event == DriverAsyncEvent.STATE_CHANGE:
self._react()
elif event == DriverAsyncEvent.CONFIG_CHANGE:
# do nothing, we handle this ourselves in set_param
pass
else:
# pass the event up to the instrument agent
log.debug(
'Passing event up to the Instrument agent: %r %r %r',
event, args, kwargs)
self._driver_event(event, *args)
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
self._param_dict.add(
Parameter.SAMPLE_INTERVAL,
'',
None,
int,
type=ParameterDictType.INT,
display_name='Autosample Interval',
description=
'Interval between sample starts during autosample state',
units=Units.SECOND)
def _build_command_dict(self):
"""
Populate the command dictionary with commands.
"""
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE,
display_name="Acquire Sample")
self._cmd_dict.add(Capability.START_AUTOSAMPLE,
display_name="Start Autosample")
self._cmd_dict.add(Capability.CALIBRATE,
display_name="Acquire Calibration Samples")
self._cmd_dict.add(Capability.START_ION,
display_name="Start Ion Chamber Regeneration")
self._cmd_dict.add(Capability.START_NAFION,
display_name="Start Nafion Regeneration")
self._cmd_dict.add(Capability.STOP_REGEN,
display_name="Stop Current Regeneration")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE,
display_name="Stop Autosample")
self._cmd_dict.add(Capability.POWEROFF, display_name='Low Power State')
self._cmd_dict.add(Capability.GET_SLAVE_STATES,
display_name='Get Slave States')
self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, False)
def _react(self):
"""
Determine if an action is necessary based on the states of the slave protocols.
(MCU STATE, TURBO STATE, RGA STATE) : (TARGET, EVENT)
The specified event will be sent to the specified target.
"""
state = self.get_current_state()
slave_states = self._get_slave_states()
if MASSP_STATE_ERROR in slave_states:
return self._error()
if state == ProtocolState.REGEN and slave_states[
0] == ProtocolState.COMMAND:
self._async_raise_fsm_event(ProtocolEvent.REGEN_COMPLETE)
# these actions are only applicable in POLL, AUTOSAMPLE or CALIBRATE states
if state not in [
ProtocolState.POLL, ProtocolState.AUTOSAMPLE,
ProtocolState.CALIBRATE
]:
return
mps = mcu.ProtocolState
tps = turbo.ProtocolState
rps = rga.ProtocolState
action_map = {
# Waiting Turbo (RGA is off)
(mps.WAITING_TURBO, tps.COMMAND, rps.COMMAND):
(TURBO, turbo.Capability.START_TURBO),
(mps.WAITING_TURBO, tps.AT_SPEED, rps.COMMAND):
(MCU, mcu.Capability.START2),
# Waiting RGA
(mps.WAITING_RGA, tps.AT_SPEED, rps.SCAN): (MCU,
mcu.Capability.SAMPLE),
(mps.WAITING_RGA, tps.AT_SPEED, rps.COMMAND):
(RGA, rga.Capability.START_SCAN),
(mps.WAITING_RGA, tps.COMMAND, rps.SCAN):
(RGA, rga.Capability.STOP_SCAN), # this should never happen!
(mps.WAITING_RGA, tps.COMMAND, rps.COMMAND):
(MCU, mcu.Capability.STANDBY), # this should never happen!
# Stopping
(mps.STOPPING, tps.AT_SPEED, rps.SCAN): (RGA,
rga.Capability.STOP_SCAN),
(mps.STOPPING, tps.AT_SPEED, rps.COMMAND):
(TURBO, turbo.Capability.STOP_TURBO),
(mps.STOPPING, tps.COMMAND, rps.SCAN):
(RGA, rga.Capability.STOP_SCAN), # this should never happen!
(mps.STOPPING, tps.COMMAND, rps.COMMAND): (MCU,
mcu.Capability.STANDBY),
}
action = action_map.get(self._get_slave_states())
if action is not None:
if not isinstance(action, list):
action = [action]
# iterate through the action list, sending the events to the targets
# if we are in POLL or CALIBRATE and we see a STANDBY event, return this driver to COMMAND.
for target, command in action:
if command == mcu.Capability.SAMPLE and state == ProtocolState.CALIBRATE:
command = mcu.Capability.CALIBRATE
if command == mcu.Capability.STANDBY and state in [
ProtocolState.CALIBRATE, ProtocolState.POLL
]:
self._send_event_to_slave(target, command)
self._async_raise_fsm_event(ProtocolEvent.STOP)
else:
self._send_event_to_slave(target, command)
return action
def _error(self):
"""
Handle error state in slave protocol
"""
state = self.get_current_state()
slave_states = self._get_slave_states()
# if we are not currently in the error state, make the transition
if state != ProtocolState.ERROR:
self._async_raise_fsm_event(ProtocolEvent.ERROR)
mcu_state, turbo_state, rga_state = slave_states
# before we do anything else, the RGA must be stopped.
if rga_state not in [
rga.ProtocolState.COMMAND, rga.ProtocolState.ERROR
]:
self._send_event_to_slave(RGA, rga.ProtocolEvent.STOP_SCAN)
# RGA must be in COMMAND or ERROR, the TURBO must be stopped.
elif turbo_state not in [
turbo.ProtocolState.COMMAND, turbo.ProtocolState.SPINNING_DOWN
]:
self._send_event_to_slave(TURBO, turbo.ProtocolEvent.STOP_TURBO)
# Turbo and RGA must be in COMMAND or ERROR, stop the MCU
elif mcu_state != mcu.ProtocolState.COMMAND:
self._send_event_to_slave(MCU, mcu.ProtocolEvent.STANDBY)
def _got_chunk(self, chunk):
"""
This driver has no chunker...
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
@param events: Events to be filtered
@return: list of events which are also capabilities
"""
return [
x for x in events if Capability.has(x) or mcu.Capability.has(x)
or turbo.Capability.has(x) or rga.Capability.has(x)
]
def _get_slave_states(self):
"""
Retrieve the current protocol state from each of the slave protocols and return them as a tuple.
"""
return (
self._slave_protocols[MCU].get_current_state(),
self._slave_protocols[TURBO].get_current_state(),
self._slave_protocols[RGA].get_current_state(),
)
def _send_event_to_all(self, event):
"""
Send the same event to all slave protocols.
@return: List of (name, result) for a slave protocols
"""
return [(name, slave._protocol_fsm.on_event(event))
for name, slave in self._slave_protocols.items()]
def _send_event_to_slave(self, name, event):
"""
Send an event to a specific protocol
@param name: Name of slave protocol
@param event: Event to be sent
"""
slave_protocol = self._slave_protocols.get(name)
if slave_protocol is None:
raise InstrumentProtocolException(
'Attempted to send event to non-existent protocol: %s' % name)
slave_protocol._async_raise_fsm_event(event)
def _send_massp_direct_access(self, command):
"""
Handle a direct access command. Driver expects direct access commands to specify the target
using the following format:
target:command
It then routes the command to the appropriate slave protocol.
@param command: Direct access command received
"""
err_string = 'Invalid command. Command must be in the following format: "target:command' + NEWLINE + \
'Valid targets are: %r' % self._slave_protocols.keys()
try:
target, command = command.split(DA_COMMAND_DELIMITER, 1)
target = target.lower()
except ValueError:
target = None
log.debug('_do_cmd_direct - target: %s command: %r', target, command)
if target not in self._slave_protocols:
self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, err_string)
else:
self._slave_protocols[target]._protocol_fsm.on_event(
ProtocolEvent.EXECUTE_DIRECT, command)
def _set_params(self, *args, **kwargs):
"""
Set one or more parameters. This method will determine where the parameter actually resides and
forward it to the appropriate parameter dictionary based on name.
@param args: arglist which must contain a parameter dictionary
@throws InstrumentParameterException
"""
params = args[0]
if not isinstance(params, dict):
raise InstrumentParameterException(
'Attempted to set parameters with a non-dictionary argument')
_, old_config = self._handler_command_get([Parameter.ALL])
temp_dict = {}
for key in params:
split_key = key.split('_', 1)
if len(split_key) == 1:
raise InstrumentParameterException(
'Missing target in MASSP parameter: %s' % key)
target = split_key[0]
if not target in self._slave_protocols:
# this is a master driver parameter, set it here
if key in self._param_dict.get_keys():
log.debug("Setting value for %s to %s", key, params[key])
self._param_dict.set_value(key, params[key])
else:
raise InstrumentParameterException(
'Invalid key in SET action: %s' % key)
else:
temp_dict.setdefault(target, {})[key] = params[key]
# set parameters for slave protocols
for name in temp_dict:
if name in self._slave_protocols:
self._slave_protocols[name]._set_params(temp_dict[name])
else:
# how did we get here? This should never happen, but raise an exception if it does.
raise InstrumentParameterException(
'Invalid key(s) in SET action: %r' % temp_dict[name])
_, new_config = self._handler_command_get([Parameter.ALL])
if not new_config == old_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def set_init_params(self, config):
"""
Set initial parameters. Parameters are forwarded to the appropriate parameter dictionary based on name.
@param config: Init param config to be handled
"""
temp_dict = {}
self._startup_config = config
config = config.get(DriverConfigKey.PARAMETERS, {})
for key in config:
target, _ = key.split('_', 1)
if not target in self._slave_protocols:
# master driver parameter
log.debug("Setting init value for %s to %s", key, config[key])
self._param_dict.set_init_value(key, config[key])
else:
temp_dict.setdefault(target, {})[key] = config[key]
for name in temp_dict:
if name in self._slave_protocols:
self._slave_protocols[name].set_init_params(
{DriverConfigKey.PARAMETERS: temp_dict[name]})
else:
# how did we get here? This should never happen, but raise an exception if it does.
raise InstrumentParameterException(
'Invalid key(s) in INIT PARAMS action: %r' %
temp_dict[name])
def get_config_metadata_dict(self):
"""
See base class for full description. This method is overridden to retrieve the parameter
dictionary from each slave protocol and merge them.
@return: dictionary containing driver metadata
"""
log.debug("Getting metadata dict from protocol...")
return_dict = {
ConfigMetadataKey.DRIVER: self._driver_dict.generate_dict(),
ConfigMetadataKey.COMMANDS: self._cmd_dict.generate_dict(),
ConfigMetadataKey.PARAMETERS: self._param_dict.generate_dict()
}
for protocol in self._slave_protocols.values():
return_dict[ConfigMetadataKey.PARAMETERS].update(
protocol._param_dict.generate_dict())
return_dict[ConfigMetadataKey.COMMANDS].update(
protocol._cmd_dict.generate_dict())
return return_dict
def get_resource_capabilities(self, current_state=True):
"""
Overrides base class to include slave protocol parameters
@param current_state: Boolean indicating whether we should return only the current state events
@return: (resource_commands, resource_parameters)
"""
res_cmds = self._protocol_fsm.get_events(current_state)
res_cmds = self._filter_capabilities(res_cmds)
res_params = self._param_dict.get_keys()
for protocol in self._slave_protocols.values():
res_params.extend(protocol._param_dict.get_keys())
return res_cmds, res_params
def _build_scheduler(self):
"""
Build a scheduler for periodic status updates
"""
job_name = ScheduledJob.ACQUIRE_SAMPLE
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE:
TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS:
self._param_dict.get(Parameter.SAMPLE_INTERVAL)
},
}
}
}
self.set_init_params(config)
self._add_scheduler_event(ScheduledJob.ACQUIRE_SAMPLE,
ProtocolEvent.ACQUIRE_SAMPLE)
def _delete_scheduler(self):
"""
Remove the autosample schedule.
"""
try:
self._remove_scheduler(ScheduledJob.ACQUIRE_SAMPLE)
except KeyError:
log.info('Failed to remove scheduled job for ACQUIRE_SAMPLE')
########################################################################
# Generic handlers.
########################################################################
def _handler_generic_enter(self, *args, **kwargs):
"""
Generic enter handler, raise STATE CHANGE
"""
if self.get_current_state() != ProtocolState.UNKNOWN:
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_generic_exit(self, *args, **kwargs):
"""
Generic exit handler, do nothing.
"""
def _handler_stop_generic(self, *args, **kwargs):
"""
Generic stop method to return to COMMAND (via POLL if appropriate)
@return next_state, (next_agent_state, None)
"""
self._delete_scheduler()
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
# check if we are in autosample AND currently taking a sample, if so, move to POLL
# otherwise go back to COMMAND.
if self.get_current_state() == ProtocolState.AUTOSAMPLE:
if self._get_slave_states() != (ProtocolState.COMMAND,
ProtocolState.COMMAND,
ProtocolState.COMMAND):
next_state = ProtocolState.POLL
next_agent_state = ResourceAgentState.BUSY
# notify the agent we have changed states
self._async_agent_state_change(next_agent_state)
return next_state, (next_agent_state, None)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@return (next_state, next_agent_state)
"""
result = self._send_event_to_all(ProtocolEvent.DISCOVER)
log.debug('_handler_unknown_discover -- send DISCOVER to all: %r',
result)
target_state = (ProtocolState.COMMAND, ProtocolState.COMMAND,
ProtocolState.COMMAND)
success = False
# wait for the slave protocols to discover
for attempt in xrange(5):
slave_states = self._get_slave_states()
if slave_states == target_state:
success = True
break
time.sleep(1)
if not success:
return ProtocolState.ERROR, ResourceAgentState.IDLE
return ProtocolState.COMMAND, ResourceAgentState.IDLE
########################################################################
# Command handlers.
########################################################################
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter. Query this protocol plus all slave protocols.
@param args: arglist which should contain a list of parameters to get
@return None, results
"""
params = args[0]
if not isinstance(params, list):
params = [params]
temp_dict = {}
result_dict = {}
# request is for all parameters, send get(ALL) to each protocol then combine the results.
if Parameter.ALL in params:
params = [Parameter.ALL]
_, result = self._handler_get(params, **kwargs)
result_dict.update(result)
for protocol in self._slave_protocols.values():
_, result = protocol._handler_get(params, **kwargs)
result_dict.update(result)
# request is for specific parameters. Determine which protocol should service each,
# call the appropriate _handler_get and combine the results
else:
for key in params:
log.debug('about to split: %s', key)
target, _ = key.split('_', 1)
temp_dict.setdefault(target, []).append(key)
for key in temp_dict:
if key == MASTER:
_, result = self._handler_get(params, **kwargs)
else:
if key in self._slave_protocols:
_, result = self._slave_protocols[key]._handler_get(
params, **kwargs)
else:
raise InstrumentParameterException(
'Invalid key(s) in GET action: %r' %
temp_dict[key])
result_dict.update(result)
return None, result_dict
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter, just pass through to _set_params, which knows how to set the params
in the slave protocols.
"""
self._set_params(*args, **kwargs)
return None, None
def _handler_command_start_direct(self):
"""
Start direct access
@return next_state, (next_agent_state, result)
"""
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS,
None)
def _handler_command_start_autosample(self):
"""
Move my FSM to autosample and start the sample sequence by sending START1 to the MCU.
Create the scheduler to automatically start the next sample sequence
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
self._build_scheduler()
return ProtocolState.AUTOSAMPLE, (ResourceAgentState.STREAMING, None)
def _handler_command_start_poll(self):
"""
Move my FSM to poll and start the sample sequence by sending START1 to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
return ProtocolState.POLL, (ResourceAgentState.BUSY, None)
def _handler_command_start_calibrate(self):
"""
Move my FSM to calibrate and start the calibrate sequence by sending START1 to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
return ProtocolState.CALIBRATE, (ResourceAgentState.BUSY, None)
def _handler_command_start_nafion_regen(self):
"""
Move my FSM to NAFION_REGEN and send NAFION_REGEN to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.NAFREG)
return ProtocolState.REGEN, (ResourceAgentState.BUSY, None)
def _handler_command_start_ion_regen(self):
"""
Move my FSM to ION_REGEN and send ION_REGEN to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.IONREG)
return ProtocolState.REGEN, (ResourceAgentState.BUSY, None)
def _handler_command_poweroff(self):
"""
Send POWEROFF to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.POWEROFF)
return None, (None, None)
def _handler_command_start_manual(self):
"""
Move FSM to MANUAL OVERRIDE state
@return next_state, (next_agent_state, result)
"""
return ProtocolState.MANUAL_OVERRIDE, (ResourceAgentState.COMMAND,
None)
########################################################################
# Error handlers.
########################################################################
def _handler_error(self):
"""
@return next_state, next_agent_state
"""
return ProtocolState.ERROR, ResourceAgentState.BUSY
def _handler_error_clear(self):
"""
Send the CLEAR event to any slave protocol in the error state and return this driver to COMMAND
@return next_state, (next_agent_state, result)
"""
for protocol in self._slave_protocols:
state = protocol.get_current_state()
if state == MASSP_STATE_ERROR:
# do this synchronously, to allow each slave protocol to complete the CLEAR action
# before transitioning states.
protocol._protocol_fsm.on_event(ProtocolEvent.CLEAR)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_acquire_sample(self):
"""
Fire off a sample sequence while in the autosample state.
@return None, None
@throws InstrumentProtocolException
"""
slave_states = self._get_slave_states()
# verify the MCU is not already in a sequence
if slave_states[0] == ProtocolState.COMMAND:
result = self._send_event_to_slave(MCU, mcu.Capability.START1)
else:
raise InstrumentProtocolException(
"Attempted to acquire sample while sampling")
return None, None
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state. Forward to all slave protocols.
"""
self._send_event_to_all(ProtocolEvent.START_DIRECT)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state. Check slave protocol states and verify they all
return to COMMAND, otherwise raise InstrumentProtocolException.
@throws InstrumentProtocolException
"""
for attempt in range(DA_EXIT_MAX_RETRIES):
slave_states = self._get_slave_states()
if ProtocolState.DIRECT_ACCESS in slave_states:
log.error(
'Slave protocol failed to return to command, attempt %d',
attempt)
time.sleep(1)
else:
return
raise InstrumentProtocolException(
'Slave protocol never returned to command from DA.')
def _handler_direct_access_execute_direct(self, data):
"""
Execute a direct access command. For MASSP, this means passing the actual command to the
correct slave protocol. This is handled by _send_massp_direct_access.
@return next_state, (next_agent_state, result)
"""
self._send_massp_direct_access(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return None, (None, None)
def _handler_direct_access_stop_direct(self):
"""
@return next_state, (next_agent_state, result)
"""
self._send_event_to_all(ProtocolEvent.STOP_DIRECT)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Regen handlers.
########################################################################
def _handler_stop_regen(self):
"""
Abort the current regeneration sequence, return to COMMAND
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.STANDBY)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_regen_complete(self):
"""
Regeneration sequence is complete, return to COMMAND
@return next_state, (next_agent_state, result)
"""
self._async_agent_state_change(ResourceAgentState.COMMAND)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_manual_override_stop(self):
"""
Exit manual override. Attempt to bring the slave drivers back to COMMAND.
"""
mcu_state, turbo_state, rga_state = self._get_slave_states()
if rga_state == rga.ProtocolState.SCAN:
self._slave_protocols[RGA]._protocol_fsm.on_event(
rga.Capability.STOP_SCAN)
if turbo_state == turbo.ProtocolState.AT_SPEED:
self._slave_protocols[TURBO]._protocol_fsm.on_event(
turbo.Capability.STOP_TURBO)
while rga_state not in [rga.ProtocolState.COMMAND, rga.ProtocolState.ERROR] or \
turbo_state not in [turbo.ProtocolState.COMMAND, turbo.ProtocolState.ERROR]:
time.sleep(.1)
mcu_state, turbo_state, rga_state = self._get_slave_states()
if mcu_state != mcu.ProtocolState.COMMAND:
self._slave_protocols[MCU]._protocol_fsm.on_event(
mcu.Capability.STANDBY)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_manual_get_slave_states(self):
"""
Get the slave states and return them to the user
@return: next_state, (next_agent_state, result)
"""
mcu_state, turbo_state, rga_state = self._get_slave_states()
return None, (None, {
MCU: mcu_state,
RGA: rga_state,
TURBO: turbo_state
})
def __init__(self, driver_event):
"""
Protocol constructor.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
InstrumentProtocol.__init__(self, driver_event)
# Build protocol state machine.
self._protocol_fsm = InstrumentFSM(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_AUTOSAMPLE, self._handler_command_start_autosample),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_start_poll),
(ProtocolEvent.CALIBRATE, self._handler_command_start_calibrate),
(ProtocolEvent.START_NAFION, self._handler_command_start_nafion_regen),
(ProtocolEvent.START_ION, self._handler_command_start_ion_regen),
(ProtocolEvent.ERROR, self._handler_error),
(ProtocolEvent.POWEROFF, self._handler_command_poweroff),
(ProtocolEvent.START_MANUAL, self._handler_command_start_manual),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_autosample_acquire_sample),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.POLL: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.ERROR: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CLEAR, self._handler_error_clear),
],
ProtocolState.CALIBRATE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.REGEN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_REGEN, self._handler_stop_regen),
(ProtocolEvent.REGEN_COMPLETE, self._handler_regen_complete),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_direct_access_exit),
(ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct),
(ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct),
],
ProtocolState.MANUAL_OVERRIDE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_MANUAL, self._handler_manual_override_stop),
(ProtocolEvent.GET_SLAVE_STATES, self._handler_manual_get_slave_states),
],
}
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()
# 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._slave_protocols = {}
self.initialize_scheduler()
def __init__(self, driver_event):
"""
Protocol constructor.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
InstrumentProtocol.__init__(self, driver_event)
# Build protocol state machine.
self._protocol_fsm = InstrumentFSM(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_AUTOSAMPLE,
self._handler_command_start_autosample),
(ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_command_start_poll),
(ProtocolEvent.CALIBRATE,
self._handler_command_start_calibrate),
(ProtocolEvent.START_NAFION,
self._handler_command_start_nafion_regen),
(ProtocolEvent.START_ION,
self._handler_command_start_ion_regen),
(ProtocolEvent.ERROR, self._handler_error),
(ProtocolEvent.POWEROFF, self._handler_command_poweroff),
(ProtocolEvent.START_MANUAL,
self._handler_command_start_manual),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_autosample_acquire_sample),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.POLL: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.ERROR: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CLEAR, self._handler_error_clear),
],
ProtocolState.CALIBRATE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.REGEN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_REGEN, self._handler_stop_regen),
(ProtocolEvent.REGEN_COMPLETE, self._handler_regen_complete),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_direct_access_exit),
(ProtocolEvent.STOP_DIRECT,
self._handler_direct_access_stop_direct),
(ProtocolEvent.EXECUTE_DIRECT,
self._handler_direct_access_execute_direct),
],
ProtocolState.MANUAL_OVERRIDE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_MANUAL,
self._handler_manual_override_stop),
(ProtocolEvent.GET_SLAVE_STATES,
self._handler_manual_get_slave_states),
],
}
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()
# 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._slave_protocols = {}
self.initialize_scheduler()
class VadcpProtocol(CommandResponseInstrumentProtocol):
"""
"""
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 execute_init_protocol(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.INITIALIZE, *args,
**kwargs)
def execute_get_latest_sample(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.GET_LAST_ENSEMBLE,
*args, **kwargs)
def execute_get_metadata(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.GET_METADATA, *args,
**kwargs)
def execute_run_recorder_tests(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.RUN_RECORDER_TESTS,
*args, **kwargs)
def execute_run_all_tests(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.RUN_ALL_TESTS, *args,
**kwargs)
################
# State handlers
################
def _handler_initialize(self, *args, **kwargs):
"""
Determines initial protocol state according to instrument's state
"""
next_state = None
result = None
# TODO determine the state. For now, assume command mode
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = ProtocolState.COMMAND_MODE
return (next_state, result)
def _handler_command_get_latest_sample(self, *args, **kwargs):
"""
"""
if log.isEnabledFor(logging.DEBUG):
log.debug("args=%s kwargs=%s" % (str(args), str(kwargs)))
next_state = self._protocol_fsm.get_current_state()
result = None
timeout = kwargs.get('timeout', self._timeout)
try:
result = self._connection.get_latest_sample(timeout)
except TimeoutException, e:
raise InstrumentTimeoutException(msg=str(e))
except ClientException, e:
log.warn("ClientException while get_latest_sample: %s" % str(e))
raise InstrumentException('ClientException: %s' % str(e))
class VadcpProtocol(CommandResponseInstrumentProtocol):
"""
"""
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 execute_init_protocol(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.INITIALIZE,
*args, **kwargs)
def execute_get_latest_sample(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.GET_LAST_ENSEMBLE,
*args, **kwargs)
def execute_get_metadata(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.GET_METADATA,
*args, **kwargs)
def execute_run_recorder_tests(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.RUN_RECORDER_TESTS,
*args, **kwargs)
def execute_run_all_tests(self, *args, **kwargs):
"""
"""
return self._protocol_fsm.on_event(ProtocolEvent.RUN_ALL_TESTS,
*args, **kwargs)
################
# State handlers
################
def _handler_initialize(self, *args, **kwargs):
"""
Determines initial protocol state according to instrument's state
"""
next_state = None
result = None
# TODO determine the state. For now, assume command mode
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = ProtocolState.COMMAND_MODE
return (next_state, result)
def _handler_command_get_latest_sample(self, *args, **kwargs):
"""
"""
if log.isEnabledFor(logging.DEBUG):
log.debug("args=%s kwargs=%s" % (str(args), str(kwargs)))
next_state = self._protocol_fsm.get_current_state()
result = None
timeout = kwargs.get('timeout', self._timeout)
try:
result = self._connection.get_latest_sample(timeout)
except TimeoutException, e:
raise InstrumentTimeoutException(msg=str(e))
except ClientException, e:
log.warn("ClientException while get_latest_sample: %s" %
str(e))
raise InstrumentException('ClientException: %s' % str(e))
class mavs4InstrumentProtocol(MenuInstrumentProtocol):
"""
The protocol is a very simple command/response protocol with a few show
commands and a few set commands.
"""
def __init__(self, prompts, newline, driver_event):
"""
"""
self.write_delay = WRITE_DELAY
self._last_data_timestamp = None
self.eoln = INSTRUMENT_NEWLINE
# create short alias for Directions class
Directions = MenuInstrumentProtocol.MenuTree.Directions
# create MenuTree object
menu = MenuInstrumentProtocol.MenuTree({
SubMenues.ROOT : [],
SubMenues.SET_TIME : [Directions(InstrumentCmds.SET_TIME, InstrumentPrompts.SET_TIME)],
SubMenues.DEPLOY : [Directions(InstrumentCmds.DEPLOY_MENU, InstrumentPrompts.SUB_MENU, 20)]
})
MenuInstrumentProtocol.__init__(self, menu, prompts, newline, driver_event)
# these build handlers will be called by the base class during the
# navigate_and_execute sequence.
self._add_build_handler(InstrumentCmds.ENTER_TIME, self._build_time_command)
self._add_build_handler(InstrumentCmds.SET_TIME, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.ANSWER_YES, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.DEPLOY_MENU, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.DEPLOY_GO, self._build_keypress_command)
self._add_build_handler(InstrumentCmds.EXIT_SUB_MENU, self._build_keypress_command)
# Add response handlers for device commands.
self._add_response_handler(InstrumentCmds.SET_TIME, self._parse_time_response)
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.GET, self._handler_get)
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.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)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
# Set state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolStates.UNKNOWN)
########################################################################
# overridden superclass methods
########################################################################
def _navigate_and_execute(self, cmds, **kwargs):
"""
Navigate to a sub-menu and execute a list of commands.
@param cmds The list of commands to execute.
@param expected_prompt optional kwarg passed through to do_cmd_resp.
@param timeout=timeout optional wakeup and command timeout.
@param write_delay optional kwarg passed through to do_cmd_resp.
@raises InstrumentTimeoutException if the response did not occur in time.
@raises InstrumentProtocolException if command could not be built or if response
was not recognized.
"""
resp_result = None
# Get dest_submenu
dest_submenu = kwargs.pop('dest_submenu', None)
if dest_submenu == None:
raise InstrumentProtocolException('_navigate_and_execute(): dest_submenu parameter missing')
# iterate through the directions
directions_list = self._menu.get_directions(dest_submenu)
for directions in directions_list:
log.debug('_navigate_and_execute: directions: %s' %(directions))
command = directions.get_command()
response = directions.get_response()
timeout = directions.get_timeout()
self._do_cmd_resp(command, expected_prompt = response, timeout = timeout)
for interaction in cmds:
command = interaction[0]
response = interaction[1]
log.debug('_navigate_and_execute: sending cmd: %s with expected response %s and kwargs: %s to _do_cmd_resp.'
%(command, response, kwargs))
resp_result = self._do_cmd_resp(command, expected_prompt = response, **kwargs)
return resp_result
def _do_cmd_resp(self, cmd, *args, **kwargs):
"""
Perform a command-response on the device.
@param cmd The command to execute.
@param args positional arguments to pass to the build handler.
@param timeout=timeout optional command timeout.
@retval resp_result The (possibly parsed) response result.
@raises InstrumentTimeoutException if the response did not occur in time.
@raises InstrumentProtocolException if command could not be built or if response
was not recognized.
"""
# Get timeout and final response.
timeout = kwargs.get('timeout', 10)
expected_prompt = kwargs.get('expected_prompt', None)
# Get the build handler.
build_handler = self._build_handlers.get(cmd, None)
if not build_handler:
raise InstrumentProtocolException('_do_cmd_resp: Cannot build command: %s' % cmd)
value = kwargs.get('value', None)
cmd_line = build_handler(cmd, value)
# Send command.
log.debug('mavs4InstrumentProtocol._do_cmd_resp: %s, timeout=%s, expected_prompt=%s, expected_prompt(hex)=%s,'
%(cmd_line, timeout, expected_prompt, expected_prompt.encode("hex")))
if cmd_line == InstrumentCmds.EXIT_SUB_MENU:
self._connection.send(cmd_line)
else:
for char in cmd_line: # Clear line and prompt buffers for result.
self._linebuf = ''
self._promptbuf = ''
self._connection.send(char)
# Wait for the character to be echoed, timeout exception
self._get_response(timeout, expected_prompt='%s'%char)
self._connection.send(INSTRUMENT_NEWLINE)
(prompt, result) = self._get_response(timeout, expected_prompt=expected_prompt)
resp_handler = self._response_handlers.get(cmd, None)
resp_result = None
if resp_handler:
resp_result = resp_handler(result, prompt)
return resp_result
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.
MenuInstrumentProtocol.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 _go_to_root_menu(self):
self._do_cmd_resp(InstrumentCmds.EXIT_SUB_MENU, expected_prompt=InstrumentPrompts.MAIN_MENU, timeout=4)
def _float_to_string(self, v):
"""
Write a float value to string formatted for "generic" set operations.
Subclasses should overload this as needed for instrument-specific
formatting.
@param v A float val.
@retval a float string formatted for "generic" set operations.
@throws InstrumentParameterException if value is not a float.
"""
if not isinstance(v,float):
raise InstrumentParameterException('Value %s is not a float.' % v)
else:
return str(v)
########################################################################
# State Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can be COMMAND or AUTOSAMPLE. If the instrument is sleeping
consider that to be in command state.
@retval (next_state, result), (ProtocolStates.COMMAND or ProtocolStates.AUTOSAMPLE, None) if successful.
"""
next_state = None
result = None
# try to wakeup the device using timeout if passed.
timeout = kwargs.get('timeout', INSTRUMENT_TIMEOUT)
try:
prompt = self._get_prompt(timeout)
except InstrumentTimeoutException:
# didn't get any command mode prompt, so...
# might be in deployed mode and sending data or
# might be in 'deployed' mode with monitor off or
# maybe not connected to an instrument at all
next_state = ProtocolStates.AUTOSAMPLE
result = ProtocolStates.AUTOSAMPLE
else:
# got one of the prompts, so device is in command mode
next_state = ProtocolStates.COMMAND
result = ProtocolStates.COMMAND
return (next_state, result)
########################################################################
# State Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
self._update_params()
log.debug("parameters values are: %s" %str(self._param_dict.get_config()))
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_set(self, *args, **kwargs):
"""
Perform a set command.
@param args[0] parameter : value dict.
@retval (next_state, result) tuple, (None, None).
@throws InstrumentParameterException if missing set parameters, if set parameters not ALL and
not a dict, or if paramter can't be properly formatted.
@throws InstrumentTimeoutException if device cannot be woken for set command.
@throws InstrumentProtocolException if set command could not be built or misunderstood.
"""
next_state = None
result = None
# Retrieve required parameter from args.
# Raise exception if no parameter provided, or not a dict.
try:
params_to_set = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
else:
if not isinstance(params_to_set, dict):
raise InstrumentParameterException('Set parameters not a dict.')
for (key, val) in params_to_set.iteritems():
# go to root menu.
got_prompt = False
for i in range(10):
try:
self._go_to_root_menu()
got_prompt = True
break
except:
pass
if not got_prompt:
raise InstrumentTimeoutException()
dest_submenu = self._param_dict.get_menu_path_write(key)
commands = self._param_dict.get_submenu_write(key)
self._navigate_and_execute(commands, value=val, dest_submenu=dest_submenu, timeout=5)
self._update_params()
return (next_state, result)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Switch into autosample mode.
@retval (next_state, result) tuple, (SBE37ProtocolState.AUTOSAMPLE,
None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
"""
next_state = None
result = None
self._go_to_root_menu()
# Issue start command and switch to autosample if successful.
self._navigate_and_execute(InstrumentCmds.DEPLOY_GO,
dest_submenu=SubMenues.DEPLOY,
timeout=20,
expected_prompt=InstrumentPrompts.DEPLOY,
*args, **kwargs)
next_state = ProtocolStates.AUTOSAMPLE
return (next_state, result)
def _handler_command_test(self, *args, **kwargs):
"""
Switch to test state to perform instrument tests.
@retval (next_state, result) tuple, (SBE37ProtocolState.TEST, None).
"""
next_state = None
result = None
next_state = ProtocolStates.TEST
return (next_state, result)
def _handler_command_start_direct(self):
"""
"""
next_state = None
result = None
next_state = ProtocolStates.DIRECT_ACCESS
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit autosample state.
"""
pass
def _handler_autosample_stop_autosample(self, *args, **kwargs):
"""
Stop autosample and switch back to command mode.
@retval (next_state, result) tuple, (SBE37ProtocolState.COMMAND,
None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command misunderstood or
incorrect prompt received.
"""
next_state = None
result = None
# Issue stop command and switch to command if successful.
got_root_prompt = False
for i in range(10):
try:
self._go_to_root_menu()
got_root_prompt = True
break
except:
pass
if not got_root_prompt:
raise InstrumentTimeoutException()
next_state = ProtocolStates.COMMAND
return (next_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
self._do_cmd_direct(data)
return (next_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolStates.COMMAND
return (next_state, result)
########################################################################
# Common handlers.
########################################################################
def _handler_get(self, *args, **kwargs):
"""
Get device parameters from the parameter dict.
@param args[0] list of parameters to retrieve, or DriverParameter.ALL.
@throws InstrumentParameterException if missing or invalid parameter.
"""
next_state = None
result = None
# Retrieve the required parameter, raise if not present.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Get command requires a parameter list or tuple.')
# If all params requested, retrieve config.
if params == DriverParameter.ALL:
result = self._param_dict.get_config()
# If not all params, confirm a list or tuple of params to retrieve.
# Raise if not a list or tuple.
# Retireve each key in the list, raise if any are invalid.
else:
if not isinstance(params, (list, tuple)):
raise InstrumentParameterException('Get argument not a list or tuple.')
result = {}
for key in params:
try:
val = self._param_dict.get(key)
result[key] = val
except KeyError:
raise InstrumentParameterException(('%s is not a valid parameter.' % key))
return (next_state, result)
########################################################################
# Private helpers.
########################################################################
def _build_param_dict(self):
"""
Populate the parameter dictionary with MAVS4 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = Mavs4ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(InstrumentParameters.SYS_CLOCK,
r'.*\[(.*)\].*',
lambda match : match.group(1),
lambda string : string,
value='',
menu_path_read=SubMenues.ROOT,
submenu_read=[[InstrumentCmds.SET_TIME, InstrumentPrompts.SET_TIME]],
menu_path_write=SubMenues.SET_TIME,
submenu_write=[[InstrumentCmds.ENTER_TIME, InstrumentPrompts.SET_TIME],
[InstrumentCmds.ANSWER_YES, InstrumentPrompts.SET_TIME]])
self._param_dict.add(InstrumentParameters.DATA_MONITOR,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.QUERY_MODE,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.MEASUREMENT_FREQUENCY,
'',
lambda line : float(line),
self._float_to_string,
value=0.0)
self._param_dict.add(InstrumentParameters.MEASUREMENTS_PER_SAMPLE,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.SAMPLE_PERIOD_SECS,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.SAMPLE_PERIOD_TICKS,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.SAMPLES_PER_BURST,
'',
lambda line : int(line),
self._int_to_string,
value=0)
self._param_dict.add(InstrumentParameters.INTERVAL_BETWEEN_BURSTS,
'',
lambda line : int(line),
self._int_to_string,
value=0)
def _get_prompt(self, timeout, delay=1):
"""
_wakeup is replaced by this method for this instrument to search for
prompt strings at other than just the end of the line. There is no
'wakeup' for this instrument when it is in 'deployed' mode,
so the best that can be done is to see if it responds or not.
Clear buffers and send some CRs to the instrument
@param timeout The timeout to wake the device.
@param delay The time to wait between consecutive wakeups.
@throw InstrumentTimeoutException if the device could not be woken.
"""
# Clear the prompt buffer.
self._promptbuf = ''
# Grab time for timeout.
starttime = time.time()
while True:
# Send a line return and wait a sec.
log.debug('Sending 2 newlines to get a response from the instrument.')
# Send two newlines to attempt to wake the MAVS-4 device and get a response.
self._connection.send(INSTRUMENT_NEWLINE + INSTRUMENT_NEWLINE)
time.sleep(delay)
for item in self._prompts.list():
if item in self._promptbuf:
log.debug('wakeup got prompt: %s' % repr(item))
return item
if time.time() > starttime + timeout:
raise InstrumentTimeoutException()
def _extract_sample(self, line, publish=True):
"""
Extract sample from a response line if present and publish to agent.
@param line string to match for sample.
@param publsih boolean to publish sample (default True).
@retval Sample dictionary if present or None.
"""
return # TODO remove this when sample format is known
def _update_params(self, *args, **kwargs):
"""
Update the parameter dictionary. Issue the upload command. The response
needs to be iterated through a line at a time and valuse saved.
@throws InstrumentTimeoutException if device cannot be timely woken.
@throws InstrumentProtocolException if ds/dc misunderstood.
"""
if self.get_current_state() != ProtocolStates.COMMAND:
raise InstrumentStateException('Can not perform update of parameters when not in command state',
error_code=InstErrorCode.INCORRECT_STATE)
# Get old param dict config.
old_config = self._param_dict.get_config()
params_to_get = [InstrumentParameters.SYS_CLOCK]
for key in params_to_get:
# go to root menu.
got_prompt = False
for i in range(10):
try:
self._go_to_root_menu()
got_prompt = True
break
except:
pass
if not got_prompt:
raise InstrumentTimeoutException()
dest_submenu = self._param_dict.get_menu_path_read(key)
commands = self._param_dict.get_submenu_read(key)
self._navigate_and_execute(commands, dest_submenu=dest_submenu, timeout=5)
# Get new param dict config. If it differs from the old config,
# tell driver superclass to publish a config change event.
new_config = self._param_dict.get_config()
if new_config != old_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def _build_time_command(self, throw_away, val):
"""
Build handler for time set command
String cmd constructed by param dict formatting function.
@ retval The set command to be sent to the device.
"""
cmd = self._param_dict.format(InstrumentParameters.SYS_CLOCK, val)
log.debug("_build_time_command: cmd=%s" %cmd)
return cmd
def _parse_time_response(self, response, prompt):
"""
Parse handler for upload command.
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if upload command misunderstood.
"""
if not InstrumentPrompts.GET_TIME in response:
raise InstrumentProtocolException('get time command not recognized: %s.' % response)
log.debug("_parse_time_response: response=%s" %response)
if not self._param_dict.update(InstrumentParameters.SYS_CLOCK, response.splitlines()[-1]):
log.debug('_parse_time_response: Failed to parse %s' %InstrumentParameters.SYS_CLOCK)
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)
class SBE43Protocol(SBE19Protocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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)
@staticmethod
def sieve_function(raw_data):
""" The method that splits samples
Over-ride sieve function to handle additional particles.
"""
matchers = []
return_list = []
matchers.append(SBE43DataParticle.regex_compiled())
matchers.append(SBE43HardwareParticle.regex_compiled())
matchers.append(SBE43CalibrationParticle.regex_compiled())
matchers.append(SBE43StatusParticle.regex_compiled())
matchers.append(SBE43ConfigurationParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
Over-ride sieve function to handle additional particles.
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
for particle_class in SBE43HardwareParticle, SBE43DataParticle, SBE43CalibrationParticle, \
SBE43ConfigurationParticle, SBE43StatusParticle:
if self._extract_sample(particle_class, particle_class.regex_compiled(), chunk, timestamp):
return
raise InstrumentProtocolException("Unhandled chunk %s" % chunk)
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
#check values that the instrument doesn't validate
#handle special cases for driver specific parameters
for (key, val) in params.iteritems():
if key == Parameter.PUMP_DELAY and (val < MIN_PUMP_DELAY or val > MAX_PUMP_DELAY):
raise InstrumentParameterException("pump delay out of range")
elif key == Parameter.NUM_AVG_SAMPLES and (val < MIN_AVG_SAMPLES or val > MAX_AVG_SAMPLES):
raise InstrumentParameterException("num average samples out of range")
self._verify_not_readonly(*args, **kwargs)
for (key, val) in params.iteritems():
log.debug("KEY = %s VALUE = %s", key, val)
if key in ConfirmedParameter.list():
# We add a write delay here because this command has to be sent
# twice, the write delay allows it to process the first command
# before it receives the beginning of the second.
self._do_cmd_resp(Command.SET, key, val, write_delay=0.2)
else:
self._do_cmd_resp(Command.SET, key, val, **kwargs)
log.debug("set complete, update params")
self._update_params()
########################################################################
# Command handlers.
########################################################################
def _handler_command_acquire_status(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = []
result.append(self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetSD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetHD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetCD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetCC Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetEC Response: %s", result)
#Reset the event counter right after getEC
self._do_cmd_resp(Command.RESET_EC, timeout=TIMEOUT)
return next_state, (next_agent_state, ''.join(result))
def _handler_autosample_acquire_status(self, *args, **kwargs):
"""
Get device status in autosample mode
"""
next_state = None
next_agent_state = None
result = []
# When in autosample this command requires two wakeups to get to the right prompt
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
result.append(self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetSD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetHD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetCD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetCC Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetEC Response: %s", result)
#Reset the event counter right after getEC
self._do_cmd_no_resp(Command.RESET_EC)
return next_state, (next_agent_state, ''.join(result))
def _build_set_command(self, cmd, param, val):
"""
Build handler for set commands. param=val followed by newline.
String val constructed by param dict formatting function.
@param param the parameter key to set.
@param val the parameter value to set.
@ retval The set command to be sent to the device.
@throws InstrumentProtocolException if the parameter is not valid or
if the formatting function could not accept the value passed.
"""
try:
str_val = self._param_dict.format(param, val)
set_cmd = '%s=%s%s' % (param, str_val, NEWLINE)
# Some set commands need to be sent twice to confirm
if param in ConfirmedParameter.list():
set_cmd = set_cmd + set_cmd
except KeyError:
raise InstrumentParameterException('Unknown driver parameter %s' % param)
return set_cmd
########################################################################
# response handlers.
########################################################################
def _validate_GetSD_response(self, response, prompt):
"""
validation handler for GetSD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("_validate_GetSD_response: GetSD command encountered error; type='%s' msg='%s'", error[0],
error[1])
raise InstrumentProtocolException('GetSD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43StatusParticle.resp_regex_compiled().search(response):
log.error('_validate_GetSD_response: GetSD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetSD command not recognized: %s.' % response)
return response
def _validate_GetHD_response(self, response, prompt):
"""
validation handler for GetHD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetHD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetHD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43HardwareParticle.resp_regex_compiled().search(response):
log.error('_validate_GetHD_response: GetHD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetHD command not recognized: %s.' % response)
return response
def _validate_GetCD_response(self, response, prompt):
"""
validation handler for GetCD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetCD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetCD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43ConfigurationParticle.resp_regex_compiled().search(response):
log.error('_validate_GetCD_response: GetCD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetCD command not recognized: %s.' % response)
return response
########################################################################
# Private helpers.
########################################################################
def _build_param_dict(self):
"""
Populate the parameter dictionary with SBE19 parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(Parameter.DATE_TIME,
r'SBE 19plus V ([\w.]+) +SERIAL NO. (\d+) +(\d{2} [a-zA-Z]{3,4} \d{4} +[\d:]+)',
lambda match: string.upper(match.group(3)),
self._date_time_string_to_numeric,
type=ParameterDictType.STRING,
display_name="Date/Time",
visibility=ParameterDictVisibility.READ_ONLY)
self._param_dict.add(Parameter.LOGGING,
r'status = (not )?logging',
lambda match: False if (match.group(1)) else True,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Is Logging",
visibility=ParameterDictVisibility.READ_ONLY)
self._param_dict.add(Parameter.PTYPE,
r'pressure sensor = ([\w\s]+),',
self._pressure_sensor_to_int,
str,
type=ParameterDictType.INT,
display_name="Pressure Sensor Type",
startup_param=True,
direct_access=True,
default_value=1,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT0,
r'Ext Volt 0 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 0",
startup_param=True,
direct_access=True,
default_value=True,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT1,
r'Ext Volt 1 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 1",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT2,
r'Ext Volt 2 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 2",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT3,
r'Ext Volt 3 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 3",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT4,
r'Ext Volt 4 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 4",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT5,
r'Ext Volt 5 = ([\w]+)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 5",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.SBE38,
r'SBE 38 = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="SBE38 Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.WETLABS,
r'WETLABS = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Enable Wetlabs sensor",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.GTD,
r'Gas Tension Device = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="GTD Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.DUAL_GTD,
r'Gas Tension Device = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Dual GTD Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.SBE63,
r'SBE63 = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="SBE63 Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.OPTODE,
r'OPTODE = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Optode Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.OUTPUT_FORMAT,
r'output format = (raw HEX)',
self._output_format_string_2_int,
int,
type=ParameterDictType.INT,
display_name="Output Format",
startup_param=True,
direct_access=True,
default_value=0,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.NUM_AVG_SAMPLES,
r'number of scans to average = ([\d]+)',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Scans To Average",
startup_param=True,
direct_access=False,
default_value=4,
visibility=ParameterDictVisibility.READ_WRITE)
self._param_dict.add(Parameter.MIN_COND_FREQ,
r'minimum cond freq = ([\d]+)',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Minimum Conductivity Frequency",
startup_param=True,
direct_access=False,
default_value=500,
units=ParameterUnit.HERTZ,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.PUMP_DELAY,
r'pump delay = ([\d]+) sec',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Pump Delay",
startup_param=True,
direct_access=False,
default_value=60,
units=ParameterUnit.SECOND,
visibility=ParameterDictVisibility.READ_WRITE)
self._param_dict.add(Parameter.AUTO_RUN,
r'autorun = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Auto Run",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.IGNORE_SWITCH,
r'ignore magnetic switch = (yes|no)',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Ignore Switch",
startup_param=True,
direct_access=True,
default_value=True,
visibility=ParameterDictVisibility.IMMUTABLE)
class THSPHProtocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = get_logging_metaclass(log_level='debug')
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)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = []
return_list = []
matchers.append(THSPHParticle.regex_compiled())
for matcher in matchers:
log.trace('matcher: %r raw_data: %r', matcher.pattern, raw_data)
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if not self._extract_sample(THSPHParticle, THSPHParticle.regex_compiled(), chunk, timestamp):
raise InstrumentProtocolException("Unhandled chunk")
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
def _build_command_dict(self):
"""
Populate the command dictionary with command.
"""
self._cmd_dict.add(Capability.START_AUTOSAMPLE, display_name="start autosample")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE, display_name="stop autosample")
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE, display_name="acquire sample")
self._cmd_dict.add(Capability.SET, display_name="set")
self._cmd_dict.add(Capability.GET, display_name="get")
def _build_param_dict(self):
"""
Populate the parameter dictionary with THSPH parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(Parameter.INTERVAL,
r'Auto Polled Interval = (\d+)',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
units=Units.SECOND,
display_name="Polled Interval",
startup_param=True,
direct_access=False,
default_value=5)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown State handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; Change next state to be COMMAND state.
@retval (next_state, result).
"""
log.debug('_handler_unknown_discover ')
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.IDLE
return next_state, next_agent_state
########################################################################
# Command State handlers.
########################################################################
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Get device status
"""
log.debug("_handler_command_acquire_sample")
next_state = None
next_agent_state = None
result = None
self._do_cmd_no_resp(Command.GET_SAMPLE, timeout=TIMEOUT)
return next_state, (next_agent_state, result)
def _handler_command_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
pass
def _handler_command_get(self, *args, **kwargs):
"""
Get device parameters from the parameter dict. First we set a baseline timestamp
that all data expirations will be calculated against. Then we try to get parameter
value. If we catch an expired parameter then we will update all parameters and get
values using the original baseline time that we set at the beginning of this method.
Assuming our _update_params is updating all parameter values properly then we can
ensure that all data will be fresh. Nobody likes stale data!
@param args[0] list of parameters to retrieve, or DriverParameter.ALL.
"""
return self._handler_get(*args, **kwargs)
def _handler_command_set(self, *args, **kwargs):
"""
Perform a set command.
@param args[0] parameter : value dict.
@retval (next_state, result) tuple, (None, None).
@throws InstrumentParameterException if missing set parameters, if set parameters not ALL and
not a dict, or if parameter can't be properly formatted.
"""
next_state = None
result = None
startup = False
log.debug("_handler_command_set enter ")
# Retrieve required parameter.
# Raise if no parameter provided, or not a dict.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
if not isinstance(params, dict):
raise InstrumentParameterException('Set parameters not a dict.')
try:
startup = args[1]
except IndexError:
pass
old_config = self._param_dict.get_config()
self._set_params(params, startup)
new_config = self._param_dict.get_config()
if old_config != new_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
return next_state, result
def _set_params(self, *args, **kwargs):
"""
Set various parameters internally to the driver. No issuing commands to the
instrument needed for this driver.
"""
log.debug("_set_params ")
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
#list can be null, like in the case of direct access params, in this case do nothing
if not params:
return
# Sampling interval is the only parameter that is set by the driver.
# Do a range check before we start all sets
for (key, val) in params.iteritems():
if key == Parameter.INTERVAL and not (0 < val < 601):
log.debug("Auto Sample Interval not in 1 to 600 range ")
raise InstrumentParameterException("sample interval out of range [1, 600]")
log.debug('key = (%s), value = (%s)' % (key, val))
self._param_dict.set_value(Parameter.INTERVAL, params[Parameter.INTERVAL])
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Switch into autosample mode.
@retval (next_state, result) tuple, (ProtocolState.AUTOSAMPLE,
(next_agent_state, None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return next_state, (next_agent_state, result)
def _handler_command_start_direct(self):
"""
Start direct access
"""
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS, None)
#######################################################################
# Autosample State handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state Because this is an instrument that must be
polled we need to ensure the scheduler is added when we are in an
autosample state. This scheduler raises events to poll the
instrument for data.
@retval next_state, (next_agent_state, result)
"""
log.debug("_handler_autosample_enter ")
self._init_params()
self._setup_autosample_config()
# Schedule auto sample task
self._add_scheduler_event(ScheduledJob.AUTO_SAMPLE, ProtocolEvent.SCHEDULE_ACQUIRE_SAMPLE)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
return None, (None, None)
def _setup_autosample_config(self):
"""
Set up auto sample configuration and add it to the scheduler.
"""
# Start the scheduler to poll the instrument for
# data every sample interval seconds
log.debug("_setup_autosample_config")
job_name = ScheduledJob.AUTO_SAMPLE
polled_interval = self._param_dict.get_config_value(Parameter.INTERVAL)
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS: polled_interval
}
}
}
}
self.set_init_params(config)
# Start the scheduler if it is not running
if not self._scheduler:
self.initialize_scheduler()
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit auto sample state. Remove the auto sample task
"""
log.debug("_handler_autosample_exit ")
next_state = None
next_agent_state = None
result = None
return next_state, (next_agent_state, result)
def _handler_autosample_stop_autosample(self, *args, **kwargs):
"""
Remove the auto sample task. Exit Auto sample state
"""
log.debug("_handler_autosample_stop_autosample ")
result = None
# Stop the Auto Poll scheduling
self._remove_scheduler(ScheduledJob.AUTO_SAMPLE)
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
Execute direct command
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return next_state, (next_agent_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
def _build_simple_command(self, cmd, *args):
"""
Build handler for basic THSPH commands.
@param cmd the simple ooicore command to format.
@retval The command to be sent to the device.
"""
return "%s%s" % (cmd, NEWLINE)
def _build_set_command(self, cmd, param, val):
"""
Build handler for set commands. param=val followed by newline.
String val constructed by param dict formatting function.
@param param the parameter key to set.
@param val the parameter value to set.
@ retval The set command to be sent to the device.
@throws InstrumentParameterException if the parameter is not valid or
if the formatting function could not accept the value passed.
@throws InstrumentProtocolException if there is no build handler for the
communication test command.
"""
try:
str_val = self._param_dict.format(param, val)
if param == 'INTERVAL':
param = 'sampleinterval'
set_cmd = '%s=%s' % (param, str_val)
set_cmd += NEWLINE
except KeyError:
raise InstrumentParameterException('Unknown driver parameter %s' % param)
return set_cmd
def _wakeup(self, wakeup_timeout=WAKEUP_TIMEOUT, response_timeout=RESPONSE_TIMEOUT):
"""
waking this instrument up by sending MAX_COM_TEST communication test commands
(aP*)
@param wakeup_timeout The timeout to wake the device.
@param response_timeout The time to look for response to a wakeup attempt.
@throw InstrumentTimeoutException if the device could not be woken.
"""
log.debug("_wakeup ")
sleep_time = CMD_RESP_TIME
cmd_line = self._build_simple_command(Command.COMM_TEST)
# Grab start time for overall wakeup timeout.
start_time = time.time()
test_count = 0
while test_count < MAX_COMM_TEST:
# Clear the prompt buffer.
self._promptbuf = ''
# Send a communication test command and wait delay amount for response.
self._connection.send(cmd_line)
time.sleep(sleep_time)
if self._promptbuf.find(Prompt.COMM_RESPONSE) != -1:
# instrument is awake
log.debug('_wakeup: got communication test response %s', Prompt.COMM_RESPONSE)
test_count += 1
else:
#clear test_count since we want MAX_COMM_TEST consecutive successful communication test
test_count = 0
# Stop wake up the instrument if the wake up time out has elapsed
if time.time() > start_time + wakeup_timeout:
break
if test_count != MAX_COMM_TEST:
log.debug('instrument failed to wakeup in %d seconds time' % wakeup_timeout)
raise InstrumentTimeoutException(
"_wakeup(): instrument failed to wakeup in %d seconds time" % wakeup_timeout)
else:
return Prompt.COMM_RESPONSE
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.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.START_DIRECT, self._handler_command_start_direct)
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 = []
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@retval (next_state, result)
"""
(ProtocolState.COMMAND, None)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
"""
next_state = None
result = None
next_state = ProtocolState.DIRECT_ACCESS
return (next_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
return (next_state, result)
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def got_data(self, data):
"""
Callback for receiving new data from the device.
"""
# got data callback for direct access only
# TODO: should we have a generic got_data in the base class that does something useful?? Is this code
# TODO: instrument specific?
if self.get_current_state() == ProtocolState.DIRECT_ACCESS:
# direct access mode
if len(data) > 0:
log.debug("Protocol._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
class THSPHProtocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
SERIES_A = 'A'
SERIES_B = 'B'
SERIES_C = 'C'
GET_SAMPLE_SERIES_A = 'aH*' # Gets data sample from ADC for series A
GET_SAMPLE_SERIES_B = 'bH*' # Gets data sample from ADC for series B
GET_SAMPLE_SERIES_C = 'cH*' # Gets data sample from ADC for series C
# THSPH commands for instrument series A, B and C
THSPH_COMMANDS = {
SERIES_A: {Command.GET_SAMPLE: GET_SAMPLE_SERIES_A},
SERIES_B: {Command.GET_SAMPLE: GET_SAMPLE_SERIES_B},
SERIES_C: {Command.GET_SAMPLE: GET_SAMPLE_SERIES_C},
}
__metaclass__ = get_logging_metaclass(log_level='debug')
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
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = []
return_list = []
matchers.append(THSPHParticle.regex_compiled())
for matcher in matchers:
log.trace('matcher: %r raw_data: %r', matcher.pattern, raw_data)
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if not self._extract_sample(THSPHParticle, THSPHParticle.regex_compiled(), chunk, timestamp):
raise InstrumentProtocolException("Unhandled chunk")
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
def _build_command_dict(self):
"""
Populate the command dictionary with command.
"""
self._cmd_dict.add(Capability.START_AUTOSAMPLE, display_name="Start Autosample")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE, display_name="Stop Autosample")
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE, display_name="Acquire Sample")
self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def _build_param_dict(self):
"""
Populate the parameter dictionary with THSPH parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(Parameter.INTERVAL,
r'Auto Polled Interval = (\d+)',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
units=Units.SECOND,
display_name="Polled Interval",
visibility=ParameterDictVisibility.READ_WRITE,
startup_param=True,
direct_access=False,
default_value=5)
self._param_dict.add(Parameter.INSTRUMENT_SERIES,
r'Instrument Series = ([A-C])',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.STRING,
display_name="Instrument Series",
description='Defines instance of instrument series [A, B, C].',
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
direct_access=False,
default_value='A')
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown State handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; Change next state to be COMMAND state.
@retval (next_state, result).
"""
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.IDLE
return next_state, next_agent_state
########################################################################
# Command State handlers.
########################################################################
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = None
self._do_cmd_no_resp(Command.GET_SAMPLE, timeout=TIMEOUT)
return next_state, (next_agent_state, result)
def _handler_command_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
pass
def _handler_command_get(self, *args, **kwargs):
"""
Get device parameters from the parameter dict. First we set a baseline timestamp
that all data expirations will be calculated against. Then we try to get parameter
value. If we catch an expired parameter then we will update all parameters and get
values using the original baseline time that we set at the beginning of this method.
Assuming our _update_params is updating all parameter values properly then we can
ensure that all data will be fresh. Nobody likes stale data!
@param args[0] list of parameters to retrieve, or DriverParameter.ALL.
"""
return self._handler_get(*args, **kwargs)
def _handler_command_set(self, *args, **kwargs):
"""
Perform a set command.
@param args[0] parameter : value dict.
@retval (next_state, result) tuple, (None, None).
@throws InstrumentParameterException if missing set parameters, if set parameters not ALL and
not a dict, or if parameter can't be properly formatted.
"""
next_state = None
result = None
startup = False
# Retrieve required parameter.
# Raise if no parameter provided, or not a dict.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
if not isinstance(params, dict):
raise InstrumentParameterException('Set parameters not a dict.')
try:
startup = args[1]
except IndexError:
pass
old_config = self._param_dict.get_config()
self._set_params(params, startup)
new_config = self._param_dict.get_config()
if old_config != new_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
return next_state, result
def _set_params(self, *args, **kwargs):
"""
Set various parameters internally to the driver. No issuing commands to the
instrument needed for this driver.
"""
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
#list can be null, like in the case of direct access params, in this case do nothing
if not params:
return
# Do a range check before we start all sets
for (key, val) in params.iteritems():
if key == Parameter.INTERVAL and not (0 < val < 601):
log.debug("Auto Sample Interval not in 1 to 600 range ")
raise InstrumentParameterException("sample interval out of range [1, 600]")
if key == Parameter.INSTRUMENT_SERIES:
if val not in 'ABC':
log.debug("Instrument Series is not A, B or C ")
raise InstrumentParameterException("Instrument Series is not invalid ")
else:
self._get_sample_cmd = self.THSPH_COMMANDS[val][Command.GET_SAMPLE]
log.debug('key = (%s), value = (%s)' % (key, val))
self._param_dict.set_value(key, val)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Switch into autosample mode.
@retval (next_state, result) tuple, (ProtocolState.AUTOSAMPLE,
(next_agent_state, None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return next_state, (next_agent_state, result)
def _handler_command_start_direct(self):
"""
Start direct access
"""
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS, None)
#######################################################################
# Autosample State handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state Because this is an instrument that must be
polled we need to ensure the scheduler is added when we are in an
autosample state. This scheduler raises events to poll the
instrument for data.
@retval next_state, (next_agent_state, result)
"""
self._init_params()
self._setup_autosample_config()
# Schedule auto sample task
self._add_scheduler_event(ScheduledJob.AUTO_SAMPLE, ProtocolEvent.SCHEDULE_ACQUIRE_SAMPLE)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
return None, (None, None)
def _setup_autosample_config(self):
"""
Set up auto sample configuration and add it to the scheduler.
"""
# Start the scheduler to poll the instrument for
# data every sample interval seconds
job_name = ScheduledJob.AUTO_SAMPLE
polled_interval = self._param_dict.get_config_value(Parameter.INTERVAL)
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS: polled_interval
}
}
}
}
self.set_init_params(config)
# Start the scheduler if it is not running
if not self._scheduler:
self.initialize_scheduler()
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit auto sample state. Remove the auto sample task
"""
next_state = None
next_agent_state = None
result = None
return next_state, (next_agent_state, result)
def _handler_autosample_stop_autosample(self, *args, **kwargs):
"""
Remove the auto sample task. Exit Auto sample state
"""
result = None
# Stop the Auto Poll scheduling
self._remove_scheduler(ScheduledJob.AUTO_SAMPLE)
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
Execute direct command
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return next_state, (next_agent_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
def _build_simple_command(self, cmd, *args):
"""
Build handler for basic THSPH commands.
@param cmd the simple ooicore command to format.
@retval The command to be sent to the device.
"""
instrument_series = self._param_dict.get(Parameter.INSTRUMENT_SERIES)
if cmd == Command.GET_SAMPLE:
instrument_cmd = self.THSPH_COMMANDS[instrument_series][Command.GET_SAMPLE]
else:
raise InstrumentException('Unknown THSPH driver command %s' % cmd)
return "%s%s" % (instrument_cmd, NEWLINE)
def _wakeup(self, wakeup_timeout=0, response_timeout=0):
"""
There is no wakeup for this instrument. Do nothing.
@param wakeup_timeout The timeout to wake the device.
@param response_timeout The time to look for response to a wakeup attempt.
"""
pass
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)
class SBE43Protocol(SBE19Protocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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)
@staticmethod
def sieve_function(raw_data):
""" The method that splits samples
Over-ride sieve function to handle additional particles.
"""
matchers = []
return_list = []
matchers.append(SBE43DataParticle.regex_compiled())
matchers.append(SBE43HardwareParticle.regex_compiled())
matchers.append(SBE43CalibrationParticle.regex_compiled())
matchers.append(SBE43StatusParticle.regex_compiled())
matchers.append(SBE43ConfigurationParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
Over-ride sieve function to handle additional particles.
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if not (
self._extract_sample(SBE43HardwareParticle, SBE43HardwareParticle.regex_compiled(), chunk, timestamp)
or self._extract_sample(SBE43DataParticle, SBE43DataParticle.regex_compiled(), chunk, timestamp)
or self._extract_sample(
SBE43CalibrationParticle, SBE43CalibrationParticle.regex_compiled(), chunk, timestamp
)
or self._extract_sample(
SBE43ConfigurationParticle, SBE43ConfigurationParticle.regex_compiled(), chunk, timestamp
)
or self._extract_sample(SBE43StatusParticle, SBE43StatusParticle.regex_compiled(), chunk, timestamp)
):
raise InstrumentProtocolException("Unhandled chunk %s" % chunk)
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
try:
params = args[0]
except IndexError:
raise InstrumentParameterException("Set command requires a parameter dict.")
# check values that the instrument doesn't validate
# handle special cases for driver specific parameters
for (key, val) in params.iteritems():
if key == Parameter.PUMP_DELAY and (val < MIN_PUMP_DELAY or val > MAX_PUMP_DELAY):
raise InstrumentParameterException("pump delay out of range")
elif key == Parameter.NUM_AVG_SAMPLES and (val < MIN_AVG_SAMPLES or val > MAX_AVG_SAMPLES):
raise InstrumentParameterException("num average samples out of range")
self._verify_not_readonly(*args, **kwargs)
for (key, val) in params.iteritems():
log.debug("KEY = %s VALUE = %s", key, val)
if key in ConfirmedParameter.list():
# We add a write delay here because this command has to be sent
# twice, the write delay allows it to process the first command
# before it receives the beginning of the second.
self._do_cmd_resp(Command.SET, key, val, write_delay=0.2)
else:
self._do_cmd_resp(Command.SET, key, val, **kwargs)
log.debug("set complete, update params")
self._update_params()
########################################################################
# Command handlers.
########################################################################
def _handler_command_acquire_status(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(), timeout=TIMEOUT)
log.debug("_handler_command_acquire_status: GetSD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_command_acquire_status: GetHD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_command_acquire_status: GetCD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_command_acquire_status: GetCC Response: %s", result)
result += self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT)
log.debug("_handler_command_acquire_status: GetEC Response: %s", result)
# Reset the event counter right after getEC
self._do_cmd_resp(Command.RESET_EC, timeout=TIMEOUT)
return next_state, (next_agent_state, result)
def _handler_autosample_acquire_status(self, *args, **kwargs):
"""
Get device status in autosample mode
"""
next_state = None
next_agent_state = None
# When in autosample this command requires two wakeups to get to the right prompt
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
result = self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(), timeout=TIMEOUT)
log.debug("_handler_autosample_acquire_status: GetSD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_autosample_acquire_status: GetHD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_autosample_acquire_status: GetCD Response: %s", result)
result += self._do_cmd_resp(
Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(), timeout=TIMEOUT
)
log.debug("_handler_autosample_acquire_status: GetCC Response: %s", result)
result += self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT)
log.debug("_handler_autosample_acquire_status: GetEC Response: %s", result)
# Reset the event counter right after getEC
self._do_cmd_no_resp(Command.RESET_EC)
return next_state, (next_agent_state, result)
def _build_set_command(self, cmd, param, val):
"""
Build handler for set commands. param=val followed by newline.
String val constructed by param dict formatting function.
@param param the parameter key to set.
@param val the parameter value to set.
@ retval The set command to be sent to the device.
@throws InstrumentProtocolException if the parameter is not valid or
if the formatting function could not accept the value passed.
"""
try:
str_val = self._param_dict.format(param, val)
set_cmd = "%s=%s%s" % (param, str_val, NEWLINE)
# Some set commands need to be sent twice to confirm
if param in ConfirmedParameter.list():
set_cmd = set_cmd + set_cmd
except KeyError:
raise InstrumentParameterException("Unknown driver parameter %s" % param)
return set_cmd
########################################################################
# response handlers.
########################################################################
def _validate_GetSD_response(self, response, prompt):
"""
validation handler for GetSD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error(
"_validate_GetSD_response: GetSD command encountered error; type='%s' msg='%s'", error[0], error[1]
)
raise InstrumentProtocolException('GetSD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43StatusParticle.resp_regex_compiled().search(response):
log.error("_validate_GetSD_response: GetSD command not recognized: %s." % response)
raise InstrumentProtocolException("GetSD command not recognized: %s." % response)
return response
def _validate_GetHD_response(self, response, prompt):
"""
validation handler for GetHD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetHD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetHD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43HardwareParticle.resp_regex_compiled().search(response):
log.error("_validate_GetHD_response: GetHD command not recognized: %s." % response)
raise InstrumentProtocolException("GetHD command not recognized: %s." % response)
return response
def _validate_GetCD_response(self, response, prompt):
"""
validation handler for GetCD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetCD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetCD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43ConfigurationParticle.resp_regex_compiled().search(response):
log.error("_validate_GetCD_response: GetCD command not recognized: %s." % response)
raise InstrumentProtocolException("GetCD command not recognized: %s." % response)
return response
########################################################################
# Private helpers.
########################################################################
def _build_param_dict(self):
"""
Populate the parameter dictionary with SBE19 parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(
Parameter.DATE_TIME,
r"SBE 19plus V ([\w.]+) +SERIAL NO. (\d+) +(\d{2} [a-zA-Z]{3,4} \d{4} +[\d:]+)",
lambda match: string.upper(match.group(3)),
self._date_time_string_to_numeric,
type=ParameterDictType.STRING,
display_name="Date/Time",
startup_param=False,
direct_access=False,
visibility=ParameterDictVisibility.READ_ONLY,
)
self._param_dict.add(
Parameter.LOGGING,
r"status = (not )?logging",
lambda match: False if (match.group(1)) else True,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Is Logging",
visibility=ParameterDictVisibility.READ_ONLY,
)
self._param_dict.add(
Parameter.PTYPE,
r"pressure sensor = ([\w\s]+),",
self._pressure_sensor_to_int,
str,
type=ParameterDictType.INT,
display_name="Pressure Sensor Type",
startup_param=True,
direct_access=True,
default_value=1,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT0,
r"Ext Volt 0 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 0",
startup_param=True,
direct_access=True,
default_value=True,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT1,
r"Ext Volt 1 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 1",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT2,
r"Ext Volt 2 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 2",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT3,
r"Ext Volt 3 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 3",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT4,
r"Ext Volt 4 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 4",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.VOLT5,
r"Ext Volt 5 = ([\w]+)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 5",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.SBE38,
r"SBE 38 = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="SBE38 Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.WETLABS,
r"WETLABS = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Enable Wetlabs sensor",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.GTD,
r"Gas Tension Device = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="GTD Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.DUAL_GTD,
r"Gas Tension Device = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Dual GTD Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.SBE63,
r"SBE63 = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="SBE63 Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.OPTODE,
r"OPTODE = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Optode Attached",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.OUTPUT_FORMAT,
r"output format = (raw HEX)",
self._output_format_string_2_int,
int,
type=ParameterDictType.INT,
display_name="Output Format",
startup_param=True,
direct_access=True,
default_value=0,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.NUM_AVG_SAMPLES,
r"number of scans to average = ([\d]+)",
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Scans To Average",
startup_param=True,
direct_access=False,
default_value=4,
visibility=ParameterDictVisibility.READ_WRITE,
)
self._param_dict.add(
Parameter.MIN_COND_FREQ,
r"minimum cond freq = ([\d]+)",
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Minimum Conductivity Frequency",
startup_param=True,
direct_access=False,
default_value=500,
units=ParameterUnit.HERTZ,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.PUMP_DELAY,
r"pump delay = ([\d]+) sec",
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Pump Delay",
startup_param=True,
direct_access=False,
default_value=60,
units=ParameterUnit.SECONDS,
visibility=ParameterDictVisibility.READ_WRITE,
)
self._param_dict.add(
Parameter.AUTO_RUN,
r"autorun = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Auto Run",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE,
)
self._param_dict.add(
Parameter.IGNORE_SWITCH,
r"ignore magnetic switch = (yes|no)",
lambda match: True if match.group(1) == "yes" else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Ignore Switch",
startup_param=True,
direct_access=True,
default_value=True,
visibility=ParameterDictVisibility.IMMUTABLE,
)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = get_logging_metaclass(log_level='debug')
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')
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
raw_data_len = len(raw_data)
return_list = []
# look for samples
for match in PACKET_REGISTRATION_REGEX.finditer(raw_data):
if match.start() + INDEX_OF_PACKET_RECORD_LENGTH + SIZE_OF_PACKET_RECORD_LENGTH < raw_data_len:
packet_length = get_two_byte_value(raw_data,
match.start() + INDEX_OF_PACKET_RECORD_LENGTH) + SIZE_OF_CHECKSUM_PLUS_PAD
if match.start() + packet_length <= raw_data_len:
return_list.append((match.start(), match.start() + packet_length))
# look for status
for match in STATUS_REGEX.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
# On a rare occurrence the particle sample coming in will be missing a byte
# trap the exception thrown and log an error
try:
self._extract_sample(OptaaSampleDataParticle, PACKET_REGISTRATION_REGEX, chunk, timestamp)
self._extract_sample(OptaaStatusDataParticle, STATUS_REGEX, chunk, timestamp)
except SampleException:
log.error("Unable to process sample (%r)", SampleException.message)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
"""
return ProtocolState.AUTOSAMPLE, ResourceAgentState.STREAMING
########################################################################
# Command handlers.
# Implemented to make DA possible, instrument has no actual command mode
########################################################################
def _handler_command_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
pass
def _handler_command_get(self, *args, **kwargs):
"""
Does nothing, implemented to make framework happy
"""
return None, None
def _handler_command_set(self, *args, **kwargs):
"""
Does nothing, implemented to make framework happy
"""
return None, None
def _handler_command_start_direct(self, *args, **kwargs):
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS, None)
def _handler_command_start_autosample(self, *args, **kwargs):
return ProtocolState.AUTOSAMPLE, (ResourceAgentState.STREAMING, None)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
pass
def _handler_autosample_stop_autosample(self):
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
pass
def _handler_direct_access_execute_direct(self, data):
self._do_cmd_direct(data)
return None, None
def _handler_direct_access_stop_direct(self):
"""
Instead of using discover(), as is the norm, put instrument into
Command state. Instrument can only sample, even when in a command state.
"""
return DriverProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
class SamiProtocol(CommandResponseInstrumentProtocol):
"""
SAMI Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
Should be sub-classed in specific driver.
"""
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.WAITING,
ProtocolEvent.ENTER,
self._handler_waiting_enter)
self._protocol_fsm.add_handler(ProtocolState.WAITING,
ProtocolEvent.EXIT,
self._handler_waiting_exit)
self._protocol_fsm.add_handler(ProtocolState.WAITING,
ProtocolEvent.DISCOVER,
self._handler_waiting_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.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.ACQUIRE_STATUS,
self._handler_command_acquire_status)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_command_acquire_sample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.START_AUTOSAMPLE,
self._handler_command_start_autosample)
# the ACQUIRE_CONFIGURATION event may not be necessary
#self._protocol_fsm.add_handler(
# ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_CONFIGURATION,
# self._handler_command_acquire_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.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)
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.AUTOSAMPLE,
ProtocolEvent.ACQUIRE_SAMPLE,
self._handler_autosample_acquire_sample)
# this state would be entered whenever an ACQUIRE_SAMPLE event
# occurred while in the AUTOSAMPLE state and will last anywhere
# from 10 seconds to 3 minutes depending on instrument and the
# type of sampling.
self._protocol_fsm.add_handler(ProtocolState.SCHEDULED_SAMPLE,
ProtocolEvent.ENTER,
self._handler_scheduled_sample_enter)
self._protocol_fsm.add_handler(ProtocolState.SCHEDULED_SAMPLE,
ProtocolEvent.EXIT,
self._handler_scheduled_sample_exit)
# this state would be entered whenever an ACQUIRE_SAMPLE event
# occurred while in either the COMMAND state (or via the
# discover transition from the UNKNOWN state with the instrument
# unresponsive) and will last anywhere from a few seconds to 3
# minutes depending on instrument and sample type.
self._protocol_fsm.add_handler(ProtocolState.POLLED_SAMPLE,
ProtocolEvent.ENTER,
self._handler_polled_sample_enter)
self._protocol_fsm.add_handler(ProtocolState.POLLED_SAMPLE,
ProtocolEvent.EXIT,
self._handler_polled_sample_exit)
# 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.
self._add_build_handler(SamiInstrumentCommand.GET_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.START_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.STOP_STATUS,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.GET_CONFIG,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.SET_CONFIG,
self._build_set_config)
self._add_build_handler(SamiInstrumentCommand.ERASE_ALL,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.START,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.STOP,
self._build_simple_command)
self._add_build_handler(SamiInstrumentCommand.ACQUIRE_SAMPLE_SAMI,
self._build_sample_sami)
self._add_build_handler(SamiInstrumentCommand.ESCAPE_BOOT,
self._build_escape_boot)
# Add response handlers for device commands.
self._add_response_handler(SamiInstrumentCommand.GET_STATUS,
self._build_response_get_status)
self._add_response_handler(SamiInstrumentCommand.GET_CONFIG,
self._build_response_get_config)
self._add_response_handler(SamiInstrumentCommand.SET_CONFIG,
self._build_response_set_config)
self._add_response_handler(SamiInstrumentCommand.ERASE_ALL,
self._build_response_erase_all)
self._add_response_handler(SamiInstrumentCommand.ACQUIRE_SAMPLE_SAMI,
self._build_response_sample_sami)
# Add sample handlers.
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
# continue __init__ in the sub-class in the specific driver
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Turn on debugging
log.debug("_handler_unknown_enter")
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can be UNKNOWN, COMMAND or POLLED_SAMPLE
@retval (next_state, result)
"""
next_state = None
result = None
log.debug("_handler_unknown_discover: starting discover")
(next_state, next_agent_state) = self._discover()
log.debug("_handler_unknown_discover: next agent state: %s",
next_agent_state)
return (next_state, (next_agent_state, result))
########################################################################
# Waiting handlers.
########################################################################
def _handler_waiting_enter(self, *args, **kwargs):
"""
Enter discover state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
# Test to determine what state we truly are in, command or unknown.
self._protocol_fsm.on_event(ProtocolEvent.DISCOVER)
def _handler_waiting_exit(self, *args, **kwargs):
"""
Exit discover state.
"""
pass
def _handler_waiting_discover(self, *args, **kwargs):
"""
Discover current state; can be UNKNOWN or COMMAND
@retval (next_state, result)
"""
# Exit states can be either COMMAND or back to UNKNOWN.
next_state = None
next_agent_state = None
result = None
# try to discover our state
count = 1
while count <= 6:
log.debug("_handler_waiting_discover: starting discover")
(next_state, next_agent_state) = self._discover()
if next_state is ProtocolState.COMMAND:
log.debug("_handler_waiting_discover: discover succeeded")
log.debug("_handler_waiting_discover: next agent state: %s",
next_agent_state)
return (next_state, (next_agent_state, result))
else:
log.debug(
"_handler_waiting_discover: discover failed, attempt %d of 3",
count)
count += 1
time.sleep(20)
log.debug("_handler_waiting_discover: discover failed")
log.debug("_handler_waiting_discover: next agent state: %s",
ResourceAgentState.ACTIVE_UNKNOWN)
return (ProtocolState.UNKNOWN, (ResourceAgentState.ACTIVE_UNKNOWN,
result))
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Command device to initialize parameters and send a config change event.
self._protocol_fsm.on_event(DriverEvent.INIT_PARAMS)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_init_params(self, *args, **kwargs):
"""
initialize parameters
"""
next_state = None
result = None
self._init_params()
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
# Not used currently. Maybe added later
#def _handler_command_acquire_configuration(self, *args, **kwargs):
# """
# Acquire the instrument's configuration
# """
# next_state = None
# result = None
#
# return (next_state, result)
def _handler_command_acquire_status(self, *args, **kwargs):
"""
Acquire the instrument's status
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Acquire a sample
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_start_autosample(self):
"""
Start autosample mode (spoofed via use of scheduler)
"""
next_state = ProtocolState.START_AUTOSAMPLE
next_agent_state = ResourceAgentState.START_AUTOSAMPLE
result = None
log.debug(
"_handler_command_start_autosample: entering Autosample mode")
return (next_state, (next_agent_state, result))
return (next_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
log.debug("_handler_direct_access_stop_direct: starting discover")
(next_state, next_agent_state) = self._discover()
log.debug("_handler_direct_access_stop_direct: next agent state: %s",
next_agent_state)
return (next_state, (next_agent_state, result))
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, ):
"""
Enter Autosample state
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit autosample state
"""
pass
def _handler_autosample_stop(self, *args, **kwargs):
"""
Stop autosample
"""
next_state = None
result = None
return (next_state, result)
def _handler_autosample_acquire_sample(self, *args, **kwargs):
"""
While in autosample mode, poll for samples using the scheduler
"""
next_state = None
result = None
return (next_state, result)
########################################################################
# Scheduled Sample handlers.
########################################################################
def _handler_scheduled_sample_enter(self, *args, **kwargs):
"""
Enter busy state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_scheduled_sample_exit(self, *args, **kwargs):
"""
Exit busy state.
"""
pass
########################################################################
# Polled Sample handlers.
########################################################################
def _handler_polled_sample_enter(self, *args, **kwargs):
"""
Enter busy state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_polled_sample_exit(self, *args, **kwargs):
"""
Exit busy state.
"""
pass
# handlers for the SUCCESS and TIMEOUT events associated with the
# Polled Sample and Scheduled Sample states are defined in the sub
# class.
####################################################################
# Build Command & Parameter dictionary
####################################################################
def _build_command_dict(self):
"""
Populate the command dictionary with command.
"""
self._cmd_dict.add(Capability.ACQUIRE_STATUS,
display_name="acquire status")
self._cmd_dict.add(Capability.START_AUTOSAMPLE,
display_name="start autosample")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE,
display_name="stop autosample")
self._cmd_dict.add(Capability.START_DIRECT,
display_name="start direct access")
self._cmd_dict.add(Capability.STOP_DIRECT,
display_name="stop direct access")
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Command handlers.
########################################################################
def _build_simple_command(self, cmd):
"""
Build handler for basic SAMI commands.
@param cmd the simple SAMI command to format.
@retval The command to be sent to the device.
"""
return cmd + NEWLINE
def _build_set_config(self):
pass
def _build_sample_sami(self):
pass
def _build_escape_boot(self):
pass
########################################################################
# Response handlers.
########################################################################
def _build_response_get_status(self):
pass
def _build_response_get_config(self):
pass
def _build_response_set_config(self):
pass
def _build_response_erase_all(self):
pass
def _build_response_sample_sami(self):
pass
########################################################################
# Private helpers.
########################################################################
@staticmethod
def _discover():
"""
Discover current state; can be UNKNOWN, COMMAND or DISCOVER
@retval (next_state, result)
"""
# Exit states can be either COMMAND, DISCOVER or back to UNKNOWN.
next_state = None
next_agent_state = None
log.debug("_discover")
# Set response timeout to 10 seconds. Should be immediate if
# communications are enabled and the instrument is not sampling.
# Otherwise, sampling can take up to ~3 minutes to complete. Partial
# strings are output during that time period.
kwargs['timeout'] = 10
# Make sure automatic-status updates are off. This will stop the
# broadcast of information while we are trying to get data.
cmd = self._build_simple_command(InstrumentCommand.STOP_STATUS)
self._do_cmd_direct(cmd)
# Acquire the current instrument status
status = self._do_cmd_resp(InstrumentCommand.GET_STATUS, *args,
**kwargs)
status_match = REGULAR_STATUS_REGEX_MATCHER.match(status)
if status is None or not status_match:
# No response received in the timeout period, or response that does
# not match the status string format is received. In either case,
# we assume the unit is sampling and transition to a new state,
# WAITING, to confirm or deny.
next_state = ProtocolState.WAITING
next_agent_state = ResourceAgentState.BUSY
else:
# Unit is powered on and ready to accept commands, etc.
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.IDLE
log.debug("_discover. result start: %s" % next_state)
return (next_state, next_agent_state)
@staticmethod
def _int_to_hexstring(val, slen):
"""
Write an integer value to an ASCIIHEX string formatted for SAMI
configuration set operations.
@param val the integer value to convert.
@param slen the required length of the returned string.
@retval an integer string formatted in ASCIIHEX for SAMI configuration
set operations.
@throws InstrumentParameterException if the integer and string length
values are not an integers.
"""
if not isinstance(val, int):
raise InstrumentParameterException('Value %s is not an integer.' %
str(val))
elif not isinstance(slen, int):
raise InstrumentParameterException('Value %s is not an integer.' %
str(slen))
else:
hexstr = format(val, 'X')
return hexstr.zfill(slen)
@staticmethod
def _epoch_to_sami():
"""
Create a timestamp in seconds using January 1, 1904 as the Epoch
@retval an integer value representing the number of seconds since
January 1, 1904.
"""
return int(time.time()) + SAMI_TO_UNIX
@staticmethod
def calc_crc(s, num_points):
"""
Compute a checksum for a Sami data record or control record string.
The '*' (character 1) and unique identifying byte (byte 1,
characters 2 & 3) at the beginning should be excluded from the
checksum calculation as well as the checksum value itself (last
byte, last 2 characters). It should include the record length
(byte 2, characters 4 & 5).
Note that this method does NOT calculate the checksum on the
configuration string that is returned during instrument
configuration.
@author Chris Center
@param s: string for check-sum analysis.
@param num_points: number of bytes (each byte is 2-chars).
"""
cs = 0
k = 0
for i in range(num_points):
value = int(s[k:k + 2], 16) # 2-chars per data point
cs = cs + value
k = k + 2
cs = cs & 0xFF
return (cs)
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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')
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
:param raw_data: raw data from instrument
"""
raw_data_len = len(raw_data)
return_list = []
# look for samples
# OPTAA record looks like this:
# ff00ff00 <- packet registration
# 02d0 <- record length minus checksum
# ... <- data
# 2244 <- checksum
# 00 <- pad
for match in PACKET_REGISTRATION_REGEX.finditer(raw_data):
# make sure I have at least 6 bytes (packet registration plus 2 bytes for record length)
start = match.start()
if (start + 6) <= raw_data_len:
packet_length = struct.unpack_from('>H', raw_data,
start + 4)[0]
# make sure we have enough data to construct a whole packet
if (start + packet_length +
SIZE_OF_CHECKSUM_PLUS_PAD) <= raw_data_len:
# validate the checksum, if valid add to the return list
checksum = struct.unpack_from('>H', raw_data,
start + packet_length)[0]
calulated_checksum = sum(
bytearray(
raw_data[start:start + packet_length])) & 0xffff
if checksum == calulated_checksum:
return_list.append(
(match.start(), match.start() + packet_length +
SIZE_OF_CHECKSUM_PLUS_PAD))
# look for status
for match in STATUS_REGEX.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
self._extract_sample(OptaaSampleDataParticle,
PACKET_REGISTRATION_REGEX, chunk, timestamp)
self._extract_sample(OptaaStatusDataParticle, STATUS_REGEX, chunk,
timestamp)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can only be AUTOSAMPLE (instrument has no actual command mode).
"""
next_state = ProtocolState.AUTOSAMPLE
result = []
return next_state, (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
pass
class Protocol(InstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = META_LOGGER
def __init__(self, driver_event):
"""
Protocol constructor.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
InstrumentProtocol.__init__(self, driver_event)
# Build protocol state machine.
self._protocol_fsm = InstrumentFSM(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_AUTOSAMPLE, self._handler_command_start_autosample),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_start_poll),
(ProtocolEvent.CALIBRATE, self._handler_command_start_calibrate),
(ProtocolEvent.START_NAFION, self._handler_command_start_nafion_regen),
(ProtocolEvent.START_ION, self._handler_command_start_ion_regen),
(ProtocolEvent.ERROR, self._handler_error),
(ProtocolEvent.POWEROFF, self._handler_command_poweroff),
(ProtocolEvent.START_MANUAL, self._handler_command_start_manual),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_autosample_acquire_sample),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.POLL: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.ERROR: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CLEAR, self._handler_error_clear),
],
ProtocolState.CALIBRATE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP, self._handler_stop_generic),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.REGEN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_REGEN, self._handler_stop_regen),
(ProtocolEvent.REGEN_COMPLETE, self._handler_regen_complete),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_direct_access_exit),
(ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct),
(ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct),
],
ProtocolState.MANUAL_OVERRIDE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_MANUAL, self._handler_manual_override_stop),
(ProtocolEvent.GET_SLAVE_STATES, self._handler_manual_get_slave_states),
],
}
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()
# 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._slave_protocols = {}
self.initialize_scheduler()
def _add_manual_override_handlers(self):
for slave in self._slave_protocols:
for event in self._slave_protocols[slave]._cmd_dict._cmd_dict:
self._protocol_fsm.add_handler(ProtocolState.MANUAL_OVERRIDE,
event, self._build_override_handler(slave, event))
def _build_override_handler(self, slave, event):
log.debug('Building event handler for protocol: %s event: %s', slave, event)
def inner():
return None, self._slave_protocols[slave]._protocol_fsm.on_event(event)
return inner
def register_slave_protocol(self, name, protocol):
"""
@param name: slave protocol name
@param protocol: slave protocol instance
@return: None
"""
self._slave_protocols[name] = protocol
def _slave_protocol_event(self, event, *args, **kwargs):
"""
Handle an event from a slave protocol.
@param event: event to be processed
"""
name = kwargs.get('name')
if name is not None and name in self._slave_protocols:
# only react to slave protocol events once we have transitioned out of unknown
if self.get_current_state() != ProtocolState.UNKNOWN or event == DriverAsyncEvent.ERROR:
if event == DriverAsyncEvent.STATE_CHANGE:
self._react()
elif event == DriverAsyncEvent.CONFIG_CHANGE:
# do nothing, we handle this ourselves in set_param
pass
else:
# pass the event up to the instrument agent
log.debug('Passing event up to the Instrument agent: %r %r %r', event, args, kwargs)
self._driver_event(event, *args)
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
self._param_dict.add(Parameter.SAMPLE_INTERVAL, '', None, int,
type=ParameterDictType.INT,
display_name='Autosample Interval',
description='Interval between sample starts during autosample state',
units=Units.SECOND)
def _build_command_dict(self):
"""
Populate the command dictionary with commands.
"""
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE, display_name="Acquire one sample")
self._cmd_dict.add(Capability.START_AUTOSAMPLE, display_name="Start autosample")
self._cmd_dict.add(Capability.CALIBRATE, display_name="Acquire calibration samples")
self._cmd_dict.add(Capability.START_ION, display_name="Start the ion chamber regeneration sequence")
self._cmd_dict.add(Capability.START_NAFION, display_name="Start the nafion regeneration sequence")
self._cmd_dict.add(Capability.STOP_REGEN, display_name="Stop the current regeneration sequence")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE, display_name="Stop autosample")
self._cmd_dict.add(Capability.POWEROFF, display_name='Issue the "Power Off" command to the instrument')
self._cmd_dict.add(Capability.GET_SLAVE_STATES,
display_name='Report the states of the underlying slave protocols')
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, False)
def _react(self):
"""
Determine if an action is necessary based on the states of the slave protocols.
(MCU STATE, TURBO STATE, RGA STATE) : (TARGET, EVENT)
The specified event will be sent to the specified target.
"""
state = self.get_current_state()
slave_states = self._get_slave_states()
if MASSP_STATE_ERROR in slave_states:
return self._error()
if state == ProtocolState.REGEN and slave_states[0] == ProtocolState.COMMAND:
self._async_raise_fsm_event(ProtocolEvent.REGEN_COMPLETE)
# these actions are only applicable in POLL, AUTOSAMPLE or CALIBRATE states
if state not in [ProtocolState.POLL, ProtocolState.AUTOSAMPLE, ProtocolState.CALIBRATE]:
return
mps = mcu.ProtocolState
tps = turbo.ProtocolState
rps = rga.ProtocolState
action_map = {
# Waiting Turbo (RGA is off)
(mps.WAITING_TURBO, tps.COMMAND, rps.COMMAND): (TURBO, turbo.Capability.START_TURBO),
(mps.WAITING_TURBO, tps.AT_SPEED, rps.COMMAND): (MCU, mcu.Capability.START2),
# Waiting RGA
(mps.WAITING_RGA, tps.AT_SPEED, rps.SCAN): (MCU, mcu.Capability.SAMPLE),
(mps.WAITING_RGA, tps.AT_SPEED, rps.COMMAND): (RGA, rga.Capability.START_SCAN),
(mps.WAITING_RGA, tps.COMMAND, rps.SCAN): (RGA, rga.Capability.STOP_SCAN), # this should never happen!
(mps.WAITING_RGA, tps.COMMAND, rps.COMMAND): (MCU, mcu.Capability.STANDBY), # this should never happen!
# Stopping
(mps.STOPPING, tps.AT_SPEED, rps.SCAN): (RGA, rga.Capability.STOP_SCAN),
(mps.STOPPING, tps.AT_SPEED, rps.COMMAND): (TURBO, turbo.Capability.STOP_TURBO),
(mps.STOPPING, tps.COMMAND, rps.SCAN): (RGA, rga.Capability.STOP_SCAN), # this should never happen!
(mps.STOPPING, tps.COMMAND, rps.COMMAND): (MCU, mcu.Capability.STANDBY),
}
action = action_map.get(self._get_slave_states())
if action is not None:
if not isinstance(action, list):
action = [action]
# iterate through the action list, sending the events to the targets
# if we are in POLL or CALIBRATE and we see a STANDBY event, return this driver to COMMAND.
for target, command in action:
if command == mcu.Capability.SAMPLE and state == ProtocolState.CALIBRATE:
command = mcu.Capability.CALIBRATE
if command == mcu.Capability.STANDBY and state in [ProtocolState.CALIBRATE, ProtocolState.POLL]:
self._send_event_to_slave(target, command)
self._async_raise_fsm_event(ProtocolEvent.STOP)
else:
self._send_event_to_slave(target, command)
return action
def _error(self):
"""
Handle error state in slave protocol
"""
state = self.get_current_state()
slave_states = self._get_slave_states()
# if we are not currently in the error state, make the transition
if state != ProtocolState.ERROR:
self._async_raise_fsm_event(ProtocolEvent.ERROR)
mcu_state, turbo_state, rga_state = slave_states
# before we do anything else, the RGA must be stopped.
if rga_state not in [rga.ProtocolState.COMMAND, rga.ProtocolState.ERROR]:
self._send_event_to_slave(RGA, rga.ProtocolEvent.STOP_SCAN)
# RGA must be in COMMAND or ERROR, the TURBO must be stopped.
elif turbo_state not in [turbo.ProtocolState.COMMAND, turbo.ProtocolState.SPINNING_DOWN]:
self._send_event_to_slave(TURBO, turbo.ProtocolEvent.STOP_TURBO)
# Turbo and RGA must be in COMMAND or ERROR, stop the MCU
elif mcu_state != mcu.ProtocolState.COMMAND:
self._send_event_to_slave(MCU, mcu.ProtocolEvent.STANDBY)
def _got_chunk(self, chunk):
"""
This driver has no chunker...
"""
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
@param events: Events to be filtered
@return: list of events which are also capabilities
"""
return [x for x in events if Capability.has(x) or mcu.Capability.has(x)
or turbo.Capability.has(x) or rga.Capability.has(x)]
def _get_slave_states(self):
"""
Retrieve the current protocol state from each of the slave protocols and return them as a tuple.
"""
return (
self._slave_protocols[MCU].get_current_state(),
self._slave_protocols[TURBO].get_current_state(),
self._slave_protocols[RGA].get_current_state(),
)
def _send_event_to_all(self, event):
"""
Send the same event to all slave protocols.
@return: List of (name, result) for a slave protocols
"""
return [(name, slave._protocol_fsm.on_event(event)) for name, slave in self._slave_protocols.items()]
def _send_event_to_slave(self, name, event):
"""
Send an event to a specific protocol
@param name: Name of slave protocol
@param event: Event to be sent
"""
slave_protocol = self._slave_protocols.get(name)
if slave_protocol is None:
raise InstrumentProtocolException('Attempted to send event to non-existent protocol: %s' % name)
slave_protocol._async_raise_fsm_event(event)
def _send_massp_direct_access(self, command):
"""
Handle a direct access command. Driver expects direct access commands to specify the target
using the following format:
target:command
It then routes the command to the appropriate slave protocol.
@param command: Direct access command received
"""
err_string = 'Invalid command. Command must be in the following format: "target:command' + NEWLINE + \
'Valid targets are: %r' % self._slave_protocols.keys()
try:
target, command = command.split(DA_COMMAND_DELIMITER, 1)
target = target.lower()
except ValueError:
target = None
log.debug('_do_cmd_direct - target: %s command: %r', target, command)
if target not in self._slave_protocols:
self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, err_string)
else:
self._slave_protocols[target]._protocol_fsm.on_event(ProtocolEvent.EXECUTE_DIRECT, command)
def _set_params(self, *args, **kwargs):
"""
Set one or more parameters. This method will determine where the parameter actually resides and
forward it to the appropriate parameter dictionary based on name.
@param args: arglist which must contain a parameter dictionary
@throws InstrumentParameterException
"""
params = args[0]
if not isinstance(params, dict):
raise InstrumentParameterException('Attempted to set parameters with a non-dictionary argument')
_, old_config = self._handler_command_get([Parameter.ALL])
temp_dict = {}
for key in params:
split_key = key.split('_', 1)
if len(split_key) == 1:
raise InstrumentParameterException('Missing target in MASSP parameter: %s' % key)
target = split_key[0]
if not target in self._slave_protocols:
# this is a master driver parameter, set it here
if key in self._param_dict.get_keys():
log.debug("Setting value for %s to %s", key, params[key])
self._param_dict.set_value(key, params[key])
else:
raise InstrumentParameterException('Invalid key in SET action: %s' % key)
else:
temp_dict.setdefault(target, {})[key] = params[key]
# set parameters for slave protocols
for name in temp_dict:
if name in self._slave_protocols:
self._slave_protocols[name]._set_params(temp_dict[name])
else:
# how did we get here? This should never happen, but raise an exception if it does.
raise InstrumentParameterException('Invalid key(s) in SET action: %r' % temp_dict[name])
_, new_config = self._handler_command_get([Parameter.ALL])
if not new_config == old_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def set_init_params(self, config):
"""
Set initial parameters. Parameters are forwarded to the appropriate parameter dictionary based on name.
@param config: Init param config to be handled
"""
temp_dict = {}
self._startup_config = config
config = config.get(DriverConfigKey.PARAMETERS, {})
for key in config:
target, _ = key.split('_', 1)
if not target in self._slave_protocols:
# master driver parameter
log.debug("Setting init value for %s to %s", key, config[key])
self._param_dict.set_init_value(key, config[key])
else:
temp_dict.setdefault(target, {})[key] = config[key]
for name in temp_dict:
if name in self._slave_protocols:
self._slave_protocols[name].set_init_params({DriverConfigKey.PARAMETERS: temp_dict[name]})
else:
# how did we get here? This should never happen, but raise an exception if it does.
raise InstrumentParameterException('Invalid key(s) in INIT PARAMS action: %r' % temp_dict[name])
def get_config_metadata_dict(self):
"""
See base class for full description. This method is overridden to retrieve the parameter
dictionary from each slave protocol and merge them.
@return: dictionary containing driver metadata
"""
log.debug("Getting metadata dict from protocol...")
return_dict = {ConfigMetadataKey.DRIVER: self._driver_dict.generate_dict(),
ConfigMetadataKey.COMMANDS: self._cmd_dict.generate_dict(),
ConfigMetadataKey.PARAMETERS: self._param_dict.generate_dict()}
for protocol in self._slave_protocols.values():
return_dict[ConfigMetadataKey.PARAMETERS].update(protocol._param_dict.generate_dict())
return_dict[ConfigMetadataKey.COMMANDS].update(protocol._cmd_dict.generate_dict())
return return_dict
def get_resource_capabilities(self, current_state=True):
"""
Overrides base class to include slave protocol parameters
@param current_state: Boolean indicating whether we should return only the current state events
@return: (resource_commands, resource_parameters)
"""
res_cmds = self._protocol_fsm.get_events(current_state)
res_cmds = self._filter_capabilities(res_cmds)
res_params = self._param_dict.get_keys()
for protocol in self._slave_protocols.values():
res_params.extend(protocol._param_dict.get_keys())
return res_cmds, res_params
def _build_scheduler(self):
"""
Build a scheduler for periodic status updates
"""
job_name = ScheduledJob.ACQUIRE_SAMPLE
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS: self._param_dict.get(Parameter.SAMPLE_INTERVAL)
},
}
}
}
self.set_init_params(config)
self._add_scheduler_event(ScheduledJob.ACQUIRE_SAMPLE, ProtocolEvent.ACQUIRE_SAMPLE)
def _delete_scheduler(self):
"""
Remove the autosample schedule.
"""
try:
self._remove_scheduler(ScheduledJob.ACQUIRE_SAMPLE)
except KeyError:
log.info('Failed to remove scheduled job for ACQUIRE_SAMPLE')
########################################################################
# Generic handlers.
########################################################################
def _handler_generic_enter(self, *args, **kwargs):
"""
Generic enter handler, raise STATE CHANGE
"""
if self.get_current_state() != ProtocolState.UNKNOWN:
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_generic_exit(self, *args, **kwargs):
"""
Generic exit handler, do nothing.
"""
def _handler_stop_generic(self, *args, **kwargs):
"""
Generic stop method to return to COMMAND (via POLL if appropriate)
@return next_state, (next_agent_state, None)
"""
self._delete_scheduler()
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
# check if we are in autosample AND currently taking a sample, if so, move to POLL
# otherwise go back to COMMAND.
if self.get_current_state() == ProtocolState.AUTOSAMPLE:
if self._get_slave_states() != (ProtocolState.COMMAND, ProtocolState.COMMAND, ProtocolState.COMMAND):
next_state = ProtocolState.POLL
next_agent_state = ResourceAgentState.BUSY
# notify the agent we have changed states
self._async_agent_state_change(next_agent_state)
return next_state, (next_agent_state, None)
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state
@return (next_state, next_agent_state)
"""
result = self._send_event_to_all(ProtocolEvent.DISCOVER)
log.debug('_handler_unknown_discover -- send DISCOVER to all: %r', result)
target_state = (ProtocolState.COMMAND, ProtocolState.COMMAND, ProtocolState.COMMAND)
success = False
# wait for the slave protocols to discover
for attempt in xrange(5):
slave_states = self._get_slave_states()
if slave_states == target_state:
success = True
break
time.sleep(1)
if not success:
return ProtocolState.ERROR, ResourceAgentState.IDLE
return ProtocolState.COMMAND, ResourceAgentState.IDLE
########################################################################
# Command handlers.
########################################################################
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter. Query this protocol plus all slave protocols.
@param args: arglist which should contain a list of parameters to get
@return None, results
"""
params = args[0]
if not isinstance(params, list):
params = [params]
temp_dict = {}
result_dict = {}
# request is for all parameters, send get(ALL) to each protocol then combine the results.
if Parameter.ALL in params:
params = [Parameter.ALL]
_, result = self._handler_get(params, **kwargs)
result_dict.update(result)
for protocol in self._slave_protocols.values():
_, result = protocol._handler_get(params, **kwargs)
result_dict.update(result)
# request is for specific parameters. Determine which protocol should service each,
# call the appropriate _handler_get and combine the results
else:
for key in params:
log.debug('about to split: %s', key)
target, _ = key.split('_', 1)
temp_dict.setdefault(target, []).append(key)
for key in temp_dict:
if key == MASTER:
_, result = self._handler_get(params, **kwargs)
else:
if key in self._slave_protocols:
_, result = self._slave_protocols[key]._handler_get(params, **kwargs)
else:
raise InstrumentParameterException('Invalid key(s) in GET action: %r' % temp_dict[key])
result_dict.update(result)
return None, result_dict
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter, just pass through to _set_params, which knows how to set the params
in the slave protocols.
"""
self._set_params(*args, **kwargs)
return None, None
def _handler_command_start_direct(self):
"""
Start direct access
@return next_state, (next_agent_state, result)
"""
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS, None)
def _handler_command_start_autosample(self):
"""
Move my FSM to autosample and start the sample sequence by sending START1 to the MCU.
Create the scheduler to automatically start the next sample sequence
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
self._build_scheduler()
return ProtocolState.AUTOSAMPLE, (ResourceAgentState.STREAMING, None)
def _handler_command_start_poll(self):
"""
Move my FSM to poll and start the sample sequence by sending START1 to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
return ProtocolState.POLL, (ResourceAgentState.BUSY, None)
def _handler_command_start_calibrate(self):
"""
Move my FSM to calibrate and start the calibrate sequence by sending START1 to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.START1)
return ProtocolState.CALIBRATE, (ResourceAgentState.BUSY, None)
def _handler_command_start_nafion_regen(self):
"""
Move my FSM to NAFION_REGEN and send NAFION_REGEN to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.NAFREG)
return ProtocolState.REGEN, (ResourceAgentState.BUSY, None)
def _handler_command_start_ion_regen(self):
"""
Move my FSM to ION_REGEN and send ION_REGEN to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.IONREG)
return ProtocolState.REGEN, (ResourceAgentState.BUSY, None)
def _handler_command_poweroff(self):
"""
Send POWEROFF to the MCU
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.POWEROFF)
return None, (None, None)
def _handler_command_start_manual(self):
"""
Move FSM to MANUAL OVERRIDE state
@return next_state, (next_agent_state, result)
"""
return ProtocolState.MANUAL_OVERRIDE, (ResourceAgentState.COMMAND, None)
########################################################################
# Error handlers.
########################################################################
def _handler_error(self):
"""
@return next_state, next_agent_state
"""
return ProtocolState.ERROR, ResourceAgentState.BUSY
def _handler_error_clear(self):
"""
Send the CLEAR event to any slave protocol in the error state and return this driver to COMMAND
@return next_state, (next_agent_state, result)
"""
for protocol in self._slave_protocols:
state = protocol.get_current_state()
if state == MASSP_STATE_ERROR:
# do this synchronously, to allow each slave protocol to complete the CLEAR action
# before transitioning states.
protocol._protocol_fsm.on_event(ProtocolEvent.CLEAR)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_acquire_sample(self):
"""
Fire off a sample sequence while in the autosample state.
@return None, None
@throws InstrumentProtocolException
"""
slave_states = self._get_slave_states()
# verify the MCU is not already in a sequence
if slave_states[0] == ProtocolState.COMMAND:
result = self._send_event_to_slave(MCU, mcu.Capability.START1)
else:
raise InstrumentProtocolException("Attempted to acquire sample while sampling")
return None, None
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state. Forward to all slave protocols.
"""
self._send_event_to_all(ProtocolEvent.START_DIRECT)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state. Check slave protocol states and verify they all
return to COMMAND, otherwise raise InstrumentProtocolException.
@throws InstrumentProtocolException
"""
for attempt in range(DA_EXIT_MAX_RETRIES):
slave_states = self._get_slave_states()
if ProtocolState.DIRECT_ACCESS in slave_states:
log.error('Slave protocol failed to return to command, attempt %d', attempt)
time.sleep(1)
else:
return
raise InstrumentProtocolException('Slave protocol never returned to command from DA.')
def _handler_direct_access_execute_direct(self, data):
"""
Execute a direct access command. For MASSP, this means passing the actual command to the
correct slave protocol. This is handled by _send_massp_direct_access.
@return next_state, (next_agent_state, result)
"""
self._send_massp_direct_access(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return None, (None, None)
def _handler_direct_access_stop_direct(self):
"""
@return next_state, (next_agent_state, result)
"""
self._send_event_to_all(ProtocolEvent.STOP_DIRECT)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
########################################################################
# Regen handlers.
########################################################################
def _handler_stop_regen(self):
"""
Abort the current regeneration sequence, return to COMMAND
@return next_state, (next_agent_state, result)
"""
self._send_event_to_slave(MCU, mcu.Capability.STANDBY)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_regen_complete(self):
"""
Regeneration sequence is complete, return to COMMAND
@return next_state, (next_agent_state, result)
"""
self._async_agent_state_change(ResourceAgentState.COMMAND)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_manual_override_stop(self):
"""
Exit manual override. Attempt to bring the slave drivers back to COMMAND.
"""
mcu_state, turbo_state, rga_state = self._get_slave_states()
if rga_state == rga.ProtocolState.SCAN:
self._slave_protocols[RGA]._protocol_fsm.on_event(rga.Capability.STOP_SCAN)
if turbo_state == turbo.ProtocolState.AT_SPEED:
self._slave_protocols[TURBO]._protocol_fsm.on_event(turbo.Capability.STOP_TURBO)
while rga_state not in [rga.ProtocolState.COMMAND, rga.ProtocolState.ERROR] or \
turbo_state not in [turbo.ProtocolState.COMMAND, turbo.ProtocolState.ERROR]:
time.sleep(.1)
mcu_state, turbo_state, rga_state = self._get_slave_states()
if mcu_state != mcu.ProtocolState.COMMAND:
self._slave_protocols[MCU]._protocol_fsm.on_event(mcu.Capability.STANDBY)
return ProtocolState.COMMAND, (ResourceAgentState.COMMAND, None)
def _handler_manual_get_slave_states(self):
"""
Get the slave states and return them to the user
@return: next_state, (next_agent_state, result)
"""
mcu_state, turbo_state, rga_state = self._get_slave_states()
return None, (None, {MCU: mcu_state, RGA: rga_state, TURBO: turbo_state})
class SatlanticPARInstrumentProtocol(CommandResponseInstrumentProtocol):
"""The instrument protocol classes to deal with a Satlantic PAR sensor.
The protocol is a very simple command/response protocol with a few show
commands and a few set commands.
Note protocol state machine must be called "self._protocol_fsm"
@todo Check for valid state transitions and handle requests appropriately
possibly using better exceptions from the fsm.on_event() method
"""
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 execute_exit(self, *args, **kwargs):
""" Execute the exit command
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
kwargs.update({KwargsKey.COMMAND:Command.EXIT})
return self._protocol_fsm.on_event(PARProtocolEvent.COMMAND, *args, **kwargs)
def execute_exit_and_reset(self, *args, **kwargs):
""" Execute the exit and reset command
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
kwargs.update({KwargsKey.COMMAND:Command.EXIT_AND_RESET})
return self._protocol_fsm.on_event(PARProtocolEvent.COMMAND, *args, **kwargs)
def execute_poll(self, *args, **kwargs):
""" Enter manual poll mode
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
@todo fix this to handle change to poll mode from different states
"""
return self._protocol_fsm.on_event(PARProtocolEvent.POLL, *args, **kwargs)
def execute_sample(self, *args, **kwargs):
""" Try to get a sample. Should only be successful once in poll mode,
will leave the instrument in poll mode, so an exit may be required to
get back to command mode.
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
@todo fix this to handle change to poll mode from different states
"""
return self._protocol_fsm.on_event(PARProtocolEvent.SAMPLE, *args, **kwargs)
def execute_reset(self, *args, **kwargs):
""" Execute the reset command
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
return self._protocol_fsm.on_event(PARProtocolEvent.RESET, *args, **kwargs)
def execute_break(self, *args, **kwargs):
""" Execute the break command
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
return self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
def execute_stop(self, *args, **kwargs):
""" Execute the stop command
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
return self._protocol_fsm.on_event(PARProtocolEvent.STOP, *args, **kwargs)
def execute_stop_autosample(self, *args, **kwargs):
"""
Leave autosample mode, back to command mode
@param timeout=timeout Optional command timeout.
@throws InstrumentTimeoutException if could not wake device or no response.
@throws InstrumentProtocolException if stop command not recognized.
@throws InstrumentStateException if command not allowed in current state.
"""
# Forward event and argument to the protocol FSM.
return self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
def execute_init_device(self, *args, **kwargs):
""" Transition the device to a know, ready-to-respond, command prompt
and bring the state machine from unknown state to a known one
(hopefully COMMAND mode)
@retval None if nothing was done, otherwise result of FSM event handle
@throws InstrumentProtocolException On invalid command or missing
"""
return self._protocol_fsm.on_event(PARProtocolEvent.INITIALIZE, *args, **kwargs)
def get_config(self, *args, **kwargs):
""" Get the entire configuration for the instrument
@param params The parameters and values to set
@retval None if nothing was done, otherwise result of FSM event handle
Should be a dict of parameters and values
@throws InstrumentProtocolException On invalid parameter
"""
config = self._protocol_fsm.on_event(PARProtocolEvent.GET, [Parameter.TELBAUD, Parameter.MAXRATE], **kwargs)
assert (isinstance(config, dict))
assert (config.has_key(Parameter.TELBAUD))
assert (config.has_key(Parameter.MAXRATE))
# Make sure we get these
while config[Parameter.TELBAUD] == InstErrorCode.HARDWARE_ERROR:
config[Parameter.TELBAUD] = self._protocol_fsm.on_event(PARProtocolEvent.GET, [Parameter.TELBAUD])
while config[Parameter.MAXRATE] == InstErrorCode.HARDWARE_ERROR:
config[Parameter.MAXRATE] = self._protocol_fsm.on_event(PARProtocolEvent.GET, [Parameter.MAXRATE])
return config
def restore_config(self, config=None, *args, **kwargs):
""" Apply a complete configuration.
In this instrument, it is simply a compound set that must contain all
of the parameters.
@throws InstrumentProtocolException on missing or bad config
"""
if (config == None):
raise InstrumentParameterException()
if ((config.has_key(Parameter.TELBAUD))
and (config.has_key(Parameter.MAXRATE))):
assert (isinstance(config, dict))
assert (len(config) == 2)
return self._protocol_fsm.on_event(PARProtocolEvent.SET, config, **kwargs)
else:
raise InstrumentParameterException()
################
# State handlers
################
def _handler_initialize(self, *args, **kwargs):
"""Handle transition from UNKNOWN state to a known one.
This method determines what state the device is in or gets it to a
known state so that the instrument and protocol are in sync.
@param params Parameters to pass to the state
@retval return (next state, result)
@todo fix this to only do break when connected
"""
next_state = None
result = None
# Break to command mode, then set next state to command mode
# If we are doing this, we must be connected
self._send_break()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.COMMAND_MODE
return (next_state, result)
def _handler_reset(self, *args, **kwargs):
"""Handle reset condition for all states.
@param params Parameters to pass to the state
@retval return (next state, result)
"""
next_state = None
self._send_reset()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.AUTOSAMPLE_MODE
return (next_state, None)
def _handler_autosample_enter_state(self, *args, **kwargs):
""" Handle PARProtocolState.AUTOSAMPLE_MODE PARProtocolEvent.ENTER
@param params Parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For hardware error
"""
next_state = None
result = None
if not self._confirm_autosample_mode:
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Not in the correct mode!")
return (next_state, result)
def _handler_autosample_break(self, *args, **kwargs):
"""Handle PARProtocolState.AUTOSAMPLE_MODE PARProtocolEvent.BREAK
@param params Parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For hardware error
"""
next_state = None
result = None
try:
self._send_break()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.COMMAND_MODE
except InstrumentException:
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Could not break from autosample!")
return (next_state, result)
def _handler_autosample_stop(self, *args, **kwargs):
"""Handle PARProtocolState.AUTOSAMPLE_MODE PARProtocolEvent.STOP
@param params Parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For hardware error
"""
next_state = None
try:
self._send_stop()
# Give the instrument a bit to keep up. 1 sec is not enough!
time.sleep(5)
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.POLL_MODE
except InstrumentException:
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Could not stop autosample!")
return (next_state, None)
def _handler_autosample_command(self, *args, **kwargs):
"""Handle PARProtocolState.AUTOSAMPLE_MODE PARProtocolEvent.COMMAND transition
@param params Dict with "command" enum and "params" of the parameters to
pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
cmd = kwargs.get(KwargsKey.COMMAND, None)
if (cmd == Command.BREAK):
result = self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
elif (cmd == Command.STOP):
result = self._protocol_fsm.on_event(PARProtocolEvent.STOP, *args, **kwargs)
elif (cmd == Command.RESET):
result = self._protocol_fsm.on_event(PARProtocolEvent.RESET, *args, **kwargs)
else:
raise InstrumentProtocolException(error_code=InstErrorCode.INVALID_COMMAND)
mi_logger.debug("next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_command_enter_state(self, *args, **kwargs):
"""Handle PARProtocolState.COMMAND_MODE PARProtocolEvent.ENTER_STATE transition
@param params Dict with "command" enum and "params" of the parameters to
pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter'
@todo Make this only active when we are connected.
"""
# Just update parameters, no state change
try:
# dont do anything for now
# pass
self._update_params(timeout=3)
except InstrumentTimeoutException:
#squelch the error if we timeout...best effort update
pass
return (None, None)
def _handler_command_command(self, *args, **kwargs):
"""Handle PARProtocolState.COMMAND_MODE PARProtocolEvent.COMMAND transition
@param params Dict with "command" enum and "params" of the parameters to
pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter'
@todo Fix this funky on_event logic...should just feed one on_event call
"""
next_state = None
result = None
cmd = kwargs.get(KwargsKey.COMMAND, None)
mi_logger.info("Handling command event [%s] in command mode...", cmd)
if cmd == Command.EXIT:
result = self._do_cmd_resp(Command.EXIT, None,
write_delay=self.write_delay)
if result:
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.POLL_MODE
elif cmd == Command.EXIT_AND_RESET:
self._do_cmd_no_resp(Command.EXIT_AND_RESET, None,
write_delay=self.write_delay)
time.sleep(RESET_DELAY)
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.AUTOSAMPLE_MODE
elif cmd == Command.SAVE:
# Sadly, instrument never gives confirmation of a save in any way
self._do_cmd_no_resp(Command.SAVE, None,
write_delay=self.write_delay)
else:
raise InstrumentProtocolException(error_code=InstErrorCode.INVALID_COMMAND)
mi_logger.debug("next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_command_poll(self, *args, **kwargs):
"""Handle getting a POLL event when in command mode. This should move
the state machine into poll mode via autosample mode
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
try:
# get into auto-sample mode guaranteed, then stop and sample
kwargs.update({KwargsKey.COMMAND:Command.EXIT_AND_RESET})
result = self._protocol_fsm.on_event(PARProtocolEvent.COMMAND, *args, **kwargs)
result = self._protocol_fsm.on_event(PARProtocolEvent.STOP, *args, **kwargs)
next_state = PARProtocolState.POLL_MODE
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
except (InstrumentTimeoutException, InstrumentProtocolException) as e:
mi_logger.debug("Caught exception while moving to manual poll mode: %s", e)
if self._protocol_fsm.current_state == PARProtocolState.AUTOSAMPLE_MODE:
result = self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
raise e
elif (self._protocol_fsm.current_state == PARProtocolState.POLL_MODE):
result = self._protocol_fsm.on_event(PARProtocolEvent.AUTOSAMPLE, *args, **kwargs)
result = self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
raise e
return (next_state, result)
def _handler_command_autosample(self, params=None, *args, **kwargs):
"""Handle getting an autosample event when in command mode
@param params List of the parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
result = self.execute_exit_and_reset(*args, **kwargs)
return (next_state, result)
def _handler_command_get(self, params=None, *args, **kwargs):
"""Handle getting data from command mode
@param params List of the parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
result_vals = {}
if (params == DriverParameter.ALL):
params = [Parameter.TELBAUD, Parameter.MAXRATE]
if ((params == None) or (not isinstance(params, list))):
raise InstrumentParameterException()
for param in params:
if not Parameter.has(param):
raise InstrumentParameterException()
break
result_vals[param] = self._do_cmd_resp(Command.GET, param,
expected_prompt=Prompt.COMMAND,
write_delay=self.write_delay)
result = result_vals
mi_logger.debug("Get finished, next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_command_set(self, params, *args, **kwargs):
"""Handle setting data from command mode
@param params Dict of the parameters and values to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid parameter
"""
next_state = None
result = None
result_vals = {}
if ((params == None) or (not isinstance(params, dict))):
raise InstrumentParameterException()
name_values = params
for key in name_values.keys():
if not Parameter.has(key):
raise InstrumentParameterException()
break
result_vals[key] = self._do_cmd_resp(Command.SET, key, name_values[key],
expected_prompt=Prompt.COMMAND,
write_delay=self.write_delay)
# Populate with actual value instead of success flag
if result_vals[key]:
result_vals[key] = name_values[key]
self._update_params()
result = self._do_cmd_resp(Command.SAVE, None, None,
expected_prompt=Prompt.COMMAND,
write_delay=self.write_delay)
"""@todo raise a parameter error if there was a bad value"""
result = result_vals
mi_logger.debug("next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_poll_enter_state(self, *args, **kwargs):
""" Handle PARProtocolState.POLL_MODE PARProtocolEvent.ENTER
@param params Parameters to pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For hardware error
"""
next_state = None
result = None
if not self._confirm_poll_mode:
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Not in the correct mode!")
return (next_state, result)
def _handler_poll_sample(self, *args, **kwargs):
"""Handle PARProtocolState.POLL_MODE PARProtocolEvent.SAMPLE
@retval return (next state, result)
@throw InstrumentProtocolException For invalid command
"""
next_state = None
result = None
# This sometimes takes a few seconds, so stall after our sample cmd
# and before the read/parse
delay = self.write_delay + 2
result = self._do_cmd_resp(Command.SAMPLE, None,
expected_prompt=Prompt.NULL,
write_delay=delay)
mi_logger.debug("Polled sample: %s", result)
if (result):
self._driver_event(DriverAsyncEvent.SAMPLE, result)
return (next_state, result)
def _handler_poll_break(self, *args, **kwargs):
"""Handle PARProtocolState.POLL_MODE, PARProtocolEvent.BREAK
@retval return (next state, result)
@throw InstrumentProtocolException For invalid command
"""
next_state = None
result = None
mi_logger.debug("Breaking from poll mode...")
try:
self._send_break()
next_state = PARProtocolState.COMMAND_MODE
except InstrumentException:
raise InstrumentProtocolException(error_code=InstErrorCode.HARDWARE_ERROR,
msg="Could not interrupt hardware!")
return (next_state, result)
def _handler_poll_autosample(self, *args, **kwargs):
"""Handle PARProtocolState.POLL_MODE PARProtocolEvent.AUTOSAMPLE
@retval return (success/fail code, next state, result)
"""
next_state = None
self._do_cmd_no_resp(Command.AUTOSAMPLE, None)
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
next_state = PARProtocolState.AUTOSAMPLE_MODE
return (next_state, None)
def _handler_poll_command(self, *args, **kwargs):
"""Handle PARProtocolState.POLL_MODE PARProtocolEvent.COMMAND transition
@param params Dict with "command" enum and "params" of the parameters to
pass to the state
@retval return (next state, result)
@throw InstrumentProtocolException For invalid command
"""
next_state = None
result = None
cmd = kwargs.get(KwargsKey.COMMAND, None)
if (cmd == Command.AUTOSAMPLE):
result = self._protocol_fsm.on_event(PARProtocolEvent.AUTOSAMPLE, *args, **kwargs)
elif (cmd == Command.RESET):
result = self._protocol_fsm.on_event(PARProtocolEvent.RESET, *args, **kwargs)
elif (cmd == Command.SAMPLE):
result = self._protocol_fsm.on_event(PARProtocolEvent.SAMPLE, *args, **kwargs)
elif (cmd == Command.BREAK):
result = self._protocol_fsm.on_event(PARProtocolEvent.BREAK, *args, **kwargs)
else:
raise InstrumentProtocolException(error_code=InstErrorCode.INVALID_COMMAND)
mi_logger.debug("next: %s, result: %s", next_state, result)
return (next_state, result)
def _handler_noop(self, *args, **kwargs):
""" Do nothing as a handler...for when an event is acceptable, but
not worth acting on.
"""
return (None, None)
###################################################################
# Builders
###################################################################
def _build_set_command(self, cmd, param, value):
"""
Build a command that is ready to send out to the instrument. Checks for
valid parameter name, only handles one value at a time.
@param cmd The command...in this case, Command.SET
@param param The name of the parameter to set. From Parameter enum
@param value The value to set for that parameter
@retval Returns string ready for sending to instrument
"""
# Check to make sure all parameters are valid up front
assert Parameter.has(param)
assert cmd == Command.SET
return "%s %s %s%s" % (Command.SET, param,
self._param_dict.format(param, value),
self.eoln)
def _build_param_fetch_command(self, cmd, param):
"""
Build a command to fetch the desired argument.
@param cmd The command being used (Command.GET in this case)
@param param The name of the parameter to fetch
@retval Returns string ready for sending to instrument
"""
assert Parameter.has(param)
return "%s %s%s" % (Command.GET, param, self.eoln)
def _build_exec_command(self, cmd, *args):
"""
Builder for simple commands
@param cmd The command being used (Command.GET in this case)
@param args Unused arguments
@retval Returns string ready for sending to instrument
"""
return "%s%s" % (cmd, self.eoln)
def _build_control_command(self, cmd, *args):
""" Send a single control char command
@param cmd The control character to send
@param args Unused arguments
@retval The string with the complete command
"""
return "%c" % (cmd)
def _build_multi_control_command(self, cmd, *args):
""" Send a quick series of control char command
@param cmd The control character to send
@param args Unused arguments
@retval The string with the complete command
"""
return "%c%c%c%c%c%c%c" % (cmd, cmd, cmd, cmd, cmd, cmd, cmd)
##################################################################
# Response parsers
##################################################################
def _parse_set_response(self, response, prompt):
"""Determine if a set was successful or not
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
"""
if prompt == Prompt.COMMAND:
return True
elif response == PARProtocolError.INVALID_COMMAND:
return InstErrorCode.SET_DEVICE_ERR
else:
return InstErrorCode.HARDWARE_ERROR
def _parse_get_response(self, response, prompt):
""" Parse the response from the instrument for a couple of different
query responses.
@param response The response string from the instrument
@param prompt The prompt received from the instrument
@retval return The numerical value of the parameter in the known units
@todo Fill this in
"""
# should end with the response, an eoln, and a prompt
split_response = response.split(self.eoln)
if (len(split_response) < 2) or (split_response[-1] != Prompt.COMMAND):
return InstErrorCode.HARDWARE_ERROR
name = self._param_dict.update(split_response[-2])
return self._param_dict.get(name)
def _parse_silent_response(self, response, prompt):
"""Parse a silent response
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval return An InstErrorCode value
"""
mi_logger.debug("Parsing silent response of [%s] with prompt [%s]",
response, prompt)
if ((response == "") or (response == prompt)) and \
((prompt == Prompt.NULL) or (prompt == Prompt.COMMAND)):
return InstErrorCode.OK
else:
return InstErrorCode.HARDWARE_ERROR
def _parse_header_response(self, response, prompt):
""" Parse what the header looks like to make sure if came up.
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval return An InstErrorCode value
"""
mi_logger.debug("Parsing header response of [%s] with prompt [%s]",
response, prompt)
if header_regex.search(response):
return InstErrorCode.OK
else:
return InstErrorCode.HARDWARE_ERROR
def _parse_reset_response(self, response, prompt):
""" Parse the results of a reset
This is basically a header followed by some initialization lines
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval return An InstErrorCode value
"""
mi_logger.debug("Parsing reset response of [%s] with prompt [%s]",
response, prompt)
lines = response.split(self.eoln)
for line in lines:
if init_regex.search(line):
return InstErrorCode.OK
# else
return InstErrorCode.HARDWARE_ERROR
def _parse_cmd_prompt_response(self, response, prompt):
"""Parse a command prompt response
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval return An InstErrorCode value
"""
mi_logger.debug("Parsing command prompt response of [%s] with prompt [%s]",
response, prompt)
if (response == Prompt.COMMAND):
# yank out the command we sent, split at the self.eoln
split_result = response.split(self.eoln, 1)
if len(split_result) > 1:
response = split_result[1]
return InstErrorCode.OK
else:
return InstErrorCode.HARDWARE_ERROR
def _parse_sample_poll_response(self, response, prompt):
"""Parse a sample poll response
@param response What was sent back from the command that was sent
@param prompt The prompt that was returned from the device
@retval return The sample string
"""
mi_logger.debug("Parsing sample poll response of [%s] with prompt [%s]",
response, prompt)
if (prompt == ""):
# strip the eoln, check for regex, report data,
# and leave it in the buffer for return via execute_poll
if self.eoln in response:
lines = response.split(self.eoln)
for line in lines:
if sample_regex.match(line):
# In poll mode, we only care about the first response, right?
return line
else:
return ""
elif sample_regex.match(response):
return response
else:
return ""
else:
return InstErrorCode.HARDWARE_ERROR
###################################################################
# Helpers
###################################################################
def _wakeup(self, timeout):
"""There is no wakeup sequence for this instrument"""
pass
def _update_params(self, *args, **kwargs):
"""Fetch the parameters from the device, and update the param dict.
@param args Unused
@param kwargs Takes timeout value
@throws InstrumentProtocolException
@throws InstrumentTimeoutException
"""
mi_logger.debug("Updating parameter dict")
old_config = self._param_dict.get_config()
self.get_config()
new_config = self._param_dict.get_config()
if (new_config != old_config) and (None not in old_config.values()):
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def _send_reset(self, timeout=10):
"""Send a reset command out to the device
@throw InstrumentTimeoutException
@throw InstrumentProtocolException
@todo handle errors correctly here, deal with repeats at high sample rate
"""
write_delay = 0.2
mi_logger.debug("Sending reset chars")
if self._protocol_fsm.get_current_state() == PARProtocolState.COMMAND_MODE:
return InstErrorCode.OK
while True:
self._do_cmd_no_resp(Command.RESET, timeout=timeout,
write_delay=write_delay)
time.sleep(RESET_DELAY)
if self._confirm_autosample_mode():
break
def _send_stop(self, timeout=10):
"""Send a stop command out to the device
@retval return InstErrorCode.OK for success or no-op, error code on
failure
@throw InstrumentTimeoutException
@throw InstrumentProtocolException
@todo handle errors correctly here, deal with repeats at high sample rate
"""
write_delay = 0.2
mi_logger.debug("Sending stop chars")
if self._protocol_fsm.get_current_state() == PARProtocolState.COMMAND_MODE:
return InstErrorCode.OK
while True:
self._do_cmd_no_resp(Command.STOP, timeout=timeout,
write_delay=write_delay)
if self._confirm_poll_mode():
return
def _send_break(self, timeout=10):
"""Send a blind break command to the device, confirm command mode after
@throw InstrumentTimeoutException
@throw InstrumentProtocolException
@todo handle errors correctly here, deal with repeats at high sample rate
"""
write_delay = 0.2
mi_logger.debug("Sending break char")
# do the magic sequence of sending lots of characters really fast...
# but not too fast
if self._protocol_fsm.get_current_state() == PARProtocolState.COMMAND_MODE:
return
while True:
self._do_cmd_no_resp(Command.BREAK, timeout=timeout,
expected_prompt=Prompt.COMMAND,
write_delay=write_delay)
if self._confirm_command_mode():
break
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 _confirm_autosample_mode(self):
"""Confirm we are in autosample mode
This is done by waiting for a sample to come in, and confirming that
it does or does not.
@retval True if in autosample mode, False if not
"""
mi_logger.debug("Confirming autosample mode...")
# timestamp now,
start_time = self._last_data_timestamp
# wait a sample period,
# @todo get this working when _update_params is happening right (only when connected)
#time_between_samples = (1/self._param_dict.get_config()[Parameter.MAXRATE])+1
time_between_samples = 2
time.sleep(time_between_samples)
end_time = self._last_data_timestamp
return not (end_time == start_time)
def _confirm_poll_mode(self):
"""Confirm we are in poll mode by waiting for things not to happen.
Time depends on max data rate
@retval True if in poll mode, False if not
"""
mi_logger.debug("Confirming poll mode...")
autosample_mode = self._confirm_autosample_mode()
cmd_mode = self._confirm_command_mode()
if (not autosample_mode) and (not cmd_mode):
mi_logger.debug("Confirmed in poll mode")
return True
else:
mi_logger.debug("Confirmed NOT in poll mode")
return False
def _confirm_command_mode(self):
"""Confirm we are in command mode
This is done by issuing a bogus command and getting a prompt
@retval True if in command mode, False if not
"""
mi_logger.debug("Confirming command mode...")
try:
# suspend our belief that we are in another state, and behave
# as if we are in command mode long enough to confirm or deny it
self._do_cmd_no_resp(Command.SAMPLE, timeout=2,
expected_prompt=Prompt.COMMAND)
(prompt, result) = self._get_response(timeout=2,
expected_prompt=Prompt.COMMAND)
except InstrumentTimeoutException:
# If we timed out, its because we never got our $ prompt and must
# not be in command mode (probably got a data value in POLL mode)
mi_logger.debug("Confirmed NOT in command mode via timeout")
return False
except InstrumentProtocolException:
mi_logger.debug("Confirmed NOT in command mode via protocol exception")
return False
# made it this far
mi_logger.debug("Confirmed in command mode")
time.sleep(0.5)
return True
class THSPHProtocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
SERIES_A = 'A'
SERIES_B = 'B'
SERIES_C = 'C'
GET_SAMPLE_SERIES_A = 'aH*' # Gets data sample from ADC for series A
GET_SAMPLE_SERIES_B = 'bH*' # Gets data sample from ADC for series B
GET_SAMPLE_SERIES_C = 'cH*' # Gets data sample from ADC for series C
# THSPH commands for instrument series A, B and C
THSPH_COMMANDS = {
SERIES_A: {
Command.GET_SAMPLE: GET_SAMPLE_SERIES_A
},
SERIES_B: {
Command.GET_SAMPLE: GET_SAMPLE_SERIES_B
},
SERIES_C: {
Command.GET_SAMPLE: GET_SAMPLE_SERIES_C
},
}
__metaclass__ = get_logging_metaclass(log_level='debug')
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
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
matchers = []
return_list = []
matchers.append(THSPHParticle.regex_compiled())
for matcher in matchers:
log.trace('matcher: %r raw_data: %r', matcher.pattern, raw_data)
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if not self._extract_sample(THSPHParticle,
THSPHParticle.regex_compiled(), chunk,
timestamp):
raise InstrumentProtocolException("Unhandled chunk")
def _build_driver_dict(self):
"""
Populate the driver dictionary with options
"""
self._driver_dict.add(DriverDictKey.VENDOR_SW_COMPATIBLE, True)
def _build_command_dict(self):
"""
Populate the command dictionary with command.
"""
self._cmd_dict.add(Capability.START_AUTOSAMPLE,
display_name="Start Autosample")
self._cmd_dict.add(Capability.STOP_AUTOSAMPLE,
display_name="Stop Autosample")
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE,
display_name="Acquire Sample")
self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
def _build_param_dict(self):
"""
Populate the parameter dictionary with THSPH parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(Parameter.INTERVAL,
r'Auto Polled Interval = (\d+)',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
units=Units.SECOND,
display_name="Polled Interval",
visibility=ParameterDictVisibility.READ_WRITE,
startup_param=True,
direct_access=False,
default_value=5)
self._param_dict.add(
Parameter.INSTRUMENT_SERIES,
r'Instrument Series = ([A-C])',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.STRING,
display_name="Instrument Series",
description='Defines instance of instrument series [A, B, C].',
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
direct_access=False,
default_value='A')
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown State handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; Change next state to be COMMAND state.
@retval (next_state, result).
"""
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.IDLE
return next_state, next_agent_state
########################################################################
# Command State handlers.
########################################################################
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
next_agent_state = None
result = None
self._do_cmd_no_resp(Command.GET_SAMPLE, timeout=TIMEOUT)
return next_state, (next_agent_state, result)
def _handler_command_enter(self, *args, **kwargs):
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._init_params()
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
pass
def _handler_command_get(self, *args, **kwargs):
"""
Get device parameters from the parameter dict. First we set a baseline timestamp
that all data expirations will be calculated against. Then we try to get parameter
value. If we catch an expired parameter then we will update all parameters and get
values using the original baseline time that we set at the beginning of this method.
Assuming our _update_params is updating all parameter values properly then we can
ensure that all data will be fresh. Nobody likes stale data!
@param args[0] list of parameters to retrieve, or DriverParameter.ALL.
"""
return self._handler_get(*args, **kwargs)
def _handler_command_set(self, *args, **kwargs):
"""
Perform a set command.
@param args[0] parameter : value dict.
@retval (next_state, result) tuple, (None, None).
@throws InstrumentParameterException if missing set parameters, if set parameters not ALL and
not a dict, or if parameter can't be properly formatted.
"""
next_state = None
result = None
startup = False
# Retrieve required parameter.
# Raise if no parameter provided, or not a dict.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException(
'Set command requires a parameter dict.')
if not isinstance(params, dict):
raise InstrumentParameterException('Set parameters not a dict.')
try:
startup = args[1]
except IndexError:
pass
old_config = self._param_dict.get_config()
self._set_params(params, startup)
new_config = self._param_dict.get_config()
if old_config != new_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
return next_state, result
def _set_params(self, *args, **kwargs):
"""
Set various parameters internally to the driver. No issuing commands to the
instrument needed for this driver.
"""
try:
params = args[0]
except IndexError:
raise InstrumentParameterException(
'Set command requires a parameter dict.')
#list can be null, like in the case of direct access params, in this case do nothing
if not params:
return
# Do a range check before we start all sets
for (key, val) in params.iteritems():
if key == Parameter.INTERVAL and not (0 < val < 601):
log.debug("Auto Sample Interval not in 1 to 600 range ")
raise InstrumentParameterException(
"sample interval out of range [1, 600]")
if key == Parameter.INSTRUMENT_SERIES:
if val not in 'ABC':
log.debug("Instrument Series is not A, B or C ")
raise InstrumentParameterException(
"Instrument Series is not invalid ")
else:
self._get_sample_cmd = self.THSPH_COMMANDS[val][
Command.GET_SAMPLE]
log.debug('key = (%s), value = (%s)' % (key, val))
self._param_dict.set_value(key, val)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Switch into autosample mode.
@retval (next_state, result) tuple, (ProtocolState.AUTOSAMPLE,
(next_agent_state, None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
"""
result = None
next_state = ProtocolState.AUTOSAMPLE
next_agent_state = ResourceAgentState.STREAMING
return next_state, (next_agent_state, result)
def _handler_command_start_direct(self):
"""
Start direct access
"""
return ProtocolState.DIRECT_ACCESS, (ResourceAgentState.DIRECT_ACCESS,
None)
#######################################################################
# Autosample State handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state Because this is an instrument that must be
polled we need to ensure the scheduler is added when we are in an
autosample state. This scheduler raises events to poll the
instrument for data.
@retval next_state, (next_agent_state, result)
"""
self._init_params()
self._setup_autosample_config()
# Schedule auto sample task
self._add_scheduler_event(ScheduledJob.AUTO_SAMPLE,
ProtocolEvent.SCHEDULE_ACQUIRE_SAMPLE)
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
return None, (None, None)
def _setup_autosample_config(self):
"""
Set up auto sample configuration and add it to the scheduler.
"""
# Start the scheduler to poll the instrument for
# data every sample interval seconds
job_name = ScheduledJob.AUTO_SAMPLE
polled_interval = self._param_dict.get_config_value(Parameter.INTERVAL)
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE:
TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS: polled_interval
}
}
}
}
self.set_init_params(config)
# Start the scheduler if it is not running
if not self._scheduler:
self.initialize_scheduler()
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit auto sample state. Remove the auto sample task
"""
next_state = None
next_agent_state = None
result = None
return next_state, (next_agent_state, result)
def _handler_autosample_stop_autosample(self, *args, **kwargs):
"""
Remove the auto sample task. Exit Auto sample state
"""
result = None
# Stop the Auto Poll scheduling
self._remove_scheduler(ScheduledJob.AUTO_SAMPLE)
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
Execute direct command
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return next_state, (next_agent_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return next_state, (next_agent_state, result)
def _build_simple_command(self, cmd, *args):
"""
Build handler for basic THSPH commands.
@param cmd the simple ooicore command to format.
@retval The command to be sent to the device.
"""
instrument_series = self._param_dict.get(Parameter.INSTRUMENT_SERIES)
if cmd == Command.GET_SAMPLE:
instrument_cmd = self.THSPH_COMMANDS[instrument_series][
Command.GET_SAMPLE]
else:
raise InstrumentException('Unknown THSPH driver command %s' % cmd)
return "%s%s" % (instrument_cmd, NEWLINE)
def _wakeup(self, wakeup_timeout=0, response_timeout=0):
"""
There is no wakeup for this instrument. Do nothing.
@param wakeup_timeout The timeout to wake the device.
@param response_timeout The time to look for response to a wakeup attempt.
"""
pass
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.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.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)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
"""
CHECKSUM_PLUS_PAD = 3 #three bytes for these items
global brute_force_search
sieve_matchers = [SAMPLE_REGEX_MATCHER,
STATUS_REGEX_MATCHER]
pattern = pack('4B',0xff,0x00,0xff,0x00)
return_list = []
for matcher in sieve_matchers:
if matcher == SAMPLE_REGEX_MATCHER:
start_pos_list = brute_force_search(pattern, raw_data)
for start_pos in start_pos_list:
if start_pos+5 < len(raw_data):
expected_length = CHECKSUM_PLUS_PAD + ord(raw_data[start_pos+4])*256 + ord(raw_data[start_pos+5])
if start_pos+expected_length <= len(raw_data):
return_list.append((start_pos, start_pos+expected_length))
elif matcher == STATUS_REGEX_MATCHER:
for match in re.finditer(matcher,raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
def _got_chunk(self, chunk, timestamp):
"""
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if(self._extract_sample(OPTAA_StatusDataParticle, STATUS_REGEX_MATCHER, chunk, timestamp)):
log.debug("successful extract_sample for STATUS")
return
if(self._extract_sample(OPTAA_SampleDataParticle, SAMPLE_REGEX_MATCHER, chunk, timestamp)):
log.debug("successful extract_sample for SAMPLE")
return
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can be COMMAND or AUTOSAMPLE.
@retval (next_state, result), (ProtocolState.COMMAND or
State.AUTOSAMPLE, None) if successful.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentStateException if the device response does not correspond to
an expected state.
"""
timeout = kwargs.get('timeout', TIMEOUT)
next_state = None
result = None
current_state = self._protocol_fsm.get_current_state()
log.debug("///////////////////// in handler_unknown_discover: current state is ",current_state)
if current_state == ProtocolState.AUTOSAMPLE:
result = ResourceAgentState.STREAMING
elif current_state == ProtocolState.COMMAND:
result = ResourceAgentState.IDLE
elif current_state == ProtocolState.UNKNOWN:
# Wakeup the device with timeout if passed.
delay = 0.5
log.debug("############## TIMEOUT = " + str(timeout))
prompt = self._wakeup(timeout=timeout, delay=delay)
prompt = self._wakeup(timeout)
logging = self._is_logging(timeout=timeout)
if logging == True:
next_state = ProtocolState.AUTOSAMPLE
result = ResourceAgentState.STREAMING
elif logging == False:
next_state = ProtocolState.COMMAND
result = ResourceAgentState.IDLE
else:
raise InstrumentStateException('Unknown state.')
print "//////////////////// on exit from handler_unknown_discover: next_state is ",next_state
return (next_state, result)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
#self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_get(self, *args, **kwargs):
"""
Get parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_set(self, *args, **kwargs):
"""
Set parameter
"""
next_state = None
result = None
return (next_state, result)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_start_direct(self):
"""
Start direct access
"""
next_state = ProtocolState.DIRECT_ACCESS
next_agent_state = ResourceAgentState.DIRECT_ACCESS
result = None
log.debug("_handler_command_start_direct: entering DA mode")
return (next_state, (next_agent_state, result))
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
next_agent_state = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, (next_agent_state, result))
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = ProtocolState.COMMAND
next_agent_state = ResourceAgentState.COMMAND
return (next_state, (next_agent_state, result))
class SingleConnectionInstrumentDriver(InstrumentDriver):
"""
Base class for instrument drivers with a single device connection.
Provides connenction state logic for single connection drivers. This is
the base class for the majority of driver implementation classes.
"""
def __init__(self, event_callback):
"""
Constructor for singly connected instrument drivers.
@param event_callback Callback to the driver process to send asynchronous
driver events back to the agent.
"""
InstrumentDriver.__init__(self, event_callback)
# The only and only instrument connection.
# Exists in the connected state.
self._connection = None
# The one and only instrument protocol.
self._protocol = None
# Build connection state machine.
self._connection_fsm = InstrumentFSM(DriverConnectionState,
DriverEvent,
DriverEvent.ENTER,
DriverEvent.EXIT)
# Add handlers for all events.
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.ENTER, self._handler_unconfigured_enter)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.EXIT, self._handler_unconfigured_exit)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.INITIALIZE, self._handler_unconfigured_initialize)
self._connection_fsm.add_handler(DriverConnectionState.UNCONFIGURED, DriverEvent.CONFIGURE, self._handler_unconfigured_configure)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.ENTER, self._handler_disconnected_enter)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.EXIT, self._handler_disconnected_exit)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.INITIALIZE, self._handler_disconnected_initialize)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.CONFIGURE, self._handler_disconnected_configure)
self._connection_fsm.add_handler(DriverConnectionState.DISCONNECTED, DriverEvent.CONNECT, self._handler_disconnected_connect)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.ENTER, self._handler_connected_enter)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.EXIT, self._handler_connected_exit)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.DISCONNECT, self._handler_connected_disconnect)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.CONNECTION_LOST, self._handler_connected_connection_lost)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.DISCOVER, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.GET, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.SET, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.EXECUTE, self._handler_connected_protocol_event)
self._connection_fsm.add_handler(DriverConnectionState.CONNECTED, DriverEvent.FORCE_STATE, self._handler_connected_protocol_event)
# Start state machine.
self._connection_fsm.start(DriverConnectionState.UNCONFIGURED)
#############################################################
# Device connection interface.
#############################################################
def initialize(self, *args, **kwargs):
"""
Initialize driver connection, bringing communications parameters
into unconfigured state (no connection object).
@raises InstrumentStateException if command not allowed in current state
"""
# Forward event and argument to the connection FSM.
return self._connection_fsm.on_event(DriverEvent.INITIALIZE, *args, **kwargs)
def configure(self, *args, **kwargs):
"""
Configure the driver for communications with the device via
port agent / logger (valid but unconnected connection object).
@param arg[0] comms config dict.
@raises InstrumentStateException if command not allowed in current state
@throws InstrumentParameterException if missing comms or invalid config dict.
"""
# Forward event and argument to the connection FSM.
return self._connection_fsm.on_event(DriverEvent.CONFIGURE, *args, **kwargs)
def connect(self, *args, **kwargs):
"""
Establish communications with the device via port agent / logger
(connected connection object).
@raises InstrumentStateException if command not allowed in current state
@throws InstrumentConnectionException if the connection failed.
"""
# Forward event and argument to the connection FSM.
return self._connection_fsm.on_event(DriverEvent.CONNECT, *args, **kwargs)
def disconnect(self, *args, **kwargs):
"""
Disconnect from device via port agent / logger.
@raises InstrumentStateException if command not allowed in current state
"""
# Forward event and argument to the connection FSM.
return self._connection_fsm.on_event(DriverEvent.DISCONNECT, *args, **kwargs)
#############################################################
# Commande and control interface.
#############################################################
def discover_state(self, *args, **kwargs):
"""
Determine initial state upon establishing communications.
@param timeout=timeout Optional command timeout.
@retval Current device state.
@raises InstrumentTimeoutException if could not wake device.
@raises InstrumentStateException if command not allowed in current state or if
device state not recognized.
@raises NotImplementedException if not implemented by subclass.
"""
# Forward event and argument to the protocol FSM.
return self._connection_fsm.on_event(DriverEvent.DISCOVER, DriverEvent.DISCOVER, *args, **kwargs)
def get_resource_capabilities(self, current_state=True, *args, **kwargs):
"""
Return driver commands and parameters.
@param current_state True to retrieve commands available in current
state, otherwise reutrn all commands.
@retval list of AgentCapability objects representing the drivers
capabilities.
@raises NotImplementedException if not implemented by subclass.
"""
if self._protocol:
return self._protocol.get_resource_capabilities(current_state)
else:
return [[], []]
def get_resource_state(self, *args, **kwargs):
"""
Return the current state of the driver.
@retval str current driver state.
@raises NotImplementedException if not implemented by subclass.
"""
connection_state = self._connection_fsm.get_current_state()
if connection_state == DriverConnectionState.CONNECTED:
return self._protocol.get_current_state()
else:
return connection_state
def get_resource(self, *args, **kwargs):
"""
Retrieve device parameters.
@param args[0] DriverParameter.ALL or a list of parameters to retrive.
@retval parameter : value dict.
@raises InstrumentParameterException if missing or invalid get parameters.
@raises InstrumentStateException if command not allowed in current state
@raises NotImplementedException if not implemented by subclass.
"""
# Forward event and argument to the protocol FSM.
return self._connection_fsm.on_event(DriverEvent.GET, DriverEvent.GET, *args, **kwargs)
def set_resource(self, *args, **kwargs):
"""
Set device parameters.
@param args[0] parameter : value dict of parameters to set.
@param timeout=timeout Optional command timeout.
@raises InstrumentParameterException if missing or invalid set parameters.
@raises InstrumentTimeoutException if could not wake device or no response.
@raises InstrumentProtocolException if set command not recognized.
@raises InstrumentStateException if command not allowed in current state.
@raises NotImplementedException if not implemented by subclass.
"""
# Forward event and argument to the protocol FSM.
return self._connection_fsm.on_event(DriverEvent.SET, DriverEvent.SET, *args, **kwargs)
def execute_resource(self, resource_cmd, *args, **kwargs):
"""
Poll for a sample.
@param timeout=timeout Optional command timeout.
@ retval Device sample dict.
@raises InstrumentTimeoutException if could not wake device or no response.
@raises InstrumentProtocolException if acquire command not recognized.
@raises InstrumentStateException if command not allowed in current state.
@raises NotImplementedException if not implemented by subclass.
"""
# Forward event and argument to the protocol FSM.
return self._connection_fsm.on_event(DriverEvent.EXECUTE, resource_cmd, *args, **kwargs)
def test_force_state(self, *args, **kwargs):
"""
Force driver into a given state for the purposes of unit testing
@param state=desired_state Required desired state to change to.
@raises InstrumentParameterException if no state parameter.
@raises TestModeException if not in test mode
"""
if(not self._test_mode):
raise TestModeException();
# Get the required param
state = kwargs.get('state', None) # via kwargs
if state is None:
raise InstrumentParameterException('Missing state parameter.')
# We are mucking with internal FSM parameters which may be bad.
# The alternative was to raise an event to change the state. Dont
# know which is better.
self._protocol._protocol_fsm.current_state = state
########################################################################
# Unconfigured handlers.
########################################################################
def _handler_unconfigured_enter(self, *args, **kwargs):
"""
Enter unconfigured state.
"""
# Send state change event to agent.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unconfigured_exit(self, *args, **kwargs):
"""
Exit unconfigured state.
"""
pass
def _handler_unconfigured_initialize(self, *args, **kwargs):
"""
Initialize handler. We are already in unconfigured state, do nothing.
@retval (next_state, result) tuple, (None, None).
"""
next_state = None
result = None
return (next_state, result)
def _handler_unconfigured_configure(self, *args, **kwargs):
"""
Configure driver for device comms.
@param args[0] Communiations config dictionary.
@retval (next_state, result) tuple, (DriverConnectionState.DISCONNECTED,
None) if successful, (None, None) otherwise.
@raises InstrumentParameterException if missing or invalid param dict.
"""
next_state = None
result = None
# Get the required param dict.
config = kwargs.get('config', None) # via kwargs
# TODO use kwargs as the only mechanism
if config is None:
try:
config = args[0] # via first argument
except IndexError:
pass
if config is None:
raise InstrumentParameterException('Missing comms config parameter.')
# Verify dict and construct connection client.
self._connection = self._build_connection(config)
next_state = DriverConnectionState.DISCONNECTED
return (next_state, result)
########################################################################
# Disconnected handlers.
########################################################################
def _handler_disconnected_enter(self, *args, **kwargs):
"""
Enter disconnected state.
"""
# Send state change event to agent.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_disconnected_exit(self, *args, **kwargs):
"""
Exit disconnected state.
"""
pass
def _handler_disconnected_initialize(self, *args, **kwargs):
"""
Initialize device communications. Causes the connection parameters to
be reset.
@retval (next_state, result) tuple, (DriverConnectionState.UNCONFIGURED,
None).
"""
next_state = None
result = None
self._connection = None
next_state = DriverConnectionState.UNCONFIGURED
return (next_state, result)
def _handler_disconnected_configure(self, *args, **kwargs):
"""
Configure driver for device comms.
@param args[0] Communiations config dictionary.
@retval (next_state, result) tuple, (None, None).
@raises InstrumentParameterException if missing or invalid param dict.
"""
next_state = None
result = None
# Get required config param dict.
config = kwargs.get('config', None) # via kwargs
# TODO use kwargs as the only mechanism
if config is None:
try:
config = args[0] # via first argument
except IndexError:
pass
if config is None:
raise InstrumentParameterException('Missing comms config parameter.')
# Verify configuration dict, and update connection if possible.
self._connection = self._build_connection(config)
return (next_state, result)
def _handler_disconnected_connect(self, *args, **kwargs):
"""
Establish communications with the device via port agent / logger and
construct and intialize a protocol FSM for device interaction.
@retval (next_state, result) tuple, (DriverConnectionState.CONNECTED,
None) if successful.
@raises InstrumentConnectionException if the attempt to connect failed.
"""
next_state = None
result = None
self._build_protocol()
self._connection.init_comms(self._protocol.got_data)
self._protocol._connection = self._connection
next_state = DriverConnectionState.CONNECTED
return (next_state, result)
########################################################################
# Connected handlers.
########################################################################
def _handler_connected_enter(self, *args, **kwargs):
"""
Enter connected state.
"""
# Send state change event to agent.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_connected_exit(self, *args, **kwargs):
"""
Exit connected state.
"""
pass
def _handler_connected_disconnect(self, *args, **kwargs):
"""
Disconnect to the device via port agent / logger and destroy the
protocol FSM.
@retval (next_state, result) tuple, (DriverConnectionState.DISCONNECTED,
None) if successful.
"""
next_state = None
result = None
self._connection.stop_comms()
self._protocol = None
next_state = DriverConnectionState.DISCONNECTED
return (next_state, result)
def _handler_connected_connection_lost(self, *args, **kwargs):
"""
The device connection was lost. Stop comms, destroy protocol FSM and
revert to disconnected state.
@retval (next_state, result) tuple, (DriverConnectionState.DISCONNECTED,
None).
"""
next_state = None
result = None
self._connection.stop_comms()
self._protocol = None
next_state = DriverConnectionState.DISCONNECTED
return (next_state, result)
def _handler_connected_protocol_event(self, event, *args, **kwargs):
"""
Forward a driver command event to the protocol FSM.
@param args positional arguments to pass on.
@param kwargs keyword arguments to pass on.
@retval (next_state, result) tuple, (None, protocol result).
"""
next_state = None
result = self._protocol._protocol_fsm.on_event(event, *args, **kwargs)
return (next_state, result)
########################################################################
# Helpers.
########################################################################
def _build_connection(self, config):
"""
Constructs and returns a Connection object according to the given
configuration. The connection object is a LoggerClient instance in
this base class. Subclasses can overwrite this operation as needed.
The value returned by this operation is assigned to self._connection
and also to self._protocol._connection upon entering in the
DriverConnectionState.CONNECTED state.
@param config configuration dict
@retval a Connection instance, which will be assigned to
self._connection
@throws InstrumentParameterException Invalid configuration.
"""
if 'mock_port_agent' in config:
mock_port_agent = config['mock_port_agent']
# check for validity here...
if (mock_port_agent is not None):
return mock_port_agent
try:
addr = config['addr']
port = config['port']
if isinstance(addr, str) and isinstance(port, int) and len(addr)>0:
#return LoggerClient(addr, port)
return PortAgentClient(addr, port)
else:
raise InstrumentParameterException('Invalid comms config dict.')
except (TypeError, KeyError):
raise InstrumentParameterException('Invalid comms config dict.')
def _build_protocol(self):
"""
Construct device specific single connection protocol FSM.
Overridden in device specific subclasses.
"""
pass
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)
class SBE37Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class for SBE37 driver.
Subclasses CommandResponseInstrumentProtocol
"""
def __init__(self, prompts, newline, driver_event):
"""
SBE37Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The SBE37 newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build SBE37 protocol state machine.
self._protocol_fsm = InstrumentFSM(SBE37ProtocolState, SBE37ProtocolEvent,
SBE37ProtocolEvent.ENTER, SBE37ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.EXIT, self._handler_unknown_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.EXIT, self._handler_command_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.SET, self._handler_command_set)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.TEST, self._handler_command_test)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.ENTER, self._handler_autosample_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.EXIT, self._handler_autosample_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.ENTER, self._handler_test_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.EXIT, self._handler_test_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.RUN_TEST, self._handler_test_run_tests)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.ENTER, self._handler_direct_access_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.EXIT, self._handler_direct_access_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_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.
self._add_build_handler('ds', self._build_simple_command)
self._add_build_handler('dc', self._build_simple_command)
self._add_build_handler('ts', self._build_simple_command)
self._add_build_handler('startnow', self._build_simple_command)
self._add_build_handler('stop', self._build_simple_command)
self._add_build_handler('tc', self._build_simple_command)
self._add_build_handler('tt', self._build_simple_command)
self._add_build_handler('tp', self._build_simple_command)
self._add_build_handler('set', self._build_set_command)
# Add response handlers for device commands.
self._add_response_handler('ds', self._parse_dsdc_response)
self._add_response_handler('dc', self._parse_dsdc_response)
self._add_response_handler('ts', self._parse_ts_response)
self._add_response_handler('set', self._parse_set_response)
self._add_response_handler('tc', self._parse_test_response)
self._add_response_handler('tt', self._parse_test_response)
self._add_response_handler('tp', self._parse_test_response)
# Add sample handlers.
self._sample_pattern = r'^#? *(-?\d+\.\d+), *(-?\d+\.\d+), *(-?\d+\.\d+)'
self._sample_pattern += r'(, *(-?\d+\.\d+))?(, *(-?\d+\.\d+))?'
self._sample_pattern += r'(, *(\d+) +([a-zA-Z]+) +(\d+), *(\d+):(\d+):(\d+))?'
self._sample_pattern += r'(, *(\d+)-(\d+)-(\d+), *(\d+):(\d+):(\d+))?'
self._sample_regex = re.compile(self._sample_pattern)
# State state machine in UNKNOWN state.
self._protocol_fsm.start(SBE37ProtocolState.UNKNOWN)
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
########################################################################
# Unknown handlers.
########################################################################
def _handler_unknown_enter(self, *args, **kwargs):
"""
Enter unknown state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_unknown_exit(self, *args, **kwargs):
"""
Exit unknown state.
"""
pass
def _handler_unknown_discover(self, *args, **kwargs):
"""
Discover current state; can be COMMAND or AUTOSAMPLE.
@retval (next_state, result), (SBE37ProtocolState.COMMAND or
SBE37State.AUTOSAMPLE, None) if successful.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentStateException if the device response does not correspond to
an expected state.
"""
next_state = None
result = None
# Wakeup the device with timeout if passed.
timeout = kwargs.get('timeout', SBE37_TIMEOUT)
prompt = self._wakeup(timeout)
prompt = self._wakeup(timeout)
# Set the state to change.
# Raise if the prompt returned does not match command or autosample.
if prompt == SBE37Prompt.COMMAND:
next_state = SBE37ProtocolState.COMMAND
result = SBE37ProtocolState.COMMAND
elif prompt == SBE37Prompt.AUTOSAMPLE:
next_state = SBE37ProtocolState.AUTOSAMPLE
result = SBE37ProtocolState.AUTOSAMPLE
else:
raise InstrumentStateException('Unknown state.')
return (next_state, result)
########################################################################
# Command handlers.
########################################################################
def _handler_command_enter(self, *args, **kwargs):
"""
Enter command state.
@throws InstrumentTimeoutException if the device cannot be woken.
@throws InstrumentProtocolException if the update commands and not recognized.
"""
# Command device to update parameters and send a config change event.
self._update_params()
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_command_exit(self, *args, **kwargs):
"""
Exit command state.
"""
pass
def _handler_command_set(self, *args, **kwargs):
"""
Perform a set command.
@param args[0] parameter : value dict.
@retval (next_state, result) tuple, (None, None).
@throws InstrumentParameterException if missing set parameters, if set parameters not ALL and
not a dict, or if paramter can't be properly formatted.
@throws InstrumentTimeoutException if device cannot be woken for set command.
@throws InstrumentProtocolException if set command could not be built or misunderstood.
"""
next_state = None
result = None
# Retrieve required parameter.
# Raise if no parameter provided, or not a dict.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
if not isinstance(params, dict):
raise InstrumentParameterException('Set parameters not a dict.')
# For each key, val in the dict, issue set command to device.
# Raise if the command not understood.
else:
for (key, val) in params.iteritems():
result = self._do_cmd_resp('set', key, val, **kwargs)
self._update_params()
return (next_state, result)
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Acquire sample from SBE37.
@retval (next_state, result) tuple, (None, sample dict).
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
@throws SampleException if a sample could not be extracted from result.
"""
next_state = None
result = None
result = self._do_cmd_resp('ts', *args, **kwargs)
return (next_state, result)
def _handler_command_start_autosample(self, *args, **kwargs):
"""
Switch into autosample mode.
@retval (next_state, result) tuple, (SBE37ProtocolState.AUTOSAMPLE,
None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command could not be built or misunderstood.
"""
next_state = None
result = None
# Assure the device is transmitting.
if not self._param_dict.get(SBE37Parameter.TXREALTIME):
self._do_cmd_resp('set', SBE37Parameter.TXREALTIME, True, **kwargs)
# Issue start command and switch to autosample if successful.
self._do_cmd_no_resp('startnow', *args, **kwargs)
next_state = SBE37ProtocolState.AUTOSAMPLE
return (next_state, result)
def _handler_command_test(self, *args, **kwargs):
"""
Switch to test state to perform instrument tests.
@retval (next_state, result) tuple, (SBE37ProtocolState.TEST, None).
"""
next_state = None
result = None
next_state = SBE37ProtocolState.TEST
return (next_state, result)
def _handler_command_start_direct(self):
"""
"""
next_state = None
result = None
next_state = SBE37ProtocolState.DIRECT_ACCESS
return (next_state, result)
########################################################################
# Autosample handlers.
########################################################################
def _handler_autosample_enter(self, *args, **kwargs):
"""
Enter autosample state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
def _handler_autosample_exit(self, *args, **kwargs):
"""
Exit autosample state.
"""
pass
def _handler_autosample_stop_autosample(self, *args, **kwargs):
"""
Stop autosample and switch back to command mode.
@retval (next_state, result) tuple, (SBE37ProtocolState.COMMAND,
None) if successful.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command misunderstood or
incorrect prompt received.
"""
next_state = None
result = None
# Wake up the device, continuing until autosample prompt seen.
timeout = kwargs.get('timeout', SBE37_TIMEOUT)
self._wakeup_until(timeout, SBE37Prompt.AUTOSAMPLE)
# Issue the stop command.
self._do_cmd_resp('stop', *args, **kwargs)
# Prompt device until command prompt is seen.
self._wakeup_until(timeout, SBE37Prompt.COMMAND)
next_state = SBE37ProtocolState.COMMAND
return (next_state, result)
########################################################################
# Common handlers.
########################################################################
def _handler_command_autosample_test_get(self, *args, **kwargs):
"""
Get device parameters from the parameter dict.
@param args[0] list of parameters to retrieve, or DriverParameter.ALL.
@throws InstrumentParameterException if missing or invalid parameter.
"""
next_state = None
result = None
# Retrieve the required parameter, raise if not present.
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Get command requires a parameter list or tuple.')
# If all params requested, retrieve config.
if params == DriverParameter.ALL:
result = self._param_dict.get_config()
# If not all params, confirm a list or tuple of params to retrieve.
# Raise if not a list or tuple.
# Retireve each key in the list, raise if any are invalid.
else:
if not isinstance(params, (list, tuple)):
raise InstrumentParameterException('Get argument not a list or tuple.')
result = {}
for key in params:
try:
val = self._param_dict.get(key)
result[key] = val
except KeyError:
raise InstrumentParameterException(('%s is not a valid parameter.' % key))
return (next_state, result)
########################################################################
# Test handlers.
########################################################################
def _handler_test_enter(self, *args, **kwargs):
"""
Enter test state. Setup the secondary call to run the tests.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
# Forward the test event again to run the test handler and
# switch back to command mode afterward.
Timer(1, lambda: self._protocol_fsm.on_event(SBE37ProtocolEvent.RUN_TEST)).start()
def _handler_test_exit(self, *args, **kwargs):
"""
Exit test state.
"""
pass
def _handler_test_run_tests(self, *args, **kwargs):
"""
Run test routines and validate results.
@throws InstrumentTimeoutException if device cannot be woken for command.
@throws InstrumentProtocolException if command misunderstood or
incorrect prompt received.
"""
next_state = None
result = None
tc_pass = False
tt_pass = False
tp_pass = False
tc_result = None
tt_result = None
tp_result = None
test_result = {}
try:
tc_pass, tc_result = self._do_cmd_resp('tc', timeout=200)
tt_pass, tt_result = self._do_cmd_resp('tt', timeout=200)
tp_pass, tp_result = self._do_cmd_resp('tp', timeout=200)
except Exception as e:
test_result['exception'] = e
test_result['message'] = 'Error running instrument tests.'
finally:
test_result['cond_test'] = 'Passed' if tc_pass else 'Failed'
test_result['cond_data'] = tc_result
test_result['temp_test'] = 'Passed' if tt_pass else 'Failed'
test_result['temp_data'] = tt_result
test_result['pres_test'] = 'Passed' if tp_pass else 'Failed'
test_result['pres_data'] = tp_result
test_result['success'] = 'Passed' if (tc_pass and tt_pass and tp_pass) else 'Failed'
self._driver_event(DriverAsyncEvent.TEST_RESULT, test_result)
next_state = SBE37ProtocolState.COMMAND
return (next_state, result)
########################################################################
# Direct access handlers.
########################################################################
def _handler_direct_access_enter(self, *args, **kwargs):
"""
Enter direct access state.
"""
# Tell driver superclass to send a state change event.
# Superclass will query the state.
self._driver_event(DriverAsyncEvent.STATE_CHANGE)
self._sent_cmds = []
def _handler_direct_access_exit(self, *args, **kwargs):
"""
Exit direct access state.
"""
pass
def _handler_direct_access_execute_direct(self, data):
"""
"""
next_state = None
result = None
self._do_cmd_direct(data)
# add sent command to list for 'echo' filtering in callback
self._sent_cmds.append(data)
return (next_state, result)
def _handler_direct_access_stop_direct(self):
"""
@throw InstrumentProtocolException on invalid command
"""
next_state = None
result = None
next_state = SBE37ProtocolState.COMMAND
return (next_state, result)
########################################################################
# Private helpers.
########################################################################
def _send_wakeup(self):
"""
Send a newline to attempt to wake the SBE37 device.
"""
self._connection.send(SBE37_NEWLINE)
def _update_params(self, *args, **kwargs):
"""
Update the parameter dictionary. Wake the device then issue
display status and display calibration commands. The parameter
dict will match line output and udpate itself.
@throws InstrumentTimeoutException if device cannot be timely woken.
@throws InstrumentProtocolException if ds/dc misunderstood.
"""
# Get old param dict config.
old_config = self._param_dict.get_config()
# Issue display commands and parse results.
timeout = kwargs.get('timeout', SBE37_TIMEOUT)
self._do_cmd_resp('ds',timeout=timeout)
self._do_cmd_resp('dc',timeout=timeout)
# Get new param dict config. If it differs from the old config,
# tell driver superclass to publish a config change event.
new_config = self._param_dict.get_config()
if new_config != old_config:
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def _build_simple_command(self, cmd):
"""
Build handler for basic SBE37 commands.
@param cmd the simple sbe37 command to format.
@retval The command to be sent to the device.
"""
return cmd+SBE37_NEWLINE
def _build_set_command(self, cmd, param, val):
"""
Build handler for set commands. param=val followed by newline.
String val constructed by param dict formatting function.
@param param the parameter key to set.
@param val the parameter value to set.
@ retval The set command to be sent to the device.
@throws InstrumentProtocolException if the parameter is not valid or
if the formatting function could not accept the value passed.
"""
try:
str_val = self._param_dict.format(param, val)
set_cmd = '%s=%s' % (param, str_val)
set_cmd = set_cmd + SBE37_NEWLINE
except KeyError:
raise InstrumentParameterException('Unknown driver parameter %s' % param)
return set_cmd
def _parse_set_response(self, response, prompt):
"""
Parse handler for set command.
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if set command misunderstood.
"""
if prompt != SBE37Prompt.COMMAND:
raise InstrumentProtocolException('Set command not recognized: %s' % response)
def _parse_dsdc_response(self, response, prompt):
"""
Parse handler for dsdc commands.
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if dsdc command misunderstood.
"""
if prompt != SBE37Prompt.COMMAND:
raise InstrumentProtocolException('dsdc command not recognized: %s.' % response)
for line in response.split(SBE37_NEWLINE):
self._param_dict.update(line)
def _parse_ts_response(self, response, prompt):
"""
Response handler for ts command.
@param response command response string.
@param prompt prompt following command response.
@retval sample dictionary containig c, t, d values.
@throws InstrumentProtocolException if ts command misunderstood.
@throws InstrumentSampleException if response did not contain a sample
"""
if prompt != SBE37Prompt.COMMAND:
raise InstrumentProtocolException('ts command not recognized: %s', response)
sample = None
for line in response.split(SBE37_NEWLINE):
sample = self._extract_sample(line, True)
if sample:
break
if not sample:
raise SampleException('Response did not contain sample: %s' % repr(response))
return sample
def _parse_test_response(self, response, prompt):
"""
Do minimal checking of test outputs.
@param response command response string.
@param promnpt prompt following command response.
@retval tuple of pass/fail boolean followed by response
"""
success = False
lines = response.split()
if len(lines)>2:
data = lines[1:-1]
bad_count = 0
for item in data:
try:
float(item)
except ValueError:
bad_count += 1
if bad_count == 0:
success = True
return (success, response)
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 _extract_sample(self, line, publish=True):
"""
Extract sample from a response line if present and publish to agent.
@param line string to match for sample.
@param publsih boolean to publish sample (default True).
@retval Sample dictionary if present or None.
"""
sample = None
match = self._sample_regex.match(line)
if match:
sample = {}
sample['t'] = [float(match.group(1))]
sample['c'] = [float(match.group(2))]
sample['p'] = [float(match.group(3))]
# Driver timestamp.
sample['time'] = [time.time()]
sample['stream_name'] = 'ctd_parsed'
if self._driver_event:
self._driver_event(DriverAsyncEvent.SAMPLE, sample)
return sample
def _build_param_dict(self):
"""
Populate the parameter dictionary with SBE37 parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict.add(SBE37Parameter.OUTPUTSAL,
r'(do not )?output salinity with each sample',
lambda match : False if match.group(1) else True,
self._true_false_to_string)
self._param_dict.add(SBE37Parameter.OUTPUTSV,
r'(do not )?output sound velocity with each sample',
lambda match : False if match.group(1) else True,
self._true_false_to_string)
self._param_dict.add(SBE37Parameter.NAVG,
r'number of samples to average = (\d+)',
lambda match : int(match.group(1)),
self._int_to_string)
self._param_dict.add(SBE37Parameter.SAMPLENUM,
r'samplenumber = (\d+), free = \d+',
lambda match : int(match.group(1)),
self._int_to_string)
self._param_dict.add(SBE37Parameter.INTERVAL,
r'sample interval = (\d+) seconds',
lambda match : int(match.group(1)),
self._int_to_string)
self._param_dict.add(SBE37Parameter.STORETIME,
r'(do not )?store time with each sample',
lambda match : False if match.group(1) else True,
self._true_false_to_string)
self._param_dict.add(SBE37Parameter.TXREALTIME,
r'(do not )?transmit real-time data',
lambda match : False if match.group(1) else True,
self._true_false_to_string)
self._param_dict.add(SBE37Parameter.SYNCMODE,
r'serial sync mode (enabled|disabled)',
lambda match : False if (match.group(1)=='disabled') else True,
self._true_false_to_string)
self._param_dict.add(SBE37Parameter.SYNCWAIT,
r'wait time after serial sync sampling = (\d+) seconds',
lambda match : int(match.group(1)),
self._int_to_string)
self._param_dict.add(SBE37Parameter.TCALDATE,
r'temperature: +((\d+)-([a-zA-Z]+)-(\d+))',
lambda match : self._string_to_date(match.group(1), '%d-%b-%y'),
self._date_to_string)
self._param_dict.add(SBE37Parameter.TA0,
r' +TA0 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.TA1,
r' +TA1 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.TA2,
r' +TA2 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.TA3,
r' +TA3 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CCALDATE,
r'conductivity: +((\d+)-([a-zA-Z]+)-(\d+))',
lambda match : self._string_to_date(match.group(1), '%d-%b-%y'),
self._date_to_string)
self._param_dict.add(SBE37Parameter.CG,
r' +G = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CH,
r' +H = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CI,
r' +I = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CJ,
r' +J = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.WBOTC,
r' +WBOTC = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CTCOR,
r' +CTCOR = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.CPCOR,
r' +CPCOR = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PCALDATE,
r'pressure .+ ((\d+)-([a-zA-Z]+)-(\d+))',
lambda match : self._string_to_date(match.group(1), '%d-%b-%y'),
self._date_to_string)
self._param_dict.add(SBE37Parameter.PA0,
r' +PA0 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PA1,
r' +PA1 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PA2,
r' +PA2 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCA0,
r' +PTCA0 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCA1,
r' +PTCA1 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCA2,
r' +PTCA2 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCB0,
r' +PTCSB0 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCB1,
r' +PTCSB1 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.PTCB2,
r' +PTCSB2 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.POFFSET,
r' +POFFSET = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.RCALDATE,
r'rtc: +((\d+)-([a-zA-Z]+)-(\d+))',
lambda match : self._string_to_date(match.group(1), '%d-%b-%y'),
self._date_to_string)
self._param_dict.add(SBE37Parameter.RTCA0,
r' +RTCA0 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.RTCA1,
r' +RTCA1 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
self._param_dict.add(SBE37Parameter.RTCA2,
r' +RTCA2 = (-?\d.\d\d\d\d\d\de[-+]\d\d)',
lambda match : float(match.group(1)),
self._float_to_string)
########################################################################
# Static helpers to format set commands.
########################################################################
@staticmethod
def _true_false_to_string(v):
"""
Write a boolean value to string formatted for sbe37 set operations.
@param v a boolean value.
@retval A yes/no string formatted for sbe37 set operations.
@throws InstrumentParameterException if value not a bool.
"""
if not isinstance(v,bool):
raise InstrumentParameterException('Value %s is not a bool.' % str(v))
if v:
return 'y'
else:
return 'n'
@staticmethod
def _int_to_string(v):
"""
Write an int value to string formatted for sbe37 set operations.
@param v An int val.
@retval an int string formatted for sbe37 set operations.
@throws InstrumentParameterException if value not an int.
"""
if not isinstance(v,int):
raise InstrumentParameterException('Value %s is not an int.' % str(v))
else:
return '%i' % v
@staticmethod
def _float_to_string(v):
"""
Write a float value to string formatted for sbe37 set operations.
@param v A float val.
@retval a float string formatted for sbe37 set operations.
@throws InstrumentParameterException if value is not a float.
"""
if not isinstance(v,float):
raise InstrumentParameterException('Value %s is not a float.' % v)
else:
return '%e' % v
@staticmethod
def _date_to_string(v):
"""
Write a date tuple to string formatted for sbe37 set operations.
@param v a date tuple: (day,month,year).
@retval A date string formatted for sbe37 set operations.
@throws InstrumentParameterException if date tuple is not valid.
"""
if not isinstance(v,(list,tuple)):
raise InstrumentParameterException('Value %s is not a list, tuple.' % str(v))
if not len(v)==3:
raise InstrumentParameterException('Value %s is not length 3.' % str(v))
months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep',
'Oct','Nov','Dec']
day = v[0]
month = v[1]
year = v[2]
if len(str(year)) > 2:
year = int(str(year)[-2:])
if not isinstance(day,int) or day < 1 or day > 31:
raise InstrumentParameterException('Value %s is not a day of month.' % str(day))
if not isinstance(month,int) or month < 1 or month > 12:
raise InstrumentParameterException('Value %s is not a month.' % str(month))
if not isinstance(year,int) or year < 0 or year > 99:
raise InstrumentParameterException('Value %s is not a 0-99 year.' % str(year))
return '%02i-%s-%02i' % (day,months[month-1],year)
@staticmethod
def _string_to_date(datestr,fmt):
"""
Extract a date tuple from an sbe37 date string.
@param str a string containing date information in sbe37 format.
@retval a date tuple.
@throws InstrumentParameterException if datestr cannot be formatted to
a date.
"""
if not isinstance(datestr,str):
raise InstrumentParameterException('Value %s is not a string.' % str(datestr))
try:
date_time = time.strptime(datestr,fmt)
date = (date_time[2],date_time[1],date_time[0])
except ValueError:
raise InstrumentParameterException('Value %s could not be formatted to a date.' % str(datestr))
return date
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 __init__(self, prompts, newline, driver_event):
"""
SBE37Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The SBE37 newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build SBE37 protocol state machine.
self._protocol_fsm = InstrumentFSM(SBE37ProtocolState, SBE37ProtocolEvent,
SBE37ProtocolEvent.ENTER, SBE37ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.EXIT, self._handler_unknown_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.UNKNOWN, SBE37ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.EXIT, self._handler_command_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.SET, self._handler_command_set)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.TEST, self._handler_command_test)
self._protocol_fsm.add_handler(SBE37ProtocolState.COMMAND, SBE37ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.ENTER, self._handler_autosample_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.EXIT, self._handler_autosample_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.AUTOSAMPLE, SBE37ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.ENTER, self._handler_test_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.EXIT, self._handler_test_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.RUN_TEST, self._handler_test_run_tests)
self._protocol_fsm.add_handler(SBE37ProtocolState.TEST, SBE37ProtocolEvent.GET, self._handler_command_autosample_test_get)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.ENTER, self._handler_direct_access_enter)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.EXIT, self._handler_direct_access_exit)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct)
self._protocol_fsm.add_handler(SBE37ProtocolState.DIRECT_ACCESS, SBE37ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_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.
self._add_build_handler('ds', self._build_simple_command)
self._add_build_handler('dc', self._build_simple_command)
self._add_build_handler('ts', self._build_simple_command)
self._add_build_handler('startnow', self._build_simple_command)
self._add_build_handler('stop', self._build_simple_command)
self._add_build_handler('tc', self._build_simple_command)
self._add_build_handler('tt', self._build_simple_command)
self._add_build_handler('tp', self._build_simple_command)
self._add_build_handler('set', self._build_set_command)
# Add response handlers for device commands.
self._add_response_handler('ds', self._parse_dsdc_response)
self._add_response_handler('dc', self._parse_dsdc_response)
self._add_response_handler('ts', self._parse_ts_response)
self._add_response_handler('set', self._parse_set_response)
self._add_response_handler('tc', self._parse_test_response)
self._add_response_handler('tt', self._parse_test_response)
self._add_response_handler('tp', self._parse_test_response)
# Add sample handlers.
self._sample_pattern = r'^#? *(-?\d+\.\d+), *(-?\d+\.\d+), *(-?\d+\.\d+)'
self._sample_pattern += r'(, *(-?\d+\.\d+))?(, *(-?\d+\.\d+))?'
self._sample_pattern += r'(, *(\d+) +([a-zA-Z]+) +(\d+), *(\d+):(\d+):(\d+))?'
self._sample_pattern += r'(, *(\d+)-(\d+)-(\d+), *(\d+):(\d+):(\d+))?'
self._sample_regex = re.compile(self._sample_pattern)
# State state machine in UNKNOWN state.
self._protocol_fsm.start(SBE37ProtocolState.UNKNOWN)
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
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)
class SBE43Protocol(SBE16Protocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
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.
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.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 _filter_capabilities(self, events):
return [x for x in events if Capability.has(x)]
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
Over-ride sieve function to handle additional particles.
"""
matchers = []
return_list = []
matchers.append(SBE43DataParticle.regex_compiled())
matchers.append(SBE43HardwareParticle.regex_compiled())
matchers.append(SBE43CalibrationParticle.regex_compiled())
matchers.append(SBE43StatusParticle.regex_compiled())
matchers.append(SBE43ConfigurationParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
return return_list
def _got_chunk(self, chunk, timestamp):
"""
Over-ride sieve function to handle additional particles.
The base class got_data has gotten a chunk from the chunker. Pass it to extract_sample
with the appropriate particle objects and REGEXes.
"""
if self._extract_sample(SBE43DataParticle, SBE43DataParticle.regex_compiled(), chunk, timestamp):
self._sampling = True
return
for particle_class in SBE43HardwareParticle, \
SBE43CalibrationParticle, \
SBE43ConfigurationParticle, \
SBE43StatusParticle:
if self._extract_sample(particle_class, particle_class.regex_compiled(), chunk, timestamp):
return
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
try:
params = args[0]
except IndexError:
raise InstrumentParameterException('Set command requires a parameter dict.')
self._verify_not_readonly(*args, **kwargs)
update_params = False
# check values that the instrument doesn't validate
# handle special cases for driver specific parameters
for (key, val) in params.iteritems():
if key == Parameter.PUMP_DELAY and (val < MIN_PUMP_DELAY or val > MAX_PUMP_DELAY):
raise InstrumentParameterException("pump delay out of range")
elif key == Parameter.NUM_AVG_SAMPLES and (val < MIN_AVG_SAMPLES or val > MAX_AVG_SAMPLES):
raise InstrumentParameterException("num average samples out of range")
for (key, val) in params.iteritems():
old_val = self._param_dict.format(key)
new_val = self._param_dict.format(key, val)
log.debug("KEY = %r OLD VALUE = %r NEW VALUE = %r", key, old_val, new_val)
if old_val != new_val:
update_params = True
if ConfirmedParameter.has(key):
# We add a write delay here because this command has to be sent
# twice, the write delay allows it to process the first command
# before it receives the beginning of the second.
self._do_cmd_resp(Command.SET, key, val, write_delay=0.2)
else:
self._do_cmd_resp(Command.SET, key, val, **kwargs)
log.debug("set complete, update params")
if update_params:
self._update_params()
########################################################################
# Command handlers.
########################################################################
def _handler_command_acquire_status(self, *args, **kwargs):
"""
Get device status
"""
next_state = None
result = []
result.append(self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetSD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetHD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetCD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetCC Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT))
log.debug("_handler_command_acquire_status: GetEC Response: %s", result)
# Reset the event counter right after getEC
self._do_cmd_resp(Command.RESET_EC, timeout=TIMEOUT)
return next_state, (next_state, ''.join(result))
def _handler_command_acquire_sample(self, *args, **kwargs):
"""
Acquire sample from SBE16.
@retval next_state, (next_state, result) tuple
"""
next_state = None
timeout = time.time() + TIMEOUT
self._do_cmd_resp(Command.TS, *args, **kwargs)
particles = self.wait_for_particles(DataParticleType.CTD_PARSED, timeout)
return next_state, (next_state, particles)
def _handler_autosample_acquire_status(self, *args, **kwargs):
"""
Get device status in autosample mode
"""
next_state = None
result = []
# When in autosample this command requires two wake-ups to get to the right prompt
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
self._wakeup(timeout=WAKEUP_TIMEOUT, delay=0.3)
result.append(self._do_cmd_resp(Command.GET_SD, response_regex=SBE43StatusParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetSD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_HD, response_regex=SBE43HardwareParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetHD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CD, response_regex=SBE43ConfigurationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetCD Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_CC, response_regex=SBE43CalibrationParticle.regex_compiled(),
timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetCC Response: %s", result)
result.append(self._do_cmd_resp(Command.GET_EC, timeout=TIMEOUT))
log.debug("_handler_autosample_acquire_status: GetEC Response: %s", result)
# Reset the event counter right after getEC
self._do_cmd_no_resp(Command.RESET_EC)
return next_state, (next_state, ''.join(result))
########################################################################
# response handlers.
########################################################################
def _validate_GetSD_response(self, response, prompt):
"""
validation handler for GetSD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("_validate_GetSD_response: GetSD command encountered error; type='%s' msg='%s'", error[0],
error[1])
raise InstrumentProtocolException('GetSD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43StatusParticle.resp_regex_compiled().search(response):
log.error('_validate_GetSD_response: GetSD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetSD command not recognized: %s.' % response)
self._param_dict.update_many(response)
return response
def _validate_GetHD_response(self, response, prompt):
"""
validation handler for GetHD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetHD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetHD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43HardwareParticle.resp_regex_compiled().search(response):
log.error('_validate_GetHD_response: GetHD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetHD command not recognized: %s.' % response)
self._param_dict.update_many(response)
return response
def _validate_GetCD_response(self, response, prompt):
"""
validation handler for GetCD command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetCD command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetCD command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43ConfigurationParticle.resp_regex_compiled().search(response):
log.error('_validate_GetCD_response: GetCD command not recognized: %s.' % response)
raise InstrumentProtocolException('GetCD command not recognized: %s.' % response)
self._param_dict.update_many(response)
return response
def _validate_GetCC_response(self, response, prompt):
"""
validation handler for GetCC command
@param response command response string.
@param prompt prompt following command response.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetCC command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetCC command failure: type="%s" msg="%s"' % (error[0], error[1]))
if not SBE43CalibrationParticle.resp_regex_compiled().search(response):
log.error('_validate_GetCC_response: GetCC command not recognized: %s.' % response)
raise InstrumentProtocolException('GetCC command not recognized: %s.' % response)
return response
def _validate_GetEC_response(self, response, prompt):
"""
validation handler for GetEC command
@param response command response string.
@throws InstrumentProtocolException if command misunderstood.
"""
error = self._find_error(response)
if error:
log.error("GetEC command encountered error; type='%s' msg='%s'", error[0], error[1])
raise InstrumentProtocolException('GetEC command failure: type="%s" msg="%s"' % (error[0], error[1]))
return response
########################################################################
# Private helpers.
########################################################################
def _build_param_dict(self):
"""
Populate the parameter dictionary with SBE19 parameters.
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
self._build_common_param_dict()
self._param_dict.add(Parameter.SBE63,
r'SBE63>(.*)</SBE63',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="SBE63 Attached",
range={'True': True, 'False': False},
description="Enable SBE63: (true | false)",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.NUM_AVG_SAMPLES,
r'ScansToAverage>([\d]+)</ScansToAverage>',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Scans to Average",
range=INT16,
description="Number of samples to average",
startup_param=True,
direct_access=False,
default_value=4,
visibility=ParameterDictVisibility.READ_WRITE)
self._param_dict.add(Parameter.MIN_COND_FREQ,
r'MinimumCondFreq>([\d]+)</MinimumCondFreq',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Minimum Conductivity Frequency",
range=INT16,
description="Minimum conductivity frequency to enable pump turn-on.",
startup_param=True,
direct_access=False,
default_value=500,
units=Units.HERTZ,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.PUMP_DELAY,
r'PumpDelay>([\d]+)</PumpDelay',
lambda match: int(match.group(1)),
str,
type=ParameterDictType.INT,
display_name="Pump Delay",
range=INT16,
description="Time to wait after minimum conductivity frequency is reached before turning pump on.",
startup_param=True,
direct_access=False,
default_value=60,
units=Units.SECOND,
visibility=ParameterDictVisibility.READ_WRITE)
self._param_dict.add(Parameter.AUTO_RUN,
r'AutoRun>(.*)</AutoRun',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Auto Run",
range={'True': True, 'False': False},
description="Enable automatic logging when power is applied: (true | false).",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.IGNORE_SWITCH,
r'IgnoreSwitch>(.*)</IgnoreSwitch',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Ignore Switch",
range={'True': True, 'False': False},
description="Disable magnetic switch position for starting or stopping logging: (true | false)",
startup_param=True,
direct_access=True,
default_value=True,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.PTYPE,
r"<Sensor id = 'Main Pressure'>.*?<type>(.*?)</type>.*?</Sensor>",
self._pressure_sensor_to_int,
str,
type=ParameterDictType.INT,
display_name="Pressure Sensor Type",
range={'Strain Gauge': 1, 'Quartz with Temp Comp': 3},
startup_param=True,
direct_access=True,
default_value=1,
description="Sensor type: (1:strain gauge | 3:quartz with temp comp)",
visibility=ParameterDictVisibility.IMMUTABLE,
regex_flags=re.DOTALL)
self._param_dict.add(Parameter.OPTODE,
r'OPTODE>(.*)</OPTODE',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Optode Attached",
range={'True': True, 'False': False},
description="Enable optode: (true | false)",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.VOLT1,
r'ExtVolt1>(.*)</ExtVolt1',
lambda match: True if match.group(1) == 'yes' else False,
self._true_false_to_string,
type=ParameterDictType.BOOL,
display_name="Volt 1",
range={'True': True, 'False': False},
description="Enable external voltage 1: (true | false)",
startup_param=True,
direct_access=True,
default_value=False,
visibility=ParameterDictVisibility.IMMUTABLE)