def test_color(): cs = ColorSensor(INPUT_1) for mode in cs.modes: cs.mode = mode print('The current color mode is: {}'.format(cs.mode)) print('{} is the same as {} - (Red, Green, Blue)'.format( cs.raw, cs.rgb)) print('{}: {}'.format(cs.color, cs.color_name)) hue, luminance, saturation = cs.hls print('Hue: {}, Luminance: {}, Saturation: {}'.format( hue, luminance, saturation)) hue, saturation, value = cs.hsv print('Hue: {}, Saturation: {}, Value: {}'.format( hue, saturation, value)) print('Ambient light intensity: {}'.format(cs.ambient_light_intensity)) print('Reflected light intensity: {}'.format( cs.reflected_light_intensity)) while not button.any(): print('Color: {} which is {}'.format(cs.rgb, cs.color_name)) print('Ambient light intensity: {}'.format(cs.ambient_light_intensity)) print('Reflected light intensity: {}'.format( cs.reflected_light_intensity)) sleep(0.5)
def setup(): global tank_drive, colorSensorLeft, colorSensorRight, ultra, sound, touchSensor, gyroSensor tank_drive = MoveTank(OUTPUT_A, OUTPUT_B) tank_drive.gyro = GyroSensor('in4') 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() sound = Sound()
def main(): # remove the following line and replace with your code btn = Button() # we will use any button to stop script cl = ColorSensor() cl.mode = 'COL-AMBIENT' while not btn.any(): # exit loop when any button pressed print("Ambient light reading:") print(cl.value()) sleep(1) # wait for 0.1 seconds
def find_color(self, search=False, safe_from_wall=20): utils = IRUtils() cs = ColorSensor() cs.mode('COL_COLOR') driver = Driver() driver.set_speed(40) driver.move() while True: distance_from_wall = utils.get_distance_cm() print(distance_from_wall) if distance_from_wall < safe_from_wall: driver.turn_degrees(15) driver.move_seconds(0.5) driver.move() if cs.color == 6: break
def run_bot(): iru = IRUtils() while True: iru.get_distance_cm() return LineFollower.run() drive_obj = MoveTank(OUTPUT_B, OUTPUT_C) cs = ColorSensor() drop_dens() #remote() cs.mode = 'COL-COLOR' end = True while end: drive_obj.on_for_degrees(0, SpeedPercent(30), 90) if cs.color == 6: end = False
from ev3dev2.motor import OUTPUT_A, OUTPUT_C, OUTPUT_D, SpeedPercent, MoveTank, MediumMotor import random ################################################# # sensores # ################################################# #som sound = Sound() #mover tank = MoveTank(OUTPUT_A, OUTPUT_D) #garra garra = MediumMotor(OUTPUT_C) #sensor de cor sensorLuz = ColorSensor(INPUT_2) sensorLuz.mode = 'COL-COLOR' #sensor de toque sensorToque = TouchSensor(INPUT_1) #sensor utra som sensorSom = UltrasonicSensor(INPUT_3) #leds cerebro leds = Leds() #giro gs = GyroSensor(INPUT_4) ################################################ # variaveis # ################################################ #constantes peca_final = 2 #n de pecas total
# MOTOR METHODS speed = 20 wheelDiameter = 56 wheelBase = 115 rightMotor = LargeMotor(OUTPUT_D) leftMotor = LargeMotor(OUTPUT_A) moveTank = MoveTank(OUTPUT_A, OUTPUT_D) moveDiff = MoveDifferential(OUTPUT_A, OUTPUT_D, EV3EducationSetTire, 115) ultrasonicS = UltrasonicSensor() ultrasonicM = MediumMotor(OUTPUT_B) colorS = ColorSensor() ultrasonicS.mode = 'US-DIST-CM' colorS.mode = 'COL-COLOR' def calculateRotationsForDistance(distance, wheelDiameter): return distance/(math.pi*wheelDiameter) def moveForwardMotor(motor, wheelDiameter, distance): motor.on_for_rotations(speed, calculateRotationsForDistance(distance, wheelDiameter)) def moveForwardTank(distance): rightMotorThread = threading.Thread(target=moveForwardMotor, args=(rightMotor, wheelDiameter, distance)) leftMotorThread = threading.Thread(target=moveForwardMotor, args=(leftMotor, wheelDiameter, distance)) rightMotorThread.start() leftMotorThread.start() rightMotorThread.join() leftMotorThread.join()
from ev3dev2.sensor.lego import ColorSensor from ev3dev2.sensor.lego import UltrasonicSensor from ev3dev2.sensor.lego import TouchSensor from time import sleep # Creating instances of sensor classes tank_pair = MoveTank(OUTPUT_B, OUTPUT_C) btn = Button() s = Sound() cl = ColorSensor() us = UltrasonicSensor() touch = TouchSensor() # Setting default sensor modes cl.mode = 'COL-REFLECT' us.mode = 'US-DIST-CM' # Initialising global variables black_count = 0 grey_count = 0 counted = False # Setting threshold for what reflected light can be determined as black and white # Anything below b_thresh is black, anything higher than w_thresh is white b_thresh = 15 w_thresh = 49 # Increase the black_count and beeps def count_black():
#!/usr/bin/env micropython from ev3dev2.motor import LargeMotor from ev3dev2.sensor.lego import ColorSensor from ev3dev2.button import Button btn = Button() ma = LargeMotor('outA') mb = LargeMotor('outD') cl = ColorSensor() cl.mode='COL-AMBIENT' while True: if btn.any(): break ma.on(speed=10) mb.on(speed=10) print(cl.value()) ma.off() mb.off()
ultrasonic_sensor_front = UltrasonicSensor(INPUT_4) ultrasonic_sensor_side = UltrasonicSensor(INPUT_2) ultrasonic_sensor_front.mode = 'US-DIST-CM' ultrasonic_sensor_side.mode = 'US-DIST-CM' # define ultrasonic sensor. gyro = GyroSensor() gyro.mode = 'MODE_GYRO_ANG' # define gyro sensor; # set gyro sensor to detect angles. color_sensor = ColorSensor(INPUT_3) color_sensor.mode = 'COL-COLOR' # definr color sensor; # put color sensor in COL-COLOR mode. colors = ('red', 'white') # 0: No color 1: Black 2: Blue 3: Green # 4: Yellow 5: Red 6: White 7: Brown drivetrain = MoveSteering(OUTPUT_B, OUTPUT_C) # control drivetrain motors usinf Sterring Drive. medium_motor = MediumMotor(OUTPUT_A) # control the medium motor of victim intake mechanics. drivetrain.on(steering=0, speed=20)
from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, SpeedPercent, MoveTank from ev3dev2.sensor import INPUT_1 from ev3dev2.sensor.lego import UltrasonicSensor, ColorSensor, TouchSensor from ev3dev2.led import Leds from ev3dev2.sound import Sound # TODO: Add code here tank_drive = MoveTank(OUTPUT_A, OUTPUT_B) colorLeftSensor = ColorSensor('in1') colorRightSensor = ColorSensor('in2') touchSensor = TouchSensor('in3') colorRightSensor.mode = 'COL-COLOR' colorLeftSensor.mode = 'COL-COLOR' #ultra = UltrasonicSensor('in3') sound = Sound() #colors=('unknown','black','blue','green','yellow','red','white','brown') colorLeft = ColorSensor.COLORS[colorLeftSensor.color] colorRight = ColorSensor.COLORS[colorRightSensor.color] print(colorLeft) print(colorRight) sound.speak(colorRight) sound.speak(colorLeft)
from time import sleep from ev3dev2.sound import Sound ent_sc_esq = INPUT_1 ent_sc_dir = INPUT_2 #ent_us_lat = INPUT_3 #ent_us_fr = INPUT_4 cor_esq = ColorSensor(ent_sc_esq) cor_dir = ColorSensor(ent_sc_dir) #us_lat = UltrasonicSensor(ent_us_lat) #us_fr = UltrasonicSensor(ent_us_fr) a=0 sound = Sound() cor_esq.mode = 'RGB-RAW' cor_dir.mode = 'RGB-RAW' def qual_cor(sensor): cores = {'e':[27,199,114], 'd':[23,150,64]} re = cor_esq.red rd = cor_dir.red ge = cor_esq.green gd = cor_dir.green be = cor_esq.blue bd = cor_dir.blue ne = [re,ge,be] nd = [rd,gd,bd] i = 0 if sensor='d':
m1 = LargeMotor(OUTPUT_A) m2 = LargeMotor(OUTPUT_B) try: m4 = MediumMotor(OUTPUT_D) except ev3dev2.DeviceNotFound: pass g = GyroSensor(INPUT_1) g_off = 0 u = UltrasonicSensor(INPUT_3) c_exists = True try: c = ColorSensor(INPUT_2) c.mode = 'COL-COLOR' except ev3dev2.DeviceNotFound: c_exists = False l = Leds() l.set_color('LEFT', 'AMBER') s = Sound() s.set_volume(100) g_off = 0 f = open("data.txt", "w") CM_PER_ROT = 8.415 # 21.375 for cm right_start = True
from ev3dev2.sensor.lego import ColorSensor, InfraredSensor pino_ir = '4' pino_corE = '2' pino_corD = '3' fator_ir_distancia = 0.9 ir = InfraredSensor() ir.mode = 'IR-PROX' corE = ColorSensor(pino_corE) corD = ColorSensor(pino_corD) corE.mode = 'RGB-RAW' corD.mode = 'RGB-RAW' def viu_verde(r, g, b): lim_inf = 25 lim_sup = 80 prop = 1.5 if (r < lim_sup and g < lim_sup and g > lim_inf): if g > r * prop: return True return False def le_rgb(sensor): return corE.red, corE.green, corE.blue
def run(self, target_color): lm = self.lm rm = self.rm dt = 500 stop_action = "coast" speed = 400 cs = ColorSensor() cs.mode = 'COL-REFLECT' # PID tuning Kp = 1 # proportional gain Ki = 0.01 # integral gain Kd = 0.01 # derivative gain target_value = self.correct_value count = 0 integral = 0 previous_error = 0 factor_negative = (self.correct_value - self.too_dark) / 100 factor_positive = (self.too_light - self.correct_value) / 100 factor = (self.too_light - self.correct_value) / (self.correct_value - self.too_dark) # if value is 0 turned to left last turn = -1 turn_speed_value = 200 while not self.end: measured_value = cs.value() color = 6 while color == 6: error = measured_value - target_value integral += (error * dt) derivative = (error - previous_error) / dt if error < 0: u = (Kp * factor * factor_negative * error) + (Ki * integral) + (Kd * derivative) else: u = (Kp * factor_positive * error) + (Ki * integral) + (Kd * derivative) if speed + abs(u) > 1000: if u >= 0: u = 1000 - speed else: u = speed - 1000 if u < 0: lm.run_timed(time_sp=dt, speed_sp=speed - abs(u), stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=speed + abs(u), stop_action=stop_action) sleep(dt / 2000) else: lm.run_timed(time_sp=dt, speed_sp=speed + abs(u), stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=speed - abs(u), stop_action=stop_action) sleep(dt / 2000) color = cs.color previous_error = error found_white = False count = 22 while not found_white: left_number = 0 count *= 2.5 while not found_white: lm.run_timed(time_sp=dt, speed_sp=-1 * turn * turn_speed_value, stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=turn * turn_speed_value, stop_action=stop_action) print(cs.color) if cs.color == 6: lm.run_timed(time_sp=dt, speed_sp=-1 * turn * turn_speed_value, stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=turn * turn_speed_value, stop_action=stop_action) found_white = True turn *= -1 if left_number >= count: break left_number += 1 if count > 200: if cs.color == 4: lm.run_timed(time_sp=dt, speed_sp=turn_speed_value, stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=turn_speed_value, stop_action=stop_action) Driver().turn_degrees(180) lm.run_timed(time_sp=dt, speed_sp=turn_speed_value, stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=turn_speed_value, stop_action=stop_action) turn *= -1
from time import sleep button = Button() # up, down, left, right, enter, backspace # Connect EV3 color sensor color_sensor_2 = ColorSensor(INPUT_2) color_sensor_3 = ColorSensor(INPUT_3) color_sensor_4 = ColorSensor(INPUT_4) # Put the color sensor into COL-REFLECT mode # to measure reflected light intensity. # In this mode the sensor will return a value between 0 and 100 #cl.mode='COL-REFLECT' color_sensor_2.mode='COL-REFLECT' color_sensor_3.mode='COL-REFLECT' color_sensor_4.mode='COL-REFLECT' tank = MoveTank(OUTPUT_A, OUTPUT_B) tank.on(SpeedPercent(50), SpeedPercent(50)) sleep(1.5) tank.off() #while True: # # txt = "exit" # if button.check_buttons(buttons=['backspace']): # exit()
#!/usr/bin/env python3 from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4 from ev3dev2.sensor.lego import ColorSensor, UltrasonicSensor from ev3dev2.power import PowerSupply # initiate color sensors # the colour sensor needs to be between 1-2 cm away from the surface you are trying to measure. (color mode) # TODO confirm the mapping colorSensor_lt = ColorSensor(INPUT_4) colorSensor_rt = ColorSensor(INPUT_1) ultrasonicSensor = UltrasonicSensor(INPUT_2) # COL-REFLECT COL-AMBIENT COL-COLOR RGB-RAW colorSensor_mode_default = "COL-COLOR" colorSensor_lt.mode="COL-COLOR" colorSensor_rt.mode="COL-COLOR" ultrasonicSensor.mode="US-DIST-CM" powerSupply = PowerSupply() def getColorString(color_reading): if(color_reading==1): return "black" elif(color_reading==2): #return "blue" return "white" elif(color_reading==3): return "green" elif(color_reading==4): #return "yellow" return "white"
from ev3dev2.motor import LargeMotor from ev3dev2.motor import SpeedPercent from ev3dev2.sensor.lego import ColorSensor from ev3dev2.sound import Sound from threading import Thread from time import sleep from ev3dev.ev3 import * lm = LargeMotor('outA') lm2 = LargeMotor('outD') cs = ColorSensor("in1") cs2 = ColorSensor("in2") ir = InfraredSensor("in3") # to measure reflected light intensity. In this mode the sensor will return a value between 0 and 100 cs.mode = 'COL-COLOR' cs2.mode = 'COL-COLOR' # Put the infrared sensor into proximity mode. ir.mode = 'IR-PROX' q = {'0': 0} # For detecting what color he has found k = {'0': 0} # For detecting if we are close to some other object i = {'0': 0} # For detecting if we've already made a round for needed color def distan(ir, l): while (True): if (ir.value() > 25): k['0'] = 1 # okay else: k['0'] = 2 # need turn
#!/usr/bin/env python3 from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4 from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D from ev3dev2.sensor.lego import ColorSensor, UltrasonicSensor import sensorReading # initiate color sensors # the colour sensor needs to be between 1-2 cm away from the surface you are trying to measure. (color mode) colorSensor_lt = ColorSensor(INPUT_4) colorSensor_rt = ColorSensor(INPUT_1) colorSensor_lt.mode = sensorReading.colorSensor_mode_default colorSensor_rt.mode = sensorReading.colorSensor_mode_default ultrasonicSensor = UltrasonicSensor(INPUT_3) ultrasonicSensor.mode = "US-DIST-CM" # initiate all motors largeMotor_port_lt = OUTPUT_D largeMotor_port_rt = OUTPUT_A largeMotor_lt = LargeMotor(largeMotor_port_lt) largeMotor_rt = LargeMotor(largeMotor_port_rt) largeMotor_lt.speed
#!/usr/bin/env python3 from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, SpeedRPS, MoveSteering from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4 from ev3dev2.sensor.lego import TouchSensor, UltrasonicSensor, ColorSensor from time import sleep, time my_motor = LargeMotor(OUTPUT_A) my_motor.ramp_up_sp = 1000 # Takes 1000 ms to ramp up speed my_motor.ramp_down_sp = 1000 # Takes 1000 ms to ramp down speed ts = TouchSensor(INPUT_3) us = UltrasonicSensor(INPUT_2) cs = ColorSensor(INPUT_4) cs.mode = "RGB-RAW" #cs.mode = "COL-AMBIENT" t = time() while True: dist = us.distance_centimeters if time() - t > 1: print("dist:", dist) print("colr:", tuple(map(cs.value, [0, 1, 2]))) # print("colr:", cs.value()) t = time() if ts.is_pressed: speed = min(max(1, 100 - dist), 100) my_motor.on(speed) else: my_motor.stop() ''' rots = 10
def run(self): # sensors cs = ColorSensor() cs.mode = 'COL-REFLECT' # measure light intensity # motors lm = LargeMotor('outC') rm = LargeMotor('outB') speed = 360 / 2 # deg/sec, [-1000, 1000] dt = 500 # milliseconds stop_action = "coast" # PID tuning Kp = 1 # proportional gain Ki = 0.002 # integral gain Kd = 0.01 # derivative gain integral = 0 previous_error = 0 # initial measurment target_value = 35 # Start the main loop while not self.shut_down: # Calculate steering using PID algorithm error = target_value - cs.value() if previous_error > 0 and error < 0: integral = 0 integral += (error * dt) derivative = (error - previous_error) / dt # u zero: on target, drive forward # u positive: too bright, turn right # u negative: too dark, turn left u = (Kp * error) + (Ki * integral) + (Kd * derivative) # limit u to safe values: [-1000, 1000] deg/sec if speed + abs(u) > 1000: if u >= 0: u = 1000 - speed else: u = speed - 1000 # run motors if u >= 0: lm.run_timed(time_sp=dt, speed_sp=speed + abs(u), stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=0, stop_action=stop_action) sleep(dt / 2000) else: lm.run_timed(time_sp=dt, speed_sp=0, stop_action=stop_action) rm.run_timed(time_sp=dt, speed_sp=speed + abs(u), stop_action=stop_action) sleep(dt / 2000) previous_error = error
from ev3dev2.sensor.lego import ColorSensor from threading import Thread from time import sleep from ev3dev2.sound import Sound lm = LargeMotor('outA') lm2 = LargeMotor('outD') cs = ColorSensor("in1") cs2 = ColorSensor("in2") cs_black = {'0': False} cs2_black = {'0': False} i = {'0': 0} k = {'0': 0} # to measure reflected light intensity. In this mode the sensor will return a value between 0 and 100 cs.mode = 'COL-REFLECT' cs2.mode = 'COL-REFLECT' def notBlack(cs, cs2): while (True): if (cs.value() < 30): cs_black['0'] = True if (cs_black['0'] and cs2_black['0'] == False): i['0'] = 1 else: cs_black['0'] = False if (cs2.value() < 30): cs2_black['0'] = True if (cs2_black['0'] and cs_black['0'] == False):
def Drilling(self): cl = ColorSensor() cl.mode = 'COL-COLOR' return cl.color