def test_regul():
"""
Make a square with the robot and at the end make it turn the
other direction (just for fun).
"""
DISTANCE = 50
ANGLE = 90
motors = Motors(5)
motors.forward(DISTANCE)
wait_motors(motors)
motors.turn_left(ANGLE)
wait_motors(motors)
motors.forward(DISTANCE)
wait_motors(motors)
motors.turn_left(ANGLE)
wait_motors(motors)
motors.forward(DISTANCE)
wait_motors(motors)
motors.turn_left(ANGLE)
wait_motors(motors)
motors.forward(DISTANCE)
wait_motors(motors)
# We can't turn more than 255 degrees because
# the data send to the Arduino is a 8bits value.
motors.turn_right(180)
wait_motors(motors)
motors.turn_right(90)
wait_motors(motors)
def __init__(self, verbose=False):
self.verbose = verbose
self.status_counter = 0
self.state = self.STATE_WAITING
self.currenttime = 0
self.flex_fish_limit = self.FLEX_FISH_LIMIT
self.player = Player(self, verbose)
self.adc_sensors = AdcSensors(self, verbose)
self.motors = Motors(self, verbose)
self.web_connection = WebConnection(self, verbose)
self.gps_tracker = GpsTracker(self, verbose)
self.video = Video(self, verbose)
# Initial valus for settings
# Speed: (0-1). 1 = Full speed ahead
# Turn = -1 - +1 = +1 Only left motor on (turn to right)
# 0 Both motors same speed
# -1 Only right motor on (turn to left)
self.speed = 0.0
self.turn = 0.0
# speed style examples:
# - Constant speed = (low_speed_percent = 100)
# - Stop and go jigging with 6 sec motor on and 4 sec stop. low_speed_percent = 0,speed_change_cycle = 10, speed_motors_full_percent = 60
# - Trolling with 10 sec half speed and 5 sec full speed. low_speed_percent = 50, speed_change_cycle = 15, speed_motors_full_percent = 66.66
self.speed_change_cycle = 0
self.speed_motors_full_percent = 100
self.low_speed_percent = 0
# Play music or not
self.play_music = False
def lineTest():
reflect = ReflectanceSensors()
ZumoButton().wait_for_press()
motor = Motors()
stuck = CheckStuck()
camera = Camera()
motob = Motob(motor)
arbitrator = Arbitrator(motob=motob)
sensob = Sensob()
sensob.set_sensors([reflect])
bbcon = BBCON(arbitrator=arbitrator, motob=motob)
bbcon.add_sensob(sensob)
bbcon.set_checkStucker(stuck)
b = LineFollow(1, [sensob])
bbcon.add_behavior(b)
timesteps = 0
while timesteps < 30:
bbcon.run_one_timestep()
timesteps += 1
def lineCollision():
reflect = ReflectanceSensors()
ZumoButton().wait_for_press()
motor = Motors()
stuck = CheckStuck()
ultra = Ultrasonic()
proxim = IRProximitySensor()
sensobCol = Sensob()
sensobCol.set_sensors([ultra, proxim])
motob = Motob(motor=motor)
sensobLine = Sensob()
sensobLine.set_sensors([reflect])
arb = Arbitrator(motob=motob)
bbcon = BBCON(arbitrator=arb, motob=motob)
bbcon.set_checkStucker(stuck)
line = LineFollow(1, [sensobLine])
col = CollisionAvoidance(1, [sensobCol])
bbcon.add_behavior(line)
bbcon.add_behavior(col)
bbcon.add_sensob(sensobCol)
bbcon.add_sensob(sensobLine)
count = 0
while count < 20:
bbcon.run_one_timestep()
count += 1
def start():
bbcon = BBCON()
arb = Arbitrator(bbcon)
motor = Motors()
reflect_sens = ReflectanceSensors(False)
cam = Camera()
ir = IR()
ultra = Ultrasonic()
bbcon.add_motobs(motor)
bbcon.set_arb(arb)
bbcon.add_behaviour(AvoidObj(bbcon, ultra, ir))
bbcon.add_behaviour(Behaviour_line_follower(bbcon, reflect_sens))
bbcon.add_behaviour(fub(bb=bbcon))
#behaviour avoid blue, has to be added last, do not change this, will screw up bbcon code
bbcon.add_behaviour(Behaviour_avoid_blue(bb=bbcon, cam=cam, ultra=ultra))
bbcon.add_sensob(reflect_sens)
bbcon.add_sensob(ir)
bbcon.add_sensob(ultra)
#cam has to be added last, will screw up bbcon code if not
bbcon.add_sensob(cam)
butt = ZumoButton()
butt.wait_for_press()
print("Start zumo")
while True:
bbcon.run_one_timestep()
def test1():
ZumoButton().wait_for_press()
m = Motors()
m.turn_right(90)
m.turn_left(180)
m.turn_right(360)
m.turn_left(360)
def __init__(self):
self.motors = Motors()
#self.marg = MARG()
# not sure if I want this here, but will add for now
self.server = Server()
self.prev_msg = b''
def __init__(self):
self.ub.Init()
self.tb.Init()
self.t1 = datetime.now()
self.tickSpeed = 0.05
self.us = Ultrasonics(self.ub)
self.motors = Motors(self.tb, self.ub, self.tickSpeed)
self.steering = Steering(self.tb, self.ub, self.tickSpeed)
self.teleLogger = Telemetry("telemetry", "csv").get()
self.ptc = PanTiltController(self.ub, 270, 135)
self.joystick_controller = JoystickController(self.tb, self.ub)
battMin, battMax = self.tb.GetBatteryMonitoringLimits()
battCurrent = self.tb.GetBatteryReading()
print('Battery monitoring settings:')
print(' Minimum (red) %02.2f V' % (battMin))
print(' Half-way (yellow) %02.2f V' % ((battMin + battMax) / 2))
print(' Maximum (green) %02.2f V' % (battMax))
print()
print(' Current voltage %02.2f V' % (battCurrent))
print(' Mode %s' % (self.mode))
print()
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 crashTest():
ZumoButton().wait_for_press()
sensor = Crash_sensor()
motor = Motors()
counter = 0
f_value = sensor.calculateFront()
ir_command = sensor.calculateSides()
while True:
counter += 1
if counter >= 5:
f_value = sensor.calculateFront()
ir_command = sensor.calculateSides()
counter = 0
if ir_command == "LEFT":
motor.left(0.5, 0.1)
elif ir_command == "RIGHT":
motor.right(0.5, 0.1)
elif ir_command == "BACKWARD":
motor.backward(0.3, 0.5)
else:
motor.forward(0.3, 0.01)
if f_value == 1000:
motor.stop()
break
def __init__(self):
self.arbit = Arbitrary()
self.value = None
self.motorList = []
self.motorList.append(Motors())
def vsvingsakte():
speed = 0.5
ZumoButton().wait_for_press()
motors = Motors()
motors.set_value((speed / 2, speed / 2), 1)
motors.set_value((speed, -speed), 0.1)
motors.set_value((speed / 2, speed / 2), 1)
def vsvingrask():
speed = 0.5
ZumoButton().wait_for_press()
motors = Motors()
motors.set_value((speed / 2, speed / 2), 1)
motors.set_value((0.3, -0.3), 1)
motors.set_value((speed / 2, speed / 2), 1)
def trackTest():
ZumoButton().wait_for_press()
motor = Motors()
ultra = Ultrasonic()
camera = Camera()
stuck = CheckStuck()
motob = Motob(motor)
arbitrator = Arbitrator(motob=motob)
sensob = Sensob()
sensob.set_sensors([ultra, camera])
bbcon = BBCON(arbitrator=arbitrator, motob=motob)
b = TrackObject(priority=1, sensobs=[sensob])
bbcon.set_checkStucker(stuck)
bbcon.add_behavior(b)
bbcon.activate_behavior(0)
bbcon.add_sensob(sensob)
timesteps = 0
while timesteps < 25:
bbcon.run_one_timestep()
timesteps += 1
def shoot_panorama(camera=Camera(),motors=Motors(),shots=5):
s = 1
im = IMR.Imager(image=camera.update()).scale(s,s)
rotation_time = 3/shots # At a speed of 0.5(of max), it takes about 3 seconds to rotate 360 degrees
for i in range(shots-1):
motors.right(0.5,rotation_time)
im = im.concat_horiz(IMR.Imager(image=camera.update()))
return im
def dancer():
m = Motors()
m.forward(0.2, 3)
m.backward(0.2, 3)
m.right(0.5, 3)
m.left(0.5, 3)
m.backward(0.3, 2.5)
m.set_value([0.5, 0.1], 10)
m.set_value([-0.5, -0.1], 10)
def tourist(steps=25,shots=5,speed=.25):
ZumoButton().wait_for_press()
rs = ReflectanceSensors(); m = Motors(); c = Camera()
for i in range(steps):
random_step(m,speed=speed,duration=0.5)
vals = rs.update()
if sum(vals) < 1: # very dark area
im = shoot_panorama(c,m,shots)
im.dump_image('vacation_pic'+str(i)+'.jpeg')
def operationalize(self):
#Oppretter motors-objekt
m = Motors()
#henter inn recommendation fra arbitrator og plugger inn i motors
m.set_value(self.values, 0.5)
#Går gjennom listen og bruker den til å utføre de forskjellige handlingene fra motors
for i in range(len(self.motors)):
self.motors[i].set_value(self.values, 0.5)
def bbrun():
# Main function sets up motobs/sensobs and behavors
sensobs = []
# Calibration begins here. Students should slowly spin the robot around the
# line in a circle trying hard not to lift it up off the ground. As of now,
# calibration lasts 15 seconds which is plenty of time. Without proper
# calibration, the line following behavior may not work properly.
# Calibration determines the maximum and minimum values found by each sensor,
# which is necessary for returning the normalized values (reals from 0 to 1)
# of each sensor.
# Edit: I have turned off calibration for now, because hard-coding the configuration
# is working good enough and I don't have to use time on calibrating under testing
motors = Motors()
motors.stop()
sleep(2)
# To exit the program properly on keyboardinterrupt
def signal_handler(signal, frame):
motors.stop()
GPIO.cleanup()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
reflectanceSensob = bbc.Sensob(ReflectanceSensors())
cameraSensob = bbc.Sensob(Camera())
sensobs.append(reflectanceSensob)
sensobs.append(cameraSensob)
motob = bbc.Motob(motors)
bbcon = RobotController(None) # None agent
# Create the behaviors
# The behaviors has priorities of 3,3,5,and 1 respectively
followLineBehavior = FollowLine(bbcon, sensobs[0:1])
camera_search_behavior = Camera_search(bbcon, sensobs[1:2])
stopFollowingLineBehavior = StopFollowLine(bbcon, sensobs[0:1])
wanderBehavior = Wander(bbcon)
bbcon.add_behavior(followLineBehavior)
bbcon.add_behavior(stopFollowingLineBehavior)
bbcon.add_behavior(wanderBehavior)
bbcon.add_behavior(camera_search_behavior)
bbcon.add_motob(motob)
bbcon.add_sensob(reflectanceSensob)
bbcon.add_sensob(cameraSensob)
i = 0
while not bbcon.is_blob_found():
print("Iteration " + str(i))
i += 1
print("Found gate: " + str(bbcon.found_gate))
bbcon.run_one_timestep()
# Called at the end
motors.stop()
def __init__(self):
self.motor = Motors() #list of all motors whose values it sets
self.value = [] #most recent motor recommendation sent to the motob.
self.motorsettings = {
'f': self.motor.forward,
'b': self.motor.backward,
'l': self.motor.left,
'r': self.motor.right,
's': self.motor.stop
}
def __init__(self):
self.motor = Motors()
self.value = -1
self.speed = 0.35
self.funcs = {
"left": self.left,
"right": self.right,
"random": self.random,
"rewind": self.rewind
}
def dancer():
ZumoButton().wait_for_press()
m = Motors()
m.forward(0.2, 3)
m.backward(0.2, 3)
m.right(0.5, 3)
m.left(0.5, 3)
m.backward(0.3, 2.5)
m.set_value([0.5, 0.1], 10)
m.set_value([-0.5, -0.1], 10)
def __init__(self, host, port):
self.host = host
self.port = port
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind((host, port))
self.socket.listen(1)
self.client_socket = self.socket.accept()[0]
Motors()
self.listen()
def __init__(self, a_star=None):
self.a_star = a_star or AStar()
self.encoders = Encoders(self.a_star)
self.odometer = Odometer(self.encoders)
self.motors = Motors(self.a_star, self.odometer)
self.camera = Camera()
self.log = logging.getLogger('romi')
self.motors.stop()
def dancer():
ZumoButton().wait_for_press()
m = Motors()
m.forward(.2, 3)
m.forward(.3, 2)
m.right(.5, 3)
m.left(.5, 3)
m.backward(.3, 2.5)
m.set_value([.5, .1], 10)
m.set_value([-.5, -.1], 10)
def main():
gamepad = Gamepad()
motors = Motors()
iks = []
for i in range(4):
iks.append(DeltaIK())
controller = ManualController(iks)
angles = 8 * [0.0]
kPs = 8 * [0.1]
frametime = 1.0 / 30.0
print("Ready.")
while True:
try:
s = time.time()
if not gamepad.process_events():
print("Controller disconnected, waiting for reconnect...")
while not gamepad.reconnect():
time.sleep(0.5)
print("Controller reconnected.")
if gamepad.is_a_down():
print("Shutdown button (A) has been pressed, shutting down...")
break
pad_y = gamepad.get_left_thumbstick_y()
controller.step(pad_y, frametime)
# Map IK leg results to motors
for i in range(4):
angles[legMap[i]
[0]] = legDirs[i][0] * (iks[i].angle -
(np.pi / 2.0 - iks[i].A))
angles[legMap[i]
[1]] = legDirs[i][1] * (iks[i].angle +
(np.pi / 2.0 - iks[i].A))
motors.sendCommands(angles, kPs)
time.sleep(max(0, frametime - (time.time() - s)))
except Exception as e:
print(e)
break
print("-- Program at End --")
async def update_motors():
global cmd
m = Motors()
m.set(0, 0)
while True:
if time.time() - cmd['time'] > p.motor_command_timeout:
m.set(0, 0)
else:
m.set(cmd['forward'], cmd['turn'])
await asyncio.sleep(0.05)
def shoot_panorama(shots=5):
camera = Camera()
motors = Motors()
s = 1
im = IMR.Imager(image=camera.update()).scale(s, s)
rotation_time = 3 / shots # At a speed of 0.5(of max), it takes about 3 seconds to rotate 360 degrees
for i in range(shots - 1):
motors.right(0.5, rotation_time)
im = im.concat_horiz(IMR.Imager(image=camera.update()))
im.dump_image("/root/Oving6_Plab/basic_robot/bilder/test.png")
return im
def __init__(self, debug=False):
self.motor = Motors()
self.behaviors = []
self.debug = debug
self.sensobs = {
Camera(img_width=IMG_WIDTH, img_height=IMG_HEIGHT): None,
Ultrasonic(): None,
ReflectanceSensors(): None
}
self.arbitrator = None
def explorer(dist=10):
m = Motors()
u = Ultrasonic()
while u.update() > dist:
m.forward(0.2, 0.2)
m.backward(.1, 0.5)
m.left(.5, 3)
m.right(.5, 3.5)
sleep(2)
while u.update() < dist * 5:
m.backward(.2, 0.2)
m.left(.75, 5)