def Launchrun():
Sound.speak("ready to go")
btn = Button()
#adjust the while statement for however long you want it to go.
while True:
# V if up button is pressed, wait 1 second. if button is still pressed run program 1 if else run program 2 (repeat for each button)
if btn.up:
sleep(1)
if btn.up:
Krab()
else:
Krab()
if btn.down:
sleep(1)
if btn.down:
Spider()
else:
Spider()
if btn.left:
sleep(1)
if btn.left:
Crane()
else:
Crane()
if btn.right:
sleep(1)
if btn.right:
Bulldozer()
else:
Bulldozer()
if btn.enter:
sleep(1)
if btn.enter:
Redcircle()
else:
Traffic()
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 run(self):
button = Button()
#ultra = UltrasonicSensor(self.in1)
infra = InfraredSensor(self.in2)
touch = TouchSensor(self.in3)
color = ColorSensor(self.in4)
self.mode = 1
self.max = 5
while not button.backspace:
#if self.mode == 1:
# print("U,Distance: %d" % ultra.distance_centimeters)
if self.mode == 2:
print("I,Proximity: %d" % infra.proximity)
if self.mode == 3:
print("T,Pressed: %s" % ("Yes" if touch.is_pressed else "No"))
if self.mode == 4:
print("C,Reflected light: %d" %
color.reflected_light_intensity)
if self.mode == 5:
print("C,Ambient light: %d" % color.ambient_light_intensity)
if button.right:
self.change_mode()
#!/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
import ev3dev2.fonts as fonts
# import python stand lib
import queue
import threading
import time
from time import sleep
import sys
console = Console(font='Lat15-TerminusBold20x10')
#Console.set_font(font='Lat15-TerminusBold24x12', reset_console=True)
#打印到LCD
print('start test:')
#按键
button = Button()
print('please press enter')
print(button.buttons_pressed, file=sys.stderr)
button.wait_for_pressed('enter', timeout_ms=10000)
print(button.buttons_pressed, file=sys.stderr)
def key_enter(new_state):
print(new_state)
print('press enter', file=sys.stderr)
#定义按键的响应函数
button.on_enter = key_enter
#!/usr/bin/python3
from multiprocessing import Process, Pipe
from multiprocessing.connection import Connection
from ev3dev2.button import Button
from ev3dev2.motor import OUTPUT_A, OUTPUT_B, SpeedPercent, MoveSteering
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, list_sensors
from ev3dev2.sensor.lego import ColorSensor
from ev3_toys.logger import get_logger
btn = Button()
left_cs, right_cs, center_cs = ColorSensor(INPUT_1), ColorSensor(
INPUT_2), ColorSensor(INPUT_3)
last_bl_cs = None
motors = MoveSteering(OUTPUT_B, OUTPUT_A)
logger_cs = get_logger('line.color_sensor')
logger_m = get_logger('line.motors')
SPEED_PERCENTAGE = -30
SPEED_TURN_PERCENTAGE = 5
def straight():
motors.on(0, SpeedPercent(SPEED_PERCENTAGE))
global last_bl_cs
last_bl_cs = center_cs
def turn_right():
if left_cs.reflected_light_intensity <= 15:
motors.on(-SPEED_PERCENTAGE, SpeedPercent(SPEED_PERCENTAGE))
def __init__(self):
self.server_mac = '88:B1:11:79:C5:F6'
self.port = 4
self.us = UltrasonicSensor()
self.btn = Button()
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))
#!/usr/bin/env python3
from ev3dev2.button import Button
from time import sleep
btn = Button()
# Do something when state of any button changes:
def left(state):
if state:
print('Left button pressed')
else:
print('Left button released')
def right(state): # neater use of 'if' follows:
print('Right button pressed' if state else 'Right button released')
def up(state):
print('Up button pressed' if state else 'Up button released')
def down(state):
print('Down button pressed' if state else 'Down button released')
def enter(state):
print('Enter button pressed' if state else 'Enter button released')
#!/usr/bin/env python3
import time
from ev3dev2.motor import LargeMotor, OUTPUT_B, OUTPUT_C, OUTPUT_D, SpeedPercent, MoveTank, MediumMotor
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4
from ev3dev2.sensor.lego import ColorSensor, GyroSensor
import ev3dev2.fonts as fonts
from ev3dev2.button import Button
from ev3dev2.sound import Sound
from ev3dev2.display import Display
btn = Button()
color = ColorSensor(INPUT_4)
tank_drive = MoveTank(OUTPUT_B, OUTPUT_C) #This is the template whenever we code
gyro = GyroSensor(INPUT_1)
Sound_ = Sound()
Display_ = Display()
Sound_.play_tone(frequency=400, duration=0.5, volume=50) #plays a note so we know when the code starts
#------------------------------------------------Distance conversion--------------------------------------------------------------------------------
# Distance Conversion
wheelDiameter_mm = 56 # Look at the first number on the NUMBERxNUMBER on wheel
wheelCircumference_cm = (wheelDiameter_mm/10) * 3.14159265358979323846284338 # Convert to cm and multiply by pi for circumference
wheelCircumference_in = (wheelDiameter_mm/25.4) * 3.14159265358979323846284338 # Convert to in and multiply by pi for circumference
# inches to rotations:
# example: drive.on_for_rotations(SpeedPercent(100), SpeedPrecent(100), inToRotations(5))
# to go 5 inches
def inToRotations(inches):
return inches/wheelCircumference_in
# centimeters to rotations:
# example: drive.on_for_rotations(SpeedPercent(100), SpeedPrecent(100), cmToRotations(5))
# to go 5 centimeters
def cmToRotations(cm):
return cm/wheelCircumference_cm
#!/usr/bin/env python3
# An EV3 Python (library v2) solution to Exercise 3
# of the official Lego Robot Educator lessons that
# are part of the EV3 education software
import ev3dev2
from ev3dev2.motor import MoveTank, OUTPUT_B, OUTPUT_C
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.button import Button
from time import sleep
from ev3dev2.motor import SpeedNativeUnits
leftSpeeds=[]
rightSpeeds=[]
btn = Button() # we will use any button to stop script
tank_pair = MoveTank(OUTPUT_B, OUTPUT_C)
leftMotor = ev3dev2.motor.Motor(OUTPUT_B)
rightMotor = ev3dev2.motor.Motor(OUTPUT_C)
# Connect an EV3 color sensor to any sensor port.
cl = ColorSensor()
while not btn.any():
leftSpeeds=[]
rightSpeeds=[]
for x in range(600):
# exit loop when any button pressed
# if we are over the black line (weak reflection)
rintensity=cl.reflected_light_intensity
lmotorpower=-((100/70)*(rintensity-70)+100)
rmotorpower=-(100-((100/70)*(rintensity-70)+100))
leftMotor.on(SpeedNativeUnits(lmotorpower))
rightMotor.on(SpeedNativeUnits(rmotorpower))
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.led import Leds
from ev3dev2.sensor.lego import GyroSensor
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.button import Button
from ev3dev2.display import Display
import ev3dev2.fonts as fonts
from ev3dev2.sound import Sound
import logging
import time
logging.basicConfig(level=logging.DEBUG)
gyro = GyroSensor(INPUT_4)
disp = Display()
b = Button()
s = Sound()
color_left = ColorSensor(INPUT_1)
color_right = ColorSensor(INPUT_3)
# 14, 18, ...
# See all: https://python-ev3dev.readthedocs.io/en/latest/display.html
f = fonts.load('luBS18')
def show(text):
#disp.text_grid(t, x=5, y=5)
disp.clear()
# 0 = left, 80 = far right?
# align="center" doesn't seem to work
#!/usr/bin/env python3
from ev3dev2.sensor.lego import UltrasonicSensor
from ev3dev2.sensor.lego import GyroSensor
from ev3dev2.motor import MoveTank, OUTPUT_A, OUTPUT_D
from ev3dev2.button import Button
import logging
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)5s: %(message)s')
log = logging.getLogger(__name__)
gs = GyroSensor()
us = UltrasonicSensor()
tp = MoveTank(OUTPUT_A, OUTPUT_D)
button = Button()
try:
while not button.any():
while not button.any():
tp.on(left_speed=50, right_speed=50)
dist = int(us.distance_centimeters_continuous)
log.info(dist)
if dist < 60:
break
tp.on_for_rotations(50, -50, 1.15)
except (KeyboardInterrupt):
print('interrupt')
tp.on(left_speed=0, right_speed=0)
def display_menu(self, start_page=0, before_run_function=None, after_run_function=None, skip_to_next_page=True):
"""
Console Menu that accepts choices and corresponding functions to call.
The user must press the same button twice: once to see their choice highlited,
a second time to confirm and run the function. The EV3 LEDs show each state change:
Green = Ready for button, Amber = Ready for second button, Red = Running
Parameters:
- `choices` a dictionary of tuples "button-name": ("function-name", function-to-call)
NOTE: Don't call functions with parentheses, unless preceded by lambda: to defer the call
- `before_run_function` when not None, call this function before each function run, passed with function-name
- `after_run_function` when not None, call this function after each function run, passed with function-name
"""
self.current_page = start_page
console = Console()
leds = Leds()
button = Button()
leds.all_off()
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
menu_positions = self.get_menu_positions(console)
last = None # the last choice--initialize to None
self.menu_tone()
self.debug("Starting Menu")
while True:
# display the menu of choices, but show the last choice in inverse
console.reset_console()
self.debug("Reset the display screen")
console.set_font('Lat15-TerminusBold24x12.psf.gz', True)
# store the currently selected menu page
menu_page = self.menu_pages[self.current_page]
# store the currently selected menu items
menu_options_on_page = menu_page.items()
for btn, (name, _) in menu_options_on_page:
align, col, row = menu_positions[btn]
console.text_at(name, col, row, inverse=(btn == last), alignment=align)
self.debug("Waiting for button press...")
pressed = self.wait_for_button_press(button)
self.debug("Registered button press: {}".format(pressed))
# get the choice for the button pressed
if pressed in menu_page:
if last == pressed: # was same button pressed?
console.reset_console()
leds.set_color("LEFT", "RED")
leds.set_color("RIGHT", "RED")
# call the user's subroutine to run the function, but catch any errors
try:
name, run_function = menu_page[pressed]
if before_run_function is not None:
self.debug('Running before function')
before_run_function(name)
self.press_tone()
type_of_run_function = type(run_function)
self.debug("Type of run_function: {}".format(type_of_run_function))
if isinstance(run_function, str):
self.debug("Running {}".format(run_function))
if run_function == 'next':
self.debug("About to call next")
self.next()
elif run_function =='back':
self.debug("About to call back")
self.back()
elif callable(run_function):
run_function()
except Exception as e:
print("**** Exception when running")
raise(e)
finally:
if after_run_function is not None:
after_run_function(name)
last = None
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
else: # different button pressed
last = pressed
leds.set_color("LEFT", "AMBER")
leds.set_color("RIGHT", "AMBER")
def checkAbort():
'''check if the up button is pressed, if it is, raise an exception and exit the program'''
if Button().up:
raise Exception("button up was pressed")
log.info('Stair climber starting......')
# define the touch sensor
ts = TouchSensor(INPUT_3)
# define the gyro sensor
gy = GyroSensor(INPUT_2)
# define the large motor on port B
lm_move = LargeMotor(OUTPUT_B)
# define the large motor on port D
lm_lifter = LargeMotor(OUTPUT_D)
# define the midium motor on port A
mm_move = MediumMotor(OUTPUT_A)
# define the button
btn = Button()
# define lcd display
lcd = Display()
# define sound
snd = Sound()
# define the steps to go, initial value is 0
steps = 1
# Declare function for one step
def oneStep():
global gy
global ts
def menu(choices, before_run_function=None, after_run_function=None):
"""
Console Menu that accepts choices and corresponding functions to call.
The user must press the same button twice: once to see their choice highlited,
a second time to confirm and run the function. The EV3 LEDs show each state change:
Green = Ready for button, Amber = Ready for second button, Red = Running
Parameters:
- `choices` a dictionary of tuples "button-name": ("mission-name", function-to-call)
Example:
choices = {
# "button-name": ("mission-name", function-to-call)
# or "button-name": ("mission-name", lambda: call(x, y, z))
"enter": ("CAL", lambda: auto_calibrate(robot, 1.0)),
"up": ("MI2", fmission2),
"right": ("MI3", fmission3),
"down": ("MI4", fmission4),
"left": ("MI5", fmission5)
}
where fmission2, fmission3 are functions;
note don't call them with parentheses, unless preceded by lambda: to defer the call
- `before_run_function` when not None, call this function before each mission run, passed with mission-name
- `after_run_function` when not None, call this function after each mission run, passed with mission-name
"""
console = Console()
leds = Leds()
button = Button()
leds.all_off()
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
menu_positions = get_positions(console)
last = None # the last choice--initialize to None
while True:
# display the menu of choices, but show the last choice in inverse
console.reset_console()
for btn, (name, _) in choices.items():
align, col, row = menu_positions[btn]
console.text_at(name, col, row, inverse=(btn == last), alignment=align)
pressed = wait_for_button_press(button)
# get the choice for the button pressed
if pressed in choices:
if last == pressed: # was same button pressed?
console.reset_console()
leds.set_color("LEFT", "RED")
leds.set_color("RIGHT", "RED")
# call the user's subroutine to run the mission, but catch any errors
try:
name, mission_function = choices[pressed]
if before_run_function is not None:
before_run_function(name)
mission_function()
except Exception as ex:
print("**** Exception when running")
print(ex)
finally:
if after_run_function is not None:
after_run_function(name)
last = None
leds.set_color("LEFT", "GREEN")
leds.set_color("RIGHT", "GREEN")
else: # different button pressed
last = pressed
leds.set_color("LEFT", "AMBER")
leds.set_color("RIGHT", "AMBER")
class Ev3Robot:
def __init__(self,
wheel1=OUTPUT_B,
wheel2=OUTPUT_C,
wheel3=OUTPUT_A,
wheel4=OUTPUT_D):
self.steer_pair = MoveSteering(wheel1, wheel2)
self.gyro = GyroSensor()
self.tank_pair = MoveTank(wheel1, wheel2)
self.motor1 = LargeMotor(wheel1)
self.motor2 = LargeMotor(wheel2)
self.motor3 = MediumMotor(wheel3)
self.motor4 = MediumMotor(wheel4)
self.color1 = ColorSensor(INPUT_1)
self.color4 = ColorSensor(INPUT_4)
self._black1 = 0
self._black4 = 0
self._white1 = 100
self._white4 = 100
self.gyro.mode = 'GYRO-ANG'
self.led = Leds()
self.btn = Button()
self.btn._state = set()
def write_color(self, file, value):
# opens a file
f = open(file, "w")
# writes a value to the file
f.write(str(value))
f.close()
def read_color(self, file):
# opens a file
f = open(file, "r")
# reads the value
color = int(f.readline().strip())
f.close()
return color
def pivot_right(self, degrees, speed=20):
# makes the robot pivot to the right until the gyro sensor
# senses that it has turned the required number of degrees
self.tank_pair.on(left_speed=speed, right_speed=0)
self.gyro.wait_until_angle_changed_by(degrees - 10)
self.tank_pair.off()
def pivot_left(self, degrees, speed=20):
# makes the robot pivot to the left until the gyro sensor
# senses that it has turned the required number of degrees
self.tank_pair.on(left_speed=0, right_speed=speed)
self.gyro.wait_until_angle_changed_by(degrees - 10)
self.tank_pair.off()
def old_spin_right(self, degrees, speed=20):
#old program; don't use
self.gyro.reset()
value1 = self.gyro.angle
self.tank_pair.on(left_speed=speed, right_speed=speed * -1)
self.gyro.wait_until_angle_changed_by(degrees)
value2 = self.gyro.angle
self.tank_pair.on(left_speed=-30, right_speed=30)
self.gyro.wait_until_angle_changed_by(value1 - value2 - degrees)
self.stop()
def old_spin_left(self, degrees, speed=20):
#old program; don't use
value1 = self.gyro.angle
self.tank_pair.on(left_speed=speed * -1, right_speed=speed)
self.gyro.wait_until_angle_changed_by(degrees)
value2 = self.gyro.angle
self.tank_pair.on(left_speed=8, right_speed=-8)
self.gyro.wait_until_angle_changed_by(value2 - value1 - degrees + 5)
self.tank_pair.off()
def dog_gear(self, degrees, motor, speed=30):
if motor == 3:
self.motor3.on_for_degrees(degrees=degrees, speed=speed)
self.motor3.off()
else:
self.motor4.on_for_degrees(degrees=degrees, speed=speed)
def go_straight_forward(self, cm, speed=20, wiggle_factor=1):
value1 = self.motor1.position
angle0 = self.gyro.angle
rotations = cm / 19.05 #divides by circumference of the wheel
# calculates the amount of degrees the robot has turned, then turns the
# opposite direction and repeats until the robot has gone the required
# number of centimeters
while abs(self.motor1.position - value1) / 360 < rotations:
angle = self.gyro.angle - angle0
self.steer_pair.on(steering=angle * wiggle_factor * -1,
speed=speed * -1)
self.steer_pair.off()
def go_straight_backward(self, cm, speed=20, wiggle_factor=1):
# see go_straight_forward
value1 = self.motor1.position
angle0 = self.gyro.angle
rotations = cm / 19.05
while abs(self.motor1.position - value1) / 360 < rotations:
angle = self.gyro.angle - angle0
self.steer_pair.on(steering=angle * wiggle_factor, speed=speed)
self.steer_pair.off()
def calibrate(self):
# turns the led lights orange, and waits for a button to be pressed
# (signal that the robot is on black), then calculates the reflected
# light intensity of the black line, then does the same on the white line
self.led.set_color('LEFT', 'ORANGE')
self.led.set_color('RIGHT', 'ORANGE')
while not self.btn.any():
sleep(0.01)
self.led.set_color('LEFT', 'GREEN')
self.led.set_color('RIGHT', 'GREEN')
self._black1 = self.color1.reflected_light_intensity
self._black4 = self.color4.reflected_light_intensity
sleep(2)
self.led.set_color('LEFT', 'ORANGE')
self.led.set_color('RIGHT', 'ORANGE')
while not self.btn.any():
sleep(0.01)
self.led.set_color('LEFT', 'GREEN')
self.led.set_color('RIGHT', 'GREEN')
self._white1 = self.color1.reflected_light_intensity
self._white4 = self.color4.reflected_light_intensity
sleep(3)
self.write_color("/tmp/black1", self._black1)
self.write_color("/tmp/black4", self._black4)
self.write_color("/tmp/white1", self._white1)
self.write_color("/tmp/white4", self._white4)
def read_calibration(self):
# reads the color files
self._black1 = self.read_color("/tmp/black1")
self._black4 = self.read_color("/tmp/black4")
self._white1 = self.read_color("/tmp/white1")
self._white4 = self.read_color("/tmp/white4")
def align_white(self, speed=20, t=96.8, direction=1):
# goes forward until one of the color sensors sees the white line.
while self.calibrate_RLI(self.color1) < t and self.calibrate_RLI(
self.color4) < t:
self.steer_pair.on(steering=0, speed=speed * direction)
self.steer_pair.off()
# determines which sensor sensed the white line, then moves the opposite
# motor until both sensors have sensed the white line
if self.calibrate_RLI(self.color4) > t:
while self.calibrate_RLI(self.color1) < t:
self.motor1.on(speed=speed * direction)
self.motor1.off()
else:
while self.calibrate_RLI(self.color4) < t:
self.motor2.on(speed=speed * direction)
self.motor2.off()
def align_black(self, speed=20, t=4.7, direction=1):
# see align_white
while self.calibrate_RLI(self.color1) > t and self.calibrate_RLI(
self.color4) > t:
self.steer_pair.on(steering=0, speed=speed * direction)
self.steer_pair.off()
if self.calibrate_RLI(self.color4) < t:
while self.calibrate_RLI(self.color1) > t:
self.motor1.on(speed=speed * direction)
self.motor1.off()
else:
while self.calibrate_RLI(self.color4) > t:
self.motor2.on(speed=speed * direction)
self.motor2.off()
def align(self, t, speed=-20, direction=1):
# aligns three times for extra accuracy
self.align_white(speed=speed, t=100 - t, direction=direction)
self.align_black(speed=-5, t=t, direction=direction)
self.align_white(speed=-5, t=100 - t, direction=direction)
def calibrate_RLI(self, color_sensor):
# returns a scaled value based on what black and white are
if (color_sensor.address == INPUT_1):
black = self._black1
white = self._white1
else:
black = self._black4
white = self._white4
return (color_sensor.reflected_light_intensity - black) / (white -
black) * 100
def stop(self):
self.tank_pair.off()
def spin_right(self, degrees, speed=30):
self.turn(degrees, 100, speed)
def spin_left(self, degrees, speed=30):
self.turn(degrees, -100, speed)
def turn(self, degrees, steering, speed=30):
# turns at a decreasing speed until it turns the required amount of degrees
value1 = self.gyro.angle
s1 = speed
d1 = 0
while d1 < degrees - 2:
value2 = self.gyro.angle
d1 = abs(value1 - value2)
slope = speed / degrees
s1 = (speed - slope * d1) * (degrees / 90) + 3
self.steer_pair.on(steering=steering, speed=s1)
self.steer_pair.off()
#!/usr/bin/env python3
from time import sleep
import os
from ev3dev2.button import Button
os.system('setfont Lat7-Terminus12x6')
btn = Button()
with open("status") as f:
status = f.read().strip()
descriptions = {
"off":
"SmartSafe will not automatically start and will have to be manually started from SSH or Brickman.",
"display":
"SmartSafe will start automatically with 20 secounds of bootup and will break Brickman. To exit while running use SSH or say \"alexa open lego mindstorms\" then \"control 0 auth [your password]\"",
"nodisplay":
"SmartSafe will start automatically and will run in the background without displaying to the screen."
}
print("The current operation mode is", status)
print("[OK]")
sleep(1)
btn.wait_for_pressed("enter")
print("To change operation mode run _off.sh, _display.sh, or _nodisplay.sh")
print("[OK]")
sleep(1)
btn.wait_for_pressed("enter")
print("In this mode", descriptions[status])
print("[OK]")
sleep(1)
def Traffic():
Sound.speak("").wait()
MA = MediumMotor("")
MB = LargeMotor("outB")
MC = LargeMotor("outC")
MD = MediumMotor("")
GY = GyroSensor("")
C3 = ColorSensor("")
C4 = ColorSensor("")
T1 = TouchSensor("")
GY.mode = 'GYRO-ANG'
GY.mode = 'GYRO-RATE'
GY.mode = 'GYRO-ANG'
tank_drive = MoveTank(OUTPUT_B, OUTPUT_C)
loop_gyro = 0
gyro_adjust = 1
starting_value = GY.value()
gyro_correct_loops = 0
straight_correct_loops = 0
gyro_correct_straight = 0
# change this to whatever speed what you want
left_wheel_speed = 100
right_wheel_speed = 100
tank_drive.on_for_rotations(SpeedPercent(100), SpeedPercent(100),
0.01) #wheel alignment
# change the loop_gyro verses the defined value argument to however far you want to go
# if Gyro value is the same as the starting value, go straight, if more turn right, if less turn left
# change the value to how far you want the robot to go
tank_drive.on_for_rotations(
SpeedPercent(-30), SpeedPercent(-30),
0.675) # Originally 0.95 - the robot starts out from base
while GY.value(
) < 85: #gyro turns 85 degrees and faces towards the swing
left_wheel_speed = 100
right_wheel_speed = -100
#MB is left wheel & MC is right wheel
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
while MB.position > -1600: # this is the gyro program, the first line tells the bot to continue loop until it reaches a defined position
if GY.value(
) == 90: #this runs if the gyro is OK and already straight, sets a lot of variables as well
left_wheel_speed = -300
right_wheel_speed = -300
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
gyro_adjust = 8
gyro_correct_loops = 0
gyro_correct_straight = 0
straight_correct_loops = 0
else: #if the gyro is off it runs this section of code
if GY.value() < 90:
correct_rate = abs(
GY.value()
) # This captures the gyro value at the beginning of the statement
right_wheel_speed = right_wheel_speed - gyro_adjust #changes the wheel speeds accordingly
left_wheel_speed = left_wheel_speed + gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
if abs(
GY.value()
) >= correct_rate: # If gyro value has worsened despite the correction then change the adjust variable for next time
gyro_adjust = gyro_adjust + 1
gyro_correct_loops = gyro_correct_loops + 1
if GY.value(
) == 0 and gyro_correct_straight == 0: #runs only if bot isn't already on the original line it started from
while straight_correct_loops < gyro_correct_loops: #Basically this messes up the gyro again so the bot can correct back to the line it was orignally on
right_wheel_speed = right_wheel_speed - gyro_adjust
left_wheel_speed = left_wheel_speed + gyro_adjust
straight_correct_loops = straight_correct_loops + 1
gyro_correct_straight = 1 #sets this to 1 so that it doesn't go off the line again
gyro_correct_loops = 0
straight_correct_loops = 0
else:
correct_rate = abs(GY.value(
)) # Same idea as the other if statement, just reversed
left_wheel_speed = left_wheel_speed - gyro_adjust
right_wheel_speed = right_wheel_speed + gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
gyro_correct_loops = gyro_correct_loops + 1
if abs(GY.value()) >= correct_rate:
gyro_adjust = gyro_adjust + 1
if GY.value() == 0 and gyro_correct_straight == 0:
while straight_correct_loops < gyro_correct_loops:
left_wheel_speed = left_wheel_speed - gyro_adjust
right_wheel_speed = right_wheel_speed + gyro_adjust
straight_correct_loops = straight_correct_loops + 1
gyro_correct_straight = 1
gyro_correct_loops = 0
straight_correct_loops = 0
# stop all motors
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
while GY.value(
) > 19: #this turns the bot towards the circle, need to be less than straight 90 degrees
left_wheel_speed = -100
right_wheel_speed = 100
#MB is left wheel & MC is right wheel
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
tank_drive.on_for_rotations(
SpeedPercent(-30), SpeedPercent(-30),
1.35) #goes forward (2.5) slightly to move the block into tan
tank_drive.on_for_rotations(SpeedPercent(30), SpeedPercent(30),
0.7) #drives back a bit (1)
while GY.value() < 150: #turns to face the bridge backwards
left_wheel_speed = 100 #originaly 200
right_wheel_speed = -100 #originaly 200
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
# Drives up bridge
tank_drive.on_for_rotations(SpeedPercent(50), SpeedPercent(50),
3.5) #Onto the bridge!!
#stop the wheels and make them brake
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
btn = Button()
while True:
if btn.enter:
Launchrun()
#!/usr/bin/env micropython
import time
from ev3dev2.motor import MoveTank, OUTPUT_A, OUTPUT_D
from ev3dev2.button import Button
btn = Button()
tank_pair = MoveTank(OUTPUT_A, OUTPUT_D)
while True:
if btn.any():
break
tank_pair.on(left_speed=10, right_speed=20)
time.sleep(0.05)
tank_pair.off()
class MindstormsGadget(AlexaGadget):
def __init__(self):
super().__init__(gadget_config_path='./auth.ini')
# order queue
self.queue = Queue()
self.button = Button()
self.leds = Leds()
self.sound = Sound()
self.console = Console()
self.console.set_font("Lat15-TerminusBold16.psf.gz", True)
self.dispense_motor = LargeMotor(OUTPUT_A)
self.pump_motor = LargeMotor(OUTPUT_B)
self.touch_sensor = TouchSensor(INPUT_1)
# Start threads
threading.Thread(target=self._handle_queue, daemon=True).start()
threading.Thread(target=self._test, daemon=True).start()
def on_connected(self, device_addr):
self.leds.animate_rainbow(duration=3, block=False)
self.sound.play_song((('C4', 'e3'), ('C5', 'e3')))
def on_disconnected(self, device_addr):
self.leds.animate_police_lights('RED',
'ORANGE',
duration=3,
block=False)
self.leds.set_color("LEFT", "BLACK")
self.leds.set_color("RIGHT", "BLACK")
self.sound.play_song((('C5', 'e3'), ('C4', 'e3')))
def _test(self):
while 1:
self.button.wait_for_pressed('up')
order = {
'name': 'Test',
'tea': 'Jasmine',
'sugar': 100,
'ice': 100
}
self.queue.put(order)
sleep(1)
def _handle_queue(self):
while 1:
if self.queue.empty(): continue
order = self.queue.get()
self._make(name=order['name'],
tea=order['tea'],
sugar=order['sugar'],
ice=order['ice'])
def _send_event(self, name, payload):
self.send_custom_event('Custom.Mindstorms.Gadget', name, payload)
def _affirm_receive(self):
self.leds.animate_flash('GREEN',
sleeptime=0.25,
duration=0.5,
block=False)
self.sound.play_song((('C3', 'e3'), ('C3', 'e3')))
def on_custom_mindstorms_gadget_control(self, directive):
try:
payload = json.loads(directive.payload.decode("utf-8"))
print("Control payload: {}".format(payload), file=sys.stderr)
control_type = payload["type"]
# regular voice commands
if control_type == "automatic":
self._affirm_receive()
order = {
"name": payload["name"] or "Anonymous",
"tea": payload["tea"] or "Jasmine Milk Tea",
"sugar": payload["sugar"] or 100,
"ice": payload["ice"] or 100,
}
self.queue.put(order)
# series of voice commands
elif control_type == "manual": # Expected params: [command]
control_command = payload["command"]
if control_command == "dispense":
self._affirm_receive()
if payload['num']:
self._dispense(payload['num'])
else:
self._dispense()
elif control_command == "pour":
self._affirm_receive()
if payload['num']:
self._pour(payload['num'])
else:
self._pour()
except KeyError:
print("Missing expected parameters: {}".format(directive),
file=sys.stderr)
def _make(self, name=None, tea="Jasmine Milk Tea", sugar=100, ice=100):
if not self.touch_sensor.is_pressed:
# cup is not in place
self._send_event('CUP', None)
self.touch_sensor.wait_for_pressed()
sleep(3) # cup enter delay
# mid_col = console.columns // 2
# mid_row = console.rows // 2
# mid_col = 1
# mid_row = 1
# alignment = "L"
process = self.sound.play_file('mega.wav', 100,
Sound.PLAY_NO_WAIT_FOR_COMPLETE)
# dispense boba
self._dispense()
# dispense liquid
self._pour(tea=tea)
# self.console.text_at(
# s, column=mid_col, row=mid_row, alignment=alignment, reset_console=True
# )
# notify alexa that drink is finished
payload = {
"name": name,
"tea": tea,
"sugar": sugar,
"ice": ice,
}
self._send_event("DONE", payload)
process.kill() # kill song
self.sound.play_song((('C4', 'q'), ('C4', 'q'), ('C4', 'q')),
delay=0.1)
self.touch_sensor.wait_for_released()
# dispense liquid
def _pour(self, time_in_s=10, tea="Jasmine Milk Tea"):
# send event to alexa
payload = {"time_in_s": time_in_s, "tea": tea}
self._send_event("POUR", payload)
self.pump_motor.run_forever(speed_sp=1000)
sleep(time_in_s)
self.pump_motor.stop()
# dispense boba
def _dispense(self, cycles=10):
# send event to alexa
payload = {"cycles": cycles}
self._send_event("DISPENSE", payload)
# ensure the dispenser resets to the correct position everytime
if cycles % 2:
cycles += 1
# agitate the boba to make it fall
for i in range(cycles):
deg = 45 if i % 2 else -45
self.dispense_motor.on_for_degrees(SpeedPercent(75), deg)
sleep(0.5)
#!/usr/bin/env python3
# Before running the drawbot script, run this script and
# use the left and right buttons
# to make the medium motor cam point upwards.
from ev3dev2.motor import MediumMotor
from ev3dev2.button import Button
from time import sleep
medium_motor = MediumMotor()
btn = Button()
# Press left button to turn medium motor left (counterclockwise)
def left(state):
if state: # if state = True
medium_motor.on(speed=-10)
else:
medium_motor.stop()
# Press right button to turn medium motor right (clockwise)
def right(state):
if state:
medium_motor.on(speed=10)
else:
medium_motor.stop()
btn.on_left = left
btn.on_right = right
ent_sc_esq = INPUT_3 ent_sc_dir = INPUT_4 ent_us_lat = INPUT_2 ent_us_fr = INPUT_1 steering_pair = MoveSteering(ent_motor_esq, ent_motor_dir) garra_g = LargeMotor(ent_motor_grande) garra_m = MediumMotor(ent_motor_medio) cor_esq = ColorSensor(ent_sc_esq) cor_dir = ColorSensor(ent_sc_dir) usl = UltrasonicSensor(ent_us_lat) usf = UltrasonicSensor(ent_us_fr) sound = Sound() btn = Button() # FUNÇÕES # Reconhecimento de cor # RGBtoHSV # escalarRGB # definir_rgbmax # cor # autocompletar # Movimentação #alinhamento #girar_pro_lado # Reconhecimento de cor
ent_sc_esq = INPUT_3
ent_sc_dir = INPUT_4
ent_us_lat = INPUT_2
ent_us_fr = INPUT_1
steering_pair = MoveSteering(ent_motor_esq, ent_motor_dir)
garra_g = LargeMotor(ent_motor_grande)
garra_m = MediumMotor(ent_motor_medio)
cor_esq = ColorSensor(ent_sc_esq)
cor_dir = ColorSensor(ent_sc_dir)
usl = UltrasonicSensor(ent_us_lat)
usf = UltrasonicSensor(ent_us_fr)
sound = Sound()
btn = Button()
# FUNÇÕES
def distancia(sensor):
a1 = sensor.distance_centimeters
sleep(0.1)
a2 = sensor.distance_centimeters
sleep(0.1)
a3 = sensor.distance_centimeters
sleep(0.1)
distancia = max(a1, a2, a3)
return distancia
def __init__(self):
"""Initialize the finite state machine class"""
self.handlers = {}
self.start_state = None
self.end_states = []
self.btn = Button()
#^^^^This line is required to tell the EV3 to run this file using Python|it is called a shebang line|it MUST be on the first line
# FLL 42, Pythonian Rabbotics's master program.
#---------------------------------------------------Imports and variable definitions-----------------------------------------------------------------
from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D, SpeedPercent, MoveTank, MediumMotor #gives us accses to everything we need to run EV3 dev
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_3, INPUT_4
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor.lego import GyroSensor
from ev3dev2.button import Button
from ev3dev2.sound import Sound
from ev3dev2.display import Display
import time
import sys
btn = Button() # variable so we can get buttons pressed on EV3
color = ColorSensor(INPUT_4) # color sensor for checking attachment color
tank_drive = MoveTank(
OUTPUT_B, OUTPUT_C) # Creates a variable so we can control the drivetrain
motorA = MediumMotor(OUTPUT_A) # left medium motor
motorD = MediumMotor(OUTPUT_D) # right medium motor
gyro = GyroSensor(INPUT_1) # gyro variable
Sound_ = Sound() # beepity beep
Display_ = Display() # for displaying text
Sound_.play_tone(frequency=400, duration=0.5,
volume=50) #plays a note so we know when the code starts
#---------------------------------------------------------------------------------------------------------------------------------------------------
#------------------------------------------------Distance conversion--------------------------------------------------------------------------------
# Distance Conversion
wheelDiameter_mm = 56 # Look at the first number on the NUMBERxNUMBER on wheel
class run2019:
def __init__(self):
self.btn = Button()
self.LLight = LightSensor(INPUT_1)
self.RLight = LightSensor(INPUT_4)
self.cs = ColorSensor()
self.drive = MoveTank(OUTPUT_A, OUTPUT_D)
self.steer = MoveSteering(OUTPUT_A, OUTPUT_D)
self.heightmotor = LargeMotor(OUTPUT_B)
self.clawactuator = MediumMotor(OUTPUT_C)
os.system('setfont Lat15-TerminusBold14')
self.speed = 40
self.sectionCache = 0
self.orient = {'N': "1", 'E': "1", 'S': "1", 'W': "1"}
def sensordata(self):
print("Left Light Sensor: ", end="", file=sys.stderr)
print(self.LLight.reflected_light_intensity, end=" ", file=sys.stderr)
print("Right Light Sensor: ", end="", file=sys.stderr)
print(self.RLight.reflected_light_intensity, file=sys.stderr)
def turn(self, direc): # Half - works
self.drive.on_for_degrees(SpeedDPS(225), SpeedDPS(225), 223)
if direc == "L" or direc == "l":
self.steer.on_for_degrees(steering=-100,
speed=SpeedDPS(720),
degrees=400)
elif direc == "R" or direc == "r":
self.steer.on_for_degrees(steering=100,
speed=SpeedDPS(720),
degrees=720)
self.steer.off()
def dti(self,
speed,
n,
startCounting=False,
sectionCache=0): # Drive to nth intersection
kp = 1.1
ki = 0
kd = 0
integral = 0
perror = error = 0
inters = 0
piderror = 0
while not self.btn.any(
): # Remember to try stuff twice, this is a keyboard interrupt
lv = self.LLight.reflected_light_intensity
rv = self.RLight.reflected_light_intensity
error = rv - lv
integral += integral + error
derivative = lv - perror
piderror = (error * kp) + (integral * ki) + (derivative * kd)
if speed + abs(piderror) > 100:
if piderror >= 0:
piderror = 100 - speed
else:
piderror = speed - 100
self.drive.on(left_speed=speed - piderror,
right_speed=speed + piderror)
sleep(0.01)
perror = error
# Drive up to nth intersection
# These values are subject to change depending on outside factors, CHANGE ON COMPETITION DAY
if (lv <= 50 and rv <= 55) or (lv <= 50 and rv >= 55) or (
lv >= 50 and rv <= 55): # Currently at an intersection
inters += 1
if (startCounting == True):
sectionCache += 1
if inters == n: # Currently at nth intersection
self.drive.off()
return
self.drive.off()
self.drive.on_for_seconds(SpeedDPS(115), SpeedDPS(115), 1)
print("Left Value: {}, Right Value: {}, P error: {}, Inters: {}".
format(lv, rv, piderror, inters),
file=sys.stderr)
def main(self):
self.heightmotor.on(speed=self.speed)
self.heightmotor.wait_until_not_moving()
# # while not btn.any():
# # sensordata()
# # ## STORING COLOURS
self.drive.on_for_degrees(
left_speed=self.speed, right_speed=self.speed,
degrees=50) # To drive past little initial intersection
print(self.orient, file=sys.stderr) #DEBUG
self.turn("L")
# # # GO TO FIRST BNPs
self.dti(self.speed, 5, startCounting=True)
self.turn("L")
self.dti(self.speed, 1)
#!/usr/bin/python3
from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, OUTPUT_C, SpeedPercent, MoveTank, MediumMotor
from ev3dev2.led import Leds
from ev3dev2.button import Button
from ev3dev2.sound import Sound
from time import sleep
import os
os.system('setfont Lat15-TerminusBold14')
penLift = MediumMotor(OUTPUT_C)
penMove = LargeMotor(OUTPUT_A)
btn = Button()
penLift.on_for_degrees(speed=40, degrees=-850)
penMove.on_for_degrees(speed=20, degrees=500)
sleep(2)
while True:
penMove.on_for_degrees(speed=20, degrees=-1000)
penLift.on_for_degrees(speed=-20, degrees=10)
if btn.enter:
penMove.on_for_degrees(speed=20, degrees=500)
penLift.on_for_degrees(speed=20, degrees=900)
break
penMove.on_for_degrees(speed=20, degrees=1000)
penLift.on_for_degrees(speed=-20, degrees=10)
if btn.enter:
penMove.on_for_degrees(speed=20, degrees=-500)
penLift.on_for_degrees(speed=20, degrees=900)
break
class Ui(threading.Thread):
M_FONT = 'helvB12'
def __init__(self, config):
threading.Thread.__init__(self)
self.roboId = config['id']
self.threadID = 1
self.name = 'ui-thread'
self.isRunning = True
self.messageText = '-'
self.statusText = '-'
self.powerSupplyText = '-'
self.lcd = Display()
self.btn = Button()
self.sound = Sound()
self.leds = Leds()
self.theFont = fonts.load(Ui.M_FONT)
self.lcd.clear()
self.drawText()
self.lcd.update()
def drawText(self):
self.lcd.draw.text((0, 0), 'RoboRinth', font=self.theFont)
self.lcd.draw.text((0, 14), 'ID: ' + self.roboId, font=self.theFont)
self.lcd.draw.text((0, 28),
'Status: ' + self.statusText,
font=self.theFont)
self.lcd.draw.text((0, 42),
'Msg: ' + self.messageText,
font=self.theFont)
# self.lcd.draw.text((0,56), 'Pwr: ' + self.powerSupplyText, font=self.theFont)
def run(self):
while self.isRunning:
self.lcd.clear()
self.drawText()
self.lcd.update()
self.btn.process()
sleep(1)
# sleep(0.5)
self.lcd.clear()
self.lcd.draw.rectangle((0, 0, 178, 128), fill='white')
self.lcd.update()
def registerBackspaceHandler(self, backspaceHandler):
self.btn.on_backspace = backspaceHandler
def stop(self):
self.isRunning = False
self.join()
def setMessageText(self, text):
self.messageText = text
def setStatusText(self, text):
self.statusText = text
def setPowerSupplyText(self, text):
self.powerSupplyText = text
def playStartSound(self):
self.sound.tone([(800, 200, 0), (1200, 400, 100)])
def setStatusLed(self, color):
if color == 'green':
self.leds.set_color('RIGHT', 'GREEN')
elif color == 'orange':
self.leds.set_color('RIGHT', 'ORANGE')
else:
print('unsupported color: ' + str(color))
# LARGEMOTORS USED FOR WHEELS
# Create object functions for basic movements for wheel pair blocks
steer_pair = Shiva_MoveSteering(LARGE_MOTOR_LEFT_PORT, LARGE_MOTOR_RIGHT_PORT)
steer_pair.set_polarity(LargeMotor.POLARITY_INVERSED)
tank_pair = Shiva_MoveTank(LARGE_MOTOR_LEFT_PORT, LARGE_MOTOR_RIGHT_PORT)
tank_pair.set_polarity(LargeMotor.POLARITY_INVERSED)
# Create GYROSENSOR
gyro.mode = ShivaGyro.MODE_GYRO_ANG
# Creates sound and button objects
sound = Sound()
button = Button()
# Debug print code
def debug_print(*args, **kwargs):
'''Print debug messages to stderr.
This shows up in the output panel in VS Code.
'''
print(*args, **kwargs, file=sys.stderr)
# outputs log data to VS Code instead of robot screen
log_file = open('log_data.txt', 'a+')
from time import sleep
from ev3dev2.button import Button
from ev3dev2.sound import Sound
from ev3dev2.display import Display
from PIL import Image
import array
import random
import os
#logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)5s: %(message)s')
log=logging.getLogger(__name__)
log.info("Starting Snake")
btn=Button()
sound=Sound()
display=Display()
# declare the variables
# direction x: 0-no move; 1-left; -1-right
dx=0
# direction y: 0-no move; 1-down; -1-up
dy=0
# Set burger position x
hx=random.randint(10, 170)
# set burger position y
hy=random.randint(20, 120)
# set the start x position of snake
Sx=[80]
# set the start y position of snake
