HootAutoReplay.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/phoenix6/HootReplay.hpp"
#include "ctre/phoenix6/SignalLogger.hpp"
#include "ctre/phoenix6/SignalMeasurement.hpp"
#include "ctre/phoenix6/Utils.hpp"
#include <functional>
 
namespace ctre {
namespace phoenix6 {
 
/**
 * \brief Class for handling automatic logging and replay of custom signal inputs.
 * Each subsystem typically creates a new instance of this class.
 *
 * Note that all StatusSignals are automatically logged and replayed, so they
 * do not need to be registered with this class. Additionally, the SignalLogger
 * must be separately started at the start of the robot program.
 *
 * \details "Inputs" are signals measured directly from devices that should be
 * replayed unmodified. By comparison, a processed signal, such as a signal
 * indicating that a mechanism has reached the target, is considered an "output".
 * This class should only be used with inputs.
 *
 * Inputs are registered with a getter that returns a value to log and a setter
 * that updates the value in your robot program. For example, a `Vision` class
 * with a `Pose2d cameraPose` input would register the input using:
 *
 * ```
 * HootAutoReplay autoReplay = HootAutoReplay{}
 *     .WithStruct<wpi::math::Pose2d>(
 *         "Vision/CameraPose",
 *         [this]() -> wpi::math::Pose2d const& { return cameraPose; },
 *         [this](SignalMeasurement<wpi::math::Pose2d> val) {
 *             cameraPose = val.value;
 *         }
 *     );
 * ```
 *
 * After registering all relevant inputs, call #Update() periodically
 * to perform the following:
 *
 * - In normal/simulated robot operation, registered inputs will be
 *   fetched from your robot code using the provided getter and then
 *   logged using the SignalLogger.
 *
 * - During Hoot Replay, registered inputs will be fetched from
 *   HootReplay and then updated in your robot code using the
 *   provided setter.
 *
 * Note that for non-primitive types, the getter function must return a
 * reference to or std::span/std::string_view over the original data. As a
 * result, it cannot return a temporary value. If a getter lambda must return
 * a temporary value, capture a shared_ptr in the lambda, then modify and
 * return the value stored in the shared_ptr.
 */
class HootAutoReplay {
    std::vector<std::function<void(wpi::units::second_t)>> updates;
 
public:
    /**
     * \brief Updates the state of the robot program by doing one of the following:
     *
     * - In normal/simulated robot operation, registered signals will be
     *   fetched from your robot code using the provided getter and then
     *   logged using the SignalLogger.
     *
     * - During Hoot Replay, registered signals will be fetched from
     *   HootReplay and then updated in your robot code using the
     *   provided setter.
     *
     * This should be called periodically, typically in the subsystem.
     */
    void Update() const
    {
        auto const timestamp = utils::GetCurrentTime();
        for (auto const &update : updates) {
            update(timestamp);
        }
    }
 
#if (__has_include(<wpi/system/RobotController.hpp>) && __has_include(<wpi/system/Timer.hpp>)) || defined(_CTRE_DOCS_)
    /**
     * \brief Registers Timer::GetTimestamp() logging and playback with this
     * instance. This should only be applied to one instance in the robot
     * program.
     *
     * \returns this object
     */
    HootAutoReplay &WithTimestampReplay();
#endif
 
#if (__has_include(<wpi/driverstation/internal/DriverStationBackend.hpp>) && __has_include(<wpi/simulation/DriverStationSim.hpp>)) || defined(_CTRE_DOCS_)
    /**
     * \brief Registers Driver Station logging and playback with this instance,
     * excluding joysticks and match info. This should only be applied to one
     * instance in the robot program.
     *
     * The #Update() of this HootAutoReplay instance should be scheduled
     * in the Robot constructor using AddPeriodic() with an offset of -1 ms:
     * ```
     * AddPeriodic([this] { autoReplay.Update(); }, DEFAULT_PERIOD, -1_ms);
     * ```
     *
     * \returns this object
     */
    HootAutoReplay &WithDriverStationReplay();
 
    /**
     * \brief Registers joystick logging and playback with this instance.
     * This should only be applied to one instance in the robot program.
     *
     * To get joysticks to play back during Hoot Replay, "Turn off DS" must be
     * checked in the simulation GUI (under "DS" at the top of the window).
     *
     * The #Update() of this HootAutoReplay instance should be scheduled
     * in the Robot constructor using AddPeriodic() with an offset of -1 ms:
     * ```
     * AddPeriodic([this] { autoReplay.Update(); }, DEFAULT_PERIOD, -1_ms);
     * ```
     *
     * \returns this object
     */
    HootAutoReplay &WithJoystickReplay();
 
    /**
     * \brief Registers match info logging and playback with this instance.
     * This should only be applied to one instance in the robot program.
     *
     * The #Update() of this HootAutoReplay instance should be scheduled
     * in the Robot constructor using AddPeriodic() with an offset of -1 ms:
     * ```
     * AddPeriodic([this] { autoReplay.Update(); }, DEFAULT_PERIOD, -1_ms);
     * ```
     *
     * \returns this object
     */
    HootAutoReplay &WithMatchInfoReplay();
#endif
 
    /**
     * \brief Registers the schema-serialized bytes as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param schemaName Name of the schema
     * \param type Type of the schema, such as struct or protobuf
     * \param schema Schema bytes to write
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithSchemaValue(
        std::string name, std::string schemaName,
        HootSchemaType type, std::span<uint8_t const> schema,
        std::function<std::span<uint8_t const>()> getter,
        std::function<void(SignalMeasurement<std::vector<uint8_t>>)> setter
    );
 
    /**
     * \brief Registers the schema-serialized bytes as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param schemaName Name of the schema
     * \param type Type of the schema, such as struct or protobuf
     * \param schema Schema string to write
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithSchemaValue(
        std::string name, std::string schemaName,
        HootSchemaType type, std::string_view schema,
        std::function<std::span<uint8_t const>()> getter,
        std::function<void(SignalMeasurement<std::vector<uint8_t>>)> setter
    );
 
#if __has_include(<wpi/util/struct/Struct.hpp>) || defined(_CTRE_DOCS_)
    /**
     * \brief Registers the WPILib Struct as a Hoot-Replayed input.
     *
     * \tparam T Struct type
     * \tparam I Struct info types
     * \param name Name of the signal in the log
     * \param info Optional struct type info
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    template <typename T, typename... I>
        requires wpi::util::StructSerializable<T, I...>
    HootAutoReplay &WithStruct(
        std::string name, I &&... info,
        std::function<T const &()> getter,
        std::function<void(SignalMeasurement<T>)> setter
    ) {
        if (utils::IsReplay()) {
            updates.emplace_back([name=std::move(name), ... info=std::forward<I>(info), setter=std::move(setter)](auto) {
                auto val = HootReplay::GetStruct<T>(name, info...);
                if (val.status.IsOK() && val.value) {
                    SignalMeasurement<T> v{
                        std::move(val.name),
                        std::move(*val.value),
                        val.timestamp,
                        std::move(val.units),
                        val.status
                    };
                    setter(std::move(v));
                }
            });
        } else {
            updates.emplace_back([name=std::move(name), ... info=std::forward<I>(info), getter=std::move(getter)](auto timestamp) {
                SignalLogger::WriteStruct(name, info..., getter(), timestamp);
            });
        }
        return *this;
    }
 
    /**
     * \brief Registers the array of WPILib Structs as a Hoot-Replayed input.
     *
     * \tparam T Struct type
     * \tparam I Struct info types
     * \param name Name of the signal in the log
     * \param info Optional struct type info
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    template <typename T, typename... I>
        requires wpi::util::StructSerializable<T, I...>
    HootAutoReplay &WithStructArray(
        std::string name, I &&... info,
        std::function<std::span<T const>()> getter,
        std::function<void(SignalMeasurement<std::vector<T>>)> setter
    ) {
        if (utils::IsReplay()) {
            updates.emplace_back([name=std::move(name), ... info=std::forward<I>(info), setter=std::move(setter)](auto) {
                auto val = HootReplay::GetStructArray<T>(name, info...);
                if (val.status.IsOK() && val.value) {
                    SignalMeasurement<std::vector<T>> v{
                        std::move(val.name),
                        std::move(*val.value),
                        val.timestamp,
                        std::move(val.units),
                        val.status
                    };
                    setter(std::move(v));
                }
            });
        } else {
            updates.emplace_back([name=std::move(name), ... info=std::forward<I>(info), getter=std::move(getter)](auto timestamp) {
                SignalLogger::WriteStructArray(name, info..., getter(), timestamp);
            });
        }
        return *this;
    }
#endif
 
#if __has_include(<wpi/util/protobuf/Protobuf.hpp>) || defined(_CTRE_DOCS_)
    /**
     * \brief Registers the protobuf as a Hoot-Replayed input.
     *
     * \tparam T Protobuf type
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    template <wpi::util::ProtobufSerializable T>
    HootAutoReplay &WithProtobuf(
        std::string name,
        std::function<T const &()> getter,
        std::function<void(SignalMeasurement<T>)> setter
    ) {
        if (utils::IsReplay()) {
            updates.emplace_back([name=std::move(name), setter=std::move(setter)](auto) {
                auto val = HootReplay::GetProtobuf<T>(name);
                if (val.status.IsOK() && val.value) {
                    SignalMeasurement<T> v{
                        std::move(val.name),
                        std::move(*val.value),
                        val.timestamp,
                        std::move(val.units),
                        val.status
                    };
                    setter(std::move(v));
                }
            });
        } else {
            updates.emplace_back([name=std::move(name), getter=std::move(getter)](auto timestamp) {
                SignalLogger::WriteProtobuf(name, getter(), timestamp);
            });
        }
        return *this;
    }
#endif
 
    /**
     * \brief Registers the raw data bytes as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithRaw(
        std::string name,
        std::function<std::span<uint8_t const>()> getter,
        std::function<void(SignalMeasurement<std::vector<uint8_t>>)> setter
    );
 
    /**
     * \brief Registers the boolean as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithBoolean(
        std::string name,
        std::function<bool()> getter,
        std::function<void(SignalMeasurement<bool>)> setter
    );
 
    /**
     * \brief Registers the integer as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithInteger(
        std::string name,
        std::function<int64_t()> getter,
        std::function<void(SignalMeasurement<int64_t>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the float as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithFloat(
        std::string name,
        std::function<float()> getter,
        std::function<void(SignalMeasurement<float>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the double as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithDouble(
        std::string name,
        std::function<double()> getter,
        std::function<void(SignalMeasurement<double>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the string as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithString(
        std::string name,
        std::function<std::string_view()> getter,
        std::function<void(SignalMeasurement<std::string>)> setter
    );
 
    /**
     * \brief Registers the unit value as a Hoot-Replayed input.
     *
     * \tparam U Unit type
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    template <typename U>
        requires wpi::units::traits::is_unit_t_v<U>
    HootAutoReplay &WithValue(
        std::string name,
        std::function<U()> getter,
        std::function<void(SignalMeasurement<U>)> setter
    ) {
        if (utils::IsReplay()) {
            updates.emplace_back([name=std::move(name), setter=std::move(setter)](auto) {
                auto val = HootReplay::GetValue<U>(name);
                if (val.status.IsOK()) {
                    setter(std::move(val));
                }
            });
        } else {
            updates.emplace_back([name=std::move(name), getter=std::move(getter)](auto timestamp) {
                SignalLogger::WriteValue(name, getter(), timestamp);
            });
        }
        return *this;
    }
 
    /**
     * \brief Registers the array of booleans as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithBooleanArray(
        std::string name,
        std::function<std::span<bool const>()> getter,
        std::function<void(SignalMeasurement<std::vector<uint8_t>>)> setter
    );
 
    /**
     * \brief Registers the array of booleans as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithBooleanArray(
        std::string name,
        std::function<std::span<uint8_t const>()> getter,
        std::function<void(SignalMeasurement<std::vector<uint8_t>>)> setter
    );
 
    /**
     * \brief Registers the array of integers as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithIntegerArray(
        std::string name,
        std::function<std::span<int64_t const>()> getter,
        std::function<void(SignalMeasurement<std::vector<int64_t>>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the array of floats as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithFloatArray(
        std::string name,
        std::function<std::span<float const>()> getter,
        std::function<void(SignalMeasurement<std::vector<float>>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the array of doubles as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \param units Units of the signal in the log
     * \returns this object
     */
    HootAutoReplay &WithDoubleArray(
        std::string name,
        std::function<std::span<double const>()> getter,
        std::function<void(SignalMeasurement<std::vector<double>>)> setter,
        std::string units = ""
    );
 
    /**
     * \brief Registers the array of strings as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithStringArray(
        std::string name,
        std::function<std::span<std::string_view const>()> getter,
        std::function<void(SignalMeasurement<std::vector<std::string>>)> setter
    );
 
    /**
     * \brief Registers the array of strings as a Hoot-Replayed input.
     *
     * \param name Name of the signal in the log
     * \param getter Function that returns the current value of the input
     * \param setter Function that sets the input to a new value
     * \returns this object
     */
    HootAutoReplay &WithStringArray(
        std::string name,
        std::function<std::span<std::string const>()> getter,
        std::function<void(SignalMeasurement<std::vector<std::string>>)> setter
    );
};
 
}
}