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