Configs.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Cross The Road Electronics.  All rights reserved.
 * License information can be found in CTRE_LICENSE.txt
 * For support and suggestions contact support@ctr-electronics.com or file
 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
 */
#pragma once
 
#include "ctre/phoenix/StatusCodes.h"
#include "ctre/phoenixpro/Serializable.hpp"
#include "ctre/phoenixpro/networking/interfaces/ConfigSerializer.h"
#include "ctre/phoenixpro/signals/SpnEnums.hpp"
#include "ctre/phoenixpro/spns/SpnValue.hpp"
#include <sstream>
#include <string>
 
namespace ctre {
namespace phoenixpro {
namespace configs {
 
class ParentConfiguration : public ISerializable
{
public:
    virtual std::string ToString() const = 0;
    friend std::ostream &operator<<(std::ostream &str, const ParentConfiguration &v)
    {
        str << v.ToString();
        return str;
    }
    virtual ctre::phoenix::StatusCode Deserialize(const std::string &string) = 0;
};
 
 
/**
 * \brief  Configs that affect the magnet sensor and how to interpret
 *         it.
 *
 * \details  Includes sensor range and other configs related to
 *           sensor.
 */
class MagnetSensorConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Direction of the sensor to determine positive facing the LED
     * side of the CANcoder.
     *
     */
    signals::SensorDirectionValue SensorDirection = signals::SensorDirectionValue::CounterClockwise_Positive;
    /**
     * \brief This offset is added to the reported position, allowing the
     * application to trim the zero position.  When set to the default
     * value of zero, position reports zero when magnet north pole aligns
     * with the LED.
     *
     *  Minimum Value: -1
     *  Maximum Value: 1
     *  Default Value: 0
     *  Units: rotations
     */
    double MagnetOffset = 0;
    /**
     * \brief The range of the absolute sensor, either [0, 1) or [-0.5,
     * 0.5).
     *
     */
    signals::AbsoluteSensorRangeValue AbsoluteSensorRange = signals::AbsoluteSensorRangeValue::Unsigned_0To1;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: MagnetSensor" << std::endl;
        ss << "Name: \"SensorDirection\" Value: \"" << SensorDirection << "\"" << std::endl;
        ss << "Name: \"MagnetOffset\" Value: \"" << MagnetOffset << "rotations\"" << std::endl;
        ss << "Name: \"AbsoluteSensorRange\" Value: \"" << AbsoluteSensorRange << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_int(821, SensorDirection.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1003, MagnetOffset, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1004, AbsoluteSensorRange.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::CANcoder_SensorDirection, string_c_str, string_length, &SensorDirection.value);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::CANCoder_MagnetOffset, string_c_str, string_length, &MagnetOffset);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::CANcoder_AbsoluteSensorRange, string_c_str, string_length, &AbsoluteSensorRange.value);
        return 0;
    }
};
 
 
/**
 * \brief  Configs for Pigeon 2's Mount Pose configuration.
 *
 * \details  These configs allow the Pigeon2 to be mounted in whatever
 *           orientation that's desired and ensure the reported
 *           Yaw/Pitch/Roll is from the robot's reference.
 */
class MountPoseConfigs : public ParentConfiguration
{
public:
    /**
     * \brief The mounting calibration yaw-component
     *
     *  Minimum Value: -360
     *  Maximum Value: 360
     *  Default Value: 0
     *  Units: deg
     */
    double MountPoseYaw = 0;
    /**
     * \brief The mounting calibration pitch-component
     *
     *  Minimum Value: -360
     *  Maximum Value: 360
     *  Default Value: 0
     *  Units: deg
     */
    double MountPosePitch = 0;
    /**
     * \brief The mounting calibration roll-component
     *
     *  Minimum Value: -360
     *  Maximum Value: 360
     *  Default Value: 0
     *  Units: deg
     */
    double MountPoseRoll = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: MountPose" << std::endl;
        ss << "Name: \"MountPoseYaw\" Value: \"" << MountPoseYaw << "deg\"" << std::endl;
        ss << "Name: \"MountPosePitch\" Value: \"" << MountPosePitch << "deg\"" << std::endl;
        ss << "Name: \"MountPoseRoll\" Value: \"" << MountPoseRoll << "deg\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(952, MountPoseYaw, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(953, MountPosePitch, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(954, MountPoseRoll, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2MountPoseYaw, string_c_str, string_length, &MountPoseYaw);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2MountPosePitch, string_c_str, string_length, &MountPosePitch);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2MountPoseRoll, string_c_str, string_length, &MountPoseRoll);
        return 0;
    }
};
 
 
/**
 * \brief  Configs to trim the Pigeon2's gyroscope.
 *
 * \details  Pigeon2 allows the user to trim the gyroscope's
 *           sensitivity. While this isn't necessary for the Pigeon2,
 *           as it comes calibrated out-of-the-box, users can make use
 *           of this to make the Pigeon2 even more accurate for their
 *           application.
 */
class GyroTrimConfigs : public ParentConfiguration
{
public:
    /**
     * \brief The gyro scalar component for the X axis
     *
     *  Minimum Value: -180
     *  Maximum Value: 180
     *  Default Value: 0
     *  Units: deg per rotation
     */
    double GyroScalarX = 0;
    /**
     * \brief The gyro scalar component for the Y axis
     *
     *  Minimum Value: -180
     *  Maximum Value: 180
     *  Default Value: 0
     *  Units: deg per rotation
     */
    double GyroScalarY = 0;
    /**
     * \brief The gyro scalar component for the Z axis
     *
     *  Minimum Value: -180
     *  Maximum Value: 180
     *  Default Value: 0
     *  Units: deg per rotation
     */
    double GyroScalarZ = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: GyroTrim" << std::endl;
        ss << "Name: \"GyroScalarX\" Value: \"" << GyroScalarX << "deg per rotation\"" << std::endl;
        ss << "Name: \"GyroScalarY\" Value: \"" << GyroScalarY << "deg per rotation\"" << std::endl;
        ss << "Name: \"GyroScalarZ\" Value: \"" << GyroScalarZ << "deg per rotation\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(958, GyroScalarX, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(959, GyroScalarY, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(960, GyroScalarZ, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2GyroScalarX, string_c_str, string_length, &GyroScalarX);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2GyroScalarY, string_c_str, string_length, &GyroScalarY);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Pigeon2GyroScalarZ, string_c_str, string_length, &GyroScalarZ);
        return 0;
    }
};
 
 
/**
 * \brief  Configs to enable/disable various features of the Pigeon2.
 *
 * \details  These configs allow the user to enable or disable various
 *           aspects of the Pigeon2.
 */
class Pigeon2FeaturesConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Turns on or off the magnetometer fusing for 9-axis. FRC
     * users are not recommended to turn this on, as the magnetic
     * influence of the robot will likely negatively affect the
     * performance of the Pigeon2.
     *
     *  Default Value: False
     */
    bool EnableCompass = false;
    /**
     * \brief Disables using the temperature compensation feature
     *
     *  Default Value: False
     */
    bool DisableTemperatureCompensation = false;
    /**
     * \brief Disables using the no-motion calibration feature
     *
     *  Default Value: False
     */
    bool DisableNoMotionCalibration = false;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Pigeon2Features" << std::endl;
        ss << "Name: \"EnableCompass\" Value: \"" << EnableCompass << "\"" << std::endl;
        ss << "Name: \"DisableTemperatureCompensation\" Value: \"" << DisableTemperatureCompensation << "\"" << std::endl;
        ss << "Name: \"DisableNoMotionCalibration\" Value: \"" << DisableNoMotionCalibration << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_bool(910, EnableCompass, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(945, DisableTemperatureCompensation, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(947, DisableNoMotionCalibration, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Pigeon2UseCompass, string_c_str, string_length, &EnableCompass);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Pigeon2DisableTemperatureCompensation, string_c_str, string_length, &DisableTemperatureCompensation);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Pigeon2DisableNoMotionCalibration, string_c_str, string_length, &DisableNoMotionCalibration);
        return 0;
    }
};
 
 
/**
 * \brief  What the gains for slot 0 are
 *
 * \details  If this slot is selected, these gains are used in closed
 *           loop control requests.
 */
class Slot0Configs : public ParentConfiguration
{
public:
    /**
     * \brief Proportional Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input, the units
     * should be defined as units of output per unit of input error. For
     * example, when controlling velocity using a duty cycle closed loop,
     * the units for the proportional gain will be duty cycle per rps of
     * error, or 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kP = 0;
    /**
     * \brief Integral Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input integrated over
     * time (in units of seconds), the units should be defined as units of
     * output per unit of integrated input error. For example, when
     * controlling velocity using a duty cycle closed loop, integrating
     * velocity over time results in rps * s = rotations. Therefore, the
     * units for the integral gain will be duty cycle per rotation of
     * accumulated error, or 1/rot.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kI = 0;
    /**
     * \brief Derivative Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the derivative of error in the
     * input with respect to time (in units of seconds), the units should
     * be defined as units of output per unit of the differentiated input
     * error. For example, when controlling velocity using a duty cycle
     * closed loop, the derivative of velocity with respect to time is
     * rps/s, which is acceleration. Therefore, the units for the
     * derivative gain will be duty cycle per unit of acceleration error,
     * or 1/(rps/s).
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kD = 0;
    /**
     * \brief Velocity Feed Forward Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the requested velocity, the units
     * should be defined as units of output per unit of requested input
     * velocity. For example, when controlling velocity using a duty cycle
     * closed loop, the units for the velocity feed foward gain will be
     * duty cycle per requested rps, or 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kV = 0;
    /**
     * \brief Static Constant
     *
     * \details This is added to the closed loop output.  The sign is
     * determined by target velocity. The unit for this constant is
     * dependent on the control mode, typically fractional duty cycle,
     * voltage, or torque current.
     *
     *  Minimum Value: -512
     *  Maximum Value: 511
     *  Default Value: 0
     *  Units: 
     */
    double kS = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Slot0" << std::endl;
        ss << "Name: \"kP\" Value: \"" << kP << "\"" << std::endl;
        ss << "Name: \"kI\" Value: \"" << kI << "\"" << std::endl;
        ss << "Name: \"kD\" Value: \"" << kD << "\"" << std::endl;
        ss << "Name: \"kV\" Value: \"" << kV << "\"" << std::endl;
        ss << "Name: \"kS\" Value: \"" << kS << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1407, kP, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1408, kI, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1409, kD, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1410, kV, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1411, kS, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot0_kP, string_c_str, string_length, &kP);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot0_kI, string_c_str, string_length, &kI);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot0_kD, string_c_str, string_length, &kD);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot0_kV, string_c_str, string_length, &kV);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot0_kS, string_c_str, string_length, &kS);
        return 0;
    }
};
 
 
/**
 * \brief  What the gains for slot 1 are
 *
 * \details  If this slot is selected, these gains are used in closed
 *           loop control requests.
 */
class Slot1Configs : public ParentConfiguration
{
public:
    /**
     * \brief Proportional Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input, the units
     * should be defined as units of output per unit of input error. For
     * example, when controlling velocity using a duty cycle closed loop,
     * the units for the proportional gain will be duty cycle per rps, or
     * 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kP = 0;
    /**
     * \brief Integral Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input integrated over
     * time (in units of seconds), the units should be defined as units of
     * output per unit of integrated input error. For example, when
     * controlling velocity using a duty cycle closed loop, integrating
     * velocity over time results in rps * s = rotations. Therefore, the
     * units for the integral gain will be duty cycle per rotation of
     * accumulated error, or 1/rot.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kI = 0;
    /**
     * \brief Derivative Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the derivative of error in the
     * input with respect to time (in units of seconds), the units should
     * be defined as units of output per unit of the differentiated input
     * error. For example, when controlling velocity using a duty cycle
     * closed loop, the derivative of velocity with respect to time is
     * rps/s, which is acceleration. Therefore, the units for the
     * derivative gain will be duty cycle per unit of acceleration error,
     * or 1/(rps/s).
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kD = 0;
    /**
     * \brief Velocity Feed Forward Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the requested velocity, the units
     * should be defined as units of output per unit of requested input
     * velocity. For example, when controlling velocity using a duty cycle
     * closed loop, the units for the velocity feed foward gain will be
     * duty cycle per requested rps, or 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kV = 0;
    /**
     * \brief Static Constant
     *
     * \details This is added to the closed loop output.  The sign is
     * determined by target velocity. The unit for this constant is
     * dependent on the control mode, typically fractional duty cycle,
     * voltage, or torque current.
     *
     *  Minimum Value: -512
     *  Maximum Value: 511
     *  Default Value: 0
     *  Units: 
     */
    double kS = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Slot1" << std::endl;
        ss << "Name: \"kP\" Value: \"" << kP << "\"" << std::endl;
        ss << "Name: \"kI\" Value: \"" << kI << "\"" << std::endl;
        ss << "Name: \"kD\" Value: \"" << kD << "\"" << std::endl;
        ss << "Name: \"kV\" Value: \"" << kV << "\"" << std::endl;
        ss << "Name: \"kS\" Value: \"" << kS << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1412, kP, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1413, kI, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1414, kD, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1415, kV, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1416, kS, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot1_kP, string_c_str, string_length, &kP);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot1_kI, string_c_str, string_length, &kI);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot1_kD, string_c_str, string_length, &kD);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot1_kV, string_c_str, string_length, &kV);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot1_kS, string_c_str, string_length, &kS);
        return 0;
    }
};
 
 
/**
 * \brief  What the gains for slot 2 are
 *
 * \details  If this slot is selected, these gains are used in closed
 *           loop control requests.
 */
class Slot2Configs : public ParentConfiguration
{
public:
    /**
     * \brief Proportional Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input, the units
     * should be defined as units of output per unit of input error. For
     * example, when controlling velocity using a duty cycle closed loop,
     * the units for the proportional gain will be duty cycle per rps, or
     * 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kP = 0;
    /**
     * \brief Integral Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by error in the input integrated over
     * time (in units of seconds), the units should be defined as units of
     * output per unit of integrated input error. For example, when
     * controlling velocity using a duty cycle closed loop, integrating
     * velocity over time results in rps * s = rotations. Therefore, the
     * units for the integral gain will be duty cycle per rotation of
     * accumulated error, or 1/rot.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kI = 0;
    /**
     * \brief Derivative Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the derivative of error in the
     * input with respect to time (in units of seconds), the units should
     * be defined as units of output per unit of the differentiated input
     * error. For example, when controlling velocity using a duty cycle
     * closed loop, the derivative of velocity with respect to time is
     * rps/s, which is acceleration. Therefore, the units for the
     * derivative gain will be duty cycle per unit of acceleration error,
     * or 1/(rps/s).
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kD = 0;
    /**
     * \brief Velocity Feed Forward Gain
     *
     * \details The units for this gain is dependent on the control mode.
     * Since this gain is multiplied by the requested velocity, the units
     * should be defined as units of output per unit of requested input
     * velocity. For example, when controlling velocity using a duty cycle
     * closed loop, the units for the velocity feed foward gain will be
     * duty cycle per requested rps, or 1/rps.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: 
     */
    double kV = 0;
    /**
     * \brief Static Constant
     *
     * \details This is added to the closed loop output.  The sign is
     * determined by target velocity. The unit for this constant is
     * dependent on the control mode, typically fractional duty cycle,
     * voltage, or torque current.
     *
     *  Minimum Value: -512
     *  Maximum Value: 511
     *  Default Value: 0
     *  Units: 
     */
    double kS = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Slot2" << std::endl;
        ss << "Name: \"kP\" Value: \"" << kP << "\"" << std::endl;
        ss << "Name: \"kI\" Value: \"" << kI << "\"" << std::endl;
        ss << "Name: \"kD\" Value: \"" << kD << "\"" << std::endl;
        ss << "Name: \"kV\" Value: \"" << kV << "\"" << std::endl;
        ss << "Name: \"kS\" Value: \"" << kS << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1417, kP, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1418, kI, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1419, kD, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1420, kV, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1421, kS, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot2_kP, string_c_str, string_length, &kP);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot2_kI, string_c_str, string_length, &kI);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot2_kD, string_c_str, string_length, &kD);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot2_kV, string_c_str, string_length, &kV);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Slot2_kS, string_c_str, string_length, &kS);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class MotorOutputConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Invert state of the device
     *
     */
    signals::InvertedValue Inverted = signals::InvertedValue::CounterClockwise_Positive;
    /**
     * \brief The state of the motor controller bridge when output is
     * neutral or disabled.
     *
     */
    signals::NeutralModeValue NeutralMode = signals::NeutralModeValue::Coast;
    /**
     * \brief Configures the output deadband percentage.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 0.25
     *  Default Value: 0
     *  Units: fractional
     */
    double DutyCycleNeutralDeadband = 0;
    /**
     * \brief Maximum (forward) output during duty cycle based control
     * modes.
     *
     *  Minimum Value: -1.0
     *  Maximum Value: 1.0
     *  Default Value: 1
     *  Units: fractional
     */
    double PeakForwardDutyCycle = 1;
    /**
     * \brief Minimum (reverse) output during duty cycle based control
     * modes.
     *
     *  Minimum Value: -1.0
     *  Maximum Value: 1.0
     *  Default Value: -1
     *  Units: fractional
     */
    double PeakReverseDutyCycle = -1;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: MotorOutput" << std::endl;
        ss << "Name: \"Inverted\" Value: \"" << Inverted << "\"" << std::endl;
        ss << "Name: \"NeutralMode\" Value: \"" << NeutralMode << "\"" << std::endl;
        ss << "Name: \"DutyCycleNeutralDeadband\" Value: \"" << DutyCycleNeutralDeadband << "fractional\"" << std::endl;
        ss << "Name: \"PeakForwardDutyCycle\" Value: \"" << PeakForwardDutyCycle << "fractional\"" << std::endl;
        ss << "Name: \"PeakReverseDutyCycle\" Value: \"" << PeakReverseDutyCycle << "fractional\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_int(1422, Inverted.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1425, NeutralMode.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1426, DutyCycleNeutralDeadband, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1431, PeakForwardDutyCycle, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1432, PeakReverseDutyCycle, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_Inverted, string_c_str, string_length, &Inverted.value);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_NeutralMode, string_c_str, string_length, &NeutralMode.value);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_DutyCycleNeutralDB, string_c_str, string_length, &DutyCycleNeutralDeadband);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakForwardDC, string_c_str, string_length, &PeakForwardDutyCycle);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakReverseDC, string_c_str, string_length, &PeakReverseDutyCycle);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect current limiting features.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class CurrentLimitsConfigs : public ParentConfiguration
{
public:
    /**
     * \brief The amount of current allowed in the motor (motoring and
     * regen current).  This is only applicable for non-torque current
     * control modes.  Note this requires the corresponding enable to be
     * true.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 800.0
     *  Default Value: 0
     *  Units: A
     */
    double StatorCurrentLimit = 0;
    /**
     * \brief Enable motor stator current limiting.
     *
     *  Default Value: False
     */
    bool StatorCurrentLimitEnable = false;
    /**
     * \brief The amount of supply current allowed.  This is only
     * applicable for non-torque current control modes.  Note this
     * requires the corresponding enable to be true.  Use
     * SupplyCurrentThreshold and SupplyTimeThreshold to allow brief
     * periods of high-current before limiting occurs.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 800.0
     *  Default Value: 0
     *  Units: A
     */
    double SupplyCurrentLimit = 0;
    /**
     * \brief Enable motor supply current limiting.
     *
     *  Default Value: False
     */
    bool SupplyCurrentLimitEnable = false;
    /**
     * \brief Delay supply current limiting until current exceeds this
     * threshold for longer than SupplyTimeThreshold.  This allows current
     * draws above SupplyCurrentLimit for a fixed period of time.  This
     * has no effect if SupplyCurrentLimit is greater than this value.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 511
     *  Default Value: 0
     *  Units: A
     */
    double SupplyCurrentThreshold = 0;
    /**
     * \brief Allows unlimited current for a period of time before current
     * limiting occurs.  Current threshold is the maximum of
     * SupplyCurrentThreshold and SupplyCurrentLimit.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 1.275
     *  Default Value: 0
     *  Units: sec
     */
    double SupplyTimeThreshold = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: CurrentLimits" << std::endl;
        ss << "Name: \"StatorCurrentLimit\" Value: \"" << StatorCurrentLimit << "A\"" << std::endl;
        ss << "Name: \"StatorCurrentLimitEnable\" Value: \"" << StatorCurrentLimitEnable << "\"" << std::endl;
        ss << "Name: \"SupplyCurrentLimit\" Value: \"" << SupplyCurrentLimit << "A\"" << std::endl;
        ss << "Name: \"SupplyCurrentLimitEnable\" Value: \"" << SupplyCurrentLimitEnable << "\"" << std::endl;
        ss << "Name: \"SupplyCurrentThreshold\" Value: \"" << SupplyCurrentThreshold << "A\"" << std::endl;
        ss << "Name: \"SupplyTimeThreshold\" Value: \"" << SupplyTimeThreshold << "sec\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1427, StatorCurrentLimit, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1428, StatorCurrentLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1429, SupplyCurrentLimit, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1430, SupplyCurrentLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1505, SupplyCurrentThreshold, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1506, SupplyTimeThreshold, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_StatorCurrentLimit, string_c_str, string_length, &StatorCurrentLimit);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_StatorCurrLimitEn, string_c_str, string_length, &StatorCurrentLimitEnable);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_SupplyCurrentLimit, string_c_str, string_length, &SupplyCurrentLimit);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_SupplyCurrLimitEn, string_c_str, string_length, &SupplyCurrentLimitEnable);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_SupplyCurrThres, string_c_str, string_length, &SupplyCurrentThreshold);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_SupplyTimeThres, string_c_str, string_length, &SupplyTimeThreshold);
        return 0;
    }
};
 
 
/**
 * \brief  Voltage-specific configs
 *
 * \details  Voltage-specific configs
 */
class VoltageConfigs : public ParentConfiguration
{
public:
    /**
     * \brief The time constant (in seconds) of the low-pass filter for
     * the supply voltage.
     *
     * \details This impacts the filtering for the reported supply
     * voltage, and any control strategies that use the supply voltage
     * (such as voltage control on a motor controller).
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 0.1
     *  Default Value: 0
     *  Units: sec
     */
    double SupplyVoltageTimeConstant = 0;
    /**
     * \brief Maximum (forward) output during voltage based control modes.
     *
     *  Minimum Value: -16
     *  Maximum Value: 16
     *  Default Value: 16
     *  Units: V
     */
    double PeakForwardVoltage = 16;
    /**
     * \brief Minimum (reverse) output during voltage based control modes.
     *
     *  Minimum Value: -16
     *  Maximum Value: 16
     *  Default Value: -16
     *  Units: V
     */
    double PeakReverseVoltage = -16;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Voltage" << std::endl;
        ss << "Name: \"SupplyVoltageTimeConstant\" Value: \"" << SupplyVoltageTimeConstant << "sec\"" << std::endl;
        ss << "Name: \"PeakForwardVoltage\" Value: \"" << PeakForwardVoltage << "V\"" << std::endl;
        ss << "Name: \"PeakReverseVoltage\" Value: \"" << PeakReverseVoltage << "V\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1423, SupplyVoltageTimeConstant, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1433, PeakForwardVoltage, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1434, PeakReverseVoltage, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_SupplyVLowpassTau, string_c_str, string_length, &SupplyVoltageTimeConstant);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakForwardV, string_c_str, string_length, &PeakForwardVoltage);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakReverseV, string_c_str, string_length, &PeakReverseVoltage);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class TorqueCurrentConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Maximum (forward) output during torque current based control
     * modes.
     *
     *  Minimum Value: -800
     *  Maximum Value: 800
     *  Default Value: 800
     *  Units: A
     */
    double PeakForwardTorqueCurrent = 800;
    /**
     * \brief Minimum (reverse) output during torque current based control
     * modes.
     *
     *  Minimum Value: -800
     *  Maximum Value: 800
     *  Default Value: -800
     *  Units: A
     */
    double PeakReverseTorqueCurrent = -800;
    /**
     * \brief Configures the output deadband during torque current based
     * control modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 25
     *  Default Value: 0.0
     *  Units: A
     */
    double TorqueNeutralDeadband = 0.0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: TorqueCurrent" << std::endl;
        ss << "Name: \"PeakForwardTorqueCurrent\" Value: \"" << PeakForwardTorqueCurrent << "A\"" << std::endl;
        ss << "Name: \"PeakReverseTorqueCurrent\" Value: \"" << PeakReverseTorqueCurrent << "A\"" << std::endl;
        ss << "Name: \"TorqueNeutralDeadband\" Value: \"" << TorqueNeutralDeadband << "A\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1435, PeakForwardTorqueCurrent, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1436, PeakReverseTorqueCurrent, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1437, TorqueNeutralDeadband, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakForTorqCurr, string_c_str, string_length, &PeakForwardTorqueCurrent);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_PeakRevTorqCurr, string_c_str, string_length, &PeakReverseTorqueCurrent);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_TorqueNeutralDB, string_c_str, string_length, &TorqueNeutralDeadband);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class FeedbackConfigs : public ParentConfiguration
{
public:
    /**
     * \brief This offset is applied to the absolute integrated rotor
     * sensor.  This can be used to zero the rotor in applications that
     * are within one rotor rotation.
     *
     *  Minimum Value: -1
     *  Maximum Value: 1
     *  Default Value: 0.0
     *  Units: rotations
     */
    double FeedbackRotorOffset = 0.0;
    /**
     * \brief This is the ratio of sensor rotations to the mechanism's
     * output.  This is equivalent to the mechanism's gear ratio if the
     * sensor is located on the input of a gearbox.  If sensor is on the
     * output of a gearbox, then this is typically set to 1.  Note if this
     * is set to zero, device will reset back to one.
     *
     *  Minimum Value: -1000
     *  Maximum Value: 1000
     *  Default Value: 1.0
     *  Units: scalar
     */
    double SensorToMechanismRatio = 1.0;
    /**
     * \brief Talon FX is capable of fusing a remote CANcoder with its
     * rotor sensor to produce a high-bandwidth sensor source.  This
     * feature requires specifying the ratio between the remote sensor and
     * the motor rotor.  Note if this is set to zero, device will reset
     * back to one.
     *
     *  Minimum Value: -1000
     *  Maximum Value: 1000
     *  Default Value: 1.0
     *  Units: scalar
     */
    double RotorToSensorRatio = 1.0;
    /**
     * \brief Choose what sensor source is reported via API and used by
     * closed-loop and limit features.  The default is RotorSensor, which
     * uses the internal rotor sensor in the Talon FX.  Choose
     * RemoteCANcoder to use another CANcoder on the same CAN bus (this
     * also requires setting FeedbackRemoteSensorID).  Talon FX will
     * update its position and velocity whenever CANcoder publishes its
     * information on CAN bus.  Choose FusedCANcoder and Talon FX will
     * fuse another CANcoder's information with the internal rotor, which
     * provides the best possible position and velocity for accuracy and
     * bandwidth (note this requires setting FeedbackRemoteSensorID). 
     * FusedCANcoder was developed for applications such as
     * swerve-azimuth.
     *
     * \details Note: When the Talon Source is changed to FusedCANcoder,
     * the Talon needs a period of time to fuse before sensor-based
     * (soft-limit, closed loop, etc.) features are used. This period of
     * time is determined by the update frequency of the CANcoder's
     * Position signal.
     *
     */
    signals::FeedbackSensorSourceValue FeedbackSensorSource = signals::FeedbackSensorSourceValue::RotorSensor;
    /**
     * \brief Device ID of which remote device to use.  This is not used
     * if the Sensor Source is the internal rotor sensor.
     *
     *  Minimum Value: 0
     *  Maximum Value: 62
     *  Default Value: 0
     *  Units: 
     */
    int FeedbackRemoteSensorID = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Feedback" << std::endl;
        ss << "Name: \"FeedbackRotorOffset\" Value: \"" << FeedbackRotorOffset << "rotations\"" << std::endl;
        ss << "Name: \"SensorToMechanismRatio\" Value: \"" << SensorToMechanismRatio << "scalar\"" << std::endl;
        ss << "Name: \"RotorToSensorRatio\" Value: \"" << RotorToSensorRatio << "scalar\"" << std::endl;
        ss << "Name: \"FeedbackSensorSource\" Value: \"" << FeedbackSensorSource << "\"" << std::endl;
        ss << "Name: \"FeedbackRemoteSensorID\" Value: \"" << FeedbackRemoteSensorID << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1438, FeedbackRotorOffset, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1439, SensorToMechanismRatio, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1440, RotorToSensorRatio, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1441, FeedbackSensorSource.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1442, FeedbackRemoteSensorID, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_FeedbackRotorOffset, string_c_str, string_length, &FeedbackRotorOffset);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_SensorToMechanismRatio, string_c_str, string_length, &SensorToMechanismRatio);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_RotorToSensorRatio, string_c_str, string_length, &RotorToSensorRatio);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_FeedbackSensorSource, string_c_str, string_length, &FeedbackSensorSource.value);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_FeedbackRemoteSensorID, string_c_str, string_length, &FeedbackRemoteSensorID);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class OpenLoopRampsConfigs : public ParentConfiguration
{
public:
    /**
     * \brief If non-zero, this determines how much time to ramp from 0%
     * output to 100% during open-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 1
     *  Default Value: 0
     *  Units: sec
     */
    double DutyCycleOpenLoopRampPeriod = 0;
    /**
     * \brief If non-zero, this determines how much time to ramp from 0V
     * output to 12V during open-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 1
     *  Default Value: 0
     *  Units: sec
     */
    double VoltageOpenLoopRampPeriod = 0;
    /**
     * \brief If non-zero, this determines how much time to ramp from 0A
     * output to 300A during open-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 10
     *  Default Value: 0
     *  Units: sec
     */
    double TorqueOpenLoopRampPeriod = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: OpenLoopRamps" << std::endl;
        ss << "Name: \"DutyCycleOpenLoopRampPeriod\" Value: \"" << DutyCycleOpenLoopRampPeriod << "sec\"" << std::endl;
        ss << "Name: \"VoltageOpenLoopRampPeriod\" Value: \"" << VoltageOpenLoopRampPeriod << "sec\"" << std::endl;
        ss << "Name: \"TorqueOpenLoopRampPeriod\" Value: \"" << TorqueOpenLoopRampPeriod << "sec\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1443, DutyCycleOpenLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1444, VoltageOpenLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1445, TorqueOpenLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_DutyCycleOpenLoopRampPeriod, string_c_str, string_length, &DutyCycleOpenLoopRampPeriod);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_VoltageOpenLoopRampPeriod, string_c_str, string_length, &VoltageOpenLoopRampPeriod);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_TorqueOpenLoopRampPeriod, string_c_str, string_length, &TorqueOpenLoopRampPeriod);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class ClosedLoopRampsConfigs : public ParentConfiguration
{
public:
    /**
     * \brief If non-zero, this determines how much time to ramp from 0%
     * output to 100% during closed-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 1
     *  Default Value: 0
     *  Units: sec
     */
    double DutyCycleClosedLoopRampPeriod = 0;
    /**
     * \brief If non-zero, this determines how much time to ramp from 0V
     * output to 12V during closed-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 1
     *  Default Value: 0
     *  Units: sec
     */
    double VoltageClosedLoopRampPeriod = 0;
    /**
     * \brief If non-zero, this determines how much time to ramp from 0A
     * output to 300A during closed-loop modes.
     *
     *  Minimum Value: 0
     *  Maximum Value: 10
     *  Default Value: 0
     *  Units: sec
     */
    double TorqueClosedLoopRampPeriod = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: ClosedLoopRamps" << std::endl;
        ss << "Name: \"DutyCycleClosedLoopRampPeriod\" Value: \"" << DutyCycleClosedLoopRampPeriod << "sec\"" << std::endl;
        ss << "Name: \"VoltageClosedLoopRampPeriod\" Value: \"" << VoltageClosedLoopRampPeriod << "sec\"" << std::endl;
        ss << "Name: \"TorqueClosedLoopRampPeriod\" Value: \"" << TorqueClosedLoopRampPeriod << "sec\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1446, DutyCycleClosedLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1447, VoltageClosedLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1448, TorqueClosedLoopRampPeriod, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_DutyCycleClosedLoopRampPeriod, string_c_str, string_length, &DutyCycleClosedLoopRampPeriod);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_VoltageClosedLoopRampPeriod, string_c_str, string_length, &VoltageClosedLoopRampPeriod);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_TorqueClosedLoopRampPeriod, string_c_str, string_length, &TorqueClosedLoopRampPeriod);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class HardwareLimitSwitchConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Determines if limit is normally-open (default) or
     * normally-closed.
     *
     */
    signals::ForwardLimitTypeValue ForwardLimitType = signals::ForwardLimitTypeValue::NormallyOpen;
    /**
     * \brief If enabled, the position is auto-set to a specific value,
     * specified by ForwardLimitAutosetPositionValue
     *
     *  Default Value: False
     */
    bool ForwardLimitAutosetPositionEnable = false;
    /**
     * \brief The value to auto-set the position to.  This has no effect
     * if ForwardLimitAutosetPositionEnable is false.
     *
     *  Minimum Value: -3.4e+38
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rotations
     */
    double ForwardLimitAutosetPositionValue = 0;
    /**
     * \brief If enabled, motor output is set to neutral when forward
     * limit switch is asseted and positive output is requested.
     *
     *  Default Value: True
     */
    bool ForwardLimitEnable = true;
    /**
     * \brief Determines where to poll the forward limit switch.  This
     * defaults to the limit switch pin on the limit switch connector.
     *
     */
    signals::ForwardLimitSourceValue ForwardLimitSource = signals::ForwardLimitSourceValue::LimitSwitchPin;
    /**
     * \brief Device ID of the device if using remote limit switch
     * features.
     *
     *  Minimum Value: 0
     *  Maximum Value: 62
     *  Default Value: 0
     *  Units: 
     */
    int ForwardLimitRemoteSensorID = 0;
    /**
     * \brief Determines if limit is normally-open (default) or
     * normally-closed.
     *
     */
    signals::ReverseLimitTypeValue ReverseLimitType = signals::ReverseLimitTypeValue::NormallyOpen;
    /**
     * \brief If enabled, the position is auto-set to a specific value,
     * specified by ReverseLimitAutosetPositionValue
     *
     *  Default Value: False
     */
    bool ReverseLimitAutosetPositionEnable = false;
    /**
     * \brief The value to auto-set the position to.  This has no effect
     * if ReverseLimitAutosetPositionEnable is false.
     *
     *  Minimum Value: -3.4e+38
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rotations
     */
    double ReverseLimitAutosetPositionValue = 0;
    /**
     * \brief If enabled, motor output is set to neutral when reverse
     * limit switch is asseted and positive output is requested.
     *
     *  Default Value: True
     */
    bool ReverseLimitEnable = true;
    /**
     * \brief Determines where to poll the reverse limit switch.  This
     * defaults to the limit switch pin on the limit switch connector.
     *
     */
    signals::ReverseLimitSourceValue ReverseLimitSource = signals::ReverseLimitSourceValue::LimitSwitchPin;
    /**
     * \brief Device ID of the device if using remote limit switch
     * features.
     *
     *  Minimum Value: 0
     *  Maximum Value: 62
     *  Default Value: 0
     *  Units: 
     */
    int ReverseLimitRemoteSensorID = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: HardwareLimitSwitch" << std::endl;
        ss << "Name: \"ForwardLimitType\" Value: \"" << ForwardLimitType << "\"" << std::endl;
        ss << "Name: \"ForwardLimitAutosetPositionEnable\" Value: \"" << ForwardLimitAutosetPositionEnable << "\"" << std::endl;
        ss << "Name: \"ForwardLimitAutosetPositionValue\" Value: \"" << ForwardLimitAutosetPositionValue << "rotations\"" << std::endl;
        ss << "Name: \"ForwardLimitEnable\" Value: \"" << ForwardLimitEnable << "\"" << std::endl;
        ss << "Name: \"ForwardLimitSource\" Value: \"" << ForwardLimitSource << "\"" << std::endl;
        ss << "Name: \"ForwardLimitRemoteSensorID\" Value: \"" << ForwardLimitRemoteSensorID << "\"" << std::endl;
        ss << "Name: \"ReverseLimitType\" Value: \"" << ReverseLimitType << "\"" << std::endl;
        ss << "Name: \"ReverseLimitAutosetPositionEnable\" Value: \"" << ReverseLimitAutosetPositionEnable << "\"" << std::endl;
        ss << "Name: \"ReverseLimitAutosetPositionValue\" Value: \"" << ReverseLimitAutosetPositionValue << "rotations\"" << std::endl;
        ss << "Name: \"ReverseLimitEnable\" Value: \"" << ReverseLimitEnable << "\"" << std::endl;
        ss << "Name: \"ReverseLimitSource\" Value: \"" << ReverseLimitSource << "\"" << std::endl;
        ss << "Name: \"ReverseLimitRemoteSensorID\" Value: \"" << ReverseLimitRemoteSensorID << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_int(1449, ForwardLimitType.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1450, ForwardLimitAutosetPositionEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1451, ForwardLimitAutosetPositionValue, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1452, ForwardLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1453, ForwardLimitSource.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1454, ForwardLimitRemoteSensorID, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1455, ReverseLimitType.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1456, ReverseLimitAutosetPositionEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1457, ReverseLimitAutosetPositionValue, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1458, ReverseLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1459, ReverseLimitSource.value, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(1460, ReverseLimitRemoteSensorID, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitType, string_c_str, string_length, &ForwardLimitType.value);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitAutosetPosEnable, string_c_str, string_length, &ForwardLimitAutosetPositionEnable);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitAutosetPosValue, string_c_str, string_length, &ForwardLimitAutosetPositionValue);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitEnable, string_c_str, string_length, &ForwardLimitEnable);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitSource, string_c_str, string_length, &ForwardLimitSource.value);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ForwardLimitRemoteSensorID, string_c_str, string_length, &ForwardLimitRemoteSensorID);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitType, string_c_str, string_length, &ReverseLimitType.value);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitAutosetPosEnable, string_c_str, string_length, &ReverseLimitAutosetPositionEnable);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitAutosetPosValue, string_c_str, string_length, &ReverseLimitAutosetPositionValue);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitEnable, string_c_str, string_length, &ReverseLimitEnable);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitSource, string_c_str, string_length, &ReverseLimitSource.value);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::Config_ReverseLimitRemoteSensorID, string_c_str, string_length, &ReverseLimitRemoteSensorID);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class AudioConfigs : public ParentConfiguration
{
public:
    /**
     * \brief If true, the TalonFX will beep during boot-up.  This is
     * useful for general debugging, and defaults to true.  If rotor is
     * moving during boot-up, the beep will not occur regardless of this
     * setting.
     *
     *  Default Value: True
     */
    bool BeepOnBoot = true;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: Audio" << std::endl;
        ss << "Name: \"BeepOnBoot\" Value: \"" << BeepOnBoot << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_bool(1424, BeepOnBoot, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_BeepOnBoot, string_c_str, string_length, &BeepOnBoot);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class SoftwareLimitSwitchConfigs : public ParentConfiguration
{
public:
    /**
     * \brief If enabled, the motor output is set to neutral if position
     * exceeds ForwardSoftLimitThreshold and forward output is requested.
     *
     *  Default Value: False
     */
    bool ForwardSoftLimitEnable = false;
    /**
     * \brief If enabled, the motor output is set to neutral if position
     * exceeds ReverseSoftLimitThreshold and reverse output is requested.
     *
     *  Default Value: False
     */
    bool ReverseSoftLimitEnable = false;
    /**
     * \brief Position threshold for forward soft limit features.
     * ForwardSoftLimitEnable must be enabled for this to take effect.
     *
     *  Minimum Value: -3.4e+38
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rotations
     */
    double ForwardSoftLimitThreshold = 0;
    /**
     * \brief Position threshold for reverse soft limit features.
     * ReverseSoftLimitEnable must be enabled for this to take effect.
     *
     *  Minimum Value: -3.4e+38
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rotations
     */
    double ReverseSoftLimitThreshold = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: SoftwareLimitSwitch" << std::endl;
        ss << "Name: \"ForwardSoftLimitEnable\" Value: \"" << ForwardSoftLimitEnable << "\"" << std::endl;
        ss << "Name: \"ReverseSoftLimitEnable\" Value: \"" << ReverseSoftLimitEnable << "\"" << std::endl;
        ss << "Name: \"ForwardSoftLimitThreshold\" Value: \"" << ForwardSoftLimitThreshold << "rotations\"" << std::endl;
        ss << "Name: \"ReverseSoftLimitThreshold\" Value: \"" << ReverseSoftLimitThreshold << "rotations\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_bool(1461, ForwardSoftLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_bool(1462, ReverseSoftLimitEnable, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1463, ForwardSoftLimitThreshold, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1464, ReverseSoftLimitThreshold, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ForwardSoftLimitEnable, string_c_str, string_length, &ForwardSoftLimitEnable);
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ReverseSoftLimitEnable, string_c_str, string_length, &ReverseSoftLimitEnable);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_ForwardSoftLimitThreshold, string_c_str, string_length, &ForwardSoftLimitThreshold);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_ReverseSoftLimitThreshold, string_c_str, string_length, &ReverseSoftLimitThreshold);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class MotionMagicConfigs : public ParentConfiguration
{
public:
    /**
     * \brief This is the maximum velocity Motion Magic® based control
     * modes are allowed to use.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rps
     */
    double MotionMagicCruiseVelocity = 0;
    /**
     * \brief This is the target acceleration Motion Magic® based control
     * modes are allowed to use.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rot per sec²
     */
    double MotionMagicAcceleration = 0;
    /**
     * \brief This is the target jerk (acceleration derivative) Motion
     * Magic® based control modes are allowed to use.  This allows Motion
     * Magic® support of S-Curves.  If this is set to zero, then Motion
     * Magic® will not apply a Jerk limit.
     *
     *  Minimum Value: 0
     *  Maximum Value: 3.4e+38
     *  Default Value: 0
     *  Units: rot per sec³
     */
    double MotionMagicJerk = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: MotionMagic" << std::endl;
        ss << "Name: \"MotionMagicCruiseVelocity\" Value: \"" << MotionMagicCruiseVelocity << "rps\"" << std::endl;
        ss << "Name: \"MotionMagicAcceleration\" Value: \"" << MotionMagicAcceleration << "rot per sec²\"" << std::endl;
        ss << "Name: \"MotionMagicJerk\" Value: \"" << MotionMagicJerk << "rot per sec³\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1465, MotionMagicCruiseVelocity, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1466, MotionMagicAcceleration, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_double(1467, MotionMagicJerk, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_MotionMagicCruiseVelocity, string_c_str, string_length, &MotionMagicCruiseVelocity);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_MotionMagicAcceleration, string_c_str, string_length, &MotionMagicAcceleration);
        c_ctre_phoenixpro_deserialize_double(ctre::phoenixpro::spns::SpnValue::Config_MotionMagicJerk, string_c_str, string_length, &MotionMagicJerk);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that directly affect motor-output.
 *
 * \details  Includes Motor Invert and various limit features.
 */
class CustomParamsConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Custom parameter 0.  This is provided to allow
     * end-applications to store persistent information in the device.
     *
     *  Minimum Value: -32768
     *  Maximum Value: 32767
     *  Default Value: 0
     *  Units: 
     */
    int CustomParam0 = 0;
    /**
     * \brief Custom parameter 1.  This is provided to allow
     * end-applications to store persistent information in the device.
     *
     *  Minimum Value: -32768
     *  Maximum Value: 32767
     *  Default Value: 0
     *  Units: 
     */
    int CustomParam1 = 0;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: CustomParams" << std::endl;
        ss << "Name: \"CustomParam0\" Value: \"" << CustomParam0 << "\"" << std::endl;
        ss << "Name: \"CustomParam1\" Value: \"" << CustomParam1 << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_int(816, CustomParam0, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        c_ctre_phoenixpro_serialize_int(817, CustomParam1, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::CustomParam0, string_c_str, string_length, &CustomParam0);
        c_ctre_phoenixpro_deserialize_int(ctre::phoenixpro::spns::SpnValue::CustomParam1, string_c_str, string_length, &CustomParam1);
        return 0;
    }
};
 
 
/**
 * \brief  Configs that affect general behavior during closed-looping.
 *
 * \details  Includes Continuous Wrap features.
 */
class ClosedLoopGeneralConfigs : public ParentConfiguration
{
public:
    /**
     * \brief Wrap position error within [-0.5,+0.5) mechanism rotations. 
     * Typically used for continuous position closed-loops like swerve
     * azimuth.
     *
     * \details This uses the mechanism rotation value. If there is a gear
     * ratio between the sensor and the mechanism, make sure to apply a
     * SensorToMechanismRatio so the closed loop operates on the full
     * rotation.
     *
     *  Default Value: False
     */
    bool ContinuousWrap = false;
 
    std::string ToString() const
    {
        std::stringstream ss;
        ss << "{" << std::endl;
        ss << "Config Group: ClosedLoopGeneral" << std::endl;
        ss << "Name: \"ContinuousWrap\" Value: \"" << ContinuousWrap << "\"" << std::endl;
        ss << "}" << std::endl;
        return ss.str();
    }
 
    std::string Serialize() const
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_bool(1499, ContinuousWrap, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return ss.str();
    }
 
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        const char *string_c_str = string.c_str();
        size_t string_length = string.length();
        c_ctre_phoenixpro_deserialize_bool(ctre::phoenixpro::spns::SpnValue::Config_ContinuousWrap, string_c_str, string_length, &ContinuousWrap);
        return 0;
    }
};
 
 
}
}
}