server/card_base.cpp

#include <memory>
#include <message.h>
#include "card_message_handle.h"
#include "card_person.h"
#include "card_car.h"
#include "config_file.h"
#include "select_tool.h"
#include "module_service/module_mgr.h"
#include "websocket/wsClientMgr.h"
#include "websocket/wsTimerThread.h"
#include "his_location.h"
#include "event.h"
#include "module_service/module_call.h"
#include "mine.h"
#include "common_tool.h"
#include "ant.h"
#include "area.h"
#include "loc_point.h"
#include "loc_message.h"
#include "module_service/module_traffic_light_manager.h"
#include "db/db_tool.h"
#include "tool_time.h"
#include "tool_byte.h"
#include "struct_def.h"
#include "load_raw.h"
#include "tunnel.h"

extern config_file config;
card_location_base::card_location_base(const std::string&type,uint32_t id,uint16_t dis,int16_t t,int32_t deptid,int32_t level_id,uint32_t cid)
	:card(id, dis, t, deptid, level_id, cid)
    ,m_display_old(dis)
{
    select_tool_manage::instance()->create_tool(type, m_sel_tool, m_smo_tool);
	m_his_location_card.reset(new location_card(m_id, m_type, cid));

    m_cb_pdoa.set_capacity(5);
    m_cb_tof.set_capacity(5);
    m_cb_point.set_capacity(5);

    for(int index = 0; index < 5; ++index){
        m_cb_pdoa.push_back(100);
        m_cb_tof.push_back(0);
        m_cb_point.push_back(point(0,0));
    }

	m_cb_stream_idx.set_capacity(2);
	m_cb_stream_idx.push_back(0);
	m_cb_stream_idx.push_back(0);
}

void card_location_base::do_status(int st)
{
	time_t now = time(0);
	//bool   help_flag = false;

	log_info("[help-battery] card_id=%d, help_bit=%d, status=%d", m_id, m_help_bit, st);
	// 呼救
	if((m_help_bit & 1) && (st & STATUS_HELP))
	{
		//      1111111111
		//               ^
		m_help_last_time = now;
	}
	else if((m_help_bit & 1) && (st & STATUS_HELP)==0)
	{
		//      11111111100000
		//               ^
		m_help_bit<<=1;
	}
	else if((m_help_bit & 1)==0 && (st & STATUS_HELP))
	{
		//      00000000011111
		//               ^
		// 呼救开始
		if((m_help_bit&0x3)==2)
		{
			//log_warn("[help-battery] handle_m_help, card_id=%d",m_id);
			//help_flag=true;
		}

		m_help_last_time = now;
		m_help_bit<<=1;
		m_help_bit|=1;

		log_info("[help-battery] begin help, card_id=%d, help_bit=%d, status=%d", m_id, m_help_bit, st);
	}
	else 
	{
		//      11111111100000
		//                   ^
		// 呼救结束后持续1分钟                   
		if(now - m_help_last_time > 60)
		{
			m_help_bit = 0;
			log_info("[help-battery] end help, card_id=%d, help_bit=%d, status=%d", m_id, m_help_bit, st);
		}
	}

	/*if(!help_flag)
	{
		st = st & (0xFFFFFFFF ^ STATUS_HELP);
	}*/

	if((STATUS_POWER_LOWER_SERIOUS & st) != 0)
	{
		m_pwr_stat = STATUS_POWER_LOWER_SERIOUS;
	}
	else
	{
		m_pwr_stat = 0;
	}

    module_mgr::do_status((STATUS_CARD)st, m_id, m_type);
}

//写入历史轨迹
void card_location_base::make_his_location(uint64_t t,const point & pt,bool bclose /*= false*/)
{
	int area_id = 0, map_id = 0, site_id = 0;
    double scale = 0.0;
	if(auto site_ptr = get_area_tool()->m_site)
	{
		area_id = site_ptr->m_area_id;
		map_id  = site_ptr->m_map_id;
		site_id = site_ptr->m_id;
        scale   = site_ptr->m_scale;
	}
 
	auto mine_ptr = get_mine_tool();
	if(m_time < mine_ptr->get_down_time())
	{
		return;
	}
	m_his_location_card->push(t, pt, area_id, map_id, site_id, bclose);
    m_his_location_card->insert(t, pt, area_id, map_id, site_id, scale);
}

void card_location_base::make_his_location_simplify(uint64_t t, const loc_point & pt)
{
	m_his_location_card->insert_simplify(pt, t);
}

void card_location_base::make_his_location_cell_card(uint64_t t, const loc_point & pt)
{
	m_his_location_card->insert_cell_card(pt, t);
}

void card_location_base::make_his_location_cell_reader(uint64_t t, const loc_point & pt)
{
	m_his_location_card->insert_cell_reader(pt, t);
}

float get_pdoa(const double poa[], const double& offset)
{
	if (poa == nullptr) {
		return -10.0;
	}

	float poa1 = poa[0];
	float poa2 = poa[1];
	//float poa3 = poa[2];

	float pdoa = poa2 - poa1 - offset;
	while (pdoa >= TPI) {
		pdoa -= TPI;
	}

	while (pdoa < 0) {
		pdoa += TPI;
	}

	pdoa -= PI;

	return pdoa;
}

//坐标点输入业务入口
/*
定位的逻辑处理
车辆和人员都是走这个接口，然后分别进行处理。
输入：
vp 定位结果（硬件的原始位置数据）
lm 定位消息缓存区，用于tof，pdoa 
is_v_map 是否为车辆地图
输出：
point	m_v_point;			//车辆定位系统的定位结果
定位结果相关的一些成员变量如：x、y
姿态：m_stat
人员定位结果（包含人员地图定位结果（x、y）和车辆地图定位结果m_v_point）发给WEB的server
车辆将定位结果（车辆地图定位结果）和姿态发送给WEB的server
Added by zengminguo
*/
void card_location_base::on_location(const std::vector<point>&vp, const std::vector<loc_message> &lm, bool is_v_map)
{
	m_isVehicleMap = false;
	if (is_vehicle())
	{
		if (!is_v_map)
		{
			return;
		}
	}
	if (is_person())
	{
		if (is_v_map)
		{
			m_isVehicleMap = true;
		}
	}


	if (m_last_site_id != lm[0].m_sit->m_id)
	{
		m_deque_speed.clear();
	}

    loc_point pt = m_sel_tool->select_solution(vp, lm);
    //pt.y = pt.y;
    
	auto site_ptr = get_area_tool()->m_site;
	int sid = 0;
	if(site_ptr)
        sid = site_ptr->m_id;
	if(pt.m_useless)
	{
		if (is_person())
		{
			if (!is_v_map)
			{
				x = tool_other::round(pt.x, 3);
				y = tool_other::round(pt.y, 3);
			}
			else
			{
				int cell_index_diff = int(pt.m_dist);
				m_v_point.x = tool_other::round(pt.x, 3);
				m_v_point.y = tool_other::round(pt.y, 3);
				log_info("useful loc m_v_point: type=%d, card=%d, site=%d, ct=%d, timestamp=%llu, x=%f, y=%f, speed=%.2f, acc=%.2f", m_type, m_id, sid, m_ct, m_time, m_v_point.x, m_v_point.y, m_speed, lm[0].m_acc);
				pt.m_site_cell_index = lm[0].m_sit->m_cell_index;
				int cell_index_current = pt.m_site_cell_index - cell_index_diff;
				m_v_cell_index = cell_index_current;
				return;
			}
		}
		else if (is_vehicle())
		{
			if (is_v_map)
			{
				x = tool_other::round(pt.x, 3);
				y = tool_other::round(pt.y, 3);
			}
			else
			{
				return;
			}
		}

		// 姿态判断
		if (is_vehicle())
		{	
			if (m_stat_last == ENUM_STATUS_BACK)
			{
				m_stat = ENUM_STATUS_BACK;
			}
			if (m_speed > 1 && m_stat_last != ENUM_STATUS_BACK)
			{
				m_stat = ENUM_STATUS_FORWARD;
			}

			if (m_stat_last == ENUM_STATUS_FORWARD ||
				m_stat_last == ENUM_STATUS_SPEED_UP ||
				m_stat_last == ENUM_STATUS_SPEED_DOWN
				)
			{
				m_stat = ENUM_STATUS_FORWARD;
			}
			if (m_stat_last == ENUM_STATUS_LEFT ||
				m_stat_last == ENUM_STATUS_RIGHT)
			{
				m_stat = m_statusBeforeTurning;
			}
			if ((lm[0].m_acc <= -0.009 && m_stat_last == ENUM_STATUS_STATIC) || m_stat_last == ENUM_STATUS_BACK)
			{
				m_stat = ENUM_STATUS_BACK;
			}
			if (lm[0].m_acc >= 0.009 &&
				(m_stat_last == ENUM_STATUS_FORWARD ||
					m_stat_last == ENUM_STATUS_SPEED_UP ||
					m_stat_last == ENUM_STATUS_SPEED_DOWN ||
					m_stat_last == ENUM_STATUS_STATIC))
			{
				m_stat = ENUM_STATUS_SPEED_UP;
			}
			if (lm[0].m_acc <= -0.009 &&
				(m_stat_last == ENUM_STATUS_FORWARD ||
					m_stat_last == ENUM_STATUS_SPEED_UP ||
					m_stat_last == ENUM_STATUS_SPEED_DOWN ||
					(m_speed_last - m_speed > 0.5)))
			{
				m_stat = ENUM_STATUS_SPEED_DOWN;
			}

			if (lm[0].m_rav > 0)
			{
				if (m_stat_last == ENUM_STATUS_LEFT)
				{
				}
				else
				{
					m_statusBeforeTurning = m_stat_last;
				}
				m_stat = ENUM_STATUS_LEFT;
			}
			if (lm[0].m_rav < 0)
			{
				if (m_stat_last == ENUM_STATUS_RIGHT)
				{
				}
				else
				{
					m_statusBeforeTurning = m_stat_last;
				}
				m_stat = ENUM_STATUS_RIGHT;
			}

			if (m_stat_last != ENUM_STATUS_BACK)
			{
				if (lm[0].m_acc == 0 && lm[0].m_rav == 0 && m_speed <= 1)
				{
					m_stat = ENUM_STATUS_STATIC;
				}
			}
			else
			{
				if (lm[0].m_acc == 0 && lm[0].m_rav == 0 && m_speed <= 0.3)
				{
					m_stat = ENUM_STATUS_STATIC;
				}
			}

			switch (m_stat)
			{
			case ENUM_STATUS_STATIC:
				log_info("[car-motion] card_id=%d, val=%d 静止 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_MOVE:
				log_info("[car-motion] card_id=%d, val=%d 移动 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_FORWARD:
				log_info("[car-motion] card_id=%d, val=%d 前进 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_BACK:
				log_info("[car-motion] card_id=%d, val=%d 后退 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_LEFT:
				log_info("[car-motion] card_id=%d, val=%d 左转 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_RIGHT:
				log_info("[car-motion] card_id=%d, val=%d 右转 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_SPEED_UP:
				log_info("[car-motion] card_id=%d, val=%d 加速 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			case ENUM_STATUS_SPEED_DOWN:
				log_info("[car-motion] card_id=%d, val=%d 减速 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			default:
				log_info("[car-motion] card_id=%d, val=%d 未知 lm[0].m_acc=%.2f lm[0].m_rav=%d m_speed=%.2f", m_id, m_stat, lm[0].m_acc, lm[0].m_rav, m_speed);
				break;
			}
			m_speed_last = m_speed;
			m_stat_last = m_stat;

			pt.m_stat = m_stat;

			pt.m_cid = lm[0].m_card_id;
			pt.m_sid = lm[0].m_sit->m_id;
			pt.m_site_cell_index = lm[0].m_sit->m_cell_index;

			std::string str_time = "";
			if (load_raw::m_is_history)
			{
				
				str_time = load_raw::m_vec_date[load_raw::m_index];
			}

			double pdoa = get_pdoa(lm[0].m_poa, lm[0].m_sit->m_pdoa_offset);

			int cell_index_diff = int(pt.m_dist);

			

			while (m_deque_speed.size() >= 5)
			{
				m_deque_speed.pop_front();
			}

			m_deque_speed.push_back(pt.m_speed);

			double speed_avg = 0.0;
			for (auto iter = m_deque_speed.begin(); iter != m_deque_speed.end(); iter++)
			{
				speed_avg += *iter;
			}
			speed_avg /= m_deque_speed.size();

			point point_cell;

			int cell_index_current = pt.m_site_cell_index - cell_index_diff;

			s_tunnel.get_position_by_cell_index(cell_index_current, point_cell);

			double dt = (lm[0].m_time_tmp - m_time_tmp_last)*1.0 / 1000.0;
			if (dt == 0)
			{
				dt = 1;
			}
			

			double seconds_diff = 1.0;
			if (m_time_tmp_last != 0)
			{
				seconds_diff = (lm[0].m_time_tmp - m_time_tmp_last) / 1000.0;
			}

			if (m_cell_index_last != -1000)
			{
				speed_avg = fabs(cell_index_current - m_cell_index_last) / seconds_diff;

				pt.m_speed = speed_avg;
			}
			else
			{
				speed_avg = 0.0;
			}
			//速度大于3倍平均速度，判断相反距离的速度
			if (speed_avg > m_avg_speed_for_count * 3)
			{
				int cell_index_diff_tmp = int(-pt.m_dist);
				int cell_index_current_tmp = pt.m_site_cell_index - cell_index_diff_tmp;
				int speed_avg_tmp = fabs(cell_index_current_tmp - m_cell_index_last) / seconds_diff;
				//相反距离平均速度在正常范围内，则取相反距离
				if (speed_avg_tmp <= m_avg_speed_for_count * 3)
				{
					speed_avg = speed_avg_tmp;
					cell_index_current = cell_index_current_tmp;
				}
			}

			
			
			double speed_diff = 0.0;
			if (seconds_diff != 0.0)
			{
				speed_diff = (speed_avg - m_avg_speed_last) / seconds_diff;
			}

			if (speed_avg > 0)
			{
				//最多累积一万个速度求平均
				if (m_speed_count < 10000)
				{
					m_speed_count++;
				}

				speed_avg = m_avg_speed_for_count + (speed_avg - m_avg_speed_for_count) / m_speed_count;
				m_avg_speed_for_count = speed_avg;
			}

			if (cell_index_current - m_cell_index_last == 0)
			{
				pt.m_direction = m_direction_last;
			}

			else
			{
				pt.m_direction = (cell_index_current - m_cell_index_last) > 0 ? "-" : "+";
			}
			


			//如果在基站附近
			if (fabs(pt.m_dist) < 10.0)
			{
				//掉头了
				if (pt.m_direction != m_direction_last)
				{
					int cell_index_diff_tmp = int(-pt.m_dist);
					int cell_index_current_tmp = pt.m_site_cell_index - cell_index_diff_tmp;
					int speed_avg_tmp = fabs(cell_index_current_tmp - m_cell_index_last) / seconds_diff;
					//取反试试速度，正常则不掉头。
					if (speed_avg_tmp <= m_avg_speed_for_count * 3)
					{
						speed_avg = speed_avg_tmp;
						cell_index_current = cell_index_current_tmp;
					}
				}
			}
			
			pt.m_time_tmp = lm[0].m_time_tmp;
			pt.m_speed_avg = speed_avg;
			pt.m_acc = lm[0].m_acc;
			pt.m_rav = lm[0].m_rav;
			pt.m_cell_index = cell_index_current;
			
			pt.m_speed_change_rate = speed_diff;

			

			
			log_info("[pdoa] card_location_base::on_location ,obj_id=%d, time=%s, reader_id=%d, ct=%d, poa1=%.4f, poa2=%.4f, poa3=%.4f, pdoa=%.4f, pdoa_offset=%.4f, speed=%f, avg_speed=%f, begin_pt.x=%f, begin_pt.y=%f, gesture=%d, dist_original=%f, dist=%f, angle=%f, acc=%.2f, rav=%d, cell_index=%d, cell_x=%f, cell_y=%f, site_cell_index=%d, cell_count=%d, moving_direct=%s, speed_diff=%f",
				pt.m_cid,
				tool_time::to_str_ex(lm[0].m_time_tmp).c_str(),
				pt.m_sid,
				m_ct,
				lm[0].m_poa[0],
				lm[0].m_poa[1],
				lm[0].m_poa[2],
				pdoa,
				lm[0].m_sit->m_pdoa_offset,
				pt.m_speed,
				speed_avg,
				pt.x,
				pt.y,
				pt.m_stat,
				(pdoa > 0 ? 1 : -1) * fabs(pt.m_dist),
				pt.m_dist,
				pt.m_angle,
				lm[0].m_acc,
				lm[0].m_rav,
				cell_index_current,
				point_cell.x,
				point_cell.y,
				pt.m_site_cell_index,
				s_tunnel.get_cells_count(),
				pt.m_direction.c_str(),
				speed_diff);

			m_speed = pt.m_speed;
			m_stat = pt.m_stat;
			m_cell_index_last = cell_index_current;
			m_cell_index = cell_index_current;
			m_avg_speed_last = speed_avg;
			m_direction_last = pt.m_direction;
			m_time_tmp_last = lm[0].m_time_tmp;
			pt.x = point_cell.x;
			pt.y = point_cell.y;

			//make_his_location_simplify(time(0) * 1000, pt);
			make_his_location_cell_card(pt.m_time_tmp, pt);
			make_his_location_cell_reader(pt.m_time_tmp, pt);
		}

		//pt.m_speed *= 20;

		double acc = lm[0].m_acc;
		m_acc = lm[0].m_acc;
		log_info("useful loc point: type=%d, card=%d, site=%d, ct=%d, timestamp=%llu, x=%f, y=%f, speed=%.2f, acc=%.2f", m_type, m_id, sid, m_ct, m_time, x, y, m_speed, acc);
		do_business(lm.front().m_sit, pt, acc, pt.m_cell_index);

		// 呼救128,正常0
		int val = (lm[0].m_rav ? STATUS_HELP : STATUS_NORMAL);
		if (m_battery_value > 3) {
			val += STATUS_POWER_NORMAL;
		}
		else {
			val += STATUS_POWER_LOWER_SERIOUS;
		}

		log_info("[help-battery] card_id=%d, battery=%d, val=%d", m_id, m_battery_value, val);
		do_status(val);
    }
	else
	{
		log_warn("坐标不可用:site=%d, type=%d, card=%d, ct=%d, x=%f, y=%f", sid, m_type, m_id, m_ct, pt.x, pt.y);
	}
}

void card_location_base::on_message(zloop<task*>* loop, message_locinfo& loc,bool is_history)
{
	m_ct = loc.m_card_ct;
	m_time = loc.m_time_stamp;
	auto site_ptr = sit_list::instance()->get(loc.m_site_id);
	if(!site_ptr)
	{
		log_warn("接收到分站的数据，site=%d,card=%d,ct=%d,但是分站未定义",loc.m_site_id,m_id,loc.m_card_ct);
		return;
	}

	auto area_tool=get_area_tool();
	area_tool->set_site(site_ptr);

	handle_message(loc.m_card_ct,loc.m_batty_status);

	if(site_ptr->is_up_site())
	{
        log_info("card=%d被井上分站[site=%d]收到",m_id,site_ptr->id());
		area_tool->on_point(shared_from_this(),point(1,1));
		this->site_hover(loc.m_site_id);
	}
	else
	{
		if(site_ptr->is_path_empty())
		{
			log_warn("接收到分站的数据，site=%d,card=%d,ct=%d,但是分站路径为空",site_ptr->id(),m_id,loc.m_card_ct);
			return;
		}
		m_message_handle->on_message(loop,loc,is_history);
	}
}

/*
 * tdoa 调用算法库定位
 * */
void card_location_base::on_message(zloop<task*>* loop, message_tdoa_locinfo& loc, bool is_history)
{
    log_info("[tdoa] start calc location.");
    m_ct = loc.m_card_msg.m_sync_num;
    auto site_ptr = sit_list::instance()->get(loc.m_site_msg.m_site_id);
    
    if(!site_ptr){
        log_warn("[tdoa] 接收到分站的数据：site=%d, card=%d, ct=%d, 但是分站未定义", loc.m_site_msg.m_site_id, m_id, loc.m_card_msg.m_time_stamp);
        return;
    }
    
    auto area_tool=get_area_tool();
	area_tool->set_site(site_ptr);

    handle_message(loc.m_card_msg.m_time_stamp, loc.m_card_msg.m_battery_status);
	
    if(site_ptr->is_up_site())
	{}
    else{
          m_message_handle->on_message(loop, loc, is_history);
    }
}

/*
 * pdoa 调用算法库定位
 *
 * */
void card_location_base::on_message(zloop<task*>* loop, message_pdoa_locinfo& loc, bool is_history)
{
    m_ct = loc.m_card_ct;
    m_time = loc.m_time_stamp;
    auto site_ptr = sit_list::instance()->get(loc.m_site_id);
    if(!site_ptr){
        log_warn("[pdoa] 接收到分站的数据：site=%d, card=%d, ct=%d, 但是分站未定义", loc.m_site_id, m_id, loc.m_card_ct);
        return;
    }	

	site_ptr->m_loc_time = time(0);

	// 基站覆盖距离检测
	do_site_coverage(loc);

    auto area_tool=get_area_tool();
	area_tool->set_site(site_ptr);

    m_battery_value = loc.m_batty_status;       // 电量值

    handle_message(loc.m_card_ct, loc.m_batty_status);
    if(site_ptr->is_up_site()){
        log_info("card=%d被井上分站[site=%d]收到", m_id, site_ptr->id());
        area_tool->on_point(shared_from_this(), point(1,1));
        this->site_hover(loc.m_site_id);
		m_last_site_id = site_ptr->id();
		//m_last_down_stream_idx = site_ptr->m_down_stream_idx;
		m_cb_stream_idx.push_back(site_ptr->m_down_stream_idx);
    }
    else{
        char sql[1024] = {0};
        snprintf(sql, 1024, "insert into his_distance_reader(card_type, ident, reader_id, dist, dir, cur_time) values(%d, %d, %d, %.2f, %d, '%s')", loc.m_card_type, loc.m_card_id, loc.m_site_id, loc.m_tof*15.65*2.996*1E-4, (tool_other::get_pdoa(loc.m_poa, site_ptr->m_pdoa_offset)>=0?1:-1), tool_time::to_str(time(NULL)).c_str());
        //db_tool::PushAsync(sql);
        log_info("[sql] %s", sql);
		
		do_site_locate_event(loc);
		do_card_locate_event(loc);
 
        m_message_handle->on_message(loop, loc, is_history);
   }
}

//前端推送位置函数.
void card_location_base::upt_card_pos(sys::_CARD_POS_&cp, point &pt)
{
    point _p;
    if(pt.empty())
    {
         _p = *this;
         pt = _p;
    }
    else
         _p = pt;
	
    cp.Type     = m_type;
	cp.ID       = m_id;
	cp.speed    = abs(ceil(m_speed));
	cp.x        = tool_other::round(_p.x,3);
	cp.y        = tool_other::round(_p.y,3);
	cp.running_stat = m_stat;
	cp.dept_id  = m_deptid;
	cp.display  = m_display;
	cp.rec_time = m_time;
	cp.level_id = m_level_id;
    cp.battery_val = m_battery_value;

    if(m_pwr_stat > 0){
        cp.battery_stat = (m_pwr_stat<3?1:0);
    }
    cp.m_freq   = m_freq;
	
	swsTimerThrd.upt_card_pos(cp);
}

void card_location_base::del_card_pos()
{
	sys::_CARD_POS_ cp;
	cp.ID = m_id;
	cp.Type=m_type;
	swsTimerThrd.del_card_pos(cp);
}

int  card_location_base::get_stat()
{
	//盲区>呼救>呼叫>超时>超速>正常
    uint64_t now = time(0)*1000;
    uint64_t tlost=now>m_time?now-m_time:m_time-now;

    if(tlost>CARD_LOST_TIME_OUT)
    {
        // 人卡盲区： 当人卡丢失信号大于60s，判定人卡进入盲区
        return STATUS_LOST;
    }
    else if(auto ev_ptr = event_list::instance()->get_event_card(m_id, m_type, ET_CARD_HELP))
    {
        return  (ES_DEAL_HELP == ev_ptr->m_status) ?  STATUS_HELP_DEALED : STATUS_HELP;
    }
    else if(CALL_NONE != get_mine_tool()->m_status_call)
    {
        return  STATUS_CALL;
    }
    else if(is_person())
    {
        if(event_list::instance()->get_event_card(m_id, m_type,ET_CARD_AREA_OVER_TIME_PERSON)||
                event_list::instance()->get_event_card(m_id, m_type,ET_CARD_OVER_TIME_PERSON))
            return  STATUS_AREA_OVER_TIME;
    }
    else if(event_list::instance()->get_event_card(m_id, m_type, ET_CARD_OVER_SPEED))
    {
        return  STATUS_OVER_SPEED;
    }

    return STATUS_NORMAL;
}

void  card_location_base::clear()
{
//	uint16_t m_display;			//1显示0不显示，往前端推送
    m_speed=0;			//速度
    m_stat=0;			//运动静止状态
    //m_ct;				//ct
    m_time=0;			//时间戳

    //pdoa location info clear
    m_buff_size = 0;
    m_last_recv_time = 0;
    m_last_point = point(0,0);
    m_last_site_id = 0;
    m_last_site_dir = -1;
    m_last_ct = 0;
    m_last_dist = 0.0;
    m_pdoa_diff = m_last_pdoa_diff = 100.0;
    m_last_over_site = false;
    m_cache_nums = 0;
    m_cb_pdoa.clear();
    m_cb_tof.clear();
    m_cb_point.clear();
}

/*void card_location_base::put_three_rates(card_pos & cp)
{   
	if(!three_rates_flag)
        return;
	
    cp.rec_time     = m_time;
    cp.type         = m_type;
    cp.id           = m_id;
	cp.identifier_id= m_cid;
    cp.running_stat = m_stat;
    cp.final_v      = m_speed;
	cp.dpt_id       = m_deptid;
	std::shared_ptr<area_tool> _areatool = get_area_tool();
	if(nullptr != _areatool && nullptr != _areatool->m_site)
	{
		cp.reader_x = _areatool->m_site->x;
		cp.reader_y = _areatool->m_site->y;
		cp.reader_id = _areatool->m_site->m_id;
	}

	log_info("three_rates:type:%d,id:%d,cid:%d",cp.type,cp.id,cp.identifier_id);
	three_rates::get_instance()->put(cp);
	
}*/

void card_location_base::put_traffic_light(card_pos& cp)
{
    if(!traffic_light_flag){
        return;
    }
    light_message lm;

    lm.m_cmd            = cmd_card_data;
    lm.m_pos.x          = cp.x;
    lm.m_pos.y          = cp.y;
    lm.m_pos.z          = cp.z;
    lm.m_pos.m_card_id  = m_id;
    lm.m_pos.m_type     = m_type;
    lm.m_pos.m_site_id  = cp.reader_id;
    auto site_ptr       = get_area_tool()->m_site;
    if(site_ptr){   
        lm.m_pos.m_area_id = site_ptr->m_area_id;
    }
    //lm.m_pos.m_bigger = 0;
    lm.m_pos.m_speed = m_speed;

    log_info("[traffic_light] put locate info into traffic light module, card_id=%d, ctype=%d, x=%.2f, y=%.2f, site_id=%d", m_id, m_type, x, y, cp.reader_id);
    traffic_light_manager::instance()->put(lm);
}

bool card_location_base::is_person() const
{
    return tool_other::is_person(m_type);
}

bool card_location_base::is_vehicle() const
{
    return tool_other::is_vehicle(m_type);
}

void card_location_base::set_base_data(uint32_t cid,uint16_t type,uint32_t deptid,int32_t level_id) {
    m_cid       = cid;
    m_type      = type;
    m_deptid    = deptid;
    m_level_id  = level_id;
    m_his_location_card->set_cid(cid);
}

card_location_base::~card_location_base()
{
}

std::shared_ptr<card_location_base> card_location_base::make_person(const std::string&type,uint32_t cardid,uint16_t needdisplay,int16_t t,
		int32_t deptid,int32_t level_id,uint32_t cid,int wl,const std::string &sname,const std::string & dname,int worktype_id)
{
	return std::make_shared<person>(type, cardid, needdisplay, t, deptid, level_id, cid, wl, sname, dname, worktype_id);
}

/*
 * @brief   创建车辆对象
 * @param   const std::string& type
 * @param   uint32_t cardid         卡id
 * @param   uint16_t needdisplay    是否需要显示
 * @param   int16_t t               
 * @param   int32_t deptid          部门id
 * @param   int32_t categoryid      
 * @param   int type_id             卡类型id
 * @param   int32_t level_id        职级id
 * @param   uint32_t cid        
 * @return  车辆对象
 * @note
 * @bug
 * @warning
 * */
std::shared_ptr<card_location_base> card_location_base::make_car(const std::string&type, uint32_t cardid, uint16_t needdisplay, int16_t t,
		int32_t deptid, int32_t categoryid, int type_id,int32_t level_id,uint32_t cid)
{
	return std::make_shared<car>(type, cardid, needdisplay, t, deptid, categoryid, type_id, level_id, cid);
}

/*
 * @brief	基站覆盖距离检测
 * @param	message_pdoa_locinfo& loc		卡数据
 * @return	无
 * @note
 * @bug
 * @warning
 * */
void card_location_base::do_site_coverage(message_pdoa_locinfo& loc)
{
	auto site_ptr = sit_list::instance()->get(loc.m_site_id);
	if(!site_ptr){
		log_warn("[pdoa] 接收到分站的数据：site=%d, card=%d, ct=%d, 但是分站未定义", loc.m_site_id, m_id, loc.m_card_ct);
		return;
	}

	double pdoa = tool_other::get_pdoa(loc.m_poa, site_ptr->m_pdoa_offset);
	double dist = loc.m_tof*15.65*2.996*1e-4;
	bool is_update = false;
	if(pdoa > 0){
		if(dist > site_ptr->m_coverage[0].m_distance){
			site_ptr->m_coverage[0].m_distance = dist;
			site_ptr->m_coverage[0].m_cid = tool_byte::to_cardid(loc.m_card_type, loc.m_card_id);
			site_ptr->m_coverage[0].m_time = time(0);

			is_update = true;
		}
	}else{
		if(dist > site_ptr->m_coverage[1].m_distance){
			site_ptr->m_coverage[1].m_distance = dist;
			site_ptr->m_coverage[1].m_cid = tool_byte::to_cardid(loc.m_card_type, loc.m_card_id);
			site_ptr->m_coverage[1].m_time = time(0);

			is_update = true;
		}
	}

	if(is_update){
		char sql[1024] = {0};
		snprintf(sql, 1024, "REPLACE INTO his_reader_coverage(reader_id, plus_dist, plus_card_id, plus_occur_time, minus_dist, minus_card_id, minus_occur_time, last_update) VALUES(%d,%.2f,'%s','%s',%.2f,'%s','%s','%s');", site_ptr->m_id, site_ptr->m_coverage[0].m_distance, site_ptr->m_coverage[0].m_cid.c_str(), tool_time::to_str(site_ptr->m_coverage[0].m_time).c_str(), site_ptr->m_coverage[1].m_distance, site_ptr->m_coverage[1].m_cid.c_str(), tool_time::to_str(site_ptr->m_coverage[1].m_time).c_str(), tool_time::to_str(time(0)).c_str());
        db_tool::PushAsync(sql);
        logn_info(2, "[sql] %s", sql);
	}
}

/*
 * @brief	卡定位异常检测
 * @param	message_pdoa_locinfo& loc		卡数据
 * @return	无
 * @note
 * @bug
 * @warning
 * */
void card_location_base::do_card_locate_event(const message_pdoa_locinfo& loc)
{
	bool status = false;

	status = ((loc.m_tof == 0)?true:false);

	uint64_t id = tool_other::type_id_to_u64(m_type, m_id);
    event_tool::instance()->handle_event(OT_CARD, ET_CARD_LOCATE_ERROR, id, 0, 0, status);	
	//log_info("[card-locate-event] card_id=%d, ct=%d, tof=%lld", m_id, m_ct, loc.m_tof);
}

/*
 * @brief	基站定位异常检测
 * @param	message_pdoa_locinfo& loc		卡数据
 * @return	无
 * @note
 * @bug
 * @warning
 * */
void card_location_base::do_site_locate_event(const message_pdoa_locinfo& loc)
{		
	//log_info("[site-locate-event] cur_ct=%d, ct=%d, m_last_ct=%d, m_last_site_id=%d, loc.m_site_id=%d", loc.m_card_ct, ct, m_last_ct, m_last_site_id, loc.m_site_id);	
	if(m_last_ct <= 0 || m_last_site_id == 0){
		return;
	}

	if(loc.m_site_id != m_last_site_id){
		return;
	}

	int dt = 0;
	if(loc.m_card_ct > m_last_ct){
		dt = loc.m_card_ct - m_last_ct;
	}else{
		dt = 65535 + loc.m_card_ct - m_last_ct;
	}
	
	event_tool::instance()->handle_event(OT_DEVICE_READER, ET_READER_LONG_TIME_NO_POSITION, loc.m_site_id, 3, dt, (dt>=3));
	log_info("[site-locate-event] site_id=%d, card_id=%d, ct=%d, dt=%d", loc.m_site_id, m_id, loc.m_card_ct, dt);
}