puai_dispatch/dispatch/catcher.cpp

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

#include "catcher.h"

Catcher::Catcher()
{
	m_request_x = 0;				//机器人坐标x轴,
	m_request_y = 0;				//机器人坐标y轴,
	m_request_b = 0;				//机器人坐标b轴, 旋转范围80~280
	m_request_z = 0;				//机器人坐标z轴,
	m_request_space_id = 0;			//机器人空间位置的id.
	m_request_d1 = 0;				//机器人坐标d1轴, 机器人抓车杆纵向移动(前轮抓杆)
	m_request_d2 = 0;				//机器人坐标d2轴, 机器人抓车杆纵向移动(后轮抓杆)
	m_request_wheelbase = 0;		//机器人抓车杆前后轮距.
	m_request_clamp_motion = E_CLAMP_NO_ACTION;		//机器人夹车杆. 0=无动作，1=夹紧，2=松开

	m_respons_status = RESPONS_WORKING;			//指令完成状态, 机器人答复指令, 返回任务完成的情况
	m_respons_x = 0;				//机器人坐标x轴,
	m_respons_y = 0;				//机器人坐标y轴,
	m_respons_b = 0;				//机器人坐标b轴, 旋转范围80~280
	m_respons_z = 0;				//机器人坐标z轴,
	m_respons_space_id = 0;			//机器人空间位置的id.
	m_respons_d1 = 0;				//机器人坐标d1轴, 机器人抓车杆纵向移动(前轮抓杆)
	m_respons_d2 = 0;				//机器人坐标d2轴, 机器人抓车杆纵向移动(后轮抓杆)
	m_respons_wheelbase = 0;		//机器人抓车杆前后轮距.
	m_respons_clamp_motion = E_CLAMP_NO_ACTION;		//机器人夹车杆. 0=无动作，1=夹紧，2=松开

	m_status_updata_time = std::chrono::system_clock::now();
	m_last_heartbeat = 0;			//上一次的心跳
	m_actual_device_status = DEVICE_UNKNOWN;			//机器人的硬件设备状态
	m_actual_load_status = LOAD_UNKNOWN;				//机器人的负载状态, 小跑车上面是否有车.
	m_actual_x = 0;					//机器人坐标x轴,
	m_actual_y = 0;					//机器人坐标y轴,
	m_actual_b = 0;					//机器人坐标b轴, 旋转范围80~280
	m_actual_z = 0;					//机器人坐标z轴,
	m_actual_d1 = 0;				//机器人坐标d1轴, 机器人抓车杆纵向移动(前轮抓杆)
	m_actual_d2 = 0;				//机器人坐标d2轴, 机器人抓车杆纵向移动(后轮抓杆)
	m_actual_clamp_motion1 = E_CLAMP_NO_ACTION;		//小跑车夹车杆. 0=无动作，1=夹紧，2=松开
	m_actual_clamp_motion2 = E_CLAMP_NO_ACTION;		//小跑车夹车杆. 0=无动作，1=夹紧，2=松开
	m_actual_clamp_motion3 = E_CLAMP_NO_ACTION;		//小跑车夹车杆. 0=无动作，1=夹紧，2=松开
	m_actual_clamp_motion4 = E_CLAMP_NO_ACTION;		//小跑车夹车杆. 0=无动作，1=夹紧，2=松开

	memset(m_actual_error_code, 0, 50);	//搬运器设备的报警信息位
	memset(m_actual_warning_code, 0, 50);	//升降机设备的报警信息位
}

Catcher::~Catcher()
{

}

//检查任务类型, 子类必须重载, 用来检查输入的任务是否为子类所需的.
Error_manager Catcher::check_task_type(std::shared_ptr<Task_Base> p_task)
{
	//检查任务类型，
	if (p_task->get_task_type() != CATCHER_TASK)
	{
		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");
	}

	return Error_code::SUCCESS;
}

//获取硬件设备的状态, 必须子类继承
Catcher::Device_status Catcher::get_actual_device_status()
{
	return m_actual_device_status;
}


//把任务单写入到内存中, 子类必须重载
Error_manager Catcher::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
{
	//检查任务类型，
	if (p_task->get_task_type() != CATCHER_TASK)
	{
		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");
	}
	else
	{
		std::unique_lock<std::mutex> t_lock(m_lock);

		Catcher_task* tp_catcher_task = (Catcher_task*)p_task.get();
		std::unique_lock<std::mutex> t_lock1(tp_catcher_task->m_lock);
		m_request_key = tp_catcher_task->m_request_key;
		m_request_x = tp_catcher_task->m_request_x;
		m_request_y = tp_catcher_task->m_request_y;
		m_request_b = tp_catcher_task->m_request_b;
		m_request_z = tp_catcher_task->m_request_z;
		m_request_space_id = tp_catcher_task->m_request_space_id;
		m_request_d1 = tp_catcher_task->m_request_d1;
		m_request_d2 = tp_catcher_task->m_request_d2;
		m_request_wheelbase = tp_catcher_task->m_request_wheelbase;
		m_request_clamp_motion = (Dispatch_device_base::Clamp_motion)tp_catcher_task->m_request_clamp_motion;

		return Error_code::SUCCESS;
	}
	return Error_code::SUCCESS;
}
//更新设备底层通信数据, 子类必须重载
Error_manager Catcher::update_device_communication()
{
	std::unique_lock<std::mutex> t_lock1(Dispatch_communication::get_instance_references().m_data_lock);
	std::unique_lock<std::mutex> t_lock(m_lock);

	//请求消息, 调度->plc
	Dispatch_communication::Catcher_request_from_dispatch_to_plc_for_data * tp_catcher_request_from_dispatch_to_plc_for_data =
	& Dispatch_communication::get_instance_references().m_catcher_request_from_dispatch_to_plc_for_data[m_device_id];
	Dispatch_communication::Catcher_request_from_dispatch_to_plc_for_key * tp_catcher_request_from_dispatch_to_plc_for_key =
	& Dispatch_communication::get_instance_references().m_catcher_request_from_dispatch_to_plc_for_key[m_device_id];
	memset(tp_catcher_request_from_dispatch_to_plc_for_key->m_request_key, 0, 50);
	memcpy(tp_catcher_request_from_dispatch_to_plc_for_key->m_request_key, m_request_key.c_str(), m_request_key.size());
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_x = m_request_x;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_y = m_request_y;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_b = m_request_b;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_z = m_request_z;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_clamp_motion = m_request_clamp_motion;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_wheelbase = m_request_wheelbase;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_d1 = m_request_d1;
	tp_catcher_request_from_dispatch_to_plc_for_data->m_request_d2 = m_request_d2;



	//答复消息, plc->调度
	Dispatch_communication::Catcher_response_from_plc_to_dispatch * tp_catcher_response_from_plc_to_dispatch =
	& Dispatch_communication::get_instance_references().m_catcher_response_from_plc_to_dispatch[m_device_id];
	m_respons_key = (char*) tp_catcher_response_from_plc_to_dispatch->m_respons_key;
	m_respons_status = (Dispatch_device_base::Respons_status)tp_catcher_response_from_plc_to_dispatch->m_respons_status;
	m_respons_x = tp_catcher_response_from_plc_to_dispatch->m_respons_x;
	m_respons_y = tp_catcher_response_from_plc_to_dispatch->m_respons_y;
	m_respons_b = tp_catcher_response_from_plc_to_dispatch->m_respons_b;
	m_respons_z = tp_catcher_response_from_plc_to_dispatch->m_respons_z;
	m_respons_clamp_motion = (Dispatch_device_base::Clamp_motion)tp_catcher_response_from_plc_to_dispatch->m_respons_clamp_motion;
	m_respons_wheelbase = tp_catcher_response_from_plc_to_dispatch->m_respons_wheelbase;
	m_respons_d1 = tp_catcher_response_from_plc_to_dispatch->m_respons_d1;
	m_respons_d2 = tp_catcher_response_from_plc_to_dispatch->m_respons_d2;


	//状态消息, plc->调度
	Dispatch_communication::Catcher_status_from_plc_to_dispatch *tp_catcher_status_from_plc_to_dispatch =
	& Dispatch_communication::get_instance_references().m_catcher_status_from_plc_to_dispatch[m_device_id];
	//通过心跳帧来判断通信是否正常
	if ( m_last_heartbeat != tp_catcher_status_from_plc_to_dispatch->m_heartbeat )
	{
		m_last_heartbeat = tp_catcher_status_from_plc_to_dispatch->m_heartbeat;
		m_status_updata_time = std::chrono::system_clock::now();

		//设备异常  //注注注注注注注注意了, ==的优先级比&要高.
		if ( (tp_catcher_status_from_plc_to_dispatch->m_safe_status & 0x02) == 0 )
		{
			m_actual_device_status = Dispatch_device_base::DEVICE_EMERGENCY_STOP;
			m_dispatch_device_status = Dispatch_device_base::E_FAULT;
		}
		else if ( (tp_catcher_status_from_plc_to_dispatch->m_safe_status & 0x01) == 0 )
		{
			m_actual_device_status = Dispatch_device_base::DEVICE_FAULT;
			m_dispatch_device_status = Dispatch_device_base::E_FAULT;
		}
		else if ( (tp_catcher_status_from_plc_to_dispatch->m_safe_status & 0x08) == 0 )
		{
			m_actual_device_status = Dispatch_device_base::DEVICE_COLLISION;
			m_dispatch_device_status = Dispatch_device_base::E_FAULT;
		}
		//正常状态
		else
		{
			if (tp_catcher_status_from_plc_to_dispatch->m_work_status == 1)
			{
				m_actual_device_status = Dispatch_device_base::DEVICE_WORKING;
			}
			else if(tp_catcher_status_from_plc_to_dispatch->m_work_status == 2)
			{
				m_actual_device_status = Dispatch_device_base::DEVICE_READY;
			}
			else if(tp_catcher_status_from_plc_to_dispatch->m_work_status == 0)
			{
				m_actual_device_status = Dispatch_device_base::DEVICE_UNKNOWN;
			}

			//故障恢复之后   E_FAULT  ->>  E_THREE_LEVEL_WORK
			if ( m_dispatch_device_status == Dispatch_device_base::E_FAULT )
			{
				m_dispatch_device_status = Dispatch_device_base::E_THREE_LEVEL_WORK;
			}
			//else 流程状态维持不变
		}

		m_actual_load_status = (Dispatch_device_base::Load_status)tp_catcher_status_from_plc_to_dispatch->m_actual_load_status;
		m_actual_x = tp_catcher_status_from_plc_to_dispatch->m_actual_x;
		m_actual_y = tp_catcher_status_from_plc_to_dispatch->m_actual_y;
		m_actual_b = tp_catcher_status_from_plc_to_dispatch->m_actual_b;
		m_actual_z = tp_catcher_status_from_plc_to_dispatch->m_actual_z;
		m_actual_d1 = tp_catcher_status_from_plc_to_dispatch->m_actual_d1;
		m_actual_d2 = tp_catcher_status_from_plc_to_dispatch->m_actual_d2;
		m_actual_clamp_motion1 = (Dispatch_device_base::Clamp_motion)tp_catcher_status_from_plc_to_dispatch->m_actual_clamp_motion1;
		m_actual_clamp_motion2 = (Dispatch_device_base::Clamp_motion)tp_catcher_status_from_plc_to_dispatch->m_actual_clamp_motion2;
		m_actual_clamp_motion3 = (Dispatch_device_base::Clamp_motion)tp_catcher_status_from_plc_to_dispatch->m_actual_clamp_motion3;
		m_actual_clamp_motion4 = (Dispatch_device_base::Clamp_motion)tp_catcher_status_from_plc_to_dispatch->m_actual_clamp_motion4;
		memcpy(m_actual_error_code, tp_catcher_status_from_plc_to_dispatch->m_actual_error_code, 50);
		memcpy(m_actual_warning_code, tp_catcher_status_from_plc_to_dispatch->m_actual_warning_code, 50);
		m_actual_error_description = (char*)(tp_catcher_status_from_plc_to_dispatch->m_actual_error_description);

		//重连之后,搬运器状态   E_DISCONNECT  ->>  E_THREE_LEVEL_WORK
		if ( m_dispatch_device_status == Dispatch_device_base::E_DISCONNECT )
		{
			m_dispatch_device_status = Dispatch_device_base::E_THREE_LEVEL_WORK;
		}
	}
	else if(std::chrono::system_clock::now() - m_status_updata_time > std::chrono::milliseconds(COMMUNICATION_OVER_TIME_MS))
	{
		m_dispatch_device_status = Dispatch_device_base::E_DISCONNECT;
	}
	//else 继续等待,直到消息刷新或者超时.



//
//	std::cout << " huli test :::: " << " *********************************************** = " << std::endl;
//	std::cout << " huli test :::: " << " m_dispatch_device_status = " << m_dispatch_device_status << std::endl;
//	int heat = m_last_heartbeat;
//	std::cout << " huli test :::: " << " m_last_heartbeat = " << heat << std::endl;
//	std::cout << " huli test :::: " << " m_actual_device_status = " << m_actual_device_status << std::endl;
//	std::cout << " huli test :::: " << " m_actual_load_status = " << m_actual_load_status << std::endl;
//
//	std::cout << " huli test :::: " << " m_actual_x = " << m_actual_x << std::endl;
//	std::cout << " huli test :::: " << " m_actual_y = " << m_actual_y << std::endl;
//	std::cout << " huli test :::: " << " m_actual_b = " << m_actual_b << std::endl;
//	std::cout << " huli test :::: " << " m_actual_z = " << m_actual_z << std::endl;
//	std::cout << " huli test :::: " << " m_actual_d1 = " << m_actual_d1 << std::endl;
//	std::cout << " huli test :::: " << " m_actual_d2 = " << m_actual_d2 << std::endl;
//	std::cout << " huli test :::: " << " m_actual_clamp_motion1 = " << m_actual_clamp_motion1 << std::endl;
//	std::cout << " huli test :::: " << " m_actual_clamp_motion2 = " << m_actual_clamp_motion2 << std::endl;
//	std::cout << " huli test :::: " << " m_actual_clamp_motion3 = " << m_actual_clamp_motion3 << std::endl;
//	std::cout << " huli test :::: " << " m_actual_clamp_motion4 = " << m_actual_clamp_motion4 << std::endl;
//	unsigned int error32 = m_actual_error_code[3];
//	error32 = (error32<<8) | m_actual_error_code[2];
//	error32 = (error32<<8) | m_actual_error_code[1];
//	error32 = (error32<<8) | m_actual_error_code[0];
//	std::cout << " huli test :::: " << " m_actual_error_code = " << error32 << std::endl;
//	for (int i = 0; i < 50; ++i)
//	{
//		printf("0x%x ", m_actual_error_code[i]);
//	}
//	std::cout <<  std::endl;
//
//	unsigned int warn32 = m_actual_warning_code[3];
//	warn32 = (warn32<<8) | m_actual_warning_code[2];
//	warn32 = (warn32<<8) | m_actual_warning_code[1];
//	warn32 = (warn32<<8) | m_actual_warning_code[0];
//	std::cout << " huli test :::: " << " m_actual_warning_code = " << warn32 << std::endl;
//	for (int i = 0; i < 50; ++i)
//	{
//		printf("0x%x ", m_actual_warning_code[i]);
//	}
//	std::cout <<  std::endl;
//	std::cout << " huli test :::: " << " m_actual_error_description = " << m_actual_error_description << std::endl;
//
//	for (int i = 0; i < 256; ++i)
//	{
//		printf("0x%x ", m_actual_error_description[i]);
//	}
//	std::cout <<  std::endl;


	return Error_code::SUCCESS;
}
//从内存中读数据到任务单, 子类必须重载
Error_manager Catcher::check_and_read_memory_to_task(std::shared_ptr<Task_Base> p_task)
{
	//检查任务类型，
	if (p_task->get_task_type() != CATCHER_TASK)
	{
		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");
	}
	else
	{
		std::unique_lock<std::mutex> t_lock(m_lock);
		if ( m_respons_key == m_request_key && m_respons_status != RESPONS_WORKING )
		{
			Catcher_task* tp_catcher_task = (Catcher_task*)p_task.get();
			std::unique_lock<std::mutex> t_lock1(tp_catcher_task->m_lock);

			tp_catcher_task->m_respons_key = m_respons_key;
			tp_catcher_task->m_respons_status = (Catcher_task::Respons_status)m_respons_status;
			tp_catcher_task->m_respons_x = m_respons_x;
			tp_catcher_task->m_respons_y = m_respons_y;
			tp_catcher_task->m_respons_b = m_respons_b;
			tp_catcher_task->m_respons_z = m_respons_z;
			tp_catcher_task->m_respons_space_id = m_respons_space_id;
			tp_catcher_task->m_respons_d1 = m_respons_d1;
			tp_catcher_task->m_respons_d2 = m_respons_d2;
			tp_catcher_task->m_respons_wheelbase = m_respons_wheelbase;
			tp_catcher_task->m_respons_clamp_motion = (Catcher_task::Clamp_motion)m_respons_clamp_motion;

			//如果故障,则添加错误码
			if ( m_respons_status == RESPONS_MINOR_ERROR || m_respons_status == RESPONS_CRITICAL_ERROR )
			{
				//添加错误码
				Error_manager t_error(CATCHER_RESPONS_ERROR, MINOR_ERROR, "m_respons_status is error");
				tp_catcher_task->set_task_error_manager(t_error);
			}

			return Error_code::SUCCESS;
		}
		//返回没有收到数据
		else
		{
			return Error_code::NODATA;
		}
	}
	return Error_code::SUCCESS;
}



//取消下发的指令
Error_manager Catcher::cancel_command()
{
	//以后再写 need programe
	//目前调度和plc的通信指令做的很简单,没有暂停和急停 复位等操作.
	//这里先空着,以后再写.
	//调度模块单方面销毁任务, 不管底层plc的执行情况, 也不去告知plc任务取消.

	return Error_code::SUCCESS;
}