Python language bindings for ev3dev¶

https://travis-ci.org/ev3dev/ev3dev-lang-python.svg?branch=ev3dev-stretch

A Python3 library implementing an interface for ev3dev devices, letting you control motors, sensors, hardware buttons, LCD displays and more from Python code.

If you haven’t written code in Python before, you can certainly use this library to help you learn the language!

Getting Started¶

This library runs on ev3dev. Before continuing, make sure that you have set up your EV3 or other ev3dev device as explained in the ev3dev Getting Started guide. Make sure you have an ev3dev-stretch version greater than 2.2.0. You can check the kernel version by selecting “About” in Brickman and scrolling down to the “kernel version”. If you don’t have a compatible version, upgrade the kernel before continuing.

Usage¶

To start out, you’ll need a way to work with Python. We recommend the ev3dev Visual Studio Code extension. If you’re interested in using that, check out our Python + VSCode introduction tutorial and then come back once you have that set up.

Otherwise, you can can work with files via an SSH connection with an editor such as nano, use the Python interactive REPL (type python3), or roll your own solution. If you don’t know how to do that, you are probably better off choosing the recommended option above.

The template for a Python script¶

Every Python program should have a few basic parts. Use this template to get started:

#!/usr/bin/env python3

from time import sleep

from ev3dev2.motor import LargeMotor, OUTPUT_A, OUTPUT_B, SpeedPercent, MoveTank
from ev3dev2.sensor import INPUT_1
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.led import Leds

# TODO: Add code here

The first line should be included in every Python program you write for ev3dev. It allows you to run this program from Brickman, the graphical menu that you see on the device screen. The other lines are import statements which give you access to the library functionality. You will need to add additional classes to the import list if you want to use other types of devices or additional utilities.

You should use the .py extension for your file, e.g. my-file.py.

If you encounter an error such as /usr/bin/env: 'python3\r': No such file or directory, you must switch your editor’s “line endings” setting for the file from “CRLF” to just “LF”. This is usually in the status bar at the bottom. For help, see our FAQ page.

Important: Make your script executable (non-Visual Studio Code only)¶

To be able to run your Python file, your program must be executable. If you are using the ev3dev Visual Studio Code extension, you can skip this step, as it will be automatically performed when you download your code to the brick.

To mark a program as executable from the command line (often an SSH session), run chmod +x my-file.py.

You can now run my-file.py via the Brickman File Browser or you can run it from the command line by preceding the file name with ./: ./my-file.py

Controlling the LEDs with a touch sensor¶

This code will turn the LEDs red whenever the touch sensor is pressed, and back to green when it’s released. Plug a touch sensor into any sensor port before trying this out.

ts = TouchSensor()
leds = Leds()

print("Press the touch sensor to change the LED color!")

while True:
    if ts.is_pressed:
        leds.set_color("LEFT", "GREEN")
        leds.set_color("RIGHT", "GREEN")
    else:
        leds.set_color("LEFT", "RED")
        leds.set_color("RIGHT", "RED")
    # don't let this loop use 100% CPU
    sleep(0.01)

If you’d like to use a sensor on a specific port, specify the port like this:

ts = TouchSensor(INPUT_1)

Heads-up: If you are using a BrickPi instead of an EV3, you will need to manually configure the sensor. See the example here: https://github.com/ev3dev/ev3dev-lang-python-demo/blob/stretch/platform/brickpi3-motor-and-sensor.py

Running a single motor¶

This will run a LEGO Large Motor at 75% of maximum speed for 5 rotations.

m = LargeMotor(OUTPUT_A)
m.on_for_rotations(SpeedPercent(75), 5)

You can also run a motor for a number of degrees, an amount of time, or simply start it and let it run until you tell it to stop. Additionally, other units are also available. See the following pages for more information:

Driving with two motors¶

The simplest drive control style is with the MoveTank class:

tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)

# drive in a turn for 5 rotations of the outer motor
# the first two parameters can be unit classes or percentages.
tank_drive.on_for_rotations(SpeedPercent(50), SpeedPercent(75), 10)

# drive in a different turn for 3 seconds
tank_drive.on_for_seconds(SpeedPercent(60), SpeedPercent(30), 3)

There are also MoveSteering and MoveJoystick classes which provide different styles of control. See the following pages for more information:

Using text-to-speech¶

If you want to make your robot speak, you can use the Sound.speak method:

from ev3dev2.sound import Sound

sound = Sound()
sound.speak('Welcome to the E V 3 dev project!')

More Demo Code¶

There are several demo programs that you can run to get acquainted with this language binding. The programs are available at this GitHub site.

You can also copy and run the programs in the utils directory to understand some of the code constructs to use the EV3 motors, sensors, LCD console, buttons, sound, and LEDs.

We also highly recommend ev3python.com where one of our community members, @ndward, has put together a great website with detailed guides on using this library which are targeted at beginners. If you are just getting started with programming, we highly recommend that you check it out at ev3python.com!

Using Micropython¶

Normal Python too slow? Review Micropython to see if it supports the features your project needs.

Library Documentation¶

Class documentation for this library can be found on our Read the Docs page. You can always go there to get information on how you can use this library’s functionality.

Frequently-Asked Questions¶

Experiencing an odd error or unsure of how to do something that seems simple? Check our our FAQ to see if there’s an existing answer.

Contents

Using python-ev3dev with MicroPython¶

The core modules of this library are shipped as a module for MicroPython, which is faster to load and run on the EV3. If your app only requires functionality supported on MicroPython, we recommend you run your code with it for improved performance.

Module support¶

Module	Support status
ev3dev2.button	️️✔️
ev3dev2.console	✔️️
ev3dev2.control [1]	⚠️
ev3dev2.display [2]	❌
ev3dev2.fonts [3]	❌
ev3dev2.led	✔️
ev3dev2.motor	✔️
ev3dev2.port	✔️
ev3dev2.power	✔️
ev3dev2.sensor.*	✔️
ev3dev2.sound	✔️
ev3dev2.unit	✔️
ev3dev2.wheel	✔️

[1]	Untested/low-priority, but some of it might work.

[2]	`ev3dev2.display` isn’t implemented. Use `ev3dev2.console` for text-only, using ANSI codes to the EV3 LCD console.

[3]	`ev3dev2.console` supports the system fonts, but the fonts for `ev3dev2.display` do not work.

Differences from standard Python (CPython)¶

See the MicroPython differences page for language information.

Shebang¶

You should modify the first line of your scripts to replace “python3” with “micropython”:

#!/usr/bin/env micropython

Running from the command line¶

If you previously would have typed python3 foo.py, you should now type micropython foo.py.

If you are running programs via an SSH shell to your EV3, use the following command line to prevent Brickman from interfering:

brickrun -- ./program.py

Upgrading from ev3dev-jessie (library v1) to ev3dev-stretch (library v2)¶

With ev3dev-stretch, we have introduced some breaking changes that you must be aware of to get older scripts running with new features.

Scripts which worked on ev3dev-jessie are still supported and will continue to work as-is on Stretch. However, if you want to use any of the new features we have introduced, you will need to switch to using version 2 of the python-ev3dev library. You can switch to version 2 by updating your import statements.

Updating import statements¶

Previously, we recommended using one of the following as your import declaration:

import ev3dev.ev3 as ev3
import ev3dev.brickpi as ev3
import ev3dev.auto as ev3

We have re-arranged the library to provide more control over what gets imported. For all platforms, you will now import from individual modules for things like sensors and motors, like this:

from ev3dev2.motor import Motor, OUTPUT_A
from ev3dev2.sensor.lego import TouchSensor, UltrasonicSensor

The platform (EV3, BrickPi, etc.) will now be automatically determined.

You can omit import statements for modules you don’t need, and add any additional ones that you do require. With this style of import, members are globally available by their name, so you would now refer to the Motor class as simply Motor rather than ev3.Motor.

Remove references to `connected` attribute¶

In version 1 of the library, instantiating a device such as a motor or sensor would always succeed without an error. To see if the device connected successfully you would have to check the connected attribute. With the new version of the module, the constructor of device classes will throw an ev3dev2.DeviceNotConnected exception. You will need to remove any uses of the connected attribute.

`Screen` class has been renamed to `Display`¶

To match the name used by LEGO’s “EV3-G” graphical programming tools, we have renamed the Screen module to Display.

Reorganization of `RemoteControl`, `BeaconSeeker` and `InfraredSensor`¶

The RemoteControl and BeaconSeeker classes have been removed; you will now use InfraredSensor for all purposes.

Additionally, we have renamed many of the properties on the InfraredSensor class to make the meaning more obvious. Check out the InfraredSensor documentation for more info.

Re-designed `Sound` class¶

The names and interfaces of some of the Sound class methods have changed. Check out the Sound class docs for details.

Once you’ve adapted to breaking changes, check out the cool new features!¶

New classes are available for coordinating motors: ev3dev2.motor.MotorSet, ev3dev2.motor.MoveTank, ev3dev2.motor.MoveSteering, and ev3dev2.motor.MoveJoystick.
Classes representing a variety of motor speed units are available and accepted by many of the motor interfaces: see Units.
Friendlier interfaces for operating motors and sensors: check out ev3dev2.motor.Motor.on_for_rotations() and the other on_for_* methods on motors.
Easier interactivity via buttons: each button now has wait_for_pressed, wait_for_released and wait_for_bump
Improved ev3dev2.sound.Sound and ev3dev2.display.Display interfaces
New color conversion methods in ev3dev2.sensor.lego.ColorSensor

API reference¶

Device interfaces¶

Contents:

Units ¶

Most methods which run motors will accept a speed argument. While this can be provided as an integer which will be interpreted as a percentage of max speed, you can also specify an instance of any of the following classes, each of which represents a different unit system:

class ev3dev2.motor.SpeedValue¶: A base class for other unit types. Don’t use this directly; instead, see SpeedPercent, SpeedRPS, SpeedRPM, SpeedDPS, and SpeedDPM.

class ev3dev2.motor.SpeedPercent(percent, desc=None)¶: Speed as a percentage of the motor’s maximum rated speed.

class ev3dev2.motor.SpeedNativeUnits(native_counts, desc=None)¶: Speed in tacho counts per second.

class ev3dev2.motor.SpeedRPS(rotations_per_second, desc=None)¶: Speed in rotations-per-second.

class ev3dev2.motor.SpeedRPM(rotations_per_minute, desc=None)¶: Speed in rotations-per-minute.

class ev3dev2.motor.SpeedDPS(degrees_per_second, desc=None)¶: Speed in degrees-per-second.

class ev3dev2.motor.SpeedDPM(degrees_per_minute, desc=None)¶: Speed in degrees-per-minute.

Example:

from ev3dev2.motor import SpeedRPM

# later...

# rotates the motor at 200 RPM (rotations-per-minute) for five seconds.
my_motor.on_for_seconds(SpeedRPM(200), 5)

Common motors ¶

Tacho Motor (Motor)¶

class ev3dev2.motor.Motor(address=None, name_pattern='*', name_exact=False, **kwargs)¶

Bases: ev3dev2.Device

The motor class provides a uniform interface for using motors with positional and directional feedback such as the EV3 and NXT motors. This feedback allows for precise control of the motors. This is the most common type of motor, so we just call it motor.

COMMAND_RUN_FOREVER = 'run-forever'¶: Run the motor until another command is sent.

COMMAND_RUN_TO_ABS_POS = 'run-to-abs-pos'¶: Run to an absolute position specified by position_sp and then stop using the action specified in stop_action.

COMMAND_RUN_TO_REL_POS = 'run-to-rel-pos'¶: Run to a position relative to the current position value. The new position will be current position + position_sp. When the new position is reached, the motor will stop using the action specified by stop_action.

COMMAND_RUN_TIMED = 'run-timed'¶: Run the motor for the amount of time specified in time_sp and then stop the motor using the action specified by stop_action.

COMMAND_RUN_DIRECT = 'run-direct'¶: Run the motor at the duty cycle specified by duty_cycle_sp. Unlike other run commands, changing duty_cycle_sp while running will take effect immediately.

COMMAND_STOP = 'stop'¶: Stop any of the run commands before they are complete using the action specified by stop_action.

COMMAND_RESET = 'reset'¶: Reset all of the motor parameter attributes to their default value. This will also have the effect of stopping the motor.

ENCODER_POLARITY_NORMAL = 'normal'¶: Sets the normal polarity of the rotary encoder.

ENCODER_POLARITY_INVERSED = 'inversed'¶: Sets the inversed polarity of the rotary encoder.

POLARITY_NORMAL = 'normal'¶: With normal polarity, a positive duty cycle will cause the motor to rotate clockwise.

POLARITY_INVERSED = 'inversed'¶: With inversed polarity, a positive duty cycle will cause the motor to rotate counter-clockwise.

STATE_RUNNING = 'running'¶: Power is being sent to the motor.

STATE_RAMPING = 'ramping'¶: The motor is ramping up or down and has not yet reached a constant output level.

STATE_HOLDING = 'holding'¶: The motor is not turning, but rather attempting to hold a fixed position.

STATE_OVERLOADED = 'overloaded'¶: The motor is turning, but cannot reach its speed_sp.

STATE_STALLED = 'stalled'¶: The motor is not turning when it should be.

STOP_ACTION_COAST = 'coast'¶: Power will be removed from the motor and it will freely coast to a stop.

STOP_ACTION_BRAKE = 'brake'¶: Power will be removed from the motor and a passive electrical load will be placed on the motor. This is usually done by shorting the motor terminals together. This load will absorb the energy from the rotation of the motors and cause the motor to stop more quickly than coasting.

STOP_ACTION_HOLD = 'hold'¶: Does not remove power from the motor. Instead it actively try to hold the motor at the current position. If an external force tries to turn the motor, the motor will push back to maintain its position.

address¶: Returns the name of the port that this motor is connected to.

command¶: Sends a command to the motor controller. See commands for a list of possible values.

commands¶

Returns a list of commands that are supported by the motor controller. Possible values are run-forever, run-to-abs-pos, run-to-rel-pos, run-timed, run-direct, stop and reset. Not all commands may be supported.

run-forever will cause the motor to run until another command is sent.
run-to-abs-pos will run to an absolute position specified by position_sp and then stop using the action specified in stop_action.
run-to-rel-pos will run to a position relative to the current position value. The new position will be current position + position_sp. When the new position is reached, the motor will stop using the action specified by stop_action.
run-timed will run the motor for the amount of time specified in time_sp and then stop the motor using the action specified by stop_action.
run-direct will run the motor at the duty cycle specified by duty_cycle_sp. Unlike other run commands, changing duty_cycle_sp while running will take effect immediately.
stop will stop any of the run commands before they are complete using the action specified by stop_action.
reset will reset all of the motor parameter attributes to their default value. This will also have the effect of stopping the motor.

count_per_rot¶: Returns the number of tacho counts in one rotation of the motor. Tacho counts are used by the position and speed attributes, so you can use this value to convert rotations or degrees to tacho counts. (rotation motors only)

count_per_m¶: Returns the number of tacho counts in one meter of travel of the motor. Tacho counts are used by the position and speed attributes, so you can use this value to convert from distance to tacho counts. (linear motors only)

driver_name¶: Returns the name of the driver that provides this tacho motor device.

duty_cycle¶: Returns the current duty cycle of the motor. Units are percent. Values are -100 to 100.

duty_cycle_sp¶: Writing sets the duty cycle setpoint. Reading returns the current value. Units are in percent. Valid values are -100 to 100. A negative value causes the motor to rotate in reverse.

full_travel_count¶: Returns the number of tacho counts in the full travel of the motor. When combined with the count_per_m atribute, you can use this value to calculate the maximum travel distance of the motor. (linear motors only)

polarity¶: Sets the polarity of the motor. With normal polarity, a positive duty cycle will cause the motor to rotate clockwise. With inversed polarity, a positive duty cycle will cause the motor to rotate counter-clockwise. Valid values are normal and inversed.

position¶: Returns the current position of the motor in pulses of the rotary encoder. When the motor rotates clockwise, the position will increase. Likewise, rotating counter-clockwise causes the position to decrease. Writing will set the position to that value.

position_p¶: The proportional constant for the position PID.

position_i¶: The integral constant for the position PID.

position_d¶: The derivative constant for the position PID.

position_sp¶: Writing specifies the target position for the run-to-abs-pos and run-to-rel-pos commands. Reading returns the current value. Units are in tacho counts. You can use the value returned by count_per_rot to convert tacho counts to/from rotations or degrees.

max_speed¶: Returns the maximum value that is accepted by the speed_sp attribute. This may be slightly different than the maximum speed that a particular motor can reach - it’s the maximum theoretical speed.

speed¶: Returns the current motor speed in tacho counts per second. Note, this is not necessarily degrees (although it is for LEGO motors). Use the count_per_rot attribute to convert this value to RPM or deg/sec.

speed_sp¶: Writing sets the target speed in tacho counts per second used for all run-* commands except run-direct. Reading returns the current value. A negative value causes the motor to rotate in reverse with the exception of run-to-*-pos commands where the sign is ignored. Use the count_per_rot attribute to convert RPM or deg/sec to tacho counts per second. Use the count_per_m attribute to convert m/s to tacho counts per second.

ramp_up_sp¶: Writing sets the ramp up setpoint. Reading returns the current value. Units are in milliseconds and must be positive. When set to a non-zero value, the motor speed will increase from 0 to 100% of max_speed over the span of this setpoint. The actual ramp time is the ratio of the difference between the speed_sp and the current speed and max_speed multiplied by ramp_up_sp.

ramp_down_sp¶: Writing sets the ramp down setpoint. Reading returns the current value. Units are in milliseconds and must be positive. When set to a non-zero value, the motor speed will decrease from 0 to 100% of max_speed over the span of this setpoint. The actual ramp time is the ratio of the difference between the speed_sp and the current speed and max_speed multiplied by ramp_down_sp.

speed_p¶: The proportional constant for the speed regulation PID.

speed_i¶: The integral constant for the speed regulation PID.

speed_d¶: The derivative constant for the speed regulation PID.

state¶: Reading returns a list of state flags. Possible flags are running, ramping, holding, overloaded and stalled.

stop_action¶: Reading returns the current stop action. Writing sets the stop action. The value determines the motors behavior when command is set to stop. Also, it determines the motors behavior when a run command completes. See stop_actions for a list of possible values.

stop_actions¶: Returns a list of stop actions supported by the motor controller. Possible values are coast, brake and hold. coast means that power will be removed from the motor and it will freely coast to a stop. brake means that power will be removed from the motor and a passive electrical load will be placed on the motor. This is usually done by shorting the motor terminals together. This load will absorb the energy from the rotation of the motors and cause the motor to stop more quickly than coasting. hold does not remove power from the motor. Instead it actively tries to hold the motor at the current position. If an external force tries to turn the motor, the motor will ‘push back’ to maintain its position.

time_sp¶: Writing specifies the amount of time the motor will run when using the run-timed command. Reading returns the current value. Units are in milliseconds.

run_forever(**kwargs)¶: Run the motor until another command is sent.

run_to_abs_pos(**kwargs)¶: Run to an absolute position specified by position_sp and then stop using the action specified in stop_action.

run_to_rel_pos(**kwargs)¶: Run to a position relative to the current position value. The new position will be current position + position_sp. When the new position is reached, the motor will stop using the action specified by stop_action.

run_timed(**kwargs)¶: Run the motor for the amount of time specified in time_sp and then stop the motor using the action specified by stop_action.

run_direct(**kwargs)¶: Run the motor at the duty cycle specified by duty_cycle_sp. Unlike other run commands, changing duty_cycle_sp while running will take effect immediately.

stop(**kwargs)¶: Stop any of the run commands before they are complete using the action specified by stop_action.

reset(**kwargs)¶: Reset all of the motor parameter attributes to their default value. This will also have the effect of stopping the motor.

is_running¶: Power is being sent to the motor.

is_ramping¶: The motor is ramping up or down and has not yet reached a constant output level.

is_holding¶: The motor is not turning, but rather attempting to hold a fixed position.

is_overloaded¶: The motor is turning, but cannot reach its speed_sp.

is_stalled¶: The motor is not turning when it should be.

wait(cond, timeout=None)¶

Blocks until cond(self.state) is True. The condition is checked when there is an I/O event related to the state attribute. Exits early when timeout (in milliseconds) is reached.

Returns True if the condition is met, and False if the timeout is reached.

wait_until_not_moving(timeout=None)¶

Blocks until running is not in self.state or stalled is in self.state. The condition is checked when there is an I/O event related to the state attribute. Exits early when timeout (in milliseconds) is reached.

Returns True if the condition is met, and False if the timeout is reached.

Example:

m.wait_until_not_moving()

wait_until(s, timeout=None)¶

Blocks until s is in self.state. The condition is checked when there is an I/O event related to the state attribute. Exits early when timeout (in milliseconds) is reached.

Returns True if the condition is met, and False if the timeout is reached.

Example:

m.wait_until('stalled')

wait_while(s, timeout=None)¶

Blocks until s is not in self.state. The condition is checked when there is an I/O event related to the state attribute. Exits early when timeout (in milliseconds) is reached.

Returns True if the condition is met, and False if the timeout is reached.

Example:

m.wait_while('running')

on_for_rotations(speed, rotations, brake=True, block=True)¶

Rotate the motor at speed for rotations