RBControl_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <freertos/FreeRTOS.h>
#include <freertos/queue.h>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <vector>
 
#include "Adafruit_MCP23017.h"
#include "RBControl_battery.hpp"
#include "RBControl_encoder.hpp"
#include "RBControl_leds.hpp"
#include "RBControl_motor.hpp"
#include "RBControl_nvs.hpp"
#include "RBControl_piezo.hpp"
#include "RBControl_servo.hpp"
#include "RBControl_timers.hpp"
 
namespace rb {
 
class MotorChangeBuilder;
 
enum ManagerInstallFlags {
    MAN_NONE = 0,
    MAN_DISABLE_MOTOR_FAILSAFE = (1 << 0), 
    MAN_DISABLE_BATTERY_MANAGEMENT = (1 << 1), 
    MAN_DISABLE_PIEZO = (1 << 2), 
};
 
inline ManagerInstallFlags operator|(ManagerInstallFlags a, ManagerInstallFlags b) {
    return static_cast<ManagerInstallFlags>(static_cast<int>(a) | static_cast<int>(b));
}
 
// Periodically print info about all rbcontrol tasks to the console
//#define RB_DEBUG_MONITOR_TASKS 1
 
class Manager {
    friend class MotorChangeBuilder;
    friend class Encoder;
    friend class PcntInterruptHandler;
 
public:
    Manager(Manager const&) = delete;
    void operator=(Manager const&) = delete;
 
    static Manager& get() {
        static Manager instance;
        return instance;
    }
 
    void install(ManagerInstallFlags flags = MAN_NONE);
 
    SmartServoBus& initSmartServoBus(uint8_t servo_count, gpio_num_t pin = GPIO_NUM_32, uart_port_t uart = UART_NUM_1);
    SmartServoBus& servoBus() { return m_servos; };
 
    Adafruit_MCP23017& expander() { return m_expander; } 
    Piezo& piezo() { return m_piezo; } 
    Battery& battery() { return m_battery; } 
    Leds& leds() { return m_leds; } 
 
    Motor& motor(MotorId id) { return *m_motors[static_cast<int>(id)]; }; 
    MotorChangeBuilder setMotors(); 
 
    Nvs& config() { return m_config; }
 
    void schedule(uint32_t period_ms, std::function<bool()> callback) {
        timers().schedule(period_ms, callback);
    }
 
    inline Timers& timers() { return rb::Timers::get(); }
 
    // internal api to monitor RBControl tasks
    void monitorTask(TaskHandle_t task);
 
private:
    Manager();
    ~Manager();
 
    enum EventType {
        EVENT_MOTORS,
        EVENT_MOTORS_STOP_ALL,
        EVENT_ENCODER_EDGE,
        EVENT_ENCODER_PCNT,
    };
 
    struct EventMotorsData {
        bool (Motor::*setter_func)(int8_t);
        MotorId id;
        int8_t value;
    };
 
    struct Event {
        EventType type;
        union {
            std::vector<EventMotorsData>* motors;
 
            struct {
                int64_t timestamp;
                MotorId id;
                uint8_t pinLevel;
            } encoderEdge;
 
            struct {
                uint32_t status;
                MotorId id;
            } encoderPcnt;
        } data;
    };
 
    void queue(const Event* event, bool toFront = false);
    bool queueFromIsr(const Event* event, bool toFront = false);
    static void consumerRoutineTrampoline(void* cookie);
    void consumerRoutine();
    void processEvent(struct Event* ev);
 
    bool motorsFailSafe();
 
    void setupExpander();
 
#ifdef RB_DEBUG_MONITOR_TASKS
    bool printTasksDebugInfo();
 
    std::vector<TaskHandle_t> m_tasks;
    std::mutex m_tasks_mutex;
#endif
 
    QueueHandle_t m_queue;
 
    TickType_t m_motors_last_set;
    std::vector<std::unique_ptr<Motor>> m_motors;
    SerialPWM m_motors_pwm;
 
    Adafruit_MCP23017 m_expander;
    rb::Piezo m_piezo;
    rb::Leds m_leds;
    rb::Battery m_battery;
    rb::SmartServoBus m_servos;
    rb::Nvs m_config;
};
 
class MotorChangeBuilder {
public:
    MotorChangeBuilder(Manager& manager);
    MotorChangeBuilder(const MotorChangeBuilder& o) = delete;
    MotorChangeBuilder(MotorChangeBuilder&& o);
    ~MotorChangeBuilder();
 
    MotorChangeBuilder& power(MotorId id, int8_t value);
 
    MotorChangeBuilder& pwmMaxPercent(MotorId id, int8_t percent);
 
    MotorChangeBuilder& stop(MotorId id);
 
    void set(bool toFront = false);
 
private:
    Manager& m_manager;
    std::unique_ptr<std::vector<Manager::EventMotorsData>> m_values;
};
 
} // namespace rb