CANBus.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/phoenix6/HootReplay.hpp"
#include <string>
 
namespace ctre {
namespace phoenix6 {
 
/**
 * \brief Class for getting information about an available CAN bus.
 */
class CANBus {
public:
    /**
     * \brief Contains status information about a CAN bus.
     */
    struct CANBusStatus {
        /**
         * \brief Status code response of getting the data
         */
        ctre::phoenix::StatusCode Status;
 
        /**
         * \brief CAN bus utilization, from 0.0 to 1.0
         */
        float BusUtilization;
        /**
         * \brief Bus off count
         */
        uint32_t BusOffCount;
        /**
         * \brief Transmit buffer full count
         */
        uint32_t TxFullCount;
        /**
         * \brief Receive Error Counter (REC)
         */
        uint32_t REC;
        /**
         * \brief Transmit Error Counter (TEC)
         */
        uint32_t TEC;
    };
 
private:
    std::string_view _name;
 
public:
    /**
     * \brief Creates a new CAN bus with the given name.
     *
     * For the native Systemcore CAN buses, use #Systemcore instead.
     *
     * For the Motioncore CAN buses, use #Motioncore instead.
     *
     * \param canbus    Name of the CAN bus. Possible CAN bus strings are:
     *                  - "can_s0" to "can_s24" for the native Systemcore/Motioncore CAN buses
     *                  - CANivore name or serial number
     *                  - SocketCAN interface (non-FRC Linux only)
     *                  - "*" for any CANivore seen by the program
     *                  - empty string (default) to select the default for the system:
     *                    - "can_s1" on Systemcore
     *                    - "can0" on Linux
     *                    - "*" on Windows
     */
    constexpr CANBus(std::string_view canbus = "") :
        _name{canbus}
    {}
 
    /**
     * \brief Creates a new CAN bus with the given name, and loads an associated
     * hoot file for replay (equivalent to HootReplay#LoadFile).
     *
     * Only one hoot log may be replayed at a time. As a result, only one
     * CAN bus should be constructed with a hoot file.
     *
     * When using relative paths, the file path is typically relative
     * to the top-level folder of the robot project.
     *
     * For the native Systemcore CAN buses, use #Systemcore instead.
     *
     * For the Motioncore CAN buses, use #Motioncore instead.
     *
     * \param canbus    Name of the CAN bus. Possible CAN bus strings are:
     *                  - "can_s0" to "can_s24" for the native Systemcore/Motioncore CAN buses
     *                  - CANivore name or serial number
     *                  - SocketCAN interface (non-FRC Linux only)
     *                  - "*" for any CANivore seen by the program
     *                  - empty string (default) to select the default for the system:
     *                    - "can_s1" on Systemcore
     *                    - "can0" on Linux
     *                    - "*" on Windows
     * \param hootFilepath Path and name of the hoot file to load
     */
    CANBus(std::string_view canbus, char const *hootFilepath) :
        CANBus{canbus}
    {
        HootReplay::LoadFile(hootFilepath);
    }
 
    /**
     * \brief Creates a new CAN bus for one of the native Systemcore buses.
     *
     * For the Motioncore CAN buses, use #Motioncore instead.
     *
     * \param canbus Index of the Systemcore bus, from 0-4
     * \returns A native Systemcore CAN bus
     */
    static constexpr CANBus Systemcore(int canbus)
    {
        if (canbus < 0 || canbus > 4) [[unlikely]] {
            throw std::invalid_argument{"Systemcore CAN bus index must be within 0-4."};
        }
        switch (canbus) {
            case 0: return {"can_s0"};
            case 1: return {"can_s1"};
            case 2: return {"can_s2"};
            case 3: return {"can_s3"};
            case 4: return {"can_s4"};
            default: return {};
        }
    }
 
    /**
     * \brief Creates a new CAN bus for one of the native Systemcore buses,
     * and loads an associated hoot file for replay (equivalent to
     * HootReplay#LoadFile).
     *
     * Only one hoot log may be replayed at a time. As a result, only one
     * CAN bus should be constructed with a hoot file.
     *
     * When using relative paths, the file path is typically relative
     * to the top-level folder of the robot project.
     *
     * For the Motioncore CAN buses, use #Motioncore instead.
     *
     * \param canbus Index of the Systemcore bus, from 0-4
     * \param hootFilepath Path and name of the hoot file to load
     * \returns A native Systemcore CAN bus
     */
    static CANBus Systemcore(int canbus, char const *hootFilepath)
    {
        auto retval = Systemcore(canbus);
        HootReplay::LoadFile(hootFilepath);
        return retval;
    }
 
    /**
     * \brief Creates a new CAN bus for one of the Motioncore ports.
     *
     * \param port The Motioncore port, from 0-19
     * \returns A Motioncore CAN bus
     */
    static constexpr CANBus Motioncore(int port)
    {
        if (port < 0 || port > 19) [[unlikely]] {
            throw std::invalid_argument{"Motioncore port must be within 0-19."};
        }
        switch (port) {
            case 0: return {"can_s5"};
            case 1: return {"can_s6"};
            case 2: return {"can_s7"};
            case 3: return {"can_s8"};
            case 4: return {"can_s9"};
            case 5: return {"can_s10"};
            case 6: return {"can_s11"};
            case 7: return {"can_s12"};
            case 8: return {"can_s13"};
            case 9: return {"can_s14"};
            case 10: return {"can_s15"};
            case 11: return {"can_s16"};
            case 12: return {"can_s17"};
            case 13: return {"can_s18"};
            case 14: return {"can_s19"};
            case 15: return {"can_s20"};
            case 16: return {"can_s21"};
            case 17: return {"can_s22"};
            case 18: return {"can_s23"};
            case 19: return {"can_s24"};
            default: return {};
        }
    }
 
    /**
     * \brief Creates a new CAN bus for one of the Motioncore ports,
     * and loads an associated hoot file for replay (equivalent to
     * HootReplay#LoadFile).
     *
     * Only one hoot log may be replayed at a time. As a result, only one
     * CAN bus should be constructed with a hoot file.
     *
     * When using relative paths, the file path is typically relative
     * to the top-level folder of the robot project.
     *
     * \param port The Motioncore port, from 0-19
     * \param hootFilepath Path and name of the hoot file to load
     * \returns A Motioncore CAN bus
     */
    static CANBus Motioncore(int port, char const *hootFilepath)
    {
        auto retval = Motioncore(port);
        HootReplay::LoadFile(hootFilepath);
        return retval;
    }
 
    /**
     * \brief Get the name used to construct this CAN bus.
     *
     * \returns Name of the CAN bus
     */
    constexpr std::string_view GetName() const
    {
        return _name;
    }
 
    /**
     * \brief Gets whether the CAN bus is a CAN FD network.
     *
     * \returns True if the CAN bus is CAN FD
     */
    bool IsNetworkFD() const;
    /**
     * \brief Gets the status of the CAN bus, including the
     * bus utilization and the error counters.
     *
     * This can block for up to 0.001 seconds (1 ms).
     *
     * \returns Status of the CAN bus
     */
    CANBusStatus GetStatus() const;
 
    friend std::ostream &operator<<(std::ostream &os, CANBus const &canbus);
 
    constexpr friend bool operator==(CANBus const &, CANBus const &) = default;
    constexpr friend auto operator<=>(CANBus const &, CANBus const &) = default;
};
 
}
}
 
template <>
struct std::hash<ctre::phoenix6::CANBus> {
    size_t operator()(ctre::phoenix6::CANBus const &canbus) const noexcept
    {
        return std::hash<std::string_view>{}(canbus.GetName());
    }
};