def generate_state_machine():
pmodel = ProtoModel("Protocol Model")
pmachine = Machine(model=pmodel,
states=['0'],
initial='0',
auto_transitions=False)
pmachine.add_transition(exit_label, source='0', dest='0')
return pmachine
class Process(object):
states = ['sleeping', 'waiting', 'running', 'terminated']
def __init__(self, name):
self.name = name
# initialize the state machine
self.machine = GraphMachine(model=self,
states=self.states,
initial='sleeping')
# add transitions
self.machine.add_transition(trigger='wake_up',
source='sleeping',
dest='waiting')
self.machine.add_transition(trigger='start',
source='waiting',
dest='running',
before='display_message')
self.machine.add_transition(trigger='interrupt',
source='*',
dest='terminated',
after='display_warning')
self.machine.add_transition(trigger='random_trigger',
source='*',
dest='terminated',
conditions=['is_valid'])
# create image of the state machine (requires GraphViz and pygraphviz)
self.graph.draw('my_state_diagram.png', prog='dot')
def is_valid(self):
return random.random() < 0.5
def display_message(self):
print("I'm starting...")
def display_warning(self):
print("I've just got an interrupt!")
def random_termination(self):
print('terminated')
class IR_Model(object):
def __init__(self, name):
self.name = name
self.states = ['start']
self.machine = GraphMachine(model=self, initial='start', title=name, show_conditions=True, show_state_attributes=True)
def get_condition_list(self, self_transitions):
condition_list = []
existing_conditions = self_transitions[0].conditions
for condition in existing_conditions:
condition_list.append(condition.func) # get the string of the condition, not the condition obj
return condition_list
def update_condition_list(self, self_transitions, new_condition_list):
condition_list = self.get_condition_list(self_transitions)
for new_condition in new_condition_list:
if new_condition not in condition_list:
condition_list.append(new_condition)
return condition_list
def add_new_transition(self, trigger, source, dest):
existing_transitions = self.machine.get_transitions(trigger=trigger, source=source, dest=dest)
if len(existing_transitions) == 0:
self.machine.add_transition(trigger=trigger, source=source, dest=dest)
self.states.append(source)
self.states.append(dest)
def add_self_transition(self, state, new_condition_list):
trigger_list = self.machine.get_triggers(state)
for trigger in trigger_list:
if trigger == 'self': # self loop exists in the usage model
self_transitions = self.machine.get_transitions('self', state, state)
condition_list = self.update_condition_list(self_transitions, new_condition_list)
self.machine.remove_transition('self', state, state)
self.machine.add_transition(trigger='self', source=state, dest=state, conditions=condition_list)
self.states.append(state)
return
# when self loop doesn't exist or the state doesn't exist
self.machine.add_transition(trigger='self', source=state, dest=state, conditions=new_condition_list)
self.states.append(state)
class Request(object):
# --- validity checks ---
def is_tel_nr_valid(self):
print("is_telephone_nr_valid()")
self._user_telephone = self._payload.text()
return not re.match(r'[+]380\d{2}\d{7}', self._user_telephone) is None
def is_user_name_valid(self):
print("is_user_name_valid()")
self._user_name = self._payload.text()
return not re.match(r'\w+', self._user_name) is None
def is_home_flat_valid(self):
print("is_home_flat_valid()")
return True
def is_car_valid(self):
print("is_car_valid()")
return True
def is_cmd(self, stype):
print("is_cmd({})".format(stype))
cmd = self._payload.text()
return cmd == "{{" + stype + "}}"
def is_reg_tel_cmd(self):
return self.is_cmd(CMD_REG_TEL)
def is_add_home_flat_cmd(self):
return self.is_cmd(CMD_ADD_HOME_FLAT_NR)
def is_add_name_cmd(self):
return self.is_cmd(CMD_ADD_NAME)
def is_add_car_cmd(self):
return self.is_cmd(CMD_ADD_CAR_NR)
def is_unknown_cmd(self):
return not (self.is_reg_tel_cmd() or \
self.is_add_home_flat_cmd() or \
self.is_add_car_cmd() or \
self.is_add_name_cmd())
def db_failed(self):
return False
# --- on enter ---
def on_enter_IDENTIFY(self):
print("on_enter state={}".format(self.state))
# put sql queries into data base
# check user is present inside data base tables
# set _user_identified and _user_confirmed to an appropriate state according to db
self._user_identified = False
self._user_confirmed = False
self._need_input = False
self._need_output = True
self._message_out = TXT_IDENTIFY__NEW_USER
self._kb_out = KBD_ALL_KEYS
# ---
def generateConfirmationCode(self):
stime = str(datetime.datetime.timestamp(datetime.datetime.now()))
return str(stime).replace('.', '')[-5:]
def on_enter_REG_TEL_NR(self):
print("on_enter state={}".format(self.state))
self._need_input = True
self._message_out = TXT_REG_TEL_NR
self._kb_out = Keyboard([])
def on_enter_GOT_TEL_NR(self):
print("on_enter state={}".format(self.state))
self._confirmation_code = self.generateConfirmationCode()
self._need_input = False
self._need_output = False
self._message_out = TXT_GOT_TEL_NR
self._kb_out = KBD_ALL_KEYS
# ---
def on_enter_ADD_HOME_FL_NR(self):
print("on_enter state={}".format(self.state))
self._need_input = True
self._message_out = TXT_ADD_HOME_FL_NR
self._kb_out = Keyboard([])
def on_enter_GOT_HOME_FL_NR(self):
self._need_input = False
self._need_output = False
self._message_out = TXT_GOT_HOME_FL_NR
self._kb_out = KBD_ALL_KEYS
pass
# ---
def on_enter_ADD_CAR_NR(self):
print("on_enter state={}".format(self.state))
self._need_input = True
self._message_out = TXT_ADD_CAR_NR
self._kb_out = Keyboard([])
def on_enter_GOT_CAR_NR(self):
self._need_input = False
self._need_output = False
self._message_out = TXT_GOT_CAR_NR
self._kb_out = KBD_ALL_KEYS
pass
# ---
def on_enter_ADD_NAME(self):
print("on_enter state={}".format(self.state))
self._need_input = True
self._message_out = TXT_ADD_NAME
self._kb_out = Keyboard([])
def on_enter_GOT_NAME(self):
self._need_input = False
self._need_output = False
self._message_out = TXT_GOT_NAME
self._kb_out = KBD_ALL_KEYS
pass
# ---
def on_enter_UPDATE_DB(self):
print("on_enter state={}".format(self.state))
self._need_output = False
self._need_input = False
def on_enter_ERROR(self):
print("on_enter state={}".format(self.state))
self._message_out = ERR_GENERAL
self._kb_out = KBD_ALL_KEYS
self._need_output = False
self._need_input = False
def on_enter_DELETE(self):
print("on_enter state={}".format(self.state))
self._need_input = True
def _init_sm(self):
states = [
'NEW', 'IDENTIFY', 'REG_TEL_NR', 'GOT_TEL_NR', 'ADD_HOME_FL_NR',
'GOT_HOME_FL_NR', 'ADD_CAR_NR', 'GOT_CAR_NR', 'ADD_NAME',
'GOT_NAME', 'UPDATE_DB', 'DELETE', 'ERROR'
]
#self._machine = Machine(model=self, states=states, initial='NEW')
self._machine = Machine(model=self,
states=states,
initial='NEW',
show_conditions=True)
self._machine.add_transition('advance', 'NEW', 'IDENTIFY')
# --- IDENTIFY to ALL
self._machine.add_transition('advance',
'IDENTIFY',
'REG_TEL_NR',
unless='db_failed',
conditions='is_reg_tel_cmd')
self._machine.add_transition('advance',
'IDENTIFY',
'ADD_HOME_FL_NR',
unless='db_failed',
conditions='is_add_home_flat_cmd')
self._machine.add_transition('advance',
'IDENTIFY',
'ADD_CAR_NR',
unless='db_failed',
conditions='is_add_car_cmd')
self._machine.add_transition('advance',
'IDENTIFY',
'ADD_NAME',
unless='db_failed',
conditions='is_add_name_cmd')
self._machine.add_transition('advance',
'IDENTIFY',
'ERROR',
conditions='db_failed')
self._machine.add_transition('advance',
'IDENTIFY',
'ERROR',
conditions='is_unknown_cmd')
# --- TEL_NRs
self._machine.add_transition('advance',
'REG_TEL_NR',
'GOT_TEL_NR',
conditions='is_tel_nr_valid')
self._machine.add_transition('advance', 'REG_TEL_NR', 'ERROR')
self._machine.add_transition('advance', 'GOT_TEL_NR', 'UPDATE_DB')
# --- HOME_FL_NRs
self._machine.add_transition('advance',
'ADD_HOME_FL_NR',
'GOT_HOME_FL_NR',
conditions='is_home_flat_valid')
self._machine.add_transition('advance', 'ADD_HOME_FL_NR', 'ERROR')
self._machine.add_transition('advance', 'GOT_HOME_FL_NR', 'UPDATE_DB')
# --- CAR_NRs
self._machine.add_transition('advance',
'ADD_CAR_NR',
'GOT_CAR_NR',
conditions='is_car_valid')
self._machine.add_transition('advance', 'ADD_CAR_NR', 'ERROR')
self._machine.add_transition('advance', 'GOT_CAR_NR', 'UPDATE_DB')
# --- NAME_NRs
self._machine.add_transition('advance',
'ADD_NAME',
'GOT_NAME',
conditions='is_user_name_valid')
self._machine.add_transition('advance', 'ADD_NAME', 'ERROR')
self._machine.add_transition('advance', 'GOT_NAME', 'UPDATE_DB')
#---
self._machine.add_transition('advance',
'UPDATE_DB',
'ERROR',
conditions='db_failed')
self._machine.add_transition('advance', 'UPDATE_DB', 'DELETE')
self._machine.add_transition('advance', 'ERROR', 'DELETE')
# ---- Public ----
def get_kbd(self):
return self._kb_out
def get_message_out(self):
return self._message_out
def get_user_id(self):
self._payload.user_id()
def need_input(self):
return self._need_input
def need_output(self):
return self.need_input() or self._need_output
def finished(self):
return self.state == "DELETE"
def update_payload(self, payload):
self._payload = payload
def __init__(self, payload):
self._payload = payload
self._message_out = None
self._kb_out = None
self._user_identified = None
self._user_confirmed = None
self._user_blocked = None
self._need_input = False
self._need_output = False
self._user_telephone = ''
self._user_name = ''
self._confirmation_code = ''
self._user_home_flat = ''
self._init_sm()
class topomap(object):
states = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13',
'14', '15', '16', '17', '18', '19', '20', '21'
]
actions = ['N', 'E', 'S', 'W']
def __init__(self, init, initial_heading):
self.machine = Machine(model=self, states=topomap.states, initial=init)
self.last_state = init
self.current_heading = initial_heading
self.machine.add_transition(trigger=self.actions[0],
source='1',
dest='4')
self.machine.add_transition(trigger=self.actions[1],
source='1',
dest='5')
self.machine.add_transition(trigger=self.actions[2],
source='1',
dest='2')
self.machine.add_transition(trigger=self.actions[0],
source='2',
dest='3')
self.machine.add_transition(trigger=self.actions[1],
source='2',
dest='1')
self.machine.add_transition(trigger=self.actions[2],
source='2',
dest='10')
self.machine.add_transition(trigger=self.actions[0],
source='3',
dest='8')
self.machine.add_transition(trigger=self.actions[3],
source='3',
dest='2')
self.machine.add_transition(trigger=self.actions[1],
source='3',
dest='4')
self.machine.add_transition(trigger=self.actions[2],
source='3',
dest='9')
self.machine.add_transition(trigger=self.actions[0],
source='4',
dest='7')
self.machine.add_transition(trigger=self.actions[3],
source='4',
dest='1')
self.machine.add_transition(trigger=self.actions[1],
source='4',
dest='5')
self.machine.add_transition(trigger=self.actions[2],
source='4',
dest='3')
self.machine.add_transition(trigger=self.actions[0],
source='5',
dest='6')
self.machine.add_transition(trigger=self.actions[3],
source='5',
dest='1')
self.machine.add_transition(trigger=self.actions[2],
source='5',
dest='4')
self.machine.add_transition(trigger=self.actions[0],
source='6',
dest='11')
self.machine.add_transition(trigger=self.actions[3],
source='6',
dest='5')
self.machine.add_transition(trigger=self.actions[2],
source='6',
dest='7')
self.machine.add_transition(trigger=self.actions[0],
source='7',
dest='12')
self.machine.add_transition(trigger=self.actions[3],
source='7',
dest='4')
self.machine.add_transition(trigger=self.actions[1],
source='7',
dest='6')
self.machine.add_transition(trigger=self.actions[2],
source='7',
dest='8')
self.machine.add_transition(trigger=self.actions[3],
source='8',
dest='3')
self.machine.add_transition(trigger=self.actions[1],
source='8',
dest='7')
self.machine.add_transition(trigger=self.actions[2],
source='8',
dest='9')
self.machine.add_transition(trigger=self.actions[0],
source='9',
dest='10')
self.machine.add_transition(trigger=self.actions[3],
source='9',
dest='3')
self.machine.add_transition(trigger=self.actions[1],
source='9',
dest='8')
self.machine.add_transition(trigger=self.actions[0],
source='10',
dest='13')
self.machine.add_transition(trigger=self.actions[3],
source='10',
dest='2')
self.machine.add_transition(trigger=self.actions[1],
source='10',
dest='9')
self.machine.add_transition(trigger=self.actions[0],
source='11',
dest='16')
self.machine.add_transition(trigger=self.actions[3],
source='11',
dest='6')
self.machine.add_transition(trigger=self.actions[2],
source='11',
dest='12')
self.machine.add_transition(trigger=self.actions[3],
source='12',
dest='7')
self.machine.add_transition(trigger=self.actions[1],
source='12',
dest='11')
self.machine.add_transition(trigger=self.actions[2],
source='12',
dest='14')
self.machine.add_transition(trigger=self.actions[0],
source='13',
dest='18')
self.machine.add_transition(trigger=self.actions[3],
source='13',
dest='10')
self.machine.add_transition(trigger=self.actions[1],
source='13',
dest='14')
self.machine.add_transition(trigger=self.actions[0],
source='14',
dest='18')
self.machine.add_transition(trigger=self.actions[3],
source='14',
dest='12')
self.machine.add_transition(trigger=self.actions[1],
source='14',
dest='17')
self.machine.add_transition(trigger=self.actions[2],
source='14',
dest='13')
self.machine.add_transition(trigger=self.actions[0],
source='15',
dest='19')
self.machine.add_transition(trigger=self.actions[3],
source='15',
dest='15')
self.machine.add_transition(trigger=self.actions[1],
source='15',
dest='15')
self.machine.add_transition(trigger=self.actions[0],
source='16',
dest='19')
self.machine.add_transition(trigger=self.actions[3],
source='16',
dest='11')
self.machine.add_transition(trigger=self.actions[2],
source='16',
dest='17')
self.machine.add_transition(trigger=self.actions[3],
source='17',
dest='14')
self.machine.add_transition(trigger=self.actions[1],
source='17',
dest='16')
self.machine.add_transition(trigger=self.actions[2],
source='17',
dest='18')
self.machine.add_transition(trigger=self.actions[3],
source='18',
dest='14')
self.machine.add_transition(trigger=self.actions[1],
source='18',
dest='17')
self.machine.add_transition(trigger=self.actions[2],
source='18',
dest='13')
self.machine.add_transition(trigger=self.actions[0],
source='19',
dest='20')
self.machine.add_transition(trigger=self.actions[3],
source='19',
dest='16')
self.machine.add_transition(trigger=self.actions[1],
source='19',
dest='15')
self.machine.add_transition(trigger=self.actions[2],
source='19',
dest='21')
self.machine.add_transition(trigger=self.actions[0],
source='20',
dest='21')
self.machine.add_transition(trigger=self.actions[3],
source='20',
dest='19')
self.machine.add_transition(trigger=self.actions[2],
source='20',
dest='21')
self.machine.add_transition(trigger=self.actions[0],
source='21',
dest='20')
self.machine.add_transition(trigger=self.actions[3],
source='21',
dest='19')
self.machine.add_transition(trigger=self.actions[1],
source='21',
dest='20')
def service_callback(self, req):
action_str = "INIT"
action_str = req.action
head = actions.index(self.current_heading)
turn_arr = ['L', 'F', 'R']
turn = turn_arr.index(action_str) - 1
absolute_dir = (head + turn) % 4
try:
if absolute_dir == 0:
self.N()
elif absolute_dir == 1:
self.E()
elif absolute_dir == 2:
self.S()
elif absolute_dir == 3:
self.W()
print "current state: ", self.machine.get_state(self.state).name
print "last_state: ", self.last_state
self.last_state = self.machine.get_state(self.state).name
#m.get_graph().draw('my_state_diagram.png', prog='dot')
return self.machine.get_state(self.state).name
except transitions.core.MachineError as e:
print e
class FsmGsm(object):
""" FSM states
"""
states = ['init', 'GSM_IDLE', 'GSM_CHECK', 'GSM_READ']
request_list = [
"GSM_ACTIVE_REQUEST", "GSM_DEACTIVE_REQUEST", "GSM_POSITION_REQUEST"
]
def __init__(self, name, mi_sim868, url_post_token, url_post_notification,
refresh_token, url_get, device_id):
self.name = name
self.T_CHECK = 30
self.flag_data_available = 0
self.flag_active = 0
self.__new_active = 0
self.flag_find_car = 0
self.gsm_data = None
''' SIM868
'''
self.sim868 = mi_sim868
self.url_post_token = url_post_token
self.url_post_notification = url_post_notification
self.refresh_token = refresh_token
self.url_get = url_get
self.token = 0
self.device_id = device_id
''' Send data
'''
self.last_data = {}
""" Timeout GSM
"""
self.timeout_gsm = int(dt.now().timestamp()) + self.T_CHECK
""" Initialize the state machine
"""
self.machine = Machine(model=self,
states=FsmGsm.states,
initial='init')
""" Add transitions
"""
self.machine.add_transition(trigger='start',
source='init',
dest='GSM_IDLE')
self.machine.add_transition('fire',
'GSM_IDLE',
'GSM_CHECK',
conditions=['check_timeout'],
after='gsm_get_and_update_timeout')
self.machine.add_transition('fire',
'GSM_CHECK',
'GSM_READ',
conditions=['gsm_new_data_available'],
after='reset_flag_new_data_available')
self.machine.add_transition(
'fire',
'GSM_CHECK',
'GSM_IDLE',
conditions=['gsm_not_new_data_available_and_active'],
after='read_data_and_gsm_send')
self.machine.add_transition(
'fire',
'GSM_CHECK',
'GSM_IDLE',
conditions=['gsm_not_new_data_available_and_not_active'])
self.machine.add_transition('fire',
'GSM_READ',
'GSM_IDLE',
conditions=['active_request'],
after='set_alarm')
self.machine.add_transition('fire',
'GSM_READ',
'GSM_IDLE',
conditions=['deactive_request'],
after='reset_alarm')
self.machine.add_transition('fire',
'GSM_READ',
'GSM_IDLE',
conditions=['invalid_request'])
self.__n = 0
# Funciones de guarda
def check_timeout(self):
return int(dt.now().timestamp()) > self.timeout_gsm
def gsm_new_data_available(self):
return self.flag_data_available
def gsm_not_new_data_available_and_active(self):
return (not self.flag_data_available and self.flag_active)
def gsm_not_new_data_available_and_not_active(self):
return (not self.flag_data_available and not self.flag_active)
def active_request(self):
return (self.__new_active == 1)
def deactive_request(self):
return (self.__new_active == 0)
def invalid_request(self):
print("Dato no valido")
return (self.__new_active != 1 and self.__new_active != 0)
# Funciones salida
def gsm_get_and_update_timeout(self):
self.get_token()
headers = f"Authorization: Bearer {self.token}"
rcv = (self.sim868.gsm_get(self.url_get, headers))
try:
json_text = re.search("({.*})", rcv)[0]
rcv_dict = json.loads(json_text)
self.__new_active = int(rcv_dict["parameters"]["active"])
except:
pass
print(f"new_active = {self.__new_active}; active: {self.flag_active}")
if self.flag_active != self.__new_active:
self.flag_data_available = 1
print("flag_data_available = 1")
self.timeout_gsm = self.timeout_gsm + self.T_CHECK
self.__n += 1
def read_data_and_gsm_send(self):
print("------ GSM SEND ------")
self.get_token()
'''Send notification'''
body_dict = {
"notification": self.device_id,
"parameters": self.last_data
}
body = json.dumps(body_dict)
headers = f"Authorization: Bearer {self.token}"
self.sim868.gsm_post(url=self.url_post_notification,
headers=headers,
body=body)
def get_token(self):
'''Get token'''
body = {"refreshToken": self.refresh_token}
response = self.sim868.gsm_post(url=self.url_post_token,
body=json.dumps(body))
json_text = re.search("({.*})", response)[0]
token_dict = json.loads(json_text)
self.token = token_dict["accessToken"]
def reset_flag_new_data_available(self):
print("Reset flag new data available")
self.flag_data_available = 0
def set_alarm(self):
self.flag_active = 1
print("------Set alarm!------")
def reset_alarm(self):
self.flag_active = 0
print("------Reset alarm!------")
class DailyRoutineMachine(object):
states = ['awake', 'asleep', 'begging']
def __init__(self, name):
self.name = name
self.begging_from = None
self.machine = Machine(model=self,
states=DailyRoutineMachine.states,
initial='awake')
# Go To Bed Trigger / Intent
# TODO: Determine order of operations for transition as I'm using conditionals first
# then allowing a non-conditional catch-all.
self.machine.add_transition(trigger='go_to_bed',
source='awake',
dest='begging',
conditions='should_beg',
before='set_begging_from')
self.machine.add_transition('go_to_bed', 'awake', 'asleep')
# Get Up Trigger / Intent
self.machine.add_transition('get_up',
'asleep',
'begging',
conditions='should_beg',
before='set_begging_from')
self.machine.add_transition('get_up', 'asleep', 'awake')
# Yes Trigger / Intent
self.machine.add_transition('yes',
'begging',
'asleep',
conditions='is_begging_to_stay_awake',
after='reset_begging_from')
self.machine.add_transition('yes',
'begging',
'awake',
conditions='is_begging_to_stay_asleep',
after='reset_begging_from')
# No Trigger / Intent
self.machine.add_transition('no',
'begging',
'awake',
conditions='is_begging_to_stay_awake',
after='reset_begging_from')
self.machine.add_transition('no',
'begging',
'asleep',
conditions='is_begging_to_stay_asleep',
after='reset_begging_from')
# TODO: Determine if there is a better way of handling "after='reset_begging_from'". Very Repetitive.
# State Retry Replies
def current_retry(self):
# Returning a retry this way is convenient because
# The retries I have do not need to pass variables
# into the template.
current_retry_name = self.state + '_retry'
return render_question(current_retry_name)
# State Replies
def current_reply(self):
# Handy if you need to send variables into the template.
current_reply_name = self.state + '_reply'
current_reply_method = getattr(self, current_reply_name)
return current_reply_method()
def asleep_reply(self):
return render_question('asleep_reply', state=self.state)
def awake_reply(self):
return render_question('awake_reply', state=self.state)
def begging_reply(self):
return render_question('begging_reply',
state=self.state,
begging_from=self.begging_from)
# Transition Extras
def set_begging_from(self):
self.begging_from = self.state
def reset_begging_from(self):
self.begging_from = None
def execute_transition(self, name):
transition = getattr(self, name)
try:
# If a transition has conditionals
# but they are not met, the transition will
# return False.
assert True == transition()
return self.current_reply()
except (MachineError, AssertionError):
# We weren't able to make the transition.
# Send back the states retry msg.
return self.current_retry()
# Transition Conditions
def is_begging_to_stay_awake(self):
return self.begging_from == 'awake'
def is_begging_to_stay_asleep(self):
return self.begging_from == 'asleep'
@staticmethod
def should_beg():
return random() < 0.50 # 50/50 chance there is gonna be begging
# Machine Helpers
def show_graph(self):
# graph object is created by the machine
self.graph.draw('state.png', prog='dot')
display(Image('state.png'))
def return_false_v2(self):
return False
def onA(self):
print("entered A")
def onB(self):
print("entered B")
def atob(self):
print("before : a to b")
def btoa(self):
print("after : b to a")
woman_bot = Game()
machine = Machine(model=woman_bot, states=states, initial="woman_A", ignore_invalid_triggers=True, title="figure record")
machine.add_transition("a_to_b", "woman_A", "woman_B",
conditions="return_true", before="atob")
machine.add_transition("b_to_a", "woman_B", "woman_A",
conditions=["return_false_v1"])
machine.add_transition("b_to_a_unless", "woman_B", "woman_A",
unless=["return_false_v1", "return_false_v2"], after="btoa")
machine.on_enter_woman_B("onB")
machine.on_enter_woman_A("onA")
woman_bot.a_to_b()
print(woman_bot.state)
# woman_bot.b_to_a()
# print(woman_bot.state)
woman_bot.b_to_a_unless()
print(woman_bot.state)
class ungetauftes_wesen(object):
states = ['idle', 'move', 'check', 'move_straight', 'move_to_side','move_forward', 'move_back', 'orientate', 'open_gripper', 'rotate_gripper_fixed','vision','rotate_gripper_free','close_gripper','check_grip']
def __init__(self, name):
self.name = name
self.havecommand = False
self.command = " "
self.angle_of_deviation = 0.0
self.forward = True
self.gripA = True
self.gripB = True
self.orientation = [0,0,0,0,0]
self.moves_left=5
# Initialize the state machine
self.machine = Machine(model=self, states=ungetauftes_wesen.states, initial='idle')
self.machine.add_transition(trigger='wake_up', source='idle', dest='move')
self.machine.add_transition('move_straight', 'move', 'move_forward',conditions=['is_direction_forward'])
self.machine.add_transition('move_straight', 'move', 'move_back',unless=['is_direction_forward'])
self.machine.add_transition('orientate', 'move_forward', 'orientate')
self.machine.add_transition('orientate', 'move_back', 'orientate')
self.machine.add_transition('open_gripper', 'orientate', 'open_gripper')
self.machine.add_transition('close_gripper', 'vision', 'close_gripper')
self.machine.add_transition('rotate_gripper_fixed', 'open_gripper', 'rotate_gripper_fixed')
self.machine.add_transition('vision', 'rotate_gripper_fixed', 'vision')
self.machine.add_transition('check', 'idle', 'check')
# Sweat is a disorder that can be remedied with water.
# Unless you've had a particularly long day, in which case... bed time!
self.machine.add_transition('move_finished', 'close_gripper', 'idle', conditions=['is_exhausted'])
self.machine.add_transition('move_finished', 'close_gripper', 'move',)
#self.machine.add_ordered_transitions(['move_forward', 'orientate'])
## CONDITIONS
def is_exhausted(self):
""" Basically a coin toss. """
return self.moves_left < 0.5
def is_direction_forward(self): return self.forward
## CONDITIONS
def on_enter_move(self):
print("entered state move")
self.moves_left-=1
print str(self.moves_left)+(" moves left")
self.move_straight()
def on_enter_move_forward(self):
print("entered state move forward flag set")
self.forward = False
self.orientate()
def on_enter_move_back(self):
print("entered state move back flag set")
self.forward = True
self.orientate()
def on_enter_idle(self):
print("entered state idle")
def on_enter_orientate(self):
print("entered state orientate")
self.open_gripper()
def on_enter_open_gripper(self):
print("entered state open_gripper")
senddata("testdata")
print str(checkdata('fever'))
self.rotate_gripper_fixed()
def on_enter_rotate_gripper_fixed(self):
print("entered state rotate_gripper_fixed")
print("Wait for Signal:")
self.havecommand = True
self.command = "rotate"
def on_enter_vision(self):
print("entered state vision")
self.angle_of_deviation = get_course()
print "Our course is: " + str(self.angle_of_deviation)
self.close_gripper()
def on_enter_close_gripper(self):
print("entered state close_gripper")
print("Wait for Signal:")
sleep(.5)
print(".")
sleep(.5)
print(".")
sleep(.5)
print(".")
self.move_finished()
class FsmGps(object):
""" FSM states
"""
states = ['init', 'OFF', 'ON', 'ASSAULT']
""" Default timeout for GPS frame sending
"""
def __init__(self, name, mi_sim868):
self.TIMEOUT_DEFAULT = 30
self.name = name
""" Input shared variables
"""
self.flag_active = 0
""" Timeout GPS
"""
self.timeout_gps = 0
''' GPS dictionary
'''
self.gps_param = {
'GNSS_status': 0,
'UTC': '', # yyyyMMddhhmmss.sss
'Latitude': 0.0, # ±dd.dddddd [-90.000000,90.000000]
'Longitude': 0.0, # ±ddd.dddddd [-180.000000,180.000000]
'Altitude': 0.0, # in meters
'Speed': 0.0, # km/h [0,999.99]
}
""" Initialize the state machine
"""
self.machine = Machine(model=self,
states=FsmGps.states,
initial='init')
self.sim868 = mi_sim868
""" Add transitions
"""
self.machine.add_transition(trigger='start', source='init', dest='OFF')
self.machine.add_transition('fire',
'OFF',
'ON',
conditions=['is_active'])
self.machine.add_transition('fire',
'ON',
'OFF',
conditions=['is_not_active'])
self.machine.add_transition('fire',
'ON',
'ON',
conditions=['timeout_and_active'],
after='send_gps_frame_and_init_timer')
""" Guard functions
"""
def is_active(self):
return self.flag_active
def is_not_active(self):
return not self.flag_active
def timeout_and_active(self):
return ((int(dt.now().timestamp()) > self.timeout_gps)
and self.flag_active)
""" Output functions
TODO: Modify GPS frame sending with GPS drivers
"""
def send_gps_frame_and_init_timer(self):
gps_data = self.sim868.get_gps_data()
self.gps_param['UTC'] = gps_data["UTC"]
self.gps_param['Latitude'] = gps_data["Latitude"]
self.gps_param['Longitude'] = gps_data["Longitude"]
self.gps_param['Altitude'] = gps_data["Altitude"]
self.gps_param['Speed'] = gps_data["Speed"]
print(
"'UTC': {}, 'Latitude': {}, 'Longitude': {}, 'Altitude': {}, 'Speed': {}"
.format(self.gps_param["UTC"], self.gps_param["Latitude"],
self.gps_param["Longitude"], self.gps_param["Altitude"],
self.gps_param["Speed"]))
self.timeout_gps = int(dt.now().timestamp()) + self.TIMEOUT_DEFAULT
states=states,
transitions=transitions,
initial="first")
# method to do transition
print(life_bot.state)
life_bot.go_to_second()
life_bot.go_to_third()
print(life_bot.state)
life_bot.to_first()
print(life_bot.state)
life_bot.trigger("go_to_second")
print(life_bot.state)
life_bot.trigger("go_to_third")
print(life_bot.state)
machine.set_state("first")
print(life_bot.state)
# add state and transitions
machine.add_state("red")
machine.add_states(["green", "blue"])
# alternate machine.add_transition(trigger= ?, source=?, dest=?)
# machine.add_transition("r_to_b", "red", "blue")
machine.add_transition("other_to_r", ["blue", "green"], "red")
class Gandalf(object):
face_in_front = False
wants_to_enter = None
testing_mode = False
allowed_people_dict = {}
current_person = None
delete_faces = True
force_make_queue = False
STATES = [
"start", "started", "initialized", "face_detected",
"intention_recognized", "validate_card", "on_side"
]
def __init__(self, robot, testing_mode=False):
self.robot = robot
self.testing_mode = testing_mode
# Initialize the state machine
self.state_machine = Machine(model=self,
states=self.STATES,
queued=True,
initial="start")
self.state_machine.add_transition(
trigger="starting_up",
source="start",
dest="started",
after=lambda *args, **kwargs: starting_up(self, *args, **kwargs))
self.state_machine.add_transition(
trigger="initializing",
source="started",
dest="initialized",
after=lambda *args, **kwargs: initializing(self, *args, **kwargs))
self.state_machine.add_transition(
trigger="detecting_face",
source="*",
dest="face_detected",
after=lambda *args, **kwargs: recognizing_face(
self, *args, **kwargs))
self.state_machine.add_transition(
trigger="question_intention",
source="face_detected",
dest="intention_recognized",
after=lambda *args, **kwargs: intention_recognizing(
self, *args, **kwargs))
self.state_machine.add_transition(
trigger="validate_entry",
source=["intention_recognized", "validate_card"],
dest="validate_card",
after=lambda *args, **kwargs: validation_card_reading(
self, *args, **kwargs))
self.state_machine.add_transition(
trigger="move_to_side",
source="validate_card",
dest="on_side",
after=lambda *args, **kwargs: move_to_side(self, *args, **kwargs))
self.state_machine.add_transition(
trigger="move_back",
source="on_side",
dest="initialized",
after=lambda *args, **kwargs: move_back(self, *args, **kwargs))
self.state_machine.add_transition(
trigger="re_initialize",
source="*",
dest="initialized",
after=lambda *args, **kwargs: initializing(self, *args, **kwargs))
