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"

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::on_location(const std::vector<point>&vp, const std::vector<loc_message> &lm)
{
	/*std::for_each(vp.begin(), vp.end(), [](point it){
			logn_info(3, "possible solution: x = %.2f, y = %.2f", it.x, it.y);
			});*/
	if(lm.size() < 2){
		return;
	}
	loc_point pt = m_sel_tool->select_solution(vp, lm);
	//logn_info(3, "select solution: x = %.2f, y = %.2f", pt.x, pt.y);
	auto site_ptr = get_area_tool()->m_site;
	int sid = 0;
	// 天线间间距默认为3米，实际取基站上的天线间距离配置参数
	double ant_dist = 3.0;
	if(site_ptr){
        sid = site_ptr->m_id;
		ant_dist = site_ptr->m_pdoa_offset;
	}

	// first way
	sys::tof_data tdt;
	tdt.cid = tool_byte::to_cardid(m_type, m_id);
	tdt.sid = 0;
	tdt.cur_time = tool_time::to_str_ex(tool_time::now_to_ms());
	int aid = lm[0].m_ant_id;
	tdt.ant_dist[aid] = lm[0].m_num_ticks*15.65*2.996*1E-4;
	aid = lm[1].m_ant_id;
	tdt.ant_dist[aid] = lm[1].m_num_ticks*15.65*2.996*1E-4;

	if(tdt.ant_dist[0] > 1000 || tdt.ant_dist[1] > 1000){
		int a = 11;
		pt.x = a;
	}

	logn_info(3, "[tof_data] cid=%d, ct=%d, 1ant_dist=%.2f, 2ant_dist=%.2f", m_id, m_ct, tdt.ant_dist[0], tdt.ant_dist[1]);

	loc_point tp;
	if(tdt.ant_dist[0] > tdt.ant_dist[1] && tdt.ant_dist[0] > ant_dist){
		// 在0天线侧外部
		tp.y = -1.5 + tdt.ant_dist[0];
	}else if(tdt.ant_dist[1] > tdt.ant_dist[0] && tdt.ant_dist[1] > ant_dist){
		// 在1天线测外部
		tp.y = 1.5 - tdt.ant_dist[1];
	}else if(tdt.ant_dist[0] < 3.0 && tdt.ant_dist[1] < ant_dist) {
		// 在两天线之间
		tp.y = (-1.5 + tdt.ant_dist[0]) + (1.5 - tdt.ant_dist[1])/2.0;
	}

	logn_info(3, "another solution:cid =%d, ct=%d, x = %.2f, y = %.2f", m_id, m_ct, tp.x, tp.y);
	tdt.y = tp.y;
	pt = tp;
	pt.m_useless = true;

	if(pt.m_useless)
	{
		x = tool_other::round(pt.x, 3);
		y = tool_other::round(pt.y, 3);
		
		do_business(lm.front().m_sit, pt);

		sys::tof_data td;
		td.cid = tool_byte::to_cardid(m_type, m_id);
		td.y = y;
		td.sid = sid;
		td.cur_time = tool_time::to_str_ex(tool_time::now_to_ms());
		int aid = lm[0].m_ant_id;
		td.ant_dist[aid] = lm[0].m_num_ticks*15.65*2.996*1E-4;
		aid = lm[1].m_ant_id;
		td.ant_dist[aid] = lm[1].m_num_ticks*15.65*2.996*1E-4;
		td.ant_diff = site_ptr->m_pdoa_offset;

		// 将数据存入数据库中
		char sql[1024] = {0};
		snprintf(sql, 1024, "insert into his_tof_locate_data(card_id, ant_one_dist, ant_two_dist, ant_dist,site_id, y, cur_time) values('%s', %.2f, %.2f, %.2f, %d, %.2f, '%s')", tool_byte::to_cardid(m_type, m_id).c_str(), td.ant_dist[0], td.ant_dist[1], site_ptr->m_pdoa_offset, sid, y, tool_time::to_str_ex(tool_time::now_to_ms()).c_str());
		db_tool::PushAsync(sql);
        log_info("[sql] %s", sql);

		//add json to send to web
		swsTimerThrd.upt_tof_data(std::move(td));

		// 呼救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(STATUS_NORMAL);
    }
	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);
	}
}

/*
 * 实心球原始数据调用算法模块进行定位处理
 * */
void card_location_base::on_message(zloop<task*>* loop, message_ins_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;
	}*/

	//m_message_handle->on_message(loop, loc, is_history);
	log_info("[solid_ball] start calc location");
	
	auto itm = m_msg_list.find(loc.m_card_ct);

	if(itm == m_msg_list.end()){
		std::vector<message_ins_locinfo> vtm;
		vtm.push_back(loc);
		m_msg_list.insert(std::make_pair(loc.m_card_ct, vtm));
		itm = m_msg_list.find(loc.m_card_ct);
	}else{
		itm->second.push_back(loc);
	}

	if(itm->second.size() < 2){
		return;
	}

	// ct切换了
	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;
	}

	// 卡号
	std::string sid = tool_byte::to_cardid(m_type, m_id);
	std::string site_info = "";
	std::string now = tool_time::to_str_ex(tool_time::now_to_ms());

	int nIndex = 0;
	int siteId1 = 0;
	int siteId2 = 0;
	double distance1 = 0;
	double distance2 = 0;

	// 存入数据库
	for(auto itl : itm->second){
		site_info += std::to_string(itl.m_site_id);
		double d = itl.m_tof * 15.65 * 2.996 * 1E-4;
		site_info += "," + std::to_string(d);
		site_info += ",0.0";
		double v = 0.0;
		auto its = last_site_info.find(itl.m_site_id);
		if(its == last_site_info.end()){
			sinfo si;
			si.sct = m_ct;
			si.sdist = d;
			last_site_info.insert(std::make_pair(itl.m_site_id, si));
			v = 0.0;
		}else{
			double dt = 0.0;
			if(m_ct > its->second.sct ){
				dt = (m_ct - its->second.sct) / 1000.0;
			}else{
				dt = (m_ct + 65535 - its->second.sct) / 1000.0;
			}
			v = (d - its->second.sdist) / dt;

			its->second.sct = m_ct; 	
			its->second.sdist = d;
		}
		site_info += "," + std::to_string(v);
		site_info += ";";
		if (nIndex == 0)
		{
			siteId1 = itl.m_site_id;
			distance1 = d;
			nIndex++;
		}
		else if (nIndex == 1)
		{
			siteId2 = itl.m_site_id;
			distance2 = d;
		}
	}
	
	// 数据入库
	char sql[1024] = { 0 };
	snprintf(sql, 
			1024, 
			"insert into his_raw_data_sb(card_id, site_id, distance, acc, acc_x, acc_y, acc_z, ang, ang_x, ang_y, ang_z, cur_time) values('%s', %d, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, '%s')",
			sid.c_str(),
		siteId1,
		distance1,
			loc.m_ins_data.get_acc(),
			loc.m_ins_data.get_acc(0),
			loc.m_ins_data.get_acc(1),
			loc.m_ins_data.get_acc(2),
			loc.m_ins_data.get_gyro(),
			loc.m_ins_data.get_gyro(0),
			loc.m_ins_data.get_gyro(1),
			loc.m_ins_data.get_gyro(2),
			now.c_str()
		);
	db_tool::PushAsync(sql);
    log_info("[sql] %s", sql);

	memset(sql, 0, 1024);

	snprintf(sql,
		1024,
		"insert into his_raw_data_sb(card_id, site_id, distance, acc, acc_x, acc_y, acc_z, ang, ang_x, ang_y, ang_z, cur_time) values('%s', %d, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, '%s')",
		sid.c_str(),
		siteId2,
		distance2,
		loc.m_ins_data.get_acc(),
		loc.m_ins_data.get_acc(0),
		loc.m_ins_data.get_acc(1),
		loc.m_ins_data.get_acc(2),
		loc.m_ins_data.get_gyro(),
		loc.m_ins_data.get_gyro(0),
		loc.m_ins_data.get_gyro(1),
		loc.m_ins_data.get_gyro(2),
		now.c_str()
	);
	db_tool::PushAsync(sql);
	log_info("[sql] %s", sql);

	// 更新数据到发送线程
	sys::sb_data sd;
	sd.cid = sid;
	sd.speed = 0.0;
	sd.site_info = site_info;
	sd.acc = loc.m_ins_data.get_acc();
	sd.ang = loc.m_ins_data.get_gyro();
	std::copy(loc.m_ins_data.m_acc_data.begin(), loc.m_ins_data.m_acc_data.end(), sd.m_acc_data.begin());
	std::copy(loc.m_ins_data.m_ang_data.begin(), loc.m_ins_data.m_ang_data.end(), sd.m_ang_data.begin());
	sd.cur_time = now;

	swsTimerThrd.upt_sb_data(std::move(sd));

	logn_info(3, 
			"[solid_ball] cid='%s', stamp=%d, sinfo='%s', acc = %.2f, acc_x = %.2f, acc_y = %.2f, acc_z = %.2f, ang = %.2f, ang_x = %.2f, ang_y = %.2f, ang_z =  %.2f, t = '%s')",
			sid.c_str(),
			m_ct,
			site_info.c_str(),
			loc.m_ins_data.get_acc(),
			loc.m_ins_data.get_acc(0),
			loc.m_ins_data.get_acc(1),
			loc.m_ins_data.get_acc(2),
			loc.m_ins_data.get_gyro(),
			loc.m_ins_data.get_gyro(0),
			loc.m_ins_data.get_gyro(1),
			loc.m_ins_data.get_gyro(2),
			now.c_str()
	);

	//清除数据
	m_msg_list.erase(itm);
	//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_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);
}