puai_dispatch/dispatch/dispatch_device_base.cpp

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

#include "dispatch_device_base.h"

Dispatch_device_base::Dispatch_device_base()
{
	m_dispatch_device_status = DISPATCH_DEVICE_UNKNOW;
	m_device_id = -1;

	mp_execute_thread = NULL;
}

Dispatch_device_base::~Dispatch_device_base()
{
	dispatch_device_base_uninit();
}

//设备 初始化
Error_manager Dispatch_device_base::dispatch_device_base_init(int device_id, int device_key)
{
	m_device_id = device_id;
	m_device_key = device_key;
	//	线程默认开启
	m_execute_condition.reset(false, true, false);
	mp_execute_thread = new std::thread(&Dispatch_device_base::execute_thread_fun, this);

	m_dispatch_device_status = DISPATCH_DEVICE_READY;
	return Error_code::SUCCESS;
}
//设备 反初始化
Error_manager Dispatch_device_base::dispatch_device_base_uninit()
{
	if (mp_execute_thread)
	{
		m_execute_condition.kill_all();
	}
	if (mp_execute_thread)
	{
		mp_execute_thread->join();
		delete mp_execute_thread;
		mp_execute_thread = NULL;
	}

	m_dispatch_device_status = DISPATCH_DEVICE_UNKNOW;

	return Error_code::SUCCESS;
}

//执行任务
Error_manager Dispatch_device_base::execute_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level)
{
	LOG(INFO) << " ---Dispatch_device_base::execute_task ---"<< this;

	Error_manager t_error;
	Error_manager t_result;

	//检查指针
	if (p_task.get() == NULL) {
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							 "Dispatch_device_base::execute_task failed, POINTER_IS_NULL");
	}
	//检查任务类型，


	t_error = check_task_type(p_task);
	if ( t_error != Error_code::SUCCESS )
	{
		return t_error;
	}

	//检查接收方能否接受任务
	t_error = check_task_level(dispatch_task_level);
	if ( t_error != SUCCESS )
	{
		t_result.compare_and_cover_error(t_error);
	}
	else
	{
		//接受任务，并将任务的状态改为TASK_SIGNED已签收
		t_error = sign_for_task(p_task, dispatch_task_level);
		if ( t_error != Error_code::SUCCESS )
		{
			return t_error;
		}
		//这里不用检查任务内容, 直接下发给底层设备
		//永远启动到三级任务工作状态.
		// 启动定位管理模块，的核心工作线程
		m_dispatch_device_status = DISPATCH_DEVICE_THREE_LEVEL_WORK;
		m_execute_condition.notify_all(true);
		//通知 thread_work 子线程启动。

		//只签收,并不一定进入工作状态, 在线程真正的执行的时候,才改为工作中, (执行线程可能会先处理更高优先级的任务单)
	}

	if ( t_result != Error_code::SUCCESS )
	{
		return t_result;
	}

	return Error_code::SUCCESS;
}

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

	return Error_code::SUCCESS;
}

//判断能否执行任务
Error_manager Dispatch_device_base::check_task_level(Dispatch_task_level dispatch_task_level)
{
//	std::cout << " huli test :::: " << " m_dispatch_device_status = " << m_dispatch_device_status << std::endl;
	//加锁
	std::unique_lock<std::mutex> t_lock(m_lock);
	//只有当状态 不是正在执行当前等级的任务,并且当前等级的任务为空. 此时返回成功, 才能接受新的任务
	if ( m_dispatch_device_status >= DISPATCH_DEVICE_READY && m_dispatch_device_status <= DISPATCH_DEVICE_THREE_LEVEL_WORK )
	{
		switch ( dispatch_task_level )
		{
			case DISPATCH_TASK_ONE_LEVEL:
			{
				if ( mp_device_one_level_task.get() == NULL )
				{
					//一级任务直接插入
					if (  m_dispatch_device_status == DISPATCH_DEVICE_READY ||
						  m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
						  m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK ||
						  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER ||
						  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK )
					{
						return Error_code::SUCCESS;
					}
					else
					{
						return Error_manager(Error_code::DISPATCH_DEVICE_TASK_LEVEL_ERROR, Error_level::MINOR_ERROR,
											 " Dispatch_device_base::check_task_level 1 error ");
					}
				}
				else
				{
					return Error_manager(Error_code::DISPATCH_DEVICE_TASK_REPEAT, Error_level::MINOR_ERROR,
										 " Dispatch_device_base::check_task_level 2 error ");
				}
				break;
			}
			case DISPATCH_TASK_TWO_LEVEL:
			{
				if ( mp_device_two_level_task.get() == NULL )
				{
					//二级任务如果打断了一级任务, 那么要通知一级任务暂停, 后续一级任务会重新执行
					if (  m_dispatch_device_status == DISPATCH_DEVICE_READY )
					{
						return Error_code::SUCCESS;
					}
					else if ( ( m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_WORK ||
								m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER ) && mp_device_one_level_task.get() != NULL)
					{
						mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_STOP);
						return Error_code::SUCCESS;
					}
					else
					{
						return Error_manager(Error_code::DISPATCH_DEVICE_TASK_LEVEL_ERROR, Error_level::MINOR_ERROR,
											 " Dispatch_device_base::check_task_level 3  error ");
					}
				}
				else
				{
					return Error_manager(Error_code::DISPATCH_DEVICE_TASK_REPEAT, Error_level::MINOR_ERROR,
										 " Dispatch_device_base::check_task_level 4 error ");
				}
				break;
			}
			case DISPATCH_TASK_THREE_LEVEL:
			{
				if ( ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
					 m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER ) && mp_device_three_level_task.get() == NULL)
				{
					return Error_code::SUCCESS;
				}
				break;
			}
			default:
			{
				return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
									 "  Dispatch_device_base::check_task 5 PARAMETER_ERROR ");
				break;
			}
		}
		return Error_manager(Error_code::DISPATCH_DEVICE_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
							 " Dispatch_device_base::check_task is busy 6 ");
	}
	else
	{
//		std::cout << " huli test :::: " << " 777777777777777777777777777777777777 = " << 777 << std::endl;
//		std::cout << " huli test :::: " << " m_dispatch_device_status = " << m_dispatch_device_status << std::endl;
//		std::cout << " huli test :::: " << " id = " << m_device_id << std::endl;
	    return Error_manager(Error_code::DISPATCH_DEVICE_STATUS_ERROR, Error_level::MINOR_ERROR,
	    					" Dispatch_device_base::check_task 7 error ");
	}
	return Error_code::SUCCESS;
}

//签收任务
Error_manager Dispatch_device_base::sign_for_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level)
{
	//加锁
	std::unique_lock<std::mutex> t_lock(m_lock);
	switch ( dispatch_task_level )
	{
		case DISPATCH_TASK_ONE_LEVEL:
		{
			mp_device_one_level_task = p_task;
			mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
			break;
		}
		case DISPATCH_TASK_TWO_LEVEL:
		{
			mp_device_two_level_task = p_task;
			mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
			break;
		}
		case DISPATCH_TASK_THREE_LEVEL:
		{
			mp_device_three_level_task = p_task;
			mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
			break;
		}
		default:
		{
			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
								 "  Dispatch_device_base::check_task PARAMETER_ERROR ");
			break;
		}
	}
	return Error_code::SUCCESS;
}

//检查状态,是否正常运行. (工作状态 和 是否能接受对应的任务无关)
Error_manager Dispatch_device_base::check_status()
{
	if ( m_dispatch_device_status == DISPATCH_DEVICE_READY )
	{
		return Error_code::SUCCESS;
	}
	else if ( m_dispatch_device_status >= DISPATCH_DEVICE_BUSY && m_dispatch_device_status <= DISPATCH_DEVICE_THREE_LEVEL_WORK)
	{
		return Error_manager(Error_code::DISPATCH_DEVICE_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
							 " Dispatch_device_base::check_status is busy ");
	}
	else
	{
		return Error_manager(Error_code::DISPATCH_DEVICE_STATUS_ERROR, Error_level::MINOR_ERROR,
							 " Dispatch_device_base::check_status error ");
	}
	return Error_code::SUCCESS;
}


//结束任务单，里面会根据任务的故障等级修正 任务单的状态
Error_manager Dispatch_device_base::end_task(std::shared_ptr<Task_Base> p_task)
{
	LOG(INFO) << " ---Dispatch_device_base::end_task ---"<< this;
	//注:这里只修改任务单的状态, 搬运器的状态不管
	//在结束任务单时，将雷达任务状态改为 TASK_OVER 已结束
	//判断任务单的错误等级，
	if ( p_task->get_task_error_manager().get_error_level() < Error_level::MINOR_ERROR)
	{
		//强制改为TASK_OVER，不管它当前在做什么。
		p_task->set_task_statu(Task_Base::Task_statu::TASK_OVER);
	}
	else
	{
		//强制改为 TASK_ERROR，不管它当前在做什么。
		p_task->set_task_statu(Task_Base::Task_statu::TASK_ERROR);
	}
	return Error_code::SUCCESS;
}

//取消任务单，由发送方提前取消任务单
Error_manager Dispatch_device_base::cancel_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	cancel_command();
	//找到对应的任务单
	switch ( dispatch_task_level )
	{
		case DISPATCH_TASK_ONE_LEVEL:
		{
			mp_device_one_level_task.reset();
			break;
		}
		case DISPATCH_TASK_TWO_LEVEL:
		{
			mp_device_two_level_task.reset();
			break;
		}
		case DISPATCH_TASK_THREE_LEVEL:
		{
			mp_device_three_level_task.reset();
			break;
		}
		default:
		{
			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
								 "  Dispatch_device_base::cancel_task PARAMETER_ERROR ");
			break;
		}
	}
	//上级的任务单指针,改为死亡,表示任务已经失效.
	p_task->set_task_statu(Task_Base::Task_statu::TASK_DEAD);
	return Error_code::SUCCESS;
}

//判断是否为待机，如果已经准备好，则可以执行任务。
bool Dispatch_device_base::is_ready()
{
//	std::unique_lock<std::mutex> t_lock(m_lock);
	if ( m_dispatch_device_status == DISPATCH_DEVICE_READY &&
		 m_device_one_level_command_key == "" &&
		 m_device_two_level_command_key == "" &&
		 m_device_three_level_command_key == "" )
	{
		return true;
	}
	else
	{
		return false;
	}
}
//判断是否可以执行存车任务。
bool Dispatch_device_base::is_able_excute_store()
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	if ( m_device_one_level_command_key == "" &&
		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_OVER &&
		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_WORK)
	{
		if ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK)
		{
			return true;
		}
		else if ( m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER ||
				  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK )
		{
			if ( m_device_three_level_process_type == Common_data::Dispatch_process_type::DISPATCH_PROCESS_PICKUP )
			{
			    return true;
			}
			else
			{
			    return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
	    return false;
	}

}
//判断是否可以执行取车任务。
bool Dispatch_device_base::is_able_excute_pickup()
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	if ( m_device_one_level_command_key == "" &&
		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_OVER &&
		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_WORK)
	{
		if ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK)
		{
			return true;
		}
		else if ( m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER ||
				  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK )
		{
			if ( m_device_three_level_process_type == Common_data::Dispatch_process_type::DISPATCH_PROCESS_STORE )
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//判断是否已经预约了任务, return false没有预约任务,    return true已经预约了任务
bool Dispatch_device_base::is_has_appoint_task(Dispatch_task_level dispatch_task_level)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	switch ( dispatch_task_level )
	{
		case DISPATCH_TASK_ONE_LEVEL:
		{
			if ( m_device_one_level_command_key == "" )
			{
			    return false;
			}
			else
			{
			    return true;
			}
			break;
		}
		case DISPATCH_TASK_TWO_LEVEL:
		{
			if ( m_device_two_level_command_key == "" )
			{
				return false;
			}
			else
			{
				return true;
			}
			break;
		}
		case DISPATCH_TASK_THREE_LEVEL:
		{
			if ( m_device_three_level_command_key == "" )
			{
				return false;
			}
			else
			{
				return true;
			}
			break;
		}
	}
	return true;
}
//预约任务
Error_manager Dispatch_device_base::appoint_task(std::string command_key, Common_data::Dispatch_process_type process_type, Dispatch_task_level dispatch_task_level)
{
	std::unique_lock<std::mutex> t_lock(m_lock);
	switch ( dispatch_task_level )
	{
		case DISPATCH_TASK_ONE_LEVEL:
		{
			m_device_one_level_command_key = command_key;
			m_device_one_level_process_type = process_type;
			break;
		}
		case DISPATCH_TASK_TWO_LEVEL:
		{
			m_device_two_level_command_key = command_key;
			m_device_two_level_process_type = process_type;
			break;
		}
		case DISPATCH_TASK_THREE_LEVEL:
		{
			m_device_three_level_command_key = command_key;
			m_device_three_level_process_type = process_type;
			break;
		}
		default:
		{
			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
								 "  Dispatch_device_base::appoint_task PARAMETER_ERROR ");
			break;
		}
	}
	return Error_code::SUCCESS;
}

//修改任务等级
Error_manager Dispatch_device_base::change_task_level(Dispatch_task_level dispatch_task_level_source, Dispatch_task_level dispatch_task_level_target)
{
	std::string * tp_command_key_source = NULL;
	Common_data::Dispatch_process_type * tp_process_type_source = NULL;
	std::shared_ptr<Task_Base> * tp_task_source = NULL;
	std::string * tp_command_key_target = NULL;
	Common_data::Dispatch_process_type * tp_process_type_target = NULL;
	std::shared_ptr<Task_Base> * tp_task_target = NULL;
	
	if ( dispatch_task_level_source == dispatch_task_level_target )
	{
	    return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
	    					" Dispatch_device_base::change_task_level PARAMRTER ERROR ");
	}
	std::unique_lock<std::mutex> t_lock(m_lock);
	switch ( dispatch_task_level_source )
	{
	    case DISPATCH_TASK_ONE_LEVEL:
	    {
			tp_command_key_source = & m_device_one_level_command_key;
			tp_process_type_source = & m_device_one_level_process_type;
			tp_task_source = & mp_device_one_level_task;
	        break;
	    }
	    case DISPATCH_TASK_TWO_LEVEL:
	    {
			tp_command_key_source = & m_device_two_level_command_key;
			tp_process_type_source = & m_device_two_level_process_type;
			tp_task_source = & mp_device_two_level_task;;
	        break; 
	    }
		case DISPATCH_TASK_THREE_LEVEL:
		{
			tp_command_key_source = & m_device_three_level_command_key;
			tp_process_type_source = & m_device_three_level_process_type;
			tp_task_source = & mp_device_three_level_task;;
			break;
		}
	    default:
	    {
			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
								 " Dispatch_device_base::change_task_level PARAMRTER ERROR ");
	        break;   
	    }    
	}
	switch ( dispatch_task_level_target )
	{
		case DISPATCH_TASK_ONE_LEVEL:
		{
			tp_command_key_target = & m_device_one_level_command_key;
			tp_process_type_target = & m_device_one_level_process_type;
			tp_task_target = & mp_device_one_level_task;
			break;
		}
		case DISPATCH_TASK_TWO_LEVEL:
		{
			tp_command_key_target = & m_device_two_level_command_key;
			tp_process_type_target = & m_device_two_level_process_type;
			tp_task_target = & mp_device_two_level_task;;
			break;
		}
		case DISPATCH_TASK_THREE_LEVEL:
		{
			tp_command_key_target = & m_device_three_level_command_key;
			tp_process_type_target = & m_device_three_level_process_type;
			tp_task_target = & mp_device_three_level_task;;
			break;
		}
		default:
		{
			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
								 " Dispatch_device_base::change_task_level PARAMRTER ERROR ");
			break;
		}
	}

	if ( (*tp_task_target).get() == NULL )
	{
		*tp_command_key_target = *tp_command_key_source;
		*tp_process_type_target = *tp_process_type_source;
		*tp_task_target = *tp_task_source;

		(*tp_command_key_source).clear();
		(*tp_process_type_source) = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW;
		(*tp_task_source).reset();

		m_dispatch_device_status = Dispatch_device_base::Dispatch_device_status::DISPATCH_DEVICE_THREE_LEVEL_WORK;
	}
	else
	{
		return Error_manager(Error_code::DISPATCH_DEVICE_TASK_LEVEL_ERROR, Error_level::MINOR_ERROR,
							 " Dispatch_device_base::change_task_level PARAMRTER ERROR ");
	}

	return Error_code::SUCCESS;
}

Dispatch_device_base::Dispatch_device_status Dispatch_device_base::get_dispatch_device_status()
{
	return m_dispatch_device_status;
}

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

int Dispatch_device_base::get_device_id()
{
	return m_device_id;
}



//执行外界任务的执行函数
void Dispatch_device_base::execute_thread_fun()
{
	LOG(INFO) << " Dispatch_device_base::execute_thread_fun() start " << this;
	Error_manager t_error;

	while (m_execute_condition.is_alive())
	{
		m_execute_condition.wait();
		if ( m_execute_condition.is_alive() )
		{
			std::this_thread::sleep_for(std::chrono::microseconds(1));
			std::this_thread::sleep_for(std::chrono::milliseconds(1));
//			std::this_thread::sleep_for(std::chrono::seconds(1));

			std::this_thread::yield();
			std::unique_lock<std::mutex> t_lock(m_lock);
//			std::cout << " huli test :::: " << " m_device_id = " << m_device_id << std::endl;
//			std::cout << " huli test :::: " << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa m_dispatch_device_status = " << m_dispatch_device_status << std::endl;

			switch ( (Dispatch_device_status)m_dispatch_device_status )
			{
				//核心任务, (三级任务)
				case DISPATCH_DEVICE_THREE_LEVEL_WORK:
				{
					if ( mp_device_three_level_task.get() != NULL )
					{
						mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
						//执行三级任务
						write_task_to_memory(mp_device_three_level_task);
						//更新通信
						update_device_communication();
						//从内存中读数据到任务单
						t_error = check_and_read_memory_to_task(mp_device_three_level_task);

						if (t_error == NODATA)
						{
							//设备正常运行
							//延时1ms, snap7的通信效率偏慢, 不需要高频率检查
							std::this_thread::sleep_for(std::chrono::milliseconds(1));
						}
						else
						{
							if (t_error != SUCCESS)
							{
								mp_device_three_level_task->set_task_error_manager(t_error);
							}
							end_task(mp_device_three_level_task);
							m_dispatch_device_status = DISPATCH_DEVICE_THREE_LEVEL_OVER;
						}
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_WORK;
					}
					break;
				}
				case DISPATCH_DEVICE_THREE_LEVEL_OVER:
				{
					//更新通信
					update_device_communication();
					if ( mp_device_three_level_task.get() != NULL )
					{
						//检查任务状态,
						//在 E_THREE_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
						if ( mp_device_three_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
						{
							//这里会通知任务已经释放, 然后销毁任务单,  并降级
							mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
							mp_device_three_level_task.reset();
							m_device_three_level_command_key.clear();
							m_device_three_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW;
							m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_WORK;
						}
							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
						else if (  mp_device_three_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
						{
							mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
							m_dispatch_device_status = DISPATCH_DEVICE_THREE_LEVEL_WORK;
						}
						//else //保持不动, 直到发送方给定新的任务,
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_WORK;
					}
					break;
				}
				case DISPATCH_DEVICE_TWO_LEVEL_WORK:
				{
					if ( mp_device_two_level_task.get() != NULL )
					{
						mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
						//执行二级任务
						write_task_to_memory(mp_device_two_level_task);
						//更新通信
						update_device_communication();
						//从内存中读数据到任务单
						t_error = check_and_read_memory_to_task(mp_device_two_level_task);

						if (t_error == NODATA)
						{
							//设备正常运行
							//延时1ms, snap7的通信效率偏慢, 不需要高频率检查
							std::this_thread::sleep_for(std::chrono::milliseconds(1));
						}
						else
						{
							if (t_error != SUCCESS)
							{
								mp_device_two_level_task->set_task_error_manager(t_error);
							}
							end_task(mp_device_two_level_task);
							m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_OVER;
						}
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_WORK;
					}
					break;
				}
				case DISPATCH_DEVICE_TWO_LEVEL_OVER:
				{
					//更新通信
					update_device_communication();
					if ( mp_device_two_level_task.get() != NULL )
					{
						//检查任务状态,
						//在 E_TWO_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
						if ( mp_device_two_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
						{
							//这里会通知任务已经释放, 然后销毁任务单,  并降级
							mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
							mp_device_two_level_task.reset();
							m_device_two_level_command_key.clear();
							m_device_two_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW;
							m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_WORK;
						}
							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
						else if (  mp_device_two_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
						{
							mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
							m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_WORK;
						}
						//else //保持不动, 直到发送方给定新的任务,
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_WORK;
					}
					break;
				}
				case DISPATCH_DEVICE_ONE_LEVEL_WORK:
				{
					if ( mp_device_one_level_task.get() != NULL )
					{
						if ( mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
						{
							//这里会通知任务已经释放, 然后销毁任务单,  并降级
							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
							mp_device_one_level_task.reset();
							m_dispatch_device_status = DISPATCH_DEVICE_READY;
						}

						else if (mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED ||
								 mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_SIGNED ||
								 mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WORKING )
						{
							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
							//执行一级任务,
							write_task_to_memory(mp_device_one_level_task);
							//更新通信
							update_device_communication();
							//从内存中读数据到任务单
							t_error = check_and_read_memory_to_task(mp_device_one_level_task);

							if ( t_error == NODATA )
							{
								//设备正常运行
								//延时1ms, snap7的通信效率偏慢, 不需要高频率检查
								std::this_thread::sleep_for(std::chrono::milliseconds(1));
							}
							else
							{
								if ( t_error != SUCCESS )
								{
									mp_device_one_level_task->set_task_error_manager(t_error);
								}
								end_task(mp_device_one_level_task);
								m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_OVER;
							}
						}
						//else等待发送方给新的指令. TASK_STOP 之后 不执行.
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_READY;
					}
					break;
				}
				case DISPATCH_DEVICE_ONE_LEVEL_OVER:
				{
					//更新通信
					update_device_communication();
					if ( mp_device_one_level_task.get() != NULL )
					{
						//检查任务状态,
						//在 E_ONE_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
						if ( mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
						{
							//这里会通知任务已经释放, 然后销毁任务单,  并降级
							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
							mp_device_one_level_task.reset();
							m_device_one_level_command_key.clear();
							m_device_one_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW;
							m_dispatch_device_status = DISPATCH_DEVICE_READY;
						}
							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
						else if (  mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
						{
							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
							m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_WORK;
						}
						//else //保持不动, 直到发送方给定新的任务,
					}
					else
					{
						//直接降级
						m_dispatch_device_status = DISPATCH_DEVICE_READY;
					}
					break;
				}
				case DISPATCH_DEVICE_FAULT:
				{
					//更新通信
					update_device_communication();

					//所有任务报错, 并销毁任务.
					if ( mp_device_one_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_ERROR, MINOR_ERROR, "m_respons_status is error");
						mp_device_one_level_task->set_task_error_manager(t_error);
						end_task(mp_device_one_level_task);
						mp_device_one_level_task.reset();
					}
					if ( mp_device_two_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_ERROR, MINOR_ERROR, "m_respons_status is error");
						mp_device_two_level_task->set_task_error_manager(t_error);
						end_task(mp_device_two_level_task);
						mp_device_two_level_task.reset();
					}
					if ( mp_device_three_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_ERROR, MINOR_ERROR, "m_respons_status is error");
						mp_device_three_level_task->set_task_error_manager(t_error);
						end_task(mp_device_three_level_task);
						mp_device_three_level_task.reset();
					}


					break;
				}
				case DISPATCH_DEVICE_DISCONNECT:
				{
					//更新通信
					update_device_communication();
					//所有任务报错, 并销毁任务.
					if ( mp_device_one_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_DISCONNECT, MINOR_ERROR, "m_respons_status is error");
						mp_device_one_level_task->set_task_error_manager(t_error);
						end_task(mp_device_one_level_task);
						mp_device_one_level_task.reset();
					}
					if ( mp_device_two_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_DISCONNECT, MINOR_ERROR, "m_respons_status is error");
						mp_device_two_level_task->set_task_error_manager(t_error);
						end_task(mp_device_two_level_task);
						mp_device_two_level_task.reset();
					}
					if ( mp_device_three_level_task.get() != NULL )
					{
						//添加错误码
						Error_manager t_error(DISPATCH_DEVICE_STATUS_DISCONNECT, MINOR_ERROR, "m_respons_status is error");
						mp_device_three_level_task->set_task_error_manager(t_error);
						end_task(mp_device_three_level_task);
						mp_device_three_level_task.reset();
					}


					break;
				}
				case DISPATCH_DEVICE_READY:
				{
					//更新通信
					update_device_communication();
					break;
				}
				default:
				{

					break;
				}
			}
		}
	}

	LOG(INFO) << " Dispatch_device_base::execute_thread_fun() end "<< this;
	return;
}

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

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





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

	return Error_code::SUCCESS;
}