def create_machine(timer_name, duration, component):
"""
Create a complete state machine instance for the timer object.
Note that this method is static (no self argument), since it is a helper
method to create this object.
"""
timer_logic = TimerLogic(name=timer_name,
duration=duration,
component=component)
t0 = {'source': 'initial', 'target': 'active', 'effect': 'started'}
t1 = {
'source': 'active',
'target': 'completed',
'trigger': 't',
'effect': 'timer_completed'
}
t2 = {
'source': 'active',
'trigger': 'report',
'target': 'active',
'effect': 'report_status'
}
timer_stm = stmpy.Machine(name=timer_name,
transitions=[t0, t1, t2],
obj=timer_logic)
timer_logic.stm = timer_stm
return timer_stm
def __init__(self, name, duration, component):
self._logger = logging.getLogger(__name__)
self.name = name
self.duration = duration
self.component = component
t0 = {
'source': 'initial',
'target': 'active',
'effect': 'start_timer("t", ' + str(self.duration * 1000) + ")'"
}
t1 = {
'trigger': 'report',
'source': 'active',
'target': 'active',
'effect': 'report_status'
}
t2 = {
'trigger': 't',
'source': 'active',
'target': 'finished',
'effect': 'timer_finished'
}
self.stm = stmpy.Machine(name=name, transitions=[t0, t1, t2], obj=self)
def __init__(self, name, component):
self.name = name
self.component = component
self.recording_interval = 1000
t0 = {'source' : 'initial',
'target' : 'idle'}
t1 = {'trigger' : 'update',
'source' : 'idle',
'target' : 'Send_data'}
t2 = {'trigger' : 't',
'source' : "Send_data",
'target' : 'idle'}
# the states:
idle = {'name': 'idle'}
Send_Data = {'name': 'Send_data',
'entry': 'init_send_data',
'exit': 'publish_send_data'}
self.stm = stmpy.Machine(name=name, transitions=[t0, t1, t2],
obj=self, states=[idle,Send_Data])
def create_machine(self, name):
t0 = {'source': 'initial', 'target': 'ready'}
t1 = {'trigger': 'start', 'source': 'ready', 'target': 'recording'}
t2 = {
'trigger': 'stop',
'source': 'recording',
'target': 'ready',
'effect': 'stop'
}
t4 = {
'trigger': 't',
'source': 'recording',
'target': 'ready',
'effect': 'timeout'
}
s_recording = {
'name': 'recording',
'do': 'record()',
'entry': 'start_timer("t", 30000)'
}
stm = stmpy.Machine(name=name,
transitions=[t0, t1, t2, t4],
states=[s_recording],
obj=self)
self.stm = stm
return self.stm
def createSession(self, walkie, user):
session = Session(walkie, user, self)
print("Session created, id: ", walkie)
sessionMachine = stmpy.Machine(
walkie, SessionStateMachineConfig["transitions"], session,
SessionStateMachineConfig["states"])
self._driver.add_machine(sessionMachine)
self._sessions.append(session)
return session
def __init__(self, name, duration, component):
self._logger = logging.getLogger(__name__)
self.name = name
self.duration = duration
self.component = component
# TODO: build the transitions
self.stm = stmpy.Machine(name=name, transitions=[t0, t1, t2], obj=self)
def __init__(self, sensor_id, sensor):
self.sensor = sensor
self.sensor_id = sensor_id
self.last_state = ''
print("Creating Sensor Controller for Sensor ID " +
str(self.sensor_id))
self.stm = stmpy.Machine(transitions=[
SensorController.t_init, SensorController.t_timer,
SensorController.t_is_alive
],
obj=self,
name=str(self.sensor_id),
states=[SensorController.s_idle])
def create_machine(server_name, payload, component):
server_logic = ServerStm(server_name, payload, component)
# regular transitions
t0 = {
'source': 'initial',
'target': 'passive',
'effect': 'started'}
t1 = {
'source': 'passive',
'target': 'handle',
'trigger': 'incoming_request',
'effect': 'handle_request'}
# compound transition
t2 = {
'source': 'handle',
'trigger': 'finished_handling',
'targets': 'send build',
'function': server_logic.handle_compound_transition}
# regular transitions
t3 = {
'source': 'send',
'trigger': 'message_sent',
'target': 'final'}
t4 = {
'source': 'build',
'trigger': 'response_built',
'target': 'send'}
t5 = {
'source': 'build',
'trigger': 'response_failed',
'target': 'send'}
# states
s0 = {
'name': 'build',
'entry': 'build_response'}
s1 = {
'name': 'send',
'entry': 'send_message'}
server_stm = stmpy.Machine(name=server_name, transitions=[t0,t1,t2,t3,t4], states=[s0,s1],
obj=server_logic)
server_logic.stm = server_stm
return server_stm
def __init__(self, name, duration, component):
self.name = name
self.duration = duration
self.component = component
t0 = {'source': 'initial', 'target': 'active', 'effect': 'start'}
t1 = {
'trigger': 'status',
'source': 'active',
'target': 'active',
'effect': 'report_status'
}
t2 = {
'trigger': 't',
'source': 'active',
'target': 'end_state',
'effect': 'timer_completed'
}
self.stm = stmpy.Machine(name=name, transitions=[t0, t1, t2], obj=self)
def test(self):
t0 = {
"source": "initial",
"target": "s_tick",
"effect": "start_timer('tick', 1000); start_timer('tstop', 1000)",
}
t1 = {
"trigger": "tick",
"source": "s_tick",
"target": "s_tock",
"effect": "start_timer('tock', 1000)",
}
t2 = {
"trigger": "tock",
"source": "s_tock",
"target": "s_tick",
"effect": "start_timer('tick', 1000)",
}
t3 = {"trigger": "tstop", "source": "s_tock", "target": "final"}
stm_tick = stmpy.Machine(name="stm_tick",
transitions=[t0, t1, t2, t3],
obj=None)
to_promela([stm_tick])
def __init__(self, name, duration, component):
self._logger = logging.getLogger(__name__)
self.name = name
self.duration = duration
self.component = component
# TODO: build the transitions
t0 = {"source": "initial", "target": "active", "effect": "started"}
t1 = {
"trigger": "report",
"source": "active",
"target": "active",
"effect": "report_status",
}
t2 = {
"trigger": "t",
"source": "active",
"target": "completed",
"effect": "timer_completed",
}
self.stm = stmpy.Machine(name=name, transitions=[t0, t1, t2], obj=self)
def __init__(self, name, component):
self.name = name
self.component = component
self.error_count = 0
self.error_limit = 3
self.wait_time = 180000
self.state = "" #needed to specify the state name so added this variable
self.data = ""
t0 = {'source': 'initial', 'target': 'scan'}
t1 = {
'trigger': 'data_msg',
'source': 'scan',
'function': self.check_msg
}
t2 = {
'trigger': 'arbitrator',
'source': 'choose_state',
'function': self.get_state
}
t3 = {'trigger': 't', 'source': "good", 'target': 'scan'}
t4 = {'trigger': 't', 'source': 'cold', 'target': 'scan'}
t5 = {'trigger': 't', 'source': 'hot', 'target': 'scan'}
t6 = {'trigger': 't', 'source': 'dry', 'target': 'scan'}
t7 = {'trigger': 't', 'source': 'moist', 'target': 'scan'}
t8 = {'trigger': 'update', 'source': "good", 'target': 'scan'}
t9 = {'trigger': 'update', 'source': 'cold', 'target': 'scan'}
t10 = {'trigger': 'update', 'source': 'hot', 'target': 'scan'}
t11 = {'trigger': 'update', 'source': 'dry', 'target': 'scan'}
t12 = {'trigger': 'update', 'source': 'moist', 'target': 'scan'}
t13 = {
'trigger': 'update',
'source': 'error_check',
'function': self.check_error_limit
}
# the states:
scan = {'name': 'scan', 'entry': 'get_sensor_values'}
choose_state = {
'name': 'choose_state',
'entry': 'init_choose_state',
'exit': 'exit_choose_state'
}
good = {'name': 'good', 'entry': 'good'}
#bad = {'name': 'bad',
# 'entry': 'bad'}
cold = {'name': 'cold', 'entry': 'cold'}
hot = {'name': 'hot', 'entry': 'warm'}
dry = {'name': 'dry', 'entry': 'dry'}
moist = {'name': 'moist', 'entry': 'moist'}
error = {'name': 'error_check', 'entry': 'error_iterate'}
end_state = {'name': 'end_state', 'entry': 'terminate'}
self.stm = stmpy.Machine(name=name,
transitions=[
t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
t10, t11, t12, t13
],
obj=self,
states=[
scan, choose_state, good, cold, hot, dry,
moist, error, end_state
])
def __init__(self, name, component):
self._logger = logging.getLogger(__name__)
self.name = name
self.component = component
# Transitions
t0 = {'source': 'initial', 'target': 'check_status'}
t1 = {'trigger': 'check', 'source': 'error', 'target': 'check_status'}
t2 = {'trigger': 'error', 'source': 'check_status', 'target': 'error'}
t3 = {'trigger': 'check', 'source': 'booked', 'target': 'check_status'}
t4 = {
'trigger': 'isAvailable',
'source': 'check_status',
'target': 'available'
}
t5 = {'trigger': 'isBusy', 'source': 'check_status', 'target': 'busy'}
t6 = {
'trigger': 'isBooked',
'source': 'check_status',
'target': 'booked'
}
t7 = {'trigger': 'booked', 'source': 'available', 'target': 'booked'}
t8 = {'trigger': 'error', 'source': 'available', 'target': 'error'}
t9 = {'trigger': 'in_use', 'source': 'available', 'target': 'busy'}
t10 = {'trigger': 'error', 'source': 'busy', 'target': 'error'}
t11 = {
'trigger': 'available',
'source': 'busy',
'target': 'check_status'
}
t12 = {'trigger': 'in_use', 'source': 'booked', 'target': 'busy'}
t13 = {'trigger': 'error', 'source': 'booked', 'target': 'error'}
t14 = {
'trigger': 'check',
'source': 'available',
'target': 'check_status'
}
t15 = {'trigger': 'check', 'source': 'busy', 'target': 'check_status'}
#States
check_status = {'name': 'check_status', 'entry': 'get_status'}
error = {'name': 'error', 'entry': 'start_timer("check", 5000)'}
available = {
'name': 'available',
'entry': 'start_timer("check", 5000)'
}
busy = {
'name': 'busy',
'entry': 'send_msg("started"); start_timer("check", 5000)'
}
booked = {'name': 'booked', 'entry': 'start_timer("check", 5000)'}
self.stm = stmpy.Machine(
name=name,
transitions=[
t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13,
t14, t15
],
obj=self,
states=[check_status, error, available, busy, booked])
'effect': 'registration(*); sendMessageReg(*)'
}
idle = {'name': 'idle'}
validating_login = {
'name': 'validating_login',
'defer': 'registationRequest; loginRequest; delete_user; log_out'
}
validating_registration = {
'name': 'validation_registration',
'defer': 'registationRequest; loginRequest; delete_user; log_out'
}
driver = stmpy.Driver()
server = AuthenticationServer_MQTT(MQTT_BROKER, MQTT_PORT, driver,
MQTT_TOPIC_INPUT, MQTT_TOPIC_OUTPUT)
authenticationSender = AuthenticationServer_Sender(server)
machine = stmpy.Machine(
name='Authentication_server',
transitions=[t0, t1, t2, t3, t4, t5, t6],
obj=authenticationSender,
states=[idle, validating_login, validating_registration])
authenticationSender.stm = machine
driver.add_machine(machine)
server.start()
driver.start()
def create_machine(name):
walkie_logic = WalkieLogic(name=name)
#initial
t0 = {'source': 'initial', 'target': 'idle'}
#from idle
t1 = {'source': 'idle', 'target': 'message_received', 'trigger': 'message_received'}
t2 = {'source': 'idle', 'target': 'playback_stored', 'trigger': 'playback'}
t3 = {'source': 'idle', 'target': 'choose_recipients', 'trigger': 'send_message'}
t4 = {'source': 'idle', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast'}
t5 = {'source': 'idle', 'target': 'emergency_message_received', 'trigger': 'emergency_received'}
t6 = {'source': 'idle', 'target': 'idle', 'trigger': 'delete_stored', 'effect': 'delete_messages'}
#from message received
t7 = {'source': 'message_received', 'target': 'idle', 'trigger': 'listen_later', 'effect': 'store_message(*)'}
t8 = {'source': 'message_received', 'target': 'playback_message', 'trigger': 'listen_to_message'}
t9 = {'source': 'message_received', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast', 'effect': 'store_message(*)'}
t10 = {'source': 'message_received', 'target': 'emergency_message_received', 'trigger': 'emergency_received', 'effect': 'store_message(*)'}
#from playback_stored
t11 = {'source': 'playback_stored', 'target': 'idle', 'trigger': 'playback_finished'}
t12 = {'source': 'playback_stored', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast'}
t13 = {'source': 'playback_stored', 'target': 'emergency_message_received', 'trigger': 'emergency_received'}
t14 = {'source': 'playback_stored', 'target': 'idle', 'trigger': 'abort'}
#from choose_recipients
t15 = {'source': 'choose_recipients', 'target': 'idle', 'trigger': 'abort_choosing'}
t16 = {'source': 'choose_recipients', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast'}
t17 = {'source': 'choose_recipients', 'target': 'emergency_message_received', 'trigger': 'emergency_received'}
t18 = {'source': 'choose_recipients', 'target': 'record_message', 'trigger': 'chosen'}
# from playback_message
t19 = {'source': 'playback_message', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast', 'effect': 'store_message(*)'}
t20 = {'source': 'playback_message', 'target': 'emergency_message_received', 'trigger': 'emergency_received', 'effect': 'store_message(*)'}
t21 = {'source': 'playback_message', 'target': 'idle', 'trigger': 'message_played'}
#from emergency_broadcasting
t22 = {'source': 'emergency_broadcasting', 'target': 'idle', 'trigger': 'abort', 'effect': 'stop_timer("t")'}
t23 = {'source': 'emergency_broadcasting', 'target': 'idle', 'trigger': 't', 'effect': 'send_emergency; stop_timer("t")'}
#from emergency_message_received
t24 = {'source': 'emergency_message_received', 'target': 'idle', 'trigger': 'message_played'}
#from record_message
t25 = {'source': 'record_message', 'target': 'idle', 'trigger': 'abort_sending'}
t26 = {'source': 'record_message', 'target': 'idle', 'trigger': 'done_recording'}
t27 = {'source': 'record_message', 'target': 'emergency_broadcasting', 'trigger': 'emergency_broadcast'}
t28 = {'source': 'record_message', 'target': 'emergency_message_received', 'trigger': 'emergency_received'}
#states
idle = {'name': 'idle',
'entry': 'idle_state'}
emergency_received = { 'name': 'emergency_message_received',
'entry': 'playback_emergency',
'message_received': 'defer',
'emergency_broadcast': 'defer'}
emergency_broadcasting = {'name': 'emergency_broadcasting',
'entry': 'emergency_state; start_timer("t", 5000)',
'message_received': 'defer',
'emergency_received': 'defer'}
message_received = {'name': 'message_received',
'entry': 'prompt_listen',
'message_received': 'defer'}
playback_message = {'name': 'playback_message',
'entry': 'playback_message',
'message_received': 'defer'}
playback_stored = {'name': 'playback_stored',
'entry': 'listen_stored',
'message_received': 'defer'}
choose_recipients = {'name': 'choose_recipients',
'entry': 'prompt_choose',
'message_received': 'defer'}
record_message = {'name': 'record_message',
'entry': 'prompt_record',
'message_received': 'defer'}
walkie_stm = stmpy.Machine(name=name, transitions=[t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19,
t20, t21, t22, t23, t24, t25, t26, t27, t28], obj=walkie_logic, states=[idle, emergency_received, emergency_broadcasting,
message_received, playback_message, playback_stored, choose_recipients, record_message])
walkie_logic.stm = walkie_stm
return walkie_stm
receiving_emg_msg = {
'name': 'receiving_emg_msg',
# do: play() - possible other function
'do': 'print_do'
}
sending_emg_msg = {
'name': 'sending_emg_msg',
'entry': 'start_timer("t", 30000)',
#'do': 'publish()'
'do': 'print_do'
}
guitest = GUI()
machine = stmpy.Machine(
name='machine',
transitions=[t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11],
states=[idle, sending, receiving, receiving_emg_msg, sending_emg_msg],
obj=guitest)
guitest.stm = machine
driver = stmpy.Driver()
driver.add_machine(machine)
driver.start()
guitest.create_gui()
# gui (buttons or some sort) to send correct signals (triggers)
# gui.send_signal()
def __init__(self, component, name="device", id=1):
self.component = component
self.name = name
self.id = id
self._logger = logging.getLogger(__name__)
""" transitions """
t0 = {
"source": "initial",
"target": "off",
}
t1 = {
"trigger": "switch_on",
"source": "off",
"target": "no_channel",
}
t2 = {
"trigger": "switch_off",
"source": "no_channel",
"target": "off",
}
t3 = {
"trigger": "subscribe_channel",
"source": "no_channel",
"target": "idle",
"effect": "change_channel(*)",
}
t4 = {
"trigger": "unsubscribe_channel",
"source": "idle",
"target": "no_channel",
"effect": "unsubscribe_channel",
}
t5 = {
"trigger": "button_in",
"source": "idle",
"target": "reserve_channel",
"effect": "voice_recognizer(*)", # off
}
t6 = {
"trigger": "channel_unavailable",
"source": "reserve_channel",
"target": "idle",
"effect": "play_unavailable_sound",
}
t7 = {
"trigger": "channel_reserved",
"source": "reserve_channel",
"target": "speaking",
"effect": "play_success_sound",
}
t8 = {
"trigger": "button_out",
"source": "speaking",
"target": "idle",
}
t9 = {
"trigger": "over",
"source": "speaking",
"target": "idle",
"effect": "play_success_sound",
}
t10 = {
"trigger": "wake_word",
"source": "idle",
"target": "reserve_channel",
"effect": "voice_recognizer(*)", # end
}
t11 = {
"trigger": "subscribe_channel",
"source": "idle",
"target": "idle",
"effect": "change_channel(*)",
}
t12 = {
"trigger": "switch_off",
"source": "idle",
"target": "off",
}
t13 = {
'trigger': 'message',
'source': 'idle',
'target': 'play_voice_message'
}
# confirm voice message is done playing
t14 = {
'trigger': 'message_done',
'source': 'play_voice_message',
'target': 'idle'
}
# error when receiving voice message
t15 = {
'trigger': 'error',
'source': 'play_voice_message',
'target': 'idle',
'effect': 'play_error_sound'
}
""" control states """
off = {'name': 'off', 'entry': "state('off')"}
no_channel = {'name': 'no_channel', 'entry': "state('no_channel')"}
idle = {
'name': 'idle',
'entry': 'state("idle");voice_recognizer("wake")'
}
reserve_channel = {
'name':
'reserve_channel',
'entry':
'state("reserve_channel");channel_availability(); reserve_channel()'
}
speaking = {
'name': 'speaking',
'entry': 'state("speaking");start_stream_audio();receiver("off");',
'exit':
'stop_stream_audio();release_channel();ack_timout("listen")'
}
play_voice_message = {
'name': 'play_voice_message',
'entry': 'state("play_voice_message");play_message()'
}
self.stm = stmpy.Machine(name=self.name,
transitions=[
t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
t10, t11, t12, t13, t14, t15
],
states=[
off, no_channel, idle, reserve_channel,
speaking, play_voice_message
],
obj=self)
