class Gripp3r(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,
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.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.speaker = Sound()
def grip_or_release_by_ir_beacon(self, speed: float = 50):
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
if self.touch_sensor.is_pressed:
self.speaker.play_file(
wav_file='/home/robot/sound/Air release.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.grip_motor.on_for_seconds(speed=speed,
seconds=1,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Airbrake.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.grip_motor.on(speed=-speed, brake=False, block=False)
self.touch_sensor.wait_for_pressed()
self.grip_motor.off(brake=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self, speed: float = 100):
self.grip_motor.on_for_seconds(speed=-50,
seconds=1,
brake=True,
block=True)
while True:
self.drive_once_by_ir_beacon(speed=speed)
self.grip_or_release_by_ir_beacon()
class CuriosityRov3r(IRBeaconRemoteControlledTank):
def __init__(
self,
left_motor_port: str = OUTPUT_B, right_motor_port: str = OUTPUT_C,
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.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.dis = Display()
self.noise = Sound()
def spin_fan(self, speed: float = 100):
if self.color_sensor.reflected_light_intensity > 20:
self.medium_motor.on(
speed=speed,
brake=False,
block=False)
else:
self.medium_motor.off(brake=True)
def say_when_touched(self):
if self.touch_sensor.is_pressed:
self.dis.image_filename(
filename='/home/robot/image/Angry.bmp',
clear_screen=True)
self.dis.update()
self.noise.play_file(
wav_file='/home/robot/sound/No.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.medium_motor.on_for_seconds(
speed=-50,
seconds=3,
brake=True,
block=True)
def main(self, speed: float = 100):
while True:
self.drive_once_by_ir_beacon(speed=speed)
self.say_when_touched()
self.spin_fan(speed=speed)
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, motor_class=LargeMotor,
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.screen = Display()
self.speaker = Sound()
def blast_bazooka_if_touched(self):
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=3,
brake=True,
block=True)
self.touch_sensor.wait_for_released()
def main(self, driving_speed: float = 100):
self.screen.image_filename(
filename='/home/robot/image/Target.bmp',
clear_screen=True)
self.screen.update()
while True:
self.drive_once_by_ir_beacon(speed=driving_speed)
self.blast_bazooka_if_touched()
def start():
print('Start minimal example')
motor = Motor(OUTPUT_A)
motor.on_for_seconds(SpeedPercent(50), 2)
sound = Sound()
sound.play_file('/home/robot/programs/minimal_example/R2D2a.wav')
class Ev3rstorm(RemoteControlledTank):
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_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.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.screen = Display()
self.speaker = Sound()
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_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=3,
brake=True,
block=True)
self.touch_sensor.wait_for_released()
def main(self):
self.screen.image_filename(filename='/home/robot/image/Target.bmp',
clear_screen=True)
self.screen.update()
Thread(target=self.blast_bazooka_whenever_touched, daemon=True).start()
super().main() # RemoteControlledTank.main()
def callback_voice(ch, method, properties, body):
wav_file = open('ToSpeak.wav', 'wb')
wav_file.write(body)
wav_file.close
spkr = Sound()
spkr.set_volume(100, channel=None)
spkr.play_file('ToSpeak.wav')
os.remove('ToSpeak.wav')
logging.info('Voice message processed')
class Music(object):
"""docstring for DiffRobot"""
def __init__(self, r_address=OUTPUT_C):
super(Music, self).__init__()
self.sound = Sound()
#fuerElise is already in another foulder on the robot. maybe we dont have to download it every time now.
# Change code therefore and maybe folder
def playMusic(self):
self.sound.play_file(
'/home/robot/robotics_ev3/Sounds/short_fuerElise.wav')
self.sound.beep()
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, motor_class=LargeMotor,
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.speaker = Sound()
def blast_bazooka_whenever_touched(self):
while True:
self.touch_sensor.wait_for_bump()
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=3,
brake=True,
block=True)
def main(self, driving_speed: float = 100):
Process(target=self.blast_bazooka_whenever_touched).start()
self.keep_driving_by_ir_beacon(speed=driving_speed)
def skip_test_play_file(self):
flip = 1
s = Sound()
tank_drive = MoveTank(OUTPUT_A, OUTPUT_D)
for x in range(2):
flip *= -1
tank_drive.on_for_seconds(SpeedPercent(30 * flip),
SpeedPercent(30 * flip), 1, True, True)
s.play_file('inputFiles/bark.wav')
sleep(3)
for x in range(4):
flip *= -1
tank_drive.on_for_seconds(SpeedPercent(30 * flip),
SpeedPercent(30 * flip), 1, True, True)
s.play_file('inputFiles/bark.wav',
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
sleep(3)
def test_play_file(self):
spkr = Sound()
spkr.connector.play_actual_sound = False
spkr.play_file('inputFiles/bark.wav', play_type=0)
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[0]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(
args[0].serialize(), {
'type': 'SoundCommand',
'duration': 3.0,
'message': 'Playing file: ``inputFiles/bark.wav``',
'soundType': 'file'
})
# Test for invalid path files
with self.assertRaises(ValueError) as cm:
spkr.play_file('file/that/does/not/exist.wav', play_type=0)
self.assertEqual(cm.exception.args[0],
'file/that/does/not/exist.wav does not exist')
# Test for wrong extensions
with self.assertRaises(ValueError) as cm:
spkr.play_file('inputFiles/bark', play_type=0)
self.assertEqual(
cm.exception.args[0],
'invalid sound file (inputFiles/bark), only .wav files are supported'
)
class Spik3r:
def __init__(self,
claw_motor_port: str = OUTPUT_A,
move_motor_port: str = OUTPUT_B,
sting_motor_port: str = OUTPUT_D,
touch_sensor_port: str = INPUT_1,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.claw_motor = MediumMotor(address=claw_motor_port)
self.move_motor = LargeMotor(address=move_motor_port)
self.sting_motor = LargeMotor(address=sting_motor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.speaker = Sound()
def snap_claw_if_touched(self):
if self.touch_sensor.is_pressed:
self.claw_motor.on_for_seconds(speed=50,
seconds=1,
brake=True,
block=True)
self.claw_motor.on_for_seconds(speed=-50,
seconds=0.3,
brake=True,
block=True)
def move_by_ir_beacon(self):
if self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=100, block=False, brake=False)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=-100, brake=False, block=False)
else:
self.move_motor.off(brake=False)
def sting_by_ir_beacon(self):
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.sting_motor.on_for_degrees(speed=-75,
degrees=220,
brake=True,
block=False)
self.speaker.play_file(wav_file='Blip 3.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.sting_motor.on_for_seconds(speed=-100,
seconds=1,
brake=True,
block=True)
self.sting_motor.on_for_seconds(speed=40,
seconds=1,
brake=True,
block=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self):
while True:
self.snap_claw_if_touched()
self.move_by_ir_beacon()
self.sting_by_ir_beacon()
class MarsRov3r(IRBeaconRemoteControlledTank):
is_gripping = False
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.speaker = Sound()
def grip_or_release_claw_by_ir_beacon(self):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
if self.is_gripping:
self.grip_motor.on_for_seconds(speed=100,
seconds=2,
brake=True,
block=True)
self.speaker.play_file(
wav_file='/home/robot/sound/Air release.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.is_gripping = False
else:
self.grip_motor.on_for_seconds(speed=-100,
seconds=2,
brake=True,
block=True)
self.speaker.play_file(
wav_file='/home/robot/sound/Airbrake.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.is_gripping = True
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self):
self.grip_motor.on_for_seconds(speed=50,
seconds=1,
brake=True,
block=True)
Process(target=self.grip_or_release_claw_by_ir_beacon,
daemon=True).start()
self.keep_driving_by_ir_beacon(speed=100)
# Start sensor thread
sensor_thread = SensorThread(name="sensor_thread")
sensor_thread.daemon = True
sensor_thread.start()
# Main program loop
while running:
console.reset_console()
leds.all_off()
state = "reset"
reset_sensors_and_variables()
calibrate_gyro_offset()
sound.play_file("/home/robot/sounds/Speed up.wav")
console.reset_console()
leds.animate_flash('GREEN', duration=None, block=False)
state = "ready"
log.debug("Starting control loop")
while ok == True:
time = get_time()
calculate_control_loop_period()
calculate_robot_body_angle_and_speed()
calculate_wheel_angle_and_speed()
calculate_output_power()
drive_motors()
check_if_robot_fell_down()
class R3ptar:
def __init__(self,
turn_motor_port: str = OUTPUT_A,
move_motor_port: str = OUTPUT_B,
scare_motor_port: str = OUTPUT_D,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.turn_motor = MediumMotor(address=turn_motor_port)
self.move_motor = LargeMotor(address=move_motor_port)
self.scare_motor = LargeMotor(address=scare_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.noise = Sound()
def keep_driving_by_ir_beacon(self, speed: float = 100):
while True:
if self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.move_motor.on(speed=-speed, brake=False, block=False)
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=-50, brake=False, block=False)
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=50, brake=False, block=False)
self.move_motor.on(speed=speed, brake=False, block=False)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=-50, brake=False, block=False)
self.move_motor.on(speed=-speed, brake=False, block=False)
elif self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.turn_motor.on(speed=50, brake=False, block=False)
self.move_motor.on(speed=-speed, brake=False, block=False)
else:
self.turn_motor.off(brake=True)
self.move_motor.off(brake=False)
def bite_by_ir_beacon(self, speed: float = 100):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.scare_motor.on_for_seconds(speed=speed,
seconds=1,
brake=True,
block=False)
self.noise.play_file(
wav_file='/home/robot/sound/Snake hiss.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.scare_motor.on_for_seconds(speed=-speed,
seconds=1,
brake=True,
block=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def run_away_if_chased(self):
while True:
if self.color_sensor.reflected_light_intensity > 30:
self.move_motor.on_for_seconds(speed=50,
seconds=4,
brake=True,
block=False)
for i in range(2):
self.turn_motor.on_for_seconds(speed=50,
seconds=1,
brake=False,
block=True)
self.turn_motor.on_for_seconds(speed=-50,
seconds=1,
brake=False,
block=True)
def bite_if_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.scare_motor.on_for_seconds(speed=100,
seconds=1,
brake=True,
block=False)
self.noise.play_file(
wav_file='/home/robot/sound/Snake hiss.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.scare_motor.on_for_seconds(speed=-10,
seconds=10,
brake=True,
block=True)
def main(self, speed: float = 100):
Thread(target=self.bite_by_ir_beacon).start()
Thread(target=self.bite_if_touched).start()
Thread(target=self.run_away_if_chased).start()
self.keep_driving_by_ir_beacon(speed=speed)
from ev3dev2.sensor import INPUT_4
from ev3dev2.sound import Sound
TANK_DRIVER = MoveTank(left_motor_port=OUTPUT_B,
right_motor_port=OUTPUT_C,
motor_class=LargeMotor)
IR_SENSOR = InfraredSensor(address=INPUT_4)
SPEAKER = Sound()
def zigzag():
TANK_DRIVER.on_for_seconds(left_speed=-100,
right_speed=0,
seconds=1,
brake=True,
block=True)
TANK_DRIVER.on_for_seconds(left_speed=0,
right_speed=-100,
seconds=1,
brake=True,
block=True)
while IR_SENSOR.proximity >= 16:
zigzag()
SPEAKER.play_file(wav_file='/home/robot/sound/Fanfare.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER = Sound()
is_gripping = False
MEDIUM_MOTOR.on_for_seconds(speed=50, seconds=1, brake=True, block=True)
while True:
if IR_SENSOR.beacon(channel=1):
if is_gripping:
MEDIUM_MOTOR.on_for_seconds(speed=100,
seconds=2,
brake=True,
block=True)
SPEAKER.play_file(wav_file='/home/robot/sound/Air release.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
is_gripping = False
else:
MEDIUM_MOTOR.on_for_seconds(speed=-100,
seconds=2,
brake=True,
block=True)
SPEAKER.play_file(wav_file='/home/robot/sound/Airbrake.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
is_gripping = True
def test():
sounds = Sound()
sounds.set_volume(100)
sounds.beep()
sounds.play_tone(300, 0.2)
sleep(1)
sounds.play_tone(500, 0.2)
sleep(1)
sounds.speak('start runing:')
sleep(1)
sounds.play_song((
('D4', 'e3'), # intro anacrouse
('D4', 'e3'),
('D4', 'e3'),
('G4', 'h'), # meas 1
('D5', 'h'),
('C5', 'e3'), # meas 2
('B4', 'e3'),
('A4', 'e3'),
('G5', 'h'),
('D5', 'q'),
('C5', 'e3'), # meas 3
('B4', 'e3'),
('A4', 'e3'),
('G5', 'h'),
('D5', 'q'),
('C5', 'e3'), # meas 4
('B4', 'e3'),
('C5', 'e3'),
('A4', 'h.'),
))
sleep(1)
sounds.tone([(392, 350, 100), (392, 350, 100), (392, 350, 100),
(311.1, 250, 100), (466.2, 25, 100), (392, 350, 100),
(311.1, 250, 100), (466.2, 25, 100), (392, 700, 100),
(587.32, 350, 100), (587.32, 350, 100), (587.32, 350, 100),
(622.26, 250, 100), (466.2, 25, 100), (369.99, 350, 100),
(311.1, 250, 100), (466.2, 25, 100), (392, 700, 100),
(784, 350, 100), (392, 250, 100), (392, 25, 100),
(784, 350, 100), (739.98, 250, 100), (698.46, 25, 100),
(659.26, 25, 100), (622.26, 25, 100), (659.26, 50, 400),
(415.3, 25, 200), (554.36, 350, 100), (523.25, 250, 100),
(493.88, 25, 100), (466.16, 25, 100), (440, 25, 100),
(466.16, 50, 400), (311.13, 25, 200), (369.99, 350, 100),
(311.13, 250, 100), (392, 25, 100), (466.16, 350, 100),
(392, 250, 100), (466.16, 25, 100), (587.32, 700, 100),
(784, 350, 100), (392, 250, 100), (392, 25, 100),
(784, 350, 100), (739.98, 250, 100), (698.46, 25, 100),
(659.26, 25, 100), (622.26, 25, 100), (659.26, 50, 400),
(415.3, 25, 200), (554.36, 350, 100), (523.25, 250, 100),
(493.88, 25, 100), (466.16, 25, 100), (440, 25, 100),
(466.16, 50, 400), (311.13, 25, 200), (392, 350, 100),
(311.13, 250, 100), (466.16, 25, 100), (392.00, 300, 150),
(311.13, 250, 100), (466.16, 25, 100), (392, 700)])
sounds.play_file('resources/xiaohuamao.wav')
sleep(2)
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.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()
self.screen = Display()
def drive_once_by_ir_beacon(self, speed: float = 100):
# forward
if self.ir_sensor.top_left(
channel=self.ir_beacon_channel) and self.ir_sensor.top_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=speed)
# backward
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel
) and self.ir_sensor.bottom_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=-speed)
# turn left on the spot
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel
) and self.ir_sensor.bottom_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=speed)
# turn right on the spot
elif self.ir_sensor.top_right(
channel=self.ir_beacon_channel) and self.ir_sensor.bottom_left(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=-speed)
# turn left forward
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=0, right_speed=speed)
# turn right forward
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=0)
# turn left backward
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=0, right_speed=-speed)
# turn right backward
elif self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=0)
# otherwise stop
else:
self.tank_driver.off(brake=False)
def dance_if_ir_beacon_pressed(self):
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.tank_driver.on_for_seconds(left_speed=randint(-100, 100),
right_speed=randint(-100, 100),
seconds=1,
brake=False,
block=True)
def detect_object_by_ir_sensor(self):
if self.ir_sensor.proximity < 25:
self.leds.animate_police_lights(color1=Leds.ORANGE,
color2=Leds.RED,
group1=Leds.LEFT,
group2=Leds.RIGHT,
sleeptime=0.5,
duration=5,
block=False)
self.speaker.play_file(wav_file='/home/robot/sound/Object.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.speaker.play_file(wav_file='/home/robot/sound/Detected.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.speaker.play_file(
wav_file='/home/robot/sound/Error alarm.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
else:
self.leds.all_off()
def blast_bazooka_if_touched(self):
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play_file(wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=-3,
brake=True,
block=True)
self.speaker.play_file(
wav_file='/home/robot/sound/Laughing 1.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
else:
self.speaker.play_file(wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=3,
brake=True,
block=True)
self.speaker.play_file(
wav_file='/home/robot/sound/Laughing 2.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.touch_sensor.wait_for_released()
def main(self, driving_speed: float = 100):
self.screen.image_filename(filename='/home/robot/image/Target.bmp',
clear_screen=True)
self.screen.update()
while True:
self.drive_once_by_ir_beacon(speed=driving_speed)
self.dance_if_ir_beacon_pressed()
# 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
# self.detect_object_by_ir_sensor()
self.blast_bazooka_if_touched()
class Actions:
def __init__(self):
self.leftMotor = LargeMotor(OUTPUT_A)
self.rightMotor = LargeMotor(OUTPUT_D)
self.mediumMotor = MediumMotor(OUTPUT_C)
self.sound = Sound()
# Gets the current pressed key
def getch(self):
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
# Play a file - example location - "Sounds/1.wav"
def playFile(self, file):
self.sound.play_file(file, 100, Sound.PLAY_WAIT_FOR_COMPLETE)
# Go forward
def forward(self):
self.leftMotor.run_direct(duty_cycle_sp=-50)
self.rightMotor.run_direct(duty_cycle_sp=-50)
# Go backwards
def backwards(self):
self.leftMotor.run_direct(duty_cycle_sp=50)
self.rightMotor.run_direct(duty_cycle_sp=50)
# Go left
def left(self):
self.leftMotor.run_to_rel_pos(position_sp=-320, speed_sp=400)
self.rightMotor.run_to_rel_pos(position_sp=320, speed_sp=400)
# Wait for motors to complete rotation
self.leftMotor.wait_while('running')
self.rightMotor.wait_while('running')
# Go right
def right(self):
self.leftMotor.run_to_rel_pos(position_sp=320, speed_sp=400)
self.rightMotor.run_to_rel_pos(position_sp=-320, speed_sp=400)
# Wait for motors to complete rotation
self.leftMotor.wait_while('running')
self.rightMotor.wait_while('running')
# Stop motors
def stop(self):
self.mediumMotor.stop()
self.leftMotor.stop()
self.rightMotor.stop()
# Exit program
def exit(self, client, display):
# Stop the motors
self.stop()
# Close server's connection
client.send(bytes("quit", 'utf-8'))
# Close client's connection
client.close()
# Get current time HH:MM:SS
now = datetime.now()
time = now.strftime("%H:%M:%S")
print(str(time) + ": Exit program")
display.exit()
# Move Character
def movement(self, client, display):
# Get user's input
k = self.getch()
# Get current time HH:MM:SS
now = datetime.now()
time = now.strftime("%H:%M:%S")
# Exit program
if k == 'q':
self.exit(client, display)
# Stop engines
elif k == '0':
self.stop()
print(str(time) + ": Stopped motors")
# Go forward
elif k == 'w':
self.forward()
print(str(time) + ": Go forward")
# Go backwards
elif k == 's':
self.backwards()
print(str(time) + ": Go backwards")
# Go left
elif k == 'a':
self.left()
self.forward()
print(str(time) + ": Turn left")
# Go right
elif k == 'd':
self.right()
self.forward()
print(str(time) + ": Turn right")
# Get weather
elif k == 'e':
# Stop the motors
self.stop()
# Send request to server
client.send(bytes("weather", 'utf-8'))
# Get message from server
result = client.recv(1024).decode()
print(str(time) + ": " + result)
# Check if message was successful
if result == "Failed":
display.drawText("")
self.playFile("Sounds/4.wav")
else:
display.drawText(result)
self.playFile("Sounds/1.wav")
block=True,
brake=True)
STING_MOTOR.on_for_seconds(
speed=40,
seconds=1,
brake=True,
block=True)
GO_MOTOR.on(
speed=-50,
block=False,
brake=False)
SPEAKER.play_file(
wav_file='/home/robot/sound/Blip 2.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
while (INFRARED_SENSOR.distance(channel=1) is None) or (INFRARED_SENSOR.distance(channel=1) >= 30):
pass
while INFRARED_SENSOR.heading(channel=1) <= 5:
pass
GO_MOTOR.on(
speed=-20,
brake=False,
block=False)
while INFRARED_SENSOR.heading(channel=1) >= 3:
pass
#!/usr/bin/env micropython
from ev3dev2.sound import Sound
SPEAKER = Sound()
SPEAKER.play_file(wav_file='/home/robot/sound/Fanfare.wav',
volume=50,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/LEGO.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/Green.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/EV3.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/Good.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/Boo.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
SPEAKER.play_file(wav_file='/home/robot/sound/Activate.wav',
LIGHTS.set_color(
group=Leds.LEFT,
color=Leds.RED,
pct=1)
LIGHTS.set_color(
group=Leds.RIGHT,
color=Leds.RED,
pct=1)
MEDIUM_MOTOR.off(brake=True)
TAIL_MOTOR.off(brake=True)
SPEAKER.play_file(
wav_file='/home/robot/sound/Snake hiss.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
CHEST_MOTOR.on_for_seconds(
speed=100,
seconds=1,
brake=True,
block=True)
MEDIUM_MOTOR.on(
speed=100,
brake=False,
block=False)
TAIL_MOTOR.on(
speed=-100,
class MindstormsGadget(AlexaGadget):
def __init__(self):
super().__init__(gadget_config_path='./auth.ini')
# order queue
self.queue = Queue()
self.button = Button()
self.leds = Leds()
self.sound = Sound()
self.console = Console()
self.console.set_font("Lat15-TerminusBold16.psf.gz", True)
self.dispense_motor = LargeMotor(OUTPUT_A)
self.pump_motor = LargeMotor(OUTPUT_B)
self.touch_sensor = TouchSensor(INPUT_1)
# Start threads
threading.Thread(target=self._handle_queue, daemon=True).start()
threading.Thread(target=self._test, daemon=True).start()
def on_connected(self, device_addr):
self.leds.animate_rainbow(duration=3, block=False)
self.sound.play_song((('C4', 'e3'), ('C5', 'e3')))
def on_disconnected(self, device_addr):
self.leds.animate_police_lights('RED',
'ORANGE',
duration=3,
block=False)
self.leds.set_color("LEFT", "BLACK")
self.leds.set_color("RIGHT", "BLACK")
self.sound.play_song((('C5', 'e3'), ('C4', 'e3')))
def _test(self):
while 1:
self.button.wait_for_pressed('up')
order = {
'name': 'Test',
'tea': 'Jasmine',
'sugar': 100,
'ice': 100
}
self.queue.put(order)
sleep(1)
def _handle_queue(self):
while 1:
if self.queue.empty(): continue
order = self.queue.get()
self._make(name=order['name'],
tea=order['tea'],
sugar=order['sugar'],
ice=order['ice'])
def _send_event(self, name, payload):
self.send_custom_event('Custom.Mindstorms.Gadget', name, payload)
def _affirm_receive(self):
self.leds.animate_flash('GREEN',
sleeptime=0.25,
duration=0.5,
block=False)
self.sound.play_song((('C3', 'e3'), ('C3', 'e3')))
def on_custom_mindstorms_gadget_control(self, directive):
try:
payload = json.loads(directive.payload.decode("utf-8"))
print("Control payload: {}".format(payload), file=sys.stderr)
control_type = payload["type"]
# regular voice commands
if control_type == "automatic":
self._affirm_receive()
order = {
"name": payload["name"] or "Anonymous",
"tea": payload["tea"] or "Jasmine Milk Tea",
"sugar": payload["sugar"] or 100,
"ice": payload["ice"] or 100,
}
self.queue.put(order)
# series of voice commands
elif control_type == "manual": # Expected params: [command]
control_command = payload["command"]
if control_command == "dispense":
self._affirm_receive()
if payload['num']:
self._dispense(payload['num'])
else:
self._dispense()
elif control_command == "pour":
self._affirm_receive()
if payload['num']:
self._pour(payload['num'])
else:
self._pour()
except KeyError:
print("Missing expected parameters: {}".format(directive),
file=sys.stderr)
def _make(self, name=None, tea="Jasmine Milk Tea", sugar=100, ice=100):
if not self.touch_sensor.is_pressed:
# cup is not in place
self._send_event('CUP', None)
self.touch_sensor.wait_for_pressed()
sleep(3) # cup enter delay
# mid_col = console.columns // 2
# mid_row = console.rows // 2
# mid_col = 1
# mid_row = 1
# alignment = "L"
process = self.sound.play_file('mega.wav', 100,
Sound.PLAY_NO_WAIT_FOR_COMPLETE)
# dispense boba
self._dispense()
# dispense liquid
self._pour(tea=tea)
# self.console.text_at(
# s, column=mid_col, row=mid_row, alignment=alignment, reset_console=True
# )
# notify alexa that drink is finished
payload = {
"name": name,
"tea": tea,
"sugar": sugar,
"ice": ice,
}
self._send_event("DONE", payload)
process.kill() # kill song
self.sound.play_song((('C4', 'q'), ('C4', 'q'), ('C4', 'q')),
delay=0.1)
self.touch_sensor.wait_for_released()
# dispense liquid
def _pour(self, time_in_s=10, tea="Jasmine Milk Tea"):
# send event to alexa
payload = {"time_in_s": time_in_s, "tea": tea}
self._send_event("POUR", payload)
self.pump_motor.run_forever(speed_sp=1000)
sleep(time_in_s)
self.pump_motor.stop()
# dispense boba
def _dispense(self, cycles=10):
# send event to alexa
payload = {"cycles": cycles}
self._send_event("DISPENSE", payload)
# ensure the dispenser resets to the correct position everytime
if cycles % 2:
cycles += 1
# agitate the boba to make it fall
for i in range(cycles):
deg = 45 if i % 2 else -45
self.dispense_motor.on_for_degrees(SpeedPercent(75), deg)
sleep(0.5)
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.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.speaker = Sound()
def drive_once_by_ir_beacon(self, speed: float = 100):
# forward
if self.ir_sensor.top_left(
channel=self.ir_beacon_channel) and self.ir_sensor.top_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=speed)
# backward
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel
) and self.ir_sensor.bottom_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=-speed)
# turn left on the spot
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel
) and self.ir_sensor.bottom_right(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=speed)
# turn right on the spot
elif self.ir_sensor.top_right(
channel=self.ir_beacon_channel) and self.ir_sensor.bottom_left(
channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=-speed)
# turn left forward
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=0, right_speed=speed)
# turn right forward
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=speed, right_speed=0)
# turn left backward
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=0, right_speed=-speed)
# turn right backward
elif self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
self.tank_driver.on(left_speed=-speed, right_speed=0)
# otherwise stop
else:
self.tank_driver.off(brake=False)
def keep_driving_by_ir_beacon(self, speed: int = 100):
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_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=3,
brake=True,
block=True)
self.touch_sensor.wait_for_released()
def main(self, driving_speed: float = 100):
Thread(target=self.blast_bazooka_whenever_touched).start()
self.keep_driving_by_ir_beacon(speed=driving_speed)
class Rov3r(IRBeaconRemoteControlledTank):
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_port=left_motor_port, right_motor_port=right_motor_port,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
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.ir_beacon_channel = ir_beacon_channel
self.speaker = Sound()
self.dis = Display(desc='Display')
def spin_gears(self, speed: float = 100):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.gear_motor.on(
speed=speed,
block=False,
brake=False)
else:
self.gear_motor.off(brake=True)
def change_screen_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.dis.image_filename(
filename='/home/robot/image/Angry.bmp',
clear_screen=True)
self.dis.update()
else:
self.dis.image_filename(
filename='/home/robot/image/Fire.bmp',
clear_screen=True)
self.dis.update()
def make_noise_when_seeing_black(self):
while True:
if self.color_sensor.color == ColorSensor.COLOR_BLACK:
self.speaker.play_file(
wav_file='/home/robot/sound/Ouch.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
def main(self):
self.speaker.play_file(
wav_file='/home/robot/sound/Yes.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
Thread(target=self.make_noise_when_seeing_black,
daemon=True).start()
Thread(target=self.spin_gears,
daemon=True).start()
Thread(target=self.change_screen_when_touched,
daemon=True).start()
self.keep_driving_by_ir_beacon(speed=100)
#!/usr/bin/env python3
from ev3dev2.led import Leds
from ev3dev2.sound import Sound
from ev3dev2.button import Button
leds = Leds()
sound = Sound()
button = Button
print("You do it for cheese!")
while True:
if button.enter:
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
sound.play_file('/home/robot/pydev/madeleine/SU.wav')
sleep
else:
leds.set_color("LEFT", "RED")
leds.set_color("RIGHT", "RED")
# A long time ago in a galaxy far,
# far away...
Sound.play_song((
('D4', 'e3'), # intro anacrouse
('D4', 'e3'),
('D4', 'e3'),
('G4', 'h'), # meas 1
('D5', 'h'),
('C5', 'e3'), # meas 2
('B4', 'e3'),
class Gripp3r:
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):
self.tank_driver = MoveTank(left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=LargeMotor)
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.speaker = Sound()
def drive_once_by_ir_beacon(self, speed: float = 100):
if self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.top_right(channel=self.ir_beacon_channel):
# go forward
self.tank_driver.on(left_speed=speed, right_speed=speed)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
# go backward
self.tank_driver.on(left_speed=-speed, right_speed=-speed)
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel) and \
self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
# turn around left
self.tank_driver.on(left_speed=-speed, right_speed=speed)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel) and \
self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
# turn around right
self.tank_driver.on(left_speed=speed, right_speed=-speed)
elif self.ir_sensor.top_left(channel=self.ir_beacon_channel):
# turn left
self.tank_driver.on(left_speed=0, right_speed=speed)
elif self.ir_sensor.top_right(channel=self.ir_beacon_channel):
# turn right
self.tank_driver.on(left_speed=speed, right_speed=0)
elif self.ir_sensor.bottom_left(channel=self.ir_beacon_channel):
# left backward
self.tank_driver.on(left_speed=0, right_speed=-speed)
elif self.ir_sensor.bottom_right(channel=self.ir_beacon_channel):
# right backward
self.tank_driver.on(left_speed=-speed, right_speed=0)
else:
self.tank_driver.off(brake=False)
def grip_or_release_by_ir_beacon(self, speed: float = 50):
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
if self.touch_sensor.is_pressed:
self.speaker.play_file(
wav_file='/home/robot/sound/Air release.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.grip_motor.on_for_seconds(speed=speed,
seconds=1,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Airbrake.wav',
volume=100,
play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
self.grip_motor.on(speed=-speed, brake=False, block=False)
self.touch_sensor.wait_for_pressed()
self.grip_motor.off(brake=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self, speed: float = 100):
self.grip_motor.on_for_seconds(speed=-50,
seconds=1,
brake=True,
block=True)
while True:
self.drive_once_by_ir_beacon(speed=speed)
self.grip_or_release_by_ir_beacon()
class Trunk(Ev3Motor):
__Sensor = None
__Speaker = None
#
# Init
# Initialize the motor
def __init__(self, MotorPort, SensorPort):
Logging.basicConfig(level = Logging.getLevelName(Config.LOGGING_LEVEL))
Logging.info('Init trunk motor')
super().__init__(Motor = LargeMotor(address = MotorPort))
Logging.info('Init touch sensor')
self.__Sensor = TouchSensor(address = SensorPort)
self.__Sensor.mode = self.__Sensor.MODE_TOUCH
Logging.info('Init sounds')
self.__Speaker = Sound()
#
# InitPosition
# Move the elephant trunk to the initial position
def InitPosition(self):
Logging.info('Moving trunk to initial position')
# Move the trunk until the touch sensor is pressed
self.Speed = -400
self.StopAction = 'brake'
self.RunForever()
while not self.__Sensor.is_pressed:
Sleep(.01)
# Set position to 0
self.MotorReset()
#
# MakeItRoar
# Make roaring the elephant
def MakeItRoar(self, Wait):
Logging.info('Roaring')
self.__Speaker.play_file(
wav_file = 'Sounds/elephant8.wav',
volume = 100,
play_type = self.__Speaker.PLAY_NO_WAIT_FOR_COMPLETE
)
Logging.info('Moving trunk in roar position')
self.Position = 0
self.Speed = 400
self.StopAction = 'brake'
self.RunToAbsolutePosition()
if Wait:
self.WaitWhileRunning()
self.MotorOff()
#
# MakeItEat
# Make eating the elephant
def MakeItEat(self, Wait):
Logging.info('Moving trunk in eat position')
self.Position = 1400
self.Speed = 400
self.StopAction = 'brake'
self.RunToAbsolutePosition()
if Wait:
self.WaitWhileRunning()
self.MotorOff()
#
# PutToNormalPosition
# Move the trunk to the normal position
def PutToNormalPosition(self, Wait = True):
Logging.info('Moving trunk to normal position')
self.Position = 300
self.Speed = 400
self.StopAction = 'brake'
self.RunToAbsolutePosition()
if Wait:
self.WaitWhileRunning()
self.MotorOff()
#
# PutTrunkDown
# Put the elephant trunk down
def PutTrunkDown(self, Wait):
Logging.info('Moving trunk down')
self.Position = 600
self.Speed = 400
self.StopAction = 'brake'
self.RunToAbsolutePosition()
if Wait:
self.WaitWhileRunning()
self.MotorOff()
#
# Stop
# Stop moving
def Stop(self):
Logging.info('Stop moving')
self.MotorOff()
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.ir_beacon_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_file(wav_file='/home/robot/sound/Good.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
def make_noise_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.speaker.play_file(wav_file='/home/robot/sound/Ouch.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
def throw_by_ir_beacon(self):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.catapult_motor.on_for_degrees(speed=-100,
degrees=150,
brake=True,
block=True)
self.catapult_motor.on_for_degrees(speed=100,
degrees=150,
brake=True,
block=True)
while self.ir_sensor.beacon(channel=self.ir_beacon_channel):
pass
def main(self):
self.speaker.play_file(wav_file='/home/robot/sound/Yes.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
Thread(target=self.make_noise_when_touched, daemon=True).start()
Thread(target=self.throw_by_ir_beacon, daemon=True).start()
Thread(target=self.scan_colors, daemon=True).start()
self.keep_driving_by_ir_beacon(speed=100)
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,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
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.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.leds = Leds()
self.speaker = Sound()
def seek_wheeler(self):
self.leds.animate_rainbow(group1=Leds.LEFT,
group2=Leds.RIGHT,
increment_by=0.1,
sleeptime=0.5,
duration=5,
block=True)
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
heading_difference = self.ir_sensor.heading(
channel=self.ir_beacon_channel) - (-3)
proximity_difference = self.ir_sensor.distance(
channel=self.ir_beacon_channel) - 70
if (heading_difference == 0) and (proximity_difference == 0):
self.tank_driver.off(brake=True)
self.leds.animate_rainbow(group1=Leds.LEFT,
group2=Leds.RIGHT,
increment_by=0.1,
sleeptime=0.5,
duration=5,
block=True)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=3,
brake=True,
block=True)
self.speaker.play_file(
wav_file='/home/robot/sound/Laughing 2.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
else:
# FIXME: make it work
self.tank_driver.on(left_speed=max(
min((3 * proximity_difference + 4 * heading_difference) /
5, 100), -100),
right_speed=max(
min((3 * proximity_difference -
4 * heading_difference) / 5, 100),
-100))
else:
self.tank_driver.off(brake=True)
def main(self):
while True:
self.seek_wheeler()
