def test_go_straight_for_inches_using_encoder(): robot = rosebot.RoseBot() robot.drive_system.go_straight_for_inches_using_encoder(10, 100) robot.drive_system.go_straight_for_inches_using_encoder(10, -100) robot.drive_system.go_straight_for_inches_using_encoder(20, 100) robot.drive_system.go_straight_for_inches_using_encoder(20, -100) #def test_go(speed1, speed2): # robot = rosebot.RoseBot() # robot.drive_system.go(speed1,speed2) #def test_stop(): robot = rosebot.RoseBot() robot.drive_system.stop()
def main(): """ This code, which must run on the ROBOT: 1. Constructs a robot, an mqtt_sender, and a delegate to respond to messages from the LAPTOP sent via MQTT. 2. Stays in an infinite loop while a listener (for MQTT messages) runs in the background. """ robot = rosebot.RoseBot() delegate = DelegateForRobotCode(robot) mqtt_sender = mqtt.MqttClient(delegate) delegate.set_mqtt_sender(mqtt_sender) mqtt_sender.connect_to_pc(lego_robot_number=1) # DONE 3: Replace 99 in the above by YOUR team's robot number. time.sleep(1) # To let the connection process complete print() print("Starting to listen for messages. The delegate responds to them.") print() # Stay in an infinite loop while the listener (for MQTT messages) # runs in the background: while True: time.sleep(0.01) if delegate.is_time_to_quit: break
def enter_pyramid(speed): robot = rosebot.RoseBot() robot.sound_system.speech_maker.speak( "Ok, I gonna go into the dangerous pyramid!") robot.drive_system.go(speed, speed) while True: if robot.sensor_system.color_sensor.get_color() == "black": robot.drive_system.left(speed, speed) time.sleep(0.01) robot.drive_system.go(speed, speed) else: robot.drive_system.right(speed, speed) time.sleep(0.01) robot.drive_system.go(speed, speed) # if robot.sensor_system.color_sensor.get_color() == "black": # robot.drive_system.left(speed,speed) # time.sleep(0.1) # robot.drive_system.go(speed,speed) if robot.sensor_system.ir_proximity_sensor.get_distance_in_inches( ) < 2: break robot.drive_system.stop() # def detect_danger():
def run_test_drive_system(): """ Test a robot's DRIVE SYSTEM. """ print() print('--------------------------------------------------') print('Testing the DRIVE SYSTEM of a robot') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # STUDENTS: Do the work in this module as follows. # Otherwise, you will be overwhelmed by the number of tests happening. # # For each function that you implement: # 1. Locate the statements just below this comment that call TEST functions. # 2. UN-comment only one test at a time. # 3. Implement that function per its _TODO_. # 4. Implement as needed the appropriate class methods # 5. When satisfied with your work, move onto the next test, # RE-commenting out the previous test to reduce the testing. # ------------------------------------------------------------------------- # run_test_go_stop(robot) # run_test_go_straight_for_seconds(robot) # run_test_go_straight_for_inches(robot) run_test_spin_in_place_for_seconds(robot)
def main(): """ Test a robot's Remote Control, Brick Buttons, and LEDs. """ print() print('--------------------------------------------------') print(' Testing Remote Control, Brick Buttons, and LEDs') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # STUDENTS: Do the work in this module as follows. # Otherwise, you will be overwhelmed by the number of tests happening. # # For each function that you implement: # 1. Locate the statements just below this comment that call TEST functions. # 2. UN-comment only one test at a time. # 3. Implement that function per its _TODO_. # 4. Implement as needed the appropriate class methods # 5. When satisfied with your work, move onto the next test, # RE-commenting out the previous test to reduce the testing. # ------------------------------------------------------------------------- # run_test_leds_on_off(robot) # run_test_leds_colors(robot) # run_test_brick_buttons(robot) run_test_remote_control(robot)
def drive_camera_tests(): robot = rosebot.RoseBot() robot.drive_system.spin_clockwise_until_sees_object(50, 40) robot.drive_system.display_camera_data() time.sleep(3) robot.drive_system.spin_counterclockwise_until_sees_object(50, 40) robot.drive_system.display_camera_data()
def color_sensor_play_note(time_to_stop): robot = rosebot.RoseBot() print("Hello") print("Play Note Based on Color") initial_time = time.time() robot.drive_system.go(50, 50) while True: if robot.sensor_system.color_sensor.get_color_as_name() == 'Red': print("Red") robot.drive_system.stop() A4_note() break if robot.sensor_system.color_sensor.get_color_as_name() == 'Green': print("Green") robot.drive_system.stop() B4_note() break if robot.sensor_system.color_sensor.get_color_as_name() == 'Yellow': print("Yellow") robot.drive_system.stop() C5_note() break if robot.sensor_system.color_sensor.get_color_as_name() == 'Black': print("Black") robot.drive_system.stop() C5_sharp_note() break if time.time() - initial_time >= time_to_stop: print("I did not find any color") robot.drive_system.stop() robot.sound_system.speech_maker.speak("I did not find any color") break
def m3_led_proximity_sensor(initial, rate_of_increase): robot = rosebot.RoseBot() secs = float(initial) threshold = 20 robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off() robot.arm_and_claw.calibrate_arm() robot.drive_system.go(50, 50) while True: distance = robot.sensor_system.ir_proximity_sensor.get_distance() print(distance) # Led Cycle robot.led_system.left_led.turn_on() time.sleep(secs / 4) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_on() time.sleep(secs / 4) robot.led_system.right_led.turn_off() robot.led_system.left_led.turn_on() robot.led_system.right_led.turn_on() time.sleep(secs / 4) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off() time.sleep(secs / 4) if distance < threshold: robot.drive_system.stop() robot.arm_and_claw.raise_arm() break increment = float(initial) / float(rate_of_increase) sub = 100 / increment pos = 100 - distance x = pos / sub secs = initial - (float(rate_of_increase) * x) if secs < 0: secs = 0
def m3_rps(chosen_play): print('Running rps') robot = rosebot.RoseBot() x = random.randrange(1, 4) print(x) if x == 1: # Rock robot.arm_and_claw.raise_arm() robot.sound_system.speech_maker.speak('I chose Rock') if chosen_play is 'Paper': robot.sound_system.speech_maker.speak('You win') else: robot.sound_system.speech_maker.speak('You lose') elif x == 2: # Paper robot.arm_and_claw.move_arm_to_position(0) robot.sound_system.speech_maker.speak('I chose Paper') if chosen_play is 'Scissors': robot.sound_system.speech_maker.speak('You win') else: robot.sound_system.speech_maker.speak('You lose') elif x == 3: # Scissors robot.arm_and_claw.move_arm_to_position(2500) robot.sound_system.speech_maker.speak('I chose Scissors') if chosen_play is 'Rock': robot.sound_system.speech_maker.speak('You win') else: robot.sound_system.speech_maker.speak('You lose') robot.arm_and_claw.move_arm_to_position(0)
def test_arm_and_claw(): """ Test a robot's ARM AND CLAW. """ print() print('--------------------------------------------------') print('Testing the ARM AND CLAW of a robot') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # STUDENTS: Do the work in this module as follows. # Otherwise, you will be overwhelmed by the number of tests happening. # # For each function that you implement: # 1. Locate the statements just below this comment that call TEST functions. # 2. UN-comment only one test at a time. # 3. Implement that function per its _TODO_. # 4. Implement as needed the appropriate class methods # 5. When satisfied with your work, move onto the next test, # RE-commenting out the previous test to reduce the testing. # ------------------------------------------------------------------------- # run_test_touch_sensor(robot) # run_test_calibrate(robot) # run_test_raise_and_lower(robot) run_test_move_arm_to_position(robot)
def run_test_arm(): robot = rosebot.RoseBot() robot.arm_and_claw.raise_arm() robot.arm_and_claw.lower_arm() robot.arm_and_claw.move_arm_to_position(10 * 360) robot.arm_and_claw.lower_arm() robot.arm_and_claw.calibrate_arm()
def celebration(): robot = rosebot.RoseBot() robot.arm_and_claw.calibrate_arm() robot.sound_system.speech_maker.speak('Cleaned Up for Macy') robot.arm_and_claw.move_arm_to_position(2000) robot.led_system.left_led.turn_on() robot.led_system.right_led.turn_on() time.sleep(.1) robot.arm_and_claw.move_arm_to_position(1000) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off() time.sleep(.1) robot.arm_and_claw.move_arm_to_position(2000) robot.led_system.left_led.turn_on() robot.led_system.right_led.turn_on() time.sleep(.1) robot.arm_and_claw.move_arm_to_position(1000) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off() time.sleep(.1) robot.arm_and_claw.move_arm_to_position(2000) robot.led_system.left_led.turn_on() robot.led_system.right_led.turn_on() time.sleep(.1) robot.arm_and_claw.move_arm_to_position(0) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off()
def main(): """ Test a robot's color sensor and line following. """ print() print('--------------------------------------------------') print('Testing the Color sensor (in two modes) of a robot') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # STUDENTS: Do the work in this module as follows. # Otherwise, you will be overwhelmed by the number of tests happening. # # For each function that you implement: # 1. Locate the statements just below this comment that call TEST functions. # 2. UN-comment only one test at a time. # 3. Implement that function per its _TODO_. # 4. Implement as needed the appropriate class methods # 5. When satisfied with your work, move onto the next test, # RE-commenting out the previous test to reduce the testing. # ------------------------------------------------------------------------- # Color Sensor tests # run_test_display_color_names(robot) # run_test_drive_until_color(robot) # run_test_display_reflected_light_readings(robot) # run_test_calibrate_line_follower(robot) run_test_line_follower(robot)
def test_go_straight_for_inches_using_time(): robot = rosebot.RoseBot() robot.drive_system.go_straight_for_inches_using_time(10, 100) robot.drive_system.go_straight_for_inches_using_time(10, -100) robot.drive_system.go_straight_for_inches_using_time(5, 25) robot.drive_system.go_straight_for_inches_using_time(0, 75) robot.drive_system.go_straight_for_inches_using_time(3, 60)
def fight(robot): robot = rosebot.RoseBot() button = robot.sensor_system.touch_sensor speech = robot.sound_system.speech_maker counter = 0 counter_1 = 0 counter_2 = 0 counter_3 = 0 while True: if button.is_pressed() == True: counter = counter + 1 if counter == 1: counter_1 = counter_1 + 1 if counter_1 == 1: speech.speak("Hey! Watch what you're doing, twerp!") if counter == 2: counter_2 = counter_2 + 1 if counter_2 == 1: speech.speak("You'll be gettin a knuckle sandwich, punk!") if counter == 3: counter_3 = counter_3 + 1 if counter_3 == 1: speech.speak("Alright bub, you asked for it!") break robot.drive_system.go(50, -50) time.sleep(2.8) robot.drive_system.go_forward_until_distance_is_less_than(2, 50) speech.speak("Take this, you cur!") robot.arm_and_claw.raise_arm() time.sleep(1) speech.speak("Get ready for the Grand Hand Slam!") time.sleep(3) robot.arm_and_claw.lower_arm() speech.speak("Serves you right, you jerk!")
def song(self): robot = rosebot.RoseBot() NOTE_A4 = 440 NOTE_B4 = 494 NOTE_CS5 = 554 NOTE_E5 = 659 NOTE_FS5 = 740 NOTE_GS5 = 831 quarter_note = 500 eighth_note = 250 notes = [ NOTE_A4, NOTE_B4, NOTE_CS5, NOTE_E5, NOTE_FS5, NOTE_GS5, NOTE_FS5, NOTE_E5, NOTE_CS5, NOTE_B4 ] robot.sound_system.tone_maker.play_tone(notes[0], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[1], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[2], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[3], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[4], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[5], eighth_note).wait() robot.sound_system.tone_maker.play_tone(notes[6], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[7], quarter_note).wait() robot.sound_system.tone_maker.play_tone(notes[8], 1500).wait() robot.sound_system.tone_maker.play_tone(notes[9], 1500).wait()
def run_test_arm(): robot = rosebot.RoseBot() robot.arm_and_claw.raise_arm() print("Raise arm successful!") time.sleep(2) robot.arm_and_claw.lower_arm() print("Lower arm successful!")
def main(): """ Test a robot's IR sensor (proximity and beacon seeking). """ print() print('--------------------------------------------------') print('Testing the Infrared sensor (in two modes) of a robot') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # STUDENTS: Do the work in this module as follows. # Otherwise, you will be overwhelmed by the number of tests happening. # # For each function that you implement: # 1. Locate the statements just below this comment that call TEST functions. # 2. UN-comment only one test at a time. # 3. Implement that function per its _TODO_. # 4. Implement as needed the appropriate class methods # 5. When satisfied with your work, move onto the next test, # RE-commenting out the previous test to reduce the testing. # ------------------------------------------------------------------------- # run_test_sounds(robot) # run_test_proximity_readings(robot) # run_test_drive_until_distance(robot) # run_test_beacon_sensor(robot) # run_test_spin_until_beacon_seen(robot) # run_test_spin_to_track_beacon(robot) run_test_drive_towards_beacon(robot)
def led_blinker(initial, rate): robot = rosebot.RoseBot() robot.arm_and_claw.calibrate_arm() robot.drive_system.go(25, 25) while True: robot.led_system.left_led.turn_on() time.sleep(get_sleep(initial, rate)) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_on() time.sleep(get_sleep(initial, rate)) robot.led_system.left_led.turn_on() time.sleep(get_sleep(initial, rate)) robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_off() time.sleep(get_sleep(initial, rate)) d = robot.sensor_system.ir_proximity_sensor.get_distance_in_inches() if d <= 3: robot.drive_system.stop() robot.arm_and_claw.raise_arm() robot.led_system.right_led.turn_off() robot.led_system.left_led.turn_off() break
def main(): """ This code, which must run on the ROBOT: 1. Constructs a robot, an MQTT SENDER, and a DELEGATE to respond to messages FROM the LAPTOP sent TO the ROBOT via MQTT. 2. Stays in an infinite loop while a listener (for MQTT messages) runs in the background, "delegating" work to the "delegate". """ robot = rosebot.RoseBot() delegate = DelegateForRobotCode(robot) mqtt_sender = mqtt.MqttClient(delegate) delegate.set_mqtt_sender(mqtt_sender) number = m0_set_robot_number.get_robot_number() if number is not None: mqtt_sender.connect_to_mqtt_to_talk_to_laptop(lego_robot_number=number) time.sleep(1) # To let the connection process complete print() print("Starting to listen for messages. The delegate responds to them.") print() # Stay in an infinite loop while the listener (for MQTT messages) # runs in the background: while True: time.sleep(0.01) if delegate.is_time_to_quit: break
def m3_grab_object_LED(start_time, increase): robot = rosebot.RoseBot() robot.arm_and_claw.calibrate_arm() robot.drive_system.go(20, 20) led = 1 wait_time = int(start_time) while robot.sensor_system.ir_proximity_sensor.get_distance_in_inches( ) > 0.25: if led == 1: robot.led_system.left_led.turn_on() time.sleep(wait_time) if led == 2: robot.led_system.left_led.turn_off() robot.led_system.right_led.turn_on() time.sleep(wait_time) if led == 3: robot.led_system.left_led.turn_on() time.sleep(wait_time) if led == 4: robot.led_system.right_led.turn_off() robot.led_system.left_led.turn_off() time.sleep(wait_time) if led == 4: led = 0 led = led + 1 wait_time = wait_time - ( float(increase) / (robot.sensor_system.ir_proximity_sensor.get_distance_in_inches() + 5)) if wait_time <= 0: wait_time = 0 robot.drive_system.stop() robot.arm_and_claw.raise_arm()
def check(cup_2_entry): robot = rosebot.RoseBot() if cup_2_entry == 'x': robot.sound_system.tone_maker.play_tone(440, 2).wait() robot.sound_system.tone_maker.play_tone(880, 2).wait() robot.sound_system.beeper.beep().wait() print('YOU DID IT!')
def real_thing(): # Connects computer to ev3 via delegate robot = rosebot.RoseBot() delegate = m2_shared_gui_delegate_on_robot.Delegate(robot) mqtt_receiver = com.MqttClient(delegate) mqtt_receiver.connect_to_pc() # Connects ev3 to computer via delegate mqtt_client = mqtt_receiver while True: # If get_distance_in_inches method has been called, distance_counter = 1. # If distance_counter = 1, robot tells computer to execute 'handle_change_anxiety' # method via MQTT / delegate running on PC if robot.sensor_system.ir_proximity_sensor.distance_counter == 1: dis = robot.sensor_system.ir_proximity_sensor.get_distance_in_inches() mqtt_client.send_message('handle_change_anxiety', [dis]) time.sleep(2) robot.sensor_system.ir_proximity_sensor.distance_counter = 0 # If is_pressed method has been called, touch_counter = 1. # If touch_counter = 1, robot tells computer to execute 'handle_change_hostility' # method via MQTT / delegate running on PC if robot.sensor_system.touch_sensor.touch_counter == 1: mqtt_client.send_message('handle_change_hostility') time.sleep(2) robot.sensor_system.touch_sensor.touch_counter = 0 if not delegate.enabled: time.sleep(0.01)
def camera_test(): robot = rosebot.RoseBot() while True: b = robot.sensor_system.camera.get_biggest_blob() print(b) time.sleep(5)
def anything(): robot = rosebot.RoseBot() pixy = robot.sensor_system.camera print('1') blob = pixy.get_biggest_blob() Area = blob.width * blob.height print(Area)
def whale(n, k): robot = rosebot.RoseBot() sensor = robot.sensor_system.ir_proximity_sensor robot.drive_system.go(30, 30) left = robot.led_left right = robot.led_right n = float(n) k = float(k) while True: ir = sensor.get_distance() left.turn_on() left.turn_off() time.sleep(k * ir / n) right.turn_on() right.turn_off() time.sleep(k * ir / n) left.turn_on() right.turn_on() left.turn_off() right.turn_off() time.sleep(k * ir / n) if ir <= 3: left.set_color_by_name((0, 1)) right.set_color_by_name((0, 1)) break robot.drive_system.stop()
def main(): """ Test a robot's using MQTT. """ print() print('--------------------------------------------------') print(' Listening for MQTT messages from the PC') print('--------------------------------------------------') # ------------------------------------------------------------------------- # TODO: 2. Construct a robot, that is, a rosebot.RoseBot() object. # ------------------------------------------------------------------------- robot = rosebot.RoseBot() # ------------------------------------------------------------------------- # TODO: 3. Construct an MQTT client passing in the robot as the argument. # ------------------------------------------------------------------------- mqtt_client = com.MqttClient(robot) # ------------------------------------------------------------------------- # TODO: 4. Connect to talk to the laptop # ------------------------------------------------------------------------- # mqtt_client.connect_to_mqtt_to_talk_to_laptop() mqtt_client.connect_to_mqtt_to_talk_to_laptop("broker.hivemq.com") # Off campus use this broker # ------------------------------------------------------------------------- # TODO: 5. Create a loop which can be shutdown # Add a field on the robot called should_shutdown # That is set to False # And add a method that can modify that field called shutdown # ------------------------------------------------------------------------- while True: time.sleep(0.1) if robot.should_shutdown: break
def drive_bowser(): # calls the functions that will move the robot through the bowser track robot = rosebot.RoseBot() speed = 50 starting_beeps(robot) bowser_course(robot, speed) robot.arm_and_claw.lower_arm()
def test_increasing_beeps_a1s_approach(initial_beep_rate, rate_of_beep_increase): robot = rosebot.RoseBot() initial_distance = robot.sensor_system.ir_proximity_sensor.get_distance_in_inches( ) robot.arm_and_claw.calibrate_arm() robot.drive_system.go(50, 50) initial_beep_rate = int(initial_beep_rate) rate_of_beep_increase = int(rate_of_beep_increase) print('this edit has worked') while True: percent_distance = (robot.sensor_system.ir_proximity_sensor. get_distance_in_inches()) / (initial_distance) pause_time = 3 * (percent_distance) / ((initial_beep_rate) + ((rate_of_beep_increase) * (1 - percent_distance))) robot.sound_system.beeper.beep().wait() # print(robot.sensor_system.ir_proximity_sensor.get_distance_in_inches()) print(pause_time) time.sleep(abs(pause_time)) if robot.sensor_system.ir_proximity_sensor.get_distance_in_inches( ) <= 2: robot.drive_system.stop() break robot.arm_and_claw.raise_arm() robot.arm_and_claw.calibrate_arm() # this is to reset it for testing
def test_go_distance(): """ Tests the go_distance function. """ print() print('------------------------------------------------------') print('Testing the go_distance function:') print(' See the robot.') print('------------------------------------------------------') # ------------------------------------------------------------------ # DONE: 4. Implement this TEST function. # It TESTS the go_distance function defined below. # Include at least 2 reasonable tests, with a "sleep" in between # the tests so that you can see what happened on each test. # ------------------------------------------------------------------ robot = rb.RoseBot() robot.connect_wifly(16) # Use the number on YOUR robot connection = robot.connection # Put your FIRST test here: go_distance(robot, 1000, 150) connection.sleep(.5) # Put a SECOND test here: go_distance(robot, 1000, 200) connection.shutdown()