ADI (TriPort) C API module

adi_port_config_e_t adi_port_get_config(uint8_t port)

#include <pros/adi.h>

Gets the configuration for the given ADI 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.

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));
}

int32_t adi_port_get_value(uint8_t port)

#include <pros/adi.h>

Gets the value for the given ADI 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.

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  adi_port_set_config(ANALOG_SENSOR_PORT, E_ADI_ANALOG_IN);
  printf("Port Value: %d\n", adi_get_value(ANALOG_SENSOR_PORT));
}

int32_t adi_port_set_config(uint8_t port, adi_port_config_e_t type)

#include <pros/adi.h>

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 - The given value is not within the range of ADI Ports.

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  adi_port_set_config(ANALOG_SENSOR_PORT, E_ADI_ANALOG_IN);
}

int32_t adi_port_set_value(uint8_t port, int32_t value)

#include <pros/adi.h>

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.

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.

Example

#define DIGITAL_SENSOR_PORT 1

void initialize() {
  adi_port_set_config(DIGITAL_SENSOR_PORT, E_ADI_DIGITAL_OUT);
  adi_set_value(DIGITAL_SENSOR_PORT, HIGH);
}

int32_t adi_analog_calibrate(uint8_t port)

#include <pros/adi.h>

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 adi_analog_read_calibrated() and adi_analog_read_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: ENXIO - The given value is not within the range of ADI Ports

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  adi_analog_calibrate(ANALOG_SENSOR_PORT);
  printf("Calibrated Reading: %d\n", adi_analog_read_calibrated(ANALOG_SENSOR_PORT));
  // All readings from then on will be calibrated
}

int32_t adi_analog_read(uint8_t port)

#include <pros/adi.h>

Gets the 12-bit value of the specified port.

The value returned is undefined if the analog pin has been switched to a different mode.

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 an analog input

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  while (true) {
    printf("Sensor Reading: %d\n", adi_analog_read(ANALOG_SENSOR_PORT));
    delay(5);
  }
}

int32_t adi_analog_read_calibrated(uint8_t port)

#include <pros/adi.h>

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

The adi_analog_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 adi_analog_read_calibrated_HR() instead.

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 an analog input

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  while (true) {
    printf("Sensor Reading: %d\n", adi_analog_read_calibrated(ANALOG_SENSOR_PORT));
    delay(5);
  }
}

int32_t adi_analog_read_calibrated_HR(uint8_t port)

#include <pros/adi.h>

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

The adi_analog_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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as an analog input

Example

#define ANALOG_SENSOR_PORT 1

void opcontrol() {
  while (true) {
    adi_analog_calibrate(ANALOG_SENSOR_PORT);
    printf("Sensor Reading: %d\n", adi_analog_read_calibrated_HR(ANALOG_SENSOR_PORT));
    delay(5);
  }
}

int32_t adi_digital_read(uint8_t port)

#include <pros/adi.h>

Gets the digital value (1 or 0) of a port configured as a digital input.

If the port is configured as some other mode, the digital value which reflects the current state of the port is returned, which may or may not differ from the currently set value. The return value is undefined for ports configured as any mode other than a Digital Input.

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 digital input

Example

#define DIGITAL_SENSOR_PORT 1

void opcontrol() {
  while (true) {
    printf("Sensor Value: %d\n", adi_digital_read(DIGITAL_SENSOR_PORT));
    delay(5);
  }
}

int32_t adi_digital_get_new_press(uint8_t port)

#include <pros/adi.h>

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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as a digital input

Example

#define DIGITAL_SENSOR_PORT 1

void opcontrol() {
  while (true) {
    if (adi_digital_get_new_press(DIGITAL_SENSOR_PORT)) {
      // Toggle pneumatics or other state operations
    }
    delay(5);
  }
}

int32_t adi_digital_write(uint8_t port, bool value)

#include <pros/adi.h>

Sets the digital value (1 or 0) of a port configured as a digital output.

If the port is configured as some other mode, behavior is undefined.

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 digital output

Example

#define DIGITAL_SENSOR_PORT

void opcontrol() {
  bool state = LOW;
  while (true) {
    state != state;
    adi_digital_write(DIGITAL_SENSOR_PORT, state);
    delay(5); // toggle the sensor value every 50ms
  }
}

int32_t adi_pin_mode(uint8_t port, uint8_t mode)

#include <pros/adi.h>

Configures the port as an input or output with a variety of settings.

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

Example

#define ANALOG_SENSOR_PORT 1

void initialize() {
  adi_pin_mode(ANALOG_SENSOR_PORT, INPUT_ANALOG);
}

int32_t adi_motor_set(uint8_t port, int8_t speed)

#include <pros/adi.h>

Sets the speed of the motor on 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 EADDRINUSE - The port is not configured as an motor

Example

#define MOTOR_PORT 1

void opcontrol() {
  adi_motor_set(MOTOR_PORT, 127); // Go full speed forward
  delay(1000);
  adi_motor_set(MOTOR_PORT, 0); // Stop the motor
}

int32_t adi_motor_get(uint8_t port)

#include <pros/adi.h>

Gets the last set speed of the motor on 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 EADDRINUSE - The port is not configured as an motor

Example

#define MOTOR_PORT 1

void opcontrol() {
  adi_motor_set(MOTOR_PORT, 127); // Go full speed forward
  printf("Commanded Motor Power: %d\n", adi_motor_get(MOTOR_PORT)); // Will display 127
  delay(1000);
  adi_motor_set(MOTOR_PORT, 0); // Stop the motor
}

int32_t adi_motor_stop(uint8_t port)

#include <pros/adi.h>

Stops the motor on 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 EADDRINUSE - The port is not configured as an motor

Example

#define MOTOR_PORT 1

void opcontrol() {
  adi_motor_set(MOTOR_PORT, 127); // Go full speed forward
  delay(1000);
  // adi_motor_set(MOTOR_PORT, 0); // Stop the motor
  adi_motor_stop(MOTOR_PORT); // use this instead
}

int32_t adi_encoder_get(adi_encoder_t enc)

#include <pros/adi.h>

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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as an encoder

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  adi_encoder_t enc = adi_encoder_init(PORT_TOP, PORT_BOTTOM, false);
  while (true) {
  printf("Encoder Value: %d\n", adi_encoder_get(enc));
  delay(5);
  }
}

adi_encoder_t adi_encoder_init(uint8_t port_top, uint8_t port_bottom, bool reverse)

#include <pros/adi.h>

Creates an encoder object and configures the specified ports accordingly.

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 an encoder

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  adi_encoder_t enc = adi_encoder_init(PORT_TOP, PORT_BOTTOM, false);
  while (true) {
    printf("Encoder Value: %d\n", adi_encoder_get(enc));
    delay(5);
  }
}

int32_t adi_encoder_reset(adi_encoder_t enc)

#include <pros/adi.h>

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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as an encoder

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  adi_encoder_t enc = adi_encoder_init(PORT_TOP, PORT_BOTTOM, false);
  delay(1000); // Move the encoder around in this time
  adi_encoder_reset(enc); // The encoder is now zero again
}

int32_t adi_encoder_shutdown(adi_encoder_t enc)

#include <pros/adi.h>

Disables the encoder and voids the configuration on its ports.

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 an encoder

Example

#define PORT_TOP 1
#define PORT_BOTTOM 2

void opcontrol() {
  adi_encoder_t enc = adi_encoder_init(PORT_TOP, PORT_BOTTOM, false);
  // Use the encoder
  adi_encoder_shutdown(enc);
}

int32_t adi_ultrasonic_get(adi_ultrasonic_t ult)

#include <pros/adi.h>

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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as an ultrasonic

Example

#define PORT_PING 1
#define PORT_ECHO 2

void opcontrol() {
  adi_ultrasonic_t ult = adi_ultrasonic_init(PORT_PING, PORT_ECHO);
  while (true) {
    // Print the distance read by the ultrasonic
    printf("Distance: %d\n", adi_ultrasonic_get(ult));
    delay(5);
  }
}

adi_ultrasonic_t adi_ultrasonic_init(uint8_t port_ping, uint8_t port_echo)

#include <pros/adi.h>

Creates an ultrasonic object and configures the specified ports accordingly.

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 an ultrasonic

Example

#define PORT_PING 1
#define PORT_ECHO 2

void opcontrol() {
  adi_ultrasonic_t ult = adi_ultrasonic_init(PORT_PING, PORT_ECHO);
    while (true) {
    // Print the distance read by the ultrasonic
    printf("Distance: %d\n", adi_ultrasonic_get(ult));
    delay(5);
  }
}

int32_t adi_ultrasonic_shutdown(adi_ultrasonic_t ult)

#include <pros/adi.h>

Disables the ultrasonic sensor and voids the configuration on its ports.

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 an ultrasonic

Example

#define PORT_PING 1
#define PORT_ECHO 2

void opcontrol() {
  adi_ultrasonic_t ult = adi_ultrasonic_init(PORT_PING, PORT_ECHO);
  while (true) {
    // Print the distance read by the ultrasonic
    printf("Distance: %d\n", adi_ultrasonic_get(ult));
    delay(5);
  }
  adi_ultrasonic_shutdown(ult);
}

double adi_gyro_get(adi_gyro_t gyro)

#include <pros/adi.h>

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: ENXIO - The given value is not within the range of ADI Ports EADDRINUSE - The port is not configured as a gyro

Example

#define GYRO_PORT 1
#define GYRO_MULTIPLIER 1 // Standard behavior

void opcontrol() {
  adi_gyro_t gyro = adi_gyro_init(GYRO_PORT, GYRO_MULTIPLIER);
  while (true) {
    // Print the gyro's heading
    printf("Heading: %lf\n", adi_gyro_get(gyro));
    delay(5);
  }
}

adi_gyro_t adi_gyro_init(uint8_t port, double multiplier)

#include <pros/adi.h>

Initializes a gyroscope on the given port.

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

It is highly recommended that this function be called from initialize() when the robot is stationary to ensure proper calibration.

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 gyro

Example

#define GYRO_PORT 1
#define GYRO_MULTIPLIER 1 // Standard behavior

void opcontrol() {
  adi_gyro_t gyro = adi_gyro_init(GYRO_PORT, GYRO_MULTIPLIER);
  while (true) {
    // Print the gyro's heading
    printf("Heading: %lf\n", adi_gyro_get(gyro));
    delay(5);
  }
}

int32_t adi_gyro_reset(adi_gyro_t gyro)

#include <pros/adi.h>

Resets the gyroscope value to zero.

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 gyro

Example

#define GYRO_PORT 1
#define GYRO_MULTIPLIER 1 // Standard behavior

void opcontrol() {
  adi_gyro_t gyro = adi_gyro_init(GYRO_PORT, GYRO_MULTIPLIER);
  uint32_t now = millis();
  while (true) {
    // Print the gyro's heading
    printf("Heading: %lf\n", adi_gyro_get(gyro));

    if (millis() - now > 2000) {
      // Reset the gyro every 2 seconds
      adi_gyro_reset(gyro);
      now = millis();
    }

  delay(5);
  }
}

int32_t adi_gyro_shutdown(adi_gyro_t gyro)

#include <pros/adi.h>

Disables the gyro and voids the configuration on its 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 EADDRINUSE - The port is not configured as a gyro

Example

#define GYRO_PORT 1
#define GYRO_MULTIPLIER 1 // Standard behavior

void opcontrol() {
  adi_gyro_t gyro = adi_gyro_init(GYRO_PORT, GYRO_MULTIPLIER);
  uint32_t now = millis();
  while (true) {
    // Print the gyro's heading
    printf("Heading: %lf\n", adi_gyro_get(gyro));

    if (millis() - now > 2000) {
      adi_gyro_shutdown(gyro);
      // Shut down the gyro after two seconds
      break;
    }

    delay(5);
  }
}

adi_potentiometer_t adi_potentiometer_init(uint8_t port)

#include <pros/adi.h>

Initializes a potentiometer on the given port of the original potentiometer.

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 POTENTIOMETER_PORT 1

void opcontrol() {
  adi_potentiometer_t potentiometer = adi_potentiometer_init(POTENTIOMETER_PORT);
  while (true) {
    // Print the potentiometer's angle
    printf("Angle: %lf\n", adi_potentiometer_get_angle(potentiometer));
    delay(5);
  }
}

adi_potentiometer_t adi_potentiometer_type_init(uint8_t port, adi_potentiometer_type_e_t potentiometer_type)

#include <pros/adi.h>

Initializes a potentiometer on 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 EADDRINUSE - The port is not configured as a potentiometer

Example

#define POTENTIOMETER_PORT 1
#define POTENTIOMETER_TYPE E_ADI_POT_EDR

void opcontrol() {
  adi_potentiometer_t potentiometer = adi_potentiometer_type_init(POTENTIOMETER_PORT, POTENTIOMETER_TYPE);
  while (true) {
    // Print the potentiometer's angle
    printf("Angle: %lf\n", adi_potentiometer_get_angle(potentiometer));
    delay(5);
  }
}

double adi_potentiometer_get_angle(adi_potentiometer_t potentiometer)

#include <pros/adi.h>

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 POTENTIOMETER_PORT 1

void opcontrol() {
  adi_potentiometer_t potentiometer = adi_potentiometer_t(POTENTIOMETER_PORT);
  while (true) {
    // Print the potnetiometer's angle
    printf("Angle: %lf\n", adi_potentiometer_get_angle(potentiometer));
    delay(5);
  }
}

adi_led_t adi_led_init(uint8_t port)

#include <pros/adi.h>

Initializes a led on the given port of the original led.

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 - The ADI port given is not a valid port as defined below EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1
    
void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
  uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
    // Set the led to the colors in the buffer
    adi_led_set(led, buffer, 10);
    delay(5);
  }
}

int32_t adi_led_clear_all(adi_led_t led, uint32_t* buffer, uint32_t buffer_length)

#include <pros/adi.h>

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 given value is not correct, or the buffer is null EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1
    
void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
     uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
       // Set the led to the colors in the buffer
    adi_led_set(led, buffer, 10);
    delay(5);

    // Clear the led strip
    adi_led_clear(led);
    delay(5);
  }
}

int32_t adi_led_set(adi_led_t led, uint32_t* buffer, uint32_t buffer_length)

#include <pros/adi.h>

Set the entire led strip using the colors contained in the buffer.

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 given value is not correct, or the buffer is null EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1
    
void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
  uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
    // Set the led strip to the colors in the buffer
    adi_led_set(led, buffer, 10);
    delay(5);
  }
}

int32_t adi_led_set_all(adi_led_t led, uint32_t* buffer, uint32_t buffer_length, uint32_t color)

#include <pros/adi.h>

Set the entire led strip to one 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 given value is not correct, or the buffer is null EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1
    
void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
  uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
    // Set the led strip to red
    adi_led_set_all(led, buffer, 10, 0xFF0000);
    delay(5);
  }
}

int32_t adi_led_set_pixel(adi_led_t led, uint32_t* buffer, uint32_t buffer_length, uint32_t color, uint32_t pixel_position)

#include <pros/adi.h>

Set one pixel on the led strip.

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 given value is not correct, or the buffer is null EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1

void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
  uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
    // Set the first pixel to red
    adi_led_set_pixel(led, buffer, 10, 0xFF0000, 0);
    delay(5);
  }
}

int32_t adi_led_clear_pixel(adi_led_t led, uint32_t* buffer, uint32_t buffer_length, uint32_t pixel_position)

#include <pros/adi.h>

Clear one pixel on the led strip.

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 given value is not correct, or the buffer is null EADDRINUSE - The port is not configured for ADI output

Example

#define LED_PORT 1
    
void opcontrol() {
  adi_led_t led = adi_led_init(LED_PORT);
  uint32_t buffer[10] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x000000, 0x000000, 0x000000};
  while (true) {
    // Set the first pixel to red
    adi_led_set_pixel(led, buffer, 10, 0xFF0000, 0);
    delay(5);

    // Clear the first pixel
    adi_led_clear_pixel(led, buffer, 10, 0);
    delay(5);
  }
}

enum adi_port_config_e

#include <pros/adi.h>

Represents the port type for an ADI port.

enum adi_potentiometer_type_e

#include <pros/adi.h>

typedef int32_t adi_encoder_t

#include <pros/adi.h>

Reference type for an initialized encoder.

This merely contains the port number for the encoder.

typedef int32_t adi_ultrasonic_t

#include <pros/adi.h>

Reference type for an initialized ultrasonic.

This merely contains the port number for the ultrasonic.

typedef int32_t adi_gyro_t

#include <pros/adi.h>

Reference type for an initialized gyroscope.

This merely contains the port number for the gyroscope.

typedef int32_t adi_potentiometer_t

#include <pros/adi.h>

Reference type for an initialized potentiometer.

This merely contains the port number for the potentiometer.

typedef int32_t adi_led_t

#include <pros/adi.h>

Reference type for an initialized addressable led.

This merely contains the port number for the led, unlike its use as an object to store led data in the C++ API.

#define _DEPRECATE_DIGITAL_IN

#include <pros/adi.h>

#define _DEPRECATE_ANALOG_IN

#include <pros/adi.h>

#define INTERNAL_ADI_PORT

#include <pros/adi.h>

#define NUM_ADI_PORTS

#include <pros/adi.h>

#define HIGH

#include <pros/adi.h>

Used for adi_digital_write() to specify a logic HIGH state to output.

In reality, using any non-zero expression or "true" will work to set a pin to HIGH.

#define LOW

#include <pros/adi.h>

Used for adi_digital_write() to specify a logic LOW state to output.

In reality, using a zero expression or "false" will work to set a pin to LOW.

#define INPUT

#include <pros/adi.h>

adi_pin_mode() state for a digital input.

#define OUTPUT

#include <pros/adi.h>

adi_pin_mode() state for a digital output.

#define INPUT_ANALOG

#include <pros/adi.h>

adi_pin_mode() state for an analog input.

#define OUTPUT_ANALOG

#include <pros/adi.h>

adi_pin_mode() state for an analog output.