// Copyright (c) 2025, The Robot Web Tools Contributors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "clock_event.h" #include #include #include #include #include #include #include #include #include "macros.h" #include "rcl_handle.h" namespace rclnodejs { template void ClockEvent::wait_until(rcl_clock_t* clock, rcl_time_point_t until) { // Synchronize because clock epochs might differ rcl_time_point_value_t now_value; rcl_ret_t ret = rcl_clock_get_now(clock, &now_value); if (RCL_RET_OK != ret) { throw std::runtime_error("failed to get current time"); } rcl_time_point_t rcl_entry; rcl_entry.nanoseconds = now_value; rcl_entry.clock_type = clock->type; const typename ClockType::time_point chrono_entry = ClockType::now(); rcl_duration_t delta_t; ret = rcl_difference_times(&rcl_entry, &until, &delta_t); if (RCL_RET_OK != ret) { throw std::runtime_error("failed to subtract times"); } // Cast because system clock resolution is too big for nanoseconds on Windows // & OSX const typename ClockType::time_point chrono_until = chrono_entry + std::chrono::duration_cast( std::chrono::nanoseconds(delta_t.nanoseconds)); std::unique_lock lock(mutex_); cv_.wait_until(lock, chrono_until, [this]() { return state_; }); } void ClockEvent::wait_until_ros(rcl_clock_t* clock, rcl_time_point_t until) { bool is_enabled; rcl_ret_t ret = rcl_is_enabled_ros_time_override(clock, &is_enabled); if (RCL_RET_OK != ret) { throw std::runtime_error("failed to check if ros time override is enabled"); } // Check if ROS time is enabled in C++ to avoid TOCTTOU with TimeSource if (is_enabled) { std::unique_lock lock(mutex_); // Caller must have setup a time jump callback to wake this event cv_.wait(lock, [this]() { return state_; }); } else { // ROS time not enabled is system time wait_until(clock, until); } } bool ClockEvent::is_set() { std::unique_lock lock(mutex_); return state_; } void ClockEvent::set() { { std::unique_lock lock(mutex_); state_ = true; } cv_.notify_all(); } void ClockEvent::clear() { { std::unique_lock lock(mutex_); state_ = false; } cv_.notify_all(); } // Explicit instantiation template void ClockEvent::wait_until( rcl_clock_t* clock, rcl_time_point_t until); template void ClockEvent::wait_until( rcl_clock_t* clock, rcl_time_point_t until); enum class WaitType { Steady, System, Ros }; class ClockEventWaitWorker : public Napi::AsyncWorker { public: ClockEventWaitWorker(Napi::Env env, ClockEvent* event, rcl_clock_t* clock, int64_t until, WaitType type) : Napi::AsyncWorker(env), event_(event), clock_(clock), until_(until), type_(type), deferred_(Napi::Promise::Deferred::New(env)) {} ~ClockEventWaitWorker() {} void Execute() override { try { rcl_time_point_t until_time_point; until_time_point.nanoseconds = until_; until_time_point.clock_type = clock_->type; switch (type_) { case WaitType::Ros: event_->wait_until_ros(clock_, until_time_point); break; case WaitType::Steady: event_->wait_until(clock_, until_time_point); break; case WaitType::System: event_->wait_until(clock_, until_time_point); break; } } catch (const std::exception& e) { SetError(e.what()); } } void OnOK() override { deferred_.Resolve(Env().Undefined()); } void OnError(const Napi::Error& e) override { deferred_.Reject(e.Value()); } Napi::Promise Promise() { return deferred_.Promise(); } private: ClockEvent* event_; rcl_clock_t* clock_; int64_t until_; WaitType type_; Napi::Promise::Deferred deferred_; }; Napi::Value CreateClockEvent(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); ClockEvent* event = new ClockEvent(); return RclHandle::NewInstance(env, event, nullptr, [](void* ptr) { delete static_cast(ptr); }); } Napi::Value ClockEventWaitUntilSteady(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); RclHandle* clock_handle = RclHandle::Unwrap(info[1].As()); rcl_clock_t* clock = static_cast(clock_handle->ptr()); bool lossless; int64_t until = info[2].As().Int64Value(&lossless); if (!lossless) { Napi::TypeError::New(env, "until value lost precision during conversion") .ThrowAsJavaScriptException(); return env.Undefined(); } auto worker = new ClockEventWaitWorker(env, event, clock, until, WaitType::Steady); worker->Queue(); return worker->Promise(); } Napi::Value ClockEventWaitUntilSystem(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); RclHandle* clock_handle = RclHandle::Unwrap(info[1].As()); rcl_clock_t* clock = static_cast(clock_handle->ptr()); bool lossless; int64_t until = info[2].As().Int64Value(&lossless); if (!lossless) { Napi::TypeError::New(env, "until value lost precision during conversion") .ThrowAsJavaScriptException(); return env.Undefined(); } auto worker = new ClockEventWaitWorker(env, event, clock, until, WaitType::System); worker->Queue(); return worker->Promise(); } Napi::Value ClockEventWaitUntilRos(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); RclHandle* clock_handle = RclHandle::Unwrap(info[1].As()); rcl_clock_t* clock = static_cast(clock_handle->ptr()); bool lossless; int64_t until = info[2].As().Int64Value(&lossless); if (!lossless) { Napi::TypeError::New(env, "until value lost precision during conversion") .ThrowAsJavaScriptException(); return env.Undefined(); } auto worker = new ClockEventWaitWorker(env, event, clock, until, WaitType::Ros); worker->Queue(); return worker->Promise(); } Napi::Value ClockEventIsSet(const Napi::CallbackInfo& info) { RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); return Napi::Boolean::New(info.Env(), event->is_set()); } Napi::Value ClockEventSet(const Napi::CallbackInfo& info) { RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); event->set(); return info.Env().Undefined(); } Napi::Value ClockEventClear(const Napi::CallbackInfo& info) { RclHandle* event_handle = RclHandle::Unwrap(info[0].As()); ClockEvent* event = static_cast(event_handle->ptr()); event->clear(); return info.Env().Undefined(); } void InitClockEventBindings(Napi::Env env, Napi::Object exports) { exports.Set("createClockEvent", Napi::Function::New(env, CreateClockEvent)); exports.Set("clockEventWaitUntilSteady", Napi::Function::New(env, ClockEventWaitUntilSteady)); exports.Set("clockEventWaitUntilSystem", Napi::Function::New(env, ClockEventWaitUntilSystem)); exports.Set("clockEventWaitUntilRos", Napi::Function::New(env, ClockEventWaitUntilRos)); exports.Set("clockEventIsSet", Napi::Function::New(env, ClockEventIsSet)); exports.Set("clockEventSet", Napi::Function::New(env, ClockEventSet)); exports.Set("clockEventClear", Napi::Function::New(env, ClockEventClear)); } } // namespace rclnodejs