RobotController.hpp

#ifndef KINEMATICS_ROBOTCONTROLLER_HPP
#define KINEMATICS_ROBOTCONTROLLER_HPP

#include <ros/ros.h>
#include "Planner.hpp"
#include <Kinematics/ConcurrentQueue.hpp>
#include <Kinematics/Matrix.hpp>

#include <mutex>
#include <stdexcept>
#include <thread>
#include <unordered_set>

#include "RobotDriverHandler.hpp"

namespace HLR
{
namespace Kinematics
{
struct EnvironmentObject
{
    std::uint32_t id;

    Matrix<double, 3, 1> position;

    Matrix<double, 3, 1> velocity;

    bool is_cup;

    bool has_speed;

    std::string polyhedron;
};

enum class RobotControllerState
{
    init,

    idle,

    moving_to_ready,

    moving_to_cup,

    stopped
};

enum class ArmError
{
    safety_concern,

    no_path_found,

    driver_error
};

class RobotController
{
public:
    enum class Event
    {
        move_to_ready,

        pick_up_cup,

        move_stop,

        move_continue,

        move_cancel,

        arm_move_complete,

        terminate
    };

    RobotController(RobotDriverHandler& driver);

    virtual ~RobotController();

    RobotController(const RobotController& rc) = delete;

    RobotController(RobotController&& rc) = delete;

    RobotController& operator=(const RobotController& rc) = delete;

    RobotController& operator=(RobotController&& rc) = delete;

    RobotControllerState get_state() const;

    void pick_up_cup(std::uint32_t id);

    void move_stop();

    void move_continue();

    void move_cancel();

    void remove_object(const EnvironmentObject& obj);

    void add_object(EnvironmentObject&& obj);

    void set_error_callback(const std::function<void(ArmError)>& cb);

private:
    void move_to_position(const Matrix<double, 3, 1>& pos,
                          const Planner& planner,
                          double speed);

    void event_handler();

    void move_to_ready_handler();

    void pick_up_cup_handler();

    void arm_move_complete_handler();

    void move_stop_handler();

    void move_continue_handler();

    void move_cancel_handler();

    const Matrix<double, 3, 1> target_position = {{0}, {0}, {0}};

    const Matrix<double, 3, 1> ready_pos = {{0.357}, {0.216506}, {0}};

    const double ground_level = 0;

    const double angle_step_size = 1;

    const double euclidean_step_size = 0.01;

    std::function<void(ArmError)> error_callback;

    bool is_carrying = false;

    RobotControllerState state = RobotControllerState::init;

    mutable std::mutex state_m;

    Matrix<double, 3, 1> cup_position;

    std::unordered_map<std::uint32_t, EnvironmentObject> objects;

    mutable std::mutex objects_m;

    std::thread worker;

    ConcurrentQueue<Event> events;

    RobotDriverHandler& driver;
};

} // namespace Kinematics
} // namespace HLR

#endif