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)