class Light(Agent):
states = [
State(name='off', on_enter=['set_off']),
State(name='low', on_enter=['set_low']),
State(name='medium', on_enter=['set_medium']),
State(name='high', on_enter=['set_high'])
]
def __init__(self, unique_id, model, room):
super().__init__(unique_id, model)
self.room = room
self.wait_off = 15
self.luminosity = 500
self.machine = Machine(model=self, states=Light.states, initial='off')
self.machine.add_transition('switch_off', '*', 'off')
self.machine.add_transition('switch_low', '*', 'low')
self.machine.add_transition('switch_medium', '*', 'medium')
self.machine.add_transition('switch_high', '*', 'high')
def sensorCheck(self):
userInRoom = self.model.ThereIsSomeOccupantInRoom(self.room)
if userInRoom == True:
if 450 > self.luminosity:
self.switch_low()
elif 750 > self.luminosity > 450:
self.switch_medium()
else:
self.switch_high()
else:
if self.state != 'off':
if self.wait_off > 0:
self.wait_off = self.wait_off - 1
else:
self.switch_off()
self.wait_off = 3
else:
pass
def regularBehaviour(self):
pass
def step(self):
#print('light: ', self.unique_id, self.state, self.room.name)
self.sensorCheck()
#Metodos de entrada y salida de los estados
def set_off(self):
model.ramenScript.addLightState(self.room, 'low', self.model.NStep)
def set_low(self):
model.ramenScript.addLightState(self.room, 'medium', self.model.NStep)
def set_medium(self):
model.ramenScript.addLightState(self.room, 'high', self.model.NStep)
def set_high(self):
model.ramenScript.addLightState(self.room, 'high', self.model.NStep)
def test_state_callbacks(self):
class Model:
def on_enter_A(self):
pass
def on_exit_A(self):
pass
def on_enter_B(self):
pass
def on_exit_B(self):
pass
states = [
State(name='A', on_enter='on_enter_A', on_exit='on_exit_A'),
State(name='B', on_enter='on_enter_B', on_exit='on_exit_B')
]
machine = Machine(Model(), states=states)
state_a = machine.get_state('A')
state_b = machine.get_state('B')
self.assertEqual(len(state_a.on_enter), 1)
self.assertEqual(len(state_a.on_exit), 1)
self.assertEqual(len(state_b.on_enter), 1)
self.assertEqual(len(state_b.on_exit), 1)
def test_state_callable_callbacks(self):
class Model:
def __init__(self):
self.exit_A_called = False
self.exit_B_called = False
def on_enter_A(self, event):
pass
def on_enter_B(self, event):
pass
states = [
State(name='A',
on_enter='on_enter_A',
on_exit='tests.test_core.on_exit_A'),
State(name='B', on_enter='on_enter_B', on_exit=on_exit_B),
State(name='C', on_enter='tests.test_core.AAAA')
]
model = Model()
machine = Machine(model, states=states, send_event=True, initial='A')
state_a = machine.get_state('A')
state_b = machine.get_state('B')
self.assertEqual(len(state_a.on_enter), 1)
self.assertEqual(len(state_a.on_exit), 1)
self.assertEqual(len(state_b.on_enter), 1)
self.assertEqual(len(state_b.on_exit), 1)
model.to_B()
self.assertTrue(model.exit_A_called)
model.to_A()
self.assertTrue(model.exit_B_called)
with self.assertRaises(AttributeError):
model.to_C()
def __init__(self):
''' Constructor.
'''
DomainBehavior.__init__(self)
self.state = {'status': 'IDLE', 'sigma': INFINITY}
self.proc = 0
self.x = {}
self.y = {}
self.pos = [-1] * 100
''' The object '''
self.lump = Lamp()
# The states
self.states = [
State(name='on', on_enter=['say_im_turned_on']),
State(name='off', on_enter=['say_im_turned_off'])
]
self.transitions = [{
'trigger': 'illuminate',
'source': 'off',
'dest': 'on'
}, {
'trigger': 'darken',
'source': 'on',
'dest': 'off'
}]
# Initialize
self.machine = Machine(self.lump,
states=self.states,
transitions=self.transitions,
initial='off')
def test_ignore_invalid_triggers(self):
a_state = State('A')
transitions = [['a_to_b', 'A', 'B']]
# Exception is triggered by default
b_state = State('B')
m1 = Machine(None, states=[a_state, b_state], transitions=transitions,
initial='B')
with self.assertRaises(MachineError):
m1.a_to_b()
# Exception is suppressed, so this passes
b_state = State('B', ignore_invalid_triggers=True)
m2 = Machine(None, states=[a_state, b_state], transitions=transitions,
initial='B')
m2.a_to_b()
# Set for some states but not others
new_states = ['C', 'D']
m1.add_states(new_states, ignore_invalid_triggers=True)
m1.to_D()
m1.a_to_b() # passes because exception suppressed for D
m1.to_B()
with self.assertRaises(MachineError):
m1.a_to_b()
# Set at machine level
m3 = Machine(None, states=[a_state, b_state], transitions=transitions,
initial='B', ignore_invalid_triggers=True)
m3.a_to_b()
class PC(Agent):
states = [
State(name='off', on_enter=['set_off']),
State(name='on', on_enter=['set_on']),
State(name='standby', on_enter=['set_standby'])
]
def __init__(self, unique_id, model, x, y, downUp):
super().__init__(unique_id, model)
self.x = x
self.y = y
self.pos = (x, y)
self.down_up = downUp
self.machine = Machine(model=self, states=PC.states, initial='off')
self.machine.add_transition('turn_on', '*', 'on')
self.machine.add_transition('turn_standby', 'on', 'standby')
self.machine.add_transition('turn_off', '*', 'off')
def sensorCheck(self):
if (self.down_up == 'u'):
userNear = self.model.ThereIsUserUp((self.x, self.y),
self.unique_id)
else:
userNear = self.model.ThereIsUserDown((self.x, self.y),
self.unique_id)
if userNear == True:
if self.state == 'on':
pass
else:
actions = self.model.actionsNear
if actions['channel'] == 'PCOff' and actions[
'action'] == 'TurnOnPC':
self.turn_on()
else:
if self.state == 'on':
actions = self.model.actionsFar
if actions['channel'] == 'PCOn' and actions[
'action'] == 'TurnStandbyPC':
self.turn_standby()
if actions['channel'] == 'PCOn' and actions[
'action'] == 'TurnOffPC':
self.turn_off()
else:
pass
def step(self):
self.sensorCheck()
def set_off(self):
pass
def set_on(self):
pass
def set_standby(self):
pass
def test_pass_state_instances_instead_of_names(self):
state_A = State('A')
state_B = State('B')
states = [state_A, state_B]
m = Machine(states=states, initial=state_A)
assert m.state == 'A'
m.add_transition('advance', state_A, state_B)
m.advance()
assert m.state == 'B'
async def run(robot: cozmo.robot.Robot):
states = [
State(name='LocateCube', on_enter=[], on_exit=[]),
State(name='GetCloser', on_enter=[], on_exit=[]),
State(name='Backup', on_enter=[], on_exit=[]),
State(name='Stop', on_enter=[], on_exit=[]),
]
transitions = [
{
'trigger': 'lostCube',
'source': ['GetCloser', 'Backup', 'Stop'],
'dest': 'LocateCube'
},
{
'trigger': 'foundCube',
'source': 'LocateCube',
'dest': 'GetCloser'
},
{
'trigger': 'tooClose',
'source': 'GetCloser',
'dest': 'Backup'
},
{
'trigger': 'correctDistance',
'source': ['GetCloser', 'Backup'],
'dest': 'Stop'
},
{
'trigger': 'tooFar',
'source': 'Backup',
'dest': 'GetCloser'
},
]
initState = 'LocateCube'
machine = Machine(model=robot,
states=states,
transitions=transitions,
initial=initState,
ignore_invalid_triggers=True)
imgStates = [("images/locate.png", Image.BICUBIC),
("images/getcloser.png", Image.BICUBIC),
("images/backup.png", Image.BICUBIC),
("images/stop.png", Image.BICUBIC)]
for img, smp in imgStates:
image = Image.open(img)
resizeImg = image.resize(cozmo.oled_face.dimensions(), smp)
image = cozmo.oled_face.convert_image_to_screen_data(resizeImg,
invert_image=True)
faceImages.append(image)
image = cv2.imread(img, 0)
imgs.append(image)
while True:
robot, key = await switch[robot.state](robot)
if key == ord("p"):
break
class Light(Agent):
states = [
State(name='off', on_enter=['set_off']),
State(name='on', on_enter=['set_on'])
]
def __init__(self, unique_id, model, room):
super().__init__(unique_id, model)
self.room = room
self.consume = configuration.settings.consume_light_byroom_medium
self.wait_off = int(configuration.settings.time_to_off_light * 60 *
100 / configuration.settings.time_by_step)
self.machine = Machine(model=self, states=Light.states, initial='off')
self.machine.add_transition('switch_on', '*', 'on')
self.machine.add_transition('switch_off', '*', 'off')
def sensorCheck(self):
userInRoom = self.model.ThereIsSomeOccupantInRoom(self.room)
if userInRoom == True:
if self.state == 'on':
pass
else:
self.switch_on()
else:
if self.state == 'on':
if self.wait_off > 0:
self.wait_off = self.wait_off - 1
else:
self.switch_off()
self.wait_off = int(
configuration.settings.time_to_off_light * 60 * 100 /
configuration.settings.time_by_step)
else:
pass
def regularBehaviour(self):
pass
def step(self):
#print('light: ', self.unique_id, self.state, self.room.name)
self.model.consumeEnergy(self)
if (self.model.modelWay != 0):
self.sensorCheck()
else:
self.regularBehaviour()
def set_off(self):
self.model.lightsOn.remove(self)
def set_on(self):
self.model.lightsOn.append(self)
def exit(self, event_data):
""" Call on_exit method on state object """
log.debug("%s.exit '%s' callback.", self.__class__.__name__, self.tag)
if hasattr(self, 'on_exit_state') and callable(self.on_exit_state):
try:
self.on_exit_state(event_data)
except:
traceback.print_exc()
pdb.post_mortem()
raise
State.exit(self, event_data)
def test_pass_state_instances_instead_of_names(self):
state_A = State('A')
state_B = State('B')
states = [state_A, state_B]
m = Machine(states=states, initial=state_A)
assert m.state == 'A'
m.add_transition('advance', state_A, state_B)
m.advance()
assert m.state == 'B'
state_B2 = State('B', on_enter='this_passes')
with self.assertRaises(ValueError):
m.add_transition('advance2', state_A, state_B2)
def _load_state(self, state):
self.logger.debug("Loading state: {}".format(state))
s = None
try:
state_module = load_module('pocs.state.states.{}.{}'.format(
self._state_table_name, state))
# Get the `on_enter` method
self.logger.debug("Checking {}".format(state_module))
on_enter_method = getattr(state_module, 'on_enter')
setattr(self, 'on_enter_{}'.format(state), on_enter_method)
self.logger.debug("Added `on_enter` method from {} {}".format(
state_module, on_enter_method))
self.logger.debug("Created state")
s = State(name=state)
s.add_callback('enter', '_update_status')
if can_graph:
s.add_callback('enter', '_update_graph')
s.add_callback('enter', 'on_enter_{}'.format(state))
except Exception as e:
raise error.InvalidConfig(
"Can't load state modules: {}\t{}".format(state, e))
return s
def __init__(self, *args, document, **kwargs):
if 'tag' not in kwargs:
kwargs['tag'] = self.__class__.__name__
name = kwargs.get('name', kwargs['tag'])
self.document = document
# node consumes data
Node.__init__(self, *args, **kwargs)
State.__init__(
self,
name,
on_enter=kwargs.get('on_enter'),
on_exit=kwargs.get('on_exit'),
ignore_invalid_triggers=kwargs.get('ignore_invalid_triggers'))
self.data = self
class WaitForUserFSM(BrainFSM):
states = [
State(name='wait_for_user',
on_enter=[
'state_update_program_item', 'check_robot_in',
'state_wait_for_user'
],
on_exit=['check_robot_out']),
]
transitions = [
('wait_for_user', 'program_run', 'wait_for_user'),
('done', 'wait_for_user', 'program_load_instruction'),
('error', 'wait_for_user', 'program_error'),
]
state_functions = ['state_wait_for_user']
def run(self):
self.fsm.wait_for_user()
def state_wait_for_user(self, event):
rospy.logdebug('Current state: state_wait_for_user')
self.brain.state_manager.update_program_item(
self.brain.ph.get_program_id(), self.brain.block_id,
self.brain.instruction)
rate = rospy.Rate(10)
while self.brain.user_activity != UserActivity.READY and self.brain.executing_program \
and not rospy.is_shutdown():
rate.sleep()
self.fsm.done(success=True)
def __init__(self):
"""
Initializes the Model and registers the default state machine transitions
available to all models.ctor
"""
self.state = None
self._endpoint_service = None
states = [
State(n, on_enter='new_state_entered') for n in _transform_states
]
self._machine = Machine(model=self,
states=states,
initial='started',
auto_transitions=False)
self._machine.add_transition(trigger='fail',
source=list(_transform_states -
{'terminated'}),
dest='failed')
self._machine.add_transition(trigger='ready',
source=['started', 'transforming'],
dest='ready')
self._machine.add_transition(trigger='transform',
source=['started', 'ready'],
dest='transforming',
after='_do_transform')
self._machine.add_transition(
trigger='terminate',
source=list(_transform_states -
{'terminating', 'terminated', 'failed'}),
dest='terminating',
after='_do_terminate')
self._machine.add_transition(trigger='terminated',
source='terminating',
dest='terminated')
def get_machine(model):
"""Create the parser state machine.
:param model: An instance of DbtLogParser. The state machine will
mutate the parser after this function is invoked.
"""
m = Machine(
model=model,
states=[
State(name=States.SEEK_START),
State(name=States.SEEK_START_SUMMARY),
State(name=States.SEEK_FINISH),
State(name=States.SEEK_DONE),
State(name=States.DONE),
],
initial=States.SEEK_START,
)
# the states above are linear in order; by using `add_ordered_transitions`
# we automatically make it such that the single trigger `process_next_line`
# will move linearly between states as ordered above.
m.add_ordered_transitions(
trigger="process_next_line",
# `condition` has a 1:1 mapping with states i.e.
# we will not transition out of the first state until the first condition
# is satisfied. conditions correspond to boolean attributes on the model
# i.e. the parser
conditions=[
"found_start",
"found_start_summary",
"found_finish",
"found_done",
lambda *args, **kwargs: True,
],
# before attempting to transition, the following functions will be
# invoked with any args or kwargs passed to `process_next_line`;
# `prepare` occurs before conditions are evaluated;
# if conditions fail to pass, a transition is halted;
# in this way, we assure each attempted transition processes another
# log line
prepare=[
"seek_start", "seek_summary", "seek_finish", "seek_done", None
],
)
return m
def add_state(self, name, on_enter=None, on_exit=None):
"""
Append new state to the bot's states list
See transitions.State class docs for more details.
"""
args = locals()
del args['self']
self.states.append(State(**args))
class Bulb(Agent):
states = [
State(name='off', on_enter=['set_off']),
State(name='on', on_enter=['set_on'])
]
def __init__(self, unique_id, model, room):
super().__init__(unique_id, model)
self.room = room
self.machine = Machine(model=self, states=Bulb.states, initial='off')
self.machine.add_transition('switch_on', '*', 'on')
self.machine.add_transition('switch_off', '*', 'off')
def sensorCheck(self):
userInRoom = self.model.ThereIsUserInRoom(self.room)
if userInRoom == True:
if self.state == 'on':
pass
else:
actions = self.model.actionsNear
if actions['channel'] == 'Bulb' and actions[
'action'] == 'SwitchOn':
self.switch_on()
else:
if self.state == 'off':
pass
else:
actions = self.model.actionsFar
if actions['channel'] == 'Bulb' and actions[
'action'] == 'SwitchOff':
self.switch_off()
else:
pass
def step(self):
print(self.unique_id, self.state)
self.sensorCheck()
def set_off(self):
pass
def set_on(self):
pass
def _load_state(self, state):
self.logger.debug("Loading state: {}".format(state))
s = None
try:
state_module = load_module('{}.{}.{}'.format(
self._states_location.replace("/", "."),
self._state_table_name,
state
))
# Get the `on_enter` method
self.logger.debug("Checking {}".format(state_module))
on_enter_method = getattr(state_module, 'on_enter')
setattr(self, 'on_enter_{}'.format(state), on_enter_method)
self.logger.debug(
"Added `on_enter` method from {} {}".format(
state_module, on_enter_method))
self.logger.debug("Created state")
s = State(name=state)
s.add_callback('enter', '_update_status')
if can_graph:
s.add_callback('enter', '_update_graph')
s.add_callback('enter', 'on_enter_{}'.format(state))
except Exception as e:
raise error.InvalidConfig("Can't load state modules: {}\t{}".format(state, e))
return s
def __init__(self, unique_id, model, json, speed = 0.71428):
super().__init__(unique_id, model)
"""
Create a new Occupant object.
Args:
unique_id: Unique identifier corresponding to the agent.
models: Associated Model object
json: Json of definition of parameters of behavior
speed: Movement speed in m/s
Return: Occupant object
"""
self.shape = 'circle' if json.get('shape') == None else json.get('shape')
self.model.schedule.add(self)
self.color = 'blue' if json.get('color') == None else json.get('color')
self.variationSchedule = json.get('variation')
self.jsonSchedule = json['schedule']
self.schedule = json['schedule'].copy()
self.setTodaySchedule()
self.type = json['type']
self.markovActivity = json['markovActivity']
self.timeActivity = json['timeActivity']
self.timeActivityVariation = json.get('timeActivityVariation')
self.positionByStateAux = json['states']
#State machine
self.positionByState = {}
self.states = []
for k, v in json['states'].items():
name = k
on_enter = 'start_activity'
on_exit = 'finish_activity'
self.states.append(State(name=name, on_enter=[on_enter], on_exit=[on_exit]))
self.machine = Machine(model=self, states=self.states, initial=list(json['states'].items())[0][0])
self.triggers = {}
n_state = 0
for k, v in json['states'].items():
name = k
self.machine.add_transition('setState'+str(n_state), '*', name)
self.triggers[name] = 'setState'+str(n_state)+'()'
n_state = n_state + 1
self.markov_machine = Markov(self)
self.speed = speed
self.markov = True
self.time_activity = 0
self.lastSchedule = 0.0
self.N = 0
self.pos = (0, 0)
self.pos_to_go = (0, 0)
self.movements = [self.pos]
self.inbuilding = False
def createNewState(self, textStr):
self.statesCounter = self.getNextStateId()
logger.debug("Created state " +
self.convertStateIdToName(self.statesCounter))
self.machine.add_states(
State(name=self.convertStateIdToName(self.statesCounter)))
self.stateIdToContent[self.convertStateIdToName(
self.statesCounter)] = textStr
return self.statesCounter
def _init_state_machine(self):
states = [
State(name='Init', on_exit=['_save_state']),
State(name='first_timestamp', on_exit=['_save_state']),
State(name='timestamp', on_exit=['_save_state']),
State(name='running', on_exit=['_save_state']),
State(name='walking', on_exit=['_save_state']),
State(name='running', on_exit=['_save_state']),
State(name='distance', on_exit=['_save_state']),
State(name='steps', on_exit=['_save_state'])
]
self.machine = Machine(model=self, states=states, initial='Init')
self.machine.add_transition('run',
'Init',
'first_timestamp',
conditions=['_is_first_timestamp'])
self.machine.add_transition('run',
'first_timestamp',
'timestamp',
conditions=['_is_timestamp'])
self.machine.add_transition('run',
'*',
'timestamp',
conditions=['_is_timestamp'])
self.machine.add_transition('run',
'timestamp',
'running',
conditions=['_is_running'])
self.machine.add_transition('run',
'timestamp',
'walking',
conditions=['_is_walking'])
self.machine.add_transition('run',
'walking',
'steps',
conditions=['_is_step'])
self.machine.add_transition('run',
'walking',
'distance',
conditions=['_is_distance'])
self.machine.add_transition('run',
'running',
'steps',
conditions=['_is_step'])
self.machine.add_transition('run',
'running',
'distance',
conditions=['_is_distance'])
self.machine.on_enter_distance(self._handle_distance)
self.machine.on_enter_steps(self._handle_steps)
def machine(self):
if self._machine is None:
self._initial = State(name='machine_initial')
self._machine = CustomStateMachine(model=self,
initial=self._initial,
auto_transitions=False,
show_conditions=True,
show_auto_transitions=True,
show_state_attributes=True)
return self._machine
class DummyFSM(BrainFSM):
states = [
State(name='dummy',
on_enter=['state_update_program_item', 'state_dummy']),
State(name='learning_dummy',
on_enter=['learning_load_block_id', 'state_learning_dummy']),
State(name='learning_dummy_run',
on_enter=['learning_load_block_id', 'state_learning_dummy_run']),
]
transitions = [('dummy', 'program_run', 'dummy'),
('done', 'dummy', 'program_load_instruction'),
('error', 'dummy', 'program_error'),
('dummy', 'learning_run', 'learning_dummy'),
('done', 'learning_dummy', 'learning_step_done'),
('error', 'learning_dummy', 'learning_step_error'),
('dummy_run', 'learning_run', 'learning_dummy_run'),
('done', 'learning_dummy_run', 'learning_run'),
('error', 'learning_dummy_run', 'learning_step_error')]
state_functions = [
'state_dummy', 'state_learning_dummy', 'state_learning_dummy_run'
]
def run(self):
self.fsm.dummy()
def learning(self):
self.fsm.dummy()
def learning_run(self):
self.fsm.dummy_run()
def state_dummy(self, event):
rospy.logdebug('Current state: state_dummy')
self.fsm.done(success=True)
def state_learning_dummy(self, event):
rospy.logdebug('Current state: state_dummy_points')
def state_learning_dummy_run(self, event):
rospy.logdebug('Current state: state_learning_dummy_run')
self.fsm.done(success=True)
class TestFSM(object):
states = [
State('r', on_enter='set_red'),
State('g', on_enter='set_green'),
State('b', on_enter='set_blue')
]
def __init__(self, device_group):
self.device_group = device_group
self.machine = Machine(self, states=TestFSM.states, initial='r')
self.machine.add_transition(
trigger='switch',
source='r',
dest='g'
)
self.machine.add_transition(
trigger='switch',
source='g',
dest='b'
)
self.machine.add_transition(
trigger='switch',
source='b',
dest='r'
)
def set_red(self):
self.device_group.send_message(4, 0, 3, b'\xff\x00\x00')
def set_green(self):
self.device_group.send_message(4, 0, 3, b'\x00\xff\x00')
def set_blue(self):
self.device_group.send_message(4, 0, 3, b'\x00\x00\xff')
def handle_message(self, msg):
if msg[0] == 4 and msg[2] == 4 and msg[3] == '\x01':
self.switch()
def deserialize_transitions(data: dict) -> Dict[Binding, Transition]:
transitions_by_binding = {}
for binding in Binding:
transition = data.get(binding.value, None)
if transition is None:
continue
transitions_by_binding[binding] = Transition(
starting_fidl=State(transition[0]['fidl']),
starting_src=from_src_filename(transition[0]['source']),
changes=tuple(deserialize_change(c) for c in transition[1:]))
return transitions_by_binding
def __init__(self, *a, **k):
# type: (Any, Any) -> None
transitions = [
["start", SequenceState.UN_STARTED, SequenceState.STARTED],
["terminate", SequenceState.STARTED, SequenceState.TERMINATED],
["cancel", SequenceState.STARTED, SequenceState.CANCELLED],
["error", SequenceState.STARTED, SequenceState.ERRORED],
]
states = [
State(SequenceState.UN_STARTED),
State(SequenceState.STARTED, on_enter=[self._on_start]),
State(SequenceState.TERMINATED, on_enter=[self._on_terminate]),
State(SequenceState.CANCELLED, on_enter=[self._on_cancel]),
State(SequenceState.ERRORED, on_enter=[self._on_terminate]),
]
self._state_machine = Machine(states=states,
transitions=transitions,
initial=SequenceState.UN_STARTED)
async def run(robot: cozmo.robot.Robot):
robot.camera.image_stream_enabled = True
await robot.set_head_angle(cozmo.util.degrees(7)).wait_for_completed()
states = [ State(name = 'Searching', on_enter=[], on_exit=[]),
State(name = 'PickCube', on_enter=[], on_exit=[]),
State(name = 'DropCube', on_enter=[], on_exit=[]),
State(name = 'WrongArea', on_enter=[], on_exit=[]),]
transitions = [ {'trigger':'safeZone','source':'WrongArea','dest':'Searching'},
{'trigger':'foundCube','source':'Searching','dest':'PickCube'},
{'trigger':'deliverCube','source':'PickCube','dest':'DropCube'},
{'trigger':'findPos','source':'DropCube','dest':'WrongArea'},
{'trigger':'oops','source':'Searching','dest':'WrongArea'},] #this last trigger is mostly optional
initState = 'WrongArea'
machine = Machine(model=robot, states=states, transitions=transitions, initial=initState, ignore_invalid_triggers=True)
while(True):
cozmo.robot.Robot.drive_off_charger_on_connect = False
robot = await switch[robot.state](robot);
def __init__(self):
self.position_subscriber = rospy.Subscriber("/ground_truth_to_tf/pose", PoseStamped, self.callback_position)
self.vector_publisher = rospy.Publisher("/vector", Vector3, queue_size=10)
rospy.loginfo("hello")
self.states = [
State(name="plane_centering", on_enter=['state_plane_centering']),
State(name="cone_drop", on_enter=['state_cone_drop']),
State(name="height_hit", on_enter=['state_height_hit']),
State(name="landed", on_enter=['state_landed']),
State(name="post_landed")
]
self.vc = Vector_Control()
self.machine = Machine(model=self.vc, states=self.states, initial='plane_centering')
self.machine.add_transition("next", "plane_centering", "cone_drop", conditions="is_centered")
self.machine.add_transition("next", "cone_drop", "height_hit", conditions="is_out_of_the_cone")
self.machine.add_transition("next", "height_hit", "plane_centering", conditions="is_height_hit")
self.machine.add_transition("next", "cone_drop", "landed", conditions="is_landing")
self.machine.add_transition("next", "landed", "post_landed")
self.machine.add_transition("next", "post_landed", "post_landed")
def test_auto_transitions(self):
states = ['A', {'name': 'B'}, State(name='C')]
m = Machine(None, states, initial='A', auto_transitions=True)
m.to_B()
self.assertEquals(m.state, 'B')
m.to_C()
self.assertEquals(m.state, 'C')
m.to_A()
self.assertEquals(m.state, 'A')
# Should fail if auto transitions is off...
m = Machine(None, states, initial='A', auto_transitions=False)
with self.assertRaises(TypeError):
m.to_C()
def __init__(self):
#the IR laser is connected to 'laser2'
self._laser_conf = rospy.Publisher(
'/flymad_micro/laser2/configuration',
flymad.msg.LaserConfiguration,
latch=True) #latched so message is guarenteed to arrive
#configure the laser
self._laser_conf.publish(
enable=
True, #always enabled, we turn it on/off using /experiment/laser
frequency=0, #constant (not pulsed)
intensity=1.0) #full power
#ensure the targeter is running so we can control the laser
rospy.loginfo('waiting for targeter')
rospy.wait_for_service('/experiment/laser')
self._laser = rospy.ServiceProxy('/experiment/laser',
flymad.srv.LaserState)
self._laser(LASERS_ALL_OFF)
self._flyx, self._flyy = 0, 0
#the position of the currently targeted object is sent by the targeter. In the
#case of a single fly, the default behaviour of the targeter is to target the
#one and only fly. If there are multiple flies you neet to instruct the targeter
#which fly to target. The requires you recieve the raw position of all tracked
#objects, /flymad/tracked, and decide which one is interesting by sending
#/flymad/target_object with.
_ = rospy.Subscriber('/targeter/targeted', flymad.msg.TargetedObj,
self.on_targeted)
self._pubpts = rospy.Publisher('/draw_geom/poly',
geometry_msgs.msg.Polygon,
latch=True)
#set up the states of this experiment
s1 = State('laser_on', on_enter=['on_enter_laser_on'])
s2 = State('laser_off', on_enter=['on_enter_laser_off'])
s3 = State('tile', on_enter=['on_enter_tile'])
self._machine = OrderedStateMachine(self, states=[s1, s2, s3])
def _load_state(self, state):
self.logger.debug("Loading state: {}".format(state))
try:
state_module = load_module('pocs.state.states.{}.{}'.format(self._state_table_name, state))
s = None
# Get the `on_enter` method
self.logger.debug("Checking {}".format(state_module))
if hasattr(state_module, 'on_enter'):
on_enter_method = getattr(state_module, 'on_enter')
setattr(self, 'on_enter_{}'.format(state), on_enter_method)
self.logger.debug("Added `on_enter` method from {} {}".format(state_module, on_enter_method))
self.logger.debug("Created state")
s = State(name=state)
s.add_callback('enter', '_update_graph')
s.add_callback('enter', '_update_status')
s.add_callback('enter', 'on_enter_{}'.format(state))
except Exception as e:
self.logger.warning("Can't load state modules: {}\t{}".format(state, e))
return s
