Motors C++ API module

Motor(const std::int8_t port, const pros::v5::MotorGears gearset = pros::v5::MotorGears::invalid, const pros::v5::MotorUnits encoder_units = pros::v5::MotorUnits::invalid)

#include <pros/motors.hpp>

Constructs a new Motor object.

This function uses the following values of errno when an error state is reached: ENXIO - The given value is not within the range of V5 ports |1-21|. ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
    Motor first_motor(1); //Creates a motor on port 1 without altering gearset or encoder units
 Motor reversed_motor(-2); //Creates a reversed motor on port 1 port 1 without altering gearset or encoder units
 Motor blue_motor(3, pros::v5::MotorGears::blue); //Creates a motor on port 3 with blue gear set
 Motor rotations_motor(4, pros::v5::MotorGears::green, pros::v5::MotorUnits::rotations); //port 4 w/ rotations

}

Motor(const Device& device)

#include <pros/motors.hpp>

const pros::Motor operator""_mtr(const unsigned long long int m)

#include <pros/motors.hpp>

Constructs a Motor from a literal ending in _mtr.

Example

using namespace pros::literals;
void opcontrol() {
 pros::Motor motor = 2_mtr; //Makes an Motor object on port 2
}

const pros::Motor operator""_rmtr(const unsigned long long int m)

#include <pros/motors.hpp>

Constructs a reversed Motor from a literal ending in _rmtr.

Example

using namespace pros::literals;
void opcontrol() {
 pros::motor motor = 2_rmtr; //Makes an reversed Motor object on port 2
}

std::int32_t move(std::int32_t voltage) const virtual

#include <pros/motors.hpp>

Sets the voltage for the motor from -127 to 127.

This is designed to map easily to the input from the controller's analog stick for simple opcontrol use. The actual behavior of the motor is analogous to use of motor_move().

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor Motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor.move(master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y));
    pros::delay(2);
  }
}

std::int32_t move_absolute(const double position, const std::int32_t velocity) const virtual

#include <pros/motors.hpp>

Sets the target absolute position for the motor to move to.

This movement is relative to the position of the motor when initialized or the position when it was most recently reset with pros::Motor::set_zero_position().

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100); // Moves 100 units forward
  while (!((motor.get_position() < 105) && (motor.get_position() > 95))) {
    // Continue running this loop as long as the motor is not within +-5 units of its goal
    pros::delay(2);
  }
  motor.move_absolute(100, 100); // This does not cause a movement
  while (!((motor.get_position() < 105) && (motor.get_position() > 95))) {
    pros::delay(2);
  }
  motor.tare_position();
  motor.move_absolute(100, 100); // Moves 100 units forward
  while (!((motor.get_position() < 105) && (motor.get_position() > 95))) {
    pros::delay(2);
  }
}

std::int32_t move_relative(const double position, const std::int32_t velocity) const virtual

#include <pros/motors.hpp>

Sets the relative target position for the motor to move to.

This movement is relative to the current position of the motor as given in pros::Motor::motor_get_position(). Providing 10.0 as the position parameter would result in the motor moving clockwise 10 units (counter clockwise if reversed), no matter what the current position is.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_relative(100, 100); // Moves 100 units forward
  while (!((motor.get_position() < 105) && (motor.get_position() > 95))) {
    // Continue running this loop as long as the motor is not within +-5 units of its goal
    pros::delay(2);
  }
  motor.move_relative(100, 100); // Also moves 100 units forward
  while (!((motor.get_position() < 205) && (motor.get_position() > 195))) {
    pros::delay(2);
  }
}

std::int32_t move_velocity(const std::int32_t velocity) const virtual

#include <pros/motors.hpp>

Sets the velocity for the motor.

This velocity corresponds to different actual speeds depending on the gearset used for the motor. This results in a range of +-100 for E_MOTOR_GEARSET_36, +-200 for E_MOTOR_GEARSET_18, and +-600 for E_MOTOR_GEARSET_6. The velocity is held with PID to ensure consistent speed, as opposed to setting the motor's voltage.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_velocity(100);
  pros::delay(1000); // Move at 100 RPM for 1 second
  motor.move_velocity(0);
}

std::int32_t move_voltage(const std::int32_t voltage) const virtual

#include <pros/motors.hpp>

Sets the output voltage for the motor from -12000 to 12000 in millivolts.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  motor.move_voltage(12000);
  pros::delay(1000); // Move at max voltage for 1 second
  motor.move_voltage(0);
}

std::int32_t brake(void) const virtual

#include <pros/motors.hpp>

Stops the motor using the currently configured brake mode.

This function sets motor velocity to zero, which will cause it to act according to the set brake mode. If brake mode is set to MOTOR_BRAKE_HOLD, this function may behave differently than calling move_absolute(0) or motor_move_relative(0).

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

 void autonomous() {
 Motor motor(1);
  motor.move_voltage(12000);
  pros::delay(1000); // Move at max voltage for 1 second
  motor.brake();
}

std::int32_t modify_profiled_velocity(const std::int32_t velocity) const virtual

#include <pros/motors.hpp>

Changes the output velocity for a profiled movement (motor_move_absolute or motor_move_relative).

This will have no effect if the motor is not following a profiled movement.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
     pros::Motor motor (1);
  motor.move_absolute(100, 100);
  pros::delay(100);
  motor.modify_profiled_velocity(0); // Stop the motor early
}

double get_target_position(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the target position set for the motor by the user.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor EOVERFLOW - The index is non 0

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100);
  std::cout << "Motor Target: " << motor.get_target_position();
  // Prints 100
}

std::int32_t get_target_velocity(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the velocity commanded to the motor by the user at the index specified.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor.move_velocity(master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y));
    std::cout << "Motor Velocity: " << motor.get_target_velocity();
    // Prints the value of E_CONTROLLER_ANALOG_LEFT_Y
    pros::delay(2);
  }
}

double get_actual_velocity(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the actual velocity of the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  while (true) {
    motor = controller_get_analog(E_CONTROLLER_MASTER, E_CONTROLLER_ANALOG_LEFT_Y);
    printf("Actual velocity: %lf\n", motor.get_actual_velocity());
    pros::delay(2);
  }
}

std::int32_t get_current_draw(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the current drawn by the motor in mA.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Current Draw: " << motor.get_current_draw();
    pros::delay(2);
  }
}

std::int32_t get_direction(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the direction of movement for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Direction: " << motor.get_direction();
    pros::delay(2);
  }
}

double get_efficiency(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the efficiency of the motor in percent.

An efficiency of 100% means that the motor is moving electrically while drawing no electrical power, and an efficiency of 0% means that the motor is drawing power but not moving.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Efficiency: " << motor.get_efficiency();
    pros::delay(2);
  }
}

std::uint32_t get_faults(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the faults experienced by the motor.

Compare this bitfield to the bitmasks in pros::motor_fault_e_t.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Faults: " << motor.get_faults();pros::delay(2);
  }
}

std::uint32_t get_flags(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the flags set by the motor's operation.

Compare this bitfield to the bitmasks in pros::motor_flag_e_t.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Faults: " << motor.get_faults();
    pros::delay(2);
  }
}

double get_position(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the absolute position of the motor in its encoder units.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Position: " << motor.get_position();
    pros::delay(2);
  }
}

double get_power(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the power drawn by the motor in Watts.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Power: " << motor.get_power();
    pros::delay(2);
  }
}

std::int32_t get_raw_position(std::uint32_t*const timestamp, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the raw encoder count of the motor at a given timestamp.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  std::uint32_t now = pros::millis();
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Position: " << motor.get_raw_position(&now);
    pros::delay(2);
  }
}

double get_temperature(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the temperature of the motor in degrees Celsius.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Temperature: " << motor.get_temperature();
    pros::delay(2);
  }
}

double get_torque(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the torque generated by the motor in Newton Meters (Nm).

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Torque: " << motor.get_torque();
    pros::delay(2);
  }
}

std::int32_t get_voltage(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the voltage delivered to the motor in millivolts.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Voltage: " << motor.get_voltage();
    pros::delay(2);
  }
}

std::int32_t is_over_current(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Checks if the motor is drawing over its current limit.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Is the motor over its current limit?: " << motor.is_over_current();
    pros::delay(2);
  }
}

std::int32_t is_over_temp(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the temperature limit flag for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Is the motor over its temperature limit?: " << motor.is_over_temp();
    pros::delay(2);
  }
}

MotorBrake get_brake_mode(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the brake mode that was set for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::int32_t get_current_limit(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the current limit for the motor in mA.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  while (true) {
    std::cout << "Motor Current Limit: " << motor.get_current_limit();
    pros::delay(2);
  }
}

MotorUnits get_encoder_units(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the encoder units that were set for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1, E_MOTOR_GEARSET_06, E_MOTOR_ENCODER_COUNTS);
  std::cout << "Motor Encoder Units: " << motor.get_encoder_units();
}

MotorGears get_gearing(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the gearset that was set for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1, E_MOTOR_GEARSET_06, E_MOTOR_ENCODER_COUNTS);
  std::cout << "Motor Gearing: " << motor.get_gearing();
}

std::int32_t get_voltage_limit(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets the voltage limit set by the user.

Default value is 0V, which means that there is no software limitation imposed on the voltage.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  std::cout << "Motor Voltage Limit: " << motor.get_voltage_limit();
}

std::int32_t is_reversed(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Gets whether the motor is reversed or not.

This function uses the following values of errno when an error state is reached:

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  std::cout << "Is the motor reversed? " << motor.is_reversed();
  // Prints "0"
}

std::int32_t set_brake_mode(const MotorBrake mode, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of Motor_Brake to the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::int32_t set_brake_mode(const pros::motor_brake_mode_e_t mode, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of MotorBrake to the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::int32_t set_current_limit(const std::int32_t limit, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets the current limit for the motor in mA.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);

motor.set_current_limit(1000);
while (true) {
  motor = controller_get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
  // The motor will reduce its output at 1000 mA instead of the default 2500 mA
  pros::delay(2);
  }
}

std::int32_t set_encoder_units(const MotorUnits units, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of MotorUnits for the motor encoder.

Works with the C enum and the C++ enum class.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_encoder_units(E_MOTOR_ENCODER_DEGREES);
  std::cout << "Encoder Units: " << motor.get_encoder_units();
}

std::int32_t set_encoder_units(const pros::motor_encoder_units_e_t units, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of MotorUnits for the motor encoder.

Works with the C enum and the C++ enum class.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

• Example

  void initialize() {
    pros::Motor motor (1);
    motor.set_encoder_units(E_MOTOR_ENCODER_DEGREES);
    std::cout << "Encoder Units: " << motor.get_encoder_units();
  }

std::int32_t set_gearing(const MotorGears gearset, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of the gear cartridge (red, green, blue) for the motor.

Usable with the C++ enum class and the C enum.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_gearing(E_MOTOR_GEARSET_06);
  std::cout << "Gearset: " << motor.get_gearing();
}

std::int32_t set_gearing(const pros::motor_gearset_e_t gearset, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets one of the gear cartridge (red, green, blue) for the motor.

Usable with the C++ enum class and the C enum.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_gearing(E_MOTOR_GEARSET_06);
  std::cout << "Gearset: " << motor.get_gearing();
}

std::int32_t set_reversed(const bool reverse, const std::uint8_t index = 0) virtual

#include <pros/motors.hpp>

Sets the reverse flag for the motor.

This will invert its movements and the values returned for its position.

This function uses the following values of errno when an error state is reached:

EOVERFLOW - The index is non 0

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_reversed(true);
  std::cout << "Is this motor reversed? " << motor.is_reversed();
}

std::int32_t set_voltage_limit(const std::int32_t limit, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets the voltage limit for the motor in Volts.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);

  motor.set_voltage_limit(10000);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    // The motor will not output more than 10 V
    pros::delay(2);
  }
}

std::int32_t set_zero_position(const double position, const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets the position for the motor in its encoder units.

This will be the future reference point for the motor's "absolute" position.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100); // Moves 100 units forward
  motor.move_absolute(100, 100); // This does not cause a movement

  motor.set_zero_position(80);
  motor.move_absolute(100, 100); // Moves 80 units forward
}

std::int32_t tare_position(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

Sets the "absolute" zero position of the motor to its current position.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100); // Moves 100 units forward
  motor.move_absolute(100, 100); // This does not cause a movement

  motor.tare_position();
  motor.move_absolute(100, 100); // Moves 100 units forward
}

std::int8_t size(void) const virtual

#include <pros/motors.hpp>

Gets the number of motors.

static std::vector<Motor> get_all_devices()

#include <pros/motors.hpp>

Gets all motors.

Example

void opcontrol() {
  std::vector<Motor> motor_all = pros::Motor::get_all_devices();  // All motors that are connected
}

std::int8_t get_port(const std::uint8_t index = 0) const virtual

#include <pros/motors.hpp>

gets the port number of the motor

std::vector<double> get_target_position_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the target position set for the motor by the user.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100);
  std::cout << "Motor Target: " << motor.get_target_position_all()[0];
  // Prints 100
}

std::vector<std::int32_t> get_target_velocity_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the velocity commanded to the motor by the user.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor.move_velocity(master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y));
    std::cout << "Motor Velocity: " << motor.get_target_velocity_all()[0];
    // Prints the value of E_CONTROLLER_ANALOG_LEFT_Y
    pros::delay(2);
  }
}

std::vector<double> get_actual_velocity_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the actual velocity commanded of the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor.move_velocity(master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y));
    std::cout << "Motor Velocity: " << motor.get_actual_velocity_all()[0];
    // Prints the value of E_CONTROLLER_ANALOG_LEFT_Y
    pros::delay(2);
  }
}

std::vector<std::int32_t> get_current_draw_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the current drawn by the motor in mA.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Current Draw: " << motor.get_current_draw_all()[0];
    pros::delay(2);
  }
}

std::vector<std::int32_t> get_direction_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the direction of movement for the motor.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Direction: " << motor.get_direction_all()[0];
    pros::delay(2);
  }
}

std::vector<double> get_efficiency_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the efficiency of the motor in percent.

An efficiency of 100% means that the motor is moving electrically while drawing no electrical power, and an efficiency of 0% means that the motor is drawing power but not moving.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Efficiency: " << motor.get_efficiency();
    pros::delay(2);
  }
}

std::vector<std::uint32_t> get_faults_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the faults experienced by the motor.

Compare this bitfield to the bitmasks in pros::motor_fault_e_t.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Faults: " << motor.get_faults_all()[0];
       pros::delay(2);
  }
}

std::vector<std::uint32_t> get_flags_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the flags set by the motor's operation.

Compare this bitfield to the bitmasks in pros::motor_flag_e_t.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Faults: " << motor.get_faults_all()[0];
    pros::delay(2);
  }
}

std::vector<double> get_position_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the absolute position of the motor in its encoder units.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Position: " << motor.get_position_all()[0];
    pros::delay(2);
  }
}

std::vector<double> get_power_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the power drawn by the motor in Watts.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Power: " << motor.get_power_all()[0];
    pros::delay(2);
  }
}

std::vector<std::int32_t> get_raw_position_all(std::uint32_t*const timestamp) const virtual

#include <pros/motors.hpp>

Gets a vector of the raw encoder count of the motor at a given timestamp.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  std::uint32_t now = pros::millis();
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Position: " << motor.get_raw_position(&now);
    pros::delay(2);
  }
}

std::vector<double> get_temperature_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the temperature of the motor in degrees Celsius.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Temperature: " << motor.get_temperature_all()[0];
    pros::delay(2);
  }
}

std::vector<double> get_torque_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the torque generated by the motor in Newton Meters (Nm).

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Torque: " << motor.get_torque();
    pros::delay(2);
  }
}

std::vector<std::int32_t> get_voltage_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the voltage delivered to the motor in millivolts.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Motor Voltage: " << motor.get_voltage_all()[0];
    pros::delay(2);
  }
}

std::vector<std::int32_t> is_over_current_all(void) const virtual

#include <pros/motors.hpp>

Checks if the motor is drawing over its current limit.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Is the motor over its current limit?: " << motor.is_over_current_all()[0];
    pros::delay(2);
  }
}

std::vector<std::int32_t> is_over_temp_all(void) const virtual

#include <pros/motors.hpp>

Gets the temperature limit flag for the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    std::cout << "Is the motor over its temperature limit?: " << motor.is_over_temp_all();
    pros::delay(2);
  }
}

std::vector<MotorBrake> get_brake_mode_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the brake mode that was set for the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::vector<std::int32_t> get_current_limit_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the current limit for the motor in mA.

The default value is 2500 mA.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  while (true) {
    std::cout << "Motor Current Limit: " << motor.get_current_limit_all()[0];
    pros::delay(2);
  }
}

std::vector<MotorUnits> get_encoder_units_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the encoder units that were set for the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1, E_MOTOR_GEARSET_06, E_MOTOR_ENCODER_COUNTS);
  std::cout << "Motor Encoder Units: " << motor.get_encoder_units_all()[0];
}

std::vector<MotorGears> get_gearing_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containing the gearset that was set for the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1, E_MOTOR_GEARSET_06, E_MOTOR_ENCODER_COUNTS);
  std::cout << "Motor Gearing: " << motor.get_gearing_all()[0];
}

std::vector<std::int8_t> get_port_all(void) const virtual

#include <pros/motors.hpp>

Gets returns a vector with all the port numbers in the motor group.

std::vector<std::int32_t> get_voltage_limit_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector of the voltage limit set by the user.

Default value is 0V, which means that there is no software limitation imposed on the voltage.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  std::cout << "Motor Voltage Limit: " << motor.get_voltage_limit_all()[0];
}

std::vector<std::int32_t> is_reversed_all(void) const virtual

#include <pros/motors.hpp>

Gets a vector containg whether the motor is reversed or not.

Example

void initialize() {
  pros::Motor motor (1);
  std::cout << "Is the motor reversed? " << motor.is_reversed_all()[0];
  // Prints "0"
}

std::int32_t set_brake_mode_all(const MotorBrake mode) const virtual

#include <pros/motors.hpp>

Sets one of Motor_Brake to the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode_all(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::int32_t set_brake_mode_all(const pros::motor_brake_mode_e_t mode) const virtual

#include <pros/motors.hpp>

Sets one of Motor_Brake to the motor.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_brake_mode_all(pros::E_MOTOR_BRAKE_HOLD);
  std::cout << "Brake Mode: " << motor.get_brake_mode();
}

std::int32_t set_current_limit_all(const std::int32_t limit) const virtual

#include <pros/motors.hpp>

Sets the current limit for the motor in mA.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void opcontrol() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);

motor.set_current_limit_all(1000);
while (true) {
  motor = controller_get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
  // The motor will reduce its output at 1000 mA instead of the default 2500 mA
  pros::delay(2);
  }
}

std::int32_t set_encoder_units_all(const MotorUnits units) const virtual

#include <pros/motors.hpp>

Sets one of Motor_Units for the motor encoder.

Works with the C enum and the C++ enum class.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

• Example

  void initialize() {
    pros::Motor motor (1);
    motor.set_encoder_units_all(E_MOTOR_ENCODER_DEGREES);
    std::cout << "Encoder Units: " << motor.get_encoder_units();
  }

std::int32_t set_encoder_units_all(const pros::motor_encoder_units_e_t units) const virtual

#include <pros/motors.hpp>

Sets one of Motor_Units for the motor encoder.

Works with the C enum and the C++ enum class.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_encoder_units_all(E_MOTOR_ENCODER_DEGREES);
  std::cout << "Encoder Units: " << motor.get_encoder_units();
}

std::int32_t set_gearing_all(const MotorGears gearset) const virtual

#include <pros/motors.hpp>

Sets one of the gear cartridge (red, green, blue) for the motor.

Usable with the C++ enum class and the C enum.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_gearing_all(E_MOTOR_GEARSET_06);
  std::cout << "Gearset: " << motor.get_gearing();
}

std::int32_t set_gearing_all(const pros::motor_gearset_e_t gearset) const virtual

#include <pros/motors.hpp>

Sets one of the gear cartridge (red, green, blue) for the motor.

Usable with the C++ enum class and the C enum.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_gearing_all(E_MOTOR_GEARSET_06);
  std::cout << "Gearset: " << motor.get_gearing();
}

std::int32_t set_reversed_all(const bool reverse) virtual

#include <pros/motors.hpp>

Sets the reverse flag for the motor.

This will invert its movements and the values returned for its position.

Example

void initialize() {
  pros::Motor motor (1);
  motor.set_reversed_all(true);
  std::cout << "Is this motor reversed? " << motor.is_reversed();
}

std::int32_t set_voltage_limit_all(const std::int32_t limit) const virtual

#include <pros/motors.hpp>

Sets the voltage limit for the motor in Volts.

This function uses the following values of errno when an error state is reached:

ENODEV - The port cannot be configured as a motor

EOVERFLOW - The index is non 0

Example

void autonomous() {
  pros::Motor motor (1);
  pros::Controller master (E_CONTROLLER_MASTER);

  motor.set_voltage_limit_all(10000);
  while (true) {
    motor = master.get_analog(E_CONTROLLER_ANALOG_LEFT_Y);
    // The motor will not output more than 10 V
    pros::delay(2);
  }
}

std::int32_t set_zero_position_all(const double position) const virtual

#include <pros/motors.hpp>

Sets the position for the motor in its encoder units.

This will be the future reference point for the motor's "absolute" position.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100); // Moves 100 units forward
  motor.move_absolute(100, 100); // This does not cause a movement

  motor.set_zero_position_all(80);
  motor.move_absolute(100, 100); // Moves 80 units forward
}

std::int32_t tare_position_all(void) const virtual

#include <pros/motors.hpp>

Sets the "absolute" zero position of the motor to its current position.

This function uses the following values of errno when an error state is reached: ENODEV - The port cannot be configured as a motor

Example

void autonomous() {
  pros::Motor motor (1);
  motor.move_absolute(100, 100); // Moves 100 units forward
  motor.move_absolute(100, 100); // This does not cause a movement

  motor.tare_position_all();
  motor.move_absolute(100, 100); // Moves 100 units forward
}

std::int8_t _port

#include <pros/motors.hpp>

The port of the motor.

Negative ports indicate that the motor is reversed