hardware.hpp

#pragma once
#include "api.h"
#include "helpers.hpp"
#include "odom.hpp"
#include "vex_macro.hpp"
#include <memory>
 
class FlipToggleHeight;
 
enum StandardPorts
{ // Negative == reversed
        motor_left_front = -14,
        motor_left_mid = -15,
        motor_left_rear = -13,
 
        motor_right_front = 11,
        motor_right_mid = 12,
        motor_right_rear = 14,
 
        imu = 5,
 
        motor_intake_11W = -16,
        motor_intake_5W5_L = -19,
        motor_intake_5W5_U = 20,
 
        motor_score_open = -1,
        motor_score_roll = -2,
 
        odom_rear = 9,
        odom_left = 4,
        odom_right = 3,
 
        distance = 3,
};
 
enum Triports
{
 
};
 
struct MotorWrapper
{
        std::unique_ptr<pros::Motor> motor;
        pros_standard_port port;
        pros::motor_gearset_e_t gearset;
 
        MotorWrapper(void) : port(0), gearset(pros::E_MOTOR_GEAR_BLUE) {};
        MotorWrapper(const pros_standard_port port, const pros::motor_gearset_e_t gearset = pros::E_MOTOR_GEAR_BLUE) : port(port), gearset(gearset) {};
        ~MotorWrapper(void);
 
        void MotorWrapper_Init() {
                if (!motor) {
                        motor = std::make_unique<pros::Motor>(port);
                        motor->set_brake_mode(pros::MotorBrake::brake);
                        motor->set_gearing(gearset);
                }
        }
 
        void operator=(pros::Motor m) {
                this->motor = std::make_unique<pros::Motor>(m);
        }
 
        void set(int speed);
};
 
struct MotorGroupWrapper
{
        std::vector<MotorWrapper*> motors;
 
        void set(int speed) {
                for (MotorWrapper* m : motors) {
                        if (m)
                                m->set(speed);
                }
        }
 
        MotorGroupWrapper(void) {};
        MotorGroupWrapper(MotorWrapper* m1, MotorWrapper* m2, MotorWrapper* m3);
};
 
struct Hardware
{
public:
        struct
        {
                MotorWrapper MOTOR_L1;
                MotorWrapper MOTOR_L2;
                MotorWrapper MOTOR_L3;
 
                MotorWrapper MOTOR_R1;
                MotorWrapper MOTOR_R2;
                MotorWrapper MOTOR_R3;
 
                MotorWrapper MOTOR_INTAKE_11W;
                MotorWrapper MOTOR_INTAKE_5W5_LOWER;
                MotorWrapper MOTOR_INTAKE_5W5_UPPER;
                MotorWrapper MOTOR_SCORE_OPEN;
                MotorWrapper MOTOR_SCORE_ROLL;
        } Motors;
 
        struct
        {
                MotorGroupWrapper MOTORGROUP_L;
                MotorGroupWrapper MOTORGROUP_R;
                MotorGroupWrapper MOTORGROUP_INTAKE;
        } Motorgroups;
 
        std::unique_ptr<pros::Controller> PRIMARY_CONTROLLER;
 
        struct
        {
                std::unique_ptr<pros::Rotation> VerticalWheel;
                std::unique_ptr<pros::Rotation> HorizontalWheel;
 
                std::unique_ptr<pros::Distance> distance;
        } Odom;
 
        struct {
                std::unique_ptr<FlipToggleHeight> flipToggleHeight;
        } Macros;
 
        Hardware(void);
        ~Hardware(void);
 
        void LoadPeripherals(void);
 
 
private:
        Hardware(const Hardware&) = delete;
        Hardware& operator=(const Hardware&) = delete;
};
 
static Hardware robotHardware = Hardware();