puai_dispatch/dispatch/passageway.cpp

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

#include "passageway.h"


Passageway::Passageway()
{
	m_request_inside_door_motion = DOOR_UNKNOWN;
	m_request_outside_door_motion = DOOR_UNKNOWN;
	m_request_turntable_direction = TURNTABLE_DIRECTION_UNKNOWN;

	m_respons_status = RESPONS_WORKING;			//指令完成状态, 搬运器答复指令, 返回任务完成的情况
	m_respons_inside_door_motion = DOOR_UNKNOWN;
	m_respons_outside_door_motion = DOOR_UNKNOWN;
	m_respons_turntable_direction = TURNTABLE_DIRECTION_UNKNOWN;

	m_status_updata_time = std::chrono::system_clock::now();
	m_last_heartbeat = 0;			//上一次的心跳
	m_actual_device_status = HARDWARE_DEVICE_UNKNOWN;			//通道口的硬件设备状态
	m_actual_inside_load_status = LOAD_UNKNOWN;	//通道口的内部负载状态, 门内地感是否有车.
	m_actual_outside_load_status = LOAD_UNKNOWN;	//通道口的外部负载状态, 门外地感是否有车.
	m_actual_front_overstep_the_boundary = BOUNDARY_NORMAL;	//通道口 汽车前边界
	m_actual_back_overstep_the_boundary = BOUNDARY_NORMAL;	//通道口 汽车前边界
	m_actual_height_overstep_the_boundary = BOUNDARY_NORMAL;	//通道口 车辆是否超高
	m_actual_outside_door_sensor = LOAD_UNKNOWN;	//通道口 的外门处的传感器, 判断是否有车经过外门
	//通道口的真实状态, 可能是路径中间的坐标
	m_actual_inside_door_motion = DOOR_UNKNOWN;	//通道口 内门动作
	m_actual_outside_door_motion = DOOR_UNKNOWN;	//通道口 外门动作
	m_actual_turntable_load_status = LOAD_UNKNOWN;	//通道口 转盘负载状态, 是否有车.
	m_actual_turntable_direction = TURNTABLE_DIRECTION_UNKNOWN;	//通道口 转台方向

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

Passageway::~Passageway()
{

}

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

	return Error_code::SUCCESS;
}

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


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

		Passageway_task* tp_passageway_task = (Passageway_task*)p_task.get();
		std::unique_lock<std::mutex> t_lock1(tp_passageway_task->m_lock);
		m_request_key = tp_passageway_task->m_request_key;
		m_request_inside_door_motion = (Dispatch_device_base::Door_motion)tp_passageway_task->m_request_inside_door_motion;
		m_request_outside_door_motion = (Dispatch_device_base::Door_motion)tp_passageway_task->m_request_outside_door_motion;
		m_request_turntable_direction = (Dispatch_device_base::Turntable_direction)tp_passageway_task->m_request_turntable_direction;

		return Error_code::SUCCESS;
	}
	return Error_code::SUCCESS;
}
//更新设备底层通信数据, 子类必须重载
Error_manager Passageway::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::Passageway_request_from_dispatch_to_plc_for_data * tp_passageway_request_from_dispatch_to_plc_for_data =
	& Dispatch_communication::get_instance_references().m_passageway_request_from_dispatch_to_plc_for_data[m_device_id];
	Dispatch_communication::Passageway_request_from_dispatch_to_plc_for_key * tp_passageway_request_from_dispatch_to_plc_for_key =
	& Dispatch_communication::get_instance_references().m_passageway_request_from_dispatch_to_plc_for_key[m_device_id];
	memset(tp_passageway_request_from_dispatch_to_plc_for_key->m_request_key, 0, 50);
	int t_size = m_request_key.size()<=50 ? m_request_key.size() : 50 ;
	memcpy(tp_passageway_request_from_dispatch_to_plc_for_key->m_request_key, m_request_key.c_str(), t_size);
	tp_passageway_request_from_dispatch_to_plc_for_data->m_request_inside_door_motion = m_request_inside_door_motion;
	tp_passageway_request_from_dispatch_to_plc_for_data->m_request_outside_door_motion = m_request_outside_door_motion;
	tp_passageway_request_from_dispatch_to_plc_for_data->m_request_turntable_direction = m_request_turntable_direction;



	//答复消息, plc->调度
	Dispatch_communication::Passageway_response_from_plc_to_dispatch * tp_passageway_response_from_plc_to_dispatch =
	& Dispatch_communication::get_instance_references().m_passageway_response_from_plc_to_dispatch[m_device_id];
	m_respons_key = (char*) tp_passageway_response_from_plc_to_dispatch->m_respons_key;
	m_respons_status = (Dispatch_device_base::Respons_status)tp_passageway_response_from_plc_to_dispatch->m_respons_status;
	m_respons_inside_door_motion = (Dispatch_device_base::Door_motion)tp_passageway_response_from_plc_to_dispatch->m_respons_inside_door_motion;
	m_respons_outside_door_motion = (Dispatch_device_base::Door_motion)tp_passageway_response_from_plc_to_dispatch->m_respons_outside_door_motion;
	m_respons_turntable_direction = (Dispatch_device_base::Turntable_direction)tp_passageway_response_from_plc_to_dispatch->m_respons_turntable_direction;


	//状态消息, plc->调度
	Dispatch_communication::Passageway_status_from_plc_to_dispatch *tp_passageway_status_from_plc_to_dispatch =
	& Dispatch_communication::get_instance_references().m_passageway_status_from_plc_to_dispatch[m_device_id];
	//设备异常  //注注注注注注注注意了, ==的优先级比&要高.
	if ( (tp_passageway_status_from_plc_to_dispatch->m_safe_status & 0x02) == 0 )
	{
		m_actual_device_status = Dispatch_device_base::HARDWARE_DEVICE_EMERGENCY_STOP;
		m_dispatch_device_status = Dispatch_device_base::DISPATCH_DEVICE_FAULT;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_safe_status & 0x01) == 0 )
	{
		m_actual_device_status = Dispatch_device_base::HARDWARE_DEVICE_FAULT;
		m_dispatch_device_status = Dispatch_device_base::DISPATCH_DEVICE_FAULT;
	}
	else//正常状态
	{
		if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x20)== 1)
		{
			m_actual_device_status = Dispatch_device_base::HARDWARE_DEVICE_WORKING;
		}
		else if( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x20)== 0)
		{
			m_actual_device_status = Dispatch_device_base::HARDWARE_DEVICE_READY;
		}
		else
		{
			m_actual_device_status = Dispatch_device_base::HARDWARE_DEVICE_UNKNOWN;
		}


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

	//数据解析
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x01)== 1)
	{
		m_actual_inside_load_status = Dispatch_device_base::HAVE_CAR;
	}
	else
	{
		m_actual_inside_load_status = Dispatch_device_base::NO_CAR;
	}
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x02)== 1)
	{
		m_actual_outside_load_status = Dispatch_device_base::HAVE_CAR;
	}
	else
	{
		m_actual_outside_load_status = Dispatch_device_base::NO_CAR;
	}
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x04)== 1)
	{
		m_actual_front_overstep_the_boundary = Dispatch_device_base::BOUNDARY_OVERSTEP;
	}
	else
	{
		m_actual_front_overstep_the_boundary = Dispatch_device_base::BOUNDARY_NORMAL;
	}
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x08)== 1)
	{
		m_actual_back_overstep_the_boundary = Dispatch_device_base::BOUNDARY_OVERSTEP;
	}
	else
	{
		m_actual_back_overstep_the_boundary = Dispatch_device_base::BOUNDARY_NORMAL;
	}
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x10)== 1)
	{
		m_actual_height_overstep_the_boundary = Dispatch_device_base::BOUNDARY_OVERSTEP;
	}
	else
	{
		m_actual_height_overstep_the_boundary = Dispatch_device_base::BOUNDARY_NORMAL;
	}
	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x20)== 1)
	{
		m_actual_outside_door_sensor = Dispatch_device_base::HAVE_CAR;
	}
	else
	{
		m_actual_outside_door_sensor = Dispatch_device_base::NO_CAR;
	}

	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x40)== 1 &&
		 (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x80)== 0)
	{
		m_actual_inside_door_motion = Dispatch_device_base::DOOR_OPEN;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x40)== 0 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x80)== 1)
	{
		m_actual_inside_door_motion = Dispatch_device_base::DOOR_CLOSE;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x40)== 1 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x80)== 1)
	{
		m_actual_inside_door_motion = Dispatch_device_base::DOOR_ERROR;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x40)== 0 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status1 & 0x80)== 0)
	{
		m_actual_inside_door_motion = Dispatch_device_base::DOOR_UNKNOWN;
	}

	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x01)== 1 &&
		 (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x02)== 0)
	{
		m_actual_outside_door_motion = Dispatch_device_base::DOOR_OPEN;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x01)== 0 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x02)== 1)
	{
		m_actual_outside_door_motion = Dispatch_device_base::DOOR_CLOSE;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x01)== 1 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x02)== 1)
	{
		m_actual_outside_door_motion = Dispatch_device_base::DOOR_ERROR;
	}
	else if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x01)== 0 &&
			  (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x02)== 0)
	{
		m_actual_outside_door_motion = Dispatch_device_base::DOOR_UNKNOWN;
	}

	if ( (tp_passageway_status_from_plc_to_dispatch->m_sensor_status2 & 0x03)== 1)
	{
		m_actual_turntable_load_status = Dispatch_device_base::HAVE_CAR;
	}
	else
	{
		m_actual_turntable_load_status = Dispatch_device_base::NO_CAR;
	}

	m_actual_turntable_direction = (Dispatch_device_base::Turntable_direction)tp_passageway_status_from_plc_to_dispatch->m_actual_turntable_direction;
	memcpy(m_actual_error_code, tp_passageway_status_from_plc_to_dispatch->m_actual_error_code, 50);
	memcpy(m_actual_warning_code, tp_passageway_status_from_plc_to_dispatch->m_actual_warning_code, 50);
	m_actual_error_description = (char*)(tp_passageway_status_from_plc_to_dispatch->m_actual_error_description-2);

	//通过心跳帧来判断通信是否正常
	if ( m_last_heartbeat != tp_passageway_status_from_plc_to_dispatch->m_heartbeat )
	{
		m_last_heartbeat = tp_passageway_status_from_plc_to_dispatch->m_heartbeat;
		m_status_updata_time = std::chrono::system_clock::now();

		//重连之后,搬运器状态   E_DISCONNECT  ->>  E_THREE_LEVEL_WORK
		if ( m_dispatch_device_status == Dispatch_device_base::DISPATCH_DEVICE_DISCONNECT )
		{
			m_dispatch_device_status = Dispatch_device_base::DISPATCH_DEVICE_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::DISPATCH_DEVICE_DISCONNECT;
	}
	//else 继续等待,直到消息刷新或者超时.

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

			tp_passageway_task->m_respons_key = m_respons_key;
			tp_passageway_task->m_respons_status = (Passageway_task::Respons_status)m_respons_status;
			tp_passageway_task->m_respons_inside_door_motion = (Passageway_task::Door_motion)m_respons_inside_door_motion;
			tp_passageway_task->m_respons_outside_door_motion = (Passageway_task::Door_motion)m_respons_outside_door_motion;
			tp_passageway_task->m_respons_turntable_direction = (Passageway_task::Turntable_direction)m_respons_turntable_direction;

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

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



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

	return Error_code::SUCCESS;
}