ADI (TriPort) C++ API module

Port(std::uint8_t adi_port, adi_port_config_e_t type = E_ADI_TYPE_UNDEFINED) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a given sensor type.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define POTENTIOMETER_PORT 1
#define POTENTIOMETER_TYPE pros::E_ADI_POT_EDR

void opcontrol() {
  pros::ADIPotentiometer potentiometer (POTENTIOMETER_PORT, POTENTIOMETER_TYPE);
  while (true) {
    // Get the potentiometer angle
    std::cout << "Angle: " << potnetiometer.get_angle();
    pros::delay(10);
  }
}

Port(ext_adi_port_pair_t port_pair, adi_port_config_e_t type = E_ADI_TYPE_UNDEFINED) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi expander to act as a given sensor type.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define ANALOG_SENSOR_PORT 'a'
#define EXT_ADI_SMART_PORT 1

void initialize() {
  pros::adi::Port sensor ({{ EXT_ADI_SMART_PORT , ANALOG_SENSOR_PORT }}, E_ADI_ANALOG_IN);
  // Displays the value of E_ADI_ANALOG_IN
  std::cout << "Port Type: " << sensor.get_config();
}

std::int32_t get_config() const

#include <pros/adi.hpp>

Gets the configuration for the given ADI port.

Example

#define ANALOG_SENSOR_PORT 1
  void initialize() {
    adi_port_set_config(ANALOG_SENSOR_PORT, E_ADI_ANALOG_IN);
    // Displays the value of E_ADI_ANALOG_IN
    printf("Port Type: %d\n", adi_port_get_config(ANALOG_SENSOR_PORT));
  }

std::int32_t get_value() const

#include <pros/adi.hpp>

Gets the value for the given ADI port.

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  pros::adi::Port sensor (ANALOG_SENSOR_PORT, E_ADI_ANALOG_IN);
  std::cout << "Port Value: " << sensor.get_value();
}

std::int32_t set_config(adi_port_config_e_t type) const

#include <pros/adi.hpp>

Configures an ADI port to act as a given sensor type.

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  pros::adi::Port sensor (ANALOG_SENSOR_PORT, E_ADI_DIGITAL_IN);
  // Do things as a digital sensor
  // Digital is unplugged and an analog is plugged in
  sensor.set_config(E_ADI_ANALOG_IN);
}

std::int32_t set_value(std::int32_t value) const

#include <pros/adi.hpp>

Sets the value for the given ADI port.

This only works on ports configured as outputs, and the behavior will change depending on the configuration of the port.

Example

#define DIGITAL_SENSOR_PORT 1

void initialize() {
  pros::adi::Port sensor (DIGITAL_SENSOR_PORT, E_ADI_DIGITAL_OUT);
  sensor.set_value(DIGITAL_SENSOR_PORT, HIGH);
}

ext_adi_port_tuple_t get_port() const virtual

#include <pros/adi.hpp>

Gets the port of the sensor.

Example

#define DIGITAL_SENSOR_PORT 1 // 'A'

void initialize() {
  pros::adi::AnalogIn sensor (DIGITAL_SENSOR_PORT);
  
     // Getting values from the tuple using std::get<index> 
     int sensorSmartPort = std::get<0>(sensor.get_port()); // First value
  int sensorAdiPort = std::get<1>(sensor.get_port()); // Second value

     // Prints the first and second value from the port tuple (The Adi Port. The first value is the Smart Port)
  printf("Sensor Smart Port: %d\n", sensorSmartPort);
  printf("Sensor Adi Port: %d\n", sensorAdiPort);   
}

AnalogIn(std::uint8_t adi_port) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as an Analog Input.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  pros::ADIAnalogIn sensor (ANALOG_SENSOR_PORT);
  while (true) {
    // Use the sensor
  }
}

AnalogIn(ext_adi_port_pair_t port_pair) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as an Analog Input.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define EXT_ADI_SENSOR_PORT 1
#define ADI_PORT 'a'

void opcontrol() {
  pros::ADIAnalogIn sensor ({{EXT_ADI_SMART_PORT, ADI_PORT}});
  while (true) {
    // Use the sensor
  }
}

std::int32_t calibrate() const

#include <pros/adi.hpp>

Calibrates the analog sensor on the specified port and returns the new calibration value.

This method assumes that the true sensor value is not actively changing at this time and computes an average from approximately 500 samples, 1 ms apart, for a 0.5 s period of calibration. The average value thus calculated is returned and stored for later calls to the pros::AnalogIn::get_value_calibrated() and pros::AnalogIn::get_value_calibrated_HR() functions. These functions will return the difference between this value and the current sensor value when called.

Do not use this function when the sensor value might be unstable (gyro rotation, accelerometer movement).

This function uses the following values of errno when an error state is reached: ENODEV - The port is not configured as an analog input

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  pros::adi::AnalogIn sensor (ANALOG_SENSOR_PORT);
  sensor.calibrate(ANALOG_SENSOR_PORT);
  std::cout << "Calibrated Reading:" << sensor.get_value_calibrated();
  // All readings from then on will be calibrated
}

std::int32_t get_value_calibrated() const

#include <pros/adi.hpp>

Gets the 12 bit calibrated value of an analog input port.

The pros::adi::AnalogIn::calibrate() function must be run first. This function is inappropriate for sensor values intended for integration, as round-off error can accumulate causing drift over time. Use pros::adi::AnalogIn::get_value_calibrated_HR() instead.

This function uses the following values of errno when an error state is reached: ENODEV - The port is not configured as an analog input

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  pros::adi::AnalogIn sensor (ANALOG_SENSOR_PORT);
  sensor.calibrate(ANALOG_SENSOR_PORT);
  std::cout << "Calibrated Reading:" << sensor.get_value_calibrated();
  // All readings from then on will be calibrated
}

std::int32_t get_value_calibrated_HR() const

#include <pros/adi.hpp>

Gets the 16 bit calibrated value of an analog input port.

The pros::adi::AnalogIn::calibrate() function must be run first. This is intended for integrated sensor values such as gyros and accelerometers to reduce drift due to round-off, and should not be used on a sensor such as a line tracker or potentiometer.

The value returned actually has 16 bits of "precision", even though the ADC only reads 12 bits, so that error induced by the average value being between two values when integrated over time is trivial. Think of the value as the true value times 16.

This function uses the following values of errno when an error state is reached: ENODEV - The port is not configured as an analog input

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  pros::adi::AnalogIn sensor (ANALOG_SENSOR_PORT);
  sensor.calibrate(ANALOG_SENSOR_PORT);
  std::cout << "Calibrated Reading:" << sensor.get_value_calibrated();
  // All readings from then on will be calibrated
}

AnalogOut(std::uint8_t adi_port) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as an Analog Output.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  pros::AnalogOut sensor (ANALOG_SENSOR_PORT);
  // Use the sensor
}

AnalogOut(ext_adi_port_pair_t port_pair) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi_expander to act as an Analog Output.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define EXT_ADI_SMART_PORT 1
#define ADI_PORT 'a'

void opcontrol() {
  pros::AnalogOut sensor ({{EXT_ADI_SMART_PORT, ADI_PORT}});
  // Use the sensor
}

DigitalOut(std::uint8_t adi_port, bool init_state = LOW) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a Digital Output.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

    #define DIGITAL_SENSOR_PORT 1

void opcontrol() {
  bool state = LOW;
  pros::adi::DigitalOut sensor (DIGITAL_SENSOR_PORT, state);
  while (true) {
    state != state;
    sensor.set_value(state);
    pros::delay(10); // toggle the sensor value every 50ms
  }
}

DigitalOut(ext_adi_port_pair_t port_pair, bool init_state = LOW) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi_expander to act as a Digital Output.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define EXT_ADI_SMART_PORT 1
#define ADI_PORT 'a'

void opcontrol() {
  bool state = LOW;
  pros::adi::DigitalOut sensor ( {{ EXT_ADI_SMART_PORT , ADI_PORT }});
  while (true) {
    state != state;
    sensor.set_value(state);
    pros::delay(10); // toggle the sensor value every 50ms
  }
}

DigitalIn(std::uint8_t adi_port) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a Digital Input.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define DIGITAL_SENSOR_PORT 1

void opcontrol() {
  pros::adi::DigitalIn sensor (ANALOG_SENSOR_PORT);
  // Use the sensor
}

DigitalIn(ext_adi_port_pair_t port_pair) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi_expander to act as a Digital Input.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define EXT_ADI_SMART_PORT 1
#define ADI_PORT 'a'

void opcontrol() {
  pros::adi::DigitalIn sensor ({{EXT_ADI_SMART_PORT, ADI_PORT}});
  // Use the sensor
}

std::int32_t get_new_press() const

#include <pros/adi.hpp>

Gets a rising-edge case for a digital button press.

This function is not thread-safe. Multiple tasks polling a single button may return different results under the same circumstances, so only one task should call this function for any given button. E.g., Task A calls this function for buttons 1 and 2. Task B may call this function for button 3, but should not for buttons 1 or 2. A typical use-case for this function is to call inside opcontrol to detect new button presses, and not in any other tasks.

This function uses the following values of errno when an error state is reached: ENODEV - The port is not configured as a digital input

Example

#define DIGITAL_SENSOR_PORT 1

void opcontrol() {
  pros::adi::DigitalIn sensor (DIGITAL_SENSOR_PORT);
  while (true) {
    if (sensor.get_new_press()) {
      // Toggle pneumatics or other state operations
    }
  pros::delay(10);
  }
}

Motor(std::uint8_t adi_port) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a Motor.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define MOTOR_PORT 1

void opcontrol() {
  pros::adi::Motor motor (MOTOR_PORT);
  motor.set_value(127); // Go full speed forward
  std::cout << "Commanded Motor Power: " << motor.get_value(); // Will display 127
  delay(1000);
  motor.set_value(0); // Stop the motor
}

Motor(ext_adi_port_pair_t port_pair) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi_expander to act as a Motor.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define EXT_ADI_SMART_PORT 1
#define ADI_MOTOR_PORT 'a'

void opcontrol() {
  pros::adi::Motor motor ( {{ EXT_ADI_SMART_PORT ,  ADI_MOTOR_PORT}} );
  motor.set_value(127); // Go full speed forward
  std::cout << "Commanded Motor Power: " << motor.get_value(); // Will display 127
  delay(1000);
  motor.set_value(0); // Stop the motor
}

std::int32_t stop() const

#include <pros/adi.hpp>

Stops the motor on the given port.

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

Example

#define MOTOR_PORT 1

void opcontrol() {
  pros::adi::Motor motor (MOTOR_PORT);
  motor.set_value(127); // Go full speed forward
  std::cout << "Commanded Motor Power: " << motor.get_value(); // Will display 127
  delay(1000);
  motor.stop(); // Stop the motor
}

Encoder(std::uint8_t adi_port_top, std::uint8_t adi_port_bottom, bool reversed = false) explicit

#include <pros/adi.hpp>

Configures a set of ADI ports to act as an Encoder.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  pros::adi::Encoder sensor (PORT_TOP, PORT_BOTTOM, false);
  // Use the sensor
}

Encoder(ext_adi_port_tuple_t port_tuple, bool reversed = false) explicit

#include <pros/adi.hpp>

Configures a set of ADI ports on an adi_expander to act as an Encoder.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define PORT_TOP 'A'
#define PORT_BOTTOM 'B'
#define SMART_PORT 1

void opcontrol() {
  pros::adi::Encoder sensor ({ SMART_PORT, PORT_TOP, PORT_BOTTOM }, false);
  // Use the sensor
}

std::int32_t reset() const

#include <pros/adi.hpp>

Sets the encoder value to zero.

It is safe to use this method while an encoder is enabled. It is not necessary to call this method before stopping or starting an encoder.

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

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  pros::adi::Encoder sensor (PORT_TOP, PORT_BOTTOM, false);
  delay(1000); // Move the encoder around in this time
  sensor.reset(); // The encoder is now zero again
}

std::int32_t get_value() const

#include <pros/adi.hpp>

Gets the number of ticks recorded by the encoder.

There are 360 ticks in one revolution.

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

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  pros::adi::Encoder sensor (PORT_TOP, PORT_BOTTOM, false);
  while (true) {
    std::cout << "Encoder Value: " << sensor.get_value();
    pros::delay(10);
  }
}

ext_adi_port_tuple_t get_port() const override

#include <pros/adi.hpp>

Gets the port of the sensor.

Example

#define DIGITAL_SENSOR_PORT 1 // 'A'

void initialize() {
  pros::adi::AnalogIn sensor (DIGITAL_SENSOR_PORT);
  
     // Getting values from the tuple using std::get<index> 
     int sensorSmartPort = std::get<0>(sensor.get_port()); // First value
  int sensorAdiPort = std::get<1>(sensor.get_port()); // Second value

     // Prints the first and second value from the port tuple (The Adi Port. The first value is the Smart Port)
  printf("Sensor Smart Port: %d\n", sensorSmartPort);
  printf("Sensor Adi Port: %d\n", sensorAdiPort);   
}

Ultrasonic(std::uint8_t adi_port_ping, std::uint8_t adi_port_echo) explicit

#include <pros/adi.hpp>

Configures a set of ADI ports to act as an Ultrasonic sensor.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define PORT_PING 1
#define PORT_ECHO 2

void opcontrol() {
  pros::adi::Ultrasonic sensor (PORT_PING, PORT_ECHO);
  while (true) {
    // Print the distance read by the ultrasonic
    std::cout << "Distance: " << sensor.get_value();
    pros::delay(10);
  }
}

Ultrasonic(ext_adi_port_tuple_t port_tuple) explicit

#include <pros/adi.hpp>

Configures a set of ADI ports on an adi_expander to act as an Ultrasonic sensor.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define PORT_PING 'A'
#define PORT_ECHO 'B'
#define SMART_PORT 1

void opcontrol() {
  pros::adi::Ultrasonic sensor ( {{ SMART_PORT, PORT_PING, PORT_ECHO }} );
  while (true) {
    // Print the distance read by the ultrasonic
    std::cout << "Distance: " << sensor.get_value();
    pros::delay(10);
  }
}

std::int32_t get_value() const

#include <pros/adi.hpp>

Gets the current ultrasonic sensor value in centimeters.

If no object was found, zero is returned. If the ultrasonic sensor was never started, the return value is undefined. Round and fluffy objects can cause inaccurate values to be returned.

This function uses the following values of errno when an error state is reached: ENODEV - The port is not configured as an ultrasonic

Example

#define PORT_PING 1
#define PORT_ECHO 2

void opcontrol() {
  pros::adi::Ultrasonic sensor (PORT_PING, PORT_ECHO);
  while (true) {
    // Print the distance read by the ultrasonic
    std::cout << "Distance: " << sensor.get_value();
    pros::delay(10);
  }
}

Gyro(std::uint8_t adi_port, double multiplier = 1) explicit

#include <pros/adi.hpp>

Initializes a gyroscope on the given port.

If the given port has not previously been configured as a gyro, then this function starts a 1300ms calibration period.

It is highly recommended that an Gyro object be created in initialize() when the robot is stationary to ensure proper calibration. If an Gyro object is declared at the global scope, a hardcoded 1300ms delay at the beginning of initialize will be necessary to ensure that the gyro's returned values are correct at the beginning of autonomous/opcontrol.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define GYRO_PORT 1

void opcontrol() {
  pros::adi::Gyro gyro (GYRO_PORT);
  while (true) {
    // Get the gyro heading
    std::cout << "Distance: " << gyro.get_value();
    pros::delay(10);
  }
}

Gyro(ext_adi_port_pair_t port_pair, double multiplier = 1) explicit

#include <pros/adi.hpp>

Initializes a gyroscope on the given port of an adi expander.

If the given port has not previously been configured as a gyro, then this function starts a 1300ms calibration period.

It is highly recommended that an adi::Gyro object be created in initialize() when the robot is stationary to ensure proper calibration. If an adi::Gyro object is declared at the global scope, a hardcoded 1300ms delay at the beginning of initialize will be necessary to ensure that the gyro's returned values are correct at the beginning of autonomous/opcontrol.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define ADI_GYRO_PORT 'a'
#define SMART_PORT 1

void opcontrol() {
  pros::adi::Gyro gyro ({{ SMART_PORT , ADI_GYRO_PORT }});
  while (true) {
    // Get the gyro heading
  std::cout << "Distance: " << gyro.get_value();
  pros::delay(10);
  }
}

double get_value() const

#include <pros/adi.hpp>

Gets the current gyro angle in tenths of a degree.

Unless a multiplier is applied to the gyro, the return value will be a whole number representing the number of degrees of rotation times 10.

There are 360 degrees in a circle, thus the gyro will return 3600 for one whole rotation.

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

Example

#define GYRO_PORT 1

void opcontrol() {
  pros::adi::Gyro gyro (GYRO_PORT);
  while (true) {
  // Get the gyro heading
  std::cout << "Distance: " << gyro.get_value();
  pros::delay(10);
  }
}

std::int32_t reset() const

#include <pros/adi.hpp>

Resets the gyroscope value to zero.

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

Example

#define GYRO_PORT 1

void opcontrol() {
  pros::adi::Gyro gyro (GYRO_PORT);
  std::uint32_t now = pros::millis();
  while (true) {
    // Get the gyro heading
    std::cout << "Distance: " << gyro.get_value();

  if (pros::millis() - now > 2000) {
    // Reset the gyro every 2 seconds
    gyro.reset();
    now = pros::millis();
  }

  pros::delay(10);
  }
}

Potentiometer(std::uint8_t adi_port, adi_potentiometer_type_e_t potentiometer_type = E_ADI_POT_EDR) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a Potentiometer.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define POTENTIOMETER_PORT 1
#define POTENTIOMETER_TYPE pros::E_ADI_POT_EDR

void opcontrol() {
  pros::adi::Potentiometer potentiometer (POTENTIOMETER_PORT, POTENTIOMETER_TYPE);
  while (true) {
    // Get the potentiometer angle
    std::cout << "Angle: " << potentiometer.get_angle();
    pros::delay(10);
  }
}

Potentiometer(ext_adi_port_pair_t port_pair, adi_potentiometer_type_e_t potentiometer_type = E_ADI_POT_EDR) explicit

#include <pros/adi.hpp>

Configures an ADI port on an adi_expander to act as a Potentiometer.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example

#define ADI_POTENTIOMETER_PORT 'a'
#define SMART_PORT 1

void opcontrol() {
  pros::adi::Potentiometer potentiometer ({{ SMART_PORT , ADI_POTENTIOMETER_PORT }});
  while (true) {
    // Get the potentiometer angle
    std::cout << "Angle: " << potentiometer.get_angle();
    pros::delay(10);
  }
}

double get_angle() const

#include <pros/adi.hpp>

Gets the current potentiometer angle in tenths of a degree.

The original potentiometer rotates 250 degrees thus returning an angle between 0-250 degrees. Potentiometer V2 rotates 330 degrees thus returning an angle between 0-330 degrees.

This function uses the following values of errno when an error state is reached: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as a potentiometer

Example

#define ADI_POTENTIOMETER_PORT 'a'
#define SMART_PORT 1

void opcontrol() {
  pros::adi::Potentiometer potentiometer ({{ SMART_PORT , ADI_POTENTIOMETER_PORT }});
  while (true) {
    // Get the potentiometer angle
    std::cout << "Angle: " << potentiometer.get_angle();
    pros::delay(10);
  }
}

Led(std::uint8_t adi_port, std::uint32_t length) explicit

#include <pros/adi.hpp>

Configures an ADI port to act as a LED.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
      // Set entire LED strip to red
    led.set_all(0xFF0000);
      pros::delay(20);
    }
}

Led(ext_adi_port_pair_t port_pair, std::uint32_t length) explicit

#include <pros/adi.hpp>

Configures an ADI port on a adi_expander to act as a LED.

This function uses the following values of errno when an error state is reached: ENXIO - Either the ADI port value or the smart port value is not within its valid range (ADI port: 1-8, 'a'-'h', or 'A'-'H'; smart port: 1-21).

Example:

#define LED_PORT 'a'
#define SMART_PORT 1
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led ({{ SMART_PORT , LED_PORT }}, LED_LENGTH);
  while (true) {
    // Set entire LED strip to red
    led.set_all(0xFF0000);
       pros::delay(20);
  }
}

std::int32_t clear_all()

#include <pros/adi.hpp>

Operator overload to access the buffer in the ADILed class, it is recommended that you call .update(); after doing any operations with this.

Example:

   #define LED_PORT 'a'
   #define LED_LENGTH 3
   
   void opcontrol() {
     pros::Led led (LED_PORT, LED_LENGTH);
     while (true) {
       // Set the first 3 pixels to red, green, and blue
       led.set_pixel(0xFF0000, 0);
       led.set_pixel(0x00FF00, 1);
       led.set_pixel(0x0000FF, 2);
       pros::delay(20);
   
       // Use the [] operator to set the first pixel to black
       led.operator[](0) = 0x000000;
       led.update();
       pros::delay(20);
     }
   }
  /
std::uint32_t& operator[] (size_t i);

/**
 * @brief Clear the entire led strip of color
 *
 * This function uses the following values of errno when an error state is
 * reached:
 * ENXIO - The given value is not within the range of ADI Ports
 * EINVAL - A parameter is out of bounds/incorrect
 * EADDRINUSE - The port is not configured for ADI output
 *
 * @return PROS_SUCCESS if successful, PROS_ERR if not
 *
 * \b Example:
 * \code
 * #define LED_PORT 'a'
 * #define LED_LENGTH 3
 *
 * void opcontrol() {
 *   pros::Led led (LED_PORT, LED_LENGTH);
 *   while (true) {
 *     // Set the first 3 pixels to red, green, and blue
 *     led.set_pixel(0xFF0000, 0);
 *     led.set_pixel(0x00FF00, 1);
 *     led.set_pixel(0x0000FF, 2);
 *     pros::delay(20);
 *
 *     // Clear the led strip of color
 *     led.clear();
 *     pros::delay(20);
 *  }
 * }
 * 

std::int32_t clear()

#include <pros/adi.hpp>

std::int32_t update() const

#include <pros/adi.hpp>

Force the LED strip to update with the current buffered values, this should be called after any changes to the buffer using the [] operator.

This function uses the following values of errno when an error state is reached: EINVAL - A parameter is out of bounds/incorrect EADDRINUSE - The port is not configured for ADI output

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
       // Set the first 3 pixels to red, green, and blue
       led.set_pixel(0xFF0000, 0);
       led.set_pixel(0x00FF00, 1);
       led.set_pixel(0x0000FF, 2);
       pros::delay(20);

       // Use the [] operator to set the first pixel to black
       led.operator[](0) = 0x000000;
     // Update the led strip with the new values
       led.update();
       pros::delay(20);
  }
}

std::int32_t set_all(uint32_t color)

#include <pros/adi.hpp>

Set the entire led strip to one color.

This function uses the following values of errno when an error state is reached: EINVAL - A parameter is out of bounds/incorrect EADDRINUSE - The port is not configured for ADI output

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
       // Set the entire led strip to blue
       led.set_all(0x0000FF);
       pros::delay(20);
     }
}

std::int32_t set_pixel(uint32_t color, uint32_t pixel_position)

#include <pros/adi.hpp>

Set one pixel on the led strip.

This function uses the following values of errno when an error state is reached: EINVAL - A parameter is out of bounds/incorrect EADDRINUSE - The port is not configured for ADI output

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
       // Set the first pixel to blue
       led.set_pixel(0x0000FF, 0);
       pros::delay(20);
     }
}

std::int32_t clear_pixel(uint32_t pixel_position)

#include <pros/adi.hpp>

Clear one pixel on the led strip.

This function uses the following values of errno when an error state is reached: EINVAL - A parameter is out of bounds/incorrect EADDRINUSE - The port is not configured for ADI output

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
       // Set the first pixel to blue
       led.set_pixel(0x0000FF, 0);
       pros::delay(20);

       // Clear the first pixel
       led.clear_pixel(0);
       pros::delay(20);
    }
}

std::int32_t length()

#include <pros/adi.hpp>

Get the length of the led strip.

This function uses the following values of errno when an error state is reached: EINVAL - A parameter is out of bounds/incorrect EADDRINUSE - The port is not configured for ADI output

Example:

#define LED_PORT 'a'
#define LED_LENGTH 3

void opcontrol() {
  pros::Led led (LED_PORT, LED_LENGTH);
  while (true) {
       // Get the length of the led strip
       int length = led.length();
       pros::lcd::print(1, "Length: %d", length);
       pros::delay(20);
     }
}

Pneumatics(std::uint8_t adi_port, bool start_extended, bool extended_is_low = false) explicit

#include <pros/adi.hpp>

Creates a Pneumatics object for the given port.

This function uses the following values of errno when an error state is reached: ENXIO - The given value is not within the range of ADI Ports

/b Example:

void opcontrol() {
     pros::adi::Pneumatics left_piston('a', false);         // Starts retracted, extends when the ADI port is high
  pros::adi::Pneumatics right_piston('b', false, true); // Starts retracted, extends when the ADI port is low 
  
  pros::Controller master(pros::E_CONTROLLER_MASTER);

  while (true) {
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_L1)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_L2)) {
      left_piston.retract();
    }
    
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_R1)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_2)) {
      left_piston.retract();
    }

    pros::delay(10);
  }

Pneumatics(ext_adi_port_pair_t port_pair, bool start_extended, bool extended_is_low = false) explicit

#include <pros/adi.hpp>

Creates a Pneumatics object for the given port pair.

This function uses the following values of errno when an error state is reached: ENXIO - The given value is not within the range of ADI Ports

/b Example:

void opcontrol() {
     pros::adi::Pneumatics left_piston({1, 'a'}, false);            // Starts retracted, extends when the ADI port is high
  pros::adi::Pneumatics right_piston({1, 'b'}, false, true);        // Starts retracted, extends when the ADI port is low 
  
  pros::Controller master(pros::E_CONTROLLER_MASTER);

  while (true) {
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_L1)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_L2)) {
      left_piston.retract();
    }
    
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_R1)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_R2)) {
      left_piston.retract();
    }

    pros::delay(10);
  }
}

std::int32_t extend()

#include <pros/adi.hpp>

Extends the piston, if not already extended.

Example:

void opcontrol() {
     pros::adi::Pneumatics piston({1, 'a'}, false);            // Starts retracted, extends when the ADI port is high
  
  pros::Controller master(pros::E_CONTROLLER_MASTER);

  while (true) {
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_X)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_B)) {
      left_piston.retract();
    }
    if(mastetr.get_digital(pros::E_CONTROLLER_DIGITAL_A)) {
      left_piston.toggle();
    }

    pros::delay(10);
  }
}

std::int32_t retract()

#include <pros/adi.hpp>

Retracts the piston, if not already retracted.

Example:

void opcontrol() {
     pros::adi::Pneumatics piston({1, 'a'}, false);            // Starts retracted, extends when the ADI port is high
  
  pros::Controller master(pros::E_CONTROLLER_MASTER);

  while (true) {
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_X)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_B)) {
      left_piston.retract();
    }
    if(mastetr.get_digital(pros::E_CONTROLLER_DIGITAL_A)) {
      left_piston.toggle();
    }

    pros::delay(10);
  }
}

std::int32_t toggle()

#include <pros/adi.hpp>

Puts the piston into the opposite state of its current state.

If it is retracted, it will extend. If it is extended, it will retract.

Example:

void opcontrol() {
    pros::adi::Pneumatics piston({1, 'a'}, false);            // Starts retracted, extends when the ADI port is high
  
  pros::Controller master(pros::E_CONTROLLER_MASTER);

  while (true) {
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_X)) {
      left_piston.extend();
    }
    if(master.get_digital(pros::E_CONTROLLER_DIGITAL_B)) {
      left_piston.retract();
    }
    if(mastetr.get_digital(pros::E_CONTROLLER_DIGITAL_A)) {
      left_piston.toggle();
    }

    pros::delay(10);
  }
}

bool is_extended() const

#include <pros/adi.hpp>

Returns whether the piston is extended or not.

Example

#define ADI_PNEUMATICS_PORT 'a'

void opcontrol() {
  pros::adi::Pneumatics pneumatics (ADI_PNEUMATICS_PORT);
  while (true) {
    // Check if the piston is extended
    if (pneumatics.is_extended()) {
      printf("The pneumatic is extended\n");
    }
    else {
      printf("The pneumatic is not extended\n");
    }

    pros::delay(10);
  }
}

std::uint8_t _smart_port

#include <pros/adi.hpp>

std::uint8_t _adi_port

#include <pros/adi.hpp>

ext_adi_port_pair_t _port_pair

#include <pros/adi.hpp>

std::vector<uint32_t> _buffer

#include <pros/adi.hpp>

bool state

#include <pros/adi.hpp>

bool extended_is_low

#include <pros/adi.hpp>