class Ev3rstorm(IRBeaconRemoteControlledTank):
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,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
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.leds = Leds()
self.screen = Screen()
self.speaker = Sound()
def keep_detecting_objects_by_ir_sensor(self):
while True:
if self.ir_sensor.proximity < 25:
self.leds.set_color(
group=Leds.LEFT,
color=Leds.RED,
pct=1)
self.leds.set_color(
group=Leds.RIGHT,
color=Leds.RED,
pct=1)
self.speaker.play(wav_file='/home/robot/sound/Object.wav').wait()
self.speaker.play(wav_file='/home/robot/sound/Detected.wav').wait()
self.speaker.play(wav_file='/home/robot/sound/Error alarm.wav').wait()
else:
self.leds.all_off()
def blast_bazooka_whenever_touched(self):
while True:
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play(wav_file='/home/robot/sound/Up.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=-3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
else:
self.speaker.play(wav_file='/home/robot/sound/Down.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
while self.touch_sensor.is_pressed:
pass
def main(self,
driving_speed: float = 1000 # degrees per second
):
self.screen.image.paste(im=Image.open('/home/robot/image/Target.bmp'))
self.screen.update()
# DON'T use IR Sensor in 2 different modes in the same program / loop
# - https://github.com/pybricks/support/issues/62
# - https://github.com/ev3dev/ev3dev/issues/1401
# Process(target=self.keep_detecting_objects_by_ir_sensor,
# daemon=True).start()
Process(target=self.blast_bazooka_whenever_touched,
daemon=True).start()
self.keep_driving_by_ir_beacon(speed=driving_speed)
class Spik3r:
def __init__(self,
sting_motor_port: str = OUTPUT_D,
go_motor_port: str = OUTPUT_B,
claw_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):
self.sting_motor = LargeMotor(address=sting_motor_port)
self.go_motor = LargeMotor(address=go_motor_port)
self.claw_motor = MediumMotor(address=claw_motor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.beacon = RemoteControl(sensor=self.ir_sensor,
channel=self.ir_beacon_channel)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.dis = Screen()
self.speaker = Sound()
def sting_by_ir_beacon(self):
while True:
if self.beacon.beacon:
self.sting_motor.run_to_rel_pos(
speed_sp=750,
position=-220,
stop_action=Motor.STOP_ACTION_HOLD)
self.sting_motor.wait_while(Motor.STATE_RUNNING)
self.speaker.play(
wav_file='/home/robot/sound/Blip 3.wav').wait()
self.sting_motor.run_timed(speed_sp=-1000,
time_sp=1000,
stop_action=Motor.STOP_ACTION_HOLD)
self.sting_motor.wait_while(Motor.STATE_RUNNING)
self.sting_motor.run_timed(speed_sp=1000,
time_sp=1000,
stop_action=Motor.STOP_ACTION_HOLD)
self.sting_motor.wait_while(Motor.STATE_RUNNING)
while self.beacon.beacon:
pass
def be_noisy_to_people(self):
while True:
if self.color_sensor.reflected_light_intensity > 30:
for i in range(4):
self.speaker.play_song(
(('D4', 'e3'), ('D4', 'e3'), ('D4', 'e3'), ('G4', 'h'),
('D5', 'h'), ('C5', 'e3'), ('B4', 'e3'), ('A4', 'e3'),
('G5', 'h'), ('D5', 'q'), ('C5', 'e3'), ('B4', 'e3'),
('A4', 'e3'), ('G5', 'h'), ('D5', 'q'), ('C5', 'e3'),
('B4', 'e3'), ('C5', 'e3'), ('A4', 'h.')))
def pinch_if_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.claw_motor.run_timed(speed_sp=500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_HOLD)
self.claw_motor.wait_while(Motor.STATE_RUNNING)
self.claw_motor.run_timed(speed_sp=-500,
time_sp=0.3 * 1000,
stop_action=Motor.STOP_ACTION_HOLD)
self.claw_motor.wait_while(Motor.STATE_RUNNING)
def keep_driving_by_ir_beacon(self):
while True:
if self.beacon.red_up and self.beacon.blue_up:
self.go_motor.run_forever(speed_sp=910)
elif self.beacon.blue_up:
self.go_motor.run_forever(speed_sp=-1000)
else:
self.go_motor.stop(stop_action=Motor.STOP_ACTION_HOLD)
def main(self):
self.dis.image.paste(im=Image.open('/home/robot/image/Evil.bmp'))
self.dis.update()
# FIXME: ValueError: invalid literal for int() with base 10: '' or '9\n9'
# when multiple threads access the same Sensor
Thread(target=self.pinch_if_touched, daemon=True).start()
Thread(target=self.be_noisy_to_people, daemon=True).start()
Thread(target=self.sting_by_ir_beacon, daemon=True).start()
self.keep_driving_by_ir_beacon()
#!/usr/bin/env python3
from ev3dev.ev3 import TouchSensor, INPUT_1, MediumMotor, OUTPUT_A
from threading import Thread
TOUCH_SENSOR = TouchSensor(address=INPUT_1)
MOTOR = MediumMotor(address=OUTPUT_A)
def motor_on_when_touched():
while True:
if TOUCH_SENSOR.is_pressed:
MOTOR.run_timed(
speed_sp=1000, # deg/s
time_sp=1000, # ms
stop_action=MediumMotor.STOP_ACTION_COAST)
Thread(target=motor_on_when_touched,
daemon=True).start()
while True:
pass
#!/usr/bin/env python3
# (MicroPython does not yet support Display as of 2020)
from ev3dev.ev3 import (
Motor, LargeMotor, MediumMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C,
InfraredSensor, INPUT_4,
Screen, Sound
)
from PIL import Image
from time import sleep
MEDIUM_MOTOR = MediumMotor(address=OUTPUT_A)
LEFT_MOTOR = LargeMotor(address=OUTPUT_B)
RIGHT_MOTOR = LargeMotor(address=OUTPUT_C)
IR_SENSOR = InfraredSensor(address=INPUT_4)
SCREEN = Screen()
SPEAKER = Sound()
MEDIUM_MOTOR.run_timed(
speed_sp=-200, # deg/s
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_HOLD)
MEDIUM_MOTOR.wait_while(Motor.STATE_RUNNING)
class Catapult(IRBeaconRemoteControlledTank):
def __init__(self,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
catapult_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_motor_port,
right_motor_port=right_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.catapult_motor = MediumMotor(address=catapult_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.beacon = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.speaker = Sound()
def scan_colors(self):
while True:
if self.color_sensor.color == ColorSensor.COLOR_YELLOW:
pass
elif self.color_sensor.color == ColorSensor.COLOR_WHITE:
self.speaker.play(wav_file='/home/robot/sound/Good.wav').wait()
def make_noise_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.speaker.play(wav_file='/home/robot/sound/Ouch.wav').wait()
def throw_by_ir_beacon(self):
while True:
if self.beacon.beacon:
self.catapult_motor.run_to_rel_pos(
speed_sp=1000,
position_sp=-150,
stop_action=Motor.STOP_ACTION_HOLD)
self.catapult_motor.wait_while(Motor.STATE_RUNNING)
self.catapult_motor.run_to_rel_pos(
speed_sp=1000,
position_sp=150,
stop_action=Motor.STOP_ACTION_HOLD)
self.catapult_motor.wait_while(Motor.STATE_RUNNING)
while self.beacon.beacon:
pass
def main(self):
self.speaker.play(wav_file='/home/robot/sound/Yes.wav').wait()
Process(target=self.make_noise_when_touched, daemon=True).start()
Process(target=self.throw_by_ir_beacon, daemon=True).start()
Process(target=self.scan_colors, daemon=True).start()
self.keep_driving_by_ir_beacon(speed=1000)
class Rov3r(RemoteControlledTank):
def __init__(
self,
left_motor_port: str = OUTPUT_B, right_motor_port: str = OUTPUT_C,
gear_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=left_motor_port, right_motor=right_motor_port,
polarity=Motor.POLARITY_NORMAL)
self.gear_motor = MediumMotor(address=gear_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.beacon = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.speaker = Sound()
self.dis = Screen()
def spin_gears(self, speed: float = 1000):
while True:
if self.beacon.beacon:
self.gear_motor.run_forever(speed_sp=speed)
else:
self.gear_motor.stop(stop_action=Motor.STOP_ACTION_HOLD)
def change_screen_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.dis.image.paste(im=Image.open('/home/robot/image/Angry.bmp'))
else:
self.dis.image.paste(im=Image.open('/home/robot/image/Fire.bmp'))
self.dis.update()
def make_noise_when_seeing_black(self):
while True:
if self.color_sensor.color == ColorSensor.COLOR_BLACK:
self.speaker.play(wav_file='/home/robot/sound/Ouch.wav').wait()
def main(self):
self.speaker.play(wav_file='/home/robot/sound/Yes.wav').wait()
Process(target=self.make_noise_when_seeing_black,
daemon=True).start()
Process(target=self.spin_gears,
daemon=True).start()
Process(target=self.change_screen_when_touched,
daemon=True).start()
super().main() # RemoteControlledTank.main()
#!/usr/bin/env python3
from ev3dev.ev3 import (Motor, LargeMotor, MediumMotor, OUTPUT_A, OUTPUT_B,
OUTPUT_C, TouchSensor, ColorSensor, INPUT_1, INPUT_3,
Screen, Sound)
from PIL import Image
from time import time
LEFT_FOOT_MOTOR = LargeMotor(address=OUTPUT_B)
RIGHT_FOOT_MOTOR = LargeMotor(address=OUTPUT_C)
MEDIUM_MOTOR = MediumMotor(address=OUTPUT_A)
TOUCH_SENSOR = TouchSensor(address=INPUT_1)
COLOR_SENSOR = ColorSensor(address=INPUT_3)
SCREEN = Screen()
SPEAKER = Sound()
while True:
if COLOR_SENSOR.ambient_light_intensity < 5: # 15 not dark enough
SCREEN.image.paste(im=Image.open('/home/robot/image/Middle left.bmp'),
box=(0, 0))
SCREEN.update()
LEFT_FOOT_MOTOR.run_timed(
speed_sp=-800, # degrees per second
time_sp=1500, # miliseconds
stop_action=Motor.STOP_ACTION_BRAKE)
RIGHT_FOOT_MOTOR.run_timed(
speed_sp=-1000, # degrees per second
class Kraz33Hors3:
def __init__(self,
back_foot_motor_port: str = OUTPUT_C,
front_foot_motor_port: str = OUTPUT_B,
gear_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):
self.front_foot_motor = LargeMotor(address=front_foot_motor_port)
self.back_foot_motor = LargeMotor(address=back_foot_motor_port)
self.gear_motor = MediumMotor(address=gear_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.remote_control = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
def drive_once_by_ir_beacon(
self,
speed: float = 1000 # deg/s
):
# forward
if self.remote_control.red_up and self.remote_control.blue_up:
self.front_foot_motor.run_timed(
speed_sp=speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.back_foot_motor.run_timed(
speed_sp=-speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.front_foot_motor.wait_while(Motor.STATE_RUNNING)
self.back_foot_motor.wait_while(Motor.STATE_RUNNING)
# backward
elif self.remote_control.red_down and self.remote_control.blue_down:
self.front_foot_motor.run_timed(
speed_sp=-speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.back_foot_motor.run_timed(
speed_sp=speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.front_foot_motor.wait_while(Motor.STATE_RUNNING)
self.back_foot_motor.wait_while(Motor.STATE_RUNNING)
# move crazily
elif self.remote_control.beacon:
self.gear_motor.run_forever(speed_sp=speed)
self.front_foot_motor.run_timed(
speed_sp=speed / 3,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.back_foot_motor.run_timed(
speed_sp=speed / 3,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.front_foot_motor.wait_while(Motor.STATE_RUNNING)
self.back_foot_motor.wait_while(Motor.STATE_RUNNING)
else:
self.gear_motor.stop(stop_action=Motor.STOP_ACTION_COAST)
def keep_driving_by_ir_beacon(
self,
speed: float = 1000 # deg/s
):
while True:
self.drive_once_by_ir_beacon(speed=speed)
def back_whenever_touched(
self,
speed: float = 1000 # deg/s
):
while True:
if self.touch_sensor.is_pressed:
self.front_foot_motor.run_timed(
speed_sp=-speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.back_foot_motor.run_timed(
speed_sp=speed,
time_sp=1000, # ms
stop_action=Motor.STOP_ACTION_COAST)
self.front_foot_motor.wait_while(Motor.STATE_RUNNING)
self.back_foot_motor.wait_while(Motor.STATE_RUNNING)
def main(
self,
speed: float = 1000 # deg/s
):
Thread(target=self.back_whenever_touched).start()
self.keep_driving_by_ir_beacon(speed=speed)
from time import sleep
from ev3dev.ev3 import MediumMotor, UltrasonicSensor
us = UltrasonicSensor()
SM = MediumMotor("outC")
def sonicValue(tolerance=10):
cache = [1, 100]
while abs(cache[0] - cache[1]) > tolerance and not (cache[0] > 21.5
and cache[1] > 21.5):
cache[0] = us.value() / 10
sleep(0.025)
cache[1] = us.value() / 10
sleep(0.025)
return sum(cache) / len(cache)
data = [0, 0, 0]
while True:
data[1] = sonicValue()
SM.run_to_rel_pos(position_sp=90, speed_sp=1550, stop_action="hold")
sleep(0.16)
data[0] = sonicValue()
SM.run_to_rel_pos(position_sp=-180, speed_sp=1550, stop_action="hold")
sleep(0.35)
data[2] = sonicValue()
SM.run_to_rel_pos(position_sp=90, speed_sp=1550, stop_action="hold")
sleep(0.2)
class Gripp3r(RemoteControlledTank):
def __init__(self,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
grip_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
super().__init__(left_motor=left_motor_port,
right_motor=right_motor_port,
polarity=Motor.POLARITY_NORMAL)
self.grip_motor = MediumMotor(address=grip_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.beacon = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.speaker = Sound()
def grip_or_release_by_ir_beacon(self, speed: float = 50):
while True:
if self.beacon.beacon:
if self.touch_sensor.is_pressed:
self.speaker.play(
wav_file='/home/robot/sound/Air release.wav')
self.grip_motor.run_timed(
speed_sp=500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.grip_motor.wait_while(Motor.STATE_RUNNING)
else:
self.speaker.play(
wav_file='/home/robot/sound/Airbrake.wav')
self.grip_motor.run_forever(speed_sp=-500)
while not self.touch_sensor.is_pressed:
pass
self.grip_motor.stop(stop_action=Motor.STOP_ACTION_BRAKE)
while self.beacon.beacon:
pass
def main(self):
self.grip_motor.run_timed(speed_sp=-500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.grip_motor.wait_while(Motor.STATE_RUNNING)
Process(target=self.grip_or_release_by_ir_beacon, daemon=True).start()
super().main()
#!/usr/bin/env python3
from ev3dev.ev3 import ColorSensor, LargeMotor, Button, GyroSensor, Sound, UltrasonicSensor, MediumMotor
from time import sleep
gyro = GyroSensor('in2')
g_motor = MediumMotor('outC')
def virarGiro(pos):
if pos == "h":
g_motor.run_to_rel_pos(position_sp=90,
speed_sp=100,
stop_action="hold")
sleep(1)
gyro.mode = 'GYRO-RATE'
gyro.mode = 'GYRO-ANG'
elif pos == "v":
g_motor.run_to_rel_pos(position_sp=-90,
speed_sp=100,
stop_action="hold")
sleep(1)
gyro.mode = 'GYRO-RATE'
gyro.mode = 'GYRO-ANG'
virarGiro("v")
def verificarInclinacao():
if gyro.value() < -10:
#!/usr/bin/env python3
from ev3dev.ev3 import (Motor, MediumMotor, OUTPUT_A, Sound)
from time import sleep
MEDIUM_MOTOR = MediumMotor(address=OUTPUT_A)
SPEAKER = Sound()
MEDIUM_MOTOR.run_timed(speed_sp=-500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
MEDIUM_MOTOR.wait_while(Motor.STATE_RUNNING)
SPEAKER.play(wav_file='/home/robot/sound/Airbrake.wav')
MEDIUM_MOTOR.run_timed(speed_sp=500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
MEDIUM_MOTOR.wait_while(Motor.STATE_RUNNING)
sleep(1)
SPEAKER.play(wav_file='/home/robot/sound/Air release.wav')
MEDIUM_MOTOR.run_timed(speed_sp=-500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
MEDIUM_MOTOR.wait_while(Motor.STATE_RUNNING)
class VerticalMovementManager:
"""
Initializes the manager.
whereMotor - interface on which vertical motor is attached
"""
def __init__(self, whereMotor=OUTPUT_A):
# Initialize motor
self._motor = MediumMotor(whereMotor)
if not self._motor.connected:
raise ValueError("Medium motor at " + whereMotor +
" not connected!")
self._motor.stop_action = MediumMotor.STOP_ACTION_HOLD
# Default speed is 0, setting this is necessary
self._motor.speed_sp = 500
# Position of the lift in percentage units, preserved across runs
self._pkl_pos = LiftPos.BOTTOM
# TODO if we need sensors for other things, initialize this manager
# outside of VerticalMovementManager and only pass a reference
self._sensors = ArduinoSensorsManager()
"""
Sets the stored position of the lift. Useful when it was moved
manually or fell.
"""
def set_position(self, pos):
self._pkl_pos = pos
"""
Moves the lift to the specified percentage position. Doesn't use
any sensors besides the motor tacho count.
pos - where to move
"""
def _move_to_raw(self, pos):
if self._pkl_pos != pos:
curr_pos_m = percent_to_motor(
self._pkl_pos) # Current position [motor]
pos_m = percent_to_motor(pos) # Desired position [motor]
self._motor.run_to_rel_pos(position_sp=pos_m - curr_pos_m)
self._motor.wait_until_not_moving()
self._pkl_pos = pos
class _MoveWhileResult(Enum):
STALLED = 1, # Engine was stalled
OVER_RANGE = 2, # Stopped at percentage range boundary
OVER_LIM = 3, # Stopped at given limit
COND = 4, # Stopped due to condition False
"""
Moves with the specified slowdown for as long as the given condition evalutes to True. An
optional maximum distance in motor units can be specified. Makes sure not to go outside of the
valid position range. Returns the distance travelled in motor units.
cond - () -> Boolean function. evaluated as frequently as possible. movement stops when False
mult - how many times to slow down. larger values allow for more precision and an earlier stop
[lim] - maximum distance to travel in motor units
"""
def _move_while(self, cond, mult=4, lim=None):
print("_move_while(cond={},mult={},lim={})".format(cond, mult, lim))
# First position within valid range
if self._pkl_pos < 0:
self._move_to_raw(0)
elif self._pkl_pos > 100:
self._move_to_raw(100)
init_pos = self._motor.position
sign = mult // abs(mult)
# Set motor parameters
self._motor.speed_sp //= mult
self._motor.polarity = 'normal' if mult > 0 else 'inversed'
self._motor.run_forever()
ret = None
while self._motor.is_running and cond():
if self._motor.is_stalled:
ret = self._MoveWhileResult.STALLED
break
else:
motor_pos = self._motor.position * sign
diff = motor_pos - init_pos
if lim != None and diff >= lim:
ret = self._MoveWhileResult.OVER_LIM
break
new_pos = self._pkl_pos + motor_to_percent(diff)
if new_pos <= -2 or new_pos >= 102:
ret = self._MoveWhileResult.OVER_RANGE
break
if ret == None:
ret = self._MoveWhileResult.COND
# Reset motor parameters
self._motor.stop()
self._motor.polarity = 'normal'
self._motor.speed_sp *= mult
# Update position
diff = self._motor.position - init_pos
self._pkl_pos += motor_to_percent(diff)
return ret
"""
Tries to position the lift in the middle of the switch.
reed - Reed switch number
pos - an approximate percentage position of the switch
"""
def _move_to_switch(self, reed, pos):
print("_move_to_switch(reed={},pos={})".format(reed, pos))
SPREAD = 7 # Minimum distance to the sensor to begin sensing
# Distance and direction to the sensor
diff = pos - self._pkl_pos
sign = int(diff / abs(diff))
assert (abs(sign) == 1)
see_mag = lambda: self._sensors.read_reed(reed)
if abs(diff) >= SPREAD:
if sign > 0:
print("Switch above lift")
else:
print("Switch below lift")
# Move up to sensor at full speed, pray it doesn't miss
mvd = self._move_while(lambda: not see_mag(), sign)
if mvd != self._MoveWhileResult.COND and mvd != self._MoveWhileResult.OVER_RANGE:
raise ValueError(
"ERROR: Sensor not within reach. Move result: " + str(mvd))
# Scale the peak to get to the center, use reduced speed for accuracy
mvd = self._move_while(see_mag, 5 * sign, 1000)
else:
print("WARNING: Lift close to desired position, not moving.")
return
# First find one of the peaks
mult = 4 * sign
if not see_mag():
print("Looking for peak 1")
diff = 500
mvd = self._move_while(lambda: not see_mag(), mult, diff)
while mvd != self._MoveWhileResult.COND:
print(mvd)
print("Moved far, reverting search direction")
diff *= 2
mult *= -1
mvd = self._move_while(lambda: not see_mag(), mult, diff)
sign = int(mult / abs(mult))
peak1 = [0, 0]
peak2 = [0, 0]
# We're on a peak, find its limits by going up and down
#print("Scanning peak 1")
self._move_while(see_mag, mult)
peak1[(sign + 1) // 2] = self._motor.position
#print("Scanning peak 1 in 2nd direction")
# Move a tiny bit down to be within peak again
mvd = self._move_while(lambda: not see_mag(), -mult, 500)
if mvd != self._MoveWhileResult.COND:
raise ValueError("ERROR: peak 1 not within reach")
self._move_while(see_mag, -mult)
peak1[(-sign + 1) // 2] = self._motor.position
print(peak1)
return
#print("Looking for peak 2")
mvd = self._move_while(lambda: not see_mag(), -4, 250)
if mvd == self._MoveWhileResult.OVER_LIM or mvd == self._MoveWhileResult.OVER_RANGE:
#print("Moved far down from peak 1, so peak 2 is above. Moving to center")
self._move_to_raw(self._pkl_pos +
motor_to_percent(peak1[1] -
self._motor.position))
self._move_to_raw(self._pkl_pos + 1)
else:
#print("Moved just a bit from peak 1, so peak 2 is below. Moving to center")
top = self._motor.position
self._move_to_raw(self._pkl_pos +
motor_to_percent(peak1[0] - top) / 2)
"""
Moves the lift to the specified percentage position, using all
available information.
pos - where to move
"""
def move_to(self, pos):
if not self._pkl_pos == pos:
reed = get_reed_id(pos)
if reed is not None:
# If there is a sensor at that height, position the lift
# accurately until it's at the sensor
self._move_to_switch(reed, pos)
else:
# Otherwise move to the position using just the tacho count
self._move_to_raw(pos)
#!/usr/bin/env python3
from ev3dev.ev3 import (Motor, LargeMotor, MediumMotor, OUTPUT_A, OUTPUT_B,
OUTPUT_C, InfraredSensor, INPUT_4, Leds, Sound)
from time import time
LEFT_FOOT_MOTOR = LargeMotor(address=OUTPUT_B)
RIGHT_FOOT_MOTOR = LargeMotor(address=OUTPUT_C)
MEDIUM_MOTOR = MediumMotor(address=OUTPUT_A)
IR_SENSOR = InfraredSensor(address=INPUT_4)
LEDS = Leds()
SPEAKER = Sound()
while True:
if IR_SENSOR.proximity < 25:
LEFT_FOOT_MOTOR.stop(stop_action=Motor.STOP_ACTION_BRAKE)
RIGHT_FOOT_MOTOR.stop(stop_action=Motor.STOP_ACTION_BRAKE)
LEDS.set_color(group=Leds.LEFT, color=Leds.RED, pct=1)
LEDS.set_color(group=Leds.RIGHT, color=Leds.RED, pct=1)
SPEAKER.play(wav_file='/home/robot/sound/Object.wav').wait()
SPEAKER.play(wav_file='/home/robot/sound/Detected.wav').wait()
SPEAKER.play(wav_file='/home/robot/sound/Error alarm.wav').wait()
MEDIUM_MOTOR.run_forever(speed_sp=1000 # degrees per second
)
class Ev3rstorm:
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):
self.left_foot_motor = LargeMotor(address=left_foot_motor_port)
self.right_foot_motor = LargeMotor(address=right_foot_motor_port)
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.remote_control = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.leds = Leds()
self.screen = Screen()
self.speaker = Sound()
def drive_once_by_ir_beacon(
self,
speed: float = 1000 # degrees per second
):
# forward
if self.remote_control.red_up and self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
self.right_foot_motor.run_forever(speed_sp=speed)
# backward
elif self.remote_control.red_down and self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn left on the spot
elif self.remote_control.red_up and self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
self.right_foot_motor.run_forever(speed_sp=speed)
# turn right on the spot
elif self.remote_control.red_down and self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn left forward
elif self.remote_control.red_up:
self.right_foot_motor.run_forever(speed_sp=speed)
# turn right forward
elif self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
# turn left backward
elif self.remote_control.red_down:
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn right backward
elif self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
# otherwise stop
else:
self.left_foot_motor.stop(stop_action=Motor.STOP_ACTION_COAST)
self.right_foot_motor.stop(stop_action=Motor.STOP_ACTION_COAST)
def keep_driving_by_ir_beacon(
self,
speed: float = 1000 # degrees per second
):
while True:
self.drive_once_by_ir_beacon(speed=speed)
def keep_detecting_objects_by_ir_sensor(self):
while True:
if self.ir_sensor.proximity < 25:
self.leds.set_color(group=Leds.LEFT, color=Leds.RED, pct=1)
self.leds.set_color(group=Leds.RIGHT, color=Leds.RED, pct=1)
self.speaker.play(
wav_file='/home/robot/sound/Object.wav').wait()
self.speaker.play(
wav_file='/home/robot/sound/Detected.wav').wait()
self.speaker.play(
wav_file='/home/robot/sound/Error alarm.wav').wait()
else:
self.leds.all_off()
def blast_bazooka_whenever_touched(self):
while True:
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play(
wav_file='/home/robot/sound/Up.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=-3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
else:
self.speaker.play(
wav_file='/home/robot/sound/Down.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
while self.touch_sensor.is_pressed:
pass
def main(
self,
driving_speed: float = 1000 # degrees per second
):
self.screen.image.paste(im=Image.open('/home/robot/image/Target.bmp'))
self.screen.update()
# DON'T use IR Sensor in 2 different modes in the same program / loop
# - https://github.com/pybricks/support/issues/62
# - https://github.com/ev3dev/ev3dev/issues/1401
# Thread(target=self.keep_detecting_objects_by_ir_sensor).start()
Thread(target=self.blast_bazooka_whenever_touched, daemon=True).start()
self.keep_driving_by_ir_beacon(speed=driving_speed)
class Ev3rstorm:
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):
self.left_foot_motor = LargeMotor(address=left_foot_motor_port)
self.right_foot_motor = LargeMotor(address=right_foot_motor_port)
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.remote_control = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.screen = Screen()
self.speaker = Sound()
def drive_once_by_ir_beacon(
self,
speed: float = 1000 # degrees per second
):
# forward
if self.remote_control.red_up and self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
self.right_foot_motor.run_forever(speed_sp=speed)
# backward
elif self.remote_control.red_down and self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn left on the spot
elif self.remote_control.red_up and self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
self.right_foot_motor.run_forever(speed_sp=speed)
# turn right on the spot
elif self.remote_control.red_down and self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn left forward
elif self.remote_control.red_up:
self.right_foot_motor.run_forever(speed_sp=speed)
# turn right forward
elif self.remote_control.blue_up:
self.left_foot_motor.run_forever(speed_sp=speed)
# turn left backward
elif self.remote_control.red_down:
self.right_foot_motor.run_forever(speed_sp=-speed)
# turn right backward
elif self.remote_control.blue_down:
self.left_foot_motor.run_forever(speed_sp=-speed)
# otherwise stop
else:
self.left_foot_motor.stop(stop_action=Motor.STOP_ACTION_COAST)
self.right_foot_motor.stop(stop_action=Motor.STOP_ACTION_COAST)
def keep_driving_by_ir_beacon(
self,
speed: float = 1000 # degrees per second
):
while True:
self.drive_once_by_ir_beacon(speed=speed)
def blast_bazooka_whenever_touched(self):
while True:
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play(wav_file='/home/robot/sound/Up.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=-3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
else:
self.speaker.play(wav_file='/home/robot/sound/Down.wav').wait()
self.bazooka_blast_motor.run_to_rel_pos(
speed_sp=1000, # degrees per second
position_sp=3 * 360, # degrees
stop_action=Motor.STOP_ACTION_HOLD)
while self.touch_sensor.is_pressed:
pass
def main(self,
driving_speed: float = 1000 # degrees per second
):
self.screen.image.paste(im=Image.open('/home/robot/image/Target.bmp'))
self.screen.update()
Process(target=self.blast_bazooka_whenever_touched,
daemon=True).start()
self.keep_driving_by_ir_beacon(speed=driving_speed)
class Sweep3r(IRBeaconRemoteControlledTank):
def __init__(self,
right_motor_port: str = OUTPUT_C,
left_motor_port: str = OUTPUT_B,
medium_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_motor_port,
right_motor_port=right_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.medium_motor = MediumMotor(address=medium_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.screen = Screen()
self.speaker = Sound()
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.remote_control = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
def drill(self):
while True:
if self.remote_control.beacon:
self.medium_motor.run_timed(
speed_sp=1000, # deg/s
time_sp=0.3 * 1000, # ms
stop_action=Motor.STOP_ACTION_HOLD)
self.medium_motor.wait_while(Motor.STATE_RUNNING)
def move_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.right_motor.run_timed(time_sp=1000,
speed_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.right_motor.wait_while(Motor.STATE_RUNNING)
def move_when_see_smothing(self):
while True:
if self.color_sensor.reflected_light_intensity > 30:
self.left_motor.run_timed(time_sp=1000,
speed_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.left_motor.wait_while(Motor.STATE_RUNNING)
def main(
self,
speed: float = 1000 # degrees per second
):
self.screen.image.paste(
im=Image.open('/home/robot/image/Pinch middle.bmp'))
self.screen.update()
Thread(target=self.move_when_touched, daemon=True).start()
Thread(target=self.move_when_see_smothing, daemon=True).start()
Thread(target=self.drill, daemon=True).start()
self.keep_driving_by_ir_beacon(speed=speed)
class MarsRov3r(IRBeaconRemoteControlledTank):
def __init__(self,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
grip_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_motor_port,
right_motor_port=right_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.grip_motor = MediumMotor(address=grip_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.beacon = RemoteControl(sensor=self.ir_sensor,
channel=ir_beacon_channel)
self.speaker = Sound()
is_gripping = False
def grip_or_release_claw_by_ir_beacon(self):
while True:
if self.beacon.beacon:
if self.is_gripping:
self.grip_motor.run_timed(
speed_sp=1000,
time_sp=2000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.grip_motor.wait_while(Motor.STATE_RUNNING)
self.speaker.play(
wav_file='/home/robot/sound/Air release.wav').wait()
self.is_gripping = False
else:
self.grip_motor.run_timed(
speed_sp=-1000,
time_sp=2000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.grip_motor.wait_while(Motor.STATE_RUNNING)
self.speaker.play(
wav_file='/home/robot/sound/Airbrake.wav').wait()
self.is_gripping = True
while self.beacon.beacon:
pass
def main(self, speed: float = 1000):
self.grip_motor.run_timed(speed_sp=500,
time_sp=1000,
stop_action=Motor.STOP_ACTION_BRAKE)
self.grip_motor.wait_while(Motor.STATE_RUNNING)
Process(target=self.grip_or_release_claw_by_ir_beacon,
daemon=True).start()
self.keep_driving_by_ir_beacon(speed=speed)
#!/usr/bin/python from ev3dev.ev3 import MediumMotor as MediumMotor from ev3dev.ev3 import LargeMotor as LargeMotor from time import sleep a = MediumMotor(address='outA') b = LargeMotor(address='outB') c = LargeMotor(address='outC') a.reset() b.reset() c.reset() a.position_sp = 50 a.duty_cycle_sp = 50 a.command = 'run-to-abs-pos' b.position_sp = -450 b.duty_cycle_sp = 50 b.command = 'run-to-abs-pos' c.position_sp = -450 b.duty_cycle_sp = 50 b.command = 'run-to-abs-pos' sleep(5)
#!/usr/bin/env python3
from ev3dev.ev3 import MediumMotor, LargeMotor, ColorSensor, InfraredSensor
from Classes.Motores import *
from Classes.PID import *
from csv import reader
# Motores
M_PORTA = MediumMotor('outC')
M_ESQUERDO = LargeMotor("outA")
M_DIREITO = LargeMotor("outB")
# Sensores de Cor
CL1 = ColorSensor("in1")
CL2 = ColorSensor("in2")
CL1.mode = "RGB-RAW"
CL2.mode = "RGB-RAW"
# Sensores infravermelhos
PROX1 = InfraredSensor("in4")
PROX2 = InfraredSensor("in3")
PROX1.mode = "IR-PROX"
PROX2.mode = "IR-PROX"
# Variaveis usadas durante o programa
TEMPO_CURVA_90 = 1600
TEMPO_CURVA_180 = 3200
DISTANCIA_BONECOS = 14
VELOCIDADE_CURVA = 400
VELOCIDADE_ATUAL = 350
KP = 2
