def backup(): """ Back away from an obstacle. """ # Sound backup alarm. spkr = Sound() # spkr.tone([(1000, 500, 500)] * 3) spkr.speak('du du') # Turn backup lights on: leds = Leds() for light in ('LEFT', 'RIGHT'): leds.set_color(light, 'RED') # Stop both motors and reverse for 1.5 seconds. # `run-timed` command will return immediately, so we will have to wait # until both motors are stopped before continuing. for m in motors: m.stop(stop_action='brake') m.run_timed(speed_sp=-500, time_sp=1500) # When motor is stopped, its `state` attribute returns empty list. # Wait until both motors are stopped: while any(m.state for m in motors): sleep(0.1) # Turn backup lights off: for light in ('LEFT', 'RIGHT'): leds.set_color(light, 'GREEN')
def speech_examples(): sound = Sound() # see http://espeak.sourceforge.net/ # values -a 200 -s 130 SHOULD BE INCLUDED if specifying any other options # a = amplitude (200 max, 100 default), s = speed 80-500, default = 175) opts = '-a 200 -s 150 -p 70 -v' # str_en = "I think you ought to know, I'm feeling very depressed" str_en = "Hello Big Daddy, your wish is my command" # Default voice = English, male # sound.speak(str_en) # English, male1 (lowest male tone) # sound.speak(str_en, espeak_opts='-a 200 -s 130 -ven+m1') # long form # English, male7 (highest male tone) # sound.speak(str_en, espeak_opts=opts+'en+m7') # using my variable 'opts' # English, female1 (lowest female tone) # sound.speak(str_en, espeak_opts=opts+'en+f1') # English, female5 (highest female tone) sound.speak(str_en, espeak_opts=opts + 'en+f5') sleep(5) # croak # sound.speak(str_en, espeak_opts=opts+'en+croak') # whisper # sound.speak(str_en, espeak_opts=opts+'en+whisper') # en-us = US English # sound.speak(str_en, espeak_opts=opts+'en-us') # en-rp = Received pronunciation ('BBC English') # sound.speak(str_en, espeak_opts=opts+'en-rp') # s = 80 is slowest possible speed # sound.speak(str_en, espeak_opts='-a 200 -s 80') # s = 300 is a high speed # sound.speak(str_en, espeak_opts='-a 200 -s 300') # French str_fr = 'Le chat est sous la chaise! Le singe est sur la branche!'
def trytospeak(): sound = Sound() #play a standard beep sound.beep() sleep(2) # pause for 2 seconds # Play a SINGLE 2000 Hz tone for 1.5 seconds sound.play_tone(2000, 1.5) sleep(2) # Play a SEQUENCE of tones sound.tone([(200, 2000, 400), (800, 1800, 2000)]) sleep(2) # Play a 500 Hz tone for 1 second and then wait 0.4 seconds # before playing the next tone # Play the tone three times sound.tone([(500, 1000, 400)] * 3) sleep(2) #text to speech sound.speak('Hello, my name is E V 3!') sound.speak('watch me talk')
class Speaker(Action): def __init__(self, text): self.text = text self.sound = Sound() def execute(self): self.sound.speak(self.text) return True
def waitStart(): speaker = Sound() speaker.speak('ready to run') touch = TouchSensor(INPUT_1) while not touch.is_pressed: sleep(0.1) mainThread = Thread(target=main) mainThread.start()
def colorSensor(): color_sensor = ColorSensor() sound = Sound() while True: color = color_sensor.color text = ColorSensor.COLORS[color] sound.speak(text)
def on_message(client, userdata, msg): data = msg.payload.decode().split() comm = int(data[0]) if comm == 0 and len(data) >= 2: sound = Sound() sound.speak(msg.payload.decode()[2:]) elif comm == 1 and len(data) >= 4: print(int(data[1]), int(data[2]), int(data[3])) MoveTank(OUTPUT_B, OUTPUT_A).on_for_seconds(SpeedPercent(int(data[1])), SpeedPercent(int(data[2])), int(data[3]))
def test_speak(self): spkr = Sound() spkr.connector.play_actual_sound = False spkr.speak("tests tests tests tests tests", volume=100, play_type=1) spkr.speak("kekeroni", volume=100, play_type=0) self.assertEqual(len(self.clientSocketMock.mock_calls), 2) fn_name, args, kwargs = self.clientSocketMock.mock_calls[0] self.assertEqual(fn_name, 'send_command') self.assertDictEqual(args[0].serialize(), {'type': 'SoundCommand', 'duration': 1.5, # 200 words per minute, (5 / 200) * 60 = 1.5 'message': 'Saying: ``tests tests tests tests tests``', 'soundType': 'speak'})
def play_sonic(button_pressed: Value, pipe: Pipe): child_conn = pipe[1] sound = Sound() # songs = ['sonic_songs/{}'.format(file) for file in listdir('sonic_songs')] # size = len(songs) # count = 0 switch = { 0: lambda: sound.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) ], play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE), 1: lambda: (sound.speak("Chomp") for _ in range(5)) } switch.get(0) while button_pressed.value == 0: switch.get(child_conn.recv())()
class lego_tank(): def __init__(self): try: self.tank_drive = MoveTank(OUTPUT_D, OUTPUT_A) self.sound = Sound() self.sound.speak("Ready to start") self.sound.speak("Waiting for orders my commander") except: self.tank_drive = False self.degrees = 1230 print("Create the tank_drive") def right(self): print("Turning right") if self.tank_drive: self.tank_drive.on_for_degrees(50, -50, 470) else: # We do not have outputs if we run this from our own computer pass def left(self): print("Turning left") if self.tank_drive: self.tank_drive.on_for_degrees(-50, 50, 470) else: # We do not have outputs if we run this from our own computer pass def forward(self): print("I am moving forward") if self.tank_drive: self.tank_drive.on_for_degrees(50, 50, self.degrees) else: # We do not have outputs if we run this from our own computer pass def backward(self): print("I am moving backwards") if self.tank_drive: self.tank_drive.on_for_degrees(50, 50, (-1) * self.degrees) else: # We do not have outputs if we run this from our own computer pass
def test_speak(self): 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.speak("tests tests tests tests") sleep(3) for x in range(4): flip *= -1 tank_drive.on_for_seconds(SpeedPercent(30 * flip), SpeedPercent(30 * flip), 1, True, True) s.speak("tests tests tests tests", play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE) sleep(3)
def setup(): global tank_drive, colorSensorLeft, colorSensorRight, ultra, sound, touchSensor, gyroSensor #g tank_drive = MoveTank(OUTPUT_A, OUTPUT_B) #tank_drive.gyro = GyroSensor('in4') #sleep(1) sound = Sound() #tank_drive.gyro.calibrate() sound.speak("setup") colorSensorLeft = ColorSensor('in1') colorSensorRight = ColorSensor('in2') colorSensorLeft.mode = 'COL-COLOR' colorSensorRight.mode = 'COL-COLOR' #ultra = UltrasonicSensor('in3') touchSensor = TouchSensor('in3') gyroSensor = GyroSensor('in4') gyroSensor.calibrate()
class Robot: 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() # Controls the robot led colors def set_leds(self, color): self.leds.set_color("LEFT", color) self.leds.set_color("RIGHT", color) # Movement control for the robot, sets the left and righ # engine speeds to 100 def move(self, speed_left=100, speed_right=100): self.tank_drive.on(speed_left, speed_right) # Stop control for the robot def stop(self, brake=True): self.tank_drive.off(brake) # Returns the ultrasound sensor distance in centimetres def get_distance(self): return self.ultra.distance_centimeters # Returns the light sensor reflected light intensity value def get_color(self): return self.color.reflected_light_intensity # Controls the speaker def speak(self, say): self.sound.speak(text=say, play_type=Sound.PLAY_NO_WAIT_FOR_COMPLETE)
def draw(self, path=None, multicolor=False): speaker = Sound() if path is not None: if multicolor: speaker.speak("Printing multi color image") print("\nPrinting multi color image...") else: speaker.speak("Printing single color image") print("\nPrinting single color image...") binarized, img_x, img_y = utilities.binarize_image( path, self._x_res, self._y_res, multicolor) else: binarized, img_x, img_y = utilities.generate_and_binarize_test_image( self._pixel_size) speaker.speak("Printing test page") print("\nPrinting test page...") quick_calibration = False for layer, i in zip(binarized, range(1, utilities.NUM_OF_COLORS)): speaker.speak("Insert a {} pen and press the touch sensor".format( utilities.palette_names[i])) self._touch.wait_for_pressed() self.calibrate(quick_calibration) p_codes = utilities.binarized_image_to_p_codes( layer, img_x, img_y, self._padding_left) if self._interpret_p_codes(p_codes): break self._paper_scroll(self._y_res) self._fb_motor.reset() self._ud_motor.reset() self._lr_motor.reset() quick_calibration = True speaker = Sound() speaker.speak("Printing finished") print("Printing finished")
def _interpret_p_codes(self, p_codes): btn = Button() speaker = Sound() self._current_line = 0 abort = False print("---------- p_codes:----------") print("-------------- Line {} --------------".format( self._current_line)) for x in p_codes: if btn.down: speaker.speak("Aborting") print("\nAborting...") abort = True break if x[0] == utilities.Command.PEN_UP: if not self._is_pen_up: self._pen_up(x[1]) elif x[0] == utilities.Command.PEN_DOWN: if self._is_pen_up: self._pen_down(x[1]) elif x[0] == utilities.Command.PEN_RIGHT: self._pen_right(x[1]) elif x[0] == utilities.Command.PEN_LEFT: self._pen_left(x[1]) elif x[0] == utilities.Command.SCROLL: self._paper_scroll(x[1]) if not self._is_pen_up: self._pen_up(1) self._ud_motor.stop() return abort
def make_drink(order, length): _id = order["_id"] name = order["name"] tea = order["options"]["tea"] sugar = order["options"]["sugar"] ice = order["options"]["ice"] console.text_at( "Making Order for " + name + "\n" + tea + " " + str(sugar) + "%" + " " + str(ice) + "%" + "\nQueue Size: " + str(length), column=mid_col, row=mid_row, alignment=alignment, reset_console=True, ) sound = Sound() sound.speak("Dispensing boba") # dispense boba m = LargeMotor(OUTPUT_B) m.on_for_rotations(SpeedPercent(75), 10) sound.speak("Dispensing " + tea) # dispense liquid m = LargeMotor(OUTPUT_A) m.run_forever(speed_sp=1000) sleep(10) m.stop() s = name + ", your boba drink is finished. Please come pick it up" console.text_at(s, column=mid_col, row=mid_row, alignment=alignment, reset_console=True) sound.speak(s) requests.patch(URL + "/queue/" + _id, json={})
def speak_and_rotate(): sound = Sound() os.system('setfont Lat15-TerminusBold14') mL = LargeMotor('outB') mL.stop_action = 'hold' mR = LargeMotor('outC') mR.stop_action = 'hold' print('Hello, my name is EV3D4!') str_en = 'Hello, my name is E V 3 D 4!' opts = '-a 200 -s 150 -p 70 -v' sound.speak(str_en, espeak_opts=opts + 'en+f5') sleep(2) str_en = "Performing perimeter scan" sound.speak(str_en, espeak_opts=opts + 'en+f5') # Sound.speak('Hello, my name is Evie, 3 D 4!').wait() mL.run_to_rel_pos(position_sp=1662, speed_sp=300) mR.run_to_rel_pos(position_sp=-1662, speed_sp=300) #mL.wait_while('running') #mR.wait_while('running') sleep(1) str_en = "At your command Big Daddy" sound.speak(str_en, espeak_opts=opts + 'en+f5') sleep(1)
def __play_text_sound(self, words): sound = Sound() sound.speak(words)
#!/usr/bin/env micropython from ev3dev2.sound import Sound sound = Sound() sound.speak("jake operational")
from roberta.ev3 import Hal from ev3dev2.motor import LargeMotor, MediumMotor from ev3dev2.motor import MoveSteering, OUTPUT_A, OUTPUT_D from ev3dev2.motor import MoveTank, OUTPUT_A, OUTPUT_D from ev3dev2.sound import Sound from ev3dev import ev3 as ev3dev #lm = LargeMotor(OUTPUT_A) #rm = LargeMotor(OUTPUT_D) mm = MediumMotor(OUTPUT_B) sound = Sound() opts = '-a 200 -s 130 -v' text = 'Saluton amikoj, mi estas Robi! mi sxatas muziki kaj danci' sound.speak(text, espeak_opts=opts+'eo') class BreakOutOfALoop(Exception): pass class ContinueLoop(Exception): pass _brickConfiguration = { 'wheel-diameter': 5.6, 'track-width': 18.0, 'actors': { 'A':Hal.makeLargeMotor(ev3dev.OUTPUT_A, 'on', 'foreward', 'right'), 'D':Hal.makeLargeMotor(ev3dev.OUTPUT_D, 'on', 'foreward', 'left'), } } hal = Hal(_brickConfiguration) def s3():
#!/usr/bin/env micropython from ev3dev2.sound import Sound sound = Sound() sound.speak('Welcome to Griffy 3 point Oh!') sound.speak('Hello Nate, Gideon and Kai')
from ev3dev2.sound import Sound from ev3dev2.motor import MoveSteering from ev3dev2.motor import OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D rob = MoveSteering(OUTPUT_D, OUTPUT_B) mySnd = Sound() mySnd.speak("Turning right in place") rob.on_for_seconds(50, -50, 2) mySnd.speak("Spiraling") rob.on_for_seconds(20, 50, 2) rob.off()
#!/usr/bin/env python3 from ev3dev2.sound import Sound from time import sleep sound = Sound() #play a standard beep sound.beep() sleep(2) # pause for 2 seconds # Play a SINGLE 2000 Hz tone for 1.5 seconds sound.play_tone(2000, 1.5) sleep(2) # Play a SEQUENCE of tones sound.tone([(200, 2000, 400), (800, 1800, 2000)]) sleep(2) # Play a 500 Hz tone for 1 second and then wait 0.4 seconds # before playing the next tone # Play the tone three times # [(500, 1000, 400)] * 3 is the same as # [(500, 1000, 400), (500, 1000, 400), (500, 1000, 400)] sound.tone([(500, 1000, 400)] * 3) sleep(2) #text to speech sound.speak('Hello, my name is E V 3!')
#!/usr/bin/env python3 from ev3dev2.sound import Sound sound = Sound() sound.speak("I'm not Alexa, I swear!")
class Robot: """ Robot is a class that instantiates and sets up the robot so that it is ready for use. It initializes the sensors and the tank drive, and it sets up the sensors. On top of that it provides functions so that the robot can be controlled. """ def __init__(self, sensormap, bluetooth=None): """ Initializer for a Robot. """ self.bluetooth = bluetooth if bluetooth: self.bluetooth.initiate_connection() print('connected') if isinstance(bluetooth, BluetoothMaster): self.database = bluetooth.get_database() self.sensormap = sensormap self.sound = Sound() self.leds = Leds() def speak(self, text): """ Speak in separate thread so it does not block anything. """ threading.Thread( target=lambda: self.sound.speak(text, Sound.PLAY_NO_WAIT_FOR_COMPLETE) ).start() def start_drive(self, speed_percentage=40): """ Activates the motors of the robot to move forward. :param speed_percentage: The speed of the Robot based on motor power. Percentage between 0 and 100. """ self.sensormap.tank_drive.on(SpeedPercent(speed_percentage), SpeedPercent(speed_percentage)) def reverse_for_rotations(self, nr_rotations, rpm=60, lock=None): """ Reverses the Robot (makes it move backwards). :param nr_rotations: Number of degrees Robot turns. :param rpm: Speed at which the Robot reverses in rotations per minute. :param lock: Optional Lock to stop the operation when requested """ self.sensormap.tank_drive.on_for_rotations(SpeedRPM(-rpm), SpeedRPM(-rpm), nr_rotations, block=False) end_time = datetime.now() + timedelta(seconds=(nr_rotations*60)/rpm) while datetime.now() < end_time: if lock and lock.is_locked(): self.sensormap.tank_drive.stop() break time.sleep(0.01) def turn_for_rotations(self, rotations, rpm=30, lock=None): """ Turn for a number of degrees with the given speed. Can be pre-empted when given a Lock. :param rotations: The number of rotations to turn. :param rpm: The speed to turn at. :param lock: Optional Lock to stop the operation when requested. """ self.sensormap.tank_drive.on_for_rotations(SpeedRPM(rpm), SpeedRPM(-rpm), abs(rotations), block=False) end_time = datetime.now() + timedelta(seconds=(abs(rotations)*60)/abs(rpm)) while datetime.now() < end_time: if lock and lock.is_locked(): self.sensormap.tank_drive.stop() break time.sleep(0.01) def rotate_degrees(self, rotations, reverse_before_continue=True, rpm=35, lock=None): """ Rotates the Robot. :param rotations: Number of rotations the Robot rotates. :param reverse_before_continue: True if Robot needs to reverse before turning, False if not. :param rpm: Speed at which the Robot turns. :param lock: Optional Lock to stop the operation when requested """ if reverse_before_continue: self.reverse_for_rotations(.6, lock=lock) if rotations < 0: rpm *= -1 self.turn_for_rotations(abs(rotations), rpm=rpm, lock=lock)
class Robot: def __init__(self): self.steer = MoveSteering(OUTPUT_B, OUTPUT_C) self.tank_pair = MoveTank(OUTPUT_B, OUTPUT_C) self.touch_sensor = TouchSensor() self.cl = ColorSensor() self.s = Sound() self.btn = Button() self.c_switch = True # True: Turning left, comp right, False: opposite. self.col_switch = True # True: black, False: white. self.tile_count = 0 self.tile_length = 230 # Sets up offset for variable light self.off_set = self.cl.reflected_light_intensity - 13 self.black_range = range(0, 30) self.white_range = range(30, 100) def move_degrees(self, degrees): self.tank_pair.on_for_degrees(left_speed=10, right_speed=10, degrees=degrees) def run(self): # Moves the robot off starting pad and onto black-white tiles self.tank_pair.on_for_degrees(left_speed=50, right_speed=50, degrees=90) while (self.cl.reflected_light_intensity in self.black_range): self.tank_pair.on(left_speed=20, right_speed=20) self.tank_pair.off() while not (self.cl.reflected_light_intensity in self.black_range): self.tank_pair.on(left_speed=20, right_speed=20) self.tank_pair.off() self.tank_pair.on_for_degrees(left_speed=50, right_speed=50, degrees=self.tile_length * 0.75) self.tank_pair.on_for_degrees(left_speed=20, right_speed=-20, degrees=180) while not (self.cl.reflected_light_intensity in self.white_range): self.tank_pair.on(left_speed=-20, right_speed=-20) self.tank_pair.off() self.tank_pair.on_for_degrees(left_speed=20, right_speed=20, degrees=self.tile_length * 0.25) current_tile = self.getColour() self.center_robot(current_tile) while not (self.cl.reflected_light_intensity in current_tile): self.tank_pair.on(left_speed=20, right_speed=20) self.tank_pair.off() #self.tank_pair.on(left_speed=20, right_speed=20) while (self.tile_count < 15): moved_degrees = 0 correct_alignment = True black_found = False while (True): while (self.cl.reflected_light_intensity in self.white_range): self.tank_pair.on() self.tank_pair.off() if (self.cl.reflected_light_intensity in self.black_range): black_found = True print("found black") break if (black_found): self.tile_count += 1 self.tank_pair.on(left_speed=20, right_speed=20) if (correct_alignment and self.tile_count > 1): self.move_degrees(self.tile_length * 0.25) turn_degrees_right = 0 turn_degrees_left = 0 while not (self.cl.reflected_light_intensity in self.white_range): self.tank_pair.on_for_degrees(left_speed=10, right_speed=-10, degrees=10) turn_degrees_right += 10 self.tank_pair.on_for_degrees(left_speed=-10, right_speed=10, degrees=turn_degrees_right) while not (self.cl.reflected_light_intensity in self.white_range): self.tank_pair.on_for_degrees(left_speed=-10, right_speed=10, degrees=10) turn_degrees_left += 10 if (turn_degrees_right < turn_degrees_left): self.tank_pair.on_for_degrees( left_speed=10, right_speed=-10, degrees=turn_degrees_left - turn_degrees_right) elif (turn_degrees_left < turn_degrees_right): self.tank_pair.on_for_degrees( left_speed=10, right_speed=-10, degrees=turn_degrees_right - turn_degrees_left) else: self.s.speak("This should never have happened.") self.tank_pair.on_for_degrees( left_speed=10, right_speed=-10, degrees=turn_degrees_left) else: while not (self.cl.reflected_light_intensity in self.white_range): pass self.tank_pair.off() if (moved_degrees > self.tile_length): self.realign() else: self.realign() ''' previous_tile_count = 0 saw_black_realign = False saw_black = True while (self.tile_count < 15): if not (t.is_alive()): # check for realignment if (previous_tile_count < self.tile_count): self.s.speak(str(self.tile_count)) previous_tile_count = self.tile_count if not (saw_black_realign): self.realign() t.start() saw_black_realign = False if (self.cl.reflected_light_intensity in self.white_range and saw_black): self.tile_count +=1 saw_black = False #self.tank_pair.off() #self.s.speak(str(self.tile_count)) #self.tank_pair.on(left_speed=20, right_speed=20) if (self.cl.reflected_light_intensity in self.black_range): saw_black = True saw_black_realign = True self.tank_pair.off() ''' ''' if (self.cl.reflected_light_intensity > 55 and self.col_switch): self.tank_pair.off() self.titleCount += 1 self.col_switch = False self.s.speak(str(self.titleCount)) self.tank_pair.on(left_speed=20, right_speed=20) if (self.cl.reflected_light_intensity < 20 and not self.col_switch): self.col_switch = True ''' def realign(self): # check side black is on self.s.speak("life is pain") # returns oposite colour def getColour(self): if (self.cl.reflected_light_intensity in self.black_range): return self.white_range elif (self.cl.reflected_light_intensity in self.white_range): return self.black_range def center_robot(self, colour): right_turn_count = 0 left_turn_count = 0 #bias = 1/2 while not (self.cl.reflected_light_intensity in colour): self.tank_pair.on_for_degrees(left_speed=10, right_speed=-10, degrees=10) right_turn_count += 1 #if (self.cl.reflected_light_intensity in self.gray_range): # bias = 3/4 self.tank_pair.on_for_degrees(left_speed=-10, right_speed=10, degrees=10 * right_turn_count) while not (self.cl.reflected_light_intensity in colour): self.tank_pair.on_for_degrees(left_speed=-10, right_speed=10, degrees=10) left_turn_count += 1 #if (self.cl.reflected_light_intensity in self.gray_range): # bias = 1/4 #if (abs(left_turn_count-right_turn_count) < 2): # bias = 1/2 self.tank_pair.on_for_degrees( left_speed=10, right_speed=-10, degrees=(10 * (right_turn_count + left_turn_count) / 2)) self.ninety_turn = 10 * (right_turn_count + left_turn_count) / 2 def length_of_tile(self): count = 0 while (self.cl.reflected_light_intensity in self.black_range): self.tank_pair.on_for_degrees(left_speed=10, right_speed=10, degrees=10) count += 1 self.s.speak(str(count * 10)) def checkColour(self): while not self.btn.any(): self.touch_sensor.wait_for_pressed() self.s.speak(str(self.cl.reflected_light_intensity))
if os.path.isfile(OPEN_BLING_path): os.remove(OPEN_BLING_path) if os.path.isfile(OPEN_GREEN_LIGHT_path): os.remove(OPEN_GREEN_LIGHT_path) if os.path.isfile(GREEN_LIGHT_path): os.remove(GREEN_LIGHT_path) sound.speak("O, A, O, A") print("OKOKOKOKOKOKOKOKOKOKOK") ''' while True: if ts.is_pressed: mt.off() break if btn.check_buttons(buttons=['up']): mt.on(-50, -50) elif btn.check_buttons(buttons=['up']) == False: mt.off() ''' ts.wait_for_bump() sound.play_tone(2500, 0.1)
#执行用例 test() exit() disp = Display() leds = Leds() sounds = Sound() #ts = TouchSensor(INPUT_2) sounds.beep() sleep(1) sounds.set_volume(100) sounds.speak(text='1.15') #sounds.speak(text='Welcome to the E V 3 dev project!') sleep(1) exit() ''' console.reset_console() console.text_at('Hello World!', column=1, row=5, reset_console=True, inverse=True) sleep(2) ''' # 在屏幕上显示字体 if True: #显示有效的Display字体 print(fonts.available(), file=sys.stderr) sleep(2)
#!/usr/bin/env python3 from time import sleep from ev3dev2.sensor import INPUT_2 from ev3dev2.sensor.lego import TouchSensor from ev3dev2.led import Leds from ev3dev2.sound import Sound ts = TouchSensor(INPUT_2) leds = Leds() speaker = Sound() print("Press the touch sensor to change the LED color!") speaker.speak("Press the touch sensor to change the LED color!") while True: if ts.is_pressed: leds.set_color("LEFT", "GREEN") leds.set_color("RIGHT", "GREEN") else: leds.set_color("LEFT", "RED") leds.set_color("RIGHT", "RED") # don't let this loop use 100% of CPU sleep(0.01)
#!/usr/bin/env python3 from ev3dev2.motor import MoveSteering, OUTPUT_B, OUTPUT_C from ev3dev2.sensor.lego import ColorSensor from ev3dev2.button import Button from ev3dev2.sound import Sound from time import sleep cl = ColorSensor() btn = Button() sound = Sound() steer_pair = MoveSteering(OUTPUT_B, OUTPUT_C) sound.speak('Press the Enter key when the sensor is in dim light') btn.wait_for_bump('enter') dim = cl.ambient_light_intensity sound.beep() sound.speak('Press the Enter key when the sensor is in bright light') btn.wait_for_bump('enter') bright = cl.ambient_light_intensity sound.beep() sound.speak('3, 2, 1, go!') while not btn.any(): # Press any key to exit intensity = cl.ambient_light_intensity steer = (200 * (intensity - dim) / (bright - dim)) - 100 steer = min(max(steer, -100), 100) steer_pair.on(steering=steer, speed=30) sleep(0.1) # wait for 0.1 seconds
else: resultado = mr / c return resultado while waiting: if btn.any(): # Checks if any button is pressed. sound.beep() # Wait for the beep to finish. global waiting waiting = False else: sleep(0.01) # Wait 0.01 second rgbmax_e = definir_rgbmax('esq') rgbmax_d = definir_rgbmax('dir') sound.speak('ok') #c = open('dist1.txt','w+') #c.close() # for i in range(100): # steering_pair.on_for_degrees(0,5,10) # sleep(0.02) # d = distancia_do_corre(usl) # c = open('testecor.txt','a') # n = str(i) # c = open('dist.txt','a') # c.write(n) # c.write(') ') # c.write(str(d)) # c.write('\n')