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 <wpi/hardware/bus/CANPort.hpp>
#include <wpi/units/dimensionless.hpp>
#include <iosfwd>
#include <stdexcept>
#include <string>
 
namespace ctre {
namespace phoenix6 {
 
/**
 * \brief Possible states of the CAN bus.
 */
struct CANState {
    /** \brief Unique integer value of this CANState. */
    int value;
 
    /**
     * \brief The controller is in normal operation.
     */
    static constexpr int ErrorActive = 0;
    /**
     * \brief The controller has detected errors and is approaching the Error Passive state.
     */
    static constexpr int ErrorWarning = 1;
    /**
     * \brief The controller is in the "Error Passive" state and has detected many errors.
     */
    static constexpr int ErrorPassive = 2;
    /**
     * \brief The controller is in the "Bus Off" state after detecting too many errors.
     */
    static constexpr int BusOff = 3;
    /**
     * \brief The controller has been manually stopped.
     */
    static constexpr int Stopped = 4;
    /**
     * \brief The controller has entered low-power sleep mode.
     */
    static constexpr int Sleeping = 5;
 
    constexpr CANState(int value) :
        value{value}
    {}
 
    constexpr CANState() :
        value{-1}
    {}
 
    constexpr bool operator==(CANState other) const
    {
        return value == other.value;
    }
    constexpr auto operator<=>(CANState other) const
    {
        return value <=> other.value;
    }
 
    /**
     * \brief Gets the string representation of this enum
     *
     * \returns String representation of this enum
     */
    constexpr std::string_view ToString() const
    {
        switch (value) {
            case CANState::ErrorActive: return "ErrorActive";
            case CANState::ErrorWarning: return "ErrorWarning";
            case CANState::ErrorPassive: return "ErrorPassive";
            case CANState::BusOff: return "BusOff";
            case CANState::Stopped: return "Stopped";
            case CANState::Sleeping: return "Sleeping";
            default: return "Invalid Value";
        }
    }
 
    friend std::ostream &operator<<(std::ostream &os, CANState state);
};
 
/**
 * \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
     */
    wpi::units::unit_t<wpi::units::scalar, float> BusUtilization;
    /**
     * \brief Bus error count
     */
    uint32_t BusErrorCount;
    /**
     * \brief Arbitration lost count
     */
    uint32_t ArbitrationLostCount;
    /**
     * \brief Restart count
     */
    uint32_t RestartCount;
    /**
     * \brief Bus off count
     */
    uint32_t BusOffCount;
    /**
     * \brief Transmit buffer full count
     */
    uint32_t TxFullCount;
    /**
     * \brief Receive Error Counter (REC)
     */
    uint16_t REC;
    /**
     * \brief Transmit Error Counter (TEC)
     */
    uint16_t TEC;
    /**
     * \brief CAN state
     */
    CANState State;
 
    friend std::ostream &operator<<(std::ostream &os, CANBusStatus const &status);
    std::string ToString() const;
};
 
/**
 * \brief Class for getting information about an available CAN bus.
 */
class CANBus {
private:
    std::string_view _name;
 
    static constexpr std::string_view GetCANPortName(wpi::CANPort canPort)
    {
        switch (canPort) {
            case wpi::CANPort::CAN_S0: return "can_s0";
            case wpi::CANPort::CAN_S1: return "can_s1";
            case wpi::CANPort::CAN_S2: return "can_s2";
            case wpi::CANPort::CAN_S3: return "can_s3";
            case wpi::CANPort::CAN_S4: return "can_s4";
            case wpi::CANPort::CAN_D0: return "can_d0";
            case wpi::CANPort::CAN_D1: return "can_d1";
            case wpi::CANPort::CAN_D2: return "can_d2";
            case wpi::CANPort::CAN_D3: return "can_d3";
            case wpi::CANPort::CAN_D4: return "can_d4";
            case wpi::CANPort::CAN_D5: return "can_d5";
            case wpi::CANPort::CAN_D6: return "can_d6";
            case wpi::CANPort::CAN_D7: return "can_d7";
            case wpi::CANPort::CAN_D8: return "can_d8";
            case wpi::CANPort::CAN_D9: return "can_d9";
            case wpi::CANPort::CAN_D10: return "can_d10";
            case wpi::CANPort::CAN_D11: return "can_d11";
            case wpi::CANPort::CAN_D12: return "can_d12";
            case wpi::CANPort::CAN_D13: return "can_d13";
            case wpi::CANPort::CAN_D14: return "can_d14";
            case wpi::CANPort::CAN_D15: return "can_d15";
            case wpi::CANPort::CAN_D16: return "can_d16";
            case wpi::CANPort::CAN_D17: return "can_d17";
            case wpi::CANPort::CAN_D18: return "can_d18";
            case wpi::CANPort::CAN_D19: return "can_d19";
            default: throw std::invalid_argument{"Unexpected Systemcore CAN port " + std::to_string((int)canPort)};
        }
    }
 
public:
    /**
     * \brief Creates a new CAN bus with the given name.
     *
     * For the native Systemcore/Motioncore CAN buses, use #CANBus(wpi::CANPort) instead.
     *
     * \param canbus    Name of the CAN bus. Possible CAN bus strings are:
     *                  - "can_s0" to "can_s4" for the native Systemcore CAN buses
     *                  - "can_d0" to "can_d19" for the 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_s2" on Systemcore
     *                    - "can0" on Linux
     *                    - "*" on Windows
     */
    constexpr CANBus(std::string_view canbus = "") :
        _name{canbus}
    {}
 
    /**
     * \brief Creates a new CAN bus for one of the native Systemcore/Motioncore buses.
     *
     * For the CANivore and non-FRC SocketCAN interfaces, use #CANBus(std::string_view)
     * instead.
     *
     * \param canPort The Systemcore/Motioncore CAN port
     */
    constexpr CANBus(wpi::CANPort canPort) :
        CANBus{GetCANPortName(canPort)}
    {}
 
    /**
     * \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());
    }
};
 
#include <wpi/util/struct/Struct.hpp>
 
/** \brief WPILib Struct implementation for ctre#phoenix6#CANBusStatus. */
template <>
struct wpi::util::Struct<ctre::phoenix6::CANBusStatus> final {
    static constexpr std::string_view GetTypeName() { return "ctre_CANBusStatus"; }
    static constexpr size_t GetSize()
    {
        return wpi::util::GetStructSize<int32_t>() +
            wpi::util::GetStructSize<float>() +
            5 * wpi::util::GetStructSize<uint32_t>() +
            2 * wpi::util::GetStructSize<uint16_t>() +
            wpi::util::GetStructSize<int32_t>();
    }
    static constexpr std::string_view GetSchema()
    {
        return "int32 Status;"
            "float BusUtilization;"
            "uint32 BusErrorCount;"
            "uint32 ArbitrationLostCount;"
            "uint32 RestartCount;"
            "uint32 BusOffCount;"
            "uint32 TxFullCount;"
            "uint16 REC;"
            "uint16 TEC;"
            "enum{ErrorActive=0,ErrorWarning=1,ErrorPassive=2,BusOff=3,Stopped=4,Sleeping=5} int32 State";
    }
 
    static ctre::phoenix6::CANBusStatus Unpack(std::span<uint8_t const> data);
    static void Pack(std::span<uint8_t> data, ctre::phoenix6::CANBusStatus const &value);
};
 
static_assert(wpi::util::StructSerializable<ctre::phoenix6::CANBusStatus>);