本文整理汇总了Python中mi.core.instrument.instrument_fsm.ThreadSafeFSM.start方法的典型用法代码示例。如果您正苦于以下问题:Python ThreadSafeFSM.start方法的具体用法?Python ThreadSafeFSM.start怎么用?Python ThreadSafeFSM.start使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类mi.core.instrument.instrument_fsm.ThreadSafeFSM
的用法示例。
在下文中一共展示了ThreadSafeFSM.start方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: SingleConnectionInstrumentDriver
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(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 = {}
# Idempotency flag for lost connections.
# This set to false when a connection is established to
# allow for lost callback to become activated.
self._connection_lost = True
#############################################################
# 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.
result = self._connection_fsm.on_event(DriverEvent.CONNECT, *args, **kwargs)
init_config = {}
if len(args) > 0 and isinstance(args[0], dict):
init_config = args[0]
self.set_init_params(init_config)
#.........这里部分代码省略.........
示例2: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = META_LOGGER
def __init__(self, prompts, newline, driver_event):
"""
Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.START_DIRECT, self._handler_command_start_direct),
(ProtocolEvent.GET, self._handler_command_get),
(ProtocolEvent.SET, self._handler_command_set),
(ProtocolEvent.START_SCAN, self._handler_command_start_scan),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct),
(ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct),
],
ProtocolState.SCAN: [
(ProtocolEvent.ENTER, self._handler_scan_enter),
(ProtocolEvent.EXIT, self._handler_scan_exit),
(ProtocolEvent.STOP_SCAN, self._handler_scan_stop_scan),
(ProtocolEvent.TAKE_SCAN, self._handler_scan_take_scan),
(ProtocolEvent.TIMEOUT, self._handler_scan_timeout),
(ProtocolEvent.ERROR, self._handler_scan_error),
],
ProtocolState.ERROR: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CLEAR, self._handler_error_clear),
(ProtocolEvent.GET, self._handler_command_get),
]
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
# Add build handlers for device commands.
for command in InstrumentCommand.list():
self._add_build_handler(command, self._generic_build_handler)
# Add response handlers for device commands.
for command in InstrumentCommand.list():
self._add_response_handler(command, functools.partial(self._generic_response_handler, command=command))
# State state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
self._chunker = StringChunker(Protocol.sieve_function)
self.initialize_scheduler()
# all calls to do_cmd_resp should expect RESPONSE_REGEX and use TIMEOUT. Freeze these arguments...
self._do_cmd_resp = functools.partial(self._do_cmd_resp, response_regex=RESPONSE_REGEX, timeout=TIMEOUT)
# these variables are used to track scan time and completion status
# for development and performance data
self.scan_start_time = 0
self.in_scan = False
@staticmethod
def sieve_function(raw_data):
"""
This is a placeholder. The sieve function for the RGA is built dynamically when a scan is started.
This function must return a list.
see self._build_sieve_function()
"""
#.........这里部分代码省略.........
示例3: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(Pco2wProtocol):
"""
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.
"""
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(
ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Construct protocol superclass.
Pco2wProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
# Start state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
# build the chunker
self._chunker = StringChunker(Protocol.sieve_function)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples
:param raw_data: data to filter
"""
return_list = []
sieve_matchers = [SAMI_REGULAR_STATUS_REGEX_MATCHER,
SAMI_CONTROL_RECORD_REGEX_MATCHER,
PCO2W_SAMPLE_REGEX_MATCHER,
PCO2WA_CONFIGURATION_REGEX_MATCHER,
SAMI_ERROR_REGEX_MATCHER]
for matcher in sieve_matchers:
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 any([self._extract_sample(SamiRegularStatusDataParticle, SAMI_REGULAR_STATUS_REGEX_MATCHER,
chunk, timestamp),
self._extract_sample(SamiControlRecordDataParticle, SAMI_CONTROL_RECORD_REGEX_MATCHER,
chunk, timestamp),
self._extract_sample(Pco2waConfigurationDataParticle, PCO2WA_CONFIGURATION_REGEX_MATCHER,
chunk, timestamp)]):
return
sample = self._extract_sample(Pco2wSamiSampleDataParticle, PCO2W_SAMPLE_REGEX_MATCHER, chunk, timestamp)
log.debug('Protocol._got_chunk(): get_current_state() == %s', self.get_current_state())
if sample:
self._verify_checksum(chunk, PCO2W_SAMPLE_REGEX_MATCHER)
########################################################################
# Build Command, Driver and Parameter dictionaries
########################################################################
def _build_param_dict(self):
"""
For each parameter key, add match string, match lambda function,
and value formatting function for set commands.
"""
Pco2wProtocol._build_param_dict(self)
### example configuration string
# VALID_CONFIG_STRING = 'CEE90B0002C7EA0001E133800A000E100402000E10010B' + \
# '000000000D000000000D000000000D07' + \
# '1020FF54181C010038' + \
# '000000000000000000000000000000000000000000000000000' + \
# '000000000000000000000000000000000000000000000000000' + \
# '000000000000000000000000000000' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
#.........这里部分代码省略.........
示例4: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit)
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._chunker = StringChunker(Protocol.sieve_function)
self._build_driver_dict()
self._cmd_dict.add(Capability.DISCOVER, display_name='Discover')
@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
#.........这里部分代码省略.........
示例5: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.START_DIRECT, self._handler_command_start_direct),
(ProtocolEvent.GET, self._handler_command_get),
(ProtocolEvent.SET, self._handler_command_set),
(ProtocolEvent.START_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)
#.........这里部分代码省略.........
示例6: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
last_sample = ''
def __init__(self, prompts, newline, driver_event):
"""
Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_command_sync_clock)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.FLASH_STATUS, self._handler_flash_status)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ENTER, self._handler_autosample_enter)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.EXIT, self._handler_autosample_exit)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_SAMPLE, self._handler_acquire_sample)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.CLOCK_SYNC, self._handler_autosample_sync_clock)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_get)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.FLASH_STATUS, self._handler_flash_status)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.ACQUIRE_STATUS, self._handler_acquire_status)
# We setup a new state for clock sync because then we could use the state machine so the autosample scheduler
# is disabled before we try to sync the clock. Otherwise there could be a race condition introduced when we
# are syncing the clock and the scheduler requests a sample.
self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.ENTER, self._handler_sync_clock_enter)
self._protocol_fsm.add_handler(ProtocolState.SYNC_CLOCK, ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock_sync)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct)
# Add build handlers for device commands.
self._add_build_handler(Command.GET_CLOCK, self._build_simple_command)
self._add_build_handler(Command.SET_CLOCK, self._build_set_clock_command)
self._add_build_handler(Command.D, self._build_simple_command)
self._add_build_handler(Command.GO, self._build_simple_command)
self._add_build_handler(Command.STOP, self._build_simple_command)
self._add_build_handler(Command.FS, self._build_simple_command)
self._add_build_handler(Command.STAT, self._build_simple_command)
# Add response handlers for device commands.
self._add_response_handler(Command.GET_CLOCK, self._parse_clock_response)
self._add_response_handler(Command.SET_CLOCK, self._parse_clock_response)
self._add_response_handler(Command.FS, self._parse_fs_response)
self._add_response_handler(Command.STAT, self._parse_common_response)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
self._chunker = StringChunker(Protocol.sieve_function)
self._add_scheduler_event(ScheduledJob.ACQUIRE_STATUS, ProtocolEvent.ACQUIRE_STATUS)
self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC)
# Start state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
matchers = []
return_list = []
matchers.append(METBK_SampleDataParticle.regex_compiled())
matchers.append(METBK_StatusDataParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
#.........这里部分代码省略.........
示例7: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = METALOGGER
def __init__(self, prompts, newline, driver_event):
"""
Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_command_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.START_DIRECT, self._handler_command_start_direct),
(ProtocolEvent.GET, self._handler_command_get),
(ProtocolEvent.SET, self._handler_command_set),
(ProtocolEvent.START1, self._handler_command_start1),
(ProtocolEvent.NAFREG, self._handler_command_nafreg),
(ProtocolEvent.IONREG, self._handler_command_ionreg),
(ProtocolEvent.POWEROFF, self._handler_command_poweroff),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.START1: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.START1_COMPLETE, self._handler_start1_complete),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.WAITING_TURBO: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.START2, self._handler_waiting_turbo_start2),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.START2: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.START2_COMPLETE, self._handler_start2_complete),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.WAITING_RGA: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.SAMPLE, self._handler_waiting_rga_sample),
(ProtocolEvent.CALIBRATE, self._handler_waiting_rga_cal),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.SAMPLE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.SAMPLE_COMPLETE, self._handler_sample_complete),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.CALIBRATE: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.CALIBRATE_COMPLETE, self._handler_cal_complete),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.STOPPING: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.REGEN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.STANDBY, self._handler_stop),
(ProtocolEvent.ERROR, self._handler_error),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
#.........这里部分代码省略.........
示例8: SBE43Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_unknown_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_command_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_command_acquire_sample),
(ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.SET, self._handler_command_set),
(ProtocolEvent.START_DIRECT, self._handler_command_start_direct),
(ProtocolEvent.CLOCK_SYNC, self._handler_command_clock_sync_clock),
(ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status)
],
ProtocolState.ACQUIRING_SAMPLE: [
(ProtocolEvent.ENTER, self._handler_acquiring_sample_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.ACQUIRE_SAMPLE_ASYNC, self._handler_acquire_sample_async),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct),
(ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct)
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_autosample_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample),
(ProtocolEvent.SCHEDULED_ACQUIRED_STATUS, self._handler_autosample_acquire_status),
]
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_driver_dict()
self._build_command_dict()
self._build_param_dict()
# Add build handlers for device commands, only using simple command handler.
for cmd in Command.list():
if cmd == Command.SET:
self._add_build_handler(Command.SET, self._build_set_command)
else:
self._add_build_handler(cmd, self._build_simple_command)
# Add response handlers for device commands.
# these are here to ensure that correct responses to the commands are received before the next command is sent
self._add_response_handler(Command.SET, self._parse_set_response)
self._add_response_handler(Command.GET_SD, self._validate_GetSD_response)
self._add_response_handler(Command.GET_HD, self._validate_GetHD_response)
self._add_response_handler(Command.GET_CD, self._validate_GetCD_response)
self._add_response_handler(Command.GET_CC, self._validate_GetCC_response)
self._add_response_handler(Command.GET_EC, self._validate_GetEC_response)
# State state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._chunker = StringChunker(self.sieve_function)
def _build_command_dict(self):
"""
Populate the command dictionary with command. Overridden to specify timeouts.
"""
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.CLOCK_SYNC, display_name="Synchronize Clock")
self._cmd_dict.add(Capability.ACQUIRE_STATUS, timeout=ACQUIRE_STATUS_TIMEOUT, display_name="Acquire Status")
self._cmd_dict.add(Capability.ACQUIRE_SAMPLE, display_name="Acquire Sample")
self._cmd_dict.add(Capability.DISCOVER, timeout=DISCOVER_TIMEOUT, display_name='Discover')
#.........这里部分代码省略.........
示例9: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = META_LOGGER
def __init__(self, prompts, newline, driver_event):
"""
Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_generic_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_autosample_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.GET, self._handler_command_get),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample),
(ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_command_enter),
(ProtocolEvent.EXIT, self._handler_generic_exit),
(ProtocolEvent.GET, self._handler_command_get),
(ProtocolEvent.SET, self._handler_command_set),
(ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample),
(ProtocolEvent.VERY_LONG_COMMAND, self._very_long_command),
],
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Construct the metadata dictionaries
self._build_command_dict()
self._build_driver_dict()
# Start state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
# set up scheduled event handling
self.initialize_scheduler()
self._schedulers = []
def _generate_particle(self, stream_name, count=1):
# we're faking it anyway, send these as fast as we can...
# the overall rate will be close enough
particle = VirtualParticle(stream_name, port_timestamp=0)
for x in range(count):
particle.contents["port_timestamp"] = ntplib.system_to_ntp_time(time.time())
self._driver_event(DriverAsyncEvent.SAMPLE, particle.generate())
time.sleep(0.001)
def _create_scheduler(self, stream_name, rate):
job_name = stream_name
if rate > 1:
interval = 1
else:
interval = 1 / rate
config = {
DriverConfigKey.SCHEDULER: {
job_name: {
DriverSchedulerConfigKey.TRIGGER: {
DriverSchedulerConfigKey.TRIGGER_TYPE: TriggerType.INTERVAL,
DriverSchedulerConfigKey.SECONDS: interval,
}
}
}
}
self.set_init_params(config)
self._schedulers.append(stream_name)
if rate > 1:
self._add_scheduler(stream_name, functools.partial(self._generate_particle, stream_name, count=rate))
else:
self._add_scheduler(stream_name, functools.partial(self._generate_particle, stream_name))
def _delete_all_schedulers(self):
for name in self._schedulers:
try:
self._remove_scheduler(name)
except:
#.........这里部分代码省略.........
示例10: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class for SBE16 DOSTA driver.
"""
particles = [
DoSampleParticle,
]
def __init__(self, prompts, newline, driver_event):
"""
@param prompts A BaseEnum class containing instrument prompts.
@param newline The SBE16 newline.
@param driver_event Driver process event callback.
"""
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# This driver does not process commands, the finite state machine and handlers are stubs
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
handlers = {
ProtocolState.UNKNOWN: {
(ProtocolEvent.ENTER, self._handler_state_change()),
(ProtocolEvent.EXIT, self._handler_pass_through()),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover()),
},
ProtocolState.COMMAND: {
(ProtocolEvent.ENTER, self._handler_state_change()),
(ProtocolEvent.EXIT, self._handler_pass_through()),
(ProtocolEvent.GET, self._handler_pass_through()),
},
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._chunker = StringChunker(self.sieve_function)
@staticmethod
def sieve_function(raw_data):
""" The method that splits samples
Over-ride sieve function to handle additional particles.
"""
matchers = []
return_list = []
matchers.append(DoSampleParticle.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_command_dict(self):
self._cmd_dict.add(Capability.DISCOVER, display_name='Discover', timeout=1)
def _build_param_dict(self):
pass
# 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",
# description="Enable optode: (true | false)",
# range={'True': True, 'False': False},
# startup_param=True,
# direct_access=True,
# default_value=True,
# 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",
# description="Enable external voltage 1: (true | false)",
# range={'True': True, 'False': False},
# startup_param=True,
# direct_access=True,
# default_value=True,
# visibility=ParameterDictVisibility.IMMUTABLE)
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(DoSampleParticle, DoSampleParticle.regex_compiled(), chunk, timestamp):
self._sampling = True
return
#.........这里部分代码省略.........
示例11: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(InstrumentProtocol):
__metaclass__ = META_LOGGER
def __init__(self, driver_event):
super(Protocol, self).__init__(driver_event)
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
handlers = {
ProtocolState.UNKNOWN: (
(ProtocolEvent.ENTER, self._handler_unknown_enter),
(ProtocolEvent.EXIT, self._handler_unknown_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
),
ProtocolState.AUTOSAMPLE: (
(ProtocolEvent.ENTER, self._handler_autosample_enter),
(ProtocolEvent.EXIT, self._handler_autosample_exit),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.FLUSH, self._flush),
(ProtocolEvent.CONFIG_ERROR, self._handler_config_error),
),
ProtocolState.WRITE_ERROR: (
(ProtocolEvent.ENTER, self._handler_error_enter),
(ProtocolEvent.EXIT, self._handler_error_exit),
),
ProtocolState.CONFIG_ERROR: (
(ProtocolEvent.ENTER, self._handler_error_enter),
(ProtocolEvent.EXIT, self._handler_error_exit),
)
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Build dictionaries for driver schema
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
# State state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._logs = {}
self._filled_logs = []
self._pickle_cache = []
self._persistent_store = None
# lock for flush actions to prevent writing or altering the data files
# during flush
self._lock = Lock()
self._pktid = None
def _filter_capabilities(self, events):
"""
Filter a list of events to only include valid capabilities
@param events: list of events to be filtered
@return: list of filtered events
"""
return [x for x in events if Capability.has(x)]
def _build_command_dict(self):
"""
Populate the command dictionary with commands.
"""
self._cmd_dict.add(Capability.GET, display_name="Get")
self._cmd_dict.add(Capability.SET, display_name="Set")
self._cmd_dict.add(Capability.DISCOVER, display_name="Discover")
def _build_param_dict(self):
self._param_dict.add(Parameter.REFDES,
'NA',
str,
str,
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
display_name='Reference Designator',
description='Reference Designator for this driver',
type=ParameterDictType.STRING)
self._param_dict.add(Parameter.SOURCE_REGEX,
'NA',
str,
str,
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
display_name='Source Filter Regex',
description='Filter sources to be processed from the ORB',
type=ParameterDictType.STRING,
value_description='Regular expression')
self._param_dict.add(Parameter.FILE_LOCATION,
'NA',
str,
str,
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
default_value="./antelope_data",
display_name='File Location',
description='Root file path of the packet data files',
type=ParameterDictType.STRING,
value_description='String representing the packet data root file path')
#.........这里部分代码省略.........
示例12: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.EXIT, self._handler_unknown_exit)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.EXIT, self._handler_command_exit)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.START_DIRECT, self._handler_command_start_direct)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.CLOCK_SYNC, self._handler_sync_clock)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_get)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.ENTER, self._handler_direct_access_enter)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXIT, self._handler_direct_access_exit)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct)
self._protocol_fsm.add_handler(ProtocolState.DIRECT_ACCESS, ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct)
# Add build handlers for device commands.
self._add_build_handler(Command.BATTERY, self._build_simple_command)
# Add response handlers for device commands.
self._add_response_handler(Command.BATTERY, self._parse_battery_response)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
self._chunker = StringChunker(Protocol.sieve_function)
self._add_scheduler_event(ScheduledJob.CLOCK_SYNC, ProtocolEvent.CLOCK_SYNC)
# Start state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
matchers = []
return_list = []
matchers.append(RASFL_SampleDataParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
"""
if return_list != []:
log.debug("sieve_function: raw_data=%s, return_list=%s" %(raw_data, return_list))
"""
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.
"""
log.debug("_got_chunk: chunk=%s" %chunk)
self._extract_sample(RASFL_SampleDataParticle, RASFL_SampleDataParticle.regex_compiled(), chunk, timestamp)
def _filter_capabilities(self, events):
"""
Return a list of currently available capabilities.
"""
return [x for x in events if Capability.has(x)]
########################################################################
# implement virtual methods from base class.
########################################################################
def apply_startup_params(self):
"""
Apply sample_interval startup parameter.
"""
config = self.get_startup_config()
log.debug("apply_startup_params: startup config = %s" %config)
#.........这里部分代码省略.........
示例13: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(CommandResponseInstrumentProtocol):
"""
Instrument protocol class
Subclasses CommandResponseInstrumentProtocol
"""
__metaclass__ = get_logging_metaclass(log_level='trace')
def __init__(self, prompts, newline, driver_event):
"""
Protocol constructor.
@param prompts A BaseEnum class containing instrument prompts.
@param newline The newline.
@param driver_event Driver process event callback.
"""
# Construct protocol superclass.
CommandResponseInstrumentProtocol.__init__(self, prompts, newline, driver_event)
# Build protocol state machine.
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent,
ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.ENTER, self._handler_unknown_enter)
self._protocol_fsm.add_handler(ProtocolState.UNKNOWN, ProtocolEvent.DISCOVER, self._handler_unknown_discover)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.ENTER, self._handler_command_enter)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample)
self._protocol_fsm.add_handler(ProtocolState.COMMAND,
ProtocolEvent.ACQUIRE_STATUS, self._handler_command_acquire_status)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.GET, self._handler_command_get)
self._protocol_fsm.add_handler(ProtocolState.COMMAND, ProtocolEvent.SET, self._handler_command_set)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE,
ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop)
self._protocol_fsm.add_handler(ProtocolState.AUTOSAMPLE, ProtocolEvent.GET, self._handler_command_get)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_driver_dict()
self._build_command_dict()
self._build_param_dict()
# Add sample handlers.
# State state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
# commands sent sent to device to be filtered in responses for telnet DA
self._sent_cmds = []
self._chunker = StringChunker(self.sieve_function)
log.info('processing particles with %d workers', POOL_SIZE)
self._process_particles = True
self._pending_particles = deque()
self._processing_pool = multiprocessing.Pool(POOL_SIZE)
self._particles_thread = Thread(target=self.particles_thread)
self._particles_thread.setDaemon(True)
self._particles_thread.start()
def particles_thread(self):
log.info('Starting particles generation thread.')
processing_pool = self._processing_pool
try:
futures = {}
while self._process_particles or futures:
# Pull all processing requests from our request deque
# Unless we have been instructed to terminate
while True and self._process_particles:
try:
filepath, timestamp = self._pending_particles.popleft()
log.info('Received RAW file to process: %r %r', filepath, timestamp)
# Schedule for processing
# parse_datagram_file takes the filepath and returns a
# tuple containing the metadata and timestamp for creation
# of the particle
futures[(filepath, timestamp)] = processing_pool.apply_async(parse_particles_file, (filepath,))
except IndexError:
break
# Grab our keys here, to avoid mutating the dictionary while iterating
future_keys = sorted(futures)
if future_keys:
log.debug('Awaiting completion of %d particles', len(future_keys))
for key in future_keys:
future = futures[key]
if future.ready():
try:
# Job complete, remove the future from our dictionary and generate a particle
result = future.get()
except Exception as e:
result = e
futures.pop(key, None)
#.........这里部分代码省略.........
示例14: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
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 = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
# Add event handlers for protocol state machine.
handlers = {
ProtocolState.UNKNOWN: [
(ProtocolEvent.ENTER, self._handler_unknown_enter),
(ProtocolEvent.EXIT, self._handler_unknown_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
],
ProtocolState.COMMAND: [
(ProtocolEvent.ENTER, self._handler_command_enter),
(ProtocolEvent.EXIT, self._handler_command_exit),
(ProtocolEvent.START_DIRECT, self._handler_command_start_direct),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_sample),
(ProtocolEvent.START_AUTOSAMPLE, self._handler_command_autosample),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.SET, self._handler_command_set),
],
ProtocolState.AUTOSAMPLE: [
(ProtocolEvent.ENTER, self._handler_autosample_enter),
(ProtocolEvent.ACQUIRE_SAMPLE, self._handler_sample),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop),
(ProtocolEvent.EXIT, self._handler_autosample_exit),
],
ProtocolState.DIRECT_ACCESS: [
(ProtocolEvent.ENTER, self._handler_direct_access_enter),
(ProtocolEvent.EXIT, self._handler_direct_access_exit),
(ProtocolEvent.EXECUTE_DIRECT, self._handler_direct_access_execute_direct),
(ProtocolEvent.STOP_DIRECT, self._handler_direct_access_stop_direct),
],
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Add build handlers for device commands - we are only using simple commands
for cmd in Command.list():
self._add_build_handler(cmd, self._build_command)
self._add_response_handler(cmd, self._check_command)
self._add_build_handler(Command.SETUP, self._build_setup_command)
self._add_response_handler(Command.READ_SETUP, self._read_setup_response_handler)
# Add response handlers for device commands.
# self._add_response_handler(Command.xyz, self._parse_xyz_response)
# Construct the parameter dictionary containing device parameters,
# current parameter values, and set formatting functions.
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
self._chunker = StringChunker(Protocol.sieve_function)
# Start state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._sent_cmds = None
self.initialize_scheduler()
# unit identifiers - must match the setup command (SU31 - '1')
self._units = ['1', '2', '3']
self._setup = None # set by the read setup command handler for comparison to see if the config needs reset
@staticmethod
def sieve_function(raw_data):
"""
The method that splits samples and status
"""
matchers = []
return_list = []
matchers.append(D1000TemperatureDataParticle.regex_compiled())
for matcher in matchers:
for match in matcher.finditer(raw_data):
return_list.append((match.start(), match.end()))
if not return_list:
log.debug("sieve_function: raw_data=%r, return_list=%s", raw_data, return_list)
return return_list
def _got_chunk(self, chunk, timestamp):
#.........这里部分代码省略.........
示例15: Protocol
# 需要导入模块: from mi.core.instrument.instrument_fsm import ThreadSafeFSM [as 别名]
# 或者: from mi.core.instrument.instrument_fsm.ThreadSafeFSM import start [as 别名]
class Protocol(InstrumentProtocol):
def __init__(self, driver_event):
super(Protocol, self).__init__(driver_event)
self._protocol_fsm = ThreadSafeFSM(ProtocolState, ProtocolEvent, ProtocolEvent.ENTER, ProtocolEvent.EXIT)
handlers = {
ProtocolState.UNKNOWN: (
(ProtocolEvent.ENTER, self._handler_unknown_enter),
(ProtocolEvent.EXIT, self._handler_unknown_exit),
(ProtocolEvent.DISCOVER, self._handler_unknown_discover),
),
ProtocolState.COMMAND: (
(ProtocolEvent.ENTER, self._handler_command_enter),
(ProtocolEvent.EXIT, self._handler_command_exit),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.SET, self._handler_set),
(ProtocolEvent.START_AUTOSAMPLE, self._handler_command_start_autosample),
),
ProtocolState.AUTOSAMPLE: (
(ProtocolEvent.ENTER, self._handler_autosample_enter),
(ProtocolEvent.EXIT, self._handler_autosample_exit),
(ProtocolEvent.GET, self._handler_get),
(ProtocolEvent.FLUSH, self._flush),
(ProtocolEvent.STOP_AUTOSAMPLE, self._handler_autosample_stop_autosample),
),
ProtocolState.STOPPING: (
(ProtocolEvent.ENTER, self._handler_stopping_enter),
(ProtocolEvent.EXIT, self._handler_stopping_exit),
(ProtocolEvent.FLUSH, self._flush),
),
ProtocolState.WRITE_ERROR: (
(ProtocolEvent.ENTER, self._handler_write_error_enter),
(ProtocolEvent.EXIT, self._handler_write_error_exit),
(ProtocolEvent.CLEAR_WRITE_ERROR, self._handler_clear_write_error),
),
}
for state in handlers:
for event, handler in handlers[state]:
self._protocol_fsm.add_handler(state, event, handler)
# Build dictionaries for driver schema
self._build_param_dict()
self._build_command_dict()
self._build_driver_dict()
# State state machine in UNKNOWN state.
self._protocol_fsm.start(ProtocolState.UNKNOWN)
self._logs = {}
self._filled_logs = []
self._pickle_cache = []
# persistent store, cannot initialize until startup config has been applied
# since we need the address for postgres
self._persistent_store = None
# lock for flush actions to prevent writing or altering the data files
# during flush
self._lock = Lock()
self._pktid = 0
def _filter_capabilities(self, events):
"""
Filter a list of events to only include valid capabilities
@param events: list of events to be filtered
@return: list of filtered events
"""
return [x for x in events if Capability.has(x)]
def _build_command_dict(self):
"""
Populate the command dictionary with commands.
"""
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.GET, display_name="Get")
self._cmd_dict.add(Capability.SET, display_name="Set")
self._cmd_dict.add(Capability.DISCOVER, display_name="Discover")
self._cmd_dict.add(Capability.CLEAR_WRITE_ERROR, display_name="Clear Write Error")
def _build_param_dict(self):
self._param_dict.add(
Parameter.REFDES,
"NA",
str,
str,
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
display_name="Reference Designator",
description="Reference Designator for this driver",
type=ParameterDictType.STRING,
)
self._param_dict.add(
Parameter.SOURCE_REGEX,
"NA",
str,
str,
visibility=ParameterDictVisibility.IMMUTABLE,
startup_param=True,
display_name="Source Filter Regex",
#.........这里部分代码省略.........