def __init__(self, debug_on=True, settings_file=SETTINGSFILE):
"""
Initalize a griffy class which is based
on move differential. Also set up the medium motors
and all sensors.
"""
super().__init__(LEFT_LARGE_MOTOR_PORT, RIGHT_LARGE_MOTOR_PORT, WHEEL_CLASS, WHEEL_DISTANCE)
self.settings = Settings(settings_file)
self.debug_on = self.settings.get('debug_on', debug_on)
self.debug('Griffy started!')
error = self.set_up_sensors_motors()
if not error is None:
# wait until user exits program!!
self.debug(error)
self.error_tone()
while True:
self.sleep_in_loop()
self.calibrate_gyro(which_gyro_sensor='right')
self.wheel_circumference = WHEEL_CIRCUMFERENCE
self.attachment_tank = MoveTank(OUTPUT_A, OUTPUT_D, motor_class=MediumMotor)
self.move_tank = MoveTank(OUTPUT_B, OUTPUT_C)
self.read_light_from_settings() # read light from settings files via Settings class
self.use_gyro = self.settings.get("use_gyro", USE_GYRO)
self.start_tone() # A sound at the end to show when it is done.
def test_beep(self):
print('Should beep 4 times, waits before driving')
flip = 1
s = Sound()
tank_drive = MoveTank(OUTPUT_A, OUTPUT_D)
for x in range(4):
flip *= -1
tank_drive.on_for_seconds(SpeedPercent(30 * flip),
SpeedPercent(30 * flip), 1, True, True)
s.beep()
sleep(1)
print('Should beep 4 times, sound plays during driving')
s = Sound()
tank_drive = MoveTank(OUTPUT_A, OUTPUT_D)
flip = 1
for x in range(4):
flip *= -1
tank_drive.on_for_seconds(SpeedPercent(30 * flip),
SpeedPercent(30 * flip), 1, True, True)
s.beep(play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
sleep(3)
def __init__(self, *args, **kwargs):
self.exposed_tank_left = MoveTank(LargeMotor(OUTPUT_A), LargeMotor(OUTPUT_B))
self.exposed_tank_right = MoveTank(LargeMotor(OUTPUT_C), LargeMotor(OUTPUT_D))
self.exposed_gyro_up = GyroSensor(INPUT_1)
self.exposed_gyro_side = GyroSensor(INPUT_2)
self.exposed_stop = TouchSensor(INPUT_3)
super().__init__(*args, **kwargs)
def main():
while True:
if ts.is_pressed:
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
tank_drive.on(SpeedPercent(100), SpeedPercent(100))
else:
leds.set_color("LEFT", "RED")
leds.set_color("RIGHT", "RED")
tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
tank_drive.on(SpeedPercent(0), SpeedPercent(0))
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Gadget state
self.patrol_mode = False
# Ev3dev initialization
self.leds = Leds()
self.sound = Sound()
self.drive = MoveTank(OUTPUT_A,OUTPUT_A) # Band """
self.deliver = MoveTank(OUTPUT_B,OUTPUT_B) # Deliver """
def calibrate(self):
colorsensor = [0,0,0]
for i in [2]:
colorsensor[i] = SpockbotsColorSensor(i)
tank = MoveTank(OUTPUT_A, OUTPUT_B)
tank.on(SpeedPercent(-5), SpeedPercent(-5))
while True:
txt = "exit"
if button.check_buttons(buttons=['backspace']):
break
else:
txt = "Press Backspace to Stop"
#print("%s 2: %3d" % ( txt, colorsensor[2].value(), "\n"))
for i in [2]:
colorsensor[i].set_white()
colorsensor[i].set_black()
tank.off()
f= open("colcal2.txt","w+")
f.write("%3d, %3d" % (colorsensor[2].black, colorsensor[2].white))
f.close()
return colorsensor
def calibrate(self):
tank = MoveTank(OUTPUT_A, OUTPUT_B)
tank.on(SpeedPercent(-5), SpeedPercent(-5))
while True:
txt = "exit"
if button.check_buttons(buttons=['backspace']):
break
else:
txt = "Press Backspace to Stop"
#print("%s 2: %3d" % ( txt, colorsensor[2].value(), "\n"))
for i in [2,3,4]:
colorsensor[i].set_white()
colorsensor[i].set_black()
tank.off()
f= open("color_calibrate.txt","w")
for i in [2,3,4]:
f.write(colorsensor[i].black)
f.write(colorsensor[i].white)
f.close()
def __init__(
self,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
motor_class=LargeMotor,
polarity: str = Motor.POLARITY_NORMAL,
ir_sensor_port: str = INPUT_4,
# sites.google.com/site/ev3devpython/learn_ev3_python/using-sensors
ir_beacon_channel: int = 1):
self.left_motor = LargeMotor(address=left_motor_port)
self.right_motor = LargeMotor(address=right_motor_port)
self.tank_driver = \
MoveTank(
left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=motor_class)
self.steer_driver = \
MoveSteering(
left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=motor_class)
self.left_motor.polarity = self.right_motor.polarity = \
self.tank_driver.left_motor.polarity = \
self.tank_driver.right_motor.polarity = \
self.steer_driver.left_motor.polarity = \
self.steer_driver.right_motor.polarity = polarity
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.tank_drive_ir_beacon_channel = ir_beacon_channel
def __init__(self, motor_izquierdo, motor_derecho, diametro_rueda,
separacion_ruedas):
self._motor_izquierdo = Motor(motor_izquierdo)
self._motor_derecho = Motor(motor_derecho)
self._dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self._radio = diametro_rueda / 2
self._sruedas = separacion_ruedas
def __init__(self):
self.leds = Leds()
self.tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
self.tank_drive.set_polarity(LargeMotor.POLARITY_INVERSED)
self.color = ColorSensor()
self.ultra = UltrasonicSensor()
self.sound = Sound()
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Robot state
self.patrol_mode = False
self.enemy_not_detected = True
print("+++++ self.patrol_mode = {} y self.enemy_not_detected = {}".
format(self.patrol_mode, self.enemy_not_detected))
self.positionX = 0
self.positionY = 0
self.direction = ['forward', 'right', 'backward', 'left']
self.offset = [0, 1, 0, -1]
self.index = 0
self.pointing = self.direction[self.index]
# Connect two large motors on output ports B and C
self.drive = MoveTank(OUTPUT_B, OUTPUT_C)
self.weapon = MediumMotor(OUTPUT_A)
self.sound = Sound()
self.leds = Leds()
self.ir = InfraredSensor()
# Start threads
threading.Thread(target=self._patrol_thread, daemon=True).start()
threading.Thread(target=self._proximity_thread, daemon=True).start()
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Gadget state
self.in_progress = False
# Ev3dev initialization
self.leds = Leds()
self.sound = Sound()
self.drive = MoveTank(OUTPUT_B, OUTPUT_A)
self.stick = MediumMotor(OUTPUT_C)
self.cs = ColorSensor(INPUT_4)
self.cs.mode = 'COL-REFLECT'
self.floor_light = self.cs.value()
print("floor light intensity = {}".format(self.floor_light))
self.speed = 20
self.kickAngle = 170
paho.Client.connected_flag = False
self.client = paho.Client()
self.client.loop_start()
self.client.on_connect = self.mqtt_connected
self.client.connect('broker.hivemq.com', 1883)
while not self.client.connected_flag:
time.sleep(1)
self.client.subscribe('/hockeybot/game/over')
self.client.on_message = self.mqtt_on_message
# Start threads
threading.Thread(target=self.check_for_obstacles_thread,
daemon=True).start()
def follow_path(path):
current_x = 0
current_y = 0
sensor_motor = MediumMotor(OUTPUT_D)
tank = MoveTank(OUTPUT_B, OUTPUT_C)
print("Length of path: " + str(len(path)))
y_off = path[-1].y - path[0].y + 1
tank.on_for_degrees(-10, -10, 38 * y_off)
i = 0
for p in path:
print(str(i) + "'th: " + str(current_x), str(current_y))
x_off = p.x - current_x
y_off = p.y - current_y
if x_off > 0:
sensor_motor.on_for_degrees(20, 55)
elif x_off < 0:
sensor_motor.on_for_degrees(-20, 55)
if y_off > 0:
tank.on_for_degrees(10, 10, 38)
elif y_off < 0:
tank.on_for_degrees(-10, -10, 38)
current_x = p.x
current_y = p.y
i += 1
def __init__(self, sensorList=[]):
try:
self.tank = MoveTank(OUTPUT_B, OUTPUT_C)
self.outputList = [OUTPUT_B, OUTPUT_C]
except:
self.tank = None
try:
self.cs = ColorSensor()
except:
self.cs = None
try:
self.gyro = GyroSensor()
except:
self.gyro = None
try:
self.ultrasonicSensor = UltrasonicSensor()
except:
self.ultrasonicSensor = None
try:
self.large = LargeMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.large = None
try:
self.medium = MediumMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.medium = None
def gyroRotateAbsoluteAngle():
"""Test code for rotating using the gyror"""
tank_drive = MoveTank(OUTPUT_A, OUTPUT_D)
gyro = GyroSensor()
logger = logToDisplay()
for sleepTime in [2, 0.5]:
gyro.mode = 'GYRO-RATE'
gyro.mode = 'GYRO-ANG'
sleep(sleepTime)
startingAngle = gyro.angle
endingAngle = 90
while True:
currentAngle = gyro.angle
logger.log("Current angle {}".format(currentAngle))
if (currentAngle >= endingAngle - 2
and currentAngle <= endingAngle + 2):
tank_drive.stop()
break
elif (currentAngle > endingAngle):
leftSpeed = SpeedPercent(-5)
rightSpeed = SpeedPercent(5)
else:
leftSpeed = SpeedPercent(5)
rightSpeed = SpeedPercent(-5)
tank_drive.on(leftSpeed, rightSpeed)
sleep(0.1)
def main():
gy = GyroSensor()
mB = LargeMotor('outB')
mC = LargeMotor('outC')
cl = ColorSensor()
ts = TouchSensor()
lcd = Screen()
btn = Button()
while not btn.any(): # While no (not any) button is pressed.
sleep(0.01) # Wait 0.01 second
Sound.beep().wait()
tank_drive = MoveTank(OUTPUT_B, OUTPUT_C)
# telling it what colors it can see
cl.mode = 'COL-COLOR'
colors = ('', 'black', 'blue', 'green', 'yellow', 'red', 'white', 'brown')
# always checking for color
while True:
print(colors[cl.value()])
#what to do when color seen, when see blue it say on screen blue
sleep(1)
if colors[cl.value()] == "red":
tank_drive.on_for_rotations(SpeedPercent(100), SpeedPercent(100),
10)
tank_drive.on_for_rotations(SpeedPercent(-50), SpeedPercent(-50),
3)
def __init__(self, motor_izquierdo, motor_derecho, radio_rueda,
separacion_ruedas):
self.motor_izquierdo = Motor(motor_izquierdo)
self.motor_derecho = Motor(motor_derecho)
self.dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self.radio = radio_rueda
self.sruedas = separacion_ruedas
def initmotors():
lw = Motor(OUTPUT_C)
rw = Motor(OUTPUT_B)
# for x in (lw,rw):
# x.polarity = 'inversed'
# x.ramp_up_sp = 2000
# x.ramp_down_sp = 2000
# lw.polarity = 'inversed'
# rw.polarity = 'inversed'
lw.ramp_up_sp = 2000
rw.ramp_up_sp = 2000
lw.ramp_down_sp = 1000
rw.ramp_down_sp = 1000
global mdiff
global mtank
mdiff = MoveDifferential(OUTPUT_C, OUTPUT_B, MCTire, 129.3)
mtank = MoveTank(OUTPUT_C, OUTPUT_B)
mtank.gyro = GyroSensor()
mdiff.set_polarity('inversed')
def __init__(self,
jaw_motor_port: str = OUTPUT_A,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.jaw_motor = MediumMotor(address=jaw_motor_port)
self.left_motor = LargeMotor(address=left_motor_port)
self.right_motor = LargeMotor(address=right_motor_port)
self.tank_driver = MoveTank(left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=LargeMotor)
self.steer_driver = MoveSteering(left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=LargeMotor)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.speaker = Sound()
self.roaring = False
self.walk_speed = self.NORMAL_WALK_SPEED
def __init__(self):
super().__init__()
self.leds = Leds()
self.sound = Sound()
self.tank = MoveTank(OUTPUT_A, OUTPUT_D)
def __init__(self,
left_foot_motor_port: str = OUTPUT_B,
right_foot_motor_port: str = OUTPUT_C,
bazooka_blast_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
super().__init__(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
polarity=Motor.POLARITY_NORMAL,
speed=1000,
channel=ir_beacon_channel)
self.tank_driver = MoveTank(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
motor_class=LargeMotor)
self.bazooka_blast_motor = MediumMotor(
address=bazooka_blast_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.leds = Leds()
self.speaker = Sound()
def main():
Sound.speak("").wait()
MA = MediumMotor("")
MB = LargeMotor("outB")
MC = LargeMotor("outC")
MD = MediumMotor("")
GY = GyroSensor("")
C3 = ColorSensor("")
C4 = ColorSensor("")
GY.mode = 'GYRO-ANG'
GY.mode = 'GYRO-RATE'
GY.mode = 'GYRO-ANG'
tank_drive = MoveTank(OUTPUT_B, OUTPUT_C)
loop_gyro = 0
gyro_adjust = 1
# change this to whatever speed what you want
left_wheel_speed = -300
right_wheel_speed = -300
# change the loop_gyro verses the defined value argument to however far you want to go
# if Gyro value is the same as the starting value, go straight, if more turn right, if less turn left
# change the value to how far you want the robot to go
while MB.position > -160:
if GY.value() == 0:
left_wheel_speed = -300
right_wheel_speed = -300
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
gyro_adjust = 12
else:
if GY.value() > 0:
correct_rate = abs(
GY.value()
) # This captures the gyro value at the beginning of the statement
left_wheel_speed = left_wheel_speed + gyro_adjust
right_wheel_speed = right_wheel_speed - gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
if abs(
GY.value()
) > correct_rate: # If gyro value has worsened despite the correction then change the adjust variable for next time
gyro_adjust = gyro_adjust + 1
else:
correct_rate = abs(
GY.value()) # Same idea as the other if statement
right_wheel_speed = right_wheel_speed + gyro_adjust
left_wheel_speed = left_wheel_speed - gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
if abs(GY.value()) > correct_rate:
gyro_adjust = gyro_adjust + 1
# stop all motors
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
def __init__(self):
self.rc = RobotContainer.RobotContainer()
self.driveColorLeft = ColorSensor(self.rc.DRIVE_COLOR_LEFT)
self.driveColorRight = ColorSensor(self.rc.DRIVE_COLOR_RIGHT)
self.driveLeft = LargeMotor(self.rc.DRIVE_LEFT)
self.driveRight = LargeMotor(self.rc.DRIVE_RIGHT)
self.tank_drive = MoveTank(self.rc.DRIVE_LEFT, self.rc.DRIVE_RIGHT)
def __init__(self):
self.server_address = (str(sys.argv[1]), 5000)
self.sensor = InfraredSensor()
self.motor = MediumMotor(OUTPUT_D)
self.drive_motor = MoveTank(OUTPUT_B, OUTPUT_C)
self.turn_motor = MoveSteering(OUTPUT_B, OUTPUT_C)
self.moved = 0
self.turned = 0
def drive():
while (line_black):
tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
tank_drive.on_for_rotations(SpeedPercent(80), SpeedPercent(80), 10)
if (lcolor.color != 1 or mcolor.color != 1 or rcolor.color != 1):
line_black == False
if (line_black == False):
test()
def __init__(self):
self.shut_down = False
# self.claw_motor
# self.left_motor = LargeMotor('outB')
# self.right_motor = LargeMotor('outC')
self.both_motors = MoveTank('outB', 'outC')
self.cs = ColorSensor()
self.irs = InfraredSensor()
def __init__(self):
print("Hockey Bot initialized")
self.bat = MediumMotor(OUTPUT_C)
self.cs = ColorSensor(INPUT_2)
self.cs.mode = 'COL-REFLECT'
self.us = UltrasonicSensor(INPUT_1)
self.drive = MoveTank(OUTPUT_A, OUTPUT_B)
self.stop = False
self.kickAngle = 180
def main():
'''The main function of our program'''
setup_brick_console()
battery_check()
mt = MoveTank(OUTPUT_D, OUTPUT_A) # control the two motors at once
# drive motor in A port at 50 % max speed, motor in port B at 75% max speed for 10 seconds
mt.on_for_seconds(-75, 0, 2)
def __init__(self):
self.tank_pair = MoveTank(OUTPUT_A, OUTPUT_B)
self.steer_pair = MoveSteering(OUTPUT_A, OUTPUT_B)
self.line_sensor = ColorSensor(INPUT_2)
self.line_counter = ColorSensor(INPUT_3)
self.sound = Sound()
self.gyro = GyroSensor(INPUT_1)
self.gyro.reset()
self.dir_state = "S"
def drive():
while (line_black):
tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
tank_drive.on_for_rotations(SpeedPercent(80), SpeedPercent(80), 1)
if (lcolor.reflected_light_intensity > 20 or mcolor.color != 1
or rcolor.reflected_light_intensity > 20):
line_black == False
if (line_black == False):
test()
