okapi namespace

Namespaces

namespace literals

Classes

class AbstractButton

class AbstractMotor

class AbstractRate

class AbstractTimer

class ADIButton

class ADIEncoder

class ADIGyro

class ADIMotor

class ADIUltrasonic

template<typename Input, typename Output>

class AsyncController

Closed-loop controller that steps on its own in another thread and automatically writes to the output.

class AsyncLinearMotionProfileController

class AsyncMotionProfileController

class AsyncMotionProfileControllerBuilder

class AsyncPosControllerBuilder

class AsyncPosIntegratedController

Closed-loop controller that uses the V5 motor's onboard control to move.

template<typename Input, typename Output>

class AsyncPositionController

class AsyncPosPIDController

class AsyncVelControllerBuilder

class AsyncVelIntegratedController

Closed-loop controller that uses the V5 motor's onboard control to move.

template<typename Input, typename Output>

class AsyncVelocityController

class AsyncVelPIDController

template<typename Input, typename Output>

class AsyncWrapper

template<std::size_t n>

class AverageFilter

A filter which returns the average of a list of values.

class ButtonBase

class ChassisController

class ChassisControllerBuilder

class ChassisControllerIntegrated

class ChassisControllerPID

class ChassisModel

A version of the ReadOnlyChassisModel that also supports write methods, such as setting motor speed.

class ChassisScales

template<typename Input, typename Output>

class ClosedLoopController

An abstract closed-loop controller.

class ComposableFilter

class ConfigurableTimeUtilFactory

A TimeUtilFactory that supplies the SettledUtil parameters passed in the constructor to every new TimeUtil instance.

class ContinuousRotarySensor

class Controller

class ControllerButton

template<typename T>

class ControllerInput

template<typename T>

class ControllerOutput

template<typename Input, typename Output>

class ControllerRunner

template<typename Input, typename Output>

class ControllerRunnerFactory

class ControllerUtil

struct DefaultLoggerInitializer

class DefaultOdomChassisController

class DemaFilter

class DistanceSensor

class EKFFilter

class EmaFilter

class Filter

template<typename InputType, typename FilterType>

class FilteredControllerInput

A ControllerInput with a filter built in.

class FlywheelSimulator

class HDriveModel

class IMU

class IntegratedEncoder

template<typename Input, typename Output>

class IterativeController

Closed-loop controller that steps iteratively using the step method below.

class IterativeControllerFactory

class IterativeMotorVelocityController

template<typename Input, typename Output>

class IterativePositionController

class IterativePosPIDController

template<typename Input, typename Output>

class IterativeVelocityController

class IterativeVelPIDController

class Logger

template<std::size_t n>

class MedianFilter

A filter which returns the median value of list of values.

class Motor

class MotorGroup

class OdomChassisController

class Odometry

class OdomMath

struct OdomState

class OffsetableControllerInput

class OpticalSensor

class PassthroughFilter

struct PathfinderLimits

struct PathfinderPoint

class PIDTuner

class PIDTunerFactory

struct Point

class Potentiometer

class Rate

class ReadOnlyChassisModel

A version of the ChassisModel that only supports read methods, such as querying sensor values.

class RotarySensor

class RotationSensor

template<typename MassDim, typename LengthDim, typename TimeDim, typename AngleDim>

class RQuantity

class SettledUtil

class SkidSteerModel

template<typename T>

class Supplier

A supplier of instances of T.

class ThreeEncoderOdometry

class ThreeEncoderSkidSteerModel

class ThreeEncoderXDriveModel

class Timer

class TimeUtil

Utility class for holding an AbstractTimer, AbstractRate, and SettledUtil together in one class since they are commonly used together.

class TimeUtilFactory

class TwoEncoderOdometry

class VelMath

class VelMathFactory

class XDriveModel

Enums

enum StateMode { FRAME_TRANSFORMATION, CARTESIAN }

The mode for the OdomState calculated by Odometry.

enum ControllerId { master = 0, partner = 1 }

Which controller role this has.

enum ControllerAnalog { leftX = 0, leftY = 1, rightX = 2, rightY = 3 }

The analog sticks.

enum ControllerDigital { L1 = 6, L2 = 7, R1 = 8, R2 = 9, up = 10, down = 11, left = 12, right = 13, X = 14, B = 15, Y = 16, A = 17 }

Various buttons.

enum OpticalSensorOutput { hue, saturation, brightness }

enum IMUAxes { z, y, x }

Functions

auto operator*(AbstractMotor::gearset gearset, double ratio) -> AbstractMotor::GearsetRatioPair

auto radian(1. 0) -> QAngle constexpr

static auto convertHertzToRadPerSec(QFrequency in) -> QAngularSpeed

auto Hz(1. 0) -> QFrequency constexpr

auto meter(1. 0) -> QLength constexpr

auto kg(1. 0) -> QMass constexpr

auto pascal(1. 0) -> QPressure constexpr

auto second(1. 0) -> QTime constexpr

auto number(1. 0) -> Number constexpr

template<typename M, typename L, typename T, typename A>

auto operator+(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto operator-(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M1, typename L1, typename T1, typename A1, typename M2, typename L2, typename T2, typename A2>

auto operator*(const RQuantity<M1, L1, T1, A1>& lhs, const RQuantity<M2, L2, T2, A2>& rhs) -> RQuantity<std::ratio_add<M1, M2>, std::ratio_add<L1, L2>, std::ratio_add<T1, T2>, std::ratio_add<A1, A2>> constexpr

template<typename M, typename L, typename T, typename A>

auto operator*(const double& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto operator*(const RQuantity<M, L, T, A>& lhs, const double& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M1, typename L1, typename T1, typename A1, typename M2, typename L2, typename T2, typename A2>

auto operator/(const RQuantity<M1, L1, T1, A1>& lhs, const RQuantity<M2, L2, T2, A2>& rhs) -> RQuantity<std::ratio_subtract<M1, M2>, std::ratio_subtract<L1, L2>, std::ratio_subtract<T1, T2>, std::ratio_subtract<A1, A2>> constexpr

template<typename M, typename L, typename T, typename A>

auto operator/(const double& x, const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio_subtract<std::ratio<0>, M>, std::ratio_subtract<std::ratio<0>, L>, std::ratio_subtract<std::ratio<0>, T>, std::ratio_subtract<std::ratio<0>, A>> constexpr

template<typename M, typename L, typename T, typename A>

auto operator/(const RQuantity<M, L, T, A>& rhs, const double& x) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto operator==(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto operator!=(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto operator<=(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto operator>=(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto operator<(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto operator>(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> bool constexpr

template<typename M, typename L, typename T, typename A>

auto abs(const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename R, typename M, typename L, typename T, typename A>

auto pow(const RQuantity<M, L, T, A>& lhs) -> RQuantity<std::ratio_multiply<M, R>, std::ratio_multiply<L, R>, std::ratio_multiply<T, R>, std::ratio_multiply<A, R>> constexpr

template<int R, typename M, typename L, typename T, typename A>

auto pow(const RQuantity<M, L, T, A>& lhs) -> RQuantity<std::ratio_multiply<M, std::ratio<R>>, std::ratio_multiply<L, std::ratio<R>>, std::ratio_multiply<T, std::ratio<R>>, std::ratio_multiply<A, std::ratio<R>>> constexpr

template<int R, typename M, typename L, typename T, typename A>

auto root(const RQuantity<M, L, T, A>& lhs) -> RQuantity<std::ratio_divide<M, std::ratio<R>>, std::ratio_divide<L, std::ratio<R>>, std::ratio_divide<T, std::ratio<R>>, std::ratio_divide<A, std::ratio<R>>> constexpr

template<typename M, typename L, typename T, typename A>

auto sqrt(const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio_divide<M, std::ratio<2>>, std::ratio_divide<L, std::ratio<2>>, std::ratio_divide<T, std::ratio<2>>, std::ratio_divide<A, std::ratio<2>>> constexpr

template<typename M, typename L, typename T, typename A>

auto cbrt(const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio_divide<M, std::ratio<3>>, std::ratio_divide<L, std::ratio<3>>, std::ratio_divide<T, std::ratio<3>>, std::ratio_divide<A, std::ratio<3>>> constexpr

template<typename M, typename L, typename T, typename A>

auto square(const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio_multiply<M, std::ratio<2>>, std::ratio_multiply<L, std::ratio<2>>, std::ratio_multiply<T, std::ratio<2>>, std::ratio_multiply<A, std::ratio<2>>> constexpr

template<typename M, typename L, typename T, typename A>

auto cube(const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio_multiply<M, std::ratio<3>>, std::ratio_multiply<L, std::ratio<3>>, std::ratio_multiply<T, std::ratio<3>>, std::ratio_multiply<A, std::ratio<3>>> constexpr

template<typename M, typename L, typename T, typename A>

auto hypot(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto mod(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M1, typename L1, typename T1, typename A1, typename M2, typename L2, typename T2, typename A2>

auto copysign(const RQuantity<M1, L1, T1, A1>& lhs, const RQuantity<M2, L2, T2, A2>& rhs) -> RQuantity<M1, L1, T1, A1> constexpr

template<typename M, typename L, typename T, typename A>

auto ceil(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto floor(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto trunc(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

template<typename M, typename L, typename T, typename A>

auto round(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<M, L, T, A> constexpr

auto sin(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto cos(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto tan(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto asin(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

auto acos(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

auto atan(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

auto sinh(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto cosh(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto tanh(const RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>>& rhs) -> Number constexpr

auto asinh(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

auto acosh(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

auto atanh(const Number& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

template<typename M, typename L, typename T, typename A>

auto atan2(const RQuantity<M, L, T, A>& lhs, const RQuantity<M, L, T, A>& rhs) -> RQuantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>> constexpr

template<class QType>

auto getShortUnitName(QType q) -> std::string

Returns a short name for a unit.

auto ipow(const double base, const int expo) -> double constexpr

Integer power function.

auto cutRange(const double value, const double min, const double max) -> double constexpr

Cuts out a range from the number.

auto deadband(const double value, const double min, const double max) -> double constexpr

Deadbands a range of the number.

auto remapRange(const double value, const double oldMin, const double oldMax, const double newMin, const double newMax) -> double constexpr

Remap a value in the range [oldMin, oldMax] to the range [newMin, newMax].

template<typename E>

auto toUnderlyingType(const E e) -> auto constexpr noexcept

Converts an enum to its value type.

auto boolToSign(const bool b) -> auto constexpr noexcept

Converts a bool to a sign.

auto modulus(const long lhs, const long rhs) -> long constexpr noexcept

Computes lhs mod rhs using Euclidean division.

auto gearsetToTPR(const AbstractMotor::gearset igearset) -> std::int32_t constexpr noexcept

Converts a gearset to its TPR.

auto transformADIPort(const std::int8_t port) -> std::int8_t constexpr

Variables

QAcceleration mps2 constexpr

QAcceleration G constexpr

QAngle degree constexpr

QAngularSpeed radps constexpr

QAngularSpeed rpm constexpr

QAngularSpeed cps constexpr

QArea kilometer2 constexpr

QArea meter2 constexpr

QArea decimeter2 constexpr

QArea centimeter2 constexpr

QArea millimeter2 constexpr

QArea inch2 constexpr

QArea foot2 constexpr

QArea mile2 constexpr

QForce newton constexpr

QForce poundforce constexpr

QForce kilopond constexpr

QLength decimeter constexpr

QLength centimeter constexpr

QLength millimeter constexpr

QLength kilometer constexpr

QLength inch constexpr

QLength foot constexpr

QLength yard constexpr

QLength mile constexpr

QLength tile constexpr

QMass gramme constexpr

QMass tonne constexpr

QMass ounce constexpr

QMass pound constexpr

QMass stone constexpr

QPressure bar constexpr

QPressure psi constexpr

QSpeed mps constexpr

QSpeed miph constexpr

QSpeed kmph constexpr

QTime millisecond constexpr

QTime minute constexpr

QTime hour constexpr

QTime day constexpr

QTorque newtonMeter constexpr

QTorque footPound constexpr

QTorque inchPound constexpr

QVolume kilometer3 constexpr

QVolume meter3 constexpr

QVolume decimeter3 constexpr

QVolume centimeter3 constexpr

QVolume millimeter3 constexpr

QVolume inch3 constexpr

QVolume foot3 constexpr

QVolume mile3 constexpr

QVolume litre constexpr

std::shared_ptr<Logger> defaultLogger

static DefaultLoggerInitializer defaultLoggerInitializer

static double inchToMM constexpr

Converts inches to millimeters.

static double mmToInch constexpr

Converts millimeters to inches.

static double degreeToRadian constexpr

Converts degrees to radians.

static double radianToDegree constexpr

Converts radians to degrees.

static double imeTorqueTPR constexpr

The ticks per rotation of the 393 IME with torque gearing.

static std::int32_t imeSpeedTPR constexpr

The ticks per rotation of the 393 IME with speed gearing.

static double imeTurboTPR constexpr

The ticks per rotation of the 393 IME with turbo gearing.

static double ime269TPR constexpr

The ticks per rotation of the 269 IME.

static std::int32_t imev5RedTPR constexpr

The ticks per rotation of the V5 motor with a red gearset.

static std::int32_t imev5GreenTPR constexpr

The ticks per rotation of the V5 motor with a green gearset.

static std::int32_t imev5BlueTPR constexpr

The ticks per rotation of the V5 motor with a blue gearset.

static std::int32_t quadEncoderTPR constexpr

The ticks per rotation of the red quadrature encoders.

static double pi constexpr

The value of pi.

static double pi2 constexpr

The value of pi divided by 2.

static double gravity constexpr

The conventional value of gravity of Earth.

static auto OKAPI_PROS_ERR constexpr

Same as PROS_ERR.

static auto OKAPI_PROS_ERR_F constexpr

Same as PROS_ERR_F.

static double v5MotorMaxVoltage constexpr

The maximum voltage that can be sent to V5 motors.

static std::int8_t motorUpdateRate constexpr

The polling frequency of V5 motors in milliseconds.

static std::int8_t adiUpdateRate constexpr

The polling frequency of the ADI ports in milliseconds.

Enum documentation

Function documentation

Variable documentation