void Print::print() {
if (count_ < 5) {
timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
timer_.async_wait(boost::bind(&Print::print, this));
}
std::cout << "wait count " << count_ << std::endl;
count_++;
}
void start_timer(){
ping_timer->expires_at(ping_timer->expires_at() + ping_interval);
ping_timer->async_wait(boost::bind(
&sAudioReceiver::handle_timer,
this,
boost::asio::placeholders::error
));
}
void deadlineCallback(boost::asio::deadline_timer& t, udp::socket& s)
{
if (t.expires_at() <= boost::asio::deadline_timer::traits_type::now())
{
s.cancel();
t.expires_at(boost::posix_time::pos_infin);
}
t.async_wait(boost::bind(&CompactRIOCommunicationNode::deadlineCallback, this, boost::ref(t), boost::ref(s)));
}
void call_func(const boost::system::error_code&)
{
if (count >= count_max)
return;
++count;
f();
t.expires_at(t.expires_at() + boost::posix_time::millisec(500));
t.async_wait(boost::bind(&a_timer::call_func, this,
boost::asio::placeholders::error));
}
void SenderImpl::scheduleTimer(Sender_weak weak)
{
namespace ptime = boost::posix_time;
m_timer.expires_at(m_timer.expires_at() +
ptime::milliseconds(m_config->period()));
m_timer.async_wait(
boost::bind(&SenderImpl::handleTimeout,
this, weak, _1));
}
void print() {
if (m_count >= 5)
return;
std::cout << __func__ << ", m_count=" << m_count << " - " << strDate() << "\n";
m_count += 1;
m_timer.expires_at( m_timer.expires_at() + boost::posix_time::seconds(1) );
m_timer.async_wait(boost::bind(&MyClass::print, this));
//m_timer.async_wait(boost::bind(&My
}
void generate_report(const bs::error_code &ec)
{
if (!ec) {
string report = "\n";
set<Client*>::iterator it;
for (it = clients.begin(); it != clients.end(); ++it)
report += (*it)->make_report();
for (it = clients.begin(); it != clients.end(); ++it)
(*it)->send_report(report);
//std::cerr << report.c_str();
report_timer.expires_at(report_timer.expires_at() + boost::posix_time::seconds(1));
report_timer.async_wait(generate_report);
}
}
void callback(const boost::system::error_code& ec)
{
callback_finisher _(this);
if (ec == boost::asio::error::operation_aborted)
{
_completed.set();
return;
}
_proc(_ctx);
if (_repeat)
{
_timer.expires_at(_timer.expires_at() + boost::posix_time::milliseconds(_ms));
_timer.async_wait(boost::bind(&linux_timer::callback, this, boost::asio::placeholders::error));
}
else
{
_completed.set();
}
}
void checkDeadLine()
{
if (deadline_.expires_at() <= boost::asio::deadline_timer::traits_type::now())
{
if (yawAdj_ != 0.0 || heigthAdj_ != 0.0) {
drone_.Yaw(drone_.Yaw() + yawAdj_);
drone_.H(drone_.H() + heigthAdj_);
drone_.SendCmd();
}
deadline_.expires_from_now(boost::posix_time::milliseconds(50));
}
deadline_.async_wait(boost::bind(&JoystickDroneHandler::checkDeadLine, this));
}
void check_connections(const bs::error_code &ec)
{
if (!ec) {
set<Client*>::iterator it;
vector<Client*> clients_to_remove;
for (it = clients.begin(); it != clients.end(); ++it)
if ((*it)->is_connected() == true || (*it)->is_broken() == true) {
if ((*it)->is_active() == false || (*it)->is_broken() == true)
clients_to_remove.push_back(*it);
else
(*it)->set_active(false);
}
while (!clients_to_remove.empty()) {
remove_client(clients_to_remove.back());
clients_to_remove.pop_back();
}
connection_timer.expires_at(connection_timer.expires_at() + boost::posix_time::seconds(1));
connection_timer.async_wait(check_connections);
}
}
timer() : t(io_context) { t.expires_at(boost::posix_time::pos_infin); }
timer() : t(io_service) { t.expires_at(boost::posix_time::pos_infin); }
// Helper function to get a timer's expiry time.
static boost::asio::deadline_timer::time_type expiry(
const boost::asio::deadline_timer& timer)
{
return timer.expires_at();
}
int init()
{
// Use global namespace for node
node_ = ros::NodeHandlePtr(new ros::NodeHandle());
// Get tf_prefix from global namespace
node_->param("tf_prefix", tf_prefix_, std::string(""));
// Use private namespace for parameters
pnode_ = ros::NodeHandlePtr(new ros::NodeHandle("~"));
pnode_->param("publish_rate", publish_rate_, PUBLISH_RATE);
pnode_->param("fixed_frame_id", fixed_frame_id_, std::string("odom"));
fixed_frame_id_ = tf::resolve(tf_prefix_, fixed_frame_id_);
pnode_->param("publish_odom_tf", publish_odom_tf_, true);
pnode_->param("crio/ip", crio_ip_, std::string("127.0.0.1"));
pnode_->param("crio/command_port", crio_cmd_port_, std::string("39000"));
pnode_->param("crio/state_port", crio_state_port_, std::string("39001"));
pnode_->param("crio/socket_timeout", socket_timeout_, 10);
VehicleKinematics::Parameters kin_params;
tfScalar minimum_radius_outer;
if (!pnode_->getParam("kinematics/frame_id", kin_params.frame_id))
{
ROS_WARN_STREAM(pnode_->getNamespace() << "/kinematics/frame_id parameter is not set");
}
else
{
kin_params.frame_id = tf::resolve(tf_prefix_, kin_params.frame_id);
}
if (!pnode_->getParam("kinematics/wheelbase", kin_params.wheelbase_length))
{
ROS_FATAL_STREAM(pnode_->getNamespace() << "/kinematics/wheelbase parameter is not set");
return -1;
}
if (!pnode_->getParam("kinematics/track", kin_params.track_width))
{
ROS_FATAL_STREAM( pnode_->getNamespace() << "/kinematics/track parameter is not set");
return -1;
}
if (!pnode_->getParam("kinematics/rotation_center", kin_params.rotation_center))
{
ROS_WARN_STREAM(
pnode_->getNamespace()
<< "/kinematics/rotation_center parameter is not set. Using default: wheelbase/2 = "
<< kin_params.wheelbase_length / 2);
kin_params.rotation_center = kin_params.wheelbase_length / 2;
}
if (!pnode_->getParam("kinematics/minimum_radius_outer", minimum_radius_outer))
{
ROS_FATAL_STREAM(pnode_->getNamespace() << "/kinematics/minimum_radius_outer parameter is not set");
return -1;
}
else
{
kin_params.minimum_radius = minimum_radius_outer - kin_params.track_width / 2;
}
if (!pnode_->getParam("kinematics/steering_ratio", kin_params.steering_ratio))
{
ROS_FATAL_STREAM(pnode_->getNamespace() << "/kinematics/steering_ratio parameter is not set");
return -1;
}
// kin_(2.7, 1.626, 1.35);
kin_ = boost::make_shared<VehicleKinematics>(kin_params);
sub_ = node_->subscribe<kut_ugv_msgs::MotionCommandStamped>("motion_command", 200,
&CompactRIOCommunicationNode::motionCommand, this);
odom_pub_ = node_->advertise<nav_msgs::Odometry>("odom", 200);
state_pub_ = node_->advertise<kut_ugv_vehicle::StateStamped>("state", 200);
tf_br_ = boost::shared_ptr<tf::TransformBroadcaster>(new tf::TransformBroadcaster);
timeout_ = boost::posix_time::seconds(socket_timeout_);
send_ep_ = udp::endpoint(boost::asio::ip::address::from_string(crio_ip_), std::atoi(crio_cmd_port_.c_str()));
receive_ep_ = udp::endpoint(udp::v4(), std::atoi(crio_state_port_.c_str()));
socket_.open(udp::v4());
deadline_.expires_at(boost::posix_time::pos_infin);
this->deadlineCallback(deadline_, socket_);
return 0;
}
void set_timer(boost::posix_time::ptime time, boost::function<void(const boost::system::error_code&)> handler) {
t.expires_at(time);
t.async_wait(handler);
}