update

card_base.cpp

@@ -181,6 +181,7 @@ void card_location_base::on_message(zloop<task*>* loop, message_tdoa_locinfo& lo
 {
     log_info("[tdoa] start calc location.");
     m_ct = loc.m_card_msg.m_sync_num;
+    //m_time = loc.m_time_stamp;
     auto site_ptr = sit_list::instance()->get(loc.m_site_msg.m_site_id);
     
     if(!site_ptr){
@@ -199,6 +200,7 @@ void card_location_base::on_message(zloop<task*>* loop, message_pdoa_locinfo& lo
 {
     //log_info("[pdoa] start calc location");
     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);
@@ -324,8 +326,13 @@ void card_location_base::put_traffic_light(card_pos& cp)
     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;
+    auto site = site_list::instance()->get(cp.m_reader_id);
+    lm.m_pos.m_area_id = site->m_site_id;
     //lm.m_pos.m_bigger = 0;
     lm.m_pos.m_speed = m_speed;
+    log_info("[traffic_light] put light message to traffic light module, card_id=%d, ctype=%d, x=%.2f, y=%.2f", m_id, m_type, x, y);
+    //traffic_light_manager::instance()->update(int(x), int(y), m_id);
     traffic_light_manager::instance()->put(lm);
 }
 

main.cpp

@@ -66,9 +66,9 @@ struct Init_Setting
         }
         log_info("数据库线程池创建成功");
 
-        std::string url=config.get("service.websocket_url","ws://127.0.0.1:8086");
-        std::string url_2=config.get("service.websocket_url_bak","");
-        int32_t send_interval =config.get("service.interval_send_json_postion",1);
+        std::string url     = config.get("service.websocket_url","ws://127.0.0.1:8086");
+        std::string url_2   = config.get("service.websocket_url_bak","");
+        int32_t send_interval = config.get("service.interval_send_json_postion",1);
         std_info("json_interval:%d,[%s]",send_interval,url.c_str());
         std::vector<std::string> url_list;
         url_list.push_back(url);

mine_business.cpp

@@ -470,7 +470,8 @@ void reverse_alarm_business::get_status()
         int nCount = DBRes.GetRecordCount( Error );
         if (nCount < 1)
         {
-            log_warn("load_sensor_data..failed[%s]", strsql);
+            //log_warn("load_sensor_data..failed[%s]", strsql);
+            logn_warn(2, "load_sensor_data...failed sql=%s", strsql);
             continue;
         }
 
@@ -522,7 +523,8 @@ void card_sensor_mgr::for_each()
         int nCount = DBRes.GetRecordCount( Error );
         if (nCount < 1)
         {
-            log_warn("load_sensor_data..failed[%s]", strsql);
+            //log_warn("load_sensor_data..failed[%s]", strsql);
+            logn_warn(2, "load_sensor_data...failed[%s]", strsql);
             continue;
         }
 

module_service/module_traffic_light.cpp

@@ -31,6 +31,7 @@ void traffic_light_group::insert(traffic_light_ptr ptl)
 
 void traffic_light_group::set_light(const int& ld, const int& lc, const int& lcr)
 {
+    log_info("[traffic_light] set light group status, light_id=%d, status=%d, reverse_status=%d",ld, lc, lcr);
     for(auto it = m_vt_lights.begin(); it != m_vt_lights.end(); ++it){
         auto ptl = traffic_light_manager::instance()->find_light((*it)->m_light_id);
             if(ptl != nullptr){

module_service/module_traffic_light.h

@@ -26,6 +26,25 @@ struct traffic_light: point{
     traffic_light(): m_light_id(0), m_group_id(0), m_ip(""), m_state(0), m_port(0), m_phy_light_id(0), m_phy_direction(0), m_rec_time(0), m_special(0), m_direct_distance(0.0)
     {}
 
+    traffic_light(double x, double y, double z, int light_id, int group_id, std::string ip, int state, int port, int pli, int pd, int special): point(x, y, z), m_light_id(light_id), m_group_id(group_id), m_ip(ip), m_state(state), m_port(port), m_phy_light_id(pli), m_phy_direction(pd), m_special(special)
+    {
+    }
+
+    void update(double x, double y, double z, int light_id, int group_id, std::string ip, int state, int port, int pli, int pd, int special)
+    {
+        this->x = x;
+        this->y = y;
+        this->z = z;
+        this->m_light_id = light_id;
+        this->m_group_id = group_id;
+        this->m_ip = ip;
+        this->m_state = state;
+        this->m_port = port;
+        this->m_phy_light_id = pli;
+        this->m_phy_direction = pd;
+        this->m_special = special;
+    }
+
     void set_state(int value = green)
     {
         m_state = value;
@@ -60,6 +79,13 @@ struct traffic_light_group: point{
         m_vt_lights.clear();   
     }
 
+    traffic_light_group(double x, double y, double z, int group_id, double scope, int interval, int map_id, int area_id): point(x, y, z), m_group_id(group_id), m_scope(scope), m_auto_interval(interval), m_map_id(map_id), m_area_id(area_id)
+    {
+        m_priority = priority_init;
+        m_vt_lights.clear();
+        m_used = false;
+    }
+
     // 给红绿灯下发指令设置其颜色
     void send_cmd_light(traffic_light_ptr& ptl);
 
@@ -139,6 +165,18 @@ struct traffic_light_group: point{
     void set_manual_ctrl(const std::string& name, const int& ld, const int& lc);
 
     uint64_t get_green_light_id();
+
+    void update(double x, double y, double z, int group_id, double scope, int interval, int map_id, int area_id)
+    {
+        this->x = x;
+        this->y = y;
+        this->z = z;
+        this->m_group_id = group_id;
+        this->m_scope = scope;
+        this->m_auto_interval = interval;
+        this->m_map_id = map_id;
+        this->m_area_id = area_id;
+    }
 };
 
 struct traffic_light_data{

module_service/module_traffic_light_common.h

@@ -35,10 +35,10 @@ enum light_shape{
 
 //优先级
 enum priority{
-    priority_init = 0,      // 初始值
-    priority_crossing,      // 路口控制
-    priority_avoidance,     // 避让控制
-    priority_manual_ctrl,   // 手动控制
+    priority_init           = 0,      // 初始值
+    priority_crossing       = 1,      // 路口控制
+    priority_avoidance      = 2,      // 避让控制
+    priority_manual_ctrl    = 3,      // 手动控制
 };
 
 //web对应的

module_service/module_traffic_light_manager.cpp

@@ -29,24 +29,37 @@ void traffic_light_manager::init_light_from_db(int lid)
     }
 
     while(res.GetNextRecod(err)){
-        traffic_light_ptr pl = std::make_shared<traffic_light>();
+        int light_id = 0;
+        res.GetField("light_id", light_id, err);
+        int group_id = 0;
+        res.GetField("lights_group_id", group_id, err);
+        std::string ip = "";
+        res.GetField("ip", ip, err);
+        double x = 0.0, y = 0.0, z = 0.0;
+        res.GetField("x", x, err);
+        res.GetField("y", y, err);
+        res.GetField("z", z, err);
+        int site_id = 0, state = 0, port = 0, phy_light_id = 0, phy_direction = 0, special = 0;
+        res.GetField("reader_id", site_id, err);
+        res.GetField("state", state, err);
+        res.GetField("port", port, err);
+        res.GetField("physics_light_id", phy_light_id, err);
+        res.GetField("physics_light_direction", phy_direction, err);
+        res.GetField("special_flag", special, err);
+        traffic_light_ptr pl = find_light(light_id);
         if(nullptr == pl){
-            return;
+            pl = std::make_shared<traffic_light>(x, y, z, light_id, group_id, ip, state, port, phy_light_id, phy_direction, special);
+            m_unmap_lights.insert(std::make_pair(light_id, pl));           
+        }else{
+            pl->update(x, y , z, light_id, group_id, ip, state, port, phy_light_id, phy_direction, special);
         }
 
-        res.GetField("light_id", pl->m_light_id, err);
-        res.GetField("lights_group_id", pl->m_group_id, err);
-        res.GetField("ip", pl->m_ip, err);
-        res.GetField("x", pl->x, err);
-        res.GetField("y", pl->y, err);
-        res.GetField("z", pl->z, err);
-        res.GetField("reader_id", pl->m_site_id, err);
-        res.GetField("state", pl->m_state, err);
-        res.GetField("port", pl->m_port, err);
-        res.GetField("physics_light_id", pl->m_phy_light_id, err);
-        res.GetField("physics_light_direction", pl->m_phy_direction, err);
-        res.GetField("special_flag", pl->m_special, err);
-        m_unmap_lights[pl->m_light_id] = pl;
+        // 将红绿灯分配到对应组中
+        auto it_group = m_unmap_groups.find(pl->m_group_id);
+        if(it_group != m_unmap_groups.end())
+        {
+            it_group->second->m_vt_lights.push_back(pl);
+        }
     }
 
     logn_info(2, "sql:%s",sql.c_str());
@@ -71,22 +84,25 @@ void traffic_light_manager::init_light_group_from_db(int gid)
     }
 
     while(res.GetNextRecod(err)){
-        traffic_light_group_ptr pg = std::make_shared<traffic_light_group>();
-        if(nullptr == pg){
-            return;
-        }
-
-        res.GetField("lights_group_id", pg->m_group_id, err);
-        res.GetField("x", pg->x, err);
-        res.GetField("y", pg->y, err);
-        res.GetField("z", pg->z, err);
-        res.GetField("scope", pg->m_scope, err);
-        res.GetField("map_id", pg->m_map_id, err);
-        res.GetField("area_id", pg->m_area_id, err);
+        int group_id = 0;       
+        res.GetField("lights_group_id", group_id, err); 
+        double x = 0.0, y = 0.0, z = 0.0, scope = 0.0;
+        res.GetField("x", x, err);
+        res.GetField("y", y, err);
+        res.GetField("z", z, err);
+        res.GetField("scope", scope, err);
+        int map_id = 0, area_id = 0;
+        res.GetField("map_id", map_id, err);
+        res.GetField("area_id", area_id, err);
         int ai = 0;
         res.GetField("light_auto_interval", ai, err);
-        pg->m_auto_interval = ai;
-        m_unmap_groups[pg->m_group_id] = pg;
+        traffic_light_group_ptr pg = find_group(group_id);
+        if(nullptr == pg){
+            pg = std::make_shared<traffic_light_group>(x, y, z, group_id, scope, ai, map_id, area_id);
+            m_unmap_groups.insert(std::make_pair(group_id, pg));
+        }else{
+            pg->update(x, y, z, group_id, scope, ai, map_id, area_id);
+        }
     }
     
     logn_info(2, "sql:%s",sql.c_str());
@@ -94,8 +110,10 @@ void traffic_light_manager::init_light_group_from_db(int gid)
 
 void traffic_light_manager::init(const traffic_send_callback& tcb)
 {
-    init_light_from_db();
+    // 1.先获得红绿灯组数据
     init_light_group_from_db();
+    // 2.再获得红绿灯数据
+    init_light_from_db();
 
     for(hashmap_light::iterator it_light = m_unmap_lights.begin(); it_light != m_unmap_lights.end(); ++it_light){
         if(it_light->second->m_group_id >0){
@@ -111,20 +129,33 @@ void traffic_light_manager::init(const traffic_send_callback& tcb)
 
 void traffic_light_manager::start()
 {
-    log_info("[traffic_light] start traffic light service");
+    log_info("[traffic_light] start traffic light service, light_group's size=%d", m_unmap_groups.size());
     m_stop = false;
     m_crossing_rule = std::unique_ptr<crossing_rule>(new crossing_rule);
     if(nullptr == m_crossing_rule){
         log_info("[traffic_light] create crossing rule failed");
         return;
+    }else{
+        for(auto it = m_unmap_groups.begin(); it != m_unmap_groups.end(); ++it)
+        {
+            m_crossing_rule->put(it->second);
+        }
     }
 
     m_avoidance_rule = std::unique_ptr<avoidance_rule>(new avoidance_rule);
     if(nullptr == m_avoidance_rule){
         log_info("[traffic_light] create avoidance rule failed");
         return;
+    }else{
+        for(auto it = m_unmap_groups.begin(); it != m_unmap_groups.end(); ++it)
+        { 
+            log_info("[traffic_light] insert light group into area, area_id=%d", it->second->m_area_id);
+            m_avoidance_rule->put(it->second);
+        }
     }
 
+    log_info("[traffic_light] rule's map size, crossing=%d, avoidance=%d", m_crossing_rule->size(), m_avoidance_rule->size());
+
     m_thread_light.reset(new std::thread(std::bind(&traffic_light_manager::run, this)));
 }
 
@@ -139,7 +170,8 @@ void traffic_light_manager::put(const light_message& msg)
 {
     std::unique_lock<std::mutex> lock(m_mutex);
     m_list_data.push_back(msg);
-    m_condition.notify_one();
+    lock.unlock();
+    m_condition.notify_all();
 }
 
 void traffic_light_manager::run()
@@ -147,7 +179,7 @@ void traffic_light_manager::run()
     while(!m_stop){
         std::list<light_message> tmp_data;
         tmp_data.clear();
-
+        //log_info("[traffic_light] working... m_stop=%d", m_stop);
         {
             std::unique_lock<std::mutex> lock(m_mutex);
             while(m_list_data.empty()){
@@ -157,6 +189,8 @@ void traffic_light_manager::run()
             if(m_list_data.size() > 0){
                 m_list_data.swap(tmp_data);
             }
+
+            lock.unlock();
         }
 
         for(std::list<light_message>::iterator it = tmp_data.begin(); it != tmp_data.end(); ++it){
@@ -170,16 +204,18 @@ void traffic_light_manager::run()
                     handle_manual(it->m_group_id,it->m_light_id, it->m_ctrl_name, it->m_light_status);
                     break;
                 case cmd_card_data:
-                    log_info("[traffic_light] cmd=%d, cid=%d, bigger=%d, aid=%d, speed=%.2f", it->m_cmd, it->m_pos.m_card_id, it->m_pos.m_bigger, it->m_pos.m_area_id, it->m_pos.m_speed);
+                    log_info("[traffic_light] cmd=%d, cid=%d, ctype=%d, bigger=%d, aid=%d, speed=%.2f", it->m_cmd, it->m_pos.m_card_id, it->m_pos.m_type, it->m_pos.m_bigger, it->m_pos.m_area_id, it->m_pos.m_speed);
                     handle_position(it->m_pos);
                     break;
                 default:
                     log_warn("[traffic_light] message cmd error, cmd=%d", it->m_cmd);
                     break;
-            }
-        
+            } 
         }
+        //log_info("[traffic_light] working thread one loop, m_stop=%d", m_stop);
     }
+
+    log_info("[traffic_light] working thread is exit. m_stop=%d", m_stop);
 }
 
 void traffic_light_manager::handle_reload(const int& gid, const int& lid)
@@ -214,17 +250,19 @@ void traffic_light_manager::handle_manual(const int& gid, const int& ld, const s
 
 void traffic_light_manager::handle_position(pos_data& p)
 {
-    if(p.m_type == 2){
+    if(p.m_type == 3 || p.m_type == 1){
         std::map<uint64_t, pos_data>::iterator it = m_map_card.find(p.m_card_id);
         if(it != m_map_card.end()){
             m_map_card.erase(it);
         }
-    }else if(p.m_type == 3 || p.m_type == 1){
-        m_geo_list.update(p.x, p.y, p.m_card_id);
+    }else if(p.m_type == 2){
+        //log_info("[traffic_light] call handle rule");
+        update(p.x, p.y, p.m_card_id);
         m_map_card[p.m_card_id] = p;
         // 路口规则
         if(nullptr != m_crossing_rule){
-            m_crossing_rule->handle_rule(p);
+            // maybe error
+            //m_crossing_rule->handle_rule(p);
         }
 
         if(!p.m_bigger && nullptr != m_avoidance_rule){

module_service/module_traffic_light_manager.h

@@ -103,6 +103,11 @@ struct traffic_light_manager{
         return &(it->second);
     }
 
+    void update(int x, int y, uint64_t cid)
+    {
+        m_geo_list.update(x, y, cid);
+    }
+
     bool send_light_ctrl(const int& light_id, const int& type, const int& shape){
         if(light_id > 0 && m_send_callback){
             m_send_callback(light_id, type, shape);
@@ -116,6 +121,7 @@ struct traffic_light_manager{
         m_send_callback = std::move(cb);   
     }
 
+
     private:
     bool m_stop;
     std::list<light_message> m_list_data;

module_service/module_traffic_light_rule.cpp

@@ -46,6 +46,8 @@ void crossing_rule::change_state(const uint64_t vid, traffic_light_group_ptr g)
             log_info("[traffic_light] card_id=%lld, light_id=%d", vid, pl->m_light_id);
             g->set_light(pl->m_light_id, green, red);
         }
+    }else{
+        log_warn("[traffic_light] it can't get vehicle position. vid=%lld, lg's id=%d", vid, g->m_group_id);
     }
 }
 
@@ -109,8 +111,12 @@ bool crossing_rule::handle_manual_ctrl(traffic_light_group_ptr g)
 
 bool crossing_rule::handle_crossing(traffic_light_group_ptr g)
 {
+    if(g->m_scope <= 0){
+        return false;
+    }
     // 查找一定范围的车辆
     std::vector<uint64_t> vtl = traffic_light_manager::instance()->find_nearby_vehicle(point(static_cast<int>(g->x), static_cast<int>(g->y)), g->m_scope, 0);
+    log_info("[traffic_light] handle crossing rule.gid=%d, group_scope=%.2f, vehicle's num=%d", g->m_group_id, g->m_scope, vtl.size());
     if(vtl.empty()){
         if(g->m_card_id > 0 && g->m_priority == priority_crossing)
         {
@@ -127,6 +133,7 @@ bool crossing_rule::handle_crossing(traffic_light_group_ptr g)
     {
         auto it = std::find(vtl.begin(), vtl.end(), g->m_card_id);
         if(it != vtl.end()){
+            log_info("[traffic_light] handle crossing rule, there has vehicle that control the light group, card_id=%d", g->m_card_id);
             return false;
         }
     }
@@ -150,7 +157,7 @@ bool crossing_rule::handle_avoidance(traffic_light_group_ptr g)
 
     do{
         auto vt = traffic_light_manager::instance()->find_nearby_vehicle(point(static_cast<int>(g->x), static_cast<int>(g->y)), g->m_scope, 0);
-
+        log_info("[traffic_light] handle avoidance, gid=%d, x=%.2f, y=%.2f, scope=%.2f, vehicle's size=%d", g->m_group_id, g->x, g->y, g->m_scope, vt.size());
         // 筛选大车
         if(vt.empty()){
             flag = true;
@@ -214,37 +221,44 @@ bool crossing_rule::handle_avoidance(traffic_light_group_ptr g)
 vt_traffic_group crossing_rule::handle_rule(pos_data& p)
 {
     vt_traffic_group llist;
-    for(auto it = m_vt_group.begin(); it != m_vt_group.end(); ++it){
+    log_info("[traffic_light] crossing_rule::handle_rule, group's size=%d", m_vt_group.size());
+    for(auto& it : m_vt_group){
         // 获取控制权
-        (*it)->get_turn();
-        int priority = (*it)->get_priority();
+        it->get_turn();
+        int priority = it->get_priority();
+        log_info("[traffic_light] crossing_rule::handle_rule, gid=%d, priority=%d, special=%d", it->m_group_id, priority, it->m_special);
         bool flag = false;
-        do{
+        while(true){
             if(priority_manual_ctrl == priority){
-                 flag = handle_manual_ctrl(*it);
+                 flag = handle_manual_ctrl(it);
+                 log_info("[traffic_light] crossing_rule::handle_rule, after call handle_manual_ctrl, flag=%d", flag);
                  if(flag){
                     break;
                  }
             }
 
-            if(priority <= priority_avoidance && (*it)->m_special){
-                flag = handle_avoidance(*it);
+            if(priority <= priority_avoidance && it->m_special){
+                flag = handle_avoidance(it);
+                log_info("[traffic_light] crossing_rule::handle_rule, after call handle_avoidance, flag=%d", flag);
                 if(flag){
                     break;
                 }
             }
 
             if(priority <= priority_crossing){
-                flag = handle_crossing(*it);
+                flag = handle_crossing(it);
+                log_info("[traffic_light] crossing_rule::handle_rule, after call handle_crossing, flag=%d", flag);
                 if(flag){
                     break;
                 }
             }
-        }while(false);
+
+            break;
+        };
  
-        (*it)->release_turn();
+        it->release_turn();
         if(flag){
-            llist.push_back(*it);
+            llist.push_back(it);
         }
     }
 
@@ -283,6 +297,7 @@ vt_traffic_group avoidance_rule::find_group(const point& po , int area_id, doubl
         // 求灯组到车辆的距离（车辆在灯组的左下方，则距离值取反）
         dist = vg[i]->dist_direct(po.x, po.y);
         // 车辆在灯组左边或下边
+        log_info("[traffic_light] avoidance_rule::find_group, area_id=%d, area_group=%d, dist=%.2f", area_id, vg.size(), dist);
         if(dist <= 0){
             // 速度方向与前进方向一致
             if(speed > 0){
@@ -309,6 +324,8 @@ vt_traffic_group avoidance_rule::find_group(const point& po , int area_id, doubl
 
             break;
         }
+
+        log_info("[traffic_light] the vehicle is in light group's left or down side.");
     }
 
     // 车辆在灯组右边或上边
@@ -320,6 +337,7 @@ vt_traffic_group avoidance_rule::find_group(const point& po , int area_id, doubl
         if(i >= 2 && vg[i-2]->dist(po.x, po.y) <= g_max_scope){
             llist.push_back(vg[i-2]);
         }
+        log_info("[traffic_light] the vehicle is in light group's right or up side");
     }
 
     return std::move(llist);
@@ -437,7 +455,7 @@ void avoidance_rule::change_group(const traffic_light_group_ptr& g, const point&
     if(nullptr == pl){
         return;
     }
-
+    log_info("[traffic_light] change light's status in %d group", g->m_group_id);
     // 2.获取灯组中临近车辆的灯id
     g->m_green_light_id = pl->m_light_id;
     g->get_turn();
@@ -467,10 +485,12 @@ vt_traffic_group avoidance_rule::handle_rule(pos_data& p)
         return std::move(llist);
     }
 
+    log_info("[traffic_light] avoidance_rule::handle_rule, group's size=%d, area_id=%d", m_map_area_group.size(), p.m_area_id);
     auto it = m_map_area_group.find(p.m_area_id);
     if(it != m_map_area_group.end()){
         // 根据车卡的定位坐标以及定位区域信息获取红绿灯组
-        vt_traffic_group vtg = find_group(p);
+        vt_traffic_group vtg = find_group(point(p.x, p.y), p.m_area_id, p.m_speed, p);
+        log_info("[traffic_light] handle avoidance rule, area has light, area_id=%d, card_id=%d, light_group's size=%d", p.m_area_id, p.m_card_id, vtg.size());
         if(vtg.size() == 0){
             // 所在区域没有可以控制的红绿灯组
             switch(p.m_light_group.size())
@@ -653,6 +673,8 @@ vt_traffic_group avoidance_rule::handle_rule(pos_data& p)
                     break;     
             }
         }
+    }else{
+        log_info("[traffic_light] the %d area has no light group", p.m_area_id);
     }
 
     return std::move(llist);

module_service/module_traffic_light_rule.h

@@ -57,6 +57,11 @@ struct crossing_rule: rule{
         m_vt_group = vc;
     }
 
+    int size()
+    {
+        return m_vt_group.size();
+    }
+
     private:
     vt_traffic_group m_vt_group;
 };
@@ -96,7 +101,12 @@ struct avoidance_rule: rule{
                 m_map_area_group[x->m_area_id].push_back(x);
             }
         }
-        
+    
+        int size()
+        {
+            return m_map_area_group.size();
+        }
+
     private:
         mp_traffic_group m_map_area_group;
 };

net-service.cpp

@@ -320,7 +320,7 @@ void net_service::on_message(const std::shared_ptr<client> &clt,const char*data,
                     uint32_t id = 0;
                     uint8_t type = 0;
                     is>>id>>type;
-                    //logn_info(1, "light info: light_id=%d, type=%d", id, type);
+                    logn_info(1, "light info: light_id=%d, type=%d", id, type);
                     /*auto light_ptr = light_list::instance()->get(id);
                     if(!light_ptr){
                         logn_error(1,"在全局信号灯列表中找不到信号灯：%d", id);
@@ -342,7 +342,7 @@ void net_service::on_message(const std::shared_ptr<client> &clt,const char*data,
                     uint16_t stamp = 0;
                     uint8_t status = 0;
                     is>>id>>stamp>>status;
-                    //logn_info(1, "light info: light_id=%d, stamp=%d, status=%d", id, stamp, status);
+                    logn_info(1, "light info: light_id=%d, stamp=%d, status=%d", id, stamp, status);
                     /*auto light_ptr = light_list::instance()->get(id);
                     if(!light_ptr)
                     {

websocket/wsClient.cpp

@@ -22,8 +22,6 @@ namespace YA
 		__wsclient.sync_close();
 	}
 
-	
-
 	void wsClient::_reset()
 	{
 		__Connected = false;
@@ -74,7 +72,6 @@ namespace YA
 		{
 			__wsclient.set_reconnect_attempts( 0 );
 
-
 			using std::placeholders::_1;
 			using std::placeholders::_2;
 			using std::placeholders::_3;
@@ -155,6 +152,7 @@ namespace YA
 		Login.user_password = JSON_VALUE_PASSWORD;
 
 		std::string strLogin = __jsBuilder.BuildLogin( Login );
+        log_info("send2web: cmd=%s, data=%s", JSON_CMD_VALUE_USER, strLogin.c_str());
 		strLogin += "\n";
 		sio::socket::ptr skt_ptr;
 		skt_ptr = __wsclient.socket();

websocket/wsClientMgr.cpp

@@ -44,6 +44,7 @@ namespace YA
 				char szError[1024] = { 0 };
 				sprintf( szError, "[%d] websocket client failed to connect: %s.", __wsClientList[i]->GetID(), __wsClientList[i]->get_uri().c_str() );
 				__LastError = szError;
+                std_error(szError);
 				return -1;
 			}
 		}