StoreProcessTask.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518
  1. //
  2. // Created by zx on 2020/7/7.
  3. //
  4. #include <Parkspace_communicator.h>
  5. #include <dispatch_message.pb.h>
  6. #include "dispatch_communicator.h"
  7. #include "StoreProcessTask.h"
  8. #include "process_message.pb.h"
  9. #include "command_manager.h"
  10. #include "system_communicator.h"
  11. #include "uniq_key.h"
  12. StoreProcessTask::StoreProcessTask(unsigned int terminor_id)
  13. :m_publish_statu_thread(nullptr)
  14. {
  15. m_terminor_id=terminor_id;
  16. message::Base_info base_info;
  17. base_info.set_msg_type(message::eStoring_process_statu_msg);
  18. base_info.set_sender(message::eMain);
  19. base_info.set_receiver(message::eEmpty);
  20. m_storing_process_statu_msg.mutable_base_info()->CopyFrom(base_info);
  21. m_storing_process_statu_msg.set_terminal_id(terminor_id);
  22. reset_process_statu();
  23. }
  24. StoreProcessTask::~StoreProcessTask()
  25. {
  26. //退出线程
  27. m_publish_exit_condition.set_pass_ever(true);
  28. if(m_publish_statu_thread!= nullptr)
  29. {
  30. if(m_publish_statu_thread->joinable())
  31. {
  32. m_publish_statu_thread->join();
  33. }
  34. delete m_publish_statu_thread;
  35. m_publish_statu_thread=nullptr;
  36. }
  37. }
  38. Error_manager StoreProcessTask::init_task(message::Locate_information locate_info,message::Car_info car_info)
  39. {
  40. reset_recv_msg();
  41. m_car_info=car_info;
  42. m_locate_info=locate_info;
  43. reset_process_statu();
  44. ///创建状态发布线程
  45. if(m_publish_statu_thread== nullptr)
  46. {
  47. m_publish_exit_condition.reset(false, false, false);
  48. m_publish_statu_thread=new std::thread(publish_thread_func,this);
  49. }
  50. return SUCCESS;
  51. }
  52. Error_manager StoreProcessTask::locate_step() {
  53. Error_manager code;
  54. //检查测量模块状态
  55. code=Locate_communicator::get_instance_pointer()->check_statu(m_terminor_id);
  56. if(code!=SUCCESS)
  57. return code;
  58. message::Measure_request_msg request;
  59. message::Base_info base_info;
  60. base_info.set_msg_type(message::eLocate_request_msg);
  61. base_info.set_sender(message::eMain);
  62. base_info.set_receiver(message::eMeasurer);
  63. base_info.set_timeout_ms(20000); //测量超时5s
  64. request.mutable_base_info()->CopyFrom(base_info);
  65. request.set_command_key(create_key());
  66. request.set_terminal_id(m_terminor_id);
  67. code=Locate_communicator::get_instance_pointer()->locate_request(request,m_measure_response_msg);
  68. if(code!=SUCCESS)
  69. return code;
  70. if(m_measure_response_msg.error_manager().error_code()==0) {
  71. return SUCCESS;
  72. }
  73. else
  74. return Error_manager(FAILED,MINOR_ERROR,m_measure_response_msg.error_manager().error_description().c_str());
  75. }
  76. /*
  77. * 调度
  78. */
  79. Error_manager StoreProcessTask::dispatch_step()
  80. {
  81. Error_manager code;
  82. /*
  83. * 判断调度所需的数据是否都正常
  84. */
  85. //1,测量信息是否存在
  86. if(m_measure_response_msg.has_base_info()== false
  87. ||m_measure_response_msg.has_locate_information()==false
  88. ||m_parcspace_alloc_response_msg.has_base_info()== false
  89. ||m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
  90. {
  91. return Error_manager(ERROR,MAJOR_ERROR,"调度所需的前置数据(测量,车位)不存在");
  92. }
  93. //2,判断调度节点状态
  94. code=Dispatch_communicator::get_instance_pointer()->check_entrance_statu(m_terminor_id);
  95. if(code!=SUCCESS)
  96. return code;
  97. message::Dispatch_request_msg request;
  98. message::Base_info base_info;
  99. base_info.set_msg_type(message::eDispatch_request_msg);
  100. base_info.set_sender(message::eMain);
  101. base_info.set_receiver(message::eDispatch);
  102. base_info.set_timeout_ms(1000*15); //超时15s
  103. request.mutable_base_info()->CopyFrom(base_info);
  104. std::string key=create_key();
  105. request.set_command_key(key);
  106. request.set_terminal_id(m_terminor_id);
  107. request.set_dispatch_motion_direction(message::E_STORE_CAR);
  108. request.set_parkspace_id(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id());
  109. code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,m_dispatch_response_msg);
  110. if(code!=SUCCESS)
  111. return code;
  112. if(m_dispatch_response_msg.error_manager().error_code()==0) {
  113. return SUCCESS;
  114. }
  115. else
  116. return Error_manager(FAILED,MINOR_ERROR,"dispatch response error_code error");
  117. }
  118. /*
  119. * reset 进度信息
  120. */
  121. void StoreProcessTask::reset_process_statu()
  122. {
  123. message::Alloc_space_step_statu alloc_step;
  124. alloc_step.set_step_statu(message::eWaiting);
  125. message::Measure_step_statu measure_step;
  126. measure_step.set_step_statu(message::eWaiting);
  127. message::Dispatch_store_step_statu store_step;
  128. store_step.set_step_statu(message::eWaiting);
  129. message::Confirm_space_step_statu confirm_step;
  130. confirm_step.set_step_statu(message::eWaiting);
  131. message::Release_space_step_statu release_step;
  132. release_step.set_step_statu(message::eWaiting);
  133. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  134. m_storing_process_statu_msg.mutable_alloc_space_step()->CopyFrom(alloc_step);
  135. m_storing_process_statu_msg.mutable_measure_step()->CopyFrom(measure_step);
  136. m_storing_process_statu_msg.mutable_dispatch_step()->CopyFrom(store_step);
  137. m_storing_process_statu_msg.mutable_confirm_space_step()->CopyFrom(confirm_step);
  138. m_storing_process_statu_msg.mutable_failed_release_space_step()->CopyFrom(release_step);
  139. m_storing_process_statu_msg.set_license(m_car_info.license());
  140. m_storing_process_statu_msg.set_terminal_id(m_terminor_id);
  141. }
  142. /*
  143. * 分配车位
  144. */
  145. Error_manager StoreProcessTask::alloc_space()
  146. {
  147. //更新车位分配步骤状态
  148. {
  149. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  150. m_storing_process_statu_msg.mutable_alloc_space_step()->mutable_car_info()->CopyFrom(m_car_info);
  151. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eWorking);
  152. }
  153. /*
  154. * 检查是否有测量数据
  155. */
  156. if(m_locate_info.has_locate_height()==false||m_locate_info.has_locate_width()==false)
  157. {
  158. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  159. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eError);
  160. m_storing_process_statu_msg.mutable_alloc_space_step()->set_description("停车请求缺少车辆高度和宽度信息");
  161. return Error_manager(FAILED,MINOR_ERROR,"停车请求缺少车辆高度和宽度信息");
  162. }
  163. /*
  164. * 检查车位管理模块是否正常
  165. */
  166. Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
  167. if(code!=SUCCESS)
  168. {
  169. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  170. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eError);
  171. m_storing_process_statu_msg.mutable_alloc_space_step()->set_description(code.get_error_description());
  172. return code;
  173. }
  174. //发送分配请求
  175. message::Parkspace_allocation_request_msg request;
  176. message::Base_info base_info;
  177. base_info.set_msg_type(message::eParkspace_allocation_request_msg);
  178. base_info.set_sender(message::eMain);
  179. base_info.set_receiver(message::eParkspace);
  180. base_info.set_timeout_ms(1000); //超时1s
  181. request.mutable_base_info()->CopyFrom(base_info);
  182. request.mutable_car_info()->CopyFrom(m_car_info);
  183. request.set_command_key(create_key());
  184. request.set_terminal_id(m_terminor_id);
  185. code=Parkspace_communicator::get_instance_pointer()->alloc_request(request,m_parcspace_alloc_response_msg);
  186. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  187. if(code!=SUCCESS)
  188. {
  189. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eError);
  190. m_storing_process_statu_msg.mutable_alloc_space_step()->set_description(code.get_error_description());
  191. return code;
  192. }
  193. if(m_parcspace_alloc_response_msg.error_manager().error_code()==0)
  194. {
  195. message::Car_info alloc_car_info=m_parcspace_alloc_response_msg.allocated_space_info().car_info();
  196. if(alloc_car_info.license()!=m_car_info.license())
  197. {
  198. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eError);
  199. m_storing_process_statu_msg.mutable_alloc_space_step()->set_description("分配车位反馈的车辆信息不匹配");
  200. return Error_manager(ERROR,MINOR_ERROR,"分配车位反馈的车辆信息不匹配");
  201. }
  202. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eComplete);
  203. return SUCCESS;
  204. }
  205. else
  206. {
  207. m_storing_process_statu_msg.mutable_alloc_space_step()->set_step_statu(message::eError);
  208. m_storing_process_statu_msg.mutable_alloc_space_step()->set_description("分配车位反馈结果错误");
  209. return Error_manager(FAILED,MINOR_ERROR,"分配车位反馈结果错误");
  210. }
  211. }
  212. /*
  213. * 车位占用确认
  214. */
  215. Error_manager StoreProcessTask::confirm_space_step()
  216. {
  217. /*
  218. * 检查车位管理模块是否正常
  219. */
  220. Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
  221. if(code!=SUCCESS)
  222. return code;
  223. message::Parkspace_confirm_alloc_request_msg request;
  224. message::Base_info base_info;
  225. base_info.set_msg_type(message::eParkspace_confirm_alloc_request_msg);
  226. base_info.set_sender(message::eMain);
  227. base_info.set_receiver(message::eParkspace);
  228. base_info.set_timeout_ms(1000); //测量超时1s
  229. request.mutable_base_info()->CopyFrom(base_info);
  230. message::Parkspace_info space_info=m_parcspace_alloc_response_msg.allocated_space_info();
  231. request.mutable_confirm_space_info()->CopyFrom(space_info);
  232. request.set_command_key(create_key());
  233. message::Parkspace_confirm_alloc_response_msg confirm_response;
  234. code=Parkspace_communicator::get_instance_pointer()->confirm_request(request,confirm_response);
  235. if(code!=SUCCESS)
  236. return code;
  237. if(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()!=
  238. confirm_response.confirm_alloc_space_info().parkspace_id())
  239. {
  240. return Error_manager(ERROR,MINOR_ERROR,"占用车位与分配车位不一致");
  241. }
  242. if(confirm_response.error_manager().error_code()==0) {
  243. /*LOG(INFO)<<"停车流程正常,确认占用车位成功,停车终端:"<<m_terminor_id
  244. <<", 指令id:"<<m_command_info.place()+m_command_info.time()
  245. <<", 车位楼层:"<<confirm_response.confirm_alloc_space_info().floor()
  246. <<", 车位序号:"<<confirm_response.confirm_alloc_space_info().index()
  247. <<", 车牌号:"<<confirm_response.confirm_alloc_space_info().car_info().license();*/
  248. return SUCCESS;
  249. }
  250. else
  251. return Error_manager(FAILED,MINOR_ERROR,"parkspace confirm response error_code error");
  252. }
  253. /*
  254. * 车位解锁,当停车失败时需要车位解锁
  255. */
  256. Error_manager StoreProcessTask::release_space_step()
  257. {
  258. /*
  259. * 检查是否曾经分配过车位
  260. */
  261. if(m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
  262. {
  263. return Error_manager(FAILED,MINOR_ERROR," parkspace release request without space info");
  264. }
  265. /*
  266. * 检查车位管理模块是否正常
  267. */
  268. Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
  269. if(code!=SUCCESS)
  270. return code;
  271. message::Parkspace_release_request_msg request;
  272. message::Base_info base_info;
  273. base_info.set_msg_type(message::eParkspace_release_request_msg);
  274. base_info.set_sender(message::eMain);
  275. base_info.set_receiver(message::eParkspace);
  276. base_info.set_timeout_ms(1000); //测量超时1s
  277. request.mutable_base_info()->CopyFrom(base_info);
  278. message::Parkspace_info space_info=m_parcspace_alloc_response_msg.allocated_space_info();
  279. request.mutable_release_space_info()->CopyFrom(space_info);
  280. request.set_command_key(create_key());
  281. message::Parkspace_release_response_msg release_response;
  282. code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
  283. if(code!=SUCCESS)
  284. return code;
  285. if(release_response.error_manager().error_code()==0) {
  286. /*LOG(WARNING)<<"停车流程异常,释放车位成功,停车终端:"<<m_terminor_id
  287. <<", 指令id:"<<m_command_info.place()+m_command_info.time()
  288. <<", 车位楼层:"<<m_parcspace_alloc_response_msg.allocated_space_info().floor()
  289. <<", 车位序号:"<<m_parcspace_alloc_response_msg.allocated_space_info().index()
  290. <<", 车牌号:"<<m_parcspace_alloc_response_msg.allocated_space_info().car_info().license();*/
  291. return SUCCESS;
  292. }
  293. else
  294. return Error_manager(FAILED,MINOR_ERROR,"parkspace release response error_code error");
  295. }
  296. void StoreProcessTask::Main()
  297. {
  298. /*
  299. * 外部已经分配好车位,进入到此流程说明车位已经分配好, 存放在 m_parcspace_alloc_response_msg
  300. */
  301. Error_manager code;
  302. //开始执行停车指令
  303. //第一步测量
  304. switch (0)
  305. {
  306. //第一步,测量
  307. case 0:
  308. {
  309. //更新状态信息
  310. {
  311. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  312. m_storing_process_statu_msg.mutable_measure_step()->set_step_statu(message::eWorking);
  313. }
  314. //开始定位
  315. code=locate_step();
  316. usleep(1000*1000*(rand()%5+1));
  317. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  318. if(code!=SUCCESS)
  319. {
  320. //更新进度状态
  321. m_storing_process_statu_msg.mutable_measure_step()->set_step_statu(message::eError);
  322. m_storing_process_statu_msg.mutable_measure_step()->set_description(code.get_error_description());
  323. LOG(ERROR)<<"测量失败:"<<code.get_error_description();
  324. break;
  325. }
  326. //更新状态信息
  327. m_storing_process_statu_msg.mutable_measure_step()->mutable_locate_info()->CopyFrom(m_measure_response_msg.locate_information());
  328. m_storing_process_statu_msg.mutable_measure_step()->set_step_statu(message::eComplete);
  329. }
  330. //第二步,调度
  331. case 1:
  332. {
  333. //更新状态信息
  334. {
  335. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  336. m_storing_process_statu_msg.mutable_dispatch_step()->set_step_statu(message::eWorking);
  337. m_storing_process_statu_msg.mutable_dispatch_step()->mutable_locate_info()->CopyFrom(
  338. m_measure_response_msg.locate_information());
  339. m_storing_process_statu_msg.mutable_dispatch_step()->mutable_space_info()->CopyFrom(
  340. m_parcspace_alloc_response_msg.allocated_space_info());
  341. }
  342. //开始调度
  343. code=dispatch_step();
  344. usleep(1000*1000*(rand()%3));
  345. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  346. if(code!=SUCCESS)
  347. {
  348. m_storing_process_statu_msg.mutable_dispatch_step()->set_step_statu(message::eError);
  349. m_storing_process_statu_msg.mutable_dispatch_step()->set_description(code.get_error_description());
  350. LOG(ERROR)<<"调度失败:"<<code.get_error_description();
  351. break;
  352. }
  353. //更新状态信息
  354. m_storing_process_statu_msg.mutable_dispatch_step()->set_step_statu(message::eComplete);
  355. }
  356. //第三步,占据车位
  357. case 2:
  358. {
  359. //更新状态信息
  360. {
  361. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  362. m_storing_process_statu_msg.mutable_confirm_space_step()->set_step_statu(message::eWorking);
  363. m_storing_process_statu_msg.mutable_confirm_space_step()->mutable_space_info()->CopyFrom(
  364. m_parcspace_alloc_response_msg.allocated_space_info());
  365. }
  366. //开始工作
  367. code=confirm_space_step();
  368. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  369. if(code!=SUCCESS)
  370. {
  371. m_storing_process_statu_msg.mutable_confirm_space_step()->set_step_statu(message::eError);
  372. m_storing_process_statu_msg.mutable_confirm_space_step()->set_description(code.get_error_description());
  373. LOG(ERROR)<<",终端号:"<<m_terminor_id<<"停车流程:"<<code.get_error_description()<<
  374. " 车位id :"<<m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()
  375. <<",车牌:"<<m_car_info.license();
  376. break;
  377. }
  378. //更新状态信息
  379. m_storing_process_statu_msg.mutable_confirm_space_step()->set_step_statu(message::eComplete);
  380. }
  381. //第四步,打印... 日志 .... 记录.....
  382. case 3:
  383. {
  384. LOG(INFO)<<"停车成功,停车终端:"<<m_terminor_id
  385. <<", 车位id:"<<m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()
  386. <<", 车牌号:"<<m_car_info.license()<<"**********************";
  387. return ;
  388. }
  389. }
  390. /*
  391. * switch 语句break,说明停车故障,需清除车位
  392. */
  393. //失败,清理车位
  394. {
  395. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  396. m_storing_process_statu_msg.mutable_failed_release_space_step()->set_step_statu(message::eWorking);
  397. }
  398. code=release_space_step();
  399. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  400. if(code!=SUCCESS)
  401. {
  402. m_storing_process_statu_msg.mutable_failed_release_space_step()->set_step_statu(message::eError);
  403. m_storing_process_statu_msg.mutable_failed_release_space_step()->set_description(code.get_error_description());
  404. LOG(ERROR)<<"致命故障,停车失败,清理车位故障:"<<code.get_error_description();
  405. }
  406. else
  407. {
  408. m_storing_process_statu_msg.mutable_failed_release_space_step()->set_step_statu(message::eComplete);
  409. }
  410. /*
  411. * 流程异常,此处应暂停系统,待管理员介入
  412. */
  413. usleep(1000*2000);
  414. }
  415. /*
  416. * 发布状态线程
  417. */
  418. void StoreProcessTask::publish_thread_func(StoreProcessTask* ptask)
  419. {
  420. if(ptask)
  421. {
  422. ptask->publish_step_status();
  423. }
  424. }
  425. void StoreProcessTask::publish_step_status()
  426. {
  427. //未收到退出信号
  428. while(false==m_publish_exit_condition.wait_for_ex(std::chrono::milliseconds(50)))
  429. {
  430. /*
  431. * 通过communicator 发布状态
  432. */
  433. if(System_communicator::get_instance_pointer())
  434. {
  435. if(m_storing_process_statu_msg.has_base_info()==true)
  436. {
  437. std::lock_guard<std::mutex> lock(m_storing_statu_lock);
  438. System_communicator::get_instance_pointer()->post_entrance_statu(m_storing_process_statu_msg);
  439. }
  440. }
  441. }
  442. }
  443. /*
  444. * 初始化 接收到的消息
  445. */
  446. void StoreProcessTask::reset_recv_msg() {
  447. m_locate_info = message::Locate_information();
  448. m_measure_response_msg = message::Measure_response_msg(); //测量模块的测量数据
  449. m_parcspace_alloc_response_msg = message::Parkspace_allocation_response_msg(); //分配的车位数据
  450. m_dispatch_response_msg = message::Dispatch_response_msg(); //调度模块的反馈数据
  451. }