def calc_fonts():
"""
Iterate through all the Latin "1 & 5" fonts, and use ANSI escape sequences to see how many rows/columns
the EV3 LCD console can accommodate for each font
"""
console = Console()
files = [
f for f in listdir("/usr/share/consolefonts/")
if f.startswith("Lat15") and f.endswith(".psf.gz")
]
files.sort()
for font in files:
console.set_font(font, True)
# position cursor at 50, 50, and ask the console to report its actual cursor position
console.text_at("\x1b[6n", 50, 50, False)
console.text_at(font, 1, 1, False, True)
console.clear_to_eol()
# now, read the console response of the actual cursor position, in the form of esc[rr;ccR
# requires pressing the center button on the EV3 for each read
dims = ''
while True:
ch = stdin.read(1)
if ch == '\x1b' or ch == '[' or ch == '\r' or ch == '\n':
continue
if ch == 'R':
break
dims += str(ch)
(rows, cols) = dims.split(";")
print("({}, {}, \"{}\"),".format(rows, cols, font), file=stderr)
sleep(.5)
def __init__(self):
self.sound = Sound()
self.direction_motor = MediumMotor(OUTPUT_D)
self.swing_motorL = LargeMotor(OUTPUT_A)
self.swing_motorC = LargeMotor(OUTPUT_B)
self.swing_motorR = LargeMotor(OUTPUT_C)
self.swing_motors = [
self.swing_motorL, self.swing_motorC, self.swing_motorR
]
self.touch_sensor = TouchSensor(INPUT_1)
self.console = Console(DEFAULT_FONT)
self.buttons = Button()
self.beeps_enabled = True
def test():
button = Button()
leds = Leds()
console = Console(font='Lat15-TerminusBold20x10')
count = 0
while True:
leds.set_color('LEFT', 'BLACK')
leds.set_color('RIGHT', "BLACK")
sleep(1)
leds.set_color('LEFT', 'GREEN')
leds.set_color('RIGHT', 'GREEN')
sleep(1)
leds.set_color('LEFT', 'BLACK')
leds.set_color('RIGHT', "BLACK")
sleep(1)
leds.set_color('LEFT', 'RED')
leds.set_color('RIGHT', 'RED')
sleep(1)
count = count + 1
if button.enter:
print("press enter", file=sys.stderr)
break
print(count)
sleep(10)
def write_to_console(self, msg:str, column:int, row:int, reset_console=True, inverse=False, alignment='L', font_size='M'):
"""Write msg to console at column, and row
reset_console clears console first
inverse reverses out text
alignment: 'L', 'C', or 'R'
font_size: 'S', 'M', 'L'
Small: 8 rows, 22 columns
Medium: 6 rows, 17 columns
Large: 4 rows, 12 columns
"""
console = Console()
if font_size == 'S':
console.set_font('Lat15-TerminusBoldVGA16.psf.gz', True)
elif font_size == 'M':
console.set_font('Lat15-Terminus20x10.psf.gz', True)
else:
console.set_font('Lat15-Terminus32x16.psf.gz', True)
console.text_at(msg, column, row, reset_console=reset_console, inverse=inverse, alignment=alignment)
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 show_fonts():
"""
Iterate over the known Latin "1 & 5" fonts and display each on the EV3 LCD console.
Note: `Terminus` fonts are "thinner"; `TerminusBold` and `VGA` offer more contrast on the LCD console
and are thus more readable; the `TomThumb` font is waaaaay too small to read!
"""
# Create a list of tuples with calulated rows, columns, font filename
fonts = [
(4, 11, "Lat15-Terminus32x16.psf.gz"),
(4, 11, "Lat15-TerminusBold32x16.psf.gz"),
(4, 11, "Lat15-VGA28x16.psf.gz"), (4, 11, "Lat15-VGA32x16.psf.gz"),
(4, 12, "Lat15-Terminus28x14.psf.gz"),
(4, 12, "Lat15-TerminusBold28x14.psf.gz"),
(5, 14, "Lat15-Terminus24x12.psf.gz"),
(5, 14, "Lat15-TerminusBold24x12.psf.gz"),
(5, 16, "Lat15-Terminus22x11.psf.gz"),
(5, 16, "Lat15-TerminusBold22x11.psf.gz"),
(6, 17, "Lat15-Terminus20x10.psf.gz"),
(6, 17, "Lat15-TerminusBold20x10.psf.gz"),
(7, 22, "Lat15-Fixed18.psf.gz"), (8, 22, "Lat15-Fixed15.psf.gz"),
(8, 22, "Lat15-Fixed16.psf.gz"), (8, 22, "Lat15-Terminus16.psf.gz"),
(8, 22, "Lat15-TerminusBold16.psf.gz"),
(8, 22, "Lat15-TerminusBoldVGA16.psf.gz"),
(8, 22, "Lat15-VGA16.psf.gz"), (9, 22, "Lat15-Fixed13.psf.gz"),
(9, 22, "Lat15-Fixed14.psf.gz"), (9, 22, "Lat15-Terminus14.psf.gz"),
(9, 22, "Lat15-TerminusBold14.psf.gz"),
(9, 22, "Lat15-TerminusBoldVGA14.psf.gz"),
(9, 22, "Lat15-VGA14.psf.gz"), (10, 29, "Lat15-Terminus12x6.psf.gz"),
(16, 22, "Lat15-VGA8.psf.gz"), (21, 44, "Lat15-TomThumb4x6.psf.gz")
]
# Paint the screen full of numbers that represent the column number, reversing the even rows
console = Console()
for rows, cols, font in fonts:
print(rows, cols, font, file=stderr)
console.set_font(font, True)
for row in range(1, rows + 1):
for col in range(1, cols + 1):
console.text_at("{}".format(col % 10), col, row, False,
(row % 2 == 0))
console.text_at(font.split(".")[0], 1, 1, False, True)
console.clear_to_eol()
sleep(.5)
def test():
#设置字体
console = Console(font='Lat15-TerminusBold20x10')
#Console.set_font(font='Lat15-TerminusBold24x12', reset_console=True)
#显示到LCD屏幕
print('start runing')
#显示到调试器的output
print("print to output", file=sys.stderr)
print('Hello World 12345')
print('0123456789ABCDEFabcdef')
print('OK')
sleep(3)
def show_fonts():
"""
Iterate through all the Latin "1 & 5" fonts, and see how many rows/columns
the EV3 LCD console can accommodate for each font.
Note: ``Terminus`` fonts are "thinner"; ``TerminusBold`` and ``VGA`` offer more contrast on the LCD console
and are thus more readable; the ``TomThumb`` font is waaaaay too small to read!
"""
console = Console()
files = [
f for f in listdir("/usr/share/consolefonts/")
if f.startswith("Lat15") and f.endswith(".psf.gz")
]
files.sort()
fonts = []
for font in files:
console.set_font(font, True)
console.text_at(font, 1, 1, False, True)
console.clear_to_eol()
console.text_at("{}, {}".format(console.columns, console.rows),
column=2,
row=4,
reset_console=False,
inverse=False)
print("{}, {}, \"{}\"".format(console.columns, console.rows, font),
file=stderr)
fonts.append((console.columns, console.rows, font))
fonts.sort(key=lambda f: (f[0], f[1], f[2]))
# Paint the screen full of numbers that represent the column number, reversing the even rows
for cols, rows, font in fonts:
print(cols, rows, font, file=stderr)
console.set_font(font, True)
for row in range(1, rows + 1):
for col in range(1, cols + 1):
console.text_at("{}".format(col % 10), col, row, False,
(row % 2 == 0))
console.text_at(font.split(".")[0], 1, 1, False, True)
console.clear_to_eol()
# Logging
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)5s: %(message)s')
log = logging.getLogger(__name__)
log.info("Starting Gyro Boy")
# Initialize
running = True
state = "reset"
timer = StopWatch()
timer.start()
# Brick variables
sound = Sound()
leds = Leds()
console = Console()
gyro_sensor = GyroSensor(INPUT_2)
gyro_sensor.mode = GyroSensor.MODE_GYRO_RATE
arms_motor = MediumMotor(OUTPUT_C)
left_motor = LargeMotor(OUTPUT_D)
right_motor = LargeMotor(OUTPUT_A)
color_sensor = ColorSensor(INPUT_1)
ultra_sonic_sensor = UltrasonicSensor(INPUT_4)
class SensorThread(Thread):
"""Sensor thread, based on Color and Ultrasonic sensors."""
def run(self):
global state
global drive_speed
global steering
import time
logging.basicConfig(level=logging.DEBUG)
# Set true to follow black line
LINE_USE_COLOR_SENSOR = True
TURN_WITH_GYRO = True
GYRO_RESET_WAIT = 4
WHEEL_DIAMATER = 6.88
M_MOTOR = OUTPUT_B
S_MOTOR = OUTPUT_C
gyro = GyroSensor(INPUT_4)
disp = Console()
b = Button()
s = Sound()
color_left = ColorSensor(INPUT_2)
color_right = ColorSensor(INPUT_3)
# 14, 18, ...
# See all: https://python-ev3dev.readthedocs.io/en/latest/display.html
# f = fonts.load('luBS18')
"""
Please depending on the robot change the number below: <<< IMPORTANT!!!! HEY!!!!
WHICH_ROBOT = 0 is if the robot has one color sensor <<<<<<OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
WHICH_ROBOT = 1 is if the robot has two color sensor <<< LOOK!!!!
PLEASE AND THANK YOU
"""
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 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 micropython
# from ev3dev2.display import Display
# screen = Display()
# import ev3dev2.fonts as fonts
from ev3dev2.button import Button
from ev3dev2.console import Console
console = Console("Lat15-TerminusBold28x14.psf.gz")
print = console.text_at
import time, sys
button = Button()
# Config
config = {
"gyroPort": "in4",
"robotName": "littleSapper",
"runFiles": ["run1", "run2", "run3", "run4"]
}
# Define myRobot
from imagine import myRobot
# k = myRobot("outB", "outC", "outD", "out4")
k = myRobot()
# Define functions
def reimportModulesAndRun(runFile):
try:
sys.modules.pop(runFile)
except:
pass
def menu(choices, 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": ("mission-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 mission run, passed with mission-name
- `after_run_function` when not None, call this function after each mission run, passed with mission-name
"""
global proc
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)
if name in ('NEXT', 'BACK', 'OFF'):
mission_function()
else:
# launch a sub process so it could be canceled with the enter button
# store the subprocess in self to reference in the stop function
proc = Process(target=mission_function)
debug('Starting {}'.format(name))
proc.start()
debug('Just started {} in proc {}'.format(name, proc.pid))
sleep(1)
proc.terminate()
# TODO: Need to figure out when to call self.proc.join
except Exception as e:
print("**** Exception when running")
debug('Exception when running {}'.format(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 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")
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.led import Leds
from ev3dev2.sound import Sound
from ev3dev2.display import Display
from ev3dev2.button import Button
from ev3dev2.console import Console
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)
class Robot:
def __init__(self):
self.sound = Sound()
self.direction_motor = MediumMotor(OUTPUT_D)
self.swing_motorL = LargeMotor(OUTPUT_A)
self.swing_motorC = LargeMotor(OUTPUT_B)
self.swing_motorR = LargeMotor(OUTPUT_C)
self.swing_motors = [
self.swing_motorL, self.swing_motorC, self.swing_motorR
]
self.touch_sensor = TouchSensor(INPUT_1)
self.console = Console(DEFAULT_FONT)
self.buttons = Button()
self.beeps_enabled = True
def beep(self, frequency=700, wait_for_comeplete=False):
if not self.beeps_enabled:
return
play_type = Sound.PLAY_WAIT_FOR_COMPLETE if wait_for_comeplete else Sound.PLAY_NO_WAIT_FOR_COMPLETE
self.sound.beep("-f %i" % frequency, play_type=play_type)
def calibrate_dir(self):
''' Calibrate direction motor '''
# Run motor with 25% power, and wait until it stops running
self.direction_motor.on(SpeedPercent(-10), block=False)
# while (not self.direction_motor.STATE_OVERLOADED):
# print(self.direction_motor.duty_cycle)
self.direction_motor.wait_until(self.direction_motor.STATE_OVERLOADED)
self.direction_motor.stop_action = Motor.STOP_ACTION_COAST
self.direction_motor.stop()
time.sleep(.5)
# Reset to straight
# self.direction_motor.on_for_seconds(SpeedPercent(10), .835, brake=True, block=True)
self.direction_motor.on_for_degrees(SpeedPercent(10),
127,
brake=True,
block=True)
self.direction_motor.reset()
print("Motor reset, position: " + str(self.direction_motor.position))
time.sleep(.5)
def calibrate_swing(self):
for m in self.swing_motors:
m.stop_action = m.STOP_ACTION_HOLD
m.on(SpeedPercent(6))
self.swing_motorC.wait_until(self.swing_motorC.STATE_OVERLOADED, 2000)
for m in self.swing_motors:
m.stop_action = m.STOP_ACTION_HOLD
m.on_for_degrees(SpeedPercent(5), -15, brake=True, block=False)
self.swing_motorC.wait_while('running')
for m in self.swing_motors:
m.reset()
m.stop_action = m.STOP_ACTION_HOLD
m.stop()
print("Ready Angle: %i" % self.swing_motorC.position)
def ready_swing(self, angle: int):
right_angle = -(angle / 3)
# adjust motors to target angle
for m in self.swing_motors:
m.stop_action = Motor.STOP_ACTION_HOLD
m.on_for_degrees(SpeedPercent(2),
right_angle,
brake=True,
block=False)
self.swing_motorC.wait_while('running')
for m in self.swing_motors:
m.stop_action = Motor.STOP_ACTION_HOLD
m.stop()
print("Swing Angle: %i" % self.swing_motorC.position)
def set_direction(self, direction):
print("Setting direction to: " + str(direction))
#direction = self.__aim_correction(direction)
self.direction_motor.on_for_degrees(SpeedPercent(10),
round(direction * 3))
print("Direction set to: " + str(self.direction_motor.position))
#
# def __aim_correction(self, direction):
# x = direction
# y = -0.00000000429085685725*x**6 + 0.00000004144345630728*x**5 + 0.00001219331494759860*x**4 + 0.00020702946527870400*x**3 + 0.00716486965517779000*x**2 + 1.29675836037884000000*x + 0.27064829453014400000
#
# return y
def shoot(self, power):
print("SHOOT, power: %i" % power)
for m in self.swing_motors:
m.duty_cycle_sp = -power
for m in self.swing_motors:
m.run_direct()
time.sleep(.5)
self.swing_motorC.wait_until_not_moving()
for m in self.swing_motors:
m.reset()
def wait_for_button(self):
self.touch_sensor.wait_for_bump()
def __set_display(self, str):
self.console.set_font(font=LARGER_FONT, reset_console=True)
self.console.text_at(str, column=1, row=1, reset_console=True)
def wait_for_power_select(self, power=0, angle=0, steps=1):
self.__set_display("Pow: %i\nAngle: %i" % (power, angle))
def left():
power -= steps
if power < 0:
power = 0
self.__set_display("Pow: %i\nAngle: %i" % (power, angle))
self.buttons.wait_for_released(buttons=['left'], timeout_ms=150)
def right():
power += steps
if power > 100:
power = 100
self.__set_display("Pow: %i\nAngle: %i" % (power, angle))
self.buttons.wait_for_released(buttons=['right'], timeout_ms=150)
def up():
angle += steps
if angle > 110:
angle = 110
self.__set_display("Pow: %i\nAngle: %i" % (power, angle))
self.buttons.wait_for_released(buttons=['up'], timeout_ms=150)
def down():
angle -= steps
if angle < 0:
angle = 0
self.__set_display("Pow: %i\nAngle: %i" % (power, angle))
self.buttons.wait_for_released(buttons=['down'], timeout_ms=150)
while not self.touch_sensor.is_pressed:
if self.buttons.left:
left()
elif self.buttons.right:
right()
elif self.buttons.up:
up()
elif self.buttons.down:
down()
self.console.set_font(font=DEFAULT_FONT, reset_console=True)
return (power, angle)
def select_connection_mode(self):
self.__set_display("Enable Connection\nLeft: True - Right: False")
enabled = True
while not self.touch_sensor.is_pressed:
if self.buttons.left:
enabled = True
self.buttons.wait_for_released(buttons=['left'])
break
elif self.buttons.right:
enabled = False
self.buttons.wait_for_released(buttons=['right'])
break
self.console.set_font(font=DEFAULT_FONT, reset_console=True)
return enabled
def print(self, string):
print(string)
#!/usr/bin/env python3
import argparse
import requests
from time import sleep
from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, SpeedPercent
from ev3dev2.sound import Sound
from ev3dev2.console import Console
from agt import AlexaGadget
URL = "http://35.230.20.197:5000" or "http://bobafetch.me:5000"
console = Console()
console.set_font("Lat15-TerminusBold16.psf.gz", True)
# mid_col = console.columns // 2
# mid_row = console.rows // 2
mid_col = 1
mid_row = 1
alignment = "L"
def main():
console.text_at(
"Mindstorms is running",
column=mid_col,
row=mid_row,
alignment=alignment,
reset_console=True,
#!/usr/bin/env python3
print("Starting server...")
from ev3dev2.console import Console
Console("Lat15-Terminus12x6")
print("Importing modules (this may take a while)...")
import time
t1 = time.perf_counter()
import json
import os
import subprocess
import time
import traceback
from base64 import b64decode
from shutil import which
from socket import gethostname
from threading import Thread, Lock
import tornado.ioloop
import tornado.options
import tornado.web
import tornado.websocket
from ev3dev2.led import Leds
from ev3dev2.motor import list_motors, Motor, MoveJoystick, OUTPUT_B, OUTPUT_C
from ev3dev2.sensor import list_sensors, Sensor
t2 = time.perf_counter()
print("Imported in", t2 - t1)
# has auth is True if users should be logged in to access the server
HAS_AUTH = (
os.path.exists(".htpasswd") # check that password file exists ...
and which("htpasswd") is not None
#!/usr/bin/env micropython
from ev3dev2.console import Console
from time import sleep
# create a Console instance, which uses the default font
console = Console()
# reset the console to clear it, home the cursor at 1,1, and then turn off the cursor
console.reset_console()
# display 'Hello World!' at row 5, column 1 in inverse, but reset the EV3 LCD console first
console.text_at('Hello World!',
column=1,
row=5,
reset_console=True,
inverse=True)
sleep(10)
from ev3dev2.motor import SpeedNativeUnits
# import Sensor modules and the ev3 ports used for it
from ShivaColor import ShivaColor
from ev3dev2.sensor import INPUT_1, INPUT_2, INPUT_4
from ev3dev2.sensor.lego import GyroSensor, TouchSensor
from ev3dev2.sensor import INPUT_3
from ShivaGyro import ShivaGyro
# Creates sound and button objects
from ev3dev2.sound import Sound
from ev3dev2.button import Button
# Sets the font size for robot lcd
console = Console()
console.set_font('Lat15-VGA16.psf.gz')
# Port assignments
MEDIUM_MOTOR_LEFT = OUTPUT_A
MEDIUM_MOTOR_RIGHT = OUTPUT_D
LARGE_MOTOR_LEFT_PORT = OUTPUT_B
LARGE_MOTOR_RIGHT_PORT = OUTPUT_C
COLORSENSOR_RIGHT = INPUT_1
COLORSENSOR_LEFT = INPUT_3
TOUCHSENSOR_PORT = INPUT_4
GYROSENSOR_PORT = INPUT_2
# Checks every port on the robot to see if its connected properly
def __init__(self,
motorPort1,
motorPort2,
modulePort,
colorPort1,
colorPort2,
gyro1=None,
gyro2=None,
motorDiff=1,
colMode="COL-COLOR",
moduleSensor=None,
printErrors=True,
enableConsole=False,
modulePort2=None):
if motorPort1 and motorPort2:
self.ms = MoveSteering(
motorPort1,
motorPort2) # If defined in parameters, define MoveSteering
if motorPort1 and motorPort2:
self.mt = MoveTank(
motorPort1,
motorPort2) # If defined in parameters, define MoveTank
if motorPort1:
self.m1 = LargeMotor(
motorPort1) # If defined in parameters, define Left Motor
if motorPort2:
self.m2 = LargeMotor(
motorPort2) # If defined in parameters, define Right Motor
if modulePort:
self.mmt = Motor(modulePort)
# If defined in parameters, define module motor
if modulePort2:
self.mmt2 = Motor(modulePort2)
# If defined in parameters, define module motor
if enableConsole: self.resetMotors()
if colorPort1 != None: # If defined in parameters, define Left Color sensor
self.csLeft = ColorSensor(colorPort1)
self.csLeft.mode = colMode # Set color mode to the one in the parameters
if colorPort2 != None: # If defined in parameters, define Right Color sensor
self.csRight = ColorSensor(colorPort2)
self.csRight.mode = colMode # Set color mode to the one in the parameters
if moduleSensor != None: # If defined in parameters, define module sensor
self.moduleSensor = ColorSensor(moduleSensor)
self.moduleSensor.mode = "COL-COLOR"
try:
self.gs = GyroSensor(gyro1)
self.gs.mode = "GYRO-RATE"
self.gs.mode = "GYRO-ANG"
except:
print("Gyro 1 can't be defined!"
) # Define gyro if possible, otherwise show error
try:
self.gs2 = GyroSensor(gyro2)
self.gs2.mode = "GYRO-RATE"
self.gs2.mode = "TILT-ANG"
except:
print("Gyro 2 can't be defined!"
) # Define gyro if possible, otherwise show error
self.using2ndGyro = False # Set default gyro to the 1st one
self.motorDiff = motorDiff # Set motor difference to the one defined
self.leds = Leds() # Setup brick leds
self.bt = Button() # Setup brick buttons
if enableConsole:
self.console = Console(
font="Lat15-Terminus32x16") # Enable console access if needed
try:
with open("/home/robot/sappers2/pid.txt", "w") as pid:
pid.write(str(os.getpid()))
except:
pass # Write PID into file for other applications.
if printErrors: print("Successfully Initialized. ")
self.timerStart = time.time()