// // 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; m_device_key = -1; m_dispatch_device_type = DISPATCH_DEVICE_UNKNOWN; mp_execute_thread = NULL; m_device_one_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW; m_device_two_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW; m_device_three_level_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_TYPE_UNKNOW; m_break_flag = false; } 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 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; } //当接受2级任务时, 标记位改为true if ( dispatch_task_level == DISPATCH_TASK_TWO_LEVEL ) { 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); } m_break_flag = true; } //这里不用检查任务内容, 直接下发给底层设备 //永远启动到三级任务工作状态. // 启动定位管理模块，的核心工作线程 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::execute_task(std::shared_ptr p_task, Dispatch_task_level dispatch_task_level, std::string command_key, Common_data::Dispatch_process_type process_type) { LOG(INFO) << " ---Dispatch_device_base::execute_task ---"<< " command_key = "<set_task_statu(Task_Base::Task_statu::TASK_STOP); } m_break_flag = true; } //这里不用检查任务内容, 直接下发给底层设备 //永远启动到三级任务工作状态. // 启动定位管理模块，的核心工作线程 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 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::unique_lock 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) { 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 p_task, Dispatch_task_level dispatch_task_level) { //加锁 std::unique_lock 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::sign_for_task(std::shared_ptr p_task, Dispatch_task_level dispatch_task_level, std::string command_key, Common_data::Dispatch_process_type process_type) { //加锁 std::unique_lock 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; 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: { m_device_two_level_command_key = command_key; m_device_two_level_process_type = process_type; 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: { m_device_three_level_command_key = command_key; m_device_three_level_process_type = process_type; 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 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 p_task, Dispatch_task_level dispatch_task_level) { std::unique_lock 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 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 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 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 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 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 * tp_task_source = NULL; std::string * tp_command_key_target = NULL; Common_data::Dispatch_process_type * tp_process_type_target = NULL; std::shared_ptr * 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 t_lock(m_lock); //只能在原任务结束的时候升级, 否则返回 return Error_code::NODATA; 通知上级重试 switch ( dispatch_task_level_source ) { case DISPATCH_TASK_ONE_LEVEL: { if ( m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_OVER ) { return Error_code::NODATA; } 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: { if ( m_dispatch_device_status != DISPATCH_DEVICE_TWO_LEVEL_OVER ) { return Error_code::NODATA; } 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: { if ( m_dispatch_device_status != DISPATCH_DEVICE_THREE_LEVEL_OVER ) { return Error_code::NODATA; } 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; } bool Dispatch_device_base::get_break_flag() { return m_break_flag; } void Dispatch_device_base::set_break_flag(bool break_flag) { m_break_flag = break_flag; } std::string Dispatch_device_base::get_current_command_key() { if ( m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER) { return m_device_three_level_command_key; } if ( m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER) { return m_device_two_level_command_key; } if ( m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER) { return m_device_one_level_command_key; } std::string st; return st; } //执行外界任务的执行函数 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::yield(); std::unique_lock t_lock(m_lock); 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 123"); 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 456"); 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 789"); 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: { //更新通信 update_device_communication(); break; } } } } LOG(INFO) << " Dispatch_device_base::execute_thread_fun() end "<< this; return; } //执行线程工作函数, 正在执行任务单. Error_manager Dispatch_device_base::execute_thread_working(std::shared_ptr p_task, Dispatch_device_status & device_status) { return Error_code::SUCCESS; } //执行线程工作函数, 已经完成任务单. 等待新的指令 Error_manager Dispatch_device_base::execute_thread_over(std::shared_ptr p_task, Dispatch_device_status & device_status) { return Error_code::SUCCESS; } //把任务单写入到内存中, 子类必须重载 Error_manager Dispatch_device_base::write_task_to_memory(std::shared_ptr 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 p_task) { return Error_code::SUCCESS; } //取消下发的指令 Error_manager Dispatch_device_base::cancel_command() { //以后再写 need programe //目前调度和plc的通信指令做的很简单,没有暂停和急停 复位等操作. //这里先空着,以后再写. //调度模块单方面销毁任务, 不管底层plc的执行情况, 也不去告知plc任务取消. return Error_code::SUCCESS; }