CANCoder.h

#pragma once
 
#include <cstdint>
#include "ctre/phoenix/CANBusAddressable.h"
#include "ctre/phoenix/CustomParamConfiguration.h"
#include "ctre/phoenix/ErrorCode.h"
#include "ctre/phoenix/paramEnum.h"
#include "ctre/phoenix/sensors/AbsoluteSensorRange.h"
#include "ctre/phoenix/sensors/CANCoderSimCollection.h"
#include "ctre/phoenix/sensors/CANCoderStatusFrame.h"
#include "ctre/phoenix/sensors/CANCoderStickyFaults.h"
#include "ctre/phoenix/sensors/CANCoderFaults.h"
#include "ctre/phoenix/sensors/SensorVelocityMeasPeriod.h"
#include "ctre/phoenix/sensors/SensorInitializationStrategy.h"
#include "ctre/phoenix/sensors/MagnetFieldStrength.h"
#include "ctre/phoenix/sensors/SensorTimeBase.h"
 
namespace ctre {
    namespace phoenix {
        namespace sensors {
 
            struct CANCoderConfiguration : CustomParamConfiguration {
                SensorVelocityMeasPeriod velocityMeasurementPeriod = SensorVelocityMeasPeriod::Period_100Ms;
                int velocityMeasurementWindow = 64;
                ctre::phoenix::sensors::AbsoluteSensorRange absoluteSensorRange = AbsoluteSensorRange::Unsigned_0_to_360;
                double magnetOffsetDegrees = 0;
                bool sensorDirection = false;
                ctre::phoenix::sensors::SensorInitializationStrategy initializationStrategy = ctre::phoenix::sensors::SensorInitializationStrategy::BootToZero;
                double sensorCoefficient = 360.0 / 4096.0;
                std::string unitString = "deg";
                ctre::phoenix::sensors::SensorTimeBase sensorTimeBase = ctre::phoenix::sensors::SensorTimeBase::PerSecond;
 
                CANCoderConfiguration() { }
 
                std::string toString() {
                    return toString("");
                }
 
                std::string toString(std::string prependString) {
 
                    std::string retstr;
                    retstr += prependString + ".velocityMeasurementPeriod = " + SensorVelocityMeasPeriodRoutines::toString(velocityMeasurementPeriod) + ";\n";
                    retstr += prependString + ".velocityMeasurementWindow = " + std::to_string(velocityMeasurementWindow) + ";\n";
                    retstr += prependString + ".absoluteSensorRange = " + std::to_string(absoluteSensorRange) + ";\n";
                    retstr += prependString + ".magnetOffsetDegrees = " + std::to_string(magnetOffsetDegrees) + ";\n";
                    retstr += prependString + ".sensorDirection = " + std::to_string(sensorDirection) + ";\n";
                    retstr += prependString + ".initializationStrategy = " + std::to_string(initializationStrategy) + ";\n";
                    retstr += prependString + ".sensorCoefficient = " + std::to_string(sensorCoefficient) + ";\n";
                    retstr += prependString + ".unitString = \"" + unitString.c_str() + "\";\n";
                    retstr += prependString + ".sensorTimeBase = " + std::to_string(sensorTimeBase) + ";\n";
                    retstr += CustomParamConfiguration::toString(prependString);
 
                    return retstr;
                }
 
            };// struct CANCoderConfiguration
 
            struct CANCoderConfigUtils : CustomParamConfigUtil {
            private:
                static CANCoderConfiguration _default;
            public:
                static bool VelocityMeasurementPeriodDifferent(const CANCoderConfiguration& settings) { return (!(settings.velocityMeasurementPeriod == _default.velocityMeasurementPeriod)) || !settings.enableOptimizations; }
                static bool VelocityMeasurementWindowDifferent(const CANCoderConfiguration& settings) { return (!(settings.velocityMeasurementWindow == _default.velocityMeasurementWindow)) || !settings.enableOptimizations; }
                static bool AbsoluteSensorRangeDifferent(const CANCoderConfiguration& settings) { return (!(settings.absoluteSensorRange == _default.absoluteSensorRange)) || !settings.enableOptimizations; }
                static bool MagnetOffsetDegreesDifferent(const CANCoderConfiguration& settings) { return (!(settings.magnetOffsetDegrees == _default.magnetOffsetDegrees)) || !settings.enableOptimizations; }
                static bool SensorDirectionDifferent(const CANCoderConfiguration& settings) { return (!(settings.sensorDirection == _default.sensorDirection)) || !settings.enableOptimizations; }
                static bool InitializationStrategyDifferent(const CANCoderConfiguration& settings) { return (!(settings.initializationStrategy == _default.initializationStrategy)) || !settings.enableOptimizations; }
                static bool SensorCoefficientDifferent(const CANCoderConfiguration& settings) { return (!(settings.sensorCoefficient == _default.sensorCoefficient)) || !settings.enableOptimizations; }
                static bool UnitStringDifferent(const CANCoderConfiguration& settings) { return (!(settings.unitString == _default.unitString)) || !settings.enableOptimizations; }
                static bool SensorTimeBaseDifferent(const CANCoderConfiguration& settings) { return (!(settings.sensorTimeBase == _default.sensorTimeBase)) || !settings.enableOptimizations; }
            };
 
 
            class CANCoder : public CANBusAddressable {
            public:
                CANCoder(int deviceNumber, std::string const &canbus = "");
 
                ~CANCoder();
 
                static void DestroyAllCANCoders();
 
 
                double GetPosition();
                double GetVelocity();
                ErrorCode SetPosition(double newPosition, int timeoutMs = 0);
                ErrorCode SetPositionToAbsolute(int timeoutMs = 0);
 
                double GetAbsolutePosition();
                ErrorCode ConfigVelocityMeasurementPeriod(SensorVelocityMeasPeriod period, int timeoutMs = 0);
                ErrorCode ConfigVelocityMeasurementWindow(int windowSize, int timeoutMs = 0);
                ErrorCode ConfigAbsoluteSensorRange(ctre::phoenix::sensors::AbsoluteSensorRange absoluteSensorRange, int timeoutMs = 0);
                ErrorCode ConfigMagnetOffset(double offsetDegrees, int timeoutMs = 0);
                ErrorCode ConfigSensorInitializationStrategy(ctre::phoenix::sensors::SensorInitializationStrategy initializationStrategy, int timeoutMs = 0);
                ErrorCode ConfigFeedbackCoefficient(double sensorCoefficient, const std::string& unitString, ctre::phoenix::sensors::SensorTimeBase sensortimeBase, int timeoutMs = 0);
 
                double GetBusVoltage();
                ctre::phoenix::sensors::MagnetFieldStrength GetMagnetFieldStrength();
 
                ErrorCode ConfigSensorDirection(bool bSensorDirection, int timeoutMs = 0);
 
                ErrorCode GetLastError();
 
                std::string GetLastUnitString();
 
                double GetLastTimestamp();
 
                ErrorCode ConfigSetCustomParam(int newValue, int paramIndex,
                    int timeoutMs = 0);
                int ConfigGetCustomParam(int paramIndex,
                    int timeoutMs = 0);
                //------ Generic Param API, typically not used ----------//
                ErrorCode ConfigSetParameter(ParamEnum param, double value,
                    uint8_t subValue, int ordinal, int timeoutMs = 0);
                double ConfigGetParameter(ParamEnum param, int ordinal, int timeoutMs = 0);
 
                ErrorCode ConfigGetParameter(ParamEnum param, int32_t valueToSend,
                    int32_t& valueReceived, uint8_t& subValue, int32_t ordinal,
                    int32_t timeoutMs);
 
 
                ErrorCode SetStatusFramePeriod(CANCoderStatusFrame statusFrame,
                    uint8_t periodMs, int timeoutMs = 0);
                int GetStatusFramePeriod(CANCoderStatusFrame frame, int timeoutMs = 0);
                int GetFirmwareVersion();
                bool HasResetOccurred();
                ErrorCode GetFaults(CANCoderFaults& toFill);
                ErrorCode GetStickyFaults(CANCoderStickyFaults& toFill);
                ErrorCode ClearStickyFaults(int timeoutMs = 0);
 
                //------ All Configs ----------//
                ctre::phoenix::ErrorCode ConfigAllSettings(const CANCoderConfiguration& allConfigs, int timeoutMs = 50);
                ErrorCode GetAllConfigs(CANCoderConfiguration& allConfigs, int timeoutMs = 50);
                ErrorCode ConfigFactoryDefault(int timeoutMs = 50);
 
                CANCoderSimCollection& GetSimCollection();
 
            private:
                void* m_handle;
                CANCoderSimCollection* _simCollection;
 
            };// class CANCoder
 
        } // namespace sensor
    } // namespace phoenix
} // namespace ctre