def main(): print("--------------------------------------------") print(" Touch sensor arm movements") print("--------------------------------------------") ev3.Sound.speak("Touch sensor arm movements").wait() arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) assert arm_motor.connected touch_sensor = ev3.TouchSensor() assert touch_sensor while True: command_to_run = input( "Enter c (for calibrate), u (for up), d (for down), or q (for quit): " ) if command_to_run == 'c': print("Calibrate the arm") print( "TODO: 3 is to delete this print statement, uncomment the line below, and implement that function." ) # arm_calibration(arm_motor, touch_sensor) elif command_to_run == 'u': print("Move the arm to the up position") print( "TODO: 4 is to delete this print statement, uncomment the line below, and implement that function." ) # arm_up(arm_motor, touch_sensor) elif command_to_run == 'd': print("Move the arm to the down position") print( "TODO: 5 is to delete this print statement, uncomment the line below, and implement that function." ) # arm_down(arm_motor) elif command_to_run == 'q': break else: print(command_to_run, "is not a known command. Please enter a valid choice.") print("Goodbye!") ev3.Sound.speak("Goodbye").wait()
def arm_calibration(self): arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) assert arm_motor.connected touch_sensor = ev3.TouchSensor() assert touch_sensor arm_motor.run_forever(speed_sp=900) while not touch_sensor.is_pressed: time.sleep(0.01) arm_motor.stop_action = ev3.Motor.STOP_ACTION_BRAKE ev3.Sound.beep() arm_revolutions_for_full_range = 14.2 * 360 arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=900) arm_motor.wait_while(ev3.Motor.STATE_RUNNING) ev3.Sound.beep() arm_motor.position = 0
def __init__(self, port, quite): self.host = socket.gethostbyname(socket.getfqdn()) self.port = port self.quite = quite self.__socket = None self.__started = False self.__peer_sock = None self.__peer_addr = None self.__leftMotor = ev3.LargeMotor('outD') self.__rightMotor = ev3.LargeMotor('outA') self.__smallMotor = ev3.MediumMotor('outC') self.__ir = ev3.InfraredSensor() self.__power = ev3.PowerSupply() self.__last_ping = 0 self.__last_ir = 0 self.__last_pwr = 0 self.__gear = 1
def __init__(self, port, motor_type='large'): """ Constructs a Motor based on the input parameters. Valid ports: 'A', 'B', 'C', or 'D' Our "large" motors are in ports "B" and "C" Our "medium" motor is in port "A" Valid motor_types: "medium" or "large" --- :param port: Letter on EV3 brick where motor connects :type port: str :param motor_type: Motor types are either "medium" or "large" :type motor_type: str """ if motor_type == 'large': self._motor = ev3.LargeMotor('out' + port) else: self._motor = ev3.MediumMotor('out' + port) # Check that the motor is actually connected (crash now if not connected) assert self._motor.connected
def __init__(self): self.robot = robo.Snatch3r() self.mqtt_client = None self.running = True self.touch_sensor = ev3.TouchSensor() self.seeker = ev3.BeaconSeeker(channel=1) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.code=[] assert self.color_sensor assert self.ir_sensor assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected
def __init__(self): self.main_cell = 'comp' try: try: self.ser = serial.Serial('/dev/ttyACM0', 9600, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE) except: self.ser = serial.Serial('/dev/ttyACM1', 9600, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE) self.cell_offset = 96 self.main_cell = 'arduino' except: self.motor = ev3.MediumMotor('outA') if not self.motor.connected: self.motor = ev3.LargeMotor('outA') if self.motor.connected: self.button = ev3.TouchSensor('in1') self.main_cell = 'ev3'
def __init__(self): """Creates and stores left and right motor""" self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.MAX_SPEED = 900 self.pixy = ev3.Sensor(driver_name="pixy-lego") self.mqtt_client = com.MqttClient() self.mqtt_client.connect_to_pc() self.run = True assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.touch_sensor assert self.color_sensor assert self.ir_sensor assert self.pixy
def get_motor(io_type, port, settings): try: if io_type == 'large motor': i = ev3.LargeMotor(port) elif io_type == 'medium motor': i = ev3.MediumMotor(port) if settings[ 'motor_mode'] == 'position': # position is the motors current distance from its starting point (when plugged in) if settings['units'] == 'rotations': return i.position / i.count_per_rot elif settings['units'] == 'degrees': return i.position # duty cycle is the tachomotor motor's percentage of power; can be varied to generate constant speed; value range = -100 to 100 elif settings['motor_mode'] == 'duty_cycle': return i.duty_cycle elif settings['motor_mode'] == 'speed': # value range = -1000 to 1000 return i.speed except ValueError: return "Not found"
def main(): claw = ev3.MediumMotor('outA') arm = ev3.LargeMotor('outB') swing = ev3.LargeMotor('outC') open(claw) time.sleep(1) arm.run_timed(time_sp=500, speed_sp=300) time.sleep(1) close(claw) time.sleep(1) arm.run_timed(time_sp=500, speed_sp=-400) time.sleep(1) swing.run_timed(time_sp=500, speed_sp=1000) time.sleep(1) arm.run_timed(time_sp=500, speed_sp=300) time.sleep(1) claw.run_timed(time_sp=500, speed_sp=-250) time.sleep(1) arm.run_timed(time_sp=500, speed_sp=-400)
def __init__(self): # Connect two large motors on output ports B and C self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.running = 0 self.ir_sensor = ev3.InfraredSensor() self.color_sensor = ev3.ColorSensor() self.pixy = ev3.Sensor(driver_name="pixy-lego") self.beacon_seeker = ev3.BeaconSeeker(channel=1) # Check that the motors are actually connected assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.touch_sensor assert self.ir_sensor assert self.color_sensor assert self.pixy
def Straight_PD_forever(self): #Initialise motors motor2 = ev3.MediumMotor('outD') motor0 = ev3.LargeMotor('outB') assert motor0.connected motor1 = ev3.LargeMotor('outC') assert motor1.connected # Connect EV3 color sensor. cl = ev3.ColorSensor() # Put the color sensor into COL-REFLECT mode # to measure reflected light intensity. cl.mode = 'COL-REFLECT' #t_end = time.time() + 7 Kp = 120 # scaled by 10 to cater for small value integer arithmetic Ki = 5 Kd = 100 # scaled by 10 to cater for small value integer arithmetic offset = 85 # Initialize the variables Tp = 25 integral = 0 lastError = 0 derivative = 0 while True: LightValue = cl.value() # current light reading? error = LightValue - offset # subtract the offset integral = integral + error # calculate the integral derivative = error - lastError # calculate the derivative Turn = Kp * error + Ki * integral + Kd * derivative #the "P term" the "I term" and the "D term" Turn = Turn / 100 # undo the affect of the factor of 100 in Kp, Ki and Kd! powerA = Tp + Turn # power level for A motor powerC = Tp - Turn # power level for C motor motor0.run_forever(speed_sp=powerA, duty_cycle_sp=25) motor1.run_forever(speed_sp=powerC, duty_cycle_sp=25) lastError = error # save error for next time around loop if error >= 15: # Stops ramp condition and servos the right wheel backwards to correct error on tight curves. error = 15 motor0.run_timed(speed_sp=-25, duty_cycle_sp=25)
def arm_calibration(self): touch_sensor = ev3.TouchSensor() MAX_SPEED = 900 arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) assert arm_motor.connected assert touch_sensor arm_motor.run_forever(speed_sp=MAX_SPEED) while not touch_sensor.is_pressed: time.sleep(0.01) arm_motor.stop() print('arm is up') ev3.Sound.beep().wait() arm_revolutions_for_full_range = 14.2 * 360 arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=MAX_SPEED) arm_motor.wait_while(ev3.Motor.STATE_RUNNING) ev3.Sound.beep().wait() arm_motor.position = 0 print('arm calibrated')
def __init__(self): # Connect the required equipement self.lm = ev3.LargeMotor('outB') self.rm = ev3.LargeMotor('outC') self.mm = ev3.MediumMotor() self.ir = ev3.InfraredSensor() self.ts = ev3.TouchSensor() self.cs = ev3.ColorSensor() self.screen = ev3.Screen() # Reset the motors for m in (self.lm, self.rm, self.mm): m.reset() m.position = 0 m.stop_action = 'brake' self.draw_face() quote('initiating')
def __init__(self): # The code below connects all of the robots sensors and motors to # specific variables self.mqtt_client = None self.running = True self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.pixy = ev3.Sensor(driver_name="pixy-lego") # Then is assures that all sensors and motors are connected properly assert self.color_sensor assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.ir_sensor.connected assert self.pixy
def __init__(self): self.mqtt_client = None self.running = True self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() # self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() # self.pixy = ev3.Sensor(driver_name="pixy-lego") # assert self.color_sensor assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.ir_sensor.connected # assert self.pixy self.led_colors = [ev3.Leds.BLACK, ev3.Leds.GREEN, ev3.Leds.RED] self.current_color_index = 0
def __init__(self): self.running = True self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_D) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.ir_sensor = ev3.InfraredSensor() self.beacon_seeker = ev3.BeaconSeeker(channel=4) self.color_sensor = ev3.ColorSensor() self.pixy = ev3.Sensor(driver_name='pixy-lego') self.mqtt_client = com.MqttClient(self) self.mqtt_client.connect_to_pc() assert self.ir_sensor.connected assert self.color_sensor.connected assert self.pixy.connected assert self.touch_sensor assert self.arm_motor.connected assert self.left_motor.connected assert self.right_motor.connected self.MAX_SPEED = 900
def __init__(self): """Constructs and connects two large motors on output ports B and C.""" self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.pixy = ev3.Sensor(driver_name="pixy-lego") self.color_key = None self.MAX_SPEED = 900 self.running = True """Check that the motors are actually connected.""" assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.touch_sensor assert self.color_sensor assert self.ir_sensor assert self.pixy
def __init__(self): self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.touch_sensor = ev3.TouchSensor() self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.beacon_seeker = ev3.BeaconSeeker(channel=1) self.pixy = ev3.Sensor(driver_name="pixy-lego") assert self.ir_sensor assert self.arm_motor assert self.touch_sensor assert self.left_motor assert self.right_motor assert self.color_sensor assert self.beacon_seeker assert self.pixy self.pixy.mode = "SIG1"
def __init__(self): self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) assert self.arm_motor.connected self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) assert self.left_motor.connected self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) assert self.right_motor.connected self.touch_sensor = ev3.TouchSensor() assert self.touch_sensor self.MAX_SPEED = 900 self.SLOW_SPEED = 100 self.running = True self.color_sensor = ev3.ColorSensor() assert self.color_sensor self.ir_sensor = ev3.InfraredSensor() assert self.ir_sensor self.pixy = ev3.Sensor(driver_name="pixy-lego") assert self.pixy self.active = False self.sides = 0 self.degrees_turned = 0
def run(self): # sensors cs = ev3.ColorSensor(); assert cs.connected # measures light intensity us = ev3.UltrasonicSensor(); assert us.connected # measures distance cs.mode = 'COL-REFLECT' # measure light intensity us.mode = 'US-DIST-CM' # measure distance in cm # motors lm = ev3.LargeMotor('outB'); assert lm.connected # left motor rm = ev3.LargeMotor('outC'); assert rm.connected # right motor mm = ev3.MediumMotor('outD'); assert mm.connected # medium motor speed = 360/4 # deg/sec, [-1000, 1000] dt = 500 # milliseconds stop_action = "coast" # PID tuning Kp = 1 # proportional gain Ki = 0 # integral gain Kd = 0 # derivative gain integral = 0 previous_error = 0 # initial measurment target_value = cs.value()
def __init__(self): self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) assert self.left_motor assert self.right_motor self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() assert self.arm_motor assert self.touch_sensor self.running = None self.color_sensor = ev3.ColorSensor() assert self.color_sensor self.ir_sensor = ev3.InfraredSensor() assert self.ir_sensor self.pixy = ev3.Sensor(driver_name="pixy-lego") assert self.pixy
def USscanForward_timed2(self): #This function scans for objects and implements avoidance measures #if necessary motor2 = ev3.MediumMotor('outD') motor2.connected #motor2.run_timed(time_sp=2000, speed_sp=-90) us = ev3.UltrasonicSensor() #t_end = time.time() + 5 #while time.time() < t_end: print us.value() if us.value() < 100: ev3.Sound.speak('object still in range').wait() OD = OC.OdometryControl() #OD.turn_left_ObjectAvoid() #OD.objectAvoidForward() OD.turn_right_ObjectAvoid() OD.objectAvoidForward() OD.turn_right_ObjectAvoid() OD.objectAvoidForward2()
def __init__(self): """ Creates and stores the instance variables for the Snatch3r class. Asserts the motors and sensors, so that the program will crash if they are not connected. """ self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.MAX_SPEED = 900 self.pixy = ev3.Sensor(driver_name="pixy-lego") assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.touch_sensor assert self.color_sensor assert self.ir_sensor assert self.pixy
def __init__(self, robot=None, bttn=None, leftM='outD', rightM='outA', armM='outC', medM='outB', cs='in3', us='in1', cs2='in4'): # self.name = name self.bttn = ev3.Button() self.leftM = ev3.LargeMotor(leftM) self.rightM = ev3.LargeMotor(rightM) self.armM = ev3.LargeMotor(armM) self.medM = ev3.MediumMotor(medM) self.cs = ev3.ColorSensor('in3') self.us = ev3.UltrasonicSensor('in1') self.cs2 = ev3.ColorSensor('in4') self.state = 'advance'
def setupSensorsMotors(self, configs): for item in configs: port = configs[item] if item == self.LEFT_MOTOR: self.lmot = ev3.LargeMotor(port) elif item == self.RIGHT_MOTOR: self.rmot = ev3.LargeMotor(port) elif item == self.SERVO_MOTOR: self.mmot = ev3.MediumMotor(port) elif item == self.LEFT_TOUCH: self.leftTouch = ev3.TouchSensor(port) elif item == self.RIGHT_TOUCH: self.rightTouch = ev3.TouchSensor(port) elif item == self.ULTRA_SENSOR: self.ultraSensor = ev3.UltrasonicSensor(port) elif item == self.COLOR_SENSOR: self.colorSensor = ev3.ColorSensor(port) elif item == self.GYRO_SENSOR: self.gyroSensor = ev3.GyroSensor(port) else: print("Unknown configuration item:", item)
def setup_hardware(self): # setup I/O connecting to EV3 self.motorR = ev3.LargeMotor('outA') self.motorL = ev3.LargeMotor('outD') self.csR = ev3.ColorSensor('in2') self.csM = ev3.ColorSensor('in3') self.csL = ev3.ColorSensor('in4') #TODO: implement using the DC motor if need #self.grabberArms = ev3.MediumMotor('outC') self.port = ev3.LegoPort('outB') assert self.port.connected self.port.mode = 'dc-motor' time.sleep(5) self.grabberArms = ev3.DcMotor("outB") print("DcMotor connected") self.grabberLift = ev3.MediumMotor('outC') self.gy = ev3.GyroSensor('in1') self.reset_gyro() self.base_pos = self.grabberLift.position
def test_medium_motor(self): def dummy(self): pass # Do not write motor.command on exit (so that fake tree stays intact) ev3.MediumMotor.__del__ = dummy m = ev3.MediumMotor() self.assertTrue(m.connected) self.assertEqual(m.device_index, 0) # Check that reading twice works: self.assertEqual(m.driver_name, 'lego-ev3-m-motor') self.assertEqual(m.driver_name, 'lego-ev3-m-motor') self.assertEqual(m.count_per_rot, 360) self.assertEqual(m.commands, [ 'run-forever', 'run-to-abs-pos', 'run-to-rel-pos', 'run-timed', 'run-direct', 'stop', 'reset' ]) self.assertEqual(m.duty_cycle, 0) self.assertEqual(m.duty_cycle_sp, 42) self.assertEqual(m.encoder_polarity, 'normal') self.assertEqual(m.polarity, 'normal') self.assertEqual(m.address, 'outA') self.assertEqual(m.position, 42) self.assertEqual(m.position_sp, 42) self.assertEqual(m.ramp_down_sp, 0) self.assertEqual(m.ramp_up_sp, 0) self.assertEqual(m.speed, 0) self.assertEqual(m.speed_regulation_enabled, 'off') self.assertEqual(m.speed_sp, 0) self.assertEqual(m.state, ['running']) self.assertEqual(m.stop_command, 'coast') self.assertEqual(m.time_sp, 1000) with self.assertRaises(Exception): c = m.command
def __init__(self, robotName, configDict=None): """Takes in a string, the name of the robot, and an optional dictionary giving motor and sensor ports for the robot.""" self.name = robotName self.leftMotor = ev3.LargeMotor('outC') self.rightMotor = ev3.LargeMotor('outB') self.servoMotor = ev3.MediumMotor('outD') self.servoMotor.reset() self.leftTouch = None self.rightTouch = None self.ultraSensor = ev3.UltrasonicSensor('in4') self.colorSensor = None self.gyroSensor = ev3.GyroSensor('in2') self.pixyCam = PixyCam() #input_1 self.button = ev3.Button() ev3.Sound.set_volume(100) if configDict is not None: self.setupSensorsMotors(configDict) if self.leftMotor is None: self.leftMotor = ev3.LargeMotor('outC') if self.rightMotor is None: self.rightMotor = ev3.LargeMotor('outB')
def __init__(self): """"The constructor function that stores the components of the robot as well as asserts them to make sure that they are connected""" self.left_motor = ev3.LargeMotor(ev3.OUTPUT_B) self.right_motor = ev3.LargeMotor(ev3.OUTPUT_C) self.arm_motor = ev3.MediumMotor(ev3.OUTPUT_A) self.touch_sensor = ev3.TouchSensor() self.color_sensor = ev3.ColorSensor() self.ir_sensor = ev3.InfraredSensor() self.pixy = ev3.Sensor(driver_name="pixy-lego") self.w = 1 assert self.left_motor.connected assert self.right_motor.connected assert self.arm_motor.connected assert self.touch_sensor.connected assert self.color_sensor.connected assert self.ir_sensor.connected assert self.pixy.connected self.MAX_SPEED = 900 self.running = True
def arm_calibration(arm_motor, touch_sensor): """ Runs the arm up until the touch sensor is hit then back to the bottom again, beeping at both locations. Once back at in the bottom position, gripper open, set the absolute encoder position to 0. You are calibrated! The Snatch3r arm needs to move 14.2 revolutions to travel from the touch sensor to the open position. Type hints: :type arm_motor: ev3.MediumMotor :type touch_sensor: ev3.TouchSensor """ # DONE: 3. Implement the arm calibration movement by fixing the code below # (it has many bugs). It should to this: # Command the arm_motor to run forever in the positive direction at max speed. # Create an infinite while loop that will block code execution until the touch sensor's is_pressed value is True. # Within that loop sleep for 0.01 to avoid running code too fast. # Once past the loop the touch sensor must be pressed. So stop the arm motor quickly using the brake stop action. # Make a beep sound # Now move the arm_motor 14.2 revolutions in the negative direction relative to the current location # Note the stop action and speed are already set correctly so we don't need to specify them again # Block code execution by waiting for the arm to finish running # Make a beep sound # Set the arm encoder position to 0 (the last line below is correct to do that, it's new so no bug there) # Code that attempts to do this task but has MANY bugs (nearly 1 on every line). Fix them! arm_motor.run_forever(speed_sp=MAX_SPEED) while True: time.sleep(0.01) if touch_sensor.is_pressed: break arm_motor.stop_action = ev3.MediumMotor(ev3.OUTPUT_A).STOP_ACTION_BRAKE ev3.Sound.beep().wait() arm_revolutions_for_full_range = 14.2 * 360 arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range) arm_motor.wait_while(ev3.Motor.STATE_RUNNING) ev3.Sound.beep().wait() arm_motor.position = 0 # Calibrate the down position as 0 (this line is correct as is).