Jason.h

Go to the documentation of this file.

 
#ifndef JASON_H
#define JASON_H
 
#include <Arduino.h>
 
#include <Ain.h>
#include <Buttons.h>
#include <CompoI.h>
#include <EEPROM.h>
#include <Monitor.h>
#include <Motors.h>
#include <Mpu_6050_dmp.h>
#include <Qmc5883l.h>
#include <Saved_data.h>
#include <Uts_gpio.h>
#include <Uts_i2c.h>
#include <Uts_uart.h>
#include <Vl53l0x.h>
#include <Serial_packer.h>
#include <Serial_unpacker.h>

struct uts_aio_ptr_t {
    union {
        Vl53l0x *lidar_ptr;
        Uts_i2c *uts_i2c_ptr;
        Uts_uart *uts_uart_ptr;
        Uts_gpio *uts_gpio_ptr;
    };
    uint8_t uts_mode;
};

struct heading_ptr_t {
    union {
        Qmc5883l *qmc_ptr;
        Mpu_6050_dmp *mpu_ptr;
    };
    uint8_t heading_use_mpu;
};

struct uart_conn_ptr_t {
    HardwareSerial *uart_ptr;
    uint32_t uart_baud;
};
 
// JM9 UART packet:
// start-byte
// length-byte (sum of amount of cmd/reg-byte and data-bytes)
// (cmd/reg-byte)
// data-bytes (variable length)
// xor-byte (xor of start-byte and length-byte and cmd/reg-byte and data-bytes)
//
// reject entire packet if xor-byte is not matched

class JM9_packer : public Serial_packer {
    public:
        JM9_packer (HardwareSerial &init_uart, const uint8_t init_start_byte);
};

class JM9_unpacker : public Serial_unpacker {
    public:
        JM9_unpacker (HardwareSerial &init_uart, const uint8_t init_start_byte);
};

class Jason : public Print {
    private:
        //
    protected:
        //
        static const uint8_t EEPROM_IMG_OFFSET;
        //
        uint8_t eeprom_img [32];
        // motor pointers
        Mtr *mtrs [4];
        // compoi pointers
        CompoI *compois [2];
        // whether the compound eyes are daisy chained
        // If this is the case,
        // then we get data from
        // only the forward compound eye
        // to get 360 degree data.
        bool are_compois_daisy_chained;
        // uts pointers
        uts_aio_ptr_t utss [4];
        // heading pointer
        heading_ptr_t heading;
        // cam pointer
        uart_conn_ptr_t cam;
        // kicker pin
        uint32_t kicker_pin;
        // dribbler pin
        uint32_t dribbler_pin;
        // comm pointer
        uart_conn_ptr_t comm;
        // display printing coordinates
        uint16_t xc, yc;
    
    public:
        // basic functions
        Jason ();
        ~Jason ();
        // library setup functions
        //
        void load_saved_info ();
        //
        void store_saved_info ();
        //
        void set_motor_port (const uint8_t mtr_idx, const uint8_t port);
        //
        uint8_t get_motor_port (const uint8_t mtr_idx);
        //
        void set_compoi_port (const uint8_t idx, const uint8_t port);
        //
        uint8_t get_compoi_port (const uint8_t idx);
        //
        void set_compoi_addr (const uint8_t idx, const uint8_t addr);
        //
        uint8_t get_compoi_addr (const uint8_t idx);
        //
        void set_uts_mode (const uint8_t side, const uint8_t mode);
        //
        uint8_t get_uts_mode (const uint8_t side);
        //
        void set_uts_port (const uint8_t side, const uint8_t port);
        //
        uint8_t get_uts_port (const uint8_t side);
        //
        void set_heading_port (const uint8_t port);
        //
        uint8_t get_heading_port ();
        //
        void set_heading_addr (const uint8_t addr);
        //
        uint8_t get_heading_addr ();
        //
        void set_cam_port (const uint8_t port);
        //
        uint8_t get_cam_port ();
        //
        void set_cam_baud (const uint32_t baud);
        //
        uint32_t get_cam_baud ();
        //
        void set_kicker_pin (const uint32_t pin);
        //
        uint32_t get_kicker_pin ();
        //
        void set_dribbler_pin (const uint32_t pin);
        //
        uint32_t get_dribbler_pin ();
        //
        void set_comm_port (const uint8_t port);
        //
        uint8_t get_comm_port ();
        //
        void set_comm_baud (const uint32_t baud);
        //
        uint32_t get_comm_baud ();
 
        // advanced functions

        void begin ();

        void end ();
 
        // motors

        void set_motor_spd (const uint8_t mtr_idx, int16_t spd);

        void polar_ctrl (int16_t angle, int16_t spd, int16_t rotation);

        void rect_ctrl (int16_t spd_x, int16_t spd_y, int16_t rotation);

        bool move_to (const uint8_t side1, const int16_t dist1, const uint8_t side2, const int16_t dist2, const int16_t target_heading = 0, const double rotation_kp = 1.2, const int16_t spd = 100, const int16_t threshold = 1);
        
        // grayscales
        
        virtual void gs ();
 
        // compound-eye

        int16_t get_ir_max_val ();

        int16_t get_ir_avg_val ();

        int8_t get_ir_max_idx ();

        int16_t get_ir_ball_angle ();
 
        // ultrasonics

        int16_t get_uts_dist (const uint8_t side);

        void disable_uts (const uint8_t side);

        void enable_uts (const uint8_t side);
 
        // heading

        int16_t get_heading ();

        void reset_heading ();

        int16_t get_rotation_spd (const int16_t target_heading = 0);
 
        // camera

        virtual int16_t get_orange_ball_dist ();

        virtual int16_t get_orange_ball_angle ();

        virtual int16_t get_opponent_goal_dist ();

        virtual int16_t get_opponent_goal_angle ();

        virtual int16_t get_my_goal_dist ();

        virtual int16_t get_my_goal_angle ();
 
        // kicker

        virtual void set_kicker_state (const bool state);

        virtual bool get_kicker_state ();
 
        // dribbler

        virtual void set_dribbler_spd (const int16_t spd);
 
        // monitor

        void clear_mon ();

        void set_cursor (int16_t x, int16_t y);
        //
        size_t print(const __FlashStringHelper *);
        size_t print(const String &);
        size_t print(const char[]);
        size_t print(char);
        size_t print(unsigned char, int = DEC);
        size_t print(int, int = DEC);
        size_t print(unsigned int, int = DEC);
        size_t print(long, int = DEC);
        size_t print(unsigned long, int = DEC);
        size_t print(double, int = 2);
        size_t print(const Printable&);
        //
        size_t write(uint8_t);
 
        // communication : TO-DO
};

extern Jason robot;

enum mtr_idx_t {
    LF = 0,

    RF = 1,

    RB = 2,

    LB = 3
};

enum side_t {
    front = 0,

    left  = 1,

    right = 2,

    back  = 3
};
 
#endif // #ifndef JASON_H