ParentDevice.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/phoenixpro/configs/Configs.hpp"
#include "ctre/phoenixpro/configs/Configurator.hpp"
#include "ctre/phoenixpro/controls/ControlRequest.hpp"
#include "ctre/phoenixpro/hardware/DeviceIdentifier.hpp"
#include "ctre/phoenixpro/platform/FrcUsageReport.hpp"
#include "ctre/phoenixpro/signals/SpnEnums.hpp"
#include "ctre/phoenixpro/spns/SpnValue.hpp"
#include "ctre/phoenixpro/StatusSignalValue.hpp"
#include <map>
#include <memory>
#include <mutex>
#include <units/dimensionless.h>
 
namespace ctre {
namespace phoenixpro {
namespace hardware {
 
    /**
     * Parent class for all devices
     */
    class ParentDevice
    {
    protected:
        DeviceIdentifier deviceIdentifier;
 
        virtual void ReportIfTooOld() = 0;
 
    private:
        std::map<uint32_t, std::unique_ptr<BaseStatusSignalValue>> _signalValues;
        std::recursive_mutex _signalValuesLck;
        /**
         * Use a shared pointer so users that access the control request via #GetAppliedControl has a copy
         * of the pointer without risk of it becoming a dangling pointer due to parallel operations
         */
        std::shared_ptr<controls::ControlRequest> _controlReq = std::make_shared<controls::EmptyControl>();
        std::mutex _controlReqLck;
 
        units::time::second_t _resetTimestamp{};
 
        template <typename T>
        StatusSignalValue<T> &LookupCommon(uint16_t spn, uint16_t mapper_iter, std::function<std::map<int, StatusSignalValue<T>>()> map_filler, std::string signalName, bool reportOnConstruction)
        {
            BaseStatusSignalValue *toFind;
            {
                /* lock access to the map */
                std::lock_guard<std::recursive_mutex> lock{_signalValuesLck};
 
                const uint32_t totalHash = spn | ((uint32_t)mapper_iter << 16);
                /* lookup and return if found */
                auto iter = _signalValues.find(totalHash);
                if (iter != _signalValues.end())
                {
                    /* Found it, toFind is now the found StatusSignalValue */
                    toFind = iter->second.get();
                    /* since we didn't construct, report errors */
                    reportOnConstruction = true;
                }
                else
                {
                    /* insert into map */
                    /* Mapper_iter is 0 when using straight SPNs, otherwise it's nonzero for switchable SPNs */
                    if (mapper_iter != 0)
                    {
                        /* Switchable spn, so generate the map to switch with */
                        _signalValues.emplace(totalHash, std::unique_ptr<StatusSignalValue<T>>{new StatusSignalValue<T>{
                                                            deviceIdentifier, spn, [this]()
                                                            { ReportIfTooOld(); },
                                                            map_filler, std::move(signalName)}});
                    }
                    else
                    {
                        /* Non-switchable spn, so just add the SPN plain */
                        _signalValues.emplace(totalHash, std::unique_ptr<StatusSignalValue<T>>{new StatusSignalValue<T>{
                                                            deviceIdentifier, spn, [this]()
                                                            { ReportIfTooOld(); },
                                                            std::move(signalName)}});
                    }
 
                    /* look up and return */
                    iter = _signalValues.find(totalHash);
                    toFind = iter->second.get();
                }
            }
 
            /* Now cast it up to the StatusSignalValue */
            StatusSignalValue<T> *ret = dynamic_cast<StatusSignalValue<T> *>(toFind);
            /* If ret is null, that means the cast failed. Otherwise we can return it */
            if (ret == nullptr)
            {
                /* Cast failed, let user know this doesn't exist */
                static StatusSignalValue<T> failure{ctre::phoenix::StatusCode::InvalidParamValue};
                return failure;
            }
            else
            {
                /* Good cast, refresh it and return this now */
                ret->Refresh(reportOnConstruction);
                return *ret;
            }
        }
 
    public:
        ParentDevice(int deviceID, std::string model, std::string canbus) :
            deviceIdentifier{DeviceIdentifier{deviceID, std::move(model), std::move(canbus)}}
        {
            ctre::phoenix::platform::FRC_Report(model, deviceID + 1, canbus, 1);
        }
 
        /**
         * \returns the device ID of this device [0,62].
         */
        int GetDeviceID() const
        {
            return deviceIdentifier.deviceID;
        }
 
        /**
         * \returns name of the CAN bus this device is on.
         */
        const std::string &GetCANBus() const
        {
            return deviceIdentifier.network;
        }
 
        static constexpr double kDefaultControlRatePeriodsSec = 0.010;
 
        /**
         * \brief Get the latest applied control.
         *
         * \details This returns a shared pointer to avoid becoming a dangling pointer
         *          due to parallel operations changing the underlying data.
         *
         * \returns Latest applied control
         */
        std::shared_ptr<const controls::ControlRequest> GetAppliedControl() const
        {
            return _controlReq;
        }
 
        /**
         * \brief Get the latest applied control.
         *
         * \details This returns a shared pointer to avoid becoming a dangling pointer
         *          due to parallel operations changing the underlying data.
         *
         * \returns Latest applied control
         */
        std::shared_ptr<controls::ControlRequest> GetAppliedControl()
        {
            return _controlReq;
        }
 
    protected:
        virtual ctre::phoenix::StatusCode SetControlPrivate(controls::ControlRequest &request);
 
        template <typename T>
        StatusSignalValue<T> &LookupStatusSignalValue(uint16_t spn, std::string signalName, bool reportOnConstruction)
        {
            std::function<std::map<int, StatusSignalValue<T>>()> emptyMapFiller = []
            {
                return std::map<int, StatusSignalValue<T>>{};
            };
            return LookupCommon<T>(spn, 0, emptyMapFiller, std::move(signalName), reportOnConstruction);
        }
 
        template <typename T>
        StatusSignalValue<T> &LookupStatusSignalValue(uint16_t spn, uint16_t mapper_iter, std::function<std::map<int, StatusSignalValue<T>>()> map_filler, std::string signalName, bool reportOnConstruction)
        {
            return LookupCommon<T>(spn, mapper_iter, map_filler, std::move(signalName), reportOnConstruction);
        }
 
        /** Returns a unitless version of the StatusSignalValue by value. Do not store the result in a reference. */
        template <typename T, typename U>
        StatusSignalValue<T> LookupDimensionlessStatusSignalValue(uint16_t spn, std::string signalName)
        {
            return StatusSignalValue<T>{LookupStatusSignalValue<U>(spn, std::move(signalName), true)};
        }
 
        void ReportIfTooOld(int minMajor, int minMinor, int minBugfix, int minBuild);
    };
 
}
}
}