class BBCON:
def __init__(self):
self.ARB = ARB(self)
self.recommendations = []
self.motob = Motob()
self.behaviors = set() # all behaviors
self.active = set() # active behaviors
self.inactive = set() # inactive behaviors
self.sensobs = set()
self.motobs = [self.motob] # motor object(s)
def add_rec(self, r):
self.recommendations.append(r)
def add_behavior(self, b):
self.behaviors.add(b)
self.inactive.add(b) # all behaviors are inactive be default
def activate(self, b):
if b in self.inactive and b in self.behaviors:
print('activating', b)
self.active.add(b)
self.inactive.remove(b)
self.sensobs.add(b.get_sensob())
def deactivate(self, b):
if b in self.active and b in self.behaviors:
print('deactivating', b)
self.inactive.add(b)
self.active.remove(b)
self.sensobs.remove(b.get_sensob())
def run(self):
del self.recommendations[:]
# Update all sensobs
print('updating sensobs')
for sensob in self.sensobs:
# print ('updating',sensob.__class__.__name__)
sensob.update()
# Update all behaviors
print('updating behaviors')
for behavior in self.active:
behavior.update()
recommendation = self.ARB.choose_action()
print('recommendation = ', recommendation)
# Update motobs
for motob in self.motobs:
motob.update(recommendation[0])
# pass
# Reset sensobs
for sensob in self.sensobs:
sensob.reset()
class Bbcon:
def __init__(self):
self.behaviors = [
] # a list of all the behavior objects used by the bbcon
self.active_behaviors = [
] # a list of all behaviors that are currently active.
self.sensobs = [] # a list of all sensory objects used by the bbcon
self.motobs = Motob() # a list of all motor objects used by the bbcon
self.arbOb = Arbitrator(
) # the arbitrator object that will resolve actuator requests produced by the behaviors.
self.num_timesteps = 0 # number of timesteps done
# append a newly-created behavior onto the behaviors list.
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
# append a newly-created sensob onto the sensobs list.
def add_sensor(self, sensor):
if sensor not in self.sensobs:
self.sensobs.append(sensor)
# add an existing behavior onto the active-behaviors list.
def activate_bahavior(self, behavior):
if behavior in self.behaviors:
self.active_behaviors.append(behavior)
# remove an existing behavior from the active behaviors list.
def deactive_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
# Constitutes the core BBCON activity
def run_one_timestep(self):
"""
Main function.
:return:
"""
# Updates behaviours which in return updates sensobs.
for behaviour in self.behaviors:
behaviour.update()
# Returns recommondations of
motor_recoms = self.arbOb.choose_action(self.active_behaviors)
print("motor req: ", motor_recoms)
# Update motobs
self.motobs.update(motor_recoms)
# Waits for motors to run
sleep(0.5)
# Reset sensor values
for sensor in self.sensobs:
sensor.reset()
self.num_timesteps += 1
class BBCON:
def __init__(self):
self.behaviors = []
self.sensobs = []
self.motob = Motob()
self.motob.update("brake")
self.arbitrator = Arbitrator()
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
# def activate_behavior(self, behavior):
# self.active_behaviors.add(behavior)
# def deactive_behavior(self, behavior):
# self.active_behaviors.remove(behavior)
def move(self, action):
self.motob.update(action)
def run_one_timestep(self, delay=0.667):
start_time = time()
# Reflectance sensor index 0
# Proximity sensor index 1
# Camera sensor index 2
#self.data = [s.update() for s in self.sensobs]
self.data = []
for s in self.sensobs:
tmp = time()
self.data.append(s.update())
print("Time for {0}: {1}".format(s.sensor, round((time() - tmp)*1000, ndigits = 2)))
mrs = []
for b in self.behaviors:
tmp = time()
mrs.append(b.update())
print("Time for {0}: {1}".format(b, round((time() - tmp)*1000, ndigits = 2)))
#tmp = time()
#mrs = [b.update() for b in self.behaviors]
print(sorted(mrs, key=lambda x: x[1]))
action = self.arbitrator.choose_action(mrs)
print(action)
self.move(action)
execution_time = time() - start_time
#delay = max(delay - execution_time, 0)
delay = (delay - execution_time) if execution_time < delay else 0
print("Delay time: ", delay, "\n")
sleep(delay)
class BBCON:
"""Behavoir-Based Controller-klasse"""
def __init__(self, config_values, motob):
"""
Init
"""
self.config_values = config_values
self.behaviors = []
self.active_behaviors = []
self.inactive_behaviors = []
self.sensobs = []
self.motob = motob
self.arbitrator = Arbitrator(self)
self.rages = 0
def add_behavior(self, behavior):
""" Legger til en nylig lagd handling til behaviors-listen """
self.behaviors.append(behavior)
def add_sensob(self, sensob):
""" Legger til en nylig lagd sensob til sensob-listen"""
self.sensobs.append(sensob)
sensob.bbcon = self
def active_behavior(self, behavior):
"""Legger til en eksisterende handling til listen med aktive handlinger"""
self.active_behaviors.append(behavior)
def deactive_behavior(self, behavior):
"""Fjerner en tidligere aktiv handling fra listen med aktive handliner"""
self.active_behaviors.remove(behavior)
def run_one_timestep(self):
"""Loopen"""
# 2. Ber alle behavior oppdatere seg selv, og legger til i riktige lister
# dersom de nå har endret status fra aktiv til ikke aktiv, eller motsatt.
for behavior in self.behaviors:
behavior.update()
if behavior.active_flag and behavior not in self.active_behaviors:
self.active_behavior(behavior)
elif not behavior.active_flag and behavior in self.active_behaviors:
self.deactive_behavior(behavior)
# 3. Result består av den vinnende handlingen, som arbitrator-en bestemmer i sin choose_action-metode,
# sin motorandbefaling og halt request flag, av typen, [motorandbefaling, halt request flag =True/False]
result = self.arbitrator.choose_action()
# 4. Oppdatere alle motobs
if result[
1]: # Dersom vinnende handling har halt_request = True, så skal BBCON avslutte og returnere True
self.motob.update("stop")
return True # slik at roboten kjører så lenge
print("Anbefaler: " + result[0])
self.motob.update(
result[0]) # Oppdaterer alle motob-ene med anbefalingene
time.sleep(0.1)
class BBCON:
def __init__(self):
self.behaviors = []
self.sensobs = []
self.motob = Motob()
self.arbitrator = Arbitrator()
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
#def activate_behavior(self, behavior):
# self.active_behaviors.add(behavior)
#def deactive_behavior(self, behavior):
# self.active_behaviors.remove(behavior)
def move(self, action):
self.motob.update(action)
def run_one_timestep(self, delay = 0.667):
start_time = time()
# Reflectance sensor index 0
# Proximity sensor index 1
# Camera sensor index 2
print("Updating sensors...", end = "")
#self.data = [s.update() for s in self.sensobs]
self.data = []
for s in self.sensobs:
tmp = time()
self.data.append(s.update())
print("Time for:", s.sensor, ": ", round((time()-tmp)*1000, ndigits = 4), "ms")
print("Updating behaviors...")
tmp = time()
mrs = [b.update() for b in self.behaviors]
print((time()-tmp)*1000, "ms")
action = self.arbitrator.choose_action(mrs)
print("Moving.")
self.move(action)
execution_time = time() - start_time
#delay = max(delay - execution_time, 0)
delay = (delay - execution_time) if execution_time < delay else 0
print("Delay time: ", delay)
sleep(delay)
class Bbcon:
def __init__(self):
self.arbitrator = Arbitrator(self)
#Oppretter fire sensob objekter. Kamera, ir, reflectance og ultra.
cam = Sensob()
cam.add_sensor(Camera())
ir = Sensob()
ir.add_sensor(IRProximitySensor())
reflect = Sensob()
reflect.add_sensor(ReflectanceSensors())
ultra = Sensob()
ultra.add_sensor(Ultrasonic())
self.sensob = [cam,ir,reflect,ultra]
self.motobs = [Motob()]
self.behaviors = []
self.wall_detected = False
self.wall_checked = False
def activate_behavior(self, behavior):
behavior.active_flag=True
def dactivate_behavior(self, behavior):
behavior.active_flag=False
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensob.append(sensob)
def run(self):
ZumoButton().wait_for_press()
while True:
print("number of behaviors:", len(self.behaviors))
for behavior in self.behaviors:
if not behavior.active_flag:
behavior.consider_activation()
if behavior.active_flag:
print(behavior)
behavior.sensor.update()
behavior.sense_and_act()
# print(behavior.motor_recommendation)
recommendations = self.arbitrator.choose_action()
print("rec ", recommendations)
if recommendations[1]== True:
print("Prosess avsluttet.")
break
for motob in self.motobs:
motob.update(recommendations[0])
time.sleep(0.2)
for sensob in self.sensob:
sensob.reset()
class BBCON:
"""Controller managing behaviors, sensobs and motobs, updating and resetting them"""
def __init__(self):
self.behaviors = []
self.active_behaviors = []
self.sensobs = []
self.motobs = []
self.arbitrator = Arbitrator(self)
self.halt = False
self.closeObject = False
self.redObject = False
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
if not behavior in self.active_behaviors:
print("ACTIVATING:", behavior)
self.active_behaviors.append(behavior)
return True
return False
def deactivate_behavior(self, active_behavior):
if active_behavior in self.active_behaviors:
print("DEACTIVATING:", active_behavior)
self.active_behaviors.remove(active_behavior)
return True
return False
def run_one_timestep(self):
#for sensob in self.sensobs:
# sensob.update()
for behavior in self.active_behaviors:
for sensob in behavior.sensob:
sensob.update()
for behavior in self.behaviors:
behavior.update()
halt, action = self.arbitrator.choose_action()
if halt:
self.halt = True
for motob in self.motobs:
motob.update(action)
time.sleep(.2)
for sensob in self.sensobs:
sensob.reset()
class BBCON():
def __init__(self, sensobs):
self.behaviors = []
self.active_behaviors = []
self.sensobs = sensobs
self.motob = Motob()
self.arbitrator = Arbitrator(self)
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
if behavior not in self.active_behaviors:
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
def run_one_timestep(self):
a = datetime.datetime.now()
for sensob in self.sensobs:
sensob.update()
b = datetime.datetime.now()
print("Time to fetch data was: ", b - a)
c = datetime.datetime.now()
for behavior in self.behaviors:
behavior.update()
if behavior.halt_request:
self.motob.stop()
return False
if behavior.active_flag:
self.activate_behavior(behavior)
else:
self.deactivate_behavior(behavior)
winner = self.arbitrator.choose_action()
self.motob.update(winner.motor_recommendation)
print(winner.motor_recommendation)
d = datetime.datetime.now()
print("Time to calculate logic was: ", d - c)
#sleep(0.1) #cnonsider there is already natural delay in motor turning actions
e = datetime.datetime.now()
for sensob in self.sensobs:
sensob.reset()
f = datetime.datetime.now()
print("Time to reset sensors was: ", f - e)
return True
class BBCON:
def __init__(self):
""" init """
self.sensobs = []
self.add_sensob(Sensob(Ultrasonic()))
self.add_sensob(Sensob(ReflectanceSensors()))
self.add_sensob(Sensob(Camera()))
self.motob = Motob()
self.behaviors = []
self.add_behavior(Behavior(self, [10000, 10000, [10000, 10000, 10000]], "drive", 1))
self.add_behavior(Behavior(self, [30, 10000, [10000, 10000, 10000]], "stop", 3))
self.add_behavior(Behavior(self, [10000, 0.3, [10000, 10000, 10000]], "turnaround", 2))
self.add_behavior(Behavior(self, [10000, 10000, [210, 10000, 10000]], "turn_left", 5))
#self.add_behavior(Behavior(self, [10000, 10000, [10000, 200, 10000]], "turn_right", 4))
self.active_behaviors = []
self.arbitrator = Arbitrator()
def add_behavior(self, behavior):
"""append a newly-created behavior onto the behaviors list"""
self.behaviors.append(behavior)
def add_sensob(self, sensor):
"""append a newly-created sensob onto the sensobs list"""
self.sensobs.append(sensor)
def activate_behavior(self, behavior):
"""add an existing behavior onto the active-behaviors list"""
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
"""remove an existing behavior from the active behaviors list"""
self.active_behaviors.remove(behavior)
def run_one_timestep(self):
"""constitutes the core BBCON activity"""
prod_count = 0
for sensob in self.sensobs: #Updates all sensobs
sensob.update()
if(prod_count == 2):
image = Imager(False, sensob.get_value())
print("Camera pixel", image.get_pixel(20, 30))
prod_count += 1
for behavior in self.behaviors: #Update all behaviors
behavior.update(self.sensobs)
fav_behavior = self.arbitrator.choose_action(self.active_behaviors)
self.motob.update(fav_behavior.sense_and_act())
class BBCON:
def __init__(self):
self.behaviors = []
self.active_behaviors = []
self.sensobs = []
self.motob = Motob()
self.arbitrator = Arbitrator(self)
self.picture_taken = False
self.reset = False
def get_active_behaviors(self):
return self.active_behaviors
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
def add_sensob(self, sensob):
if sensob not in self.sensobs:
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
if behavior not in self.active_behaviors:
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
def is_picture_taken(self):
return self.picture_taken
def reset_sensobs(self):
for sensob in self.sensobs:
sensob.reset()
def run_one_timestep(self):
for sensob in self.sensobs:
sensob.update()
for behavior in self.behaviors:
behavior.update()
motor_recommendations = self.arbitrator.choose_action()
self.motob.update(motor_recommendations)
if self.reset:
self.reset_sensobs()
sleep(0.1)
class BBCON:
def __init__(self):
self.behaviours = [] # liste med alle oppførslene til bbcon
self.active_behaviours = [] # liste med alle oppførsler som er aktive
self.sensobs = [] # liste med alle sensorobejekt brukt av bbcon
self.motobs = Motob() # liste med alle motorobjekt brukt av bbcon
self.arbitrator = Arbitrator() # ikke laget ennå
# legger til en oppførsel
def add_behaviour(self, behaviour):
if behaviour not in self.behaviours:
self.behaviours.append(behaviour)
# legger til en sensor
def add_sensob(self, sensob):
if sensob not in self.sensobs:
self.sensobs.append(sensob)
# legger til en oppførsel i aktivert-listen
def activate_behaviour(self, behaviour):
if behaviour in self.behaviours:
self.active_behaviours.append(behaviour)
# fjerner en aktiv oppførsel fra listen
def deactivate_behaviour(self, behaviour):
if behaviour in self.active_behaviours:
self.active_behaviours.remove(behaviour)
# kjerneaktiviteten til bbcon
def run_one_timestep(self):
# oppdaterer oppførsler som også oppdaterer sensobs
for behaviour in self.behaviours:
behaviour.update()
# returnerer
print("Active behaviours: ", self.active_behaviours)
motor_recoms = self.arbitrator.choose_action(self.active_behaviours)
# oppdaterer motobs
self.motobs.update(motor_recoms)
# reseter sensorverdier
for sensor in self.sensobs:
sensor.reset()
def rett_fram():
ir = ReflectanceSensors(True)
s = Sensob(ir)
ab = Avoid_borders(s, s)
wr = Walk_randomly(s, s)
a = Arbitrator()
m = Motob()
print("Motob set")
ZumoButton().wait_for_press()
print("Button pressed")
while True:
ab.update()
wr.update()
print("Vekt: ", ab.weight)
print("Rec: ", ab.motor_recommendations)
winner_rec = a.choose_action(ab, wr)
print("recom: ", winner_rec)
m.update(winner_rec)
class Bbcon:
def __init__(self):
cam = CamUltra()
ref = ReflectanceSob()
self.sensobs = [cam, ref]
self.active_behaviours = [AttackRed(cam), BeScared(cam), StayInMap(ref), Wander()]
self.motobs = [Motob(self)]
self.arbitrator = Arbitrator(self)
#self.active_behaviours = []
self.inactive_behaviours = []
def activate_behaviour(self, behaviour):
if behaviour not in self.active_behaviours:
self.active_behaviours.append(behaviour)
if behaviour in self.inactive_behaviours:
self.inactive_behaviours.remove(behaviour)
def deactivate_behaviour(self, behaviour):
if behaviour in self.active_behaviours:
self.active_behaviours.remove(behaviour)
if behaviour not in self.inactive_behaviours:
self.inactive_behaviours.append(behaviour)
def r(self):
while True:
print('Updating sensors')
for sensob in self.sensobs:
sensob.update()
print('Updating behaviours')
for behaviour in self.active_behaviours:
behaviour.sense_and_act()
recommendations = self.arbitrator.choose_action()
print('Updating motobs')
for motob in self.motobs:
motob.update(recommendations)
if recommendations[-1] == False:
print('=== HALTING ===')
break
print('=============')
print('Step complete')
print('=============')
# for sensob in self.sonsobs:
# sensob.reset()
class BBCON:
def __init__(self):
self.behaviors = []
self.active_behaviors = []
self.sensobs = []
self.motob = Motob()
self.arbitrator = Arbitrator(self)
self.picture_taken = False
def get_active_behaviors(self):
return self.active_behaviors
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
def add_sensob(self, sensob):
if sensob not in self.sensobs:
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
if behavior not in self.active_behaviors:
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
def is_picture_taken(self):
return self.picture_taken
def run_one_timestep(self):
print("RUN ONE TIME STEP")
for sensob in self.sensobs:
sensob.update()
print("SENSOBS FINISHED")
for behavior in self.behaviors:
behavior.update()
print("BEHAVIOUR FINISHED")
#print("%s weight: %s" %(behavior.get_name(),behavior.get_weight()))
motor_recommendations = self.arbitrator.choose_action()
#print("Recommendations: %s",(motor_recommendations))
self.motob.update(motor_recommendations)
sleep(0.5)
class BBCON:
def __init__(self):
self.behaviors = [
] #En liste av alle behavior objektene som brukes av BBCON
self.active_behaviors = [] #En liste med de aktive behavior objektene
self.sensobs = [
] #En liste av alle sensorobjektene som brukes av BBCON
self.motobs = Motob(
) #En liste ac alle motor objektene som brukes av BBCON
self.arbitrator = Arbitrator(
self, False) #Arbitratoren som skal løse requests fra behaviors
self.take_pic = False
#Andre variabler kan være current_timestep, inaktive behaviors og roboten selv
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
def add_sensob(self, sensor):
if sensor not in self.sensobs:
self.sensobs.append(sensor)
def activate_behavior(self, behavior):
if behavior not in self.active_behaviors:
behavior.active_flag = True
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
behavior.active_flag = False
self.active_behaviors.remove(behavior)
# Oppdatere sensobs
def update_sensobs(self):
print("Updating sensobs")
for sensob in self.sensobs:
sensob.update()
def reset_sensobs(self):
for sensob in self.sensobs:
sensob.reset()
# Oppdatere behaviours
def update_behaviors(self):
print("Updating behaviors")
for behavior in self.behaviors:
behavior.update()
def update_motobs(self, action):
self.motobs.update(action)
def run_one_timesteps(self):
#Update sensobs
self.update_sensobs()
#Update behaviors
self.update_behaviors()
print("Active behaviors:", (self.active_behaviors))
#Call arbitrator.choose_action
action = self.arbitrator.choose_action()
print("Recommendation: ", action)
#Update motobs
self.update_motobs(action)
#Pause
#time.sleep(0.2)
#Reset sensobs
self.reset_sensobs()
class BBCON:
def __init__(self):
"""
Initiates the Behavior-Based Robotic Controller
:param arbitrator: arbitrator, will provide behaviors?
"""
self.behaviors = []
self.active_behaviors = []
self.inactive_behaviors = []
self.sensobs = []
self.motobs = []
self.motobs.append(BeltsController())
self.belts = self.motobs[0]
self.arbitrator = Arbitrator(self)
self.current_timestep = 0
self.controlled_robot = "Zumo Robot"
self.halt_request = False
def add_behavior(self, behavior):
"""
Adds a behavior object to the behaviors list
:param behavior: Behavior-object
:return:
"""
self.behaviors.append(behavior)
self.active_behaviors.append(behavior)
def add_sensob(self, sensob):
"""
Adds a sensob object to the sensob list
:param sensob: Sensob object
:return:
"""
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
"""
Activates a behavior
:param behavior: Behavior object
:return:
"""
self.active_behaviors.append(self.inactive_behaviors.pop(self.inactive_behaviors.index(behavior)))
behavior.active_flag = True
def deactivate_behavior(self, behavior):
"""
Deactivates a behavior
:param behavior: Behavior object
:return:
"""
self.inactive_behaviors.append(self.active_behaviors.pop(self.active_behaviors.index(behavior)))
behavior.active_flag = False
def update_all_sensobs(self):
"""
Updates all sensob-objects by calling senob.update on all
:return:
"""
for sensob in self.sensobs:
if sensob.active_flag:
sensob.update()
def update_all_behaviors(self):
"""
Updates all behaviors
:return:
"""
for behavior in self.active_behaviors:
behavior.update()
def choose_action(self):
"""
Calls arbitrator.choose_action, which returns motor_recom (dict[key: motor object, value: motor settings])
:return:
"""
motor_recom, self.halt_request = self.arbitrator.choose_action()
self.fire_motors(motor_recom)
@staticmethod
def fire_motors(motor_recom: dict):
for motob, setting in motor_recom.items():
motob.update(setting)
def wait(self, dur: float = 0.0):
sleep(dur)
def reset_sensobs(self):
for sensob in self.sensobs:
sensob.reset()
def run_one_timestep(self):
self.update_all_sensobs()
self.update_all_behaviors()
self.choose_action()
self.wait(0.01)
self.reset_sensobs()
class BBCON:
def __init__(self):
self.behaviours = [] #list of all behavior objects (BHRs)
self.active_behaviours = [] #a list of all currently-active BHRs.
self.sensobs = [] #a list of all sensory objects
self.motobs = [Motob()] #a list of all motor objects
self.arb = Arbitrator(
) #this resolves motor requests produced by the behaviors.
def add_behaviour(self, behaviour):
#append a newly-created behavior onto the behaviors list.
self.behaviours.append(behaviour)
def add_sensob(self, sensob):
#append a newly-created sensob onto the sensobs list.
self.sensobs.append(sensob)
def activate_behaviour(self, behaviour):
#add an existing behavior onto the active-behaviors list.
if behaviour not in self.active_behaviours:
self.active_behaviours.append(behaviour)
def deactivate_behaviour(self, behaviour):
#remove an existing behavior from the active behaviors list.
self.active_behaviours.remove(behaviour)
def update_sensobs(self):
#Update all sensobs
for sensob in self.sensobs:
sensob.update()
def update_behaviours(self):
for behaviour in self.behaviours:
behaviour.update()
def invoke_arb(self):
#Invoke the arbitrator by calling arbitrator.choose action.
return self.arb.choose_action(
self.active_behaviours
) #usikker på om den kun skal velge mellom de aktive eller alle
def update_motobs(self, behaviour, haltflag):
#Update motobs based on the winning motor recommendations.
for motob in self.motobs:
motob.update(behaviour, haltflag)
def wait(self):
#Allows motor settings to work for a timestep.
sleep(0.5)
def reset_sensobs(self):
for sensob in self.sensobs:
sensob.reset()
def run_one_timestep(self):
#Does methods 1-6 in sequence
self.update_sensobs()
self.update_behaviours()
setting, haltflag = self.invoke_arb()
self.update_motobs(setting, haltflag)
self.wait()
self.reset_sensobs()
class Bbcon():
def __init__(self):
self.behaviors = []
self.active_behaviors = []
self.sensobs = []
self.motobs = []
self.arbitrator = Arbitrator();
self.active = True
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
def add_motob(self, motob):
self.motobs.append(motob)
def activate_behavior(self, behavior):
if behavior in self.behaviors:
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
def activate_all_behaviors(self):
for b in self.behaviors:
self.activate_behavior(b)
def get_active_behaviors(self):
return self.active_behaviors
def halt_request(self):
self.active = False
for m in self.motobs:
m.stop()
Led().pulse(10, 0.1)
def run_one_timestep(self):
# Update all sensobs
self.update_sensobs()
# Update all behaviours
self.update_behaviors()
# Invoke the arbitrator
recommendations = self.arbitrator.choose_action(self.active_behaviors)
# Update all motobs based on the above
print(recommendations)
self.update_motors(recommendations)
# Exits if button is pressed again
if ZumoButton().check_if_pressed() == 0:
self.halt_request()
# Resets sensors
self.reset_sensobs()
def update_sensobs(self):
for sensob in self.sensobs:
sensob.update()
def reset_sensobs(self):
for sensob in self.sensobs:
sensob.reset()
def update_behaviors(self):
for behavior in self.behaviors:
behavior.update()
def update_motors(self, recommendation):
for motob in self.motobs:
motob.update(recommendation)
class Bbcon:
def __init__(self):
self.behaviors = [
] # behavior-listen, med både inaktive og aktive behaviors
self.active_behaviors = [] # liste med aktive behaviors
self.sensobs = [] # liste med sensor-objekter
self.motobs = Motob(self) # list med motor-objekter
self.arbitrator = Arbitrator(
) # arbitrator-objektet, velger winning-behavior
self.num_timesteps = 0 # antall timesteps som er kjørt
self.can_take_photo = False
# Legger til behavior i listen
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
# Legger til sensor-objekt i listen
def add_sensor(self, sensor):
if sensor not in self.sensobs:
self.sensobs.append(sensor)
# Legger til behavior i listen over active-behaviors
def activate_behavior(self, behavior):
if behavior in self.behaviors:
self.active_behaviors.append(behavior)
# Fjerner aktive behaviors fra active-behaviors listen
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
# Resetter hvis foto er tatt
def photo_taken(self):
self.can_take_photo = False
self.motobs.photograph = False
# "loopen" til klassen
def run_one_timestep(self):
# Oppdaterer behaviors
for behaviour in self.behaviors:
behaviour.update()
# Henter ut motor-recommendations
print("Active behaviors", self.active_behaviors)
motor_recoms = self.arbitrator.choose_action(self.active_behaviors)
# Oppdaterer motobs
self.motobs.update(motor_recoms)
if self.motobs.photograph:
self.can_take_photo = True
# vent slik at motorene kan gjøre tingen sin
sleep(0.25)
# Reset sensorverdiene
for sensor in self.sensobs:
sensor.reset()
self.active_behaviors = []
self.num_timesteps += 1
class Bbcon:
def __init__(self):
self.behaviors = [] #Liste over alle behaviors, aktive og inaktive
self.active_behaviors = [] # Kun aktive behaviors
self.sensobs = [] # Liste over sensorer
self.motobs = Motob(self) # Liste med motorobjekter
self.arbitrator = Arbitrator() # Arbitrator-objektet, velger winning behavior
self.num_timesteps = 0 # Hvor mange timesteps som er kjort
self.can_take_photo = False
#Trivielt, legger til behavior i listen
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
# Trivielt, legger til sensor-objekt i listen
def add_sensor(self, sensor):
if sensor not in self.sensobs:
self.sensobs.append(sensor)
# Legger til behavior i listen over active-behaviors
def activate_behavior(self, behavior):
if behavior in self.behaviors:
self.active_behaviors.append(behavior)
# Fjerner aktive behaviors fra active-behaviors listen
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
# Resetter dersom bilde allerede er tatt
def photo_taken(self):
self.can_take_photo = False
self.motobs.photograph = False
# loopen til klassen
def run_one_timestep(self):
# Oppdaterer behaviors
for behaviour in self.behaviors:
behaviour.update()
# Henter ut motor-recommendations
print("Active behaviors", self.active_behaviors)
motor_recoms = self.arbitrator.choose_action(self.active_behaviors)
# Oppdaterer motobs
self.motobs.update(motor_recoms)
if self.motobs.photograph:
self.can_take_photo = True
# vent slik at motorene kan gjore tingen sin
sleep(0.25)
# Reset sensorverdiene
for sensor in self.sensobs:
sensor.reset()
self.active_behaviors=[]
self.num_timesteps += 1
class BBCON():
def __init__(self):
self.behaviors = [] # Stores all behaviors
self.active_behaviors = [] # Stores the active behaviors
self.inactive_behaviors = [] # Stores the inactive behaviors
self.sensobs = [] # Stores the sensobs
self.motobs = [] # Stores the motob
self.arbitrator = Arbitrator(
self, True) # Createas and stores a deterministic arbitrator
self.current_timestep = 0 # Timestep at start is 0
def add_behavior(self, behavior):
#Adds a behavior
self.behaviors.append(behavior)
# Adds to active instead of inactive
self.active_behaviors.append(behavior)
def add_sensob(self, sensob):
#Adds a sensob
self.sensobs.append(sensob)
def activate_behavior(self, behavior):
# Activates a behavior
if behavior in self.inactive_behaviors:
self.inactive_behaviors.remove(behavior)
self.active_behaviors.append(behavior)
else:
print("behavior not known or already activated.")
def deactivate_behavior(self, behavior):
# Deactivates a behavior
if behavior in self.active_behaviors:
self.inactive_behaviors.append(behavior)
self.active_behaviors.remove(behavior)
else:
print("behavior not known or already deactivated.")
def run_one_timestep(self):
#The main function of BBCON
# Update all sensobs.
for sensob in self.sensobs:
sensob.update()
print(sensob)
# Update all behaviors
for sensob in self.behaviors:
sensob.update()
# BBCON creates list of motor_recommendation objects from active_behaviors
motor_recommendations = []
for behavior in self.active_behaviors:
print(behavior)
motor_recommendations.append(behavior.motor_recommendation)
# Receive actions for each motob object, and a flag for if the robot should halt.
# Input argument was made above
if len(motor_recommendations) is 0:
print("\nNo recommendations, exiting...\n")
return True
which_actions, should_halt = self.arbitrator.choose_action(
motor_recommendations)
# This is commented out as there are only one motob
# Updates the motobs with their corresponing action (MR) from the arbitrator.
#for i in range(len(which_actions)):
#self.motobs[i].update(which_actions[i])
self.motobs[0].update((which_actions, should_halt))
# Waits so that the motors can start. idk.
#time.sleep(0.25) I removed this sleep, as it was added in motob instead.
# Reset all sensobs.
for sensob in self.sensobs:
sensob.reset()
return should_halt
class Bbcon(object):
def __init__(self, time_step=0.2):
""":param time_step: float time in seconds between to wait after each time step
"""
self.sensors = [] # All sensors
self.behavs = [] # All behaviours
self.active_behavs = [] # Active behaviours
self.sensobs = [] # Sensory objects
self.motobs = [] # Motor objects
self.arbit = Arbitrator(self) # Arbitrator
self.time_step = time_step
def add_sensor(self, sensor):
self.sensors.append(sensor)
def remove_sensor(self, sensor):
try:
self.sensors.remove(sensor)
except ValueError:
pass
def add_behaviour(self, behaviour):
self.behavs.append(behaviour)
def add_sensory_object(self, sensory_object):
self.sensobs.append(sensory_object)
def activate_behaviour(self, behaviour):
self.active_behavs.append(behaviour)
def deactivate_behaviour(self, behaviour):
"""Remove behaviour.
:return: boolean True if removed, False otherwise
"""
try:
self.active_behavs.remove(behaviour)
except ValueError:
return False
else:
return True
def set_arbit(self, arbitrator):
self.arbit = arbitrator
def run_one_timestep(self):
"""
Returns if execution should continue.
False => Halt, stop program
True => Keep running
:return: bool
"""
print("="*50)
print()
forks = []
# Update sensors
for sensor in self.sensors:
if isinstance(sensor, Camera):
thread = threading.Thread(target=sensor.update)
forks.append(thread)
thread.start()
else:
sensor.update()
for fork in forks:
fork.join()
forks = []
# Update sensobs
for sensob in self.sensobs:
thread = threading.Thread(target=sensob.update)
forks.append(thread)
thread.start()
for fork in forks:
fork.join()
# Update behaviours
for behav in self.active_behavs:
behav.update()
# Invoke arbitrator
motor_rec = self.arbit.choose_action() # Returns a tuple(list(motor_recommendations), halt)
print("Arbitrator chose: "+str(motor_rec))
if motor_rec[1]: # Check halt recommendation
return False # Halt and exit program
# Update motobs
print(self.motobs)
i = 0
for motob in self.motobs: # Updates each motob with it's respective motor recommendation
print("Bbcon: Updating motob " + str(i))
motob.update(motor_rec[0][i])
i += 1
# Wait
time.sleep(0.5) #waits half a second
# Reset sensors
for sensor in self.sensors:
sensor.reset()
return True
class BBCON:
"""Behaviour based controller"""
timestep = 0.001
def __init__(self):
self.running = True
self.behaviours = []
self.active_behaviours = []
self.inactive_behaviours = []
self.sensobs = []
self.motob = Motob()
self.arbitrator = Arbitrator(self)
self.setup()
def setup(self):
"""Sets up behaviours and sensobs"""
sensob_border_lines = SensobBorderLines()
sensob_camera = SensobCamera()
sensob_ultrasonic = SensobUltrasonic()
self.sensobs.append(sensob_border_lines)
self.sensobs.append(sensob_camera)
self.sensobs.append(sensob_ultrasonic)
self.behaviours.append(AvoidLineCrossing(self, [sensob_border_lines]))
self.behaviours.append(AvoidWall(self, [sensob_ultrasonic]))
self.behaviours.append(DefaultMovement(self, []))
self.behaviours.append(
FollowRed(self, [sensob_camera, sensob_ultrasonic]))
for behaviour in self.behaviours:
self.active_behaviours.append(behaviour)
def add_behaviour(self, behaviour):
"""Adds a new behaviour to the list of behaviours"""
if behaviour not in self.behaviours:
self.behaviours.append(behaviour)
def add_sensob(self, sensob):
"""Adds a new sensob to the list of sensobs"""
if sensob not in self.sensobs:
self.sensobs.append(sensob)
def activate_behaviour(self, behaviour):
"""Sets an inactive behaviour as active"""
if (behaviour in self.behaviours
and behaviour not in self.active_behaviours
and behaviour in self.inactive_behaviours):
self.inactive_behaviours.remove(behaviour)
self.active_behaviours.append(behaviour)
def deactivate_behaviour(self, behaviour):
"""Sets an active behaviour as inactive"""
if (behaviour in self.behaviours
and behaviour in self.active_behaviours
and behaviour not in self.inactive_behaviours):
self.active_behaviours.remove(behaviour)
self.inactive_behaviours.append(behaviour)
def run_one_timestep(self):
"""Runs one timestep by updating sensors,
behaviors, arbitrator and motors"""
print("#####################################")
self.update_sensobs()
self.update_behaviours()
motor_recommendation = self.arbitrator.choose_action()
self.update_motob(motor_recommendation)
if self.behaviours[3].active_flag:
self.timestep = 0.001
else:
self.timestep = 0.3
sleep(self.timestep)
self.reset_sensobs()
def update_sensobs(self):
"""Instructs all sensobs to get value from sensors and save it."""
for sensob in self.sensobs:
if sensob == self.sensobs[1]:
if self.behaviours[3].active_flag:
sensob.update()
else:
sensob.update()
def reset_sensobs(self):
"""Instructs all sensobs to reset if it needs to"""
for sensob in self.sensobs:
sensob.reset()
def update_behaviours(self):
"""Instructs all behaviours to make a motor recommendation."""
for behaviour in self.behaviours:
behaviour.update()
def update_motob(self, moto_rec):
"""Updates the motobs to do the requested motor recommendation"""
self.motob.update(moto_rec)
class BBCON:
behaviors = []
active_behaviors = []
sensors = {}
active_sensors = []
sensobs = {}
active_sensobs = []
motobs = []
arbitrator = None
line_finished = False
_wait_duration = 0.1 # The amount of time (in seconds) that the program sleeps each time tick
def __init__(self):
# Initialize arbitrator
self.arbitrator = Arbitrator()
# Initialize motobs (single object for both motors on the Zumo)
self.motobs.append(Motob(Motors()))
# Initialize sensors
self.sensors = {
'ultrasonic': Ultrasonic(0.05),
'IR': IRProximitySensor(),
'reflectance': ReflectanceSensors(False, 0, 900),
'camera': Camera(),
}
self.active_sensors = [self.sensors['ultrasonic'], self.sensors['IR'], self.sensors['reflectance']]
# Initialize sensobs
self.sensobs = {
'distance': DistanceSensob([self.sensors['ultrasonic']]),
'line_pos': LinePosSensob([self.sensors['reflectance']]),
'proximity': ProximitySensob([self.sensors['IR']]),
'red_search': RedSearchSensob([self.sensors['camera']]),
}
self.active_sensobs = [self.sensobs['distance'], self.sensobs['line_pos'], self.sensobs['proximity']]
time.sleep(1)
def add_behavior(self, behavior):
if behavior not in self.behaviors:
self.behaviors.append(behavior)
def activate_behavior(self, behavior):
if behavior not in self.active_behaviors:
self.active_behaviors.append(behavior)
behavior.active = True
def deactivate_behavior(self, behavior):
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
behavior.active = False
def activate_sensor(self, sensor):
if sensor not in self.active_sensors:
self.active_sensors.append(sensor)
def deactivate_sensor(self, sensor):
if sensor in self.active_sensors:
self.active_sensors.remove(sensor)
def activate_sensob(self, sensob):
if sensob not in self.active_sensobs:
self.active_sensobs.append(sensob)
def deactivate_sensob(self, sensob):
if sensob in self.active_sensobs:
self.active_sensobs.remove(sensob)
def run_one_timestep(self):
print("Timestep")
for sensor in self.active_sensors:
sensor.update()
for sensob in self.active_sensobs:
sensob.update()
for behavior in self.behaviors:
behavior.consider_activation()
behavior.consider_deactivation()
for behavior in self.active_behaviors:
behavior.update()
motor_recommendations, request_halt = self.arbitrator.choose_action(self.active_behaviors)
if request_halt:
# If halt is requested: stop all motors, and exit program
for motob in self.motobs:
motob.stop()
sys.exit(0)
for i in range(len(self.motobs)):
if len(motor_recommendations) > i:
self.motobs[i].update(motor_recommendations[i])
time.sleep(self._wait_duration)
for sensob in self.sensobs.values():
sensob.reset()
class BehaviorBasedController:
"""
BBCON (Behaviour-Based CONtroller); one instance per robot. Robot calls this class for the next move.
"""
def __init__(self):
self.__behaviors = [] # List of all behaviors
self.active_behaviors = [] # List of all _active_ behaviors
self.__sensobs = [] # List of all sensory objects
self.motob = Motob() # List of all motor objects
self.__arbitrator = Arbitrator(
self) # Arbitrator chooses the next behavior
self.timesteps = 0
self.notifications = []
def should_continue_operating(self):
return "q" not in self.notifications
def add_behaviour(self, behavior: Behavior):
"""
Adds a newly created behavior into the behaviors list.
:param behavior: behavior to be added
"""
if behavior not in self.__behaviors:
self.__behaviors.append(behavior)
# TODO: Refactor this because the method is doing more than it's name is implying.
for sensob in behavior.sensobs:
self.add_sensob(sensob)
def remove_behaviour(self, behavior: Behavior):
"""
Adds a newly created behavior into the behaviors list.
:param behavior: behavior to be added
"""
if behavior in self.__behaviors:
self.__behaviors.remove(behavior)
def add_sensob(self, sensob: Sensob):
"""
Adds a newly created sensob into the sensobs list.
:param sensob: sensob to be added
"""
if sensob not in self.__sensobs:
self.__sensobs.append(sensob)
def remove_sensob(self, sensob: Sensob):
"""
Removes a previously added sensob from the sensobs list.
:param sensob: sensob to be removed
"""
if sensob in self.__sensobs:
self.__sensobs.remove(sensob)
def activate_behavior(self, behavior: Behavior):
"""
Activates a behavior by moving it to the active behaviors list.
:param behavior: behavior to be activated
"""
if behavior not in self.active_behaviors:
self.active_behaviors.append(behavior)
def deactivate_behavior(self, behavior: Behavior):
"""
Deactivates a behavior by removing it from the active behaviors list.
:param behavior: behavior to be deactivated
"""
if behavior in self.active_behaviors:
self.active_behaviors.remove(behavior)
def run_one_timestep(self):
"""
The core BBCON activity; updates sensors and behaviors, invokes arbitrator, invokes sensors, waits, resets
sensors..
"""
# Update all sensors
# TODO: Couldn't this actually be done in every behavior? behavior.reset_sensors()?
for sensob in self.__sensobs:
if isinstance(sensob, CameraSensob):
if len(self.notifications
) > 0 and self.notifications[0] == "p":
sensob.update()
else:
continue
else:
sensob.update()
# Update all behaviors
for behavior in self.__behaviors:
behavior.update()
print("Active behaviors: {}".format(self.active_behaviors))
if len(self.active_behaviors) > 0:
# TODO: Change implementation to use halt request
motor_recommendations, halt_request = self.__arbitrator.choose_action(
)
print("Next recommendation: {}".format(motor_recommendations))
# Update motobs based on motor recommendations
self.motob.update(motor_recommendations)
else:
# Default behavior; this is just temporary.
# TODO: Implement default behavior
print("No active behaviors, will drive forward.")
self.motob.update(["f"])
# Reset sensobs
for sensob in self.__sensobs:
sensob.reset()
self.timesteps += 1
class BBcon:
def __init__(self):
self.behaviors = []
self.active_behaviors = []
self.sensobs = []
self.motob = Motob()
self.arbitrator = Arbitrator(self)
self._running = False
def add_behavior(self, behavior):
self.behaviors.append(behavior)
def add_sensob(self, sensob):
self.sensobs.append(sensob)
# add a newly active behavior to the active_behaviors list
# (if it exists in behaviors)
def activate_behavior(self, active_behavior):
if self.behaviors.__contains__(active_behavior) and \
active_behavior not in self.active_behaviors:
self.active_behaviors.append(active_behavior)
# remove a newly deactived behavior from the active_behaviors list
# (if it exists in active_behaviors)
def deactivate_behavior(self, deactive_behavior):
if self.active_behaviors.__contains__(deactive_behavior):
self.active_behaviors.remove(deactive_behavior)
def run_one_timestep(self):
# update all sensobs
for i in range(len(self.sensobs)):
if not (i == 0 and self.behaviors[1].active_flag == False):
self.sensobs[i].update()
# update all behaviors
for behavior in self.behaviors:
behavior.update()
if behavior.active_flag:
self.activate_behavior(behavior)
else:
self.deactivate_behavior(behavior)
recommended_behavior, halt_request = self.arbitrator.choose_action()
# update motor object based on recommended_behavior
self.motob.update(recommended_behavior)
# reset sensobs
for sensob in self.sensobs:
sensob.reset()
# Stop running if a halt is requested
if halt_request:
self._running = False
def startup(self):
# add sensor objects
cam = Sensob(Camera())
ultrasonic = Sensob(Ultrasonic())
ir_sensor = Sensob(ReflectanceSensors())
self.add_sensob(cam)
self.add_sensob(ultrasonic)
self.add_sensob(ir_sensor)
# add behaviors
sb = StandardBehavior(self)
self.add_behavior(sb)
self.activate_behavior(sb)
cb = CameraBehavior(self)
self.add_behavior(cb)
self.activate_behavior(cb)
ub = UltraBehavior(self)
self.add_behavior(ub)
self.activate_behavior(ub)
ir = IRBehavior(self)
self.add_behavior(ir)
self.activate_behavior(ir)
button = ZumoButton()
button.wait_for_press()
self._running = True
while self._running:
self.run_one_timestep()
# wait
time.sleep(0.001)