Merge remote-tracking branch 'origin/master'

# Conflicts:
#	.gitignore
#	入口引导提示节点/ui_config.json
#	入口引导提示节点/window_screen_pyqt.py
#	指令检查节点/CheckEntrance.py
#	指令检查节点/node.py
#	管理节点/ui/spaceUi.py
#	管理节点/ui/spaceUi.ui
#	终端/ct_terminal/ct_terminal/MainForm.Designer.cs
#	终端/ct_terminal/ct_terminal/MainForm.cs

CMakeLists.txt

@@ -0,0 +1,308 @@
+cmake_minimum_required(VERSION 3.15)
+project(CT_project)
+
+set(CMAKE_CXX_STANDARD 14)
+
+include_directories(plc调度节点/communication)
+include_directories(plc调度节点/dispatch)
+include_directories(plc调度节点/error_code)
+include_directories(plc调度节点/message)
+include_directories(plc调度节点/rabbitmq)
+include_directories(plc调度节点/snap7_communication)
+include_directories(plc调度节点/system)
+include_directories(plc调度节点/task)
+include_directories(plc调度节点/tool)
+include_directories(plc调度节点/tool/TaskQueue)
+include_directories(plc调度节点/tool/TaskQueue/threadpp)
+include_directories(plc调度节点/tool/TaskQueue/threadpp/impl)
+include_directories(测量节点/communication)
+include_directories(测量节点/error_code)
+include_directories(测量节点/message)
+include_directories(测量节点/rabbitmq)
+include_directories(测量节点/system)
+include_directories(测量节点/task)
+include_directories(测量节点/tool)
+include_directories(测量节点/tool/TaskQueue)
+include_directories(测量节点/tool/TaskQueue/threadpp)
+include_directories(测量节点/tool/TaskQueue/threadpp/impl)
+include_directories(测量节点/velodyne_lidar)
+include_directories(测量节点/velodyne_lidar/match3d)
+include_directories(测量节点/velodyne_lidar/match3d/common)
+include_directories(测量节点/velodyne_lidar/velodyne_driver)
+include_directories(测量节点/verify)
+include_directories(测量节点/wanji_lidar)
+
+add_executable(CT_project
+        plc调度节点/communication/communication.pb.cc
+        plc调度节点/communication/communication.pb.h
+        plc调度节点/communication/communication_message.cpp
+        plc调度节点/communication/communication_message.h
+        plc调度节点/communication/communication_socket_base.cpp
+        plc调度节点/communication/communication_socket_base.h
+        plc调度节点/dispatch/database_communication_configuration.pb.cc
+        plc调度节点/dispatch/database_communication_configuration.pb.h
+        plc调度节点/dispatch/database_controller.cpp
+        plc调度节点/dispatch/database_controller.h
+        plc调度节点/dispatch/dispatch_command.cpp
+        plc调度节点/dispatch/dispatch_command.h
+        plc调度节点/dispatch/dispatch_communication.cpp
+        plc调度节点/dispatch/dispatch_communication.h
+        plc调度节点/dispatch/dispatch_coordinates.cpp
+        plc调度节点/dispatch/dispatch_coordinates.h
+        plc调度节点/dispatch/dispatch_ground_lidar.cpp
+        plc调度节点/dispatch/dispatch_ground_lidar.h
+        plc调度节点/dispatch/dispatch_manager.cpp
+        plc调度节点/dispatch/dispatch_manager.h
+        plc调度节点/dispatch/dispatch_parameter.pb.cc
+        plc调度节点/dispatch/dispatch_parameter.pb.h
+        plc调度节点/dispatch/dispatch_plc.cpp
+        plc调度节点/dispatch/dispatch_plc.h
+        plc调度节点/dispatch/dispatch_singlechip.cpp
+        plc调度节点/dispatch/dispatch_singlechip.h
+        plc调度节点/error_code/error_code.cpp
+        plc调度节点/error_code/error_code.h
+        plc调度节点/message/message.pb.cc
+        plc调度节点/message/message.pb.h
+        plc调度节点/message/message_base.pb.cc
+        plc调度节点/message/message_base.pb.h
+        plc调度节点/rabbitmq/rabbitmq.pb.cc
+        plc调度节点/rabbitmq/rabbitmq.pb.h
+        plc调度节点/rabbitmq/rabbitmq_base.cpp
+        plc调度节点/rabbitmq/rabbitmq_base.h
+        plc调度节点/rabbitmq/rabbitmq_message.cpp
+        plc调度节点/rabbitmq/rabbitmq_message.h
+        plc调度节点/rabbitmq/ttt.cpp
+        plc调度节点/rabbitmq/ttt.h
+        plc调度节点/snap7_communication/plc_data.cpp
+        plc调度节点/snap7_communication/plc_data.h
+        plc调度节点/snap7_communication/s7_plc.cpp
+        plc调度节点/snap7_communication/s7_plc.h
+        plc调度节点/snap7_communication/snap7_buf.cpp
+        plc调度节点/snap7_communication/snap7_buf.h
+        plc调度节点/snap7_communication/snap7_communication.pb.cc
+        plc调度节点/snap7_communication/snap7_communication.pb.h
+        plc调度节点/snap7_communication/snap7_communication_base.cpp
+        plc调度节点/snap7_communication/snap7_communication_base.h
+        plc调度节点/system/system_communication.cpp
+        plc调度节点/system/system_communication.h
+        plc调度节点/system/system_executor.cpp
+        plc调度节点/system/system_executor.h
+        plc调度节点/task/task_base.cpp
+        plc调度节点/task/task_base.h
+        plc调度节点/task/task_command_manager.cpp
+        plc调度节点/task/task_command_manager.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/pthread_lock.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/pthread_lock.hpp
+        plc调度节点/tool/TaskQueue/threadpp/impl/pthread_thread.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/pthread_thread.hpp
+        plc调度节点/tool/TaskQueue/threadpp/impl/std_lock.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/std_lock.hpp
+        plc调度节点/tool/TaskQueue/threadpp/impl/std_thread.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/std_thread.hpp
+        plc调度节点/tool/TaskQueue/threadpp/impl/win_lock.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/win_lock.hpp
+        plc调度节点/tool/TaskQueue/threadpp/impl/win_thread.h
+        plc调度节点/tool/TaskQueue/threadpp/impl/win_thread.hpp
+        plc调度节点/tool/TaskQueue/threadpp/recursive_lock.h
+        plc调度节点/tool/TaskQueue/threadpp/threadpp.h
+        plc调度节点/tool/TaskQueue/threadpp/threadpp_assert.h
+        plc调度节点/tool/TaskQueue/BaseTask.cpp
+        plc调度节点/tool/TaskQueue/BaseTask.h
+        plc调度节点/tool/TaskQueue/TaskPool.h
+        plc调度节点/tool/TaskQueue/ThreadTaskQueue.cpp
+        plc调度节点/tool/TaskQueue/ThreadTaskQueue.h
+        plc调度节点/tool/TaskQueue/TQFactory.cpp
+        plc调度节点/tool/TaskQueue/TQFactory.h
+        plc调度节点/tool/TaskQueue/TQInterface.h
+        plc调度节点/tool/binary_buf.cpp
+        plc调度节点/tool/binary_buf.h
+        plc调度节点/tool/common_data.cpp
+        plc调度节点/tool/common_data.h
+        plc调度节点/tool/measure_filter.h
+        plc调度节点/tool/pathcreator.cpp
+        plc调度节点/tool/pathcreator.h
+        plc调度节点/tool/pcl_cloud_with_lock.cpp
+        plc调度节点/tool/pcl_cloud_with_lock.h
+        plc调度节点/tool/point2D_tool.cpp
+        plc调度节点/tool/point2D_tool.h
+        plc调度节点/tool/point3D_tool.cpp
+        plc调度节点/tool/point3D_tool.h
+        plc调度节点/tool/point_tool.cpp
+        plc调度节点/tool/point_tool.h
+        plc调度节点/tool/proto_tool.cpp
+        plc调度节点/tool/proto_tool.h
+        plc调度节点/tool/singleton.cpp
+        plc调度节点/tool/singleton.h
+        plc调度节点/tool/string_convert.cpp
+        plc调度节点/tool/string_convert.h
+        plc调度节点/tool/thread_condition.cpp
+        plc调度节点/tool/thread_condition.h
+        plc调度节点/tool/thread_pool.h
+        plc调度节点/tool/thread_safe_list.cpp
+        plc调度节点/tool/thread_safe_list.h
+        plc调度节点/tool/thread_safe_queue.cpp
+        plc调度节点/tool/thread_safe_queue.h
+        plc调度节点/tool/time_tool.cpp
+        plc调度节点/tool/time_tool.h
+        plc调度节点/main.cpp
+        入口引导提示节点/led资料文档/led_protocol.cpp
+        测量节点/communication/communication.pb.cc
+        测量节点/communication/communication.pb.h
+        测量节点/communication/communication_message.cpp
+        测量节点/communication/communication_message.h
+        测量节点/communication/communication_socket_base.cpp
+        测量节点/communication/communication_socket_base.h
+        测量节点/error_code/error_code.cpp
+        测量节点/error_code/error_code.h
+        测量节点/message/measure_message.pb.cc
+        测量节点/message/measure_message.pb.h
+        测量节点/message/message.pb.cc
+        测量节点/message/message.pb.h
+        测量节点/message/message_base.pb.cc
+        测量节点/message/message_base.pb.h
+        测量节点/rabbitmq/rabbitmq.pb.cc
+        测量节点/rabbitmq/rabbitmq.pb.h
+        测量节点/rabbitmq/rabbitmq_base.cpp
+        测量节点/rabbitmq/rabbitmq_base.h
+        测量节点/rabbitmq/rabbitmq_message.cpp
+        测量节点/rabbitmq/rabbitmq_message.h
+        测量节点/rabbitmq/ttt.cpp
+        测量节点/rabbitmq/ttt.h
+        "测量节点/system/system_communication mq.cpp"
+        测量节点/system/system_communication.cpp
+        测量节点/system/system_communication.h
+        测量节点/system/system_communication_mq.h
+        测量节点/system/system_executor.cpp
+        测量节点/system/system_executor.h
+        测量节点/task/task_base.cpp
+        测量节点/task/task_base.h
+        测量节点/task/task_command_manager.cpp
+        测量节点/task/task_command_manager.h
+        测量节点/tests/lidar_calib_tools.cpp
+        测量节点/tests/vlp16_driver_test.cpp
+        测量节点/tool/TaskQueue/threadpp/impl/pthread_lock.h
+        测量节点/tool/TaskQueue/threadpp/impl/pthread_lock.hpp
+        测量节点/tool/TaskQueue/threadpp/impl/pthread_thread.h
+        测量节点/tool/TaskQueue/threadpp/impl/pthread_thread.hpp
+        测量节点/tool/TaskQueue/threadpp/impl/std_lock.h
+        测量节点/tool/TaskQueue/threadpp/impl/std_lock.hpp
+        测量节点/tool/TaskQueue/threadpp/impl/std_thread.h
+        测量节点/tool/TaskQueue/threadpp/impl/std_thread.hpp
+        测量节点/tool/TaskQueue/threadpp/impl/win_lock.h
+        测量节点/tool/TaskQueue/threadpp/impl/win_lock.hpp
+        测量节点/tool/TaskQueue/threadpp/impl/win_thread.h
+        测量节点/tool/TaskQueue/threadpp/impl/win_thread.hpp
+        测量节点/tool/TaskQueue/threadpp/recursive_lock.h
+        测量节点/tool/TaskQueue/threadpp/threadpp.h
+        测量节点/tool/TaskQueue/threadpp/threadpp_assert.h
+        测量节点/tool/TaskQueue/BaseTask.cpp
+        测量节点/tool/TaskQueue/BaseTask.h
+        测量节点/tool/TaskQueue/TaskPool.h
+        测量节点/tool/TaskQueue/ThreadTaskQueue.cpp
+        测量节点/tool/TaskQueue/ThreadTaskQueue.h
+        测量节点/tool/TaskQueue/TQFactory.cpp
+        测量节点/tool/TaskQueue/TQFactory.h
+        测量节点/tool/TaskQueue/TQInterface.h
+        测量节点/tool/binary_buf.cpp
+        测量节点/tool/binary_buf.h
+        测量节点/tool/common_data.cpp
+        测量节点/tool/common_data.h
+        测量节点/tool/icp_svd_registration.cpp
+        测量节点/tool/icp_svd_registration.hpp
+        测量节点/tool/measure_filter.h
+        测量节点/tool/pathcreator.cpp
+        测量节点/tool/pathcreator.h
+        测量节点/tool/pcl_cloud_with_lock.cpp
+        测量节点/tool/pcl_cloud_with_lock.h
+        测量节点/tool/point2D_tool.cpp
+        测量节点/tool/point2D_tool.h
+        测量节点/tool/point3D_tool.cpp
+        测量节点/tool/point3D_tool.h
+        测量节点/tool/point_tool.cpp
+        测量节点/tool/point_tool.h
+        测量节点/tool/proto_tool.cpp
+        测量节点/tool/proto_tool.h
+        测量节点/tool/region_status_checker.h
+        测量节点/tool/rotate_center_caliber.cpp
+        测量节点/tool/rotate_center_caliber.h
+        测量节点/tool/singleton.cpp
+        测量节点/tool/singleton.h
+        测量节点/tool/thread_condition.cpp
+        测量节点/tool/thread_condition.h
+        测量节点/tool/thread_pool.h
+        测量节点/tool/thread_safe_list.cpp
+        测量节点/tool/thread_safe_list.h
+        测量节点/tool/thread_safe_queue.cpp
+        测量节点/tool/thread_safe_queue.h
+        测量节点/tool/time_tool.cpp
+        测量节点/tool/time_tool.h
+        测量节点/velodyne_lidar/match3d/common/math.h
+        测量节点/velodyne_lidar/match3d/common/port.h
+        测量节点/velodyne_lidar/match3d/detect_ceres3d.cpp
+        测量节点/velodyne_lidar/match3d/detect_ceres3d.h
+        测量节点/velodyne_lidar/match3d/detect_wheel_ceres3d.cpp
+        测量节点/velodyne_lidar/match3d/detect_wheel_ceres3d.h
+        测量节点/velodyne_lidar/match3d/hybrid_grid.hpp
+        测量节点/velodyne_lidar/match3d/interpolated_grid.hpp
+        测量节点/velodyne_lidar/velodyne_driver/angles.h
+        测量节点/velodyne_lidar/velodyne_driver/calibration.cc
+        测量节点/velodyne_lidar/velodyne_driver/calibration.h
+        测量节点/velodyne_lidar/velodyne_driver/input.cc
+        测量节点/velodyne_lidar/velodyne_driver/input.h
+        测量节点/velodyne_lidar/velodyne_driver/rawdata.cc
+        测量节点/velodyne_lidar/velodyne_driver/rawdata.h
+        测量节点/velodyne_lidar/velodyne_driver/velodyne_lidar_device.cpp
+        测量节点/velodyne_lidar/velodyne_driver/velodyne_lidar_device.h
+        测量节点/velodyne_lidar/velodyne_driver/velodyne_lidar_scan_task.cpp
+        测量节点/velodyne_lidar/velodyne_driver/velodyne_lidar_scan_task.h
+        测量节点/velodyne_lidar/car_pose_detector.cpp
+        测量节点/velodyne_lidar/car_pose_detector.h
+        测量节点/velodyne_lidar/chassis_ceres_solver.cpp
+        测量节点/velodyne_lidar/chassis_ceres_solver.h
+        测量节点/velodyne_lidar/ground_region.cpp
+        测量节点/velodyne_lidar/ground_region.h
+        测量节点/velodyne_lidar/velodyne_config.pb.cc
+        测量节点/velodyne_lidar/velodyne_config.pb.h
+        测量节点/velodyne_lidar/velodyne_manager.cpp
+        测量节点/velodyne_lidar/velodyne_manager.h
+        测量节点/velodyne_lidar/velodyne_manager_task.cpp
+        测量节点/velodyne_lidar/velodyne_manager_task.h
+        测量节点/verify/hardware_limit.pb.cc
+        测量节点/verify/hardware_limit.pb.h
+        测量节点/verify/Railing.cpp
+        测量节点/verify/Railing.h
+        测量节点/verify/Terminal_region_limit.cpp
+        测量节点/verify/Terminal_region_limit.h
+        测量节点/verify/Verify_result.cpp
+        测量节点/verify/Verify_result.h
+        测量节点/wanji_lidar/async_client.cpp
+        测量节点/wanji_lidar/async_client.h
+        测量节点/wanji_lidar/detect_wheel_ceres.cpp
+        测量节点/wanji_lidar/detect_wheel_ceres.h
+        测量节点/wanji_lidar/LogFiles.cpp
+        测量节点/wanji_lidar/LogFiles.h
+        测量节点/wanji_lidar/Point2D.cpp
+        测量节点/wanji_lidar/Point2D.h
+        测量节点/wanji_lidar/Point3D.cpp
+        测量节点/wanji_lidar/Point3D.h
+        测量节点/wanji_lidar/region_detect.cpp
+        测量节点/wanji_lidar/region_detect.h
+        测量节点/wanji_lidar/region_worker.cpp
+        测量节点/wanji_lidar/region_worker.h
+        测量节点/wanji_lidar/wanji_716N_device.cpp
+        测量节点/wanji_lidar/wanji_716N_device.h
+        测量节点/wanji_lidar/wanji_lidar_device.cpp
+        测量节点/wanji_lidar/wanji_lidar_device.h
+        测量节点/wanji_lidar/wanji_lidar_scan_task.cpp
+        测量节点/wanji_lidar/wanji_lidar_scan_task.h
+        测量节点/wanji_lidar/wanji_manager.cpp
+        测量节点/wanji_lidar/wanji_manager.h
+        测量节点/wanji_lidar/wanji_manager_task.cpp
+        测量节点/wanji_lidar/wanji_manager_task.h
+        测量节点/wanji_lidar/wj_716_lidar_protocol.cpp
+        测量节点/wanji_lidar/wj_716_lidar_protocol.h
+        测量节点/wanji_lidar/wj_716N_lidar_protocol.cpp
+        测量节点/wanji_lidar/wj_716N_lidar_protocol.h
+        测量节点/wanji_lidar/wj_lidar_conf.pb.cc
+        测量节点/wanji_lidar/wj_lidar_conf.pb.h
+        测量节点/main.cpp)

plc调度节点/dispatch/dispatch_command.cpp

@@ -1,7 +1,7 @@
 
 #include "dispatch_command.h"
 #include <google/protobuf/text_format.h>
-
+#include "../tool/time_tool.h"
 
 Dispatch_command::Dispatch_command()
 {
@@ -86,6 +86,8 @@ Error_manager Dispatch_command::dispatch_request_to_sql(int device_floor, int di
 				t_error = update_command_queue_for_statu(1);
 				//制作存车表单
 				t_error = create_park_table();
+				//增加 记录表, 存车指令 完成后添加存车记录
+				t_error =  insert_record_for_park_start();
 
 				LOG(INFO) << " create_park_table 创建存车任务单 =  "<< m_park_table_msg.DebugString() << " --- " << this;
 				return Error_code::SUCCESS;
@@ -117,6 +119,9 @@ Error_manager Dispatch_command::dispatch_request_to_sql(int device_floor, int di
 				t_error = update_command_queue_for_statu(1);
 				//制作取车表单
 				t_error = create_pick_table(outlet_ready);
+				//更新 记录表, 取车指令 完成后更新取车记录
+				t_error =  updata_record_for_pick_start();
+
 				LOG(INFO) << " create_pick_table 创建取车车任务单 =  "<< m_pick_table_msg.DebugString() << " --- " << this;
 			}
 		}
@@ -144,7 +149,8 @@ Error_manager Dispatch_command::dispatch_response_to_sql(Error_manager dispatch_
 			t_error = insert_vehicle_for_car_number();
 			//更新 指令队列, 根据车牌号 删除指令
 			t_error = delete_command_queue_for_statu();
-
+			//增加 记录表, 存车指令 完成后添加存车记录
+			t_error =  updata_record_for_park_end();
 		}
 		else if ( m_dispatch_process_type == Common_data::DISPATCH_PROCESS_PICKUP )
 		{
@@ -156,7 +162,8 @@ Error_manager Dispatch_command::dispatch_response_to_sql(Error_manager dispatch_
 			t_error = update_parkspace_info_clear_car_number();
 			//更新 指令队列, 根据车牌号 修改状态即可,  //指令状态, 0排队中, 1正在工作, 2已完成, 3故障异常
 			t_error = update_command_queue_for_statu(2);
-//			LOG(INFO) << "llllllllllllllllllllllllllllllllllllllllll respons =  "<< t_error << " --- " << this;
+			//更新 记录表, 取车指令 完成后更新取车记录
+			t_error =  updata_record_for_pick_end();
 		}
 		else if ( m_dispatch_process_type == Common_data::DISPATCH_PROCESS_REALLOCATE )
 		{
@@ -165,7 +172,8 @@ Error_manager Dispatch_command::dispatch_response_to_sql(Error_manager dispatch_
 			t_error = insert_vehicle_for_car_number();
 			//更新 指令队列, 根据车牌号 删除指令
 			t_error = delete_command_queue_for_statu();
-
+			//增加 记录表, 存车指令 完成后添加存车记录
+			t_error =  updata_record_for_park_end();
 		}
 		else if ( m_dispatch_process_type == Common_data::DISPATCH_PROCESS_REVOCATION )
 		{
@@ -178,6 +186,8 @@ Error_manager Dispatch_command::dispatch_response_to_sql(Error_manager dispatch_
 			//更新 指令队列, 根据车牌号 修改状态即可,  //指令状态, 0排队中, 1正在工作, 2已完成, 3故障异常
 			t_error = update_command_queue_for_statu(2);
 //			LOG(INFO) << "llllllllllllllllllllllllllllllllllllllllll respons =  "<< t_error << " --- " << this;
+			//更新 记录表, 取车指令 完成后更新取车记录, 撤销指令, 没有取车时间差
+			t_error =  updata_record_for_pick_end_ex();
 		}
 		else
 		{
@@ -769,7 +779,7 @@ Error_manager Dispatch_command::update_command_queue_for_statu(int statu)
 	sprintf(update_command_sql, "update command_queue set statu = %d, export_id = %d where car_number = '%s'",
 			statu, m_dispatch_command_map[m_car_number_optimal].m_export_id,
 			m_dispatch_command_map[m_car_number_optimal].m_car_number.c_str());
-	LOG(INFO) << "jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj update_command_sql =  "<< update_command_sql << " --- " << this;
+//	LOG(INFO) << "jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj update_command_sql =  "<< update_command_sql << " --- " << this;
 	Error_manager ec = Database_controller::get_instance_pointer()->sql_update(update_command_sql);
 	return ec;
 }
@@ -869,7 +879,179 @@ Error_manager Dispatch_command::delete_vehicle_for_car_number()
 	return ec;
 }
 
+//增加 记录表, 存车指令 完成后添加存车记录
+Error_manager Dispatch_command::insert_record_for_park_start()
+{
+	Time_tool::get_instance_references().time_start(PARK_TIME_FLAG);
+
+	int t_terminal = 0;
+	if (m_dispatch_command_map[m_car_number_optimal].m_measure_info_msg.cx()<0)
+	{
+		t_terminal = m_dispatch_id*2+1;
+	}
+	else if(m_dispatch_command_map[m_car_number_optimal].m_measure_info_msg.cx()>0)
+	{
+		t_terminal = m_dispatch_id*2+2;
+	}
+
+	char insert_record_sql[1024];
+	memset(insert_record_sql, 0, 1024);
+	sprintf(insert_record_sql, "INSERT INTO record (primary_key,car_number,in_time_start,measure_info,import_id) values ('%s','%s','%s','%s',%d)",
+			m_dispatch_command_map[m_car_number_optimal].m_primary_key.c_str(),
+			m_car_number_optimal.c_str(),
+			Time_tool::get_instance_references().get_current_time_seconds().c_str(),
+//			m_dispatch_command_map[m_car_number_optimal].m_parkspace_info_msg.id(),
+//			m_dispatch_command_map[m_car_number_optimal].m_parkspace_info_msg.DebugString().c_str(),
+			m_dispatch_command_map[m_car_number_optimal].m_measure_info.c_str(),
+			t_terminal	);
+	LOG(INFO) << " insert_record_sql =  "<< insert_record_sql << " --- " << this;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_insert(insert_record_sql);
+	return ec;
+}
+
+//增加 记录表, 存车指令 完成后添加存车记录
+Error_manager Dispatch_command::updata_record_for_park_end()
+{
+	Time_tool::get_instance_references().time_end(PARK_TIME_FLAG);
+	int in_time_difference = Time_tool::get_instance_references().get_time_seconds(PARK_TIME_FLAG);
+
+	//执行sql操作
+	char update_record_sql[1024];
+	memset(update_record_sql, 0, 1024);
+	sprintf(update_record_sql, "update record set in_time_end = '%s', in_time_difference = %d, space_id = %d, space_info = '%s' where primary_key = '%s' ",
+			Time_tool::get_instance_references().get_current_time_seconds().c_str(),
+			in_time_difference,
+			m_dispatch_command_map[m_car_number_optimal].m_parkspace_info_msg.id(),
+			m_dispatch_command_map[m_car_number_optimal].m_parkspace_info_msg.DebugString().c_str(),
+			m_dispatch_command_map[m_car_number_optimal].m_primary_key.c_str()	);
+	LOG(INFO) << " update_record_sql =  "<< update_record_sql << " --- " << this;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_update(update_record_sql);
+	return ec;
+}
+
+//更新 记录表, 取车指令 完成后更新取车记录
+Error_manager Dispatch_command::updata_record_for_pick_start()
+{
+	Time_tool::get_instance_references().time_start(PICK_TIME_FLAG);
+
+	//执行sql操作
+	char update_record_sql[1024];
+	memset(update_record_sql, 0, 1024);
+	sprintf(update_record_sql, "update record set out_time_start = '%s', export_id = %d where primary_key = '%s' ",
+			Time_tool::get_instance_references().get_current_time_seconds().c_str(),
+			m_dispatch_command_map[m_car_number_optimal].m_export_id,
+			m_dispatch_command_map[m_car_number_optimal].m_primary_key.c_str()	);
+	LOG(INFO) << " update_record_sql =  "<< update_record_sql << " --- " << this;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_update(update_record_sql);
+	return ec;
+}
+
+//更新 记录表, 取车指令 完成后更新取车记录
+Error_manager Dispatch_command::updata_record_for_pick_end()
+{
+	Time_tool::get_instance_references().time_end(PICK_TIME_FLAG);
+	int out_time_difference = Time_tool::get_instance_references().get_time_seconds(PICK_TIME_FLAG);
+
+	int parking_time;
+	get_parking_time(m_dispatch_command_map[m_car_number_optimal].m_primary_key, parking_time);
+	char parking_time_string[256] = "";
+	int hour = parking_time / 3600;
+	int min = parking_time / 60;
+	int sec = parking_time % 60;
+	sprintf(parking_time_string, " %d:%02d:%02d", hour, min, sec);
+
+	//执行sql操作
+	char update_record_sql[1024];
+	memset(update_record_sql, 0, 1024);
+	sprintf(update_record_sql, "update record set out_time_end = '%s', out_time_difference = %d, parking_time = '%s' where primary_key = '%s' ",
+			Time_tool::get_instance_references().get_current_time_seconds().c_str(),
+			out_time_difference,
+			parking_time_string,
+			m_dispatch_command_map[m_car_number_optimal].m_primary_key.c_str()	);
+	LOG(INFO) << " update_record_sql =  "<< update_record_sql << " --- " << this;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_update(update_record_sql);
+	return ec;
+}
+
+//更新 记录表, 取车指令 完成后更新取车记录, 撤销指令, 没有取车时间差
+Error_manager Dispatch_command::updata_record_for_pick_end_ex()
+{
+	int parking_time;
+	get_parking_time(m_dispatch_command_map[m_car_number_optimal].m_primary_key, parking_time);
+	char parking_time_string[256] = "";
+	int hour = parking_time / 3600;
+	int min = parking_time / 60;
+	int sec = parking_time % 60;
+	sprintf(parking_time_string, " %d:%02d:%02d", hour, min, sec);
+
+	//执行sql操作
+	char update_record_sql[1024];
+	memset(update_record_sql, 0, 1024);
+	sprintf(update_record_sql, "update record set out_time_end = '%s', parking_time = '%s' where primary_key = '%s' ",
+			Time_tool::get_instance_references().get_current_time_seconds().c_str(),
+			parking_time_string,
+			m_dispatch_command_map[m_car_number_optimal].m_primary_key.c_str()	);
+	LOG(INFO) << " update_record_sql =  "<< update_record_sql << " --- " << this;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_update(update_record_sql);
+	return ec;
+}
+
+//计算汽车在车库的存车时间, 从存车开始到取车结束, 返回 parking_time, 单位秒.
+Error_manager Dispatch_command::get_parking_time(std::string primary_key, int & parking_time )
+{
+	//查询存车时间 in_time_start
+	char query_record_sql[1024];
+	memset(query_record_sql, 0, 1024);
+	sprintf(query_record_sql,"select * from record where primary_key = '%s' ", primary_key.c_str() );
+	boost::shared_ptr<sql::ResultSet>  tp_result = nullptr;
+	Error_manager ec = Database_controller::get_instance_pointer()->sql_query(query_record_sql, tp_result);
+	if(ec == SUCCESS)
+	{
+		if(tp_result == nullptr)
+		{
+			return DB_RESULT_SET_EMPTY;
+		}
+		//只取第一条结果, 默认是id最小的,
+		if (tp_result->next())
+		{
+			char buf[1024];
+			memset(buf, 0, 1024);
+			try
+			{
+				//解析数据
+				std::string in_time_start_string = tp_result->getString("in_time_start");
+				std::chrono::system_clock::time_point in_time_start = Time_tool::get_instance_references().transform_time_string_seconds(in_time_start_string);
+				std::chrono::system_clock::time_point out_time_end = std::chrono::system_clock::now();
+				double t_parking_time = (out_time_end - in_time_start).count() / 1000000000;
+				parking_time = t_parking_time;
+				return Error_code::SUCCESS;
+			}
+			catch (sql::SQLException &e)
+			{
+				/* Use what() (derived from std::runtime_error) to fetch the error message */
+				sprintf(buf, "# ERR: %s\n (MySQL error code: %d, SQLState: %s", e.what(), e.getErrorCode(), e.getSQLState().c_str());
+				return Error_manager(DB_RESULT_SET_PARSE_ERROR, NEGLIGIBLE_ERROR, buf);
+			}
+			catch (std::runtime_error &e)
+			{
+				sprintf(buf, "# ERR: %s\n ERR: runtime_error in  %s ", e.what(), __FILE__);
+				return Error_manager(DB_RESULT_SET_PARSE_ERROR, NEGLIGIBLE_ERROR, buf);
+			}
+		}
+		else
+		{
+			return Error_manager(Error_code::DB_NOT_QUERY_EMPTY_PARKSPACE, Error_level::MINOR_ERROR,
+								 "数据库未查询到空车位 Parkspace_operating_function::query_one_empty_parkspace error ");
+		}
+		return SUCCESS;
+	}
+	else
+	{
+		return ec;
+	}
 
+	return Error_code::SUCCESS;
+}
 
 
 

plc调度节点/dispatch/dispatch_command.h

@@ -18,7 +18,8 @@
 class Dispatch_command
 {
 public:
-
+#define PARK_TIME_FLAG	101		//存车时间标记, 用于记录时差
+#define PICK_TIME_FLAG	102		//取车时间标记, 用于记录时差
 
 
 
@@ -143,7 +144,19 @@ protected://member functions
 	//删除 车辆表, 取车指令 完成后删除车辆信息
 	Error_manager delete_vehicle_for_car_number();
 
-
+	//增加 记录表, 存车指令 完成后添加存车记录
+	Error_manager insert_record_for_park_start();
+	//增加 记录表, 存车指令 完成后添加存车记录
+	Error_manager updata_record_for_park_end();
+	//更新 记录表, 取车指令 完成后更新取车记录
+	Error_manager updata_record_for_pick_start();
+	//更新 记录表, 取车指令 完成后更新取车记录
+	Error_manager updata_record_for_pick_end();
+	//更新 记录表, 取车指令 完成后更新取车记录, 撤销指令, 没有取车时间差
+	Error_manager updata_record_for_pick_end_ex();
+
+	//计算汽车在车库的存车时间, 从存车开始到取车结束, 返回 parking_time, 单位秒.
+	Error_manager get_parking_time(std::string primary_key, int & parking_time );
 
 protected://member variable
 public:

plc调度节点/dispatch/dispatch_communication.cpp

@@ -275,8 +275,10 @@ Error_manager Dispatch_communication::communication_init(int plc_id)
 	t_index += sizeof(float)*1;
 	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_response_locate_correct", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 1 });
 	t_index += sizeof(unsigned char)*1;
-	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_reserved45_48", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 3 });
-	t_index += sizeof(unsigned char)*3;
+	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_response_ground_status", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 1 });
+	t_index += sizeof(unsigned char)*1;
+	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_reserved46_47", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 2 });
+	t_index += sizeof(unsigned char)*2;
 	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_heartbeat", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 1 });
 	t_index += sizeof(unsigned char)*1;
 	t_variable_information_vector.push_back(Snap7_buf::Variable_information{"m_communication_mode", typeid(unsigned char).name(), t_index,sizeof(unsigned char), 1 });

plc调度节点/dispatch/dispatch_communication.h

@@ -482,7 +482,9 @@ public:
 		float					m_response_uniformed_car_y = 0;					//转角复位后,车辆中心点y
 		unsigned char			m_response_locate_correct = 0;				//数据是否有效, 0=无效, 1=有效
 
-		unsigned char			m_reserved45_48[3] = {0};							//预留
+		unsigned char			m_response_ground_status = 0;				//数据是否有效, 0=无效, 1=有效
+		unsigned char			m_reserved46_47[2] = {0};							//预留
+
 		unsigned char			m_response_heartbeat = 0;							//心跳位, 0-255循环
 		unsigned char			m_response_communication_mode = 0;					//通信模式	0 = 未知, 1=自动循环模式,2=手动刷新模式
 		unsigned char			m_response_refresh_command = 0;						//刷新指令 0-255任意数字,与上一次不同即可

plc调度节点/dispatch/dispatch_ground_lidar.cpp

@@ -132,22 +132,53 @@ void Dispatch_ground_lidar::execute_thread_fun()
 //					p_response_data->m_response_uniformed_car_y = m_ground_status_msg.locate_information_realtime().uniformed_car_y();
 //					p_response_data->m_response_locate_correct = m_ground_status_msg.locate_information_realtime().locate_correct();
 
-					p_response_data->m_response_car_center_x = m_measure_info.cx();
-					p_response_data->m_response_car_center_y = m_measure_info.cy();
-					p_response_data->m_response_car_angle = m_measure_info.theta();
-					p_response_data->m_response_car_front_theta = m_measure_info.front_theta();
-					p_response_data->m_response_car_length = m_measure_info.length();
-					p_response_data->m_response_car_width = m_measure_info.width();
-					p_response_data->m_response_car_height = m_measure_info.height();
-					p_response_data->m_response_car_wheel_base = m_measure_info.wheelbase();
-					p_response_data->m_response_car_wheel_width = m_measure_info.width();
-					p_response_data->m_response_uniformed_car_x = m_measure_info.cx();
-					p_response_data->m_response_uniformed_car_y = m_measure_info.cy();
+
 					if ( m_measure_info.ground_status() == 0 ) //ground_status  :ok 1,nothing 2,noise  3,border
 					{
+                        p_response_data->m_response_car_center_x = m_measure_info.cx();
+                        p_response_data->m_response_car_center_y = m_measure_info.cy();
+                        p_response_data->m_response_car_angle = m_measure_info.theta();
+                        p_response_data->m_response_car_front_theta = m_measure_info.front_theta();
+                        p_response_data->m_response_car_length = m_measure_info.length();
+                        p_response_data->m_response_car_width = m_measure_info.width();
+                        p_response_data->m_response_car_height = m_measure_info.height();
+                        p_response_data->m_response_car_wheel_base = m_measure_info.wheelbase();
+                        p_response_data->m_response_car_wheel_width = m_measure_info.width();
+                        p_response_data->m_response_uniformed_car_x = m_measure_info.cx();
+                        p_response_data->m_response_uniformed_car_y = m_measure_info.cy();
+
 						p_response_data->m_response_locate_correct = 1;	//locate_correct  0=无效, 1=有效,
+						p_response_data->m_response_ground_status = m_measure_info.ground_status();	//0  ok 1,nothing 2,noise  3,border
+
 					}
-				}
+					else
+                    {
+                        p_response_data->m_response_car_center_x = 0;
+                        p_response_data->m_response_car_center_y = 0;
+                        p_response_data->m_response_car_angle = 0;
+                        p_response_data->m_response_car_front_theta = 0;
+                        p_response_data->m_response_car_length = 0;
+                        p_response_data->m_response_car_width = 0;
+                        p_response_data->m_response_car_height = 0;
+                        p_response_data->m_response_car_wheel_base = 0;
+                        p_response_data->m_response_car_wheel_width = 0;
+                        p_response_data->m_response_uniformed_car_x = 0;
+                        p_response_data->m_response_uniformed_car_y = 0;
+
+                        p_response_data->m_response_locate_correct = 0;
+						p_response_data->m_response_ground_status = m_measure_info.ground_status();	//0  ok 1,nothing 2,noise  3,border
+					}
+
+//                    LOG(WARNING) << "------------------------------------------------------------ "<<std::endl;
+//                    LOG(WARNING) << "m_measure_info = " << m_measure_info.ground_status() <<std::endl;
+//                    LOG(WARNING) << "m_measure_info = " << m_measure_info.DebugString() <<std::endl;
+//                    LOG(WARNING) << "m_measure_info.wheelbase() = " << m_measure_info.wheelbase() <<std::endl;
+//                    LOG(WARNING) << "m_measure_info.ground_status() = " << m_measure_info.ground_status() <<std::endl;
+//                    LOG(WARNING) << "p_response_data->m_response_locate_correct = " << p_response_data->m_response_locate_correct <<std::endl;
+//                    printf("p_response_data->m_response_locate_correct = %d, \n", p_response_data->m_response_locate_correct);
+//                    LOG(WARNING) << "-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ "<<std::endl;
+
+                }
 				else if (p_response_data->m_response_refresh_command == p_request->m_request_refresh_command)
 				{
 					p_response_data->m_response_heartbeat = 1+p_response_data->m_response_heartbeat;
@@ -173,20 +204,39 @@ void Dispatch_ground_lidar::execute_thread_fun()
 //					p_response_data->m_response_uniformed_car_y = m_ground_status_msg.locate_information_realtime().uniformed_car_y();
 //					p_response_data->m_response_locate_correct = m_ground_status_msg.locate_information_realtime().locate_correct();
 
-					p_response_data->m_response_car_center_x = m_measure_info.cx();
-					p_response_data->m_response_car_center_y = m_measure_info.cy();
-					p_response_data->m_response_car_angle = m_measure_info.theta();
-					p_response_data->m_response_car_front_theta = m_measure_info.front_theta();
-					p_response_data->m_response_car_length = m_measure_info.length();
-					p_response_data->m_response_car_width = m_measure_info.width();
-					p_response_data->m_response_car_height = m_measure_info.height();
-					p_response_data->m_response_car_wheel_base = m_measure_info.wheelbase();
-					p_response_data->m_response_car_wheel_width = m_measure_info.width();
-					p_response_data->m_response_uniformed_car_x = m_measure_info.cx();
-					p_response_data->m_response_uniformed_car_y = m_measure_info.cy();
-					if ( m_measure_info.ground_status() == 0 ) //ground_status  :ok 1,nothing 2,noise  3,border
-					{
-						p_response_data->m_response_locate_correct = 1;	//locate_correct  0=无效, 1=有效,
+                    if ( m_measure_info.ground_status() == 0 ) //ground_status  :ok 1,nothing 2,noise  3,border
+                    {
+                        p_response_data->m_response_car_center_x = m_measure_info.cx();
+                        p_response_data->m_response_car_center_y = m_measure_info.cy();
+                        p_response_data->m_response_car_angle = m_measure_info.theta();
+                        p_response_data->m_response_car_front_theta = m_measure_info.front_theta();
+                        p_response_data->m_response_car_length = m_measure_info.length();
+                        p_response_data->m_response_car_width = m_measure_info.width();
+                        p_response_data->m_response_car_height = m_measure_info.height();
+                        p_response_data->m_response_car_wheel_base = m_measure_info.wheelbase();
+                        p_response_data->m_response_car_wheel_width = m_measure_info.width();
+                        p_response_data->m_response_uniformed_car_x = m_measure_info.cx();
+                        p_response_data->m_response_uniformed_car_y = m_measure_info.cy();
+
+                        p_response_data->m_response_locate_correct = 1;	//locate_correct  0=无效, 1=有效,
+						p_response_data->m_response_ground_status = m_measure_info.ground_status();	//0  ok 1,nothing 2,noise  3,border
+					}
+                    else
+                    {
+                        p_response_data->m_response_car_center_x = 0;
+                        p_response_data->m_response_car_center_y = 0;
+                        p_response_data->m_response_car_angle = 0;
+                        p_response_data->m_response_car_front_theta = 0;
+                        p_response_data->m_response_car_length = 0;
+                        p_response_data->m_response_car_width = 0;
+                        p_response_data->m_response_car_height = 0;
+                        p_response_data->m_response_car_wheel_base = 0;
+                        p_response_data->m_response_car_wheel_width = 0;
+                        p_response_data->m_response_uniformed_car_x = 0;
+                        p_response_data->m_response_uniformed_car_y = 0;
+
+                        p_response_data->m_response_locate_correct = 0;
+						p_response_data->m_response_ground_status = m_measure_info.ground_status();	//0  ok 1,nothing 2,noise  3,border
 					}
 				}
 

plc调度节点/main.cpp

@@ -63,6 +63,33 @@ GOOGLE_GLOG_DLL_DECL void shut_down_logging(const char* data, int size)
 
 int main(int argc,char* argv[])
 {
+//	std::string t = Time_tool::get_instance_references().get_current_time_seconds();
+//	std::cout << " huli test :::: " << " t = " << t << std::endl;
+//
+//	Time_tool::get_instance_references().time_start();
+//	Time_tool::get_instance_references().time_end();
+//	Time_tool::get_instance_references().cout_time_seconds();
+//
+//	std::chrono::system_clock::time_point a = Time_tool::get_instance_references().transform_time_string_seconds("2022-11-16 11:12:34");
+//	std::chrono::system_clock::time_point b = Time_tool::get_instance_references().transform_time_string_seconds("2022-11-16 11:34:56");
+//    double k = (b-a).count();
+//    std::cout << " huli test :::: " << " k = " << k << std::endl;
+//	double d = (b-a).count()/1000000000;
+//	std::cout << " huli test :::: " << " d = " << d << std::endl;
+//
+//    std::cout << " huli test :::: " << " a = " << Time_tool::get_instance_references().get_time_string_seconds(a) << std::endl;
+//    std::cout << " huli test :::: " << " b = " << Time_tool::get_instance_references().get_time_string_seconds(b) << std::endl;
+//
+//
+//    int parking_time = d;
+//    char parking_time_string[256] = "";
+//    int hour = parking_time / 3600;
+//    int min = parking_time / 60;
+//    int sec = parking_time % 60;
+//    sprintf(parking_time_string, " %d:%02d:%02d", hour, min, sec);
+//    std::cout << " huli test :::: " << " parking_time_string = " << parking_time_string << std::endl;
+//
+//	return 0;
 
 
 

plc调度节点/tool/time_tool.cpp

@@ -85,6 +85,37 @@ std::string Time_tool::get_time_string_seconds(std::chrono::system_clock::time_p
 	std::string result=strTime;
 	return result;
 }
+//转化 时间 精确到秒
+std::chrono::system_clock::time_point Time_tool::transform_time_string_seconds(std::string time_string)
+{
+	std::chrono::system_clock::time_point t_time_point;
+	time_t tt;
+	tm time_tm;
+	int t_year = 0;
+	int t_mon = 0;
+	sscanf(time_string.c_str(), "%d-%02d-%02d %02d:%02d:%02d", &t_year,
+		   &t_mon, &time_tm.tm_mday, &time_tm.tm_hour,
+		   &time_tm.tm_min, &time_tm.tm_sec);
+
+	time_tm.tm_year = t_year -1900;
+	time_tm.tm_mon = t_mon -1;
+    time_tm.tm_isdst = 0;
+//    std::cout << " huli test :::: " << " t_year = " << t_year << std::endl;
+//    std::cout << " huli test :::: " << " t_mon = " << t_mon << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_year = " << time_tm.tm_year << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_mon = " << time_tm.tm_mon << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_mday = " << time_tm.tm_mday << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_hour = " << time_tm.tm_hour << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_min = " << time_tm.tm_min << std::endl;
+//    std::cout << " huli test :::: " << " time_tm.tm_sec = " << time_tm.tm_sec << std::endl;
+
+	tt = mktime(&time_tm);
+	t_time_point = std::chrono::system_clock::from_time_t(tt);
+//    std::cout << " huli test :::: " << " time_tm.tt = " << tt << std::endl;
+//    std::cout << " huli test :::: " << " t_time_point = " << Time_tool::get_instance_references().get_time_string_seconds(t_time_point) << std::endl;
+    return t_time_point;
+}
+
 std::string Time_tool::get_time_string_millisecond(std::chrono::system_clock::time_point time_point)
 {
 	time_t tt = std::chrono::system_clock::to_time_t(time_point);
@@ -150,6 +181,19 @@ void Time_tool::cout_time_seconds(int key)
 		std::cout<<"没有此计时器:"<<key<<std::endl;
 	}
 }
+double Time_tool::get_time_seconds(int key)
+{
+
+	if ( timetool_map.find(key)!=timetool_map.end() )
+	{
+		double dieoutTime=(double)timetool_map[key].t_time_difference.count()/1000000000;
+		return dieoutTime;
+	}
+	else
+	{
+		return 0;
+	}
+}
 void Time_tool::cout_time_millisecond(int key)
 {
 	if ( timetool_map.find(key)!=timetool_map.end() )
@@ -162,6 +206,19 @@ void Time_tool::cout_time_millisecond(int key)
 		std::cout<<"没有此计时器:"<<key<<std::endl;
 	}
 }
+double Time_tool::get_time_millisecond(int key)
+{
+
+	if ( timetool_map.find(key)!=timetool_map.end() )
+	{
+		double dieoutTime=(double)timetool_map[key].t_time_difference.count()/1000000;
+		return dieoutTime;
+	}
+	else
+	{
+		return 0;
+	}
+}
 void Time_tool::cout_time_microsecond(int key)
 {
 	if ( timetool_map.find(key)!=timetool_map.end() )
@@ -175,6 +232,19 @@ void Time_tool::cout_time_microsecond(int key)
 		std::cout<<"没有此计时器:"<<key<<std::endl;
 	}
 }
+double Time_tool::get_time_microsecond(int key)
+{
+
+	if ( timetool_map.find(key)!=timetool_map.end() )
+	{
+		double dieoutTime=(double)timetool_map[key].t_time_difference.count()/1000;
+		return dieoutTime;
+	}
+	else
+	{
+		return 0;
+	}
+}
 void Time_tool::cout_time_nanosecond(int key)
 {
 	if ( timetool_map.find(key)!=timetool_map.end() )
@@ -186,6 +256,19 @@ void Time_tool::cout_time_nanosecond(int key)
 		std::cout<<"没有此计时器:"<<key<<std::endl;
 	}
 }
+double Time_tool::get_time_nanosecond(int key)
+{
+
+	if ( timetool_map.find(key)!=timetool_map.end() )
+	{
+		double dieoutTime=(double)timetool_map[key].t_time_difference.count();
+		return dieoutTime;
+	}
+	else
+	{
+		return 0;
+	}
+}
 void Time_tool::clear_timer()
 {
 	Time_tool_uninit();

plc调度节点/tool/time_tool.h

@@ -53,6 +53,8 @@ public://API functions
 
 	//获取 时间 精确到秒
 	std::string get_time_string_seconds(std::chrono::system_clock::time_point time_point);
+	//转化 时间 精确到秒
+	std::chrono::system_clock::time_point transform_time_string_seconds(std::string time_string);
 
 	//获取 时间 精确到毫秒
 	std::string get_time_string_millisecond(std::chrono::system_clock::time_point time_point);
@@ -68,15 +70,19 @@ public://API functions
 
 	//打印计时时差 精确到秒
 	void cout_time_seconds(int key=1);
+	double get_time_seconds(int key=1);
 
 	//打印计时时差 精确到毫秒
 	void cout_time_millisecond(int key=1);
+	double get_time_millisecond(int key=1);
 
 	//打印计时时差 精确到微秒
 	void cout_time_microsecond(int key=1);
+	double get_time_microsecond(int key=1);
 
 	//打印计时时差 精确到纳秒
 	void cout_time_nanosecond(int key=1);
+	double get_time_nanosecond(int key=1);
 
 	//清除计时器
 	void clear_timer();
@@ -85,6 +91,7 @@ protected://member variable
 
     
 private:
+public:
 	std::map<int,time_data> 			timetool_map;
 };
 #endif //PKGNAME_TIME_TOOL_H

出口单片机节点/DatabaseSearchPickCmd.py

@@ -1,6 +1,8 @@
 import time
 import pymysql as psql
 import message_pb2 as message
+import threading
+
 class DBSeacherPickCmd():
     def __init__(self,ip,port,database,user,password):
         self.ip=ip
@@ -17,6 +19,7 @@ class DBSeacherPickCmd():
                                user=user,
                                passwd=password)
 
+
     def close(self):
         self._close=True
         self.join()
@@ -27,18 +30,19 @@ class DBSeacherPickCmd():
         SQL="select * from command_queue where statu=2 "    #寻找已到出口的取车指令
         cursor.execute(SQL)
         pick_cmds=cursor.fetchall()
-        self.conn.commit()
         cursor.close()
-
+        self.conn.commit()
         return pick_cmds
 
     def delete_cmd(self,id):
         self.conn.begin()
         cursor=self.conn.cursor()
-        SQL="delete from command_queue where statu=2 and export_id=%d"%id
-        cursor.execute(SQL)
-        self.conn.commit()
+        SQL1="select * from command_queue for update"
+        cursor.execute(SQL1)
+        SQL2="delete from command_queue where statu=2 and export_id=%d"%id
+        cursor.execute(SQL2)
         cursor.close()
+        self.conn.commit()
 
 '''
     def run(self):

出口单片机节点/ExportIO.py

@@ -95,10 +95,17 @@ class ExportIO(threading.Thread):
         print("Connected to {}:{}".format(self._ip, self._port))
         return reader, writer
     async def recv_loop(self):
+        if (self._id == 5):
+            print(" test 1 ")
         while self._close==False:
+            if (self._id == 5):
+                print(" test 2 ")
             try:
                 recieve=await self._reader.readuntil(b'$')
+                if (self._id == 5):
+                    print(" 00 recieve = " + str(recieve))
             except Exception as e:
+                print("self._reader.readuntil(b'$') error")
                 print("  e: {}".format(e))
                 self._reader,self._writer=await self.connect()
                 await asyncio.sleep(0.001)
@@ -113,16 +120,24 @@ class ExportIO(threading.Thread):
                 self._latest_iomsg =self.recieve2message(bytes)
                 if (not self._rabbit_mq == None) and (not self._latest_iomsg == None):
                     if self._latest_iomsg.outside_safety == 0 or self._latest_iomsg.door_statu == 0:
+                        print("self._latest_iomsg error")
                         continue
                     else:
+                        if (self._id == 5):
+                            print(" 11 recieve = " + str(recieve))
                         ex_name = "statu_ex"
                         key = "out_mcpu_%d_statu_port" % self._id
                         self._rabbit_mq.publish(ex_name, key, tf.MessageToString(self._latest_iomsg, as_utf8=True))
+                else:
+                    print("self._rabbit_mq")
+                    print(self._rabbit_mq)
+                    print("self._latest_iomsg")
+                    print(self._latest_iomsg)
             else:
                 print(" start_index = %s"%start_index)
                 print("end_index = %s"%end_index)
                 print("WARNING : mcpu recieve format error , time = %s"%time.time())
-                print("  recieve = " + str(recieve))
+                print(" 22 recieve = " + str(recieve))
                 await asyncio.sleep(0)
 
                 continue
@@ -160,11 +175,15 @@ class ExportIO(threading.Thread):
         if 'InsideExistenceFlag' in data.keys():
             statu_msg.outside_safety = data['InsideExistenceFlag'] + 1
         else:
+            print("statu_msg.outside_safety not live")
+            print(bytes)
             statu_msg.outside_safety = 0
 
         if 'OutsideDoorStatus' in data.keys():
             statu_msg.door_statu = data["OutsideDoorStatus"] + 1  # 1 k  2g 3 running
         else:
+            print("statu_msg.door_statu not live ")
+            print(bytes)
             statu_msg.door_statu = 0
 
         return statu_msg

出口单片机节点/node.py

@@ -48,7 +48,7 @@ if __name__=="__main__":
 
     while True:
         pickcmds=g_db.search_pickcmd()
-        # print(pickcmds)
+        print(pickcmds)
         if len(pickcmds)>0:
             for cmd in pickcmds:
                 table=message.pick_table()

出口提示节点/LedControl.py

@@ -192,4 +192,4 @@ class LedControl:
     #
     #
     # sock.close()
-    # print("end")
+    # print("end")

测量节点/back/wanji_manager.prototxt

@@ -0,0 +1,866 @@
+fence_data_path:"/home/zx/data/fence_wj"
+#fence_log_path:"/home/zx/yct/MainStructure/new_electronic_fence/log"
+distribution_mode:false
+
+#1
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.211"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#-1.6412
+	m10:0
+	m11:1
+	m12:0#-2.3441
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:0
+}
+
+#2
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.212"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99992
+	m01:0.01236
+	m02:0#-1.6706
+	m10:-0.01236
+	m11:-0.99992
+	m12:0#2.3453
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:1
+}
+
+#3
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.213"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99984
+	m01:-0.0177
+	m02:0#1.8655#-2.073
+	m10:0.0177
+	m11:0.99984
+	m12:0#-2.41#-2.263
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:2
+}
+
+#4
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.214"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9976
+	m01:-0.06972
+	m02:0#1.8761#-1.9663
+	m10:0.06972
+	m11:-0.9976
+	m12:0#2.3286#2.3815
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:3
+}
+
+#5
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.215"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99997
+	m01:0.00728
+	m02:0#1.8395#-1.9348
+	m10:-0.00728
+	m11:0.99997
+	m12:0#-2.4037#-2.2882
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:4
+}
+
+#6
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.216"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9995
+	m01:-0.03147
+	m02:0#1.9198#-1.8524
+	m10:0.03417
+	m11:-0.9995
+	m12:0#2.24#2.3954
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:5
+}
+
+#7
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.217"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#1.9424#-1.8714
+	m10:0
+	m11:1
+	m12:0#-2.3569#-2.3391
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:6
+}
+
+#8
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.218"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99554
+	m01:-0.0944
+	m02:0#1.9602#-1.8639
+	m10:0.0944
+	m11:-0.99554
+	m12:0#2.3309#2.3995
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:7
+}
+
+#9
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.219"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#-1.812
+	m10:0
+	m11:1
+	m12:0#-2.514
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:8
+}
+
+#10
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.220"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9997
+	m01:0.02258
+	m02:0#-1.9153
+	m10:-0.02258
+	m11:-0.99974
+	m12:0#2.226
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:9
+}
+
+#11
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.221"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99990
+	m01:-0.01445
+	m02:0#1.898#-1.839
+	m10:0.01445
+	m11:0.99990
+	m12:0#-2.356#-2.353
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-3.0
+        maxx:6.0
+        miny:-14
+        maxy:14
+    }
+    lidar_id:10
+}
+
+#12
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.222"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99998
+	m01:0.00605
+	m02:0#1.8454#-1.9305
+	m10:-0.00605
+	m11:-0.99998
+	m12:0#2.3043#2.301
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:11
+}
+
+#13
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.223"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99997
+	m01:-0.0078
+	m02:0#2.023
+	m10:0.0078
+	m11:0.99997
+	m12:0#-2.259
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:12
+}
+
+#14
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.224"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99986
+	m01:0.01685
+	m02:0#1.916
+	m10:-0.01685
+	m11:-0.99986
+	m12:0#2.387
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:13
+}
+
+#1
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:0
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:0
+        calib
+        {
+            cx:-1.6412
+            cy:-2.3441
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:1
+        calib
+        {
+            cx:-1.6706
+            cy:2.3453
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:2
+        calib
+        {
+            cx:1.8655
+            cy:-2.41
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:3
+        calib
+        {
+            cx:1.8761
+            cy:2.3286
+        }
+    }
+}
+
+#2
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:1
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:2
+        calib
+        {
+            cx:-2.073
+            cy:-2.263
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:3
+        calib
+        {
+            cx:-1.9663
+            cy:2.3815
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:4
+        calib
+        {
+            cx:1.8395
+            cy:-2.4037
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:5
+        calib
+        {
+            cx:1.9198
+            cy:2.24
+        }
+    }
+}
+
+#3
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:2
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:4
+        calib
+        {
+            cx:-1.9348
+            cy:-2.2882
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:5
+        calib
+        {
+            cx:-1.8524
+            cy:2.3954
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:6
+        calib
+        {
+            cx:1.9424
+            cy:-2.3569
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:7
+        calib
+        {
+            cx:1.9602
+            cy:2.3309
+        }
+    }
+}
+
+#4
+regions
+{
+    # minx:8.7
+    # maxx:12
+    minx:-1.5
+    maxx:1.5
+    miny:-2.40
+    maxy:3.45
+
+    minz:0.025
+	maxz:0.5
+    region_id:3
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.3
+    border_maxx:1.3
+    plc_offsetx:0.0
+    plc_offsety:0.0
+    plc_offset_degree:0.0
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.95
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:6
+        calib
+        {
+            cx:-1.8714
+            cy:-2.3391
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:7
+        calib
+        {
+            cx:-1.8639
+            cy:2.3995
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:8
+        calib
+        {
+            cx:1.91
+            cy:-2.33
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:9
+        calib
+        {
+            cx:1.92
+            cy:2.33
+        }
+    }
+}
+
+#5
+regions
+{
+    minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:4
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:8
+        calib
+        {
+            cx:-1.812
+            cy:-2.514
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:9
+        calib
+        {
+            cx:-1.9153
+            cy:2.226
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:10
+        calib
+        {
+            cx:1.898
+            cy:-2.356
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:11
+        calib
+        {
+            cx:1.8454
+            cy:2.3043
+        }
+    }
+}
+
+#6
+regions
+{
+    minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:5
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:10
+        calib
+        {
+            cx:-1.839
+            cy:-2.353
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:11
+        calib
+        {
+            cx:-1.9305
+            cy:2.301
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:12
+        calib
+        {
+            cx:2.023
+            cy:-2.259
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:13
+        calib
+        {
+            cx:1.916
+            cy:2.387
+        }
+    }
+}
+

测量节点/setting/velodyne_manager.prototxt

@@ -23,7 +23,7 @@ velodyne_lidars
     {
          r:-0.276397
          p:-0.11717
-         y:88.703  #89.6003
+         y:91.572  # 88.703 #89.6003
          cz:0.05467
         #r:-0.623165
         #p:0.601821
@@ -179,20 +179,20 @@ region
 	maxx:1.6
 	miny:-2.6
 	maxy:2.6
-	minz:0.025
+	minz:0.025 # 0.025
 	maxz:0.5
     region_id:5
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:1.645
+    border_maxx:2.090
     plc_offsetx:1.913
     plc_offsety:-6.078
     plc_offset_degree:-89.5
     plc_border_miny:1.2
     plc_border_maxy:1.28
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -203,8 +203,8 @@ region
         lidar_id:6
         calib
         {
-            cx:1.89004
-            cy:0
+            cx:1.92004
+            cy:-0.03
         }
     }
     lidar_exts
@@ -237,8 +237,8 @@ region
     region_id:4
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:-2.220
+    border_maxx:-1.630
     # -1.8683
     plc_offsetx:-1.865
     plc_offsety:-6.11489
@@ -246,7 +246,7 @@ region
     plc_border_miny:1.2
     plc_border_maxy:1.28
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -285,15 +285,15 @@ region
     region_id:3
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:1.615
+    border_maxx:2.120
     plc_offsetx:1.926
     plc_offsety:-6.135
     plc_offset_degree:-89.5
     plc_border_miny:1.2
     plc_border_maxy:1.28
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -333,8 +333,8 @@ region
     region_id:2
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:-2.190
+    border_maxx:-1.635
     # 0.02
     plc_offsetx:-1.871
     # -0.34
@@ -343,7 +343,7 @@ region
     plc_border_miny:1.2
     plc_border_maxy:1.28
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -368,8 +368,8 @@ region
             # cx-1.9389+0.04 cy-0.01395+0.03
             cx:-1.89
             cy:0.016
-            cz:0.08
-            p:-1.5
+            cz:0.07
+            p:0.0
         }
     }
 }
@@ -387,15 +387,15 @@ region
     region_id:1
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:1.640
+    border_maxx:2.155
     plc_offsetx:1.93
     plc_offsety:-6.1368
     plc_offset_degree:-89.5
     plc_border_miny:1.2
-    plc_border_maxy:1.28
+    plc_border_maxy:1.29
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -441,15 +441,15 @@ region
     region_id:0
     turnplate_cx:0.0
     turnplate_cy:0.0
-    border_minx:-1.2
-    border_maxx:1.2
+    border_minx:-2.155
+    border_maxx:-1.655
     plc_offsetx:-1.86
     plc_offsety:-6.1368
     plc_offset_degree:-89.5
     plc_border_miny:1.2
-    plc_border_maxy:1.28
+    plc_border_maxy:1.29
     car_min_width:1.55
-    car_max_width:1.92
+    car_max_width:1.920
     car_min_wheelbase:2.3
     car_max_wheelbase:3.15
     turnplate_angle_limit_anti_clockwise:5.3
@@ -475,4 +475,4 @@ region
             cy:0.01367
         }
     }
-}
+}

测量节点/setting/wanji_manager_bak20221114.prototxt

@@ -0,0 +1,866 @@
+fence_data_path:"/home/zx/data/fence_wj"
+#fence_log_path:"/home/zx/yct/MainStructure/new_electronic_fence/log"
+distribution_mode:false
+
+#1
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.211"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#-1.6412
+	m10:0
+	m11:1
+	m12:0#-2.3441
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:0
+}
+
+#2
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.212"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99992
+	m01:0.01236
+	m02:0#-1.6706
+	m10:-0.01236
+	m11:-0.99992
+	m12:0#2.3453
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:1
+}
+
+#3
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.213"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99984
+	m01:-0.0177
+	m02:0#1.8655#-2.073
+	m10:0.0177
+	m11:0.99984
+	m12:0#-2.41#-2.263
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:2
+}
+
+#4
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.214"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9976
+	m01:-0.06972
+	m02:0#1.8761#-1.9663
+	m10:0.06972
+	m11:-0.9976
+	m12:0#2.3286#2.3815
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:3
+}
+
+#5
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.215"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99997
+	m01:0.00728
+	m02:0#1.8395#-1.9348
+	m10:-0.00728
+	m11:0.99997
+	m12:0#-2.4037#-2.2882
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:4
+}
+
+#6
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.216"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9995
+	m01:-0.03147
+	m02:0#1.9198#-1.8524
+	m10:0.03417
+	m11:-0.9995
+	m12:0#2.24#2.3954
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:5
+}
+
+#7
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.217"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#1.9424#-1.8714
+	m10:0
+	m11:1
+	m12:0#-2.3569#-2.3391
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:6
+}
+
+#8
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.218"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99554
+	m01:-0.0944
+	m02:0#1.9602#-1.8639
+	m10:0.0944
+	m11:-0.99554
+	m12:0#2.3309#2.3995
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:7
+}
+
+#9
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.219"
+        port:2110
+    }
+    transform
+    {
+        m00:1
+	m01:0
+	m02:0#-1.812
+	m10:0
+	m11:1
+	m12:0#-2.514
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:8
+}
+
+#10
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.220"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.9997
+	m01:0.02258
+	m02:0#-1.9153
+	m10:-0.02258
+	m11:-0.99974
+	m12:0#2.226
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:9
+}
+
+#11
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.221"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99990
+	m01:-0.01445
+	m02:0#1.898#-1.839
+	m10:0.01445
+	m11:0.99990
+	m12:0#-2.356#-2.353
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-3.0
+        maxx:6.0
+        miny:-14
+        maxy:14
+    }
+    lidar_id:10
+}
+
+#12
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.222"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99998
+	m01:0.00605
+	m02:0#1.8454#-1.9305
+	m10:-0.00605
+	m11:-0.99998
+	m12:0#2.3043#2.301
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:11
+}
+
+#13
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.223"
+        port:2110
+    }
+    transform
+    {
+        m00:0.99997
+	m01:-0.0078
+	m02:0#2.023
+	m10:0.0078
+	m11:0.99997
+	m12:0#-2.259
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:12
+}
+
+#14
+wj_lidar
+{
+    angle_min:-2.35619449
+    angle_max:2.35619449
+    angle_increment:0.00582
+    time_increment:0.000062
+    range_min:0
+    range_max:30
+    net_config
+    {
+        ip_address:"192.168.1.224"
+        port:2110
+    }
+    transform
+    {
+        m00:-0.99986
+	m01:0.01685
+	m02:0#1.916
+	m10:-0.01685
+	m11:-0.99986
+	m12:0#2.387
+    }
+    scan_limit
+    {
+        dist_limit:8
+        minx:-4.0
+        maxx:4.0
+        miny:-1.5
+        maxy:6.0
+    }
+    lidar_id:13
+}
+
+#1
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:0
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:0
+        calib
+        {
+            cx:-1.6412
+            cy:-2.3441
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:1
+        calib
+        {
+            cx:-1.6706
+            cy:2.3453
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:2
+        calib
+        {
+            cx:1.8655
+            cy:-2.41
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:3
+        calib
+        {
+            cx:1.8761
+            cy:2.3286
+        }
+    }
+}
+
+#2
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:1
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:2
+        calib
+        {
+            cx:-2.073
+            cy:-2.263
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:3
+        calib
+        {
+            cx:-1.9663
+            cy:2.3815
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:4
+        calib
+        {
+            cx:1.8395
+            cy:-2.4037
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:5
+        calib
+        {
+            cx:1.9198
+            cy:2.24
+        }
+    }
+}
+
+#3
+regions
+{
+	minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:2
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:4
+        calib
+        {
+            cx:-1.9348
+            cy:-2.2882
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:5
+        calib
+        {
+            cx:-1.8524
+            cy:2.3954
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:6
+        calib
+        {
+            cx:1.9424
+            cy:-2.3569
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:7
+        calib
+        {
+            cx:1.9602
+            cy:2.3309
+        }
+    }
+}
+
+#4
+regions
+{
+    # minx:8.7
+    # maxx:12
+    minx:-1.5
+    maxx:1.5
+    miny:-2.40
+    maxy:3.45
+
+    minz:0.025
+	maxz:0.5
+    region_id:3
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.3
+    border_maxx:1.3
+    plc_offsetx:0.0
+    plc_offsety:0.0
+    plc_offset_degree:0.0
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.95
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:6
+        calib
+        {
+            cx:-1.8714
+            cy:-2.3391
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:7
+        calib
+        {
+            cx:-1.8639
+            cy:2.3995
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:8
+        calib
+        {
+            cx:1.91
+            cy:-2.33
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:9
+        calib
+        {
+            cx:1.92
+            cy:2.33
+        }
+    }
+}
+
+#5
+regions
+{
+    minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:4
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:8
+        calib
+        {
+            cx:-1.812
+            cy:-2.514
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:9
+        calib
+        {
+            cx:-1.9153
+            cy:2.226
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:10
+        calib
+        {
+            cx:1.898
+            cy:-2.356
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:11
+        calib
+        {
+            cx:1.8454
+            cy:2.3043
+        }
+    }
+}
+
+#6
+regions
+{
+    minx:-1.42
+	maxx:1.5
+	miny:-2.6
+	maxy:2.3
+	minz:0.03
+	maxz:0.5
+    region_id:5
+    turnplate_cx:0.0
+    turnplate_cy:0.0
+    border_minx:-1.2
+    border_maxx:1.2
+    # -1.8683
+    plc_offsetx:-1.865
+    plc_offsety:-6.11489
+    plc_offset_degree:-89.6
+    plc_border_miny:-7.51
+    car_min_width:1.55
+    car_max_width:1.92
+    car_min_wheelbase:2.3
+    car_max_wheelbase:3.15
+    turnplate_angle_limit_anti_clockwise:5.3
+    turnplate_angle_limit_clockwise:5.3
+
+    lidar_exts
+    {
+        lidar_id:10
+        calib
+        {
+            cx:-1.839
+            cy:-2.353
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:11
+        calib
+        {
+            cx:-1.9305
+            cy:2.301
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:12
+        calib
+        {
+            cx:2.023
+            cy:-2.259
+        }
+    }
+    lidar_exts
+    {
+        lidar_id:13
+        calib
+        {
+            cx:1.916
+            cy:2.387
+        }
+    }
+}
+

测量节点/system/system_executor.cpp

@@ -545,7 +545,7 @@ Error_manager System_executor::encapsulate_send_mq_status()
 		{
 			std::string t_filename = std::string("vlp16_region_") + std::to_string(iter->first) + "_cloud.txt";
 			save_cloud_txt(t_region_cloud, t_filename);
-			LOG(INFO) << "vlp16 region " << iter->first << " cloud has been saved in " + t_filename;
+			LOG(INFO) << " vlp16 region " << iter->first << " cloud has been saved in " + t_filename;
 		}
 		// for (size_t j = 0; j < t_region_cloud->size(); j++)
 		// {
@@ -631,8 +631,8 @@ Error_manager System_executor::encapsulate_send_mq_status()
 		{
 			// rabbitmq new measure info
 			measure_info t_multi_measure_info_msg;
-			t_multi_measure_info_msg.set_cx(t_car_wheel_information.car_center_x);
-			t_multi_measure_info_msg.set_cy(t_car_wheel_information.car_center_y);
+			t_multi_measure_info_msg.set_cx(t_car_wheel_information.uniform_car_x);
+			t_multi_measure_info_msg.set_cy(t_car_wheel_information.uniform_car_y);
 			t_multi_measure_info_msg.set_theta(t_car_wheel_information.car_angle);
 			t_multi_measure_info_msg.set_length(0.0f);
 			t_multi_measure_info_msg.set_width(t_car_wheel_information.car_wheel_width);
@@ -640,7 +640,8 @@ Error_manager System_executor::encapsulate_send_mq_status()
 			t_multi_measure_info_msg.set_wheelbase(t_car_wheel_information.car_wheel_base);
 			t_multi_measure_info_msg.set_front_theta(t_car_wheel_information.car_front_theta);
 			t_multi_measure_info_msg.set_border_statu(t_car_wheel_information.range_status);
-			
+
+
 			auto t_ground_status = t_multi_status_msg.ground_status();
 			if(t_ground_status == message::Ground_statu::Car_correct)
 			{
@@ -655,14 +656,32 @@ Error_manager System_executor::encapsulate_send_mq_status()
 			else if(t_ground_status == message::Ground_statu::Car_border_reached)
 			{
 				t_multi_measure_info_msg.set_ground_status(3);
+			}else
+			{
+				t_multi_measure_info_msg.set_ground_status(2);
+				std::cout<<"system executor 661, original status "<<t_ground_status<<std::endl;
 			}
-			
+
+
+            // LOG(WARNING) << t_multi_status_msg.error_manager().error_description()<<std::endl;
 			std::string t_msg = t_multi_measure_info_msg.DebugString();
 			System_communication_mq::get_instance_references().encapsulate_status_msg(t_msg, t_multi_status_msg.id_struct().terminal_id());
+
+            // if (t_multi_status_msg.id_struct().terminal_id() == 1)
+            // {
+            //     LOG(WARNING) << "-------------------------------------------------------" <<std::endl;
+            //     LOG(WARNING) << "t_msg = " << t_msg <<std::endl;
+            //     LOG(WARNING) << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++" <<std::endl;
+            //     LOG(WARNING) << "t_multi_status_msg.ground_status() = " << t_ground_status <<std::endl;
+            //     LOG(WARNING) << "t_multi_measure_info_msg.set_ground_status(0) = " << t_multi_measure_info_msg.ground_status() <<std::endl;
+            // }
 		}
 		if (t_multi_status_msg.id_struct().terminal_id() == DISP_TERM_ID)
+		{
+			// LOG(WARNING) << t_car_wheel_information.range_status<<std::endl;
 			std::cout << t_multi_status_msg.DebugString() << std::endl
 						<< std::endl;
+		}
 	}
 }
 #endif
@@ -738,12 +757,12 @@ Error_manager System_executor::encapsulate_send_status()
 			// 获取区域点云填入信息
 			pcl::PointCloud<pcl::PointXYZ>::Ptr t_region_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
 			iter->second->get_region_cloud(t_region_cloud, Ground_region::Region_cloud_type::filtered);
-			if (cloud_count == 5)
-			{
-				std::string t_filename = std::string("region_") + std::to_string(iter->first) + "_cloud.txt";
-				save_cloud_txt(t_region_cloud, t_filename);
-				LOG(INFO) << "region " << iter->first << " cloud has been saved in " + t_filename;
-			}
+			// if (cloud_count == 5)
+			// {
+			// 	std::string t_filename = std::string("region_") + std::to_string(iter->first) + "_cloud.txt";
+			// 	save_cloud_txt(t_region_cloud, t_filename);
+			// 	LOG(INFO) << "region " << iter->first << " cloud has been saved in " + t_filename;
+			// }
 			// for (size_t j = 0; j < t_region_cloud->size(); j++)
 			// {
 			// 	message::Cloud_coordinate *tp_cloud = t_multi_status_msg.add_cloud();
@@ -805,12 +824,12 @@ Error_manager System_executor::encapsulate_send_status()
 			// 获取区域点云填入信息
 			pcl::PointCloud<pcl::PointXYZ>::Ptr t_region_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
 			iter->second->get_region_cloud(t_region_cloud);
-			if (cloud_count == 5)
-			{
-				std::string t_filename = std::string("region_") + std::to_string(iter->first) + "_cloud.txt";
-				save_cloud_txt(t_region_cloud, t_filename);
-				LOG(INFO) << "region " << iter->first << " cloud has been saved in " + t_filename;
-			}
+			// if (cloud_count == 5)
+			// {
+			// 	std::string t_filename = std::string("region_") + std::to_string(iter->first) + "_cloud.txt";
+			// 	save_cloud_txt(t_region_cloud, t_filename);
+			// 	LOG(INFO) << "region " << iter->first << " cloud has been saved in " + t_filename;
+			// }
 			// for (size_t j = 0; j < t_region_cloud->size(); j++)
 			// {
 			// 	message::Cloud_coordinate *tp_cloud = t_multi_status_msg.add_cloud();
@@ -898,14 +917,16 @@ Error_manager System_executor::encapsulate_send_status()
 		t_error = (*iter).second->get_last_wheel_information(&t_car_wheel_information, std::chrono::system_clock::now());
 
 		// 获取区域点云填入信息
+		// 20221211 changed by yct, nanomsg dont save cloud
 		pcl::PointCloud<pcl::PointXYZ>::Ptr t_region_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
 		iter->second->get_region_cloud(t_region_cloud, Ground_region::Region_cloud_type::filtered);
-		if (cloud_count == 5)
-		{
-			std::string t_filename = std::string("vlp16_region_") + std::to_string(iter->first) + "_cloud.txt";
-			save_cloud_txt(t_region_cloud, t_filename);
-			LOG(INFO) << "vlp16 region " << iter->first << " cloud has been saved in " + t_filename;
-		}
+		// if (cloud_count == 5)
+		// {
+		// 	std::string t_filename = std::string("vlp16_region_") + std::to_string(iter->first) + "_cloud.txt";
+		// 	save_cloud_txt(t_region_cloud, t_filename);
+		// 	LOG(INFO) << "vlp16 region " << iter->first << " cloud has been saved in " + t_filename;
+		// }
+
 		// for (size_t j = 0; j < t_region_cloud->size(); j++)
 		// {
 		// 	message::Cloud_coordinate *tp_cloud = t_multi_status_msg.add_cloud();
@@ -943,12 +964,14 @@ Error_manager System_executor::encapsulate_send_status()
 			// 获取区域点云填入信息
 			pcl::PointCloud<pcl::PointXYZ>::Ptr t_wj_region_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
 			t_wj_region_iter->second->get_region_cloud(t_wj_region_cloud);
-			if (cloud_count == 8)
-			{
-				std::string t_filename = std::string("wj_region_") + std::to_string(t_wj_region_iter->first) + "_cloud.txt";
-				save_cloud_txt(t_wj_region_cloud, t_filename);
-				LOG(INFO) << "wj region " << t_wj_region_iter->first << " cloud has been saved in " + t_filename;
-			}
+
+			// if (cloud_count == 8)
+			// {
+			// 	std::string t_filename = std::string("wj_region_") + std::to_string(t_wj_region_iter->first) + "_cloud.txt";
+			// 	save_cloud_txt(t_wj_region_cloud, t_filename);
+			// 	LOG(INFO) << "wj region " << t_wj_region_iter->first << " cloud has been saved in " + t_filename;
+			// }
+
 			// for (size_t j = 0; j < t_wj_region_cloud->size(); j++)
 			// {
 			// 	message::Cloud_coordinate *tp_cloud = t_multi_status_msg.add_cloud();
@@ -972,7 +995,9 @@ Error_manager System_executor::encapsulate_send_status()
 			}else
 			{
 				LOG_IF(WARNING, iter->second->get_terminal_id() == DISP_TERM_ID)<<
-					"detect mismatch, region "<<iter->first<<", dx dy dang dwb: "<<dx<<", "<<dy<<", "<<dang<<", "<< dwb;
+					"detect mismatch, region "<<iter->first<<", dx dy dang dwb: "<<dx<<", "<<dy<<", "<<dang<<", "<< dwb << std::endl 
+					<< t_car_wheel_information.to_string() << std::endl
+					<< t_wj_car_wheel_information.to_string() << std::endl;
 			}
 
 		}else{
@@ -983,9 +1008,9 @@ Error_manager System_executor::encapsulate_send_status()
 
 		std::string t_msg = t_multi_status_msg.SerializeAsString();
 		System_communication::get_instance_references().encapsulate_msg(t_msg);
-		if (t_multi_status_msg.id_struct().terminal_id() == DISP_TERM_ID)
-			std::cout << t_multi_status_msg.DebugString() << std::endl
-						<< std::endl;
+		// if (t_multi_status_msg.id_struct().terminal_id() == DISP_TERM_ID)
+		// 	std::cout << t_multi_status_msg.DebugString() << std::endl
+		// 				<< std::endl;
 	}
 }
 #endif

测量节点/system/system_executor.h

@@ -20,7 +20,7 @@
 #include "../wanji_lidar/wanji_manager.h"
 #include "../velodyne_lidar/velodyne_manager.h"
 
-#define DISP_TERM_ID -1
+#define DISP_TERM_ID 2
 // 0wj  1velo	2both
 #define WJ_VELO 2
 

测量节点/velodyne_lidar/ground_region.cpp

@@ -316,6 +316,7 @@ Ground_region::~Ground_region()
 
 Error_manager Ground_region::init(velodyne::Region region, pcl::PointCloud<pcl::PointXYZ>::Ptr left_model, pcl::PointCloud<pcl::PointXYZ>::Ptr right_model)
 {
+    m_range_status_last = 0;
     Region_status_checker::get_instance_references().Region_status_checker_init();
     m_region = region;
     m_detector = new detect_wheel_ceres3d(left_model,right_model);
@@ -469,12 +470,14 @@ Error_manager Ground_region::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, d
     Error_manager ec = t_solver.solve_mat(cloud_z_solver, z_solver_x, mid_z, z_solver_width, height, false);
     // 切除大于height高度以外点，并显示width直线
     // 根据z值切原始点云
+    // std::cout<<"before clip: "<<cloud_z_solver->size()<<std::endl;
     pcl::PassThrough<pcl::PointXYZ> pass;
     pass.setInputCloud(cloud_z_solver);
     pass.setFilterFieldName("z");
     pass.setFilterLimits(m_region.minz(), mid_z + height / 2.0);
     pass.setFilterLimitsNegative(false);
     pass.filter(*cloud_z_solver);
+    // std::cout<<"after clip: "<<cloud_z_solver->size()<<std::endl;
     // // 车宽方向画线
     // for (double i = -3.0; i < 3.0; i+=0.02)
     // {
@@ -565,8 +568,8 @@ Error_manager Ground_region::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, d
     //        center_z, last_result.theta, last_result.front_theta, last_result.wheel_base, last_result.width,
     //        min_mean_loss);
     // std::cout << "\n-------- final z: " << chassis_z << std::endl;
-    // std::cout << "cx: " << last_result.cx << ", cy: " << last_result.cy << ", theta: " << last_result.theta
-    //           << ", front: " << last_result.front_theta << ", wheelbase: " << last_result.wheel_base << ", width: " << last_result.width << std::endl << std::endl;
+    std::cout << "cx: " << last_result.cx << ", cy: " << last_result.cy << ", theta: " << last_result.theta
+              << ", front: " << last_result.front_theta << ", wheelbase: " << last_result.wheel_base << ", width: " << last_result.width << std::endl << std::endl;
 
     // last_result.cx -= x;
     // last_result.cy -= y;
@@ -584,7 +587,10 @@ Error_manager Ground_region::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, d
     // 车宽精度优化
     {
         pcl::PointCloud<pcl::PointXYZ>::Ptr t_width_extract_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
-        t_width_extract_cloud->operator+=(*mp_cloud_filtered);
+        t_width_extract_cloud->operator+=(m_detector->m_left_front_cloud);
+        t_width_extract_cloud->operator+=(m_detector->m_right_front_cloud);
+        t_width_extract_cloud->operator+=(m_detector->m_left_rear_cloud);
+        t_width_extract_cloud->operator+=(m_detector->m_right_rear_cloud);
 
         //离群点过滤
         sor.setInputCloud(t_width_extract_cloud);
@@ -626,8 +632,9 @@ Error_manager Ground_region::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, d
     return SUCCESS;
 }
 
-int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, double plate_cx, double plate_cy, double theta)
+int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, double cx, double cy, double plate_cx, double plate_cy, double theta)
 {
+    // LOG(WARNING) << m_range_status_last;
     if(cloud->size() <= 0)
         return Range_status::Range_correct;
     int res = Range_status::Range_correct;
@@ -645,14 +652,73 @@ int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud
     }
     pcl::PointXYZ min_p, max_p;
     pcl::getMinMax3D(t_cloud, min_p, max_p);
+
+#ifndef ANTI_SHAKE
     // 判断左右超界情况
     if(min_p.x < m_region.border_minx())
         res |= Range_status::Range_left;
     if(max_p.x > m_region.border_maxx())
         res |= Range_status::Range_right;
-
     // LOG_IF(WARNING, m_region.region_id() == 4)<< "border minmax x: "<< min_p.x<<", "<<max_p.x<<", res: "<<res;
     return res;
+#else
+    /*
+    if(min_p.x < m_region.border_minx()-0.000)
+    {
+        m_range_status_last |= Range_status::Range_left;
+    }
+    else if(min_p.x > m_region.border_minx()+0.010)
+    {
+        int t = Range_status::Range_left;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+
+    if(max_p.x > m_region.border_maxx()+0.000)
+    {
+        m_range_status_last |= Range_status::Range_right;
+    }
+    else if(max_p.x < m_region.border_maxx()-0.010)
+    {
+        int t = Range_status::Range_right;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+*/
+    //huli 不再使用汽车左右边界来判断，直接使用中心点x值判断左右超界。
+    //plc坐标，1 3 5入口x为-1.8左右， 2 4 6入口为1.8左右
+    //要求x取值范围，1650～2150左右
+    float t_center_x = cx + m_region.plc_offsetx();
+    if(t_center_x < m_region.border_minx()-0.000)
+    {
+        m_range_status_last |= Range_status::Range_left;
+    }
+    else if(t_center_x > m_region.border_minx()+0.010)
+    {
+        int t = Range_status::Range_left;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+
+    if(t_center_x > m_region.border_maxx()+0.000)
+    {
+        m_range_status_last |= Range_status::Range_right;
+    }
+    else if(t_center_x < m_region.border_maxx()-0.010)
+    {
+        int t = Range_status::Range_right;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+
+//    LOG(WARNING) << "-------------------------------------------------------" <<std::endl;
+//    LOG(WARNING) << "min_p.x = " << min_p.x <<std::endl;
+//    LOG(WARNING) << "max_p.x = " << max_p.x <<std::endl;
+//    LOG(WARNING) << "t_center_x = " << t_center_x <<std::endl;
+//    LOG(WARNING) << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++" <<std::endl;
+
+    return m_range_status_last;
+#endif //ANTI_SHAKE
 }
 
 int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, Common_data::Car_wheel_information measure_result, double plate_cx, double plate_cy, double theta)
@@ -667,8 +733,9 @@ int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud
     double theta_rad = theta * M_PI / 180.0;
     car_uniform_center.x() = car_center.x() * cos(theta_rad) - car_center.y() * sin(theta_rad);
     car_uniform_center.y() = car_center.x() * sin(theta_rad) + car_center.y() * cos(theta_rad);
-    // 车位位于y负方向，判断后轮超界情况
 
+#ifndef ANTI_SHAKE
+    // 车位位于y负方向，判断后轮超界情况
     //yct old program 20221101
 //    double rear_wheel_y = car_uniform_center.y() + m_region.plc_offsety() - 0.5 * measure_result.car_wheel_base;
 //    if(rear_wheel_y < m_region.plc_border_miny())
@@ -725,24 +792,6 @@ int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud
         res |= Range_status::Range_angle_clock;
     }
 
-//    if (t_terminal_id == 3)
-//    {
-//
-//        LOG(INFO) << "hulixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx t_terminal_id = " << t_terminal_id << "  ";
-//
-//        LOG(INFO) << "hulixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx m_region.plc_offset_degree() = " << m_region.plc_offset_degree() << "  ";
-//
-//
-//        LOG(INFO) << "hulixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx t_dtheta = " << t_dtheta << "  ";
-//        LOG(INFO) << "hulixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx turnplate_angle_min = " << System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_min() << "  ";
-//        LOG(INFO) << "hulixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx turnplate_angle_max = " << System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_max() << "  ";
-//
-//    }
-
-
-
-
-
     // // 判断车辆前轮角回正情况
     // if (fabs(measure_result.car_front_theta) > 8.0)
     // {
@@ -750,6 +799,89 @@ int Ground_region::outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud
     // }
     res |= outOfRangeDetection(cloud, plate_cx, plate_cy, theta);
     return res;
+#else
+    // LOG(WARNING) << m_range_status_last;
+    // 车位位于y负方向，判断后轮超界情况
+    double t_center_y = 0.0 - (car_uniform_center.y() + m_region.plc_offsety()); // 汽车中心y， 参照plc坐标，并且进行偏移， 绝对值。结果大约为 5～6左右
+    if( t_center_y - 4.88 + 0.5*(measure_result.car_wheel_base - 2.7) < m_region.plc_border_maxy()-0.000    &&
+        t_center_y - 4.88 - 0.5*(measure_result.car_wheel_base - 2.7) < m_region.plc_border_miny()-0.000 )
+    {
+        int t = Range_status::Range_back;
+        m_range_status_last &= (~t);
+    }
+    else if( t_center_y - 4.88 + 0.5*(measure_result.car_wheel_base - 2.7) > m_region.plc_border_maxy()+0.010    ||
+             t_center_y - 4.88 - 0.5*(measure_result.car_wheel_base - 2.7) > m_region.plc_border_miny()+0.010 )
+    {
+        m_range_status_last |= Range_status::Range_back;
+    }
+    //else      m_range_status_last no change
+    // LOG(WARNING) << m_range_status_last;
+
+    // 判断车辆宽度超界情况
+    if (measure_result.car_wheel_width < m_region.car_min_width()-0.000 ||
+        measure_result.car_wheel_width > m_region.car_max_width()+0.000)
+    {
+        m_range_status_last |= Range_status::Range_car_width;
+    }
+    else if (measure_result.car_wheel_width > m_region.car_min_width()+0.010 &&
+             measure_result.car_wheel_width < m_region.car_max_width()-0.010)
+    {
+        int t = Range_status::Range_car_width;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+    // LOG(WARNING) << m_range_status_last;
+
+    // 判断车辆轴距超界情况
+    if (measure_result.car_wheel_base < m_region.car_min_wheelbase()-0.000 ||
+        measure_result.car_wheel_base > m_region.car_max_wheelbase()+0.000)
+    {
+        res |= Range_status::Range_car_wheelbase;
+    }
+    else if (measure_result.car_wheel_base > m_region.car_min_wheelbase()+0.010 ||
+             measure_result.car_wheel_base < m_region.car_max_wheelbase()-0.010)
+    {
+        int t = Range_status::Range_car_wheelbase;
+        m_range_status_last &= (~t);
+    }
+    //else      m_range_status_last no change
+    // LOG(WARNING) << m_range_status_last;
+
+    // 判断车辆旋转角超界情况
+    //huli new program 20221103, 使用 plc  dispatch_1_statu_port 里面的  来做边界判断
+//    double t_dtheta = 90-measure_result.car_angle;    // 车身的旋转角， 修正到正负5度，
+    double t_dtheta = measure_result.car_angle + m_region.plc_offset_degree();    // 车身的旋转角， 修正到正5度， (m_region.plc_offset_degree():-89)
+    int t_terminal_id = m_region.region_id() +1;        //region_id:0~5,   terminal_id:1~6
+    //turnplate_angle_min = -5, turnplate_angle_max = 5,
+    if (t_dtheta > System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_max()+0.00)
+    {
+        m_range_status_last |= Range_status::Range_angle_anti_clock;
+    }
+    else if (t_dtheta < System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_max()-0.10)
+    {
+        int t = Range_status::Range_angle_anti_clock;
+        m_range_status_last &= (~t);
+    }
+    // LOG(WARNING) << m_range_status_last;
+   
+    //else      m_range_status_last no change
+    if (t_dtheta < System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_min()-0.00)
+    {
+        res |= Range_status::Range_angle_clock;
+    }
+    else if (t_dtheta > System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_min()+0.10)
+    {
+        int t = Range_status::Range_angle_clock;
+        m_range_status_last &= (~t);
+    }
+    // LOG(WARNING) << m_range_status_last;
+    // LOG(INFO) << t_dtheta<<", "<<System_communication_mq::get_instance_references().dispatch_region_info_map[t_terminal_id].turnplate_angle_min()<<std::endl;
+    //else      m_range_status_last no change
+
+
+    m_range_status_last |= outOfRangeDetection(cloud, measure_result.car_center_x, measure_result.car_center_y, plate_cx, plate_cy, theta);
+    return m_range_status_last;
+#endif
 }
 
 //外部调用获取当前车轮定位信息, 获取指令时间之后的车轮定位信息, 如果没有就会报错, 不会等待
@@ -912,6 +1044,13 @@ void Ground_region::thread_measure_func()
                 ec = Measure_filter::get_instance_references().get_filtered_wheel_information(m_region.region_id(), t_wheel_info_stamped.wheel_data);
                 if (ec == SUCCESS)
                 {
+                    // 20221208 added by yct, use avg car angle and width data.
+                    // LOG(WARNING)<<m_region.region_id()<<" angles: "<<m_car_wheel_information.car_angle<<", "<<t_wheel_info_stamped.wheel_data.car_angle;
+                    LOG(WARNING)<<m_region.region_id()<<" filter res: "<<t_wheel_info_stamped.wheel_data.to_string()<<std::endl;
+
+                    // m_car_wheel_information.car_angle = t_wheel_info_stamped.wheel_data.car_angle;
+                    // m_car_wheel_information.car_wheel_width = t_wheel_info_stamped.wheel_data.car_wheel_width;
+
                     m_car_wheel_information.car_wheel_base = t_wheel_info_stamped.wheel_data.car_wheel_base;
                     m_car_wheel_information.car_front_theta = t_wheel_info_stamped.wheel_data.car_front_theta;
                     // 临时添加，滤波后前轮超界

测量节点/velodyne_lidar/ground_region.h

@@ -24,6 +24,10 @@
 #include <pcl/point_cloud.h>
 #include <pcl/filters/approximate_voxel_grid.h>
 
+
+//huli add fangdou
+#define ANTI_SHAKE  1
+
 class Ground_region
 {
 public:
@@ -112,6 +116,7 @@ public:
       case Region_cloud_type::detect_z:
          m_detect_z_cloud_mutex.lock();
          out_cloud->operator+=(*mp_cloud_detect_z);
+         // std::cout<<"get cloud: "<<out_cloud->size()<<std::endl;
          m_detect_z_cloud_mutex.unlock();
          break;
       }
@@ -156,7 +161,7 @@ private:
 
    // 超界判断，旋转单位(deg)，默认无旋转
    // 主要判断左右超界
-   int outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, double plate_cx=0.0, double plate_cy=0.0, double theta=0.0);
+   int outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, double cx, double cy, double plate_cx=0.0, double plate_cy=0.0, double theta=0.0);
 
    // 超界判断，增加对后轮的判断，对轴距、车宽、角度超界的判断
    int outOfRangeDetection(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, Common_data::Car_wheel_information measure_result, double plate_cx=0.0, double plate_cy=0.0, double theta=0.0);
@@ -185,6 +190,10 @@ private:
    Common_data::Car_wheel_information			m_car_wheel_information;		//车轮的定位结果,
 	std::chrono::system_clock::time_point		m_detect_update_time;			//定位结果的更新时间.
    std::mutex m_car_result_mutex; // 测量结果互斥锁
+
+#ifdef ANTI_SHAKE
+    int                m_range_status_last;
+#endif //ANTI_SHAKE
 };
 
 #endif //LIDARMEASURE__GROUD_REGION_HPP_

测量节点/wanji_lidar/detect_wheel_ceres.cpp

@@ -546,6 +546,10 @@ void detect_wheel_ceres::create_mark(double x,double y,double theta,pcl::PointCl
 
 bool detect_wheel_ceres::Solve(Detect_result &detect_result, double &avg_loss)
 {
+    if(m_left_front_cloud.size()<=1 || m_right_front_cloud.size()<=1 || m_left_rear_cloud.size()<=1 || m_right_rear_cloud.size()<=1)
+    {
+        return false;
+    }
     double SCALE=300.0;
     double cx=detect_result.cx;
     double cy=detect_result.cy;

管理节点/node.py

@@ -151,7 +151,24 @@ class MainWindow(QMainWindow, threading.Thread):
             btn.setToolTip("None")
             btn.setStyleSheet(self.getBackGroundColor("gray"))
 
+    def drawMcpuBtn(self, key):
+        mouth = key.split(':')[0]
+        id = key.split(':')[1]
+        btn_name = mouth + '_' + id + '_statu_btn'
+        btn = self.findChild(QPushButton, btn_name)
+        iomsg = g_mcpu.GetMcpuIoMsg(key)
+        if g_mcpu.GetMcpuConnectStatus(key) is True or iomsg.timeout() is False:
+            btn.setText(btn.text()[:10] + "正常")
+            btn.setStyleSheet(self.getBackGroundColor("green"))
+
+            btn.setToolTip(str(iomsg.statu))
+        else:
+            btn.setText(btn.text()[:10] + "断连")
+            btn.setToolTip("None")
+            btn.setStyleSheet(self.getBackGroundColor("gray"))
+
     def drawUnitProcess(self):
+        return
         if g_space.command_queue_dict is not False and g_space.command_queue_dict is not None:
             # if self.command_queue_dict != g_space.command_queue_dict