void shutDown() { cout << "System shutting down." << endl; websocket_server.close(currentState.client, 0, "shutdown"); websocket_server.stop(); gpioTerminate(); std::exit(EXIT_SUCCESS); //system("shutdown -P now"); return; }
static bool add_to_autoload (server& srv, const std::string& world_name) { auto& conn = srv.sql ().pop (); int count = conn.query ( "SELECT count(*) FROM `autoloaded-worlds` WHERE `name`='" + world_name + "'").step ().at (0).as_int (); if (count != 0) return false; conn.execute ( "INSERT INTO `autoloaded-worlds` (`name`) VALUES ('" + world_name + "')"); srv.sql ().push (conn); return true; }
void report_time(const server& s, boost::posix_time::time_duration time) { server_times_.update_resp_time(s.get_id(), time.total_microseconds()); uint32_t new_reqs_sec = server_times_.reqs_sec(s); update_server(s, new_reqs_sec); }
static bool remove_from_autoload (server& srv, const std::string& world_name) { auto& conn = srv.sql ().pop (); int count = conn.query ( "SELECT count(*) FROM `autoload-worlds` WHERE `name`='" + world_name + "'").step ().at (0).as_int (); if (count == 0) return false; conn.execute ( "DELETE FROM `autoload-worlds` WHERE `name`='" + world_name + "'"); srv.sql ().push (conn); return true; }
void report_timeout(const server& s) { server_times_.update_resp_timeout(s.get_id()); uint32_t new_reqs_sec = server_times_.reqs_sec(s); update_server(s, new_reqs_sec); }
void _test_websocket_server::send_msg(const test_websocket_msg& msg) { // Wait for the websocket server to be initialized. pplx::task<void>(m_server_connected).wait(); const auto& data = msg.data(); auto flags = websocketpp::frame::opcode::close; switch (msg.msg_type()) { case test_websocket_message_type::WEB_SOCKET_UTF8_MESSAGE_TYPE: flags = websocketpp::frame::opcode::text; // WebSocket::FRAME_FLAG_FIN | WebSocket::FRAME_OP_TEXT; break; case test_websocket_message_type::WEB_SOCKET_BINARY_MESSAGE_TYPE: flags = websocketpp::frame::opcode::binary; // WebSocket::FRAME_FLAG_FIN | WebSocket::FRAME_OP_BINARY; break; case test_websocket_message_type::WEB_SOCKET_CLOSE_TYPE: flags = websocketpp::frame::opcode::close; // WebSocket::FRAME_OP_CLOSE; break; case test_websocket_message_type::WEB_SOCKET_UTF8_FRAGMENT_TYPE: case test_websocket_message_type::WEB_SOCKET_BINARY_FRAGMENT_TYPE: default: throw std::runtime_error("invalid message type"); } std::string strmsg(data.begin(), data.end()); if (msg.msg_type() == test_websocket_message_type::WEB_SOCKET_CLOSE_TYPE) { close(strmsg); } else { // std::cerr << "Sending message from server: " << strmsg << std::endl; m_srv.send(m_con, strmsg, flags); } }
int senddata( const server &sv, const char *buffer, u32 len ) { sockaddr_in to = ( sv.tosockaddr() ); int bytes = sendto( mSocket, buffer, len, 0, (sockaddr *)&to, sizeof( to ) ); if ( bytes > 0 ) UPLOAD.update( bytes + UDP_HEADER_SIZE ); return ( bytes ); }
void update_server(const server& s, uint32_t new_reqs_sec) { server_tree_iter_map::const_iterator it = servers_map_.find(s.get_id()); if (it != servers_map_.end()) { servers_.change_count(it->second, new_reqs_sec); } }
/* Run server and return output test rig */ std::string run_server_test(server& s, std::string input) { server::connection_ptr con; std::stringstream output; s.register_ostream(&output); s.clear_access_channels(websocketpp::log::alevel::all); s.clear_error_channels(websocketpp::log::elevel::all); con = s.get_connection(); con->start(); std::stringstream channel; channel << input; channel >> *con; return output.str(); }
void * speedometer(void * argument) { const timespec waitTime = { 0, MOUSE_SAMPLE_RATE }; cout << waitTime.tv_nsec << " " << waitTime.tv_sec << endl; int fd; struct input_event ie; if ((fd = open(MOUSE_FILE, O_RDONLY)) == -1) { perror("opening device"); // exit(1); } int flags = fcntl(fd, F_GETFL, 0); fcntl(fd, F_SETFL, flags | O_NONBLOCK); int counter = 0; while (true) { //cout << "hello from the speedometer" << endl; nanosleep(&waitTime, NULL); //cout << "wait over" << endl; counter = 0; while (read(fd, &ie, sizeof(struct input_event)) != -1) { //cout << "reading mouse" << endl; if ((ie.type == 2) && (ie.code == 8)) { counter++; // cout << "new mouse event " << counter << endl; } } //cout << "aquireing mutex" << endl; //cout << "aquired mutex" << endl; currentState.speed = (counter * MOUSE_MM_PER_CLICK) * 10; //mm/s currentState.distanceTraveled = counter * MOUSE_MM_PER_CLICK; //mm. //cout << "speed: " << currentState.speed << " distance: " << currentState.distanceTraveled << endl; ptree answerJson; stringstream jsonWriteStream; answerJson.put("speed", currentState.speed); answerJson.put("distanceTraveled", currentState.distanceTraveled); write_json(jsonWriteStream, answerJson); //cout << "sending speedometer" << endl; //pthread_mutex_lock(&watchDog_mutex); if (currentState.connected) { websocket_server.send(currentState.client, jsonWriteStream.str(), websocketpp::frame::opcode::text); } //pthread_mutex_unlock(&watchDog_mutex); //cout << "released mutex" << endl; } return 0; }
void worker::do_accept(tcp::acceptor& acceptor, server& srv) { while (acceptor.is_open()) { bs::error_code ec; // get an io service to use for a new client, we pick them via round robin auto& worker = srv.impl()->get_worker(); auto& iosvc = worker.io_service(); auto new_session = std::make_shared<session>(srv, iosvc); acceptor.async_accept(new_session->socket(), bfa::yield[ec]); if (!ec) { worker.add_session(new_session); worker.m_new_session_cv.notify_one(); } } }
/* * Constructs a new IRC client on top of hte specified socket and event base. */ irc_client::irc_client (server &srv, struct event_base *evbase, int sock) : srv (srv), log (srv.get_logger ()) { this->evbase = evbase; this->sock = sock; this->bufev = bufferevent_socket_new (evbase, sock, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb (this->bufev, &hCraft::irc_client::handle_read, &hCraft::irc_client::handle_write, &hCraft::irc_client::handle_event, this); bufferevent_enable (this->bufev, EV_READ | EV_WRITE); this->total_read = 0; this->fail = false; this->connected = false; }
bool validate(server & s, connection_hdl hdl) { server::connection_ptr con = s.get_con_from_hdl(hdl); std::cout << "Cache-Control: " << con->get_request_header("Cache-Control") << std::endl; const std::vector<std::string> & subp_requests = con->get_requested_subprotocols(); std::vector<std::string>::const_iterator it; for (it = subp_requests.begin(); it != subp_requests.end(); ++it) { std::cout << "Requested: " << *it << std::endl; } if (subp_requests.size() > 0) { con->select_subprotocol(subp_requests[0]); } return true; }
void block_generation_loop() { while( !_block_gen_loop_complete.canceled() ) { if( _pending.size() && (fc::time_point::now() - _current_block.timestamp) > fc::seconds(60) ) { signed_block next_block; next_block.number = _current_block.number + 1; auto next_diff = _current_block.difficulty * 500 / _pending.size(); next_diff = (_current_block.difficulty * 99 + next_diff) / 100; next_block.difficulty = std::max<uint64_t>(next_diff, 1000 ); next_block.timestamp = fc::time_point::now(); for( auto rec : _pending ) { next_block.records.push_back( rec.second ); } next_block.sign( _trustee_key ); _block_database.store(next_block.number,next_block); for( uint32_t rec = 0; rec < next_block.records.size(); ++rec ) { auto new_rec = next_block.records[rec]; auto hist = _self->fetch_history( new_rec.name ); hist.updates.push_back( name_index( next_block.number, rec ) ); _name_index.store( new_rec.name, hist ); _key_to_name.store( new_rec.active_key.to_base58(), new_rec.name ); } _current_block = next_block; _current_block_id = _current_block.id(); fc::path block_file = _data_dir / "block" / fc::to_string( uint64_t(_current_block.number) ); std::ofstream out( block_file.generic_string().c_str() ); auto block_str = fc::json::to_pretty_string( _current_block ); out.write( block_str.c_str(), block_str.size() ); } fc::usleep( fc::seconds( 1 ) ); } }
/// Constructor connection( server& parent, tcp::endpoint const& ep, tcp::socket&& sock) : log_(parent.log_) , ep_(ep) , ws_(std::move(sock)) , timer_(ws_.get_io_service(), (clock_type::time_point::max)()) , strand_(ws_.get_io_service()) , id_([] { static std::atomic<std::size_t> n{0}; return ++n; }()) { // Invoke the callback for new connections if set. // This allows the settings on the websocket stream // to be adjusted. For example to turn compression // on or off or adjust the read and write buffer sizes. // if(parent.mod_) parent.mod_(ws_); }
static void _init_sql_tables (world *w, server &srv) { soci::session sql (srv.sql_pool ()); // block history table sql.once << "CREATE TABLE IF NOT EXISTS `block_history_" << w->get_name () << "` (" "`x` INT, `y` INT, `z` INT, " // pos "`old_id` SMALLINT UNSIGNED, `old_meta` TINYINT UNSIGNED, `old_ex` TINYINT UNSIGNED, " // old value "`new_id` SMALLINT UNSIGNED, `new_meta` TINYINT UNSIGNED, `new_ex` TINYINT UNSIGNED, " // new value "`pid` INTEGER UNSIGNED, `time` BIGINT UNSIGNED)"; { // create index int c; sql << "SELECT Count(1) IndexIsThere FROM INFORMATION_SCHEMA.STATISTICS " "WHERE table_schema=DATABASE() AND table_name='block_history_" << w->get_name () << "' AND index_name='bh_index_" << w->get_name () << "'", soci::into (c); if (c == 0) sql.once << "CREATE INDEX `bh_index_" << w->get_name () << "` ON `block_history_" << w->get_name () << "` (`x`, `y`, `z`)"; } }
void handle_request( const fc::http::request& r, const fc::http::server::response& s ) { //ilog( "handle request ${r}", ("r",r.path) ); s.add_header( "Connection", "close" ); try { auto pos = r.path.find( "/", 1 ); auto first_dir = r.path.substr(1,pos); //ilog( "command: ${command}", ("command",first_dir) ); if( first_dir == "pending" ) { s.set_status( fc::http::reply::OK ); auto pending_json = fc::json::to_string( _pending ); s.set_length( pending_json.size() ); s.write( pending_json.c_str(), pending_json.size() ); } else if( first_dir == "update_record" ) { FC_ASSERT( r.body.size() ); std::string str(r.body.data(),r.body.size()); auto rec = fc::json::from_string( str ).as<signed_name_record>(); _self->update_record( rec ); s.set_status( fc::http::reply::RecordCreated ); s.set_length( 12 ); s.write( "Record Created", 12 ); } else if( first_dir == "fetch_by_name/" ) { auto name = r.path.substr( pos+1, std::string::npos ); auto record = _self->fetch_record( name ); s.set_status( fc::http::reply::Found ); auto blkjson = fc::json::to_string( record ); s.set_length( blkjson.size() ); s.write( blkjson.c_str(), blkjson.size() ); } else if( first_dir == "fetch_by_key/" ) { auto key = r.path.substr( pos+1, std::string::npos ); auto record = _self->fetch_record_by_key( key ); s.set_status( fc::http::reply::Found ); auto blkjson = fc::json::to_string( record ); s.set_length( blkjson.size() ); s.write( blkjson.c_str(), blkjson.size() ); } else if( first_dir == "store_key/" ) { auto name = r.path.substr( pos+1, std::string::npos ); std::string str(r.body.data(),r.body.size()); auto rec = fc::json::from_string( str ).as<stored_key>(); _self->store_key( name, rec ); s.set_status( fc::http::reply::RecordCreated ); s.set_length( 12 ); s.write( "Record Created", 12 ); } else if( first_dir == "fetch_key/" ) { auto user_name = r.path.substr( pos+1, std::string::npos ); auto key_data = _self->fetch_key( user_name ); s.set_status( fc::http::reply::Found ); auto blkjson = fc::json::to_string( key_data ); s.set_length( blkjson.size() ); s.write( blkjson.c_str(), blkjson.size() ); } else if( first_dir == "fetch_block/" ) { auto block_num = r.path.substr( pos+1, std::string::npos ); auto blk = _self->fetch_block( fc::to_uint64( block_num ) ); s.set_status( fc::http::reply::Found ); auto blkjson = fc::json::to_string( blk ); s.set_length( blkjson.size() ); s.write( blkjson.c_str(), blkjson.size() ); } else { auto dotpos = r.path.find( ".." ); FC_ASSERT( dotpos == std::string::npos ); auto filename = _data_dir / r.path.substr(1,std::string::npos); if( fc::exists( filename ) ) { FC_ASSERT( !fc::is_directory( filename ) ); auto file_size = fc::file_size( filename ); FC_ASSERT( file_size != 0 ); fc::file_mapping fm( filename.generic_string().c_str(), fc::read_only ); fc::mapped_region mr( fm, fc::read_only, 0, fc::file_size( filename ) ); s.set_status( fc::http::reply::OK ); s.set_length( file_size ); s.write( (const char*)mr.get_address(), mr.get_size() ); return; } s.set_status( fc::http::reply::NotFound ); s.set_length( 9 ); s.write( "Not Found", 9 ); } } catch ( const fc::exception& e ) { s.set_status( fc::http::reply::BadRequest ); auto msg = e.to_detail_string(); s.set_length( msg.size() ); if( msg.size() ) { s.write( msg.c_str(), msg.size() ); } } }
int main(int argc, char **argv) { /* Program start */ /* * * */ int i; int port = 5000; char *bind = (char *)"0.0.0.0"; bool daemon = false; /* Help info */ for(i=0;i<argc;i++) { if(strcmp(argv[i],"-h")==0||strcmp(argv[i],"--help")==0) { out("Usage: cframes [options]\n"); out("\t-p, --port PORT\tBind server socket to specified PORT\n"); out("\t\t\tDefault: 5000\n"); out("\t-b, --bind IP\tBind server to specified IP\n"); out("\t\t\tDefault: 0.0.0.0\n"); out("\t-d, --daemon\tForks server process\n"); out("\t-h, --help\tDisplay this help and exit\n"); out("\t-v, --version\tDisplay version information and exit\n"); return 0; } } /* Version info */ for(i=0;i<argc;i++) { if(strcmp(argv[i],"-v")==0||strcmp(argv[i],"--version")==0) { out("cframes 1.0.1\n"); return 0; } } /* Program arguments */ for(i=0;i<argc;i++) { if(strcmp(argv[i],"-p")==0||strcmp(argv[i],"--port")==0) { port = (int)argv[i+1]; } if(strcmp(argv[i],"-b")==0||strcmp(argv[i],"--bind")==0) { bind = (char *)argv[i+1]; } if(strcmp(argv[i],"-d")==0||strcmp(argv[i],"--daemon")==0) { daemon = true; } } /* Start the server */ out("Starting cframes server..........."); s.start(port); out("OK\n"); out("Listening on http://"); out(bind);out(":");out("5000");out("\n\n"); /* Single-threaded forever loop to handle requests -- NOTE: eventually will have a daemon option -d */ for(i=0;i<50;i++) { www(); } /* Stop the server */ s.stop(); return 0; }
int compare_port(const server& other) const { return get_port() - other.get_port(); }
void on_open(connection_hdl hdl) { holdThreads[hdl]=0;//just an example. Creates a new item for every connection. Gets deleted on close m_server.send(hdl,"message", websocketpp::frame::opcode::text); }
void run(uint16_t port) { m_server.listen(port); m_server.start_accept(); m_server.run(); }
int main() { ////////////////////////init current state//////////////// currentState.connected = false; currentState.autonomous = false; currentState.cruise = false; currentState.leftTurn = false; currentState.rightTurn = false; currentState.turnPeaked = false; currentState.signalOn = false; currentState.obsticle = false; currentState.servoInt = 0; currentState.motorInt = 0; currentState.speed = 0; currentState.lastMessageTime = 0; currentState.distanceTraveled = 0; currentState.lastRequestedMotorInt = 0; currentState.sonarRange = 200; currentState.cameraAngle = 0; ////////////////////////GPIO setup//////////////////////// int GPIOstatus; int GPIOfrequencySteering; int GPIOfrequencyMotor; GPIOstatus = gpioInitialise(); //required for GPIO to function if (GPIOstatus < 0) //did we succeed { fprintf(stderr, "pigpio initialisation failed.\n"); return 1; } //steering gpioSetPWMrange(GPIO_STEERING_CONTROL, 255); gpioSetPWMfrequency(GPIO_STEERING_CONTROL, 0); GPIOfrequencySteering = gpioGetPWMfrequency(GPIO_STEERING_CONTROL); int GPIOrangeSteering = gpioGetPWMrange(GPIO_MOTOR_CONTROL); //motor gpioSetPWMrange(GPIO_MOTOR_CONTROL, 255); gpioSetPWMfrequency(GPIO_MOTOR_CONTROL, 250); int GPIOrangeMotor = gpioGetPWMrange(GPIO_MOTOR_CONTROL); GPIOfrequencyMotor = gpioGetPWMfrequency(GPIO_MOTOR_CONTROL); cout << "FREQ: Using " << GPIOfrequencySteering << " for steering and " << GPIOfrequencyMotor << " for motor." << endl; cout << "RANGE: Using " << GPIOrangeSteering << " for steering and " << GPIOrangeMotor << "for motor." << endl; //gpioSetAlertFunc(GPIOsteeringControl, GPIOcallBack); gpioServo(GPIO_STEERING_CONTROL, SERVO_CENTER); //set steering to straight //set mode of turn signals to output gpioSetMode(GPIO_RIGHT_TURN_SIGNAL, PI_OUTPUT); gpioSetMode(GPIO_LEFT_TURN_SIGNAL, PI_OUTPUT); /////////////////////////threads//////////////////////////// pthread_create(&watchDog_th, NULL, watchDog, NULL); pthread_create(&turnSignal_th, NULL, turnSignal, NULL); //pthread_create(&sonar_th, NULL, sonar, NULL); pthread_create(&speedometer_th, NULL, speedometer, NULL); pthread_create(&laneDetect_th, NULL, laneDetect, NULL); pthread_create(&motorControl_th, NULL, motorControl, NULL); ////////////////////////Websocket Server setup//////////////////////// //what function should be called on a new message websocket_server.set_message_handler(&on_message);//what function should be called on a new message websocket_server.set_open_handler(&on_open); websocket_server.set_close_handler(&on_close); websocket_server.init_asio(); //What ip version and port should we listen on websocket_server.listen(boost::asio::ip::tcp::v4(), 8080); websocket_server.start_accept(); //Way to much log websocket_server.clear_access_channels(websocketpp::log::alevel::all); cout << "Starting RoadStar server" << endl; websocket_server.run(); //start the server gpioTerminate(); return 0; }
root_room::root_room(server &svr) : private_room(svr, "_root_room", svr.get_root()->get_password()) {}
void on_message(websocketpp::connection_hdl hdl, server::message_ptr msg) { try { //cout << "message" << endl; //immediatly send back a message for timing purposes //websocket_server.send(hdl ,"TIME",websocketpp::frame::opcode::text); //parse the json ptree parsedJson; stringstream jsonStream; jsonStream << msg->get_payload(); read_json(jsonStream, parsedJson); if (parsedJson.get<bool>("triangle")) { cout << "Received triangle" << endl; shutDown(); } //toggle autonomous mode if (parsedJson.get<bool>("start")) { pthread_mutex_lock(&autonomous_mutex); if (currentState.autonomous == true) { currentState.autonomous = false; cout << "Autonomous mode off." << endl; } else { currentState.autonomous = true; cout << "Autonomous mode on." << endl; } pthread_mutex_unlock(&autonomous_mutex); } pthread_mutex_lock(&autonomous_mutex); if (currentState.autonomous != true) { //update the servo values currentState.servoInt = (int) (SERVO_CENTER + (parsedJson.get<double>("leftAnalog_x") * MAX_STEERING_OFFSET)); if (parsedJson.get<double>("rightAnalog_y") < 0) { currentState.cruise = false; } if (currentState.cruise == false) { //skip the center range int requestedMotorInt = 0; pthread_mutex_lock(&obsticle_mutex); if ((parsedJson.get<double>("rightAnalog_y") > 0) && (currentState.obsticle != true)) { //forward //cout << "rightAnalog_y: " << parsedJson.get<double>("rightAnalog_y") << endl; requestedMotorInt = (int) (parsedJson.get<double>( "rightAnalog_y") * MOTOR_FORWARD_RANGE); //cout << "requestedMotirInt(forward): " << requestedMotorInt << endl; if ((requestedMotorInt - currentState.lastRequestedMotorInt) > ACCELERATION_THRESHOLD) { requestedMotorInt = currentState.lastRequestedMotorInt + ACCELERATION_THRESHOLD; //cout << "Don't accelerate so quickly!" << endl; } currentState.motorInt = MOTOR_FORWARD_START + requestedMotorInt; } else if (parsedJson.get<double>("rightAnalog_y") < 0) { //backward //cout << "rightAnalog_y: " << parsedJson.get<double>("rightAnalog_y") << endl; requestedMotorInt = -1 * (int) (parsedJson.get<double>("rightAnalog_y") * MOTOR_BACKWARD_RANGE); //cout << "requestedMotirInt(backward): " << requestedMotorInt << endl; if ((currentState.lastRequestedMotorInt - requestedMotorInt) > ACCELERATION_THRESHOLD) { requestedMotorInt = currentState.lastRequestedMotorInt - ACCELERATION_THRESHOLD; //cout << "Don't accelerate (backwards) so quickly!" << endl; } currentState.motorInt = MOTOR_BACKWARD_START - requestedMotorInt; if (currentState.cruise) { currentState.cruise = false; // cout << "Cruise mode off." << endl; } } else { //stop currentState.motorInt = SERVO_CENTER; } pthread_mutex_unlock(&obsticle_mutex); //cout << "updating lastRequestedMotorInt: " << currentState.lastRequestedMotorInt << endl; currentState.lastRequestedMotorInt = requestedMotorInt; //update motor //cout << "Current value of motorInt: " << currentState.motorInt << endl; gpioServo(GPIO_MOTOR_CONTROL, currentState.motorInt); } //update servo gpioServo(GPIO_STEERING_CONTROL, currentState.servoInt); //toggle turn signal //right pthread_mutex_lock(&turnSignal_mutex); if (parsedJson.get<bool>("R1")) { if (currentState.rightTurn == true) { currentState.rightTurn = false; currentState.leftTurn = false; //cout << "Right turn signal off." << endl; } else { currentState.rightTurn = true; currentState.leftTurn = false; //cout << "Right turn signal on." << endl; } } //left if (parsedJson.get<bool>("L1")) { if (currentState.leftTurn == true) { currentState.leftTurn = false; currentState.rightTurn = false; //cout << "Left turn signal off." << endl; } else { currentState.leftTurn = true; currentState.rightTurn = false; //cout << "Left turn signal on." << endl; } } //check for peak if (currentState.leftTurn || currentState.rightTurn) { if (currentState.turnPeaked) { if (currentState.servoInt == SERVO_CENTER) { currentState.leftTurn = false; currentState.rightTurn = false; currentState.turnPeaked = false; //cout << "Turn complete" << endl; } } else { if (currentState.leftTurn) { if (currentState.servoInt < (SERVO_CENTER - TURN_THRESHOLD)) { currentState.turnPeaked = true; } } else if (currentState.rightTurn) { if (currentState.servoInt > (SERVO_CENTER + TURN_THRESHOLD)) { currentState.turnPeaked = true; } } } } pthread_mutex_unlock(&turnSignal_mutex); //toggle cruise mode if (parsedJson.get<bool>("left")) { if (currentState.cruise == true) { currentState.cruise = false; cout << "Cruise mode off" << endl; } else { currentState.cruise = true; cout << "Cruise mode on" << endl; } } if (parsedJson.get<bool>("up")) { currentState.motorInt = currentState.motorInt + 10; gpioServo(GPIO_MOTOR_CONTROL, currentState.motorInt); //cout << "Current value of motorInt: " << currentState.motorInt << endl; } else if (parsedJson.get<bool>("down")) { currentState.motorInt = currentState.motorInt - 10; gpioServo(GPIO_MOTOR_CONTROL, currentState.motorInt); //cout << "Current value of motorInt: " << currentState.motorInt << endl; } } pthread_mutex_unlock(&autonomous_mutex); ptree answerJson; stringstream jsonWriteStream; answerJson.put("left_blinker", currentState.leftTurn); answerJson.put("right_blinker", currentState.rightTurn); write_json(jsonWriteStream, answerJson); //cout << "sending speedometer" << endl; if (currentState.connected) { websocket_server.send(currentState.client, jsonWriteStream.str(), websocketpp::frame::opcode::text); } //keep track of message recieved times. unsigned long currentTime = time(NULL); pthread_mutex_lock(&watchDog_mutex); //cout << "currentTime=" << currentTime << endl; currentState.lastMessageTime = currentTime; currentState.connected = true; pthread_mutex_unlock(&watchDog_mutex); } catch (std::exception const& e) { cerr << "<ERROR>" << endl; cerr << e.what() << endl; cerr << msg->get_payload() << endl; cerr << "</ERROR>" << endl; } }
WS(){ m_server.init_asio(); m_server.set_open_handler(bind(&WS::on_open,this,::_1)); m_server.set_close_handler(bind(&WS::on_close,this,::_1)); m_server.set_message_handler(bind(&WS::on_message,this,::_1,::_2)); }