puai_dispatch/dispatch/dispatch_device_base.h

//
// Created by huli on 2021/3/3.
//

#ifndef NNXX_TESTS_DISPATCH_DEVICE_BASE_H
#define NNXX_TESTS_DISPATCH_DEVICE_BASE_H

#include "../error_code/error_code.h"
#include <glog/logging.h>
#include <thread>
#include <mutex>
#include "../tool/thread_condition.h"
#include "../tool/common_data.h"
#include "../tool/time_tool.h"
#include "../task/task_base.h"
#include "../dispatch/dispatch_communication.h"
#include "../dispatch/dispatch_coordinates.h"

//调度设备的基类.
class Dispatch_device_base
{
public:
	//设备底层通信延时5000ms
#define	COMMUNICATION_OVER_TIME_MS	5000

//调度默认 差值 2mm (运动过程中进行比较, 对精度要求较高)
#define DISPATCH_DEFAULT_DIFFERENCE							2

//调度设备类型
	enum Dispatch_device_type
	{
		DISPATCH_DEVICE_UNKNOWN = 							0,
		DISPATCH_DEVICE_ROBOT_1 = 							101,
		DISPATCH_DEVICE_ROBOT_2 = 							102,
		DISPATCH_DEVICE_CARRIER_1 = 						200,
		DISPATCH_DEVICE_CARRIER_2 = 						207,
		DISPATCH_DEVICE_CARRIER_3 = 						203,
		DISPATCH_DEVICE_PASSAGEWAY_0 = 						300,
		DISPATCH_DEVICE_PASSAGEWAY_1 = 						301,
		DISPATCH_DEVICE_PASSAGEWAY_2 = 						302,
		DISPATCH_DEVICE_PASSAGEWAY_3 = 						303,
		DISPATCH_DEVICE_PASSAGEWAY_4 = 						304,
		DISPATCH_DEVICE_PASSAGEWAY_5 = 						305,
		DISPATCH_DEVICE_PASSAGEWAY_6 = 						306,
		DISPATCH_DEVICE_PASSAGEWAY_7 = 						307,
	};



	//设备状态,这个类的总状态,这里指工作任务流程
	enum Dispatch_device_status
	{
		DISPATCH_DEVICE_UNKNOW               	= 0,    //未知
		DISPATCH_DEVICE_READY               	= 1,    //准备，待机
		DISPATCH_DEVICE_BUSY					= 2, 	//工作正忙

		DISPATCH_DEVICE_ONE_LEVEL_OVER		= 3, 	//一级工作完成,
		DISPATCH_DEVICE_ONE_LEVEL_WORK		= 4,	//一级工作状态, 就是普通的移动任务
		DISPATCH_DEVICE_TWO_LEVEL_OVER		= 5, 	//二级工作完成,
		DISPATCH_DEVICE_TWO_LEVEL_WORK		= 6,	//二级工作状态, 就是紧急避让, 插队任务(会在执行一级任务的过程中, 插队并优先执行二级任务)
		DISPATCH_DEVICE_THREE_LEVEL_OVER		= 7, 	//三级工作完成,
		DISPATCH_DEVICE_THREE_LEVEL_WORK		= 8,	//三级工作任务, 就是锁定硬件资源, 不让插队, (除非急停或者取消任务)

		DISPATCH_DEVICE_FAULT					= 100,	//故障
		DISPATCH_DEVICE_DISCONNECT			= 101, 	//通信故障
	};
	
	//调度任务的等级
	enum Dispatch_task_level
	{
//	    DISPATCH_TASK_UNKNOW_LEVEL          = 0,    //无效任务
		DISPATCH_TASK_ONE_LEVEL             = 1,    //一级任务
		DISPATCH_TASK_TWO_LEVEL				= 2,	//二级任务
		DISPATCH_TASK_THREE_LEVEL			= 3,	//三级任务
	};

	//抓车的夹杆
	enum Clamp_motion
	{
		E_CLAMP_NO_ACTION            	= 0,    //无动作.
		E_CLAMP_TIGHT               	= 1,    //夹紧夹杆
		E_CLAMP_LOOSE					= 2,	//松开夹杆
	};

	//中跑车和平层轨道的对接
	enum Joint_motion
	{
		E_JOINT_NO_ACTION            	= 0,    //无动作.
		E_JOINT_HOLD_OUT               	= 1,    //伸出对接，之后中跑车可以x轴移动，电梯不能Z轴移动
		E_JOINT_TAKE_BACK				= 2,	//收回对接，之后中跑车固定在电梯上不能X轴移动，电梯可以Z轴移动
	};

	//小跑车的位置,是否在中跑车上面
	enum Small_sports_car_motion
	{
		E_SMALL_SPORTS_NO_ACTION		= 0,    //无动作.
		E_SMALL_SPORTS_CAR_GET_AWAY 	= 1,    //小跑车离开中跑车
		E_SMALL_SPORTS_CAR_GET_BACK		= 2,	//小跑车返回中跑车
	};


	//指令完成状态, 设备答复指令, 返回任务完成的情况
	enum Respons_status
	{
		RESPONS_WORKING            	= 0,    //任务进行中
		RESPONS_OVER               	= 1,    //任务完成
		RESPONS_MINOR_ERROR			= 100,	//一般故障, 可恢复
		RESPONS_CRITICAL_ERROR		= 101,	//致命故障,不可恢复
	};

	//设备的硬件设备状态
	enum Hardware_device_status
	{
		HARDWARE_DEVICE_UNKNOWN              = 0,    //设备未知
		HARDWARE_DEVICE_READY                = 1,    //设备空闲(可以接受新的指令任务)
		HARDWARE_DEVICE_WORKING				= 2,	//设备工作中
		HARDWARE_DEVICE_EMERGENCY_STOP		= 3,	//设备急停
		HARDWARE_DEVICE_UNSAFETY				= 4,	//设备不安全(暂时不考虑是否处于安全位置)
		HARDWARE_DEVICE_COLLISION			= 5,	//设备发生碰撞
		HARDWARE_DEVICE_FAULT				= 6,	//设备故障
	};

	//设备的负载状态, 小跑车上面是否有车.
	enum Load_status
	{
		LOAD_UNKNOWN				= 0,	//负载未知
		HAVE_CAR               		= 1,    //有车
		NO_CAR            			= 2,    //没车
	};

	//7号出口 转台方向
	enum Turntable_direction
	{
		TURNTABLE_DIRECTION_UNKNOWN				= 0,	//方向未知,
		TURNTABLE_DIRECTION_INSIDE 				= 1,    //方向朝里,对接内门的小跑车
		TURNTABLE_DIRECTION_OUTSIDE  			= 2,    //没车朝外,对接外门的出口
	};

	//出入口 门的开关状态
	enum Door_motion
	{
		DOOR_UNKNOWN            = 0,    //门的开关状态 未知, 或者工作到一半,正在工作中.
	    DOOR_OPEN               = 1,    //开门
		DOOR_CLOSE				= 2,	//关门
		DOOR_ERROR				= 3,	//
	};

	//边界判断,是否超界
	enum Overstep_the_boundary
	{
		BOUNDARY_NORMAL			= 0,	//边界 正常
		BOUNDARY_OVERSTEP       = 1,    //超界
	};

//机器手朝向角度
#define CATCHER_DIRECTION_POSITIVE_MIN				70
#define CATCHER_DIRECTION_POSITIVE_CENTER			90
#define CATCHER_DIRECTION_POSITIVE_MAX				110
#define CATCHER_DIRECTION_NEGATIVE_MIN				250
#define CATCHER_DIRECTION_NEGATIVE_CENTER			270
#define CATCHER_DIRECTION_NEGATIVE_MAX				290

	//机器手朝向
	enum Catcher_direction
	{
		CATCHER_DIRECTION_UNKNOW               		= 0,    //
		CATCHER_DIRECTION_POSITIVE               	= 1,    //朝正, 70~110度
		CATCHER_DIRECTION_NEGATIVE               	= 2,    //朝反, 250~290度
	};

public:
	Dispatch_device_base();
	Dispatch_device_base(const Dispatch_device_base& other)= default;
	Dispatch_device_base& operator =(const Dispatch_device_base& other)= default;
	~Dispatch_device_base();
public://API functions
	//设备 初始化
	virtual Error_manager dispatch_device_base_init(int device_id, int device_key);
	//设备 反初始化
	virtual Error_manager dispatch_device_base_uninit();

	//执行任务//注意了, 调度任务允许同时接受多个任务
	virtual Error_manager execute_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level);
	//执行任务//注意了, 调度任务允许同时接受多个任务
	virtual Error_manager execute_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level, std::string command_key, Common_data::Dispatch_process_type process_type);

	//检查任务类型, 子类必须重载, 用来检查输入的任务是否为子类所需的.
	virtual Error_manager check_task_type(std::shared_ptr<Task_Base> p_task);
	//判断能否执行任务
	virtual Error_manager check_task_level(Dispatch_task_level dispatch_task_level);
	//签收任务
	virtual Error_manager sign_for_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level);
	//签收任务 覆盖预约
	virtual Error_manager sign_for_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level, std::string command_key, Common_data::Dispatch_process_type process_type);

	//检查状态,是否正常运行. (工作状态 和 是否能接受对应的任务无关)
	virtual Error_manager check_status();


	//结束任务单，里面会根据任务的故障等级修正 任务单的状态
	virtual Error_manager end_task(std::shared_ptr<Task_Base> p_task);
	//取消任务单，由发送方提前取消任务单
	virtual Error_manager cancel_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level);

	//判断是否为待机，如果已经准备好，则可以执行任务。
	virtual bool is_ready();
	//判断是否可以执行存车任务。
	virtual bool is_able_excute_store();
	//判断是否可以执行取车任务。
	virtual bool is_able_excute_pickup();
	//判断是否已经预约了任务, return false没有预约任务,    return true已经预约了任务
	virtual bool is_has_appoint_task(Dispatch_task_level dispatch_task_level);

	//预约任务
	virtual Error_manager appoint_task(std::string command_key, Common_data::Dispatch_process_type process_type, Dispatch_task_level dispatch_task_level);

	//修改任务等级
	virtual Error_manager change_task_level(Dispatch_task_level dispatch_task_level_source, Dispatch_task_level dispatch_task_level_target);

public://get or set member variable
	Dispatch_device_status get_dispatch_device_status();
	//获取硬件设备的状态, 必须子类继承
	virtual Hardware_device_status get_actual_device_status();
	int get_device_id();

	bool get_break_flag();
	void set_break_flag(bool break_flag);

	virtual std::string get_current_command_key();
protected://member functions


	//执行外界任务的执行函数
	void execute_thread_fun();

	//执行线程工作函数, 正在执行任务单.
	virtual Error_manager execute_thread_working(std::shared_ptr<Task_Base> p_task, Dispatch_device_status & carrier_status);
	//执行线程工作函数, 已经完成任务单. 等待新的指令
	virtual Error_manager execute_thread_over(std::shared_ptr<Task_Base> p_task, Dispatch_device_status & carrier_status);

	//把任务单写入到内存中, 子类必须重载
	virtual Error_manager write_task_to_memory(std::shared_ptr<Task_Base> p_task);
	//更新设备底层通信数据, 子类必须重载
	virtual Error_manager update_device_communication();
	//从内存中读数据到任务单, 子类必须重载
	virtual Error_manager check_and_read_memory_to_task(std::shared_ptr<Task_Base> p_task);


	//取消下发的指令, 子类必须重载, 用来向下发送命令取消任务.
	virtual Error_manager cancel_command();




protected://member variable
public:
	std::atomic<Dispatch_device_status>			m_dispatch_device_status;			//设备总状态, 控制任务流程(长流程)
	int 								m_device_id;				//设备id, 索引
	int 								m_device_key;				//设备唯一码, 自定义

	Dispatch_device_type				m_dispatch_device_type;
	std::mutex							m_lock;	//锁

	//任务执行线程
	std::thread*        				mp_execute_thread;   			//执行的线程指针，内存由本类管理
	Thread_condition					m_execute_condition;			//执行的条件变量


	std::string							m_device_one_level_command_key;		//设备任务的唯一码, (用作任务预约)
	Common_data::Dispatch_process_type	m_device_one_level_process_type;	//调度任务类型
	std::shared_ptr<Task_Base>			mp_device_one_level_task;		//设备的普通任务, (一般移动和等待指令, 允许被打断)

	std::string							m_device_two_level_command_key;		//设备任务的唯一码, (用作任务预约)
	Common_data::Dispatch_process_type	m_device_two_level_process_type;	//调度任务类型
	std::shared_ptr<Task_Base>			mp_device_two_level_task;		//设备的优先任务, (紧急避让和插队指令, 允许打断普通任务)

	std::string							m_device_three_level_command_key;		//设备任务的唯一码, (用作任务预约)
	Common_data::Dispatch_process_type	m_device_three_level_process_type;	//调度任务类型
	std::shared_ptr<Task_Base>			mp_device_three_level_task;		//设备的核心任务, (锁定位置进行抓车和放车, 最高任务, 不允许打断和被打断)
	//task任务的流程由Dispatch_process来管理


	std::atomic<bool>					m_break_flag;				//打断标记位, 当接受2级任务时, 标记位改为true

private:

};


#endif //NNXX_TESTS_DISPATCH_DEVICE_BASE_H