from machine import automata
from machine import operations
########################################################################################################################
# Simple Supervisor Example - Conveyor & Sensor
########################################################################################################################
# Creating states
s0 = automata.State('0', True)
s1 = automata.State('1')
# Creating events
s_on = automata.Event('s_on')
s_off = automata.Event('s_off')
e_on = automata.Event('c', True)
e_off = automata.Event('d', True)
sensor_transitions = {s0: {s_on: s1}, s1: {s_off: s0}}
conveyor_transitions = {s0: {e_on: s1}, s1: {e_off: s0}}
G1 = automata.Automaton(sensor_transitions, s0)
G2 = automata.Automaton(conveyor_transitions, s0)
specifications_transitions = {
s0: {
s_on: s1,
e_off: s0
},
s1: {
def EXPERIMENT03():
#Size of the Matrix of states
w, h, N = 8, 5, 20
#Creating States
number_of_states = w * h
states = [None] * number_of_states
#Defining the positions of each State
for i in range(number_of_states):
states[i] = automata.State('S' + str(i))
# Creating events
number_of_events = 4 * w * h + 2 * (w + h - 2)
events = [None] * number_of_events
for i in range(number_of_events):
events[i] = automata.Event(('e' + str(i)), 1, True)
#Creating the automaton itself and its positions
trans = dict()
Matrix_states = [[0 for x in range(w)] for y in range(h)]
#Data about positions
wsize = 3.2
whalf = wsize / 2
hsize = 2
hhalf = hsize / 2
Initial_point = np.array([0, 0, 0])
wdif = wsize / (w)
hdif = hsize / (h)
positions = [[0 for x in range(w)] for y in range(h)]
DIC_POSITIONS = dict()
counter_states = 0
for i in range(h):
for j in range(w):
Matrix_states[i][j] = states[counter_states]
trans[states[counter_states]] = dict()
positions[i][j] = [
x + y
for x, y in zip(Initial_point, [(j - (w - 1) / 2) *
wdif, (-i +
(h - 1) / 2) * hdif, 0])
]
DIC_POSITIONS[states[counter_states]] = positions[i][j]
counter_states += 1
counter_events = 0
for i in range(h):
for j in range(w):
if i < (h - 1):
trans[Matrix_states[i][j]][
events[counter_events]] = Matrix_states[i + 1][j]
counter_events += 1
if i > (0):
trans[Matrix_states[i][j]][
events[counter_events]] = Matrix_states[i - 1][j]
counter_events += 1
if j < (w - 1):
trans[Matrix_states[i][j]][
events[counter_events]] = Matrix_states[i][j + 1]
counter_events += 1
if j > (0):
trans[Matrix_states[i][j]][
events[counter_events]] = Matrix_states[i][j - 1]
counter_events += 1
G = automata.Automaton(trans, events[0])
#Creating inputs for robotarium
RADIUS = 0.06
# Experiment 3 - Compound movement
Initial_pos = (Matrix_states[0][:] + Matrix_states[4][:] +
[Matrix_states[2][0]] + [Matrix_states[2][3]] +
[Matrix_states[2][4]] + [Matrix_states[2][7]])
Final_pos = (Matrix_states[4][:] + Matrix_states[0][:] +
[Matrix_states[2][3]] + [Matrix_states[2][0]] +
[Matrix_states[2][7]] + [Matrix_states[2][4]])
real_state = Initial_pos
pivot_state = [[]] * N
past_state = [[]] * N
past_state2 = [[]] * N
#Path planning variables
N = len(Final_pos)
T = [None] * N
S = [None] * N
T_optimal = [None] * N
S_optimal = [None] * N
T_dj = [None] * N
S_dj = [None] * N
logical_state = [None] * N
priority_radius = [2] * N
buffer = [0] * N
communication_radius = [3] * N
blacklist = dict()
blacklist_individual = dict()
calculating = [True] * N
defined_path = dict()
calculating = [True] * N
for i in range(N):
blacklist[i] = []
defined_path[i] = []
#Control variables
possible = rc.FC_POSSIBLE_STATES_ARRAY(DIC_POSITIONS)
goal_points = np.ones([3, N])
# Initializing the states list
initial_points = rc.FC_SET_ALL_POSITIONS(DIC_POSITIONS, Initial_pos)
# Initializing the robotarium
r = robotarium.Robotarium(number_of_robots=N,
show_figure=True,
initial_conditions=initial_points,
sim_in_real_time=True)
single_integrator_position_controller = create_si_position_controller()
__, uni_to_si_states = create_si_to_uni_mapping()
si_to_uni_dyn = create_si_to_uni_dynamics_with_backwards_motion()
x = r.get_poses()
x_si = uni_to_si_states(x) #"""
r.step()
RUN = True
first = [True] * N
finished = [0] * N
# Creating an structure of past states during actual order
past = dict()
for s in range(N):
past[s] = []
string_size = list()
while real_state != Final_pos:
x = r.get_poses()
x_si = uni_to_si_states(x)
# Update Real State
for i in range(N):
blacklist[i] = []
past_state[i] = real_state[i]
real_state[i] = rc.FC_MAKE_REAL_TRANSITION(possible, states,
real_state[i], x, i,
RADIUS)
if past_state[i] != real_state[i]:
past_state2[i] = past_state[i]
for i in range(N):
if real_state[i] != Final_pos[i]:
if real_state[i] == pivot_state[i]:
#Recalculus of route is necessary
calculating[i] = True
elif real_state[i] == logical_state[i]:
#Update Robotarium state orders, no recalculus is needed
defined_path[i].pop(0)
logical_state[i] = defined_path[i][1]
if calculating[i]:
for j in range(N):
if j != i:
d_real = dk.DIST(G, real_state[j],
communication_radius[j])
if real_state[i] in d_real:
#Update blacklist[i]
if S[j] != None and len(defined_path[j]) > 1:
start_black = True
for k in range(len(defined_path[j])):
if start_black:
blacklist[
i] = rc.add_black_real_logical(
G, blacklist[i],
defined_path[j][k],
defined_path[j][k + 1])
start_black = False
else:
blacklist[i] = rc.add_black3(
G, blacklist[i],
defined_path[j][k])
start_black = False
else:
blacklist[i] = rc.add_black3(
G, blacklist[i], real_state[j])
#Update Path[i]
(T_optimal[i],
S_optimal[i]) = dk.PATH2(G, [], real_state[i],
Final_pos[i])
try:
(T[i], S[i]) = dk.PATH2(G, blacklist[i], real_state[i],
Final_pos[i])
if len(S[i]) > priority_radius[i]:
index = list(range(priority_radius[i]))
else:
index = list(range(len(S[i])))
defined_path[i] = list()
for j in index:
defined_path[i].append(S[i][j])
if len(S[i]) > len(S_optimal[i]):
if len(defined_path[i]) > 2:
for j in reversed(
range(2, len(defined_path[i]))):
if defined_path[i][j] not in S_optimal[i]:
defined_path[i].pop(j)
pivot_state[i] = defined_path[i][-1]
logical_state[i] = S[i][1]
if logical_state[i] == past_state2[i]:
try:
blacklist[i] = rc.add_black3(
G, blacklist[i], past_state2[i])
(T[i],
S[i]) = dk.PATH2(G, blacklist[i],
real_state[i], Final_pos[i])
if len(S[i]) > priority_radius[i]:
index = list(range(priority_radius[i]))
else:
index = list(range(len(S[i])))
defined_path[i] = list()
for j in index:
defined_path[i].append(S[i][j])
pivot_state[i] = defined_path[i][-1]
logical_state[i] = S[i][1]
except:
pass
except:
blocked = rc.check_block(G.transitions, real_state[i],
blacklist[i])
if blocked:
S[i] = [real_state[i]]
T[i] = [None]
defined_path[i] = [S[i][0]]
pivot_state[i] = S[i][0]
logical_state[i] = S[i][0]
else:
white_auto = G.transitions[real_state[i]]
white_keys = white_auto.keys()
white_list = list()
for j in white_keys:
# print(j)
if j not in blacklist[i]:
if white_auto[j] != past_state2[i]:
white_list.append(j)
else:
past_event = j
if len(white_list) >= 1:
white_event = random.choice(white_list)
elif past_event not in blacklist[i]:
white_event = past_event
S[i] = [real_state[i], white_auto[white_event]]
T[i] = [white_event]
defined_path[i] = [
real_state[i], white_auto[white_event]
]
pivot_state[i] = S[i][1]
logical_state[i] = S[i][1]
calculating[i] = False
else:
#Reached final position
# Reached final position
logical_state[i] = real_state[i]
for j in range(N):
if logical_state[j] != None:
rc.FC_SET_GOAL_POINTS(DIC_POSITIONS, goal_points, j,
logical_state[j])
else:
rc.FC_SET_GOAL_POINTS(DIC_POSITIONS, goal_points, j,
real_state[j])
dxi = single_integrator_position_controller(x_si, goal_points[:2][:])
dxu = si_to_uni_dyn(dxi, x)
r.set_velocities(np.arange(N), dxu)
r.step()
r.call_at_scripts_end()
time_of_execution = r._iterations * 0.033
return (time_of_execution)
import time
#Size of the Matrix of states
w, h, N = 8, 5, 20
#Creating States
number_of_states = w * h
states = [None] * number_of_states
#Defining the positions of each State
for i in range(number_of_states):
states[i] = automata.State('S' + str(i))
# Creating events
number_of_events = 4 * w * h + 2 * (w + h - 2)
events = [None] * number_of_events
for i in range(number_of_events):
events[i] = automata.Event(('e' + str(i)), 1, True)
#Creating the automaton itself and its positions
trans = dict()
Matrix_states = [[0 for x in range(w)] for y in range(h)]
#Data about positions
wsize = 3.2
whalf = wsize / 2
hsize = 2.1
hhalf = hsize / 2
Initial_point = np.array([0, 0, 0])
wdif = wsize / (w)
hdif = hsize / (h)
positions = [[0 for x in range(w)] for y in range(h)]
DIC_POSITIONS = dict()
counter_states = 0
from rps.utilities.barrier_certificates import *
from rps.utilities.misc import *
from rps.utilities.controllers import *
import numpy as np
import random
#Creating States
A = automata.State('A')
B = automata.State('B')
C = automata.State('C')
D = automata.State('D')
E = automata.State('E')
F = automata.State('F')
# Creating events
a = automata.Event('a', 1, True)
b = automata.Event('b', 1, True)
c = automata.Event('c', 1, True)
d = automata.Event('d', 1, True)
e = automata.Event('e', 1, True)
f = automata.Event('f', 1, True)
g = automata.Event('g', 1, True)
h = automata.Event('h', 1, True)
k = automata.Event('k', 1, True)
l = automata.Event('l', 1, True)
m = automata.Event('m', 1, True)
n = automata.Event('n', 1, True)
o = automata.Event('o', 1, True)
p = automata.Event('p', 1, True)
#Creating the automaton itself
alphabet_uncontrollable = dict()
n_automata = clusters
robot_transitions = dict()
robot_initial_state = list()
robot = list()
I_Be_C = dict()
F_Be_C = dict()
I_C_Be = dict()
F_C_Be = dict()
I_C_Bd = dict()
F_C_Bd = dict()
I_Bd_Be = dict()
F_Bd_Be = dict()
for i in range(n_automata):
I_Be_C[i] = automata.Event('I_Be_C' + str(i), True)
F_Be_C[i] = automata.Event('F_Be_C' + str(i))
I_C_Be[i] = automata.Event('I_C_Be' + str(i), True)
F_C_Be[i] = automata.Event('F_C_Be' + str(i))
I_C_Bd[i] = automata.Event('I_C_Bd' + str(i), True)
F_C_Bd[i] = automata.Event('F_C_Bd' + str(i))
I_Bd_Be[i] = automata.Event('I_Bd_Be' + str(i), True)
F_Bd_Be[i] = automata.Event('F_Bd_Be' + str(i))
if i == n_automata - 1: # last robot
alphabet[i] = {0: I_Be_C[i], 1: F_Be_C[i], 2: I_C_Be[i], 3: F_C_Be[i]}
robot_transitions[i] = dict()
robot_transitions[i] = {
s[0]: {
alphabet[i][0]: s[1],
alphabet[i][2]: s[2]
},
from machine import automata
from machine import operations
########################################################################################################################
# Composition example
########################################################################################################################
# Creating states
s0 = automata.State('0', True)
s1 = automata.State('1')
# Creating events
a = automata.Event('a', True)
b = automata.Event('b')
c = automata.Event('c', True)
d = automata.Event('d')
transitions_1 = {s0: {a: s1, b: s0}, s1: {b: s0}}
transitions_2 = {s0: {c: s1}, s1: {d: s0}}
G1 = automata.Automaton(transitions_1, s0)
G2 = automata.Automaton(transitions_2, s0)
print("G1 states list:", G1.states_set())
print("G1 events list:", G1.events_set())
G = operations.sync(G1, G2)
print("G states list:", G.states_set())
