id stringlengths 15 54 | text stringlengths 3 133k | title stringclasses 1
value |
|---|---|---|
hardware_control/25749_5.txt | I followed the ros2 control course and tried to use the dynamixel hardware
interface in my own labtop and this error was come. I’m not familiar with C++
so If someone know what should I fix, please tell me. Basically, I just copy
and paste the code from the code to my pkg. I use ros2 foxy and DynamixelSDK
and also work... | |
hardware_control/resourcemanagercpp_16.txt | if (result)
{
RCUTILS_LOG_INFO_NAMED(
"resource_manager", "Successful initialization of hardware '%s'",
hardware_info.name.c_str());
}
else
{
RCUTILS_LOG_INFO_NAMED(
"resource_manager", "Failed to initialize hardware '%s'", hardware_info.name.c_str());
}
r... | |
hardware_control/resourcemanagercpp_108.txt | return resource_storage_->hardware_info_map_;
} | |
hardware_control/resourcemanagercpp_102.txt | // CM API: Called in "callback/slow"-thread
bool ResourceManager::command_interface_is_available(const std::string & name) const
{
std::lock_guard<std::recursive_mutex> guard(resource_interfaces_lock_);
return std::find(
resource_storage_->available_command_interfaces_.begin(),
resource_storag... | |
hardware_control/25749_0.txt | [ The Construct ROS Community ](/) | |
hardware_control/classhardwareinterfa_10.txt | double | **get_value** () const
## Additional Inherited Members
---
 Protected Attributes inherited from [
hardware_interface::ReadOnlyHandle
](classhardware__interface_1_1ReadOnlyHandle.html)
std::string | **name_**
std::string | **interface_name_**
double * | **value_ptr_** ... | |
hardware_control/resourcemanagercpp_97.txt | std::lock_guard<std::recursive_mutex> guard_claimed(claimed_command_interfaces_lock_);
if (command_interface_is_claimed(key))
{
throw std::runtime_error(
std::string("Command interface with '") + key + "' is already claimed");
} | |
hardware_control/resourcemanagercpp_100.txt | // CM API: Called in "callback/slow"-thread
std::vector<std::string> ResourceManager::command_interface_keys() const
{
std::vector<std::string> keys;
std::lock_guard<std::recursive_mutex> guard(resource_interfaces_lock_);
for (const auto & item : resource_storage_->command_interface_map_)
{
keys.push_back(s... | |
hardware_control/resourcemanagercpp_52.txt | if (hardware_info.is_async)
{
load_and_init_systems(async_systems_);
}
else
{
load_and_init_systems(systems_);
}
} | |
hardware_control/1240_28.txt | ---|---|---
| | void import_command_interfaces(HardwareT & hardware)
| | {
| | auto interfaces = hardware.export_command_interfaces();
| | std::vector<std::shared_ptr<CommandInterface>> interfaces =
| | hardware.export_command_interfaces();
Copy link
Member
###
![@saikishor](https://avatars.git... | |
hardware_control/20211WRMeetupGetting_5.txt | URDF and ros2_control
<ros2_control name="${name}" type="system">
<hardware>
<plugin>fake_components/GenericSystem</plugin>
</hardware>
<joint name="joint1">
<command_interface name="position">
<param name="min">-1</param>
<param name="max">1</param>
</command_interface>
<state_interface name="position"/>
</j... | |
hardware_control/resourcemanagercpp_17.txt | template <class HardwareT>
bool configure_hardware(HardwareT & hardware)
{
bool result = trigger_and_print_hardware_state_transition(
std::bind(&HardwareT::configure, &hardware), "configure", hardware.get_name(),
lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE); | |
hardware_control/25749_6.txt |
In file included from /home/tharit/ros2_ws/src/dynamixel_hardware_interface/src/dynamixel_hardware_interface.cpp:7:
/home/tharit/ros2_ws/src/dynamixel_hardware_interface/include/dynamixel_hardware_interface/dynamixel_hardware_interface.hpp:44:3: error: ‘CallbackReturn’ does not name a type
44 |... | |
hardware_control/resourcemanagercpp_137.txt | // BEGIN: "used only in tests and locally"
size_t ResourceManager::actuator_components_size() const
{
return resource_storage_->actuators_.size();
} | |
hardware_control/resourcemanagercpp_133.txt | // CM API: Called in "update"-thread
HardwareReadWriteStatus ResourceManager::write(
const rclcpp::Time & time, const rclcpp::Duration & period)
{
std::lock_guard<std::recursive_mutex> guard(resources_lock_);
read_write_status.ok = true;
read_write_status.failed_hardware_names.clear(); | |
hardware_control/25749_30.txt | By this the error about override came. So I just delete overrride specifier
now the error is here | |
hardware_control/classhardwareinterfa_9.txt | ## Public Member Functions
---
| **StateInterface** (const [ StateInterface
](classhardware__interface_1_1StateInterface.html) &other)=default
| **StateInterface** ( [ StateInterface
](classhardware__interface_1_1StateInterface.html) &&other)=default
| **ReadOnlyHandle** (const std::string &name, const s... | |
hardware_control/resourcemanagercpp_123.txt | return_type result = return_type::OK; | |
hardware_control/resourcemanagercpp_14.txt | const rclcpp_lifecycle::State new_state = hardware.initialize(hardware_info); | |
hardware_control/resourcemanagercpp_103.txt | void ResourceManager::import_component(
std::unique_ptr<ActuatorInterface> actuator, const HardwareInfo & hardware_info)
{
std::lock_guard<std::recursive_mutex> guard(resources_lock_);
resource_storage_->initialize_actuator(std::move(actuator), hardware_info);
read_write_status.failed_hardware_names.reserve(
... | |
hardware_control/1240_37.txt | [
](/mamueluth) [ mamueluth ](/mamueluth) [ force-pushed ](/ros-
controls/ros2_control/compare/abac29ec8313293138d8e295a38bd1fcc1d38efe..4b2328a0b4d753752ab783c251cd6af2518ac616)
the change_interface_exp... | |
hardware_control/resourcemanagercpp_39.txt | result = shutdown_hardware(hardware);
break;
case State::PRIMARY_STATE_FINALIZED:
result = true;
break;
}
break;
} | |
hardware_control/resourcemanagercpp_72.txt | ResourceManager::ResourceManager(
const std::string & urdf, bool validate_interfaces, bool activate_all, unsigned int update_rate,
rclcpp::node_interfaces::NodeClockInterface::SharedPtr clock_interface)
: resource_storage_(std::make_unique<ResourceStorage>(update_rate, clock_interface))
{
load_urdf(urdf, validate... | |
hardware_control/resourcemanagercpp_26.txt | template <class HardwareT>
bool cleanup_hardware(HardwareT & hardware)
{
bool result = trigger_and_print_hardware_state_transition(
std::bind(&HardwareT::cleanup, &hardware), "cleanup", hardware.get_name(),
lifecycle_msgs::msg::State::PRIMARY_STATE_UNCONFIGURED); | |
hardware_control/25749_14.txt |
CallbackReturn DynamixelHardware::on_deactivate(const rclcpp_lifecycle::State & previous_state)
{
RCLCPP_DEBUG(rclcpp::get_logger(kDynamixelHardware), "stop");
return CallbackReturn::SUCCESS;
}
return_type DynamixelHardware::read()
{
if (use_dummy_) {
return retur... | |
hardware_control/resourcemanagercpp_80.txt | std::lock_guard<std::recursive_mutex> guard(resource_interfaces_lock_);
return LoanedStateInterface(resource_storage_->state_interface_map_.at(key));
} | |
hardware_control/25749_15.txt | if (!dynamixel_workbench_.getSyncReadData(
kPresentPositionVelocityCurrentIndex, ids.data(), ids.size(),
control_items_[kPresentPositionItem]->address,
control_items_[kPresentPositionItem]->data_length, positions.data(), &log)) {
RCLCPP_ERROR(rclcpp::get_logger(kDynamix... | |
hardware_control/1240_14.txt | Copy link
Member
###
 **[
saikishor ](/saikishor) ** Jan 23, 2024
There was a problem hiding this comment.
### Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. [ Learn more
](https://docs.git... | |
hardware_control/classhardwareinterfa_0.txt | ROS2 Control
---
* [ hardware_interface ](namespacehardware__interface.html)
* [ StateInterface ](classhardware__interface_1_1StateInterface.html) | |
hardware_control/resourcemanagercpp_38.txt | RCUTILS_LOG_WARN_NAMED(
"resource_manager", "hardware '%s' is in finalized state and can be only destroyed.",
hardware.get_name().c_str());
break;
}
break;
case State::PRIMARY_STATE_ACTIVE:
switch (hardware.get_state().id())
{
... | |
hardware_control/1240_32.txt | the change_interface_export_variant branch from [ ` 7c07d0c ` ](/ros-
controls/ros2_control/commit/7c07d0c6bf0b677fe0feedd48d5343c5b8e9079a) to [ `
8dec983 ` ](/ros-
controls/ros2_control/commit/8dec983a6d3ca945ad6f4277b935f6d466e68120) [
Compare ](/ros-
controls/ros2_control/compare/7c07d0c6bf0b677fe0feedd48d5343c5... | |
hardware_control/resourcemanagercpp_51.txt | void load_and_initialize_system(const HardwareInfo & hardware_info)
{
auto load_and_init_systems = [&](auto & container)
{
check_for_duplicates(hardware_info);
load_hardware<System, SystemInterface>(hardware_info, system_loader_, container);
if (initialize_hardware(hardware_info, container... | |
hardware_control/resourcemanagercpp_76.txt | // throw on missing state and command interfaces, not specified keys are being ignored
if (validate_interfaces)
{
validate_storage(hardware_info);
} | |
hardware_control/resourcemanagercpp_114.txt | const bool actuators_result = call_prepare_mode_switch(resource_storage_->actuators_);
const bool systems_result = call_prepare_mode_switch(resource_storage_->systems_); | |
hardware_control/resourcemanagercpp_53.txt | void initialize_actuator(
std::unique_ptr<ActuatorInterface> actuator, const HardwareInfo & hardware_info)
{
auto init_actuators = [&](auto & container)
{
container.emplace_back(Actuator(std::move(actuator)));
if (initialize_hardware(hardware_info, container.back()))
{
import_s... | |
hardware_control/25749_17.txt | for (uint i = 0; i < info_.joints.size(); ++i) {
if (!dynamixel_workbench_.torqueOff(joint_ids_[i], &log)) {
RCLCPP_FATAL(rclcpp::get_logger(kDynamixelHardware), "%s", log);
return return_type::ERROR;
}
}
RCLCPP_INFO(rclcpp::get_logger(kDynamixelHardwa... | |
hardware_control/resourcemanagercpp_113.txt | auto call_prepare_mode_switch =
[&start_interfaces, &stop_interfaces, &interfaces_to_string](auto & components)
{
bool ret = true;
for (auto & component : components)
{
if (
component.get_state().id() == lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE ||
component.get_state(... | |
hardware_control/25749_9.txt |
#include <algorithm>
#include <array>
#include <string>
#include <limits>
#include <vector>
#include "dynamixel_hardware_interface/dynamixel_hardware_interface.hpp"
#include "hardware_interface/types/hardware_interface_return_values.hpp"
#include "hardware_interface/types/... | |
hardware_control/20211WRMeetupGetting_4.txt | Karsten Knese, Victor Lopez,
Jordan Palacios, Olivier
Stasse, Mathias Arbo, Jaron
Lundwall, Colin MacKenzie,
Matthew Reynolds, Andy
Zelenak, Lovro Ivanov, Jafar
Abdi, Tyler Weaver, Anas Abou
Allaban, Yutaka Kondo, Mateus
Amarante, Auguste Bourgois
and many more!
Thank you! | |
hardware_control/1240_2.txt | * [ Actions ](/ros-controls/ros2_control/actions)
* [ Projects 0 ](/ros-controls/ros2_control/projects)
* [ Security ](/ros-controls/ros2_control/security)
* [ Insights ](/ros-controls/ros2_control/pulse)
Additional navigation options
* [ Code ](/ros-controls/ros2_control)
* [ Issues ](/ros-controls/... | |
hardware_control/resourcemanagercpp_121.txt | auto found_it = resource_storage_->hardware_info_map_.find(component_name); | |
hardware_control/resourcemanagercpp_69.txt | // Update rate of the controller manager, and the clock interface of its node
// Used by async components.
unsigned int cm_update_rate_;
rclcpp::node_interfaces::NodeClockInterface::SharedPtr clock_interface_;
}; | |
hardware_control/resourcemanagercpp_144.txt | void ResourceManager::validate_storage(
const std::vector<hardware_interface::HardwareInfo> & hardware_info) const
{
std::vector<std::string> missing_state_keys = {};
std::vector<std::string> missing_command_keys = {}; | |
hardware_control/resourcemanagercpp_1.txt | #include "hardware_interface/resource_manager.hpp" | |
hardware_control/25749_26.txt | Currently, the error is solved by define the CallbackReturn in the .hpp file. | |
hardware_control/resourcemanagercpp_111.txt | // Check if interface exists
std::stringstream ss_not_existing;
ss_not_existing << "Not existing: " << std::endl << "[" << std::endl;
auto check_exist = [&](const std::vector<std::string> & list_to_check)
{
bool all_exist = true;
for (const auto & interface : list_to_check)
{
if (!command_in... | |
hardware_control/resourcemanagercpp_66.txt | /// Vectors with interfaces available to controllers (depending on hardware component state)
std::vector<std::string> available_state_interfaces_;
std::vector<std::string> available_command_interfaces_; | |
hardware_control/25749_16.txt | if (!dynamixel_workbench_.syncWrite(
kGoalVelocityIndex, ids.data(), ids.size(), commands.data(), 1, &log)) {
RCLCPP_ERROR(rclcpp::get_logger(kDynamixelHardware), "%s", log);
}
return return_type::OK;
} else if (std::any_of(
joints_.cbegin(), join... | |
hardware_control/resourcemanagercpp_2.txt | #include <functional>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector> | |
hardware_control/25749_37.txt | * [ Home ](/)
* [ Categories ](/categories)
* [ FAQ/Guidelines ](/guidelines)
* [ Terms of Service ](http://www.theconstructsim.com/terms_and_conditions/)
* [ Privacy Policy ](http://www.theconstructsim.com/privacy_policy/) | |
hardware_control/25749_2.txt | [ Course Support ](/c/course-support/ros2-control/69) [ ROS2 Control
Framework ](/c/course-support/ros2-control/69) | |
hardware_control/resourcemanagercpp_49.txt | void load_and_initialize_sensor(const HardwareInfo & hardware_info)
{
auto load_and_init_sensors = [&](auto & container)
{
check_for_duplicates(hardware_info);
load_hardware<Sensor, SensorInterface>(hardware_info, sensor_loader_, container);
if (initialize_hardware(hardware_info, container... | |
hardware_control/20211WRMeetupGetting_9.txt | uint32 size
uint32 stride
uint32 data_offset
float64[] data
std_msgs/Header header
string[] joint_names
float64[] displacements
float64[] velocities
float64 duration
example_msgs/Float64MultiArray control_msgs/JointJog
Messages and modifying a controller
class RRBotController : public controller_interface::Controlle... | |
hardware_control/1240_21.txt | | | HARDWARE_INTERFACE_PUBLIC
| | std::vector<StateInterface> export_state_interfaces();
| | std::vector< std::shared_ptr< StateInterface > >
export_state_interfaces();
Copy link
Member
###
 **[
saikishor ](/saikishor) ** Mar 13, 20... | |
hardware_control/resourcemanagercpp_127.txt | bool found = find_set_component_state(
std::bind(&ResourceStorage::set_component_state<Actuator>, resource_storage_.get(), _1, _2),
resource_storage_->actuators_);
if (!found)
{
found = find_set_component_state(
std::bind(&ResourceStorage::set_component_state<Sensor>, resource_storage_.get(), _1... | |
hardware_control/resourcemanagercpp_125.txt | auto find_set_component_state = [&](auto action, auto & components)
{
auto found_component_it = std::find_if(
components.begin(), components.end(),
[&](const auto & component) { return component.get_name() == component_name; }); | |
hardware_control/resourcemanagercpp_146.txt | if (!command_interface_exists(gpio.name + "/" + command_interface.name))
{
missing_command_keys.emplace_back(gpio.name + "/" + command_interface.name);
}
}
}
} | |
hardware_control/resourcemanagercpp_6.txt | bool result = new_state.id() == target_state; | |
hardware_control/25749_36.txt | This topic was automatically closed 7 days after the last reply. New replies
are no longer allowed. | |
hardware_control/resourcemanagercpp_58.txt | if (hardware_info.is_async)
{
init_systems(async_systems_);
}
else
{
init_systems(systems_);
}
} | |
hardware_control/resourcemanagercpp_60.txt | std::vector<Actuator> actuators_;
std::vector<Sensor> sensors_;
std::vector<System> systems_; | |
hardware_control/resourcemanagercpp_85.txt | // CM API: Called in "callback/slow"-thread
std::vector<std::string> ResourceManager::get_controller_reference_interface_names(
const std::string & controller_name)
{
return resource_storage_->controllers_reference_interfaces_map_.at(controller_name);
} | |
hardware_control/resourcemanagercpp_8.txt | class ResourceStorage
{
static constexpr const char * pkg_name = "hardware_interface"; | |
hardware_control/resourcemanagercpp_20.txt | // add command interfaces to available list
for (const auto & interface : hardware_info_map_[hardware.get_name()].command_interfaces)
{
// TODO(destogl): check if interface should be available on configure
auto found_it = std::find(
available_command_interfaces_.begin(), avai... | |
hardware_control/25749_21.txt | Hello [ @pbnpama ](/u/pbnpama) , | |
hardware_control/resourcemanagercpp_77.txt | std::lock_guard<std::recursive_mutex> guard(resources_lock_);
read_write_status.failed_hardware_names.reserve(
resource_storage_->actuators_.size() + resource_storage_->sensors_.size() +
resource_storage_->systems_.size());
} | |
hardware_control/20211WRMeetupGetting_0.txt | ros2_control - a robot-agnostic
control framework for ROS2
WR Meetup #13 – 7 Oct. 2021
Outline
● Why do we need a control framework in ROS/ROS2?
● History & basic concepts
● How to use ros(1)_control?
● What is a bit tricky in ros(1)_control?
● Architecture of ros2_control
● “Everything is an interface ”
● URDF extensi... | |
hardware_control/resourcemanagercpp_25.txt | if (found_it != available_state_interfaces_.end())
{
available_state_interfaces_.erase(found_it);
RCUTILS_LOG_DEBUG_NAMED(
"resource_manager", "(hardware '%s'): '%s' state interface removed from available list",
hardware_name.c_str(), interface.c_str());
}
els... | |
hardware_control/resourcemanagercpp_32.txt | return result;
} | |
hardware_control/classhardwareinterfa_12.txt | * hardware_interface/include/hardware_interface/ [ handle.hpp ](hardware__interface_2include_2hardware__interface_2handle_8hpp_source.html) | |
hardware_control/resourcemanagercpp_50.txt | if (hardware_info.is_async)
{
load_and_init_sensors(async_sensors_);
}
else
{
load_and_init_sensors(sensors_);
}
} | |
hardware_control/resourcemanagercpp_65.txt | /// Storage of all available state interfaces
std::map<std::string, StateInterface> state_interface_map_;
/// Storage of all available command interfaces
std::map<std::string, CommandInterface> command_interface_map_; | |
hardware_control/resourcemanagercpp_128.txt | return result;
} | |
hardware_control/resourcemanagercpp_82.txt | // CM API: Called in "update"-thread
std::vector<std::string> ResourceManager::available_state_interfaces() const
{
std::lock_guard<std::recursive_mutex> guard(resource_interfaces_lock_);
return resource_storage_->available_state_interfaces_;
} | |
hardware_control/1240_24.txt | | | * \return vector of descriptions to the unlisted StateInterfaces
| | */
| | virtual std::vector<hardware_interface::InterfaceDescription>
export_state_interfaces_2()
Copy link
Member
###
 **[
saikishor ](/saikishor) ** Mar 14, 20... | |
hardware_control/resourcemanagercpp_141.txt | bool ResourceManager::state_interface_exists(const std::string & key) const
{
std::lock_guard<std::recursive_mutex> guard(resource_interfaces_lock_);
return resource_storage_->state_interface_map_.find(key) !=
resource_storage_->state_interface_map_.end();
} | |
hardware_control/25749_31.txt |
/home/tharit/moonbot_ws/src/dynamixel_hardware_interface/src/dynamixel_hardware_interface.cpp:30:44: error: ‘on_init’ is not a member of ‘hardware_interface::SystemInterface’
30 | if (hardware_interface::SystemInterface::on_init(info) != CallbackReturn::SUCCESS)
| ... | |
hardware_control/resourcemanagercpp_126.txt | if (found_component_it != components.end())
{
if (action(*found_component_it, target_state))
{
result = return_type::OK;
}
else
{
result = return_type::ERROR;
}
return true;
}
return false;
}; | |
hardware_control/resourcemanagercpp_22.txt | if (hardware_info_map_[hardware.get_name()].is_async)
{
async_component_threads_.emplace(
std::piecewise_construct, std::forward_as_tuple(hardware.get_name()),
std::forward_as_tuple(&hardware, cm_update_rate_, clock_interface_));
}
}
return result;
} | |
hardware_control/resourcemanagercpp_95.txt | std::lock_guard<std::recursive_mutex> guard_claimed(claimed_command_interfaces_lock_);
return resource_storage_->claimed_command_interface_map_.at(key);
} | |
hardware_control/25749_28.txt | ExtendedPosition,
MultiTurn,
CurrentBasedPosition,
PWM,
};
class DynamixelHardware : public hardware_interface::SystemInterface {
public:
RCLCPP_SHARED_PTR_DEFINITIONS(DynamixelHardware)
CallbackReturn on_init(const hardware_interface::HardwareInfo & info) overr... | |
hardware_control/1240_30.txt | Choose a reason Spam Abuse Off Topic Outdated Duplicate Resolved Hide
comment
I've a question here. Now everyone who has access to the `
StateInterfaceHandle ` will also be able to set the value right?. Shouldn't we
add this ` set_value ` method only to the ` CommandInterfaceHandle ` ?
Sorry, something went wron... | |
hardware_control/1240_12.txt | ###
 **[
mamueluth ](/mamueluth) ** Jan 23, 2024
There was a problem hiding this comment.
### Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. [ Learn more
](https://docs.github.com/articles/... | |
hardware_control/resourcemanagercpp_74.txt | // CM API: Called in "callback/slow"-thread
void ResourceManager::load_urdf(
const std::string & urdf, bool validate_interfaces, bool load_and_initialize_components)
{
is_urdf_loaded__ = true;
const std::string system_type = "system";
const std::string sensor_type = "sensor";
const std::string actuator_type =... | |
hardware_control/resourcemanagercpp_84.txt | // CM API: Called in "callback/slow"-thread
void ResourceManager::import_controller_reference_interfaces(
const std::string & controller_name, std::vector<CommandInterface> & interfaces)
{
std::scoped_lock guard(resource_interfaces_lock_, claimed_command_interfaces_lock_);
auto interface_names = resource_storage_... | |
hardware_control/classhardwareinterfa_7.txt |  | |
hardware_control/resourcemanagercpp_31.txt | if (result)
{
if (async_component_threads_.find(hardware.get_name()) != async_component_threads_.end())
{
async_component_threads_.at(hardware.get_name()).activate();
}
// TODO(destogl): make all command interfaces available (currently are all available)
} | |
hardware_control/resourcemanagercpp_129.txt | // CM API: Called in "update"-thread
HardwareReadWriteStatus ResourceManager::read(
const rclcpp::Time & time, const rclcpp::Duration & period)
{
std::lock_guard<std::recursive_mutex> guard(resources_lock_);
read_write_status.ok = true;
read_write_status.failed_hardware_names.clear(); | |
hardware_control/resourcemanagercpp_107.txt | loop_and_get_state(resource_storage_->actuators_);
loop_and_get_state(resource_storage_->async_actuators_);
loop_and_get_state(resource_storage_->sensors_);
loop_and_get_state(resource_storage_->async_sensors_);
loop_and_get_state(resource_storage_->systems_);
loop_and_get_state(resource_storage_->async_sys... | |
hardware_control/resourcemanagercpp_9.txt | static constexpr const char * actuator_interface_name = "hardware_interface::ActuatorInterface";
static constexpr const char * sensor_interface_name = "hardware_interface::SensorInterface";
static constexpr const char * system_interface_name = "hardware_interface::SystemInterface"; | |
hardware_control/25749_11.txt | enable_torque(true);
const ControlItem * goal_position =
dynamixel_workbench_.getItemInfo(joint_ids_[0], kGoalPositionItem);
if (goal_position == nullptr) {
return CallbackReturn::ERROR;
}
const ControlItem * goal_velocity =
dynamixel_workbench_.getItemInf... | |
hardware_control/resourcemanagercpp_122.txt | if (found_it == resource_storage_->hardware_info_map_.end())
{
RCUTILS_LOG_INFO_NAMED(
"resource_manager", "Hardware Component with name '%s' does not exists",
component_name.c_str());
return return_type::ERROR;
} | |
hardware_control/resourcemanagercpp_142.txt | // END: "used only in tests and locally" | |
hardware_control/resourcemanagercpp_93.txt | // CM API: Called in "update"-thread
std::vector<std::string> ResourceManager::get_cached_controllers_to_hardware(
const std::string & hardware_name)
{
return resource_storage_->hardware_used_by_controllers_[hardware_name];
} | |
hardware_control/1240_40.txt | 5 participants
[ 
](/mamueluth) [
](/saikishor) [
 ](/VX792)
[  **[
saikishor ](/saikishor) ** Mar 13, 2024
There was a problem hiding this comment.
### Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. [ Learn more
](https://docs.github.com/ar... | |
hardware_control/resourcemanagercpp_130.txt | auto read_components = [&](auto & components)
{
for (auto & component : components)
{
auto ret_val = component.read(time, period);
if (ret_val == return_type::ERROR)
{
read_write_status.ok = false;
read_write_status.failed_hardware_names.push_back(component.get_name());
... | |
hardware_control/resourcemanagercpp_48.txt | if (hardware_info.is_async)
{
load_and_init_actuators(async_actuators_);
}
else
{
load_and_init_actuators(actuators_);
}
} | |
hardware_control/1240_15.txt | [ @destogl ](https://github.com/destogl)
1. Please check if the deprecation is now how you mentioned it.
2. Please look at the custom export again int the test if this is how you imagined it. on_export_function is now virtual and the states and command now protected instead of private to allow overriding and addin... | |
hardware_control/1240_29.txt | no because of how the deprecation is handled.
Sorry, something went wrong.
All reactions
Copy link
Member
###
 **[
saikishor ](/saikishor) ** Apr 11, 2024
There was a problem hiding this comment.
### Choose a reason for hiding this comment
The rea... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.