fix merging

LocateRecord.h

@@ -111,12 +111,12 @@ namespace nspLocate{
 			// 分站接收时间跨周期，并且在一个周期以内，以分站接收时间为主
 			else if(locateTime < lr->LocateTime())
 			{
-				deltaT = (int)((locateTime + PERIOD_MAX_VALUE - lr->LocateTime() & PERIOD_MAX_VALUE) * PICOSECOND_COEFFICIENT);
+				deltaT = (int)(((locateTime + PERIOD_MAX_VALUE - lr->LocateTime()) & PERIOD_MAX_VALUE) * PICOSECOND_COEFFICIENT);
 			}
 			// 在同一个周期内，以分站接收时间为准
 			else
 			{
-				deltaT = (int)((locateTime - lr->LocateTime() & PERIOD_MAX_VALUE) * PICOSECOND_COEFFICIENT);
+				deltaT = (int)(((locateTime - lr->LocateTime()) & PERIOD_MAX_VALUE) * PICOSECOND_COEFFICIENT);
 			}
 		}
 

MysqlConnPool.cpp

@@ -1,17 +1,21 @@
 #include "StdAfx.h"
 #include "MysqlConnPool.h"
+#include "../YAServer/mylog/log_module.h"
 #include "./system_basic_info/SystemAnalysis.h"
 
 
+
 CMysqlConnPool::CMysqlConnPool()
 {
-	m_nMinCount = 3;//3
-	m_nMaxCount = 30;
-	m_bNeedStop = FALSE;
-	m_bNeedConnection = FALSE;
+	this->m_nMinCount = 3;//3
+	this->m_nMaxCount = 30;
+	this->m_bNeedStop = FALSE;
+	this->m_bNeedConnection = FALSE;
+	this->m_needConnect = false;
 	m_hMaintanceThread = INVALID_HANDLE_VALUE;
+	m_hMaintanceThreadForConn = INVALID_HANDLE_VALUE;
 
-	m_hMaintanceThread = CreateEvent(NULL, TRUE, FALSE, _T("DataConnPool"));
+	m_hHaveData = CreateEvent(NULL, TRUE, FALSE, _T("DataConnPool"));
 	// 划定临界区
 	InitializeCriticalSectionAndSpinCount(&m_csIdleConnList, MAXCRITICALSECTIONSPINCOUNT);
 	InitializeCriticalSectionAndSpinCount(&m_csBusyConnList, MAXCRITICALSECTIONSPINCOUNT);
@@ -21,9 +25,11 @@ CMysqlConnPool::CMysqlConnPool()
 CMysqlConnPool::~CMysqlConnPool()
 {
 	m_hMaintanceThread = INVALID_HANDLE_VALUE;
+	m_hMaintanceThreadForConn = INVALID_HANDLE_VALUE;
 	m_bNeedStop = TRUE;
 	CloseHandle(m_hHaveData);
 	CloseHandle(m_hMaintanceThread);
+	CloseHandle(m_hMaintanceThreadForConn);
 
 	CloseAllConn();
 
@@ -45,7 +51,11 @@ int CMysqlConnPool::InitAllConn()
 	// 创建守护线程，用来进行维护工作
 	if(INVALID_HANDLE_VALUE == m_hMaintanceThread)
 	{
-		m_hMaintanceThread = CreateThread(NULL, NULL, thread_run, (LPVOID)this, 0, NULL);
+		m_hMaintanceThread = CreateThread(NULL, NULL,thread_run, (LPVOID)this, 0, NULL);
+	}
+	if(INVALID_HANDLE_VALUE == m_hMaintanceThreadForConn)
+	{
+		m_hMaintanceThreadForConn = CreateThread(NULL, NULL, thread_runforConn, (LPVOID)this, 0, NULL);
 	}
 	return nCount;
 }
@@ -86,6 +96,8 @@ CMysqlConn* CMysqlConnPool::GetNewConn()
 	CMysqlConn * pDBEngine = NULL;
 	// 做一个循环，反复尝试五次取连接，每次间隔1秒钟
 	int nTimes = 0;
+	if(m_listBusyConnection.size() <=0 && m_listIdleConnection.size()<=0)
+		return NULL;
 	while ((m_listIdleConnection.size() <= 0) && (nTimes < 5))
 	{
 		Sleep(1000);
@@ -168,6 +180,7 @@ int CMysqlConnPool::InitNewConn()
 	if (bSuccess)
 	{
 		m_bNeedConnection = FALSE;
+		pDBEngine->setPool(this);
 		return RestoreConn(pDBEngine);
 	}
 	else
@@ -193,7 +206,9 @@ void CMysqlConnPool::StopThread()
 	SetEvent(m_hHaveData);
 	// 等待退出
 	WaitForSingleObject(m_hMaintanceThread, INFINITE);
+	WaitForSingleObject(m_hMaintanceThreadForConn, INFINITE);
 	CloseHandle(m_hMaintanceThread);
+	CloseHandle(m_hMaintanceThreadForConn);
 }
 
 BOOL CMysqlConnPool::IsNeedStop()
@@ -206,7 +221,25 @@ BOOL CMysqlConnPool::IsNeedConnection()
 	return m_bNeedConnection;
 }
 
-DWORD WINAPI CMysqlConnPool::thread_run( LPVOID pdata )
+DWORD WINAPI thread_runforConn( LPVOID pdata )
+{
+	CMysqlConnPool * pConPool = (CMysqlConnPool *) pdata;
+	while(true)
+	{
+		if (pConPool->m_needConnect)
+		{
+			int count = pConPool->InitAllConn();
+			if (count > 0)
+			{
+				pConPool->m_needConnect = false;
+			}
+		}
+		//先简单这样处理
+		Sleep(1000*4);
+	}
+	return 0;
+}
+DWORD WINAPI thread_run( LPVOID pdata )
 {
 	CMysqlConnPool * pConPool = (CMysqlConnPool *) pdata;
 	while (!pConPool->IsNeedStop())
@@ -285,6 +318,7 @@ int CMysqlConn::Close()
 		mysql_close(m_pConn);
 		::CoUninitialize();
 		m_bOpen = false;
+		m_pConn = NULL;
 	}
 
 	return 0;
@@ -294,16 +328,41 @@ bool CMysqlConn::IsOpen() const
 {
 	return m_bOpen;
 }
+int CMysqlConn::Get_MysqlEror()
+{
+	return mysql_errno(m_pConn);
+}
 
 MYSQL_RES * CMysqlConn::Execute( const char * strSQL, int &err)
 {
 	if(strSQL == "") return NULL;
 	MYSQL_RES * pRes;
-	int _error = mysql_query(m_pConn, strSQL);
-	err = _error;
-	if(_error){
+
+	if (m_pConn  == NULL)
+	{
 		return NULL;
 	}
+	int _error = mysql_query(m_pConn, strSQL);
+	err = Get_MysqlEror();
+	switch (err)
+	{
+	case CR_COMMANDS_OUT_OF_SYNC:
+		break;
+	case CR_SERVER_GONE_ERROR:
+	case CR_SERVER_LOST:
+		{
+			//首先要把这个链接注销掉，不然会在析构函数中放入队列。但是指针已经delete
+			//增加一个合法性判断，标识走析构，不入队列
+			//pDbGuard.isVaild();
+			getPool()->IsNeedConn();
+			return NULL;
+		}
+		break;
+	case CR_UNKNOWN_ERROR:
+
+	default:
+		break;
+	}
 
 	pRes = mysql_use_result(m_pConn);
 	return pRes;
@@ -316,6 +375,26 @@ void CMysqlConn::MultiExecute( const char * strSQL, int &err)
 		err = 0;
 	MYSQL_RES * pRes;
 	err = mysql_query(m_pConn, strSQL);
+	err = Get_MysqlEror();
+	switch (err)
+	{
+	case CR_COMMANDS_OUT_OF_SYNC:
+		break;
+	case CR_SERVER_GONE_ERROR:
+	case CR_SERVER_LOST:
+		{
+			//首先要把这个链接注销掉，不然会在析构函数中放入队列。但是指针已经delete
+			//增加一个合法性判断，标识走析构，不入队列
+			//pDbGuard.isVaild();
+			getPool()->IsNeedConn();
+			return ;
+		}
+		break;
+	case CR_UNKNOWN_ERROR:
+
+	default:
+		break;
+	}
 
 	//每条语句对应一个pRes，需要释放每一个结果集；避免数据错乱
 	//不然通过mysql_error()会得知是Commands out of sync; you can't run this command now错误
@@ -324,4 +403,4 @@ void CMysqlConn::MultiExecute( const char * strSQL, int &err)
 		pRes = mysql_use_result(m_pConn);
 		mysql_free_result(pRes);
 	} while (!mysql_next_result(m_pConn));
-}
+}

MysqlConnPool.h

@@ -2,6 +2,7 @@
 #define YASERVER_MYSQLCONNPOOL_H_
 
 #include <mysql.h>
+#include <errmsg.h>
 #include <list>
 
 #ifndef MAXCRITICALSECTIONSPINCOUNT
@@ -9,7 +10,10 @@
 #endif // !MAXCRITICALSECTIONSPINCOUNT
 
 using namespace std;
+DWORD WINAPI thread_run( LPVOID pdata);
+DWORD WINAPI thread_runforConn( LPVOID pdata);
 
+class CMysqlConnPool;
 class CMysqlConn{
 public:
 	CMysqlConn(const char *option, const char *host, const char *user,
@@ -29,10 +33,14 @@ public:
 	MYSQL_RES * Execute(const char * strSQL, int &err);
 	void MultiExecute( const char * strSQL, int &err);
 
+	int Get_MysqlEror();
+	inline void setPool(CMysqlConnPool * p){m_pool = p;}
+	inline CMysqlConnPool* getPool(){return m_pool;}
 private:
 	MYSQL * m_pConn;
 	bool m_bValid; // 已被初始化成功标识
 	bool m_bOpen;
+	bool m_needTryConnect;
 
 	const char * m_option;
 	const char * m_host;
@@ -42,6 +50,7 @@ private:
 	unsigned int m_port;
 	const char * m_unix_socket;
 	unsigned long m_clientflag;
+	CMysqlConnPool *m_pool;
 };
 
 typedef std::list<CMysqlConn*> DBConnectList;
@@ -50,10 +59,10 @@ class CMysqlConnPool
 {
 public:
 	// 获取实例指针
-	static CMysqlConnPool &Instanse(){
-		static CMysqlConnPool m_pInstanse;
-		return m_pInstanse;
-	};
+	//static CMysqlConnPool &Instanse(){
+	//	static CMysqlConnPool m_pInstanse;
+	//	return m_pInstanse;
+	//};
 
 	// 初始化所有连接
 	int InitAllConn();
@@ -66,9 +75,11 @@ public:
 	int RestoreConn(CMysqlConn* pDBEngine);
 	void Init(const char* szOption, const char *szHost, const char *szUser, const char *szPwd, const char *szDbName,
 		unsigned int nPort, const char * szUnixSocket, unsigned long nClientFlag);
-private:
-	// 唯一实例
+	void IsNeedConn(){m_needConnect = true;}
+
+	bool m_needConnect;
 	CMysqlConnPool();
+
 	virtual ~CMysqlConnPool();
 	// 创建一个连接
 	int InitNewConn();
@@ -80,6 +91,8 @@ private:
 	// 判断是否需要停止
 	BOOL IsNeedStop();
 	BOOL IsNeedConnection();
+	HANDLE m_hHaveData; // 信号
+private:
 	// 将守卫类作为连接池类的友元类
 	friend class CDBConnGuard;
 
@@ -114,28 +127,50 @@ private:
 
 	// 维护线程
 	HANDLE m_hMaintanceThread; // 线程句柄
-	HANDLE m_hHaveData; // 信号
+	HANDLE m_hMaintanceThreadForConn; // 线程句柄
+
 
 	BOOL m_bNeedStop; // 管理线程起停的标志位
 	BOOL m_bNeedConnection; // 需要创建连接的标志
-	static DWORD WINAPI thread_run( LPVOID pdata);
+
+	
 };
 
 class CDBConnGuard{
 public:
-	CDBConnGuard(CMysqlConn* &pDbConn){
-		pDbConn = CMysqlConnPool::Instanse().GetNewConn();
-		//判断连接的有效性
+
+	//CDBConnGuard(CMysqlConn* &pDbConn){
+	//	pDbConn = CMysqlConnPool::Instanse().GetNewConn();
+	//	//判断连接的有效性
+	//	m_pDbConn = pDbConn;
+	//}
+	//virtual ~CDBConnGuard()
+	//{
+	//	CMysqlConnPool::Instanse().RestoreConn(m_pDbConn);
+	//}
+
+	CDBConnGuard(CMysqlConn* &pDbConn, CMysqlConnPool* pConnPool)
+		:m_isVaild(false)
+	{
+		m_pDbConnPool = pConnPool;
+		pDbConn = m_pDbConnPool->GetNewConn();
 		m_pDbConn = pDbConn;
 	}
-	virtual ~CDBConnGuard()
-	{
-		CMysqlConnPool::Instanse().RestoreConn(m_pDbConn);
+
+	virtual ~ CDBConnGuard(){
+		if (!m_isVaild)
+		{
+			m_pDbConnPool->RestoreConn(m_pDbConn);
+		}
+		m_pDbConnPool = NULL;
 	}
+	void isVaild(){m_isVaild = true;}
 private:
 	CMysqlConn * m_pDbConn;
+	bool m_isVaild;
+	CMysqlConnPool * m_pDbConnPool;
 };
 
-#define GetConnPool() CMysqlConnPool::Instanse()
+//#define GetConnPool() CMysqlConnPool::Instanse()
 
 #endif //YASERVER_MYSQLCONNPOOL_H_

ProcessRemodule.cpp

@@ -4,7 +4,6 @@
 #include <Windows.h>
 #include <iostream>
 #include <exception> 
-
 #include "log_process_module.h"
 
 #include "./system_basic_info/SystemAnalysis.h"

YAServer.cpp

@@ -244,10 +244,14 @@ void CYAServerApp::load_sys_conf()
 	send_json_postion = 1000;
 	send_json_counting = 5000;
 	send_json_alarm = 5000;
+	warning_point_alarm = 10000;
 	send_json_device = 10000;
 	ws_connect_interval = 2000;
 	time_send_call = 5000;
 	time_send_help = 5000;
+	send_json_drivingface = 30000;
+	send_json_leader = 1800000; //30 * 60 * 1000;
+	load_leader = 14400000; // 4 * 60 * 60 * 1000
 	tcp_port = PORT_SERVER_MASTER;
 
 	if(ini.open(FILEPATH_SERVER_CONFIG)){
@@ -273,7 +277,11 @@ void CYAServerApp::load_sys_conf()
 		send_json_postion = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_POSION).c_str());
 		send_json_counting = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_COUNTING).c_str());
 		send_json_alarm = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_ALARM).c_str());
+		warning_point_alarm = atoi(ini.read(CONF_SECT_SERVER_SETTING,CONF_WARNING_POINT_ALARM).c_str());
 		send_json_device = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_DEVICE).c_str());
+		send_json_drivingface = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_DRIVINGFACE).c_str());
+		send_json_leader = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_JSON_LEADER).c_str());
+		load_leader = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_LOAD_LEADER).c_str());
 		ws_connect_interval = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_WS_CONNECT_INTERVAL).c_str());
 		time_send_call = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_CALLINFO_INTERVAL).c_str());
 		time_send_help = atoi(ini.read(CONF_SECT_SERVER_SETTING, CONF_SEND_HELPINFO_INTERVAL).c_str());

YAServer.h

@@ -66,11 +66,15 @@ public:
 	int send_json_postion; // 毫秒
 	int send_json_counting;
 	int send_json_alarm;
+	int warning_point_alarm;//lemon
 	int send_json_device; 
 	int time_send_call;
 	int time_send_help;
 	int ws_connect_interval;
 	int heart_interval;
+	int send_json_drivingface;
+	int send_json_leader;
+	int load_leader;
 
 	//分站发送间隔，以毫秒为单位，100ms 
 	int reader_interval_time;

YAServer.sln

@@ -17,7 +17,4 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
-	GlobalSection(Performance) = preSolution
-		HasPerformanceSessions = true
-	EndGlobalSection
 EndGlobal

YAServerDlg.h

@@ -16,6 +16,7 @@
 #include "QueueStrManager.h"
 #include "uwb_msg_def.h"
 #include <json/json.h>
+#include "MysqlConnPool.h"
 
 extern BOOL m_log_sys_status;
 
@@ -169,7 +170,7 @@ public:
 	// 多web变量
 	bool is_websocket_login_ex;
 	bool is_websocket_ok_ex;
-
+	
 	bool is_server_ok; 
 	bool is_database_ok; 
 
@@ -193,8 +194,12 @@ public:
 	ReaderMap mp_ctrl_reader_list; // 所有控制分站
 	AreaMap mp_area_list; // 所有区域
 	DrivingfaceWarningPointMap mp_drivingface_warning_point_list; // 掘进面告警点列表
+	DrivingfaceWarningPointMapAll mp_drivingface_warning_point_list_all;//掘进面告警全列表
 	SpecilaAreaEntryMap mp_special_area_entry_list; //特殊区域入口
 	DrivingfaceRenderMap mp_driving_face_render_list; //掘进面分站基点配置信息
+	DrivingfaceCardMap mp_driving_face_card_list;//掘进面标识卡配置信息 lemon
+	WorkTypePermissionMap mp_worktype_permission_list;// lemon 2017/07/31
+	RulesMap m_rules_list;
 	MapInfoMap mp_map_list; // 所有地图
 	LandmarkInfoMap mp_landmark_list; // 所有地图地标
 	MapDirectionInfoMap mp_map_direction_list; //地图坐标系X轴正方向与地理北方的夹角
@@ -202,7 +207,6 @@ public:
 	BanShiftMap mp_banshift_list; // 班次信息
 	OccLevelMap mp_occlevel_list; // 所有职务级别
 	AlarmTypeMap mp_alarm_type_list;
-	//ReaderPathMap mp_reader_path_list;	//当前地图的所有分站的覆盖范围
 	SectionMap mp_section_list;
 	ChamberMap mp_chamber_list;
 	LightMap   mp_light_list;
@@ -214,8 +218,10 @@ public:
 	CardMap mp_card_list_up_person; // 升井人员
 	CardMap mp_card_list_down_adhoc;   //井下自组网卡
 	PatrolTaskCheckMap mp_card_task_list; // 巡检任务
+	LeaderArrangeMap mp_leaderarrange_list; // 领导带班
+	VehicleTypeAttRuleMap mp_att_area_list; // 考勤区域列表，不同车辆类型，区域可能不同
 
-    std::shared_ptr<ReaderPathMap> mp_reader_path_list;	//当前地图的所有分站的覆盖范围
+    std::shared_ptr<ReaderPathMap> mp_reader_path_list_tof;	//当前地图的所有分站的覆盖范围
 	std::shared_ptr<TDOAReaderPathMap> mp_reader_path_list_tdoa; 
 	std::shared_ptr<CardMap> mp_card_list_over_time_person;	// 超时人员	
 	std::shared_ptr<CardMap> mp_card_list_forbidden_person; // 进入限制区域人员
@@ -226,6 +232,7 @@ public:
 	std::shared_ptr<CardMap> mp_card_list_over_speed_vehicle; // 超速车辆
 	std::shared_ptr<CardMap> mp_card_list_area_over_time_vehicle; // 区域超时车辆
 	std::shared_ptr<CardMap> mp_card_list_over_count_person; // 人员超员
+	std::shared_ptr<CardMap> mp_card_list_over_count_vehicle; //车辆超员
 
 	std::shared_ptr<AreaMap> mp_area_over_count_person; // 人员超员区域
 	std::shared_ptr<AreaMap> mp_area_over_time_person; // 人员超时区域
@@ -234,6 +241,8 @@ public:
 	std::shared_ptr<AreaMap> mp_area_over_time_vehicle; // 车辆超时区域
 	std::shared_ptr<AreaMap> mp_area_forbidden_vehicle; // 有车限制区域
 
+	std::shared_ptr<CardMap> mp_card_warning_point_alarm;//lemon
+	std::shared_ptr<CardMap> mp_card_drivingface_eara_alarm;//lemon 20017/07/31 人员进入掘进机告警区域
 	std::shared_ptr<EventMap> mp_event_list; // 事件列表
 	std::shared_ptr<LightCallMap> mp_light_call_list; // 控制红绿等命令列表
 
@@ -243,6 +252,7 @@ public:
 
 	_SLS sls_setting; // 系统参数配置
 	_DBS m_db_setting; // 数据库参数配置
+	_DBS m_db_setting_bk; // 备份库参数配置
 	string m_ws_url; // web服务器url
 	string m_ws_url_ex; // 多服务器url
 	CString m_tcp_host; // 本机接收分站数据的ip
@@ -253,7 +263,8 @@ public:
 	time_t cur_shift_start_time;
 private:
 	int init_smart_pointer_var();
-
+private: //lemon
+	//int m_drivingfaceWarningIdForMinDis;
 public:
 	void init_ui(); // 初始化界面
 	void init_param(); // 初始化运行参数
@@ -280,24 +291,31 @@ public:
 	int init_area(int area_id = 0); // 区域
 	int init_special_area_entry(void); // 特殊区域入口
 	int init_drivingface_render(void); //掘进面分站基准点配置
+	int init_drivingface_card(void);//lemon init drivingface_card..
+	int init_drivingface_permission_card(void);//lemon 2017/07/31
 	int init_reader(int reader_id = 0); // 分站
 	int init_ctrl_reader(int reader_id = 0); // 控制分站
-	//int init_antenna(int reader_id = 0); // 天线
+	int init_antenna(int reader_id = 0); // 天线
 	int init_dev_adhoc(int reader_id = 0); // 自组网坐标
 	int init_antenna_sync(); // 初始化分站间距离，组装时间同步所需数据
 	int init_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
+	int init_tof_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
 	int init_tdoa_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
 	int init_traffic_lights(int light_id = 0);		//初始化红绿灯
 	int init_chamber(int chamber_id = 0);				//初始化硐室
 	int init_section(int section_id = 0);				//初始化路段
 	int init_light_group(int group_id = 0);				//初始化红绿灯组
 	int init_light_state(CONNID dwConnID,std::string strIp);
+	int init_rules(int rule_id = 0); // 初始化规则表 2017/08/01
+	int init_leader_arrange(); // 领导排班
+	void clear_leader_arrange(); // 清空列表
+	void clear_att_area();
 
 	//int init_patrol_info(int task_id = 0); // 加载巡检任务及巡检路线
 	int init_patrol_info(std::string card_id);
 	int delete_patrol_info(std::string card_id);
 	int get_help_card_nums();
-	int get_map_path_nums(const int& start_reader_id,const int& end_reader_id);	//获得地图集中两分站之间的路径数量
+	int init_att_area(); // 载入考勤区域信息
 
 	// 载入历史数据
 	void load_his_data();
@@ -310,11 +328,13 @@ public:
 	void load_his_driving_face_card_state(); // 载入掘进面卡状态
 	void init_drivingface_warning_point();
 	void load_his_card_state(); // 加载卡状态
-	void init_drivingface_card_curshift_position();
+	void load_drivingface_card_curshift_position();//从历史数据中加载掘进机的初始状态。当前班次的开始值
 	float get_drivingface_warning_point_dis(std::shared_ptr<Card> card);
 
 	// 载入报警数据
 	void load_alarm_reader();
+
+	MYSQL_RES* getMysqlRes(const char* sql);
 	// 接口数据解析
 	void parse_edit_map(int map_id);
 	void parse_edit_area(int area_id);
@@ -358,8 +378,6 @@ public:
 	int get_locate_msg_type(BYTE* DataBuffer);
 	std::shared_ptr<Card> parse_tof_locate_msg(TofLocateMsg* DataBuffer, int cardNum);
 	
-	
-	//void parse_data_locate_card_vehicle(BYTE* DataBuffer, int& nCurPos,  Card* card, unsigned short wChr);
 	void parse_data_locate_card_vehicle(BYTE* DataBuffer, int& nCurPos,  std::shared_ptr<Card> card, unsigned short wChr);
 	void parse_data_locate_reader_his(BYTE * DataBuffer, int nLen, int& nCurPos, int& reader_id, int& nTick, CString& strtime, unsigned short wChr);
 	void parse_data_locate_card_his(BYTE* DataBuffer, int& nCurPos, int reader_id, DWORD wTickCount, CString strTime, unsigned short wChr);
@@ -387,15 +405,14 @@ public:
 	// 获取json串
 	string get_json_login();
 	string get_json_logout();
-	string get_json_down_and_up(std::shared_ptr<Card> card);
-	string get_json_special_area_process(std::shared_ptr<Card> card);
-	string get_json_all_special_area_data();
-	string get_json_counting();
-	string get_json_position();
-	string get_json_card_position(std::shared_ptr<Card> card);
-	string get_json_drivingface_card_position(std::shared_ptr<Card> card);
-	string get_json_position_all();
-	int insert_data(int index, int key, StatisticDataStr** header);
+	bool   need_display_verification(std::shared_ptr<Card> card); //是否需要推送 false 不需要 true 继续执行
+	string get_json_down_and_up(std::shared_ptr<Card> card); // 升入井接口,当有升井、入井数据时发送
+	string get_json_special_area_process(std::shared_ptr<Card> card); // 进入特殊区域接口，当车辆标识卡信号丢失，根据特殊区域业务，判断车辆进入相应特殊区域时发送
+	string get_json_all_special_area_data(); // 所有在特殊区域的车辆，用于前端登录时，发送全部数据
+	string get_json_position(); // 实时位置信息接口，一定间隔主动发送 === 这个函数没处理。。处理get_json_card_statistic
+	string get_json_drivingface_card_position(std::shared_ptr<Card> card); // done
+	string get_json_position_all(); // 所有实时位置信息，用于前端有用户登录时，上报所有数据 ==== handle this function : get_json_card_statistic
+	int insert_data(int index, int key, StatisticDataStr** header); // 用户
 	void delete_memory(StatisticDataStr *header);
 	//int get_json_statistic_vehicle_data(Json::Value& vehicle_data);
 
@@ -406,39 +423,31 @@ public:
 	//int get_json_statistic_vehicle_data(Json::Value& vehicle_data);
 	//int get_json_statistic_staff_data(Json::Value& person_data);
 	Json::Value get_json_statistic_vehicle_data(Json::Value& vehicle_data);
-	Json::Value get_json_statistic_staff_data(Json::Value& person_data);
-	//刘思平修订的代码Part 10/Sum 10:end 在：YAServerDlg.h中
-	//刘思平修订的代码Part 11/Sum 11:end 在：YAServerDlg.h中
-	//刘思平修订的代码Part 5/Sum 5:begin
-	//by lsp on 2017.07.09 @山西长治
-	//下面这个函数用不到了，直接注释掉
-	//int CYAServerDlg::get_json_statistic_staff_data(Json::Value& staff_data);
-	//刘思平修订的代码Part 5/Sum 5:end
-	Json::Value get_json_statistic_data(StatisticDataStr* header);
+	Json::Value get_json_statistic_staff_data(Json::Value& staff_data);
+	Json::Value get_json_statistic_data(StatisticDataStr* header); // 每秒发送统计数据，里面包含了所有卡的位置信息，包括人员、车辆  == 处理链表中的数据成json
 	int get_json_node_position(std::shared_ptr<Card> card,Json::Value& detailNode);
-	void ReportCardStatistic();
-	string get_json_card_statistic();
-	string get_json_all_data();
-	string get_json_device_state();
-	string get_json_alarm();
-	string get_json_call_test();
+	string get_json_card_statistic();//handle get_json_statistic_vehicle_data  get_json_statistic_staff_data
+	string get_json_all_data(); // 前端有用户登录时，发送
+	string get_json_device_state(); // 分站状态信息
 	string get_json_help();			//求救json
 	string get_json_event(bool bAll = false);
-	string get_json_call_list();
-	string get_json_new_device_state();
-	string get_json_count_area();	//统计区域人数
 
-	Json::Value get_section_json_alarm();
-	Json::Value get_light_json_alarm();
-	Json::Value get_red_light_json_alarm();
-	Json::Value get_json_count_list(int req_type,int area_id);
-	Json::Value get_card_info(std::shared_ptr<Card> pCard);
+	string get_json_call_list(); // 呼叫列表 not handle
+	string get_json_new_device_state(); // 分站状态信息
+	string get_json_count_area();	//统计区域人数 not handle
+	string get_json_leader_arrange(); // 领导带班情况
+
+	Json::Value get_section_json_alarm(); // 路段告警
+	Json::Value get_light_json_alarm(); // 红绿灯告警
+	Json::Value get_red_light_json_alarm(); // 闯红灯告警
 
 	void send_json_data(string cmd, string data, bool is_login = false);
 	// 业务处理
 	void deal_readers();
 	void deal_areas();
+	void deal_attendace(std::shared_ptr<Card> card);
 	void deal_card_msg(std::shared_ptr<Card> card, bool is_hist = false);
+	void cal_card_position_by_msg(std::shared_ptr<Card> card);
 	void deal_hist_card_postion();
 	void deal_his_card_list(std::shared_ptr<Card> card);
 
@@ -451,9 +460,11 @@ public:
 	void card_enter_special_area(std::shared_ptr<Card> card, int area_id);
 	void card_leave_area(std::shared_ptr<Card> card, std::shared_ptr<Area> area);
 	void deal_card_state(std::shared_ptr<Card> card);
+	void deal_card_drivingface_permission(std::shared_ptr<Card> card);
 	void deal_alarm_card(std::shared_ptr<Card> card, std::shared_ptr<CardMap> dest_card_list, bool is_alarm, ALARM_FLAG tag);
     void deal_drivingface_alarm(std::shared_ptr<Card> card, bool is_alarm, ALARM_FLAG tag);
-	void deal_alarm_area(std::shared_ptr<Area> area, std::shared_ptr<AreaMap> dest_area_list, bool is_alarm, ALARM_FLAG tag);
+	void deal_drivingface_alarm_all();
+	void deal_alarm_area(std::shared_ptr<Area> area, std::shared_ptr<AreaMap> dest_area_list, bool is_alarm, ALARM_FLAG tag,int tyep);
 	void deal_card_lost_state();
 	int get_special_area_id(shared_ptr<Card> card);
 	int  deal_traffic_lights(std::shared_ptr<Card> card);
@@ -466,6 +477,7 @@ public:
 	// save to database
 	void execute_sql(const char* sql); // 保存到数据库
 
+	void deal_card_drivingface_real(std::shared_ptr<Card> card);
     void calculate_card_postion_by_tof(std::shared_ptr<Card> card); // 保存卡位置
     void process_driving_face_start_service(std::shared_ptr<Card> card); // 处理采掘面
     void send_drivingface_card_position_json();
@@ -474,8 +486,8 @@ public:
     void driving_face_shift_start();
 	void driving_face_shift_end();
     void process_driving_face_end_service(std::shared_ptr<Card> card);
-	void store_driving_face_data();
-	void update_driving_face_data();
+	void store_driving_face_data(std::shared_ptr<Card> card);
+	void update_driving_face_data(std::shared_ptr<Card> card);//lemon changed..2017/07/29
 	void write_his_drivingface_real(std::shared_ptr<Card> card);
 	void save_card_postion(std::shared_ptr<Card> card); // 保存卡位置
 	void save_raw_data_card_tof(std::shared_ptr<Card> card);
@@ -492,7 +504,6 @@ public:
 
 	// 打包数据
 	void package_data();
-	void package_data_test();
 	// 通用方法
 	int API_TimeToString(string &strDateStr,const time_t &timeData);
 	int API_StringToTime(const string &strDateStr,time_t &timeData);
@@ -509,7 +520,7 @@ public:
 	void parse_json_data_set_limit_value(const char* sz);
 	void parse_json_data_call_card_cancel(message::ptr const& data);
 	void parse_json_data_call_card(message::ptr const& data);//(const char* sz);
-	void parse_json_data_clear_card(const char* sz);
+	void parse_json_data_clear_card(message::ptr const& data);
 	void parse_json_data_deal_help(const char* sz);
 	int  parse_json_data_set_light_color(message::ptr const& data);
 	int  parse_json_data_request_counts_info(message::ptr const& data);
@@ -525,9 +536,11 @@ public:
 	int  deal_call_edit_section(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑路段信息
 	int  deal_call_edit_light(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑灯信息
 	int  deal_call_edit_chamber(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑硐室信息
+	void deal_call_edit_rules(int id,EDIT_TYPE_ID edit_type_id);//lemon 2017/08/01
 
 	void deal_call_edit_patrol_task(string id, EDIT_TYPE_ID edit_type_id);
 	void remove_card(string card_id);
+	void clear_card_from_list(std::shared_ptr<Card> card);
 
 	void add_event(std::shared_ptr<YaEvent> ev);
 	void remove_event(std::shared_ptr<YaEvent> ev);
@@ -551,33 +564,23 @@ public:
 	time_t GetCurShiftStartTime(int& shift_id);
 	time_t GetCurShiftEndTime();
 	time_t GetLastShiftStartTime(int& shift_id);
-	int GetCurShiftId(struct tm* current_time);
+	int GetCurShiftId(struct tm* current_time, int shift_type = 1);
 
 	DIRECTION_TYPE GetDirectionType(_point card_point, _point landmark_point, int map_id);
-
+	POS_DEVICE_TYPE GetPosDownAndUp(int vehicle_type_id, int area_id);
 public:
 	//测试函数
-	void Test();
-	void ReadFileTest();
-	int  GenerateAllDataJsonTest();
-	
-	//格子算法
-	std::shared_ptr<CellPathMap> mpCellPath;
-	CWinThread* pCellThread;			//500ms补充格子线程
-	CWinThread* pSendCellThread;		//发送格子数据的线程
-	HANDLE hEvent;						//格子线程事件
-	bool bSend;
-
-	int SaveCellData2DB();
-	int ModifyCardInfo();
-	int DivideCell(double width, std::shared_ptr<TDOAReaderPathMap> pTdoaReaderPathMap);
-	int InitCellBranch();
-	int ExecuteSql(std::string sql);
-	LRESULT UpdateCardMessage(WPARAM wParam,LPARAM lParam);
-	//std::string get_json_position(std::shared_ptr<Card> pCard);
-	void TestLandmarkRequirement();
-	void TestCallCard();
-	void TestParseCallCard();
+	void TestReadFile(); // 从dist文件中读取信息，计算坐标
+	int  ReadTofDistFile();			// 从TOF数据文件中读取数据，计算坐标
+	int  TestGenerateAllDataJson(); // 测试登录请求所有数据接口
+	void TestLandmarkRequirement(); // 测试地标信息
+	void TestCallCard(); // 测试呼叫接口，向分站发送
+	void TestParseCallCard(); // 测试呼叫接口，接收前端指令
+	void TestFitData(); // 测试拟合数据
+	void TestMultSql(); // 测试向多个库写入数据
+	void TestCardPosition(); // 测试卡靠右行驶
+	string get_json_call_test(); 
+	void package_data_test();
 public:
 	std::unique_ptr<client> _io;
 	CListBox m_list_log;
@@ -585,8 +588,6 @@ public:
 
 	void OnPushMessage();
 	void OnCallMessage(string const& name, message::ptr const& data, bool isAck,message::list &ack_resp); 
-	//void OnCallMessage(string const& name, message::ptr const& data, bool isAck = false,message::list &ack_resp = nullptr); 
-	//void OnLoginCallBack(message::list const& msglist = nullptr);
 	void OnLogin(string const& name, message::ptr const& data, bool isAck, message::list &ack_resp);
 
 	void OnConnected();
@@ -607,11 +608,21 @@ public:
 	UINT m_reader_id_hist;
 	afx_msg void OnEnUpdateEditReaderid();
 	afx_msg void OnAbout();
-	afx_msg void OnBnClickedButton1();
+	afx_msg void OnBnTest();
 
 public:
-	//初始化格子地图集
+	//格子算法相关
+	std::shared_ptr<CellPathMap> mpCellPath;
+	CWinThread* pCellThread;			//500ms补充格子线程
+	CWinThread* pSendCellThread;		//发送格子数据的线程
+	HANDLE hEvent;						//格子线程事件
+	bool bSend;
+
 	int init_cell_path_map();
+	int SaveCellData2DB();
+	int ModifyCardInfo();
+	int DivideCell(double width, std::shared_ptr<TDOAReaderPathMap> pTdoaReaderPathMap);
+	int InitCellBranch();
 };
 
 typedef struct {

classdef.h

@@ -28,15 +28,21 @@
 #define CARD_LOST_TIME_OUT_SPECIAL_AREA 1800
 #define READER_SEND_STATE_TIMEOUT 30 // (2* 60 * 60)
 #define OVER_TIME (480 * 60)
-
 #define MAX_SEMACOUNT 64
 
 //算法类型
 //#define ALGORITHM_TYPE_TOF
-#define ALGORITHM_TYPE_TDOA
+//#define ALGORITHM_TYPE_TDOA
 //#define ALGORITHM_TYPE_INS		//使用惯导判断
 #define ENABLE_MY_LOG
 
+#define NEED_DISPLAY_RULES 1  // lemon 2017/08/01
+#define NEED_DISPLAY_VALID 0
+#define NEED_DISPLAY_INVALID 1
+#define PATROL_LEVEL_ID 3
+
+#define INDEXFORRECONEREADER 10
+
 #include <string>
 #include <ctime>
 #include <map>
@@ -65,17 +71,21 @@ const double INS_WEIGHT = 9.0;	//
 const double UWB_WEIGHT = 1.0;  //UWB权重
 const double MAX_VECHILE_SPEED = 30.0;	//25
 const double NEAR_READER = 4.0;
-const double MIN_DIFFER_DISTANCE = 10.0;
-const double VECHILE_ACCELERATE_THRESHOLD = 10;
-const double PERSON_ACCELERATE_THRESHOLD = 10;
+const double MIN_DIFFER_DISTANCE = 10.0; // 使用其他分站校验计算结果时，判断该结果到校验分站的距离差允许的范围
+const double VECHILE_ACCELERATE_THRESHOLD = 10; // 校验加速度阈值
+const double PERSON_ACCELERATE_THRESHOLD = 10; // 校验速度阈值
 const int ACCELERATE_INIT_STATE = -10;
 const double INVALID_COORDINATE = -1000.0;
-const double CHAMBER_WIDTH = 10.0;			//特指前端展现巷道的宽度，单位为像素
+
+const double CHAMBER_WIDTH = 3.0;			//特指前端展现巷道的宽度，单位为像素
 const double VEHICLE_WIDTH = 10.0;
 const int MAX_READER_TDOA_PATH_NUMS = 10;	//主要是因为拐弯处可能存在多解的原因
 const int LIGHT_CTRL_DELAY = 1000;
 const int MAX_REBOUND_COUNTS = 5;
 
+const double TOF_HEIGHT_ERROR = 2;	//tof定位时的高度误差，单位为米
+const double READER_SYNC_INTERVAL_TIME  = 0.2;		//分站同步序号的时间差，估计值
+
 #define OFFSET_THRE_IN_LINE 1	//判断是否在线段上，允许的误差为1米，用于isinline
 #define ZERO_PRECISION 1E-3		//为零的精度
 #define MAX_REBOUND_COUNTS 5
@@ -93,7 +103,9 @@ enum ALARM_FLAG{
 	AF_AREA_OVER_COUNT,
 	AF_AREA_OVER_TIME,
 	AF_AREA_FORBIDDEN,
-	AF_CARD_OVER_COUNT
+	AF_CARD_OVER_COUNT,
+	AF_CARD_NEAR_WARNING_POINT,//lemon	
+	AF_CARD_NEAR_DRRIVINGFACE_VEHICLE //lemon 2017/08/01
 };
 
 enum AREA_TYPE
@@ -108,7 +120,12 @@ enum EDIT_TYPE_ID{
 	ET_UPDATE,	   // 修改
 	ET_DELETE      // 删除
 };
-
+//车辆烈性
+enum VECHILE_TYPE_ID
+{
+	VT_DIGGINGCOAL_MACHINE=25,
+	VT_DRIVINGFACE_MACHINE=26
+};
 enum ALARM_TYPE_ID
 {
 	ATID_OVER_COUNT_PERSON = 1,
@@ -209,6 +226,7 @@ enum LIGHT_SHAPE{
 };
 
 enum LIGHT_STREAM{
+	INIT_STREAM = 0,
 	UP_STREAM = 1,		//上行
 	DOWN_STREAM = 2	//下行
 };
@@ -288,6 +306,7 @@ enum ALGO_RETURN_VALUE{
 	ALGO_CALC_ONE_DATA,
 
 	SOLUTION_NO_SOLUTION = 40001,
+	SOLUTION_NOT_EXIST_READRE,
 	SOLUTION_NEAR_READER,
 	SOLUTION_TWO_SOLUTION,
 	SOLUTION_ERROR_STREAM,
@@ -299,7 +318,8 @@ enum ALGO_RETURN_VALUE{
 
 	KALMAN_FILTER_LONG_INTERVAL = 60001,
 
-	ALGO_USE_KALMAN_FILTER = 70001
+	ALGO_USE_KALMAN_FILTER = 70001,
+	ALGO_DIVIDE_ZERO = 80001,
 };
 
 extern unsigned int g_nAlgoFailedCounts[ALGO_LOC_TOTAL];	//全局的统计所有次数
@@ -338,9 +358,14 @@ enum CALL_STATE{
 	CALL_NONE = 0,			//无呼叫信息
 	CALL_SUCCESSED = 1,		//呼叫成功
 	CALL_ING = 2,			//呼叫中
-	CALL_FAILED = 3		//呼叫失败
+	CALL_FAILED = 3,		//呼叫失败
 };
 
+enum LOCATEDATATYPE // 定位数据类型
+{
+	LDT_TOF = 0, 
+	LDT_TDOA
+};
 struct SQLTHREAD_DATA//写数据库线程传递的参数
 {
 	char* pText;//数据库语句地址指针
@@ -368,11 +393,12 @@ struct _coordinate{
 		acce_state = 0;	
 		acce_state_last = 0;
 		ins_direction = 0;
+		rangingtype = 1; // 0 tof，1 toda
 	}
 	int t; // 定位时间戳
-	int reader_id;
-	unsigned long long syncRootId;
-	unsigned long long tt;
+	int reader_id; // 分站编号
+	unsigned long long syncRootId; // tdoa主节点
+	unsigned long long tt; // 分站接收的时间，为同步及线性插值后的时间
 	double d; // 距离
 
 	double x; // x坐标
@@ -390,6 +416,8 @@ struct _coordinate{
 	int ins_direction;		//惯导方向
 	int special; //分站是否属于特殊分站，0属于特殊分站，1普通分站
 
+	int rangingtype;
+
 	int reason;
 
 	_coordinate& operator=(_coordinate &tmp){
@@ -410,6 +438,7 @@ struct _coordinate{
 		acce_state = tmp.acce_state;
 		acce_state_last = tmp.acce_state_last;
 		ins_direction = tmp.ins_direction;
+		rangingtype = tmp.rangingtype;
 		reason = ALGO_LOC_SUCCESSED;
 		return *this;
 	}
@@ -523,6 +552,27 @@ struct INFO_PRE{
 	int sta_num;
 };
 
+struct TOF_REFER_DATA{
+	unsigned int nCardTimeStamp;	// 卡的ct号
+	long long llDeltaTime;			// 
+	double dDistance;				// 距离
+	unsigned int nAntennaIndex;		// 分站天线索引号
+	unsigned int nReaderId;			// 分站id
+	double x;						// 参考点x坐标
+	double y;						// 参考点y坐标
+	double z;						// 参考点z坐标
+	int a;							// 加速度状态
+
+	TOF_REFER_DATA(){
+		nCardTimeStamp = 0;
+		llDeltaTime = 0;
+		dDistance = 0.0;
+		nAntennaIndex = nReaderId = 0;
+		x = y = z = 0.0;
+		a = 0;
+	}
+};
+
 struct POS{
 	double posx;
 	double posy;
@@ -556,6 +606,8 @@ struct POS{
 
 	//当前分站同步序号与参考数据的分站同步序号时间差值
 	double diff_reader_sync_num;
+
+	double delta_time;			//时间差
 	//参考数据的定位坐标
 	double ref_x;
 	double ref_y;
@@ -567,7 +619,7 @@ struct POS{
 	POS(){
 		nFirstReader = 0;
 		nSecondReader = 0;
-		pos_radius = 0;	
+		pos_radius = 999999.9;	
 		posx = posy = posz = INVALID_COORDINATE;
 		cx = cy = cz = cvx = cvy = cvz = 0.0;
 		av = 0.0;
@@ -577,7 +629,7 @@ struct POS{
 		{
 			dDiff[i] = 0;
 		}
-		
+
 		dis_diff = 999999.9;
 		update = false;
 		is_fit = false;
@@ -585,6 +637,7 @@ struct POS{
 		origin_speed = 0;
 		sumVariance = 0;
 		diff_reader_sync_num = 0;
+		delta_time = 0.0;
 		ref_x = ref_y = ref_z = 0;
 		reason = -1;
 		reason = ALGO_LOC_SUCCESSED;
@@ -608,6 +661,7 @@ struct POS{
 		status = tmp.status;
 		is_back = tmp.is_back;
 		diff_reader_sync_num = tmp.diff_reader_sync_num;
+		delta_time = tmp.delta_time;
 		dis_diff = tmp.dis_diff;
 		ref_x = tmp.ref_x;
 		ref_y = tmp.ref_y;
@@ -644,7 +698,9 @@ class Mine;
 class Area;
 class SpecialAreaEntry;
 class DrivingfaceRender;
+class DrivingfaceCard;
 class DrivingfaceWarningPoint;
+class VehicleTypeAttRule;
 class Reader;
 class Card;
 class MapInfo;
@@ -654,6 +710,7 @@ class OccLevel;
 class ReaderPath;
 class PatrolPoint;
 class PatrolTask;
+class LeaderArrange;
 
 class Section;
 class Chamber;
@@ -668,8 +725,10 @@ class MapDirectionInfo;
 typedef map<string, std::shared_ptr<Card>> CardMap;
 typedef map<int, std::shared_ptr<Area>> AreaMap;
 typedef map<int, std::shared_ptr<DrivingfaceWarningPoint>>DrivingfaceWarningPointMap;
+typedef map<int,std::vector<std::shared_ptr<DrivingfaceWarningPoint>>> DrivingfaceWarningPointMapAll;
 typedef map<int, std::shared_ptr<SpecialAreaEntry>> SpecilaAreaEntryMap;
 typedef map<int, std::shared_ptr<DrivingfaceRender>> DrivingfaceRenderMap;
+typedef map<string,std::shared_ptr<DrivingfaceCard>> DrivingfaceCardMap;
 typedef map<int, std::shared_ptr<Reader>> ReaderMap;
 typedef map<int, std::shared_ptr<MapInfo>> MapInfoMap;
 typedef map<int, std::shared_ptr<MapDirectionInfo>>MapDirectionInfoMap;
@@ -679,6 +738,7 @@ typedef map<int, std::shared_ptr<BanShift>> BanShiftMap;
 typedef map<int, std::shared_ptr<OccLevel>> OccLevelMap;
 typedef map<int, string> AlarmTypeMap;
 typedef map<int,std::shared_ptr<ReaderPath>> ReaderPathMap;
+typedef map<int,std::shared_ptr<ReaderPath>> TOFReaderPathMap;
 typedef unordered_map<int,std::shared_ptr<ReaderPathMap>> TDOAReaderPathMap;
 typedef unordered_map<std::string, std::shared_ptr<_coordinate>> DistMap;
 typedef map<unsigned long long ,std::shared_ptr<ReceiveData>> ReceiveDataMap;
@@ -693,21 +753,25 @@ typedef map<unsigned int, std::shared_ptr<PatrolPoint>> PatrolPointMap;
 typedef map<unsigned int, std::shared_ptr<PatrolTask>> PatrolTaskMap;
 typedef map<std::string, std::shared_ptr<PatrolTask>> PatrolTaskCheckMap;
 typedef deque<std::shared_ptr<StorePostion>> QueStrorePos;
+typedef map<std::string, std::shared_ptr<LeaderArrange>> LeaderArrangeMap;
+typedef map<int,string> WorkTypePermissionMap;
+typedef map<int,int> RulesMap; //lemon 2017/08/01
+typedef map<int, std::shared_ptr<VehicleTypeAttRule>> VehicleTypeAttRuleMap;
 
 typedef std::map<std::string,std::list<std::shared_ptr<Cell>>> CellPathMap;
 
 typedef struct key_value_pair
 {
-    int key;
-    int value;
-    struct key_value_pair* next;
+	int key;
+	int value;
+	struct key_value_pair* next;
 }KeyValuePair;
 
 typedef struct statistic_data_str
 {
-    int index;
-    KeyValuePair* data_info;
-    struct statistic_data_str* next;
+	int index;
+	KeyValuePair* data_info;
+	struct statistic_data_str* next;
 }StatisticDataStr;
 
 struct DistQueMapItem
@@ -745,8 +809,8 @@ public:
 class LandmarkInfo
 {
 public:
-    int landmark_id;
-    string landmark_name;
+	int landmark_id;
+	string landmark_name;
 	int map_id;
 	double x;
 	double y;
@@ -756,9 +820,9 @@ public:
 class MapDirectionInfo
 {
 public:
-    int map_direction_id;
-    int map_id;
-    int north_angle;
+	int map_direction_id;
+	int map_id;
+	int north_angle;
 };
 // 区域
 class Area  // 矩形
@@ -865,12 +929,25 @@ class DrivingfaceRender
 public:
 	DrivingfaceRender(){}
 public:
-		INT    drivingface_id;
-		INT    reader_id;
-		double vertical_distance;
-		double x;
-		double y;
-		double z;
+	INT    drivingface_id;
+	INT    reader_id;
+	double vertical_distance;
+	double x;
+	double y;
+	double z;
+};
+
+// 工作面与卡绑定信息
+class DrivingfaceCard
+{
+public:
+	double x;
+	double y;
+	double z;
+	INT drivingface_id;
+	string card_id;
+	INT area_id;
+	float warning_threshold;
 };
 
 // 自组网预置坐标
@@ -967,38 +1044,34 @@ class Card
 public:
 	Card(void);
 	~Card(void);
-	Card(string cardid, int cardtype,double z_offset, double offset_x = 12.0, double offset_y =12.0);
+	Card(string cardid, int cardtype,double z_offset);
 
 public:
 	CRITICAL_SECTION m_csCard;
+	bool is_registered;
 public:
 	int card_type; // 卡类型 0x01人, 0x02车
-	//int64_t card_id; // 卡唯一标识， 高位为卡号，低位为卡类型， ((card_id << 8) | card_type)
 	string card_id;
-	
+
 	// 人员
-	string level; // 级别
-	string occupation; // 职务
+	int level_id;
+	int worktype_id;// 工种lemon 2017/07/31 车辆为vehicle_type_id
+	int vehice_type_id;
 	// 人员、车辆
-	string id; // 编号，人员或车辆
-	string name; // 姓名、车辆名称
-	string number; // 身份证号码，车牌号码
-	//string photo; // 照片
-	//string company; // 单位
-	string department; // 部门
-	string group; // 班组 
-	string worktype; // 工种、车辆类型
-	int dept_id;
+	int id; // 编号，人员或车辆
+	int dept_id; // 部门
 	int occlevel_id; // 职务id
-	int group_id;
-	
-	string driver_id;	//如果是车辆，则有司机id
-	int light_id;
+	int group_id; // 班组	
+	int need_display;// lemon 2071/08/01 是否在Web端显示
+	int shift_type_id; // 人员或者车辆执行的班次类型
 
-	//time_t deal_time; // 最后处理卡逻辑时间
-	SYSTEMTIME deal_time;
+	string driver_id;	//如果是车辆，则有司机id
+	int light_id; // 闯红灯的灯编号
+	int shift_id;
+	SYSTEMTIME deal_time; // 最后处理卡逻辑时间
 	SYSTEMTIME enter_area_time;
-
+	//
+	int m_indexForRcvOneReader;
 	//driving face write database time
 	ULONGLONG drive_face_location_write_time;
 	ULONGLONG drive_face_location_end_time;
@@ -1013,38 +1086,30 @@ public:
 	double x;
 	double y;
 	double z;
-	
-	//double driving_face_x;  //cur shift start point
-	//double driving_face_y;
-	//double driving_face_z;
+	//查看掘进机变量是否为初始化值，如果是不进行插入库操作
+	bool is_drivingface_Initialization;
 
 	int driving_face_id;
 	double driving_face_cur_shift_start_x; //cur shift start position
 	double driving_face_cur_shift_start_y;
 	double driving_face_cur_shift_start_z;
-	
+
 	double driving_face_cur_shift_x; //cur shift real point
 	double driving_face_cur_shift_y;
 	double driving_face_cur_shift_z;
 
 	double drving_face_cur_shift_max_speed;
-	
+
 	double a; // 上次定位时的角度
 	int t; // 上次定位时的时间戳
+
+	double v; //速度
+	double mileage; // 里程，距离上次保存数据时的距离
 	double z_offset;
 	bool init_postion;
 	bool is_first_location;
 	int is_driving_face_start;
-	double v; //速度
-	double mileage;
 
-	double xx;
-	double yy;
-	double zz;
-
-	double x1, x2, x3, x4;
-	double y1, y2, y3, y4;
-	double z1, z2, z3, z4;
 	double right_x,right_y,right_z;		//分别指卡位置右边偏移的x,y,z坐标
 	double left_x,left_y,left_z;		//分别指卡位置左边偏移的x,y,z坐标
 
@@ -1052,6 +1117,9 @@ public:
 	double last_y;
 	double last_z;
 
+	double last_offset_x;
+	double last_offset_y;
+
 	double stored_x;
 	double stored_y;
 	double stored_z;
@@ -1063,8 +1131,8 @@ public:
 	double last_vy;
 
 	int state;	// 0 正常， 共32bit,每个bit代表一个状态，从右起:
-				// 第一位 0x01 井下超时, 第二位 0x02 区域超时, 第三位 0x04 超速, 第四位 0x08, 进入限制区域
-				// 状态，故障、电量低等
+	// 第一位 0x01 井下超时, 第二位 0x02 区域超时, 第三位 0x04 超速, 第四位 0x08, 进入限制区域
+	// 状态，故障、电量低等
 	int state_moving; // 运动状态， 0 静止，1 启动
 
 	// 电量低、 呼叫、呼救
@@ -1077,7 +1145,7 @@ public:
 	int status_call; // 0 未呼叫 1 呼叫
 	int status_power; // 0 电量正常，1 电量低
 	int status_lost; // 0 未进入盲区，1 盲区状态
-	
+
 	int map_id; // 当前地图
 	double map_scale; // 地图比例尺
 	int map_id_old; // 上次测距所在地图
@@ -1088,15 +1156,12 @@ public:
 	int reader_id; // 当前分站
 
 	Reader* p_reader;
-	std::shared_ptr<ReaderPathMap> pReaderPathMap;
+	std::shared_ptr<ReaderPathMap> pTofReaderPathMap;
 	std::shared_ptr<TDOAReaderPathMap> pTdoaReaderPathMap;
-	_coordinate** p_dists_locate;
 	map<unsigned long long,std::shared_ptr<_coordinate>> mp_dists_locate;
+	_coordinate** p_dists_locate;
 	_coordinate last_locate;
 	_coordinate origin_locate;
-	_coordinate kalman_locate;
-	double m_dFirstDiff;
-	double m_dSecondDiff;
 
 	QueStrorePos _storepostions;	
 	DistQueMap _dists;
@@ -1112,34 +1177,38 @@ public:
 	int m_nMoveDirection;		//1为正向运动，-1为负向运动
 	int m_nIsRailroad;			//是否为有轨车，0为无轨车，1为有轨车
 	int m_nOutputPosState;		//0为正常输出中间坐标，1为输出靠左偏移坐标，2为输出靠右偏移坐标
+	bool bIsBack;
 
 	bool issent;		// true 已发送至客户端，false 新数据，需要发送至客户端
 	bool issaved;		//true 已保存到数据库，false 生成新的考勤记录，需要保存到数据库
 	bool isdealed;		// 已经处理
 	bool isreceive;		// 接收到
 	bool is_pos_changed;
-	bool is_deal_by_algo;
+	bool is_deal_by_algo;		//是否经过算法处理
 	bool is_hist;
 	bool is_need_cal;
+
 	bool m_bUseFilter;
 	bool isoutput;				//是否输出到json
 	bool is_red_light;
 
 	bool is_mine_over_time;		// 是否井下超时
-	bool is_mine_over_speed;
+	bool is_mine_over_speed;    // 是否井下超速
+
 	bool is_area_over_time;		// 是否区域超时, 区域超时分车辆超时、人员超时
 	bool is_area_over_speed;	// 是否区域超速
-	
+
 	time_t time_area_over_time; // 区域超时开始时间
 	time_t time_over_time;		// 井下超时开始时间
 	time_t time_area_forbidden; // 进入限制区域时间
 	time_t time_over_speed;		// 超速开始时间
 	time_t time_area_over_speed;
 	time_t time_low_power;
+
 	time_t time_red_light;		//闯红灯时间
 	time_t last_locate_time;	// 最后定位时间
 
-	void reset();
+	void reset();				// 重置所有状态
 	void set_reader(std::shared_ptr<Reader> preader);
 	void add_dist(_coordinate* dist);
 	void add_dist(std::shared_ptr<_coordinate> dist);
@@ -1151,8 +1220,7 @@ public:
 	double get_speed();
 	void set_speed(double v);
 	int get_effictive_dist_count(int offset = 0);
-	void set_reader_path_tof(std::shared_ptr<ReaderPathMap> rpm);
-	void set_reader_path_tdoa(std::shared_ptr<TDOAReaderPathMap> trpm);
+	void set_reader_path(std::shared_ptr<ReaderPathMap> rpm, std::shared_ptr<TDOAReaderPathMap> trpm);
 	void inspect_coordinate(int acce_state);
 	bool checkStream(double x1,double y1,double x2,double y2,int nStream);
 
@@ -1163,6 +1231,21 @@ public:
 	int const StateBiz();
 
 	INT64 m_event_list[CARD_EVENT_COUNT]; // 保存事件Id
+public://lemon
+	int m_warning_point_id; 
+	bool m_isWarning; // 0 
+	double m_minDistanceToWarningpoint; //
+	double m_warning_threshold; //limit value
+	bool m_CardHasBeenInDrivingfaceAlarm;
+	int m_DrivingfaceAlarmFlag;
+	//lemon 2017/08/01
+	inline double getDrivingfaceCulValue(){return m_drivingface_distance_cul_values;}
+	inline double getDrivingfaceLimitValue(){return m_drivingface_distance_limit_values;}
+	inline void	 setDrivingfaceCulValue(double cvalue){m_drivingface_distance_cul_values = cvalue;}
+	inline void  setDrivingfaceLimitValue(double lvalue){m_drivingface_distance_limit_values = lvalue;}
+private:
+	double m_drivingface_distance_cul_values;
+	double m_drivingface_distance_limit_values;
 public:
 	//算法相关参数及函数
 	bool is_algo_first_location;		//表示算法的第一次定位
@@ -1171,25 +1254,31 @@ public:
 	std::list<std::shared_ptr<POS>> idle_pos_list;
 
 	void algo_tof(int cnt);
+	int  algo_tof_1d(int cnt);		// tof一维定位
 	void algo_tdoa(int cnt);
+
 	int  algo_tdoa_1d(int cnt);		//一维定位
 	int  algo_tdoa_2d(int cnt);		//二维定位
 	int  algo_tdoa_3d(int cnt);		//三维定位
 
 	void algo_calc_offset();		//计算偏移坐标
+	double x_offset_after();        //返回偏移后的X坐标
+	double y_offset_after();        //返回偏移后的Y坐标
+	double z_offset_after();        //返回偏移后的Z坐标
 	bool algo_is_same_direction(double x,double y,double z);	//检查此次方向
 
 	int CheckDistData(int cnt);
 	int AssembleDistData(std::shared_ptr<ReceiveDataMap> pRdm);
 	int SaveCardAlgoData(std::shared_ptr<POS>& pos);
-	int SaveCardAlgoData(std::shared_ptr<Cell>& cell);
+	int SaveTofData(const std::shared_ptr<POS> pos);
+	int SaveTdoaData(const std::shared_ptr<POS> pos);
 	int SaveOriginDataBeforeFilter(std::shared_ptr<POS> pos);
 	int ChooseOneSolution(std::shared_ptr<ReceiveDataMap> pRdm, std::vector<std::shared_ptr<POS>> udm_pos, std::shared_ptr<POS>& pos);// 输出唯一解
-	int CheckSolution(std::shared_ptr<POS>& p); // 验证唯一解合法性，如速度、加速度
-	int CheckSulutionByStream(std::shared_ptr<POS> p);	//参数使用非引用，即不可修改其值
-	int GetStream(double x1,double y1,double x2,double y2);		//获得上下行方向
-	int CalcPositionBySpeed(std::shared_ptr<POS>& pos,double v);
 
+	int CheckSolution(std::shared_ptr<POS>& p);					// 验证唯一解合法性，如速度、加速度
+	int CheckSulutionByStream(std::shared_ptr<POS> p);			// 参数使用非引用，即不可修改其值
+	int GetStream(double x1,double y1,double x2,double y2);		// 获得上下行方向
+	int CalcPositionBySpeed(std::shared_ptr<POS>& pos,double v);
 	bool CheckStreamUniformity(double x1,double y1,double x2,double y2,int nStream);
 	bool IsExistPath(int left,int right);
 	int CopySolution(std::shared_ptr<POS> source,std::shared_ptr<POS>& dest);
@@ -1198,10 +1287,20 @@ public:
 	int CheckCardStatus();
 	bool IsIdleStatus(std::shared_ptr<POS> pos);
 	bool IsRebound(std::shared_ptr<POS> pos);		//判断是否回退
+	bool CheckPositionValid(const std::shared_ptr<POS> pos);		//检查解的有效性
 
+	double GetDeltaT();		//获取时间差值
+public:
+	//tof相关变量及函数
+	time_t time_last_tof;
+
+	bool CheckSolutionTof(std::shared_ptr<POS>& pos);		//通过速度及加速度检查定位结果是否正确
+private:
+	void set_reader_path_tof(std::shared_ptr<ReaderPathMap> rpm);			// 设置tof路径集
+	void set_reader_path_tdoa(std::shared_ptr<TDOAReaderPathMap> trpm);		// 设置tdoa路径集
 public:
 	// 滤波算法相关
-	std::unique_ptr<CKalmanFilter> m_pKalmanFilter;
+	std::unique_ptr<CKalmanFilter> m_pKalmanFilter;		// 卡尔曼滤波器
 	list<sync_data> m_syncNumList;
 	std::list<std::shared_ptr<POS>> his_idle_pos;
 
@@ -1255,7 +1354,7 @@ public:
 	double long_fitting_ct[REF_POSITION_NUM];
 	double long_fitting_x[REF_POSITION_NUM];
 	double long_fitting_y[REF_POSITION_NUM];
-	
+
 	double long_fit_new_x[FIT_POSITION_NUM*4];
 	double long_fit_new_y[FIT_POSITION_NUM*4];
 
@@ -1275,14 +1374,25 @@ public:
 private:
 	bool b_long_interval;	//上一次定位的间隔时间差大于10s
 
-	int state_biz;    //业务状态，呼叫/超时/进入禁区等
+	int state_biz;		//业务状态，呼叫/超时/进入禁区等
 
-	int pos_state; // 位置状态，0初始化，1井下，2井上，3车场分站
+	int pos_state;		// 位置状态，0初始化，1井下，2井上，3车场分站
 	int pos_state_old;
-	int pos_state_count; // 当前位置状态确认次数
-	int pos_state_confirm_times; // 井下、井上状态确认次数，默认为1
-public:
-	AlgoFailedMsg m_afmData;
+	int pos_state_count;			// 当前位置状态确认次数
+	int pos_state_confirm_times;	// 井下、井上状态确认次数，默认为1
+
+public: // 采集到的底层数据
+	int time_stamp_last; // 定位时间戳
+	int context_type_last; // 报文类型 tof，tdoa
+	int accelerate_state_last; // 上一次加速度状态
+	int antenna_id_last; // 天线号
+	double antenna_angle_last; // 天线角度
+	double distance_last; // 距离	
+	int64_t flying_time_last; // 飞行时间
+	int power_state_last; // 电量
+	int ins_direction;	//上一次的惯导合成方向
+	int direction;		//上下行概念
+	int reader_id_last;	//上一次定位时间戳的分站id
 public:
 	bool b_pos_change;		//位置发生了改变
 	bool b_enter_intersection;	//车辆是否进入过路口区域
@@ -1298,20 +1408,16 @@ public: //
 	int power_state; // 电量
 	int sync_num;
 
-	int time_stamp_last; // 定位时间戳
-	int context_type_last; // 报文类型 tof，tdoa
-	int accelerate_state_last; // 上一次加速度状态
-	int antenna_id_last; // 天线号
-	double antenna_angle_last; // 天线角度
-	double distance_last; // 距离	
-	int64_t flying_time_last; // 飞行时间
-	int power_state_last; // 电量
-	int ins_direction;	//上一次的惯导合成方向
-	int direction;		//上下行概念
-	int reader_id_last;	//上一次定位时间戳的分站id
-
 	string str_his_time;
 	string str_rec_time;
+	//呼叫信息
+	int call_type;
+	std::vector<int> vt_deal_call_reader_id;
+	time_t recv_call_time;	//卡接收到呼叫的时间戳
+
+public:
+	//测试及统计功能
+	AlgoFailedMsg m_afmData;
 
 public:
 	//格子算法的代码
@@ -1348,11 +1454,9 @@ public:
 	std::shared_ptr<Cell> last_cell;
 	std::list<std::shared_ptr<Cell>> his_cell;
 	std::list<std::shared_ptr<Cell>> locate_cells;
-	
 
 	int DiscreteLocate(int cnt);
 	int PersonLocation(int cnt);
-
 	bool CheckIdleStatus();
 	bool CheckStartRule();
 	bool isOverThreshold();
@@ -1370,7 +1474,8 @@ public:
 	int colourfulCloudsChasingTheMoon(std::shared_ptr<Cell> &cell, std::list<std::shared_ptr<Cell>> &myCellList);
 	int MappingCell2FitLinear(std::shared_ptr<Cell>& cell);		//将格子拟合到线上
 	bool cftool(float *data_x, float *data_y, int data_n, std::vector<float> &vResult);
-	
+	int SaveCardAlgoData(std::shared_ptr<Cell>& cell);
+
 	//刘思平修订的代码Part 3/Sum 3:begin
 	//以下函数的声明：将当前时刻的毫秒四舍五入为0ms或者500ms
 	//by lsp on 2017.07.09 @山西长治
@@ -1389,12 +1494,6 @@ public:
 
 	double dTestDelatT;		//测试时间差
 	double dTestDistance;		//测试两次的定位的距离差
-public:
-
-	//呼叫信息
-	int call_type;
-	std::vector<int> vt_deal_call_reader_id;
-	time_t recv_call_time;	//卡接收到呼叫的时间戳
 };
 
 class BanShift
@@ -1402,12 +1501,27 @@ class BanShift
 public: 
 	BanShift();
 	~BanShift();
-	BanShift(int id, std::string s, std::string e);
+	BanShift(int id, std::string s, std::string e, int tid);
 	int shift_id;
+	int shift_type_id;
 	std::string start_time;
 	std::string end_time;
 };
 
+class LeaderArrange
+{
+public:
+	LeaderArrange( string cardid);
+	~ LeaderArrange();
+
+	int staff_id;
+	string card_id;
+	int shift_id;
+	int shift_type_id;
+	time_t starttime;
+	time_t endtime;
+};
+
 class Dept
 {
 public:
@@ -1418,7 +1532,7 @@ private:
 public:
 	int dept_id;
 	string dept_name;
-	
+
 	CardMap dept_card_list_person;
 	CardMap dept_card_list_vehicle;
 };
@@ -1438,7 +1552,7 @@ public:
 };
 
 /*
- * 地图集路径描述
+* 地图集路径描述
 */
 class ReaderPath{
 public:
@@ -1446,7 +1560,7 @@ public:
 		bIsInit = false;
 		nRealCalcPoints = 0;
 		x[0] = x[1] = y[0] = y[1] = 0;
-		for(int i=0;i<MAX_CALC_POINTS;i++){
+		for(int i = 0;i < MAX_CALC_POINTS;i++){
 			px[i] = py[i] = pz[i] = 0;
 		}
 	}
@@ -1508,7 +1622,7 @@ class LightsGroup{
 public:
 	int m_nID;
 	int m_nState;
-	
+
 	bool m_bIsUsed;
 
 	std::string m_strName;
@@ -1587,7 +1701,7 @@ public:
 	LightMap mp_light_list;
 	CardMap mp_vehicle_list;
 	CardMap mp_staffer_list;
-	
+
 	INT64 m_event_list[SECTION_EVENT_COUNT];
 public:
 	Section();
@@ -1648,8 +1762,8 @@ public:
 
 enum EVENT_TYPE{ // 事件类型
 	ET_UNKNOWN = 0,
-	ET_OVER_COUNT_PERSON = 1, // 井下人员超员
-	ET_OVER_COUNT_VEHICLE = 2,    // 井下车辆超员
+	ET_OVER_COUNT_PERSON = 1, // 井下人员超员mp_card_list_over_count_person
+	ET_OVER_COUNT_VEHICLE = 2,    // 井下车辆超员mp_card_list_over_count_person
 
 	ET_AREA_OVER_COUNT_PERSON = 3,	// 区域人员超员
 	ET_AREA_OVER_COUNT_VEHICLE = 4,	// 区域车辆超员
@@ -1664,8 +1778,9 @@ enum EVENT_TYPE{ //
 
 	ET_CARD_LOW_POWER = 11, // 电量低
 	ET_CARD_LOW_POWER_SERIOUS = 12, // 电量极低
-	ET_CARD_OVER_TIME_PERSON = 13, // 人员井下超时
-	ET_CARD_OVER_TIME_VEHICLE = 14, // 车辆井下超时
+
+	ET_CARD_OVER_TIME_PERSON = 13, // 人员井下超时mp_card_list_over_time_person
+	ET_CARD_OVER_TIME_VEHICLE = 14, // 车辆井下超时mp_card_list_over_time_vehicle
 	ET_CARD_AREA_OVER_TIME_PERSON = 15, // 人员区域超时
 	ET_CARD_AREA_OVER_TIME_VEHICLE = 16, // 车辆区域超时
 	ET_CARD_AREA_LIMIT_PERSON = 17, // 人员进入限制区域
@@ -1679,8 +1794,9 @@ enum EVENT_TYPE{ //
 	ET_CARD_CALLED = 25, // 人员已被呼叫
 	ET_CARD_PATROL_ERROR = 26, // 人员巡检异常
 	ET_CARD_LOST = 27, // 标识卡信号丢失
-	ET_CARD_DRIVINGFACE_WARNING_AREA = 28,  //掘进面靠近预警区域告警
-	CARD_EVENT_COUNT_MAX
+	ET_CARD_DRIVINGFACE_WARNING_AREA = 28,  // 掘进面靠近预警区域告警
+	ET_CARD_NEAR_DRIVINGFACE_VEHICLE=29,// 人员靠近掘进机告警
+	CARD_EVENT_COUNT_MAX,
 };
 
 enum OBJECT_TYPE // 对象类型
@@ -1723,7 +1839,7 @@ public:
 	YaEvent(){};
 	YaEvent(INT64 e_id){
 		ev_id = e_id;
-		
+
 		obj_id = "";
 		cur_time = time(NULL);
 		map_id = 0;
@@ -1746,7 +1862,7 @@ public:
 	OBJECT_TYPE obj_type;
 	std::string obj_id;
 	time_t cur_time;
-	
+
 	int map_id;
 	int area_id;
 	double x;
@@ -1757,7 +1873,7 @@ public:
 	int landmarkid;
 	int landmarkdirect;
 	int landmarkdist;
-	
+
 	bool is_sent; // 已发送
 	bool is_count;
 
@@ -1789,4 +1905,18 @@ enum DIRECTION_TYPE{
 	NORTH = 4
 };
 
+class VehicleTypeAttRule
+{
+public:
+	VehicleTypeAttRule(int vtid, int pre, int back);
+	~VehicleTypeAttRule();
+
+	int vehicle_type_id;
+	int offset_pre;
+	int offset_back;
+	std::vector<int> vecArea;
+
+	void Clear();
+	void AddArea(int area_id);
+};
 #endif //YASERVER_CLASSDEF_H_

config.ini

@@ -7,6 +7,14 @@ encoding=gb2312
 port=3306
 usedb=0
 
+[DB2]
+host=localhost
+user=root
+password=password
+dbname=yaloc
+encoding=gb2312
+port=3306
+
 [SERVER_SETTING]
 websocket_url=ws://localhost:8086/
 tcp_host=0.0.0.0
@@ -14,7 +22,11 @@ tcp_port=9800
 interval_send_json_postion=1000
 interval_send_json_counting=10000
 interval_send_json_alarm=10000
+interval_warning_point_alarm=10000 
 interval_send_json_device=5000
+interval_send_json_drivingface=30000
+interval_send_json_leader=1800000
+interval_load_leader = 14400000
 send_call_interval=3000
 send_help_interval=5000
 heart_interval=5000

constdef.h

@@ -3,22 +3,14 @@
 
 #define MAXCRITICALSECTIONSPINCOUNT 4000
 #define INTERFACE_VERSION "1.0.0.2"
+#define INTERFACE_VERSION_1_1 "1.0.0.1"
 #define INTERFACE_VERSION_1_3 "1.0.0.3"
 #define INTERFACE_VERSION_1_4 "1.0.0.4"
 
-#define TEST_WEB_URL "http://localhost:8080/yaloc/servlet/main?"
-//#define TEST_WS_URL  "ws://localhost:8086" 
-//#define TEST_WS_URL  "ws://192.168.0.36:8086"
 #define TEST_WS_URL  "ws://182.92.224.191:8086"
-#define TEST_CONFIRM_COUNT 1
-#define PARAM_NAME_USERNAME "username"
-#define PARAM_NAME_INTERFACE "interface"
-#define PARAM_NAME_DATA	"data"
-#define PARAM_NAME_VERSION "version"
 #define JSON_ROOT_KEY_CMD "cmd"
 #define JSON_ROOT_KEY_VERSION "version"
 #define JSON_ROOT_KEY_DATA "data"
-#define JSON_ROOT_KEY_DIFF_TICK_COUNT "difftick"
 #define JSON_ROOT_KEY_TOTAL "total"
 #define JSON_ROOT_KEY_STATISTIC_VEHICLE_DATA "v"
 #define JSON_ROOT_KEY_STATISTIC_STAFF_DATA "s"
@@ -28,31 +20,17 @@
 #define JSON_ROOT_KEY_STATISTIC_DEPT "dept"
 #define JSON_ROOT_KEY_STATISTIC_SUM "sum"
 #define JSON_ROOT_KEY_STATISTIC_AREA "area"
-#define JSON_ROOT_KEY_STATISTIC_AREA_ID "area_id"
-#define JSON_ROOT_KEY_STATISTIC_DEPT_ID "dept_id"
 #define JSON_ROOT_KEY_STATISTIC_LEVEL "occupation_level"
-#define JSON_ROOT_KEY_STATISTIC_LEVEL_ID "level_id"
 
 // 采集端接收接口
-#define JSON_CMD_VALUE_SET_LIMIT_VALUE "set_limit_value"
-#define JSON_CMD_VALUE_CALL_CARD "call_card"
 #define JSON_CMD_VALUE_CLEAR_CARD "clear_card"
-#define JSON_CMD_VALUE_DEAL_HELP "helpme_done"
-#define JSON_CMD_VALUE_EDIT_MAP "edit_map"
-#define JSON_CMD_VALUE_EDIT_AREA "edit_area"
-#define JSON_CMD_VALUE_EDIT_STATION "edit_station"
-#define JSON_CMD_VALUE_EDIT_PATH "edit_path"
-#define JSON_CMD_VALUE_EDIT_CARD "edit_card"
-#define JSON_CMD_VALUE_EDIT_STAFFER "edit_staffer"
-#define JSON_CMD_VALUE_EDIT_VEHICLE "edit_vehicle"
+#define JSON_CMD_VALUE_DEAL_HELP "helpme_done"   //deal_help
 #define JSON_CMD_VALUE_REQUEST_ALL_POSTION "request_all_postion"
-#define JSON_CMD_VALUE_SET_LIGHT_COLOR "set_light_color"
-
 #define JSON_CMD_VALUE_REQUEST_ALL_DATA "req_all_data"
 #define JSON_CMD_VALUE_RESPONSE_ALL_DATA "resp_all_data"
-
 #define JSON_CMD_VALUE_CALL_CARD_START "call_card_start"
 #define JSON_CMD_VALUE_CALL_CARD_CANCEL "call_card_cancel"
+#define  JSON_CMD_VALUE_LEADER_ARRANGE "leader_arrange"
 //呼叫命令
 #define JSON_CMD_VALUE_CALL_CARD_REQUEST "call_card_req"
 #define JSON_CMD_VALUE_CALL_CARD_RESPONSE "call_card_resp"
@@ -64,10 +42,13 @@
 #define JSON_CMD_VALUE_LIGHTS_CTRL_REQUEST "lights_ctrl_req"
 #define JSON_CMD_VALUE_LIGHTS_CTRL_RESPONSE "lights_ctrl_res"
 
-#define JSON_KEY_NAME "name"
 #define JSON_KEY_ID "id"
 #define JSON_KEY_OP_TYPE "op_type"
+#define JSON_KEY_OP_TYPE_INSERT "INSERT"
+#define JSON_KEY_OP_TYPE_UPDATE "UPDATE"
+#define JSON_KEY_OP_TYPE_DELETE "DELETE"
 
+#define JSON_KEY_NAME "name"
 #define JSON_KEY_NAME_MAP "map"
 #define JSON_KEY_NAME_AREA "area"
 #define JSON_KEY_NAME_PATH "path"
@@ -80,9 +61,8 @@
 #define JSON_KEY_NAME_CHAMBER "chamber"
 #define JSON_KEY_NAME_SHIFT "shift"
 #define JSON_KEY_NAME_PATROL_TASK "patrol_task"
-#define JSON_KEY_OP_TYPE_INSERT "INSERT"
-#define JSON_KEY_OP_TYPE_UPDATE "UPDATE"
-#define JSON_KEY_OP_TYPE_DELETE "DELETE"
+#define JSON_KEY_NAME_RULES "rules"
+#define JSON_KEY_NAME_SETTING "setting"
 
 #define JSON_KEY_CALL_CARD_CALL_ID "call_id"
 #define JSON_KEY_CALL_CARD_CALL_TIME_OUT "call_time_out"
@@ -103,13 +83,7 @@
 #define JSON_KEY_CALL_LIGHT_LIGHTS "lights"
 #define JSON_KEY_CALL_LIGHT_ID "id"
 
-#define JSON_KEY_EDIT_MAP_ID "map_id"
-#define JSON_KEY_EDIT_AREA_ID "areaid"
-#define JSON_KEY_EDIT_READER_ID "stationid"
 #define JSON_KEY_EDIT_CARD_ID "cardid"
-#define JSON_KEY_EDIT_CARD_TYPE "cardtype"
-#define JSON_KEY_EDIT_STAFFER_ID "stafferid"
-#define JSON_KEY_EDIT_VEHICLE_ID "vehicleid"
 #define JSON_KEY_EDIT_EDIT_TYPE_ID "edittype"
 
 // 采集端调用接口
@@ -118,37 +92,20 @@
 #define JSON_KEY_USERNAME "user_name"
 #define JSON_KEY_PASSWORD "user_pass"
 #define JSON_VALUE_USERNAME "COLLECTOR"
-#define JSON_VALUE_PASSWORD "666666"
+#define JSON_VALUE_PASSWORD "666666"  //"666666"
 #define JSON_KEY_CARD_ID "card_id" //"卡号"
 #define JSON_KEY_CARD_TYPE_ID "card_type_id"
-#define JSON_KEY_CARD_NUM "number" //"编号"
-#define JSON_KEY_CARD_NAME "name" // "名称"
-#define JSON_KEY_CARD_WORKTYPE "work_type" // "类型"
-#define JSON_KEY_CARD_COMP "company" // "单位"
-#define JSON_KEY_CARD_DEPT "dept" // "部门"
 #define JSON_KEY_REC_TIME "rec_time" // "接收时间"
 #define JSON_KEY_DOWN_TIME "down_time" // "入井时间"
-#define JSON_KEY_UP_TIME "up_time" // "升井时间"
-#define JSON_KEY_ENTER_PARK_TIME "enter_park_time" // "回场时间"
-#define JSON_KEY_LEAVE_PARK_TIME "leave_park_time" // "出场时间"
 #define JSON_KEY_WORK_TIME "work_time" // "工作时间"
 #define JSON_KEY_ENTER_AREA_TIME "enter_area_time" // "进入区域时间"
-#define JSON_KEY_ENTER_READER_TIME "enter_reader_time" // "进入分站时间"
 #define JSON_KEY_CORDINATE_X "x"
 #define JSON_KEY_CORDINATE_Y "y"
 #define JSON_KEY_CORDINATE_Z "z"
 #define JSON_KEY_STATE "state" // "状态"
-#define JSON_KEY_STATE_DESC "state_desc" // "状态"
 #define JSON_KEY_STATE_MOVING "state_moving" // 运动状态
 #define JSON_KEY_STATE_BIZ "state_biz" // 业务状态
-#define JSON_KEY_ANGLE "angle" // "角度"
 #define JSON_KEY_MAP_ID "map_id" // "地图编号"
-#define JSON_KEY_MAP_NAME "map_name" // "地图名称"
-#define JSON_KEY_MAP_PATH "map_path" // "地图路径"
-#define JSON_KEY_MAP_HEIGHT "map_height" // "地图高度"
-#define JSON_KEY_MAP_WIDTH "map_width" // "地图宽度"
-#define JSON_KEY_MAP_SCALE "map_scale" // "地图比例"
-#define JSON_KEY_MAP_TYPE "map_type" // "地图类型"
 #define JSON_KEY_DEPT_ID "dept_id"
 #define JSON_KEY_SPEED "speed"	//速度
 #define JSON_KEY_LANDMARK_ID "landmark_id"
@@ -157,86 +114,21 @@
 
 // id, name, type, map_id
 #define JSON_KEY_AREA_ID "area_id" // "区域编号"
-#define JSON_KEY_AREA_TYPE "area_type" // "区域类型"
-#define JSON_KEY_AREA_NAME "area_name" // "区域名称"
 #define JSON_KEY_AREA_IS_SPECIAL "is_special_area" // "区域名称"
-#define JSON_KEY_AREA_X "area_x" // "区域坐标"
-#define JSON_KEY_AREA_Y "area_y" // 
-#define JSON_KEY_AREA_Z "area_z" // 
-#define JSON_KEY_AREA_R "area_radius" // "区域半径"
-// id, name, angle, x, y, z, type, map_id, area_id
-#define JSON_KEY_READER_ID "reader_id" // "分站编号"
-#define JSON_KEY_READER_NAME "reader_name" // "分站名称"
-#define JSON_KEY_READER_POS_STATE "reader_type" // "分站类型"
-#define JSON_KEY_READER_STATE "reader_state" // "分站状态"
-#define JSON_KEY_ANTENNA_ID "ant_id" // "天线编号"
-#define JSON_KEY_ANTENNA_NAME "ant_name" // "天线名称"
-#define JSON_KEY_DEV_MAP "dev_map"
-#define JSON_KEY_DEV_AREA "dev_area"
-#define JSON_KEY_DEV_READER "dev_reader"
-#define JSON_KEY_DEV_CARD "dev_card"
-#define JSON_KEY_DEV_TRAFFIC "dev_traffic"
-#define JSON_KEY_DEV_TURNOUT "dev_turnout"
-#define JSON_KEY_DEV_LOUDSPEEKER "dev_loudspeeker"
 // down_mine,up_mine
 #define JSON_CMD_VALUE_DOWN_MINE "down_mine"
 #define JSON_CMD_VALUE_UP_MINE "up_mine"
 #define JSON_CMD_VALUE_SPECIAL_AREA_UP_MINE "special_area_up_mine"
-#define JSON_CMD_VALUE_COUNTING "counting"
 #define JSON_CMD_VALUE_DEV_STATE "device_state"
-#define JSON_CMD_VALUE_ALARM "alarm"
 #define JSON_CMD_VALUE_EVENT "event"
 #define JSON_CMD_VALUE_CALL "CALL"
 #define JSON_CMD_VALUE_PUSH "PUSH"
-#define JSON_CMD_VALUE_USER "USER" //"USER"
-#define JSON_CMD_VALUE_WS_ERR "WS_ERR"
+#define JSON_CMD_VALUE_USER "USER"
 #define JSON_CMD_DRIVING_FACE_STATE "tunneller_stat"
 // pos_map
 #define JSON_CMD_VALUE_POS_MAP "pos_map"
-#define JSON_CMD_VALUE_POSITION_ALL "position_all"
-#define JSON_CMD_VALUE_STATISTIC "postition_statistic"
-#define JSON_KEY_POS_CARD "pos_card"
-#define JSON_KEY_POS_MAP "pos_map"
-// device state, stat_map
-#define JSON_KEY_DEV_STATE_MAP_ID "map_id"
-#define JSON_KEY_DEV_STATE_DEVICES "devices"
-#define JSON_KEY_DEV_STATE_DEVICE_ID "device_id"
-#define JSON_KEY_DEV_STATE_STATE "state"
-#define JSON_KEY_DEV_STATE_STATE_DESC "state_desc"
-#define JSON_KEY_DEV_STATE_DEVICE_TYPE_ID "device_type_id"
-#define JSON_KEY_DEV_STATE_TIME "time"
-//#define JSON_KEY_STAT_MAP_STAT_TRAFFIC "stat_traffic"
-//#define JSON_KEY_STAT_MAP_STAT_TURNOUT "stat_turnout"
-//#define JSON_KEY_STAT_MAP_STAT_LOUDSPEEKER "stat_loudspeeker"
-// counting
-#define JSON_KEY_COUNTING_COUNT_TOTAL "total" // 总卡数
-#define JSON_KEY_COUNTING_COUNT_VEHICLE "vehicle" // 总车数
-#define JSON_KEY_COUNTING_COUNT_PERSON "staff" // 总人数
-#define JSON_KEY_COUNTING_MAP_COUNT "maps"
-#define JSON_KEY_COUNTING_MAP_ID "id"
-#define JSON_KEY_COUNTING_MAP_COUNT_TOTAL "total" // 当前图中总数
-#define JSON_KEY_COUNTING_MAP_COUNT_PERSON "staff" // "map_count_vehicle" // 当前图车数
-#define JSON_KEY_COUNTING_MAP_COUNT_VEHICLE "vehicle"// "map_count_person" // 当前图车数
-#define JSON_KEY_COUNTING_AREA_COUNT "areas" 
-#define JSON_KEY_COUNTING_AREA_ID "id" 
-#define JSON_KEY_COUNTING_AREA_COUNT_TOTAL "total" // 区域总卡数
-#define JSON_KEY_COUNTING_AREA_COUNT_PERSON "staff" // 区域人数
-#define JSON_KEY_COUNTING_AREA_COUNT_VEHICLE "vehicle" // 区域车数
-#define JSON_KEY_COUNTING_DEPT_COUNT "depts" 
-#define JSON_KEY_COUNTING_DEPT_ID "id"
-//#define JSON_KEY_COUNTING_DEPT_NAME "dept_name"
-#define JSON_KEY_COUNTING_AREA_PERSON_COUNT "area_person" 
-#define JSON_KEY_COUNTING_DEPT_COUNT_TOTAL "total"
-#define JSON_KEY_COUNTING_DEPT_COUNT_VEHICLE "vehicle"
-#define JSON_KEY_COUNTING_DEPT_COUNT_PERSON "staff"
-#define JSON_KEY_COUNTING_SPECIAL_ERROR_TOTAL "special_error_total"
-#define JSON_KEY_REQ_COUNTS_USER "req_user"
-#define JSON_KEY_REQ_COUNTS_TYPE "count_type"
-#define JSON_KEY_REQ_COUNTS_TIME "req_time"
-
-// #define JSON_CMD_VALUE_REQUEST_COUNTS_INFO "count_detail_req"		//web端请求统计总数详细列表
-// #define JSON_KEY_RESPONSE_COUNTS_DETAIL "count_detail_resp"
 
+// 告警事件
 #define JSON_KEY_EVENT_EVENT_ID "event_id"
 #define JSON_KEY_EVENT_STATUS "status"
 #define JSON_KEY_EVENT_TYPE_ID "type_id"
@@ -252,10 +144,6 @@
 #define JSON_KEY_EVENT_LANDMARK_ID "lmid"
 #define JSON_KEY_EVENT_LANDMARK_DIRECTION "lmdirect"
 #define JSON_KEY_EVENT_LANDMARK_DISTANCE "lmdistance"
-
-#define JSON_CMD_VALUE_REQUEST_COUNTS_INFO "count_detail_req"		//web端请求统计总数详细列表
-#define JSON_KEY_RESPONSE_COUNTS_DETAIL "count_detail_resp"
-
 #define JSON_KEY_EVENT_READER_POS_CHANGE    "reader_pos_change"
 // alarm
 #define JSON_KEY_ALARM_OVER_COUNT_PERSON "over_count_person"
@@ -263,32 +151,9 @@
 #define JSON_KEY_ALARM_OVER_TIME_PERSON "over_time_person"
 #define JSON_KEY_ALARM_OVER_TIME_VEHICLE "over_time_vehicle"
 #define JSON_KEY_ALARM_OVER_SPEED_VEHICLE "over_speed_vehicle"
-#define JSON_KEY_ALARM_AREA_FORBIDDEN "area_forbidden"
-#define JSON_KEY_ALARM_AREA_OVER_TIME_PERSON "area_over_time_person"
-#define JSON_KEY_ALARM_AREA_OVER_TIME_VEHICLE "area_over_time_vehicle"
-#define JSON_KEY_ALARM_AREA_OVER_PERSON "area_over_person"
-#define JSON_KEY_ALARM_AREA_OVER_VEHICLE "area_over_vehicle"
-
-#define JSON_KEY_ALARM_GLOBAL "global"
-#define JSON_KEY_ALARM_ITEM "item"
-#define JSON_KEY_ALARM_DETAIL "detail"
-#define JSON_KEY_ALARM_MAX "max"
-#define JSON_KEY_ALARM_CURRENT "current"
-#define JSON_KEY_ALARM_AREA "areas"
-#define JSON_KEY_ALARM_AREA_ID "area_id"
 
-#define JSON_KEY_ALARM_ALARMS "alarms"
-#define JSON_KEY_ALARM_PERSON "person"
-#define JSON_KEY_ALARM_VEHICLE "vehicle"
-#define JSON_KEY_ALARM_ADHOC  "adhoc"
-
-#define JSON_KEY_ALARM_READER "readers"
-#define JSON_KEY_ALARM_READER_ID "reader_id"
-#define JSON_KEY_ALARM_TYPE_ID "alarm_type_id"
-#define JSON_KEY_ALARM_TYPE_NAME "alarm_type_name"
 #define JSON_KEY_ALARM_START_TIME "alarm_start_time"
 
-#define JSON_KEY_ALARM_STAFF "staff"
 #define JSON_KEY_ALARM_STAFFER_ID "staffer_id"
 #define JSON_KEY_ALARM_VEHICLE_ID "vehicle_id"
 
@@ -304,7 +169,7 @@
 #define JSON_KEY_ALARM_LIGHT_GROUP_NAME	"light_group_name"
 
 #define JSON_KEY_ALARM_TRAFFIC_RED_LIGHT "traffic_red_light"
-
+// 掘进面
 #define JSON_KEY_DRIVINGFACE_DIS "driving_face_moving_dis"
 #define JSON_KEY_DRIVINGFACE_WARNING_POINT_ID "driving_face_warning_point_id"
 #define JSON_KEY_DRIVINGFACE_WARNING_POINT_DIS "driving_face_warning_point_dis"

def.h

@@ -7,7 +7,7 @@
 //DB
 #define FILEPATH_SERVER_CONFIG "..\\config.ini"
 #define CONF_SECT_DB "DB"
-#define CONF_SECT_DB_BK "DB_2"
+#define CONF_SECT_DB_BK "DB2"
 #define CONF_DB_KEY_HOST "host"
 #define CONF_DB_KEY_USER "user"
 #define CONF_DB_KEY_PWD "password"
@@ -37,7 +37,11 @@
 #define CONF_SEND_JSON_POSION "interval_send_json_postion"
 #define CONF_SEND_JSON_COUNTING "interval_send_json_counting"
 #define CONF_SEND_JSON_ALARM "interval_send_json_alarm"
+#define CONF_WARNING_POINT_ALARM "interval_warning_point_alarm"
 #define CONF_SEND_JSON_DEVICE "interval_send_json_device"
+#define CONF_SEND_JSON_DRIVINGFACE "interval_send_json_drivingface"
+#define CONF_SEND_JSON_LEADER "interval_send_json_leader"
+#define CONF_LOAD_LEADER "interval_load_leader"
 #define CONF_SEND_CALLINFO_INTERVAL "send_call_interval"
 #define CONF_SEND_HELPINFO_INTERVAL "send_help_interval"
 #define CONF_SEND_WS_CONNECT_INTERVAL "ws_connect_inteval"

locate_algorithm.cpp

@@ -580,6 +580,72 @@ POS* LocateAlgorithm::Pos(ReaderPathMap rpm,int sta_num,int ant,double dist,INFO
 	return p;
 }
 
+std::shared_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<TOFReaderPathMap> trpm,int reader_id,int antenna_idx,double dist,TOF_REFER_DATA refer_data)
+{
+	std::shared_ptr<POS> p = std::make_shared<POS>();
+
+	double d[MAX_READER_TDOA_PATH_NUMS] = {0};
+	double xcross[MAX_READER_TDOA_PATH_NUMS] = {0};
+	double ycross[MAX_READER_TDOA_PATH_NUMS] = {0};
+
+	int seg_num = 0;
+	seg_num = trpm->find(reader_id)->second->nRealCalcPoints - 1;
+	//判断路径集的点数是否大于两个点，两点才可以构成线段路径
+	if(seg_num < 0 ){
+		return nullptr;
+	}
+
+	int j = 0;
+	int m = 0;
+	int nCounts = 0;
+	//对每一个线段所在的直线和以天线为圆心的圆求解，最多为两个解
+	for(int i = 0;i < seg_num;i++){
+		//如果线段两端点的坐标不存在，则寻找下一个线段
+		if(trpm->find(reader_id)->second->px[i] == -1 || trpm->find(reader_id)->second->px[i+1] == -1)
+		{
+			continue;
+		}
+
+		//求线段所在直线和分站readerid的antenna_idx天线为圆心，半径为dist的圆的两个交点
+		std::shared_ptr<SOLUTION> r = GetPos(trpm,reader_id,antenna_idx,dist,i);
+		//如果解不存在，则继续寻找下一个线段
+		if(r == nullptr || r->nCount <= 0){
+			continue;
+		}
+
+		int k = -1;
+		double c = 999999.9;
+		//如果解存在，则保存两个解
+		for(j = 0;j < r->nCount;j++){
+			//保存解
+			xcross[j] = r->x[j];
+			ycross[j] = r->y[j];
+			//计算解与参考分站中的天线坐标的距离distance
+			double d1 = xcross[j] - trpm->find(refer_data.nReaderId)->second->x[refer_data.nAntennaIndex];
+			double d2 = ycross[j] - trpm->find(refer_data.nReaderId)->second->y[refer_data.nAntennaIndex];
+			double distance = sqrt(pow(d1,2) + pow(d2,2));
+			d[j] = distance;
+		}
+
+		for (j = 0;j < r->nCount; j++)
+		{
+			if (d[j] < c)
+			{
+				c = d[j];
+				k = j;
+			}
+		}
+
+		if(c < p->pos_radius){
+			p->posx = xcross[k];
+			p->posy = ycross[k];
+			p->pos_radius = c;
+		}
+	}
+
+	return p;
+}
+
 std::shared_ptr<POS> LocateAlgorithm::TdoaLocate2d(std::shared_ptr<ReceiveDataMap> pRdm)
 {
 	if (pRdm->size() < 3)
@@ -1126,6 +1192,136 @@ SOLUTION* LocateAlgorithm::GetPos(ReaderPathMap rpm,int sta_num,int ant,double d
 	return result;
 }
 
+/*
+ *
+ * param
+ *		trpm
+ *		sta_num
+ *		ant
+ *		dist
+ *		i
+ *
+ * return
+ *
+*/
+std::shared_ptr<SOLUTION> LocateAlgorithm::GetPos(std::shared_ptr<TOFReaderPathMap> trpm,int reader_id,int antenna_idx,double dist,int seg_idx)
+{
+	std::shared_ptr<SOLUTION> s = std::make_shared<SOLUTION>();
+
+	double x1 = 0.0;
+	double y1 = 0.0;
+	double x2 = 0.0;
+	double y2 = 0.0;
+
+	double deta = 0.0;  //b^2 - 4*a*c;
+	int count = 0;	//方程解的个数
+
+	if(abs(trpm->find(reader_id)->second->px[seg_idx] - trpm->find(reader_id)->second->px[seg_idx + 1]) < ZERO_PRECISION){
+		//方程一的解
+		x1 = trpm->find(reader_id)->second->px[seg_idx];
+		y1 = trpm->find(reader_id)->second->y[antenna_idx] - dist;
+		x2 = trpm->find(reader_id)->second->px[seg_idx];
+		y2 = dist + trpm->find(reader_id)->second->y[antenna_idx];
+		count = 2;
+	}/*else if(abs(trpm->find(sta_num)->second->py[i] - trpm->find(sta_num)->second->py[i+1]) < ZERO_PRECISION){
+		y1 = y2 = trpm->find(sta_num)->second->py[i];
+		x1 = trpm->find(sta_num)->second->y[ant] - dist;
+		x2 = trpm->find(sta_num)->second->y[ant] + dist;
+		count = 2;
+	}*/else{
+		//计算斜率
+		double k = (trpm->find(reader_id)->second->py[seg_idx] - trpm->find(reader_id)->second->py[seg_idx + 1])/(trpm->find(reader_id)->second->px[seg_idx] - trpm->find(reader_id)->second->px[seg_idx + 1]);
+
+		//double b = trpm->find(reader_id)->second->y[antenna_idx] - k*trpm->find(reader_id)->second->x[antenna_idx];
+		double b = trpm->find(reader_id)->second->py[seg_idx] - k*trpm->find(reader_id)->second->px[seg_idx];
+		double A = pow(k,2) + 1;
+		double B = 2*k*(b - trpm->find(reader_id)->second->y[antenna_idx]) - 2*trpm->find(reader_id)->second->x[antenna_idx];
+		double C = pow(trpm->find(reader_id)->second->x[antenna_idx],2) + pow(b - trpm->find(reader_id)->second->y[antenna_idx],2) - pow(dist,2);
+		
+		deta = pow(B,2) - 4*A*C;
+		//方程二
+		//确保有两解的情况
+		//圆心为s[sta_num].x[ant],s[sta_num].y[ant];
+		//double a = pow(k,2) + 1;
+		//double b = 2*(k*(trpm->find(sta_num)->second->py[i] - k*trpm->find(sta_num)->second->px[i] - trpm->find(sta_num)->second->y[ant])- trpm->find(sta_num)->second->x[ant]);
+		//double d = trpm->find(sta_num)->second->py[i] - k * trpm->find(sta_num)->second->px[i] - trpm->find(sta_num)->second->y[ant]; 
+		////double b = 2*k*d - 2*trpm->find(sta_num)->second->px[i];
+		//double c = pow(trpm->find(sta_num)->second->x[ant],2) + pow(d,2) - pow(dist,2);
+
+		////根据deta = b^2 - 4*a*c 判断方程是否有解
+		//deta = pow(b,2) - 4*a*c; //
+		if(deta>0){
+			count = 2;
+		}else if(deta == 0){
+			count = 1;
+		}
+		else{
+			count = 0;
+		}
+
+		if(count == 0){
+			return NULL;
+		}
+
+		//得两解
+		x1 = -(B + sqrt(deta))/(2*A);
+		x2 = (-B + sqrt(deta) )/(2*A);
+		//x1 = -(b + sqrt(deta))/(2*a);
+		//x2 = (-b + sqrt(deta) )/(2*a);
+		y1 = k*x1 + trpm->find(reader_id)->second->py[seg_idx] - k*trpm->find(reader_id)->second->px[seg_idx];
+		y2 = k*x2 + trpm->find(reader_id)->second->py[seg_idx] - k*trpm->find(reader_id)->second->px[seg_idx];
+	}
+
+	double x[3] = {0,0,0};
+	double y[3] = {0,0,0};
+
+	x[0] = x1;
+	x[1] = x2;
+	y[0] = y1;
+	y[1] = y2;
+
+	int nValidCount = count;
+	if(count > 0){
+		for(int t = 0;t < count;t++){
+			if(x[t] < min(trpm->find(reader_id)->second->px[seg_idx],trpm->find(reader_id)->second->px[seg_idx+1])
+				||x[t] > max(trpm->find(reader_id)->second->px[seg_idx],trpm->find(reader_id)->second->px[seg_idx+1])
+				||y[t] < min(trpm->find(reader_id)->second->py[seg_idx],trpm->find(reader_id)->second->py[seg_idx+1])
+				||y[t] > max(trpm->find(reader_id)->second->py[seg_idx],trpm->find(reader_id)->second->py[seg_idx+1])){
+					x[t] = INVALID_COORDINATE;
+					y[t] = INVALID_COORDINATE;
+					nValidCount--;
+			}
+		}
+	}
+
+	s->nCount = nValidCount;
+	switch (s->nCount)
+	{
+	case 1:
+		for (int i = 0;i < count;i++)
+		{
+			if (x[i] != INVALID_COORDINATE && y[i] != INVALID_COORDINATE)
+			{
+				s->x[0] = x[i];
+				s->y[0] = y[i];
+				break;
+			}
+		}
+		break;
+	case 2:
+		for (int i = 0;i < s->nCount;i++)
+		{
+			s->x[i] = x[i];
+			s->y[i] = y[i];
+		}
+		break;
+	default:
+		break;
+	}
+
+	return s;
+}
+
 /*
  * TDOA算法实现
  * 函数名：Pos
@@ -1179,14 +1375,8 @@ std::unique_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<ReceiveDataMap> pRdm,s
 	f1.y = first->second->y;
 	f1.z = first->second->z;
 
-	//size_t nCount = 0;	//测试两个分站的定位
 	//从第二个开始遍历
 	for(;second != pRdm->end();++second){
-		//if (nCount > 0 && f1.reader_id > 300)
-		//{
-		//	break;
-		//}
-		//nCount++;
 		//获取第二个时间戳
 		ReceiveData f2;
 		f2.antenna_id = second->second->antenna_id;
@@ -1240,13 +1430,6 @@ std::unique_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<ReceiveDataMap> pRdm,s
 		std::shared_ptr<ReaderPath> pRP = trpm->find(f1.reader_id)->second->find(f2.reader_id)->second;
 
 		//如果和第一条分站存在地图集
-		/*tmp_dist_reader[nDistReaders].reader_id = f2.reader_id;
-		tmp_dist_reader[nDistReaders].x = f2.x;
-		tmp_dist_reader[nDistReaders].y = f2.y;
-		tmp_dist_reader[nDistReaders].z = f2.z;
-		tmp_dist_reader[nDistReaders].rec_time_stamp = f2.rec_time_stamp;
-		nDistReaders++;*/
-
 		tmp_reader[nNoReaderPathIdx].reader_id = f2.reader_id;
 		tmp_reader[nNoReaderPathIdx].x = f2.x;
 		tmp_reader[nNoReaderPathIdx].y = f2.y;
@@ -1356,7 +1539,7 @@ std::unique_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<ReceiveDataMap> pRdm,s
 		//如果定位坐标在分站附近，需要判断此分站是否为special，如果为special则接受此定位结果
 		for(ReceiveDataMap::iterator it = pRdm->begin();it!=pRdm->end();++it){
 			double dist = sqrt(pow(res[0].x - it->second->x,2) + pow(res[0].y - it->second->y,2));	
-			if(dist<4){
+			if(dist < 4){
 				if(it->second->special == 0){
 					r.reason = ALGO_FAILED_CONDITION_12;
 					ALGORITHM_FAILED(ALGO_FAILED_CONDITION_12);
@@ -1384,7 +1567,7 @@ std::unique_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<ReceiveDataMap> pRdm,s
 
 				double dif = fabs(dif1 - dif2);
 
-				if(dif>10){//4
+				if(dif > 10){//4
 					r.reason = ALGO_FAILED_CONDITION_13;
 					ALGORITHM_FAILED(ALGO_FAILED_CONDITION_13);
 					bValid = false;
@@ -1422,8 +1605,8 @@ std::unique_ptr<POS> LocateAlgorithm::Pos(std::shared_ptr<ReceiveDataMap> pRdm,s
 			}
 		}
 
-		if(pRdm->size()>=3){
-			if(pos->dDiff[r_idx] < 6){   //4
+		if(pRdm->size() >= 3){
+			if(pos->dDiff[r_idx] < NEAR_READER){
 				r.x = res[r_idx].x;
 				r.y = res[r_idx].y;
 				r.z = res[r_idx].z;
@@ -1991,9 +2174,14 @@ double LocateAlgorithm::GetTriangleArea(_point p0,_point p1,_point p2)
 /*
  * 点P是否在以start_p和end_p的线段上
  *
- * 
+ * param
+ *		p			识别点
+ *		start_p		线段端点
+ *		end_p		线段终点
+ *
  * return
  *		在线段上返回true，否则返回false
+ *
 */
 bool LocateAlgorithm::IsInLine(_point p,_point start_p,_point end_p)
 {
@@ -2114,12 +2302,14 @@ int LocateAlgorithm::CalcTdoaPosition(std::shared_ptr<ReceiveDataMap> pRdm,std::
 		}	
 	}
 
+	//定位数据条数不够2条
 	if (pRdm->size() < 2)
 	{
 		return ALGO_CALC_SOLUTION;
 	}
 
-	//先做第一遍筛选，根据前三个分站计算坐标，如果无解，做第二遍筛选
+	//先做第一遍筛选，
+	//根据前三个分站计算坐标，如果有解，直接返回；如果无解，做第二遍筛选
 	bool bNoSolution = true;
 	std::unique_ptr<POS> first_pos = LocateAlgorithm::Pos(pRdm,trpm);
 	if (first_pos->posx != INVALID_COORDINATE && first_pos->posy != INVALID_COORDINATE)
@@ -2131,12 +2321,14 @@ int LocateAlgorithm::CalcTdoaPosition(std::shared_ptr<ReceiveDataMap> pRdm,std::
 		return 0;
 	}
 
+	//如果无解且数据条数小于等于2，则返回选择失败
+	//主要是筛选两条数据，但无法定位的情况
 	if (bNoSolution && pRdm->size() <= 2)
 	{
 		return ALGO_CALC_NO_SOLUTION_WITH_TWO_DATA;
 	}
 
-	//执行第二遍筛选
+	//开始执行第二遍筛选
 	ReceiveDataMap::iterator first = pRdm->begin();
 	ReceiveDataMap::iterator second = first;
 	if (bNoSolution)
@@ -2147,14 +2339,14 @@ int LocateAlgorithm::CalcTdoaPosition(std::shared_ptr<ReceiveDataMap> pRdm,std::
 		//在第一步时，当103和104，103和102的结果被判定不合格而无解
 		//此处偏移3，即会导致301被跳过
 		//所以改为重新对后续求所有解
+		//偏移到第二个元素
 		std::advance(second,1);	
 	} 
 
-	//偏移到第二个元素
-	//std::advance(second,1);
+	//检查偏移后的元素是否存在
 	if (second == pRdm->end())
 	{
-		//偏移后找不到元素
+		//偏移后找不到元素，返回错误
 		return ALGO_CALC_ONE_DATA;
 	}
 
@@ -2391,7 +2583,7 @@ bool LocateAlgorithm::CheckPosInValid(POS* pos,ReceiveDataMap* pRdm,double dScal
 		int i = 0;
 		for(ReceiveDataMap::iterator it = pRdm->begin();it!=pRdm->end();++it,i++){
 			dist[i] = sqrt(pow(pos->posx - it->second->x,2)+pow(pos->posy - it->second->y,2));
-			if(fabs(dist[i]) < 4){
+			if(fabs(dist[i]) < NEAR_READER){
 				//误差在范围内，判断此分站是否属于特殊分站
 				if(it->second->special){
 					bRet = false;

locate_algorithm.h

@@ -42,6 +42,8 @@ public:
 	//TOFËã·¨º¯Êý
 	static POS* Pos(ReaderPathMap rpm,int sta_num,int ant,double dist,INFO_PRE info_pre);
 	static SOLUTION* GetPos(ReaderPathMap rpm,int sta_num,int ant,double dist,int i);
+	static std::shared_ptr<POS> Pos(std::shared_ptr<TOFReaderPathMap> trpm,int reader_id,int antenna_idx,double dist,TOF_REFER_DATA refer_data);
+	static std::shared_ptr<SOLUTION> GetPos(std::shared_ptr<TOFReaderPathMap> trpm,int reader_id,int antenna_idx,double dist,int seg_idx);
 	//TDOAËã·¨º¯Êý
 	static std::unique_ptr<POS> Pos(std::shared_ptr<ReceiveDataMap> pRdm,std::shared_ptr<TDOAReaderPathMap> trpm);
 	static std::unique_ptr<POS> LocatePos(std::shared_ptr<ReceiveDataMap> pRdm,std::shared_ptr<TDOAReaderPathMap> trpm);

log_def.h

@@ -14,10 +14,13 @@
 #define LOG_INIT_LEVEL "初始化职务级别信息"
 #define LOG_INIT_CARD "初始化标识卡信息"
 #define LOG_INIT_STAFF "初始化人员信息"
+#define LOG_INIT_LEADER_ARRANGE "初始化领导带班信息"
+#define LOG_INIT_ATT_AREA "初始化考勤区域信息"
 #define LOG_INIT_VEHICLE "初始化车辆信息"
 #define LOG_INIT_ADHOC "初始化自组网信息"
 #define LOG_INIT_MAP_PATH "初始化地图路径信息"
-#define LOG_INIT_READER_PATH "初始化分站路径信息"
+#define LOG_INIT_TDOA_READER_PATH "初始化Tdoa分站路径信息"
+#define LOG_INIT_TOF_READER_PATH "初始化Tof分站路径信息"
 #define LOG_INIT_MAP "初始化地图信息"
 #define LOG_INIT_AREA "初始化区域信息"
 #define LOG_INIT_READER "初始化分站信息"

mylog/ExRollingFileAppender.h

@@ -49,11 +49,11 @@ class ExRollingFileAppender : public RollingFileAppender{
 public:
 	ExRollingFileAppender(const std::string& name, 
 		const std::string& fileName,
-		size_t maxFileSize = 10*1024*1024, 
+		size_t maxFileSize = 1*1024*1024, //lemon 2017/08/04
 		unsigned int maxBackupIndex = 1,
 		bool append = true,
-		mode_t mode = 00644){
-			RollingFileAppender(name,fileName,append,mode);
+		mode_t mode = 00644):RollingFileAppender(name,fileName,append,mode){
+			//RollingFileAppender(name,fileName,append,mode);
 			_maxBackupIndex = maxBackupIndex > 0 ? maxBackupIndex : 1;
 			_maxBackupIndexWidth = (_maxBackupIndex > 0) ? log10((float)_maxBackupIndex)+1 : 1;
 			_maxFileSize = maxFileSize; 

mylog/MyLog.cpp

@@ -10,7 +10,7 @@ MyLog::MyLog(FILE_TYPE type)
 	curFileCount = 0;
 	strExeDir = GetExeDir();
 
-	if (fileType >= 0 && fileType < FILE_TYPE_TOTLA) {
+	if (fileType >= 0 && fileType < FILE_TYPE_TOTAL) {
 		status = false;
 		InitLogConfig();
 		flag = true;
@@ -28,7 +28,7 @@ MyLog::MyLog(FILE_TYPE type,bool status)
 	this->status = status;
 	strExeDir = GetExeDir();
 
-	if (fileType >= 0 && fileType < FILE_TYPE_TOTLA) {
+	if (fileType >= 0 && fileType < FILE_TYPE_TOTAL) {
 		InitLogConfig();
 		flag = true;
 	}	
@@ -44,14 +44,11 @@ int MyLog::WriteLog(const std::string msg)
 	pCategory->info(msg.c_str());
 
 	//如果日志文件超过大小，则开启新文件名
-	if (false)
+	if (getCurTime() != m_Lasttime)
 	{
-		curFileCount++;
-		curFileName = GetFileName();
-
-		pAppender = new log4cpp::FileAppender("default", curFileName.c_str());
-		pAppender->setLayout(pLayout);
-		pCategory->addAppender(pAppender);
+		m_Lasttime = getCurTime();
+		std::string filename = GetFileName();
+		SetAppender(filename);
 	}
 
 	return 0;
@@ -89,7 +86,7 @@ int MyLog::test()
 
 	bRet = IsDirExist(dir);
 	if (!bRet) {
-		CreateDir(dir);
+		CreateDir(dir.c_str());
 	}
 
 	return 0;
@@ -98,9 +95,15 @@ int MyLog::test()
 int MyLog::InitLogConfig()
 {
 	std::string name = my_log_file_name[fileType];
-	std::string filename = strExeDir + "log/" + GetFileName();
+	
 	std::string str_category = my_log_file_name[fileType] + "_category";
-
+	m_Lasttime = getCurTime();
+	std::string filepath = strExeDir + "log\\" + m_Lasttime + "\\";
+	if (!IsDirExist(filepath))
+	{
+		CreateDir(filepath.c_str());
+	}
+	std::string filename = filepath + GetFileName();
 	pLayout = new log4cpp::PatternLayout();
 	/*
 	%c category；
@@ -124,6 +127,7 @@ int MyLog::InitLogConfig()
 	//第四个参数表示备份文件最大数
 	//第五个参数表示缓冲立即刷新
 	pAppender = new log4cpp::RollingFileAppender(name.c_str(), filename.c_str(),MAX_FILE_SIZE,MAX_BACKUP_COUNTS,true);
+
 	pAppender->setLayout(pLayout);
 
 	pCategory = &(log4cpp::Category::getInstance(str_category.c_str()));
@@ -158,11 +162,47 @@ bool MyLog::IsDirExist(std::string path)
 	return bRet;
 }
 
-bool MyLog::CreateDir(std::string path)
+bool MyLog::CreateDir(const char * pDir)
 {
-	std::string cmd = "md " + path;
-	system(cmd.c_str());//创建一个文件夹 
-
+	//std::string cmd = "md " + path;
+	//system(cmd.c_str());//创建一个文件夹 
+	int i = 0;  
+	int iRet;  
+	int iLen;  
+	char* pszDir;  
+
+	if(NULL == pDir)  
+	{  
+		return 0;  
+	}  
+
+	pszDir = strdup(pDir);  
+	iLen = strlen(pszDir);  
+
+	// 创建中间目录  
+	for (i = 0;i < iLen;i ++)  
+	{  
+		if (pszDir[i] == '\\' || pszDir[i] == '/')  
+		{   
+			pszDir[i] = '\0';  
+
+			//如果不存在,创建  
+			iRet = ACCESS(pszDir,0);  
+			if (iRet != 0)  
+			{  
+				iRet = MKDIR(pszDir);  
+				if (iRet != 0)  
+				{  
+					return -1;  
+				}   
+			}  
+			//支持linux,将所有\换成/  
+			pszDir[i] = '/';  
+		}   
+	}  
+
+	iRet = MKDIR(pszDir);  
+	free(pszDir);  
 	return true;
 }
 
@@ -190,11 +230,21 @@ std::string MyLog::int2string(int value)
 int MyLog::SetAppender(const char* filename)
 {
 	std::string name = my_log_file_name[fileType];
-	std::string strFileName = strExeDir + "log/" + filename;
+	//std::string strFileName = strExeDir + "log/" + filename;
+	std::string filepath = strExeDir + "log/" + m_Lasttime + "/";
+	if (!IsDirExist(filepath))
+	{
+		CreateDir(filepath.c_str());
+	}
+	std::string strFileName = filepath + filename;
 
 	pCategory->removeAppender(pAppender);
 
 	pAppender = new log4cpp::RollingFileAppender(name.c_str(), strFileName.c_str(),MAX_FILE_SIZE,MAX_BACKUP_COUNTS,true);
+	//need malloc again 
+	pLayout = new log4cpp::PatternLayout();
+	pLayout->setConversionPattern(log_file_pattern[status]);
+
 	pAppender->setLayout(pLayout);
 
 	pCategory->setAppender(pAppender);
@@ -234,11 +284,9 @@ long MyLog::GetFileSize()
 
 	return size;
 }
-
-std::string MyLog::GetFileName()
+std::string MyLog::getCurTime()
 {
-	//日志文件格式为日期 + 计数 + 后缀（.log）
-	std::string stringDate = "";
+	std::string stringDate;
 	char chDate[255] = {0};
 	time_t today;
 	tm* t = new tm;
@@ -248,11 +296,18 @@ std::string MyLog::GetFileName()
 
 	strftime(chDate, 255, "%Y%m%d", t);
 	stringDate = chDate;
-	//curFileName = my_log_file_name[fileType] + "_" + curDate + "_" + int2string(curFileCount) + ".log";
-	curFileName = my_log_file_name[fileType] + "_" + stringDate + ".log";
-	
 	if (t) {
 		delete t;
 	}
+	return stringDate;
+}
+std::string MyLog::GetFileName()
+{
+	//日志文件格式为日期 + 计数 + 后缀（.log）
+	std::string stringDate = "";
+	stringDate = getCurTime();
+	//curFileName = my_log_file_name[fileType] + "_" + curDate + "_" + int2string(curFileCount) + ".log";
+	curFileName = my_log_file_name[fileType] + "_" + stringDate + ".log";
+
 	return curFileName;
 }

mylog/MyLog.h

@@ -1,9 +1,6 @@
 #pragma once
-#ifndef MYLOG_H
-#define MYLOG_H
-
+//日志还需要改进的地方包括：1.线程输出；2.日志内容从缓冲区申请内存放入消息，并还给缓冲区
 #include <Windows.h>
-
 #include <string>
 #include <memory>
 #include <time.h>
@@ -18,27 +15,44 @@
 #include <log4cpp\BasicLayout.hh>
 #include <log4cpp\PatternLayout.hh>
 #include <log4cpp\Priority.hh>
-
 #include <log4cpp\RollingFileAppender.hh>
 #include <log4cpp\DailyRollingFileAppender.hh>
 
+#ifdef _WIN32  
+#include <direct.h>  
+#include <io.h>  
+#elif _LINUX  
+#include <stdarg.h>  
+#include <sys/stat.h>  
+#endif  
+#ifdef _WIN32  
+#define ACCESS _access  
+#define MKDIR(a) _mkdir((a))  
+#elif _LINUX  
+#define ACCESS access  
+#define MKDIR(a) mkdir((a),0755)  
+#endif  
+
 #define MAX_FILE_SIZE 200*1024*1024
-#define MAX_BACKUP_COUNTS 10
+#define MAX_BACKUP_COUNTS 20
 
 enum FILE_TYPE {
 	RAW_S = 0,
 	SYNC_S,
 	PARSE_S,
 	DIST_S,
+	DISTX_S,
 	DISTEX_S,
 	DISTXX_S,
+	DIST_TOF_S,
+	LOCATE_TOF_S,
 	JSON_S,
 	JSON_R,
 	SQL_S,
 	SYS_S,
 	KALMAN_S,
 	ALGO_S,
-	FILE_TYPE_TOTLA
+	FILE_TYPE_TOTAL
 };
 
 const std::string my_log_file_name[] = {
@@ -46,8 +60,11 @@ const std::string my_log_file_name[] = {
 	"sync_s",
 	"parse_s",
 	"dist_s",
+	"distx_s",
 	"distex_s",
 	"distxx_s",
+	"dist_tof_s",
+	"locate_tof_s",
 	"json_s",
 	"json_r",
 	"sql_s",
@@ -83,10 +100,10 @@ private:
 	//以下函数考虑移出本类
 	std::string GetExeDir();		//获得exe程序所在目录
 	bool IsDirExist(std::string path);		//检查目录是否存在
-	bool CreateDir(std::string path);		//创建目录
+	bool CreateDir(const char* path);		//创建目录
 	std::string TCHAR2string(TCHAR* tch);
 	std::string int2string(int value);
-
+	std::string getCurTime();
 public:
 	int SetAppender(const char* filename);
 	int SetAppender(std::string filename);
@@ -110,10 +127,9 @@ private:
 
 	std::string curFileName;
 	int curFileCount;
-
+	std::string m_Lasttime;
+	std::string m_Curtime;
 	log4cpp::Appender* pAppender;
 	log4cpp::PatternLayout* pLayout;
 	log4cpp::Category* pCategory;
-};
-
-#endif
+};

mylog/log_module.cpp

@@ -9,7 +9,7 @@ int Log::init_log_module()
 {
 	clear();
 
-	for (int i = 0; i < FILE_TYPE_TOTLA; i++)
+	for (int i = 0; i < FILE_TYPE_TOTAL; i++)
 	{
 		std::shared_ptr<MyLog> log = std::make_shared<MyLog>((FILE_TYPE)i);
 		vtLog.push_back(log);
@@ -22,7 +22,7 @@ int Log::init_log_module()
 
 int Log::write_log(FILE_TYPE fileType,const std::string& content)
 {
-	if (fileType > FILE_TYPE::FILE_TYPE_TOTLA)
+	if (fileType > FILE_TYPE::FILE_TYPE_TOTAL)
 	{
 		return 1;
 	}
@@ -44,14 +44,13 @@ int Log::write_log(FILE_TYPE fileType,const std::string& content)
 	{
 		(*it)->WriteLog(content);
 	}
-	//vtLog[fileType]->WriteLog(content);
 
 	return 0;
 }
 
 int Log::write_log(FILE_TYPE fileType,const char* pValue,bool status)
 {
-	if (fileType > FILE_TYPE::FILE_TYPE_TOTLA)
+	if (fileType > FILE_TYPE::FILE_TYPE_TOTAL)
 	{
 		return 1;
 	}
@@ -93,7 +92,7 @@ int Log::write_log(FILE_TYPE fileType,const char* pValue)
 
 int Log::write_log(FILE_TYPE fileType,const std::string& content,bool status)
 {
-	if (fileType > FILE_TYPE::FILE_TYPE_TOTLA)
+	if (fileType > FILE_TYPE::FILE_TYPE_TOTAL)
 	{
 		return 1;
 	}

system_basic_info/SystemAnalysis.h

@@ -272,8 +272,8 @@ typedef enum StationSyncBasicBranch
 	LOCATION_SYSTEM_BRANCH_264,       //used
 	LOCATION_SYSTEM_BRANCH_265,       //used
 	LOCATION_SYSTEM_BRANCH_266,       //used
-	LOCATION_SYSTEM_BRANCH_267,
-	LOCATION_SYSTEM_BRANCH_268,
+	LOCATION_SYSTEM_BRANCH_267,		  //used
+	LOCATION_SYSTEM_BRANCH_268,       //used
 	LOCATION_SYSTEM_BRANCH_269,
 	LOCATION_SYSTEM_BRANCH_270,
 	LOCATION_SYSTEM_BRANCH_271,