dark0707
/
px4-firmware
forked from Archive/PX4-Autopilot
1
0
Fork 0
Code Pull Requests Activity

ORB queue depth completely static

This commit is contained in:
Daniel Agar 2024-03-08 10:27:12 -05:00
parent 600b0e6704
commit f8a8675e2d
25 changed files with 64 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
msg/OrbTestMedium.msg
View File

@ -4,4 +4,6 @@ int32 val
uint8[64] junk
uint8 ORB_QUEUE_LENGTH = 16
# TOPICS orb_test_medium orb_test_medium_multi orb_test_medium_wrap_around orb_test_medium_queue orb_test_medium_queue_poll

2
platforms/common/px4_log.cpp
View File

@ -74,7 +74,7 @@ void px4_log_initialize(void)
log_message.severity = 6; // info
strcpy((char *)log_message.text, "initialized uORB logging");
log_message.timestamp = hrt_absolute_time();
orb_log_message_pub = orb_advertise_queue(ORB_ID(log_message), &log_message, log_message_s::ORB_QUEUE_LENGTH);
orb_log_message_pub = orb_advertise(ORB_ID(log_message), &log_message);
}
__EXPORT void px4_log_modulename(int level, const char *module_name, const char *fmt, ...)

22
platforms/common/uORB/Publication.hpp
View File

@ -48,24 +48,6 @@
namespace uORB
{
template <typename U> class DefaultQueueSize
{
private:
template <typename T>
static constexpr uint8_t get_queue_size(decltype(T::ORB_QUEUE_LENGTH) *)
{
return T::ORB_QUEUE_LENGTH;
}
template <typename T> static constexpr uint8_t get_queue_size(...)
{
return 1;
}
public:
static constexpr unsigned value = get_queue_size<U>(nullptr);
};
class PublicationBase
{
public:
@ -97,7 +79,7 @@ protected:
/**
* uORB publication wrapper class
*/
template<typename T, uint8_t ORB_QSIZE = DefaultQueueSize<T>::value>
template<typename T>
class Publication : public PublicationBase
{
public:
@ -113,7 +95,7 @@ public:
bool advertise()
{
if (!advertised()) {
_handle = orb_advertise_queue(get_topic(), nullptr, ORB_QSIZE);
_handle = orb_advertise(get_topic(), nullptr);
}
return advertised();

4
platforms/common/uORB/PublicationMulti.hpp
View File

@ -51,7 +51,7 @@ namespace uORB
/**
* Base publication multi wrapper class
*/
template<typename T, uint8_t QSIZE = DefaultQueueSize<T>::value>
template<typename T>
class PublicationMulti : public PublicationBase
{
public:
@ -73,7 +73,7 @@ public:
{
if (!advertised()) {
int instance = 0;
_handle = orb_advertise_multi_queue(get_topic(), nullptr, &instance, QSIZE);
_handle = orb_advertise_multi(get_topic(), nullptr, &instance);
}
return advertised();

23
platforms/common/uORB/uORB.cpp
View File

@ -115,23 +115,12 @@ int uorb_top(char **topic_filter, int num_filters)
orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data)
{
return uORB::Manager::get_instance()->orb_advertise(meta, data, meta->o_queue);
}
orb_advert_t orb_advertise_queue(const struct orb_metadata *meta, const void *data, unsigned int queue_size)
{
return uORB::Manager::get_instance()->orb_advertise(meta, data, queue_size);
return uORB::Manager::get_instance()->orb_advertise(meta, data);
}
orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance)
{
return uORB::Manager::get_instance()->orb_advertise_multi(meta, data, instance, meta->o_queue);
}
orb_advert_t orb_advertise_multi_queue(const struct orb_metadata *meta, const void *data, int *instance,
unsigned int queue_size)
{
return uORB::Manager::get_instance()->orb_advertise_multi(meta, data, instance, queue_size);
return uORB::Manager::get_instance()->orb_advertise_multi(meta, data, instance);
}
int orb_unadvertise(orb_advert_t handle)
@ -227,6 +216,14 @@ const char *orb_get_c_type(unsigned char short_type)
return nullptr;
}
uint8_t orb_get_queue_depth(const struct orb_metadata *meta)
{
if (meta) {
return meta->o_queue;
}
return 0;
}
void orb_print_message_internal(const orb_metadata *meta, const void *data, bool print_topic_name)
{

20
platforms/common/uORB/uORB.h
View File

@ -139,23 +139,11 @@ typedef void *orb_advert_t;
*/
extern orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data) __EXPORT;
/**
* @see uORB::Manager::orb_advertise()
*/
extern orb_advert_t orb_advertise_queue(const struct orb_metadata *meta, const void *data,
unsigned int queue_size) __EXPORT;
/**
* @see uORB::Manager::orb_advertise_multi()
*/
extern orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance) __EXPORT;
/**
* @see uORB::Manager::orb_advertise_multi()
*/
extern orb_advert_t orb_advertise_multi_queue(const struct orb_metadata *meta, const void *data, int *instance,
unsigned int queue_size) __EXPORT;
/**
* @see uORB::Manager::orb_unadvertise()
*/
@ -164,7 +152,7 @@ extern int orb_unadvertise(orb_advert_t handle) __EXPORT;
/**
* @see uORB::Manager::orb_publish()
*/
extern int orb_publish(const struct orb_metadata *meta, orb_advert_t handle, const void *data) __EXPORT;
extern int orb_publish(const struct orb_metadata *meta, orb_advert_t handle, const void *data) __EXPORT;
/**
* Advertise as the publisher of a topic.
@ -245,6 +233,12 @@ extern int orb_get_interval(int handle, unsigned *interval) __EXPORT;
*/
const char *orb_get_c_type(unsigned char short_type);
/**
* Returns the queue depth of a topic
* @param meta orb topic metadata
*/
extern uint8_t orb_get_queue_depth(const struct orb_metadata *meta);
/**
* Print a topic to console. Do not call this directly, use print_message() instead.
* @param meta orb topic metadata

35
platforms/common/uORB/uORBDeviceNode.cpp
View File

@ -73,12 +73,10 @@ static inline uint8_t round_pow_of_two_8(uint8_t n)
return value + 1;
}
uORB::DeviceNode::DeviceNode(const struct orb_metadata *meta, const uint8_t instance, const char *path,
uint8_t queue_size) :
uORB::DeviceNode::DeviceNode(const struct orb_metadata *meta, const uint8_t instance, const char *path) :
CDev(strdup(path)), // success is checked in CDev::init
_meta(meta),
_instance(instance),
_queue_size(round_pow_of_two_8(queue_size))
_instance(instance)
{
}
@ -186,7 +184,7 @@ uORB::DeviceNode::write(cdev::file_t *filp, const char *buffer, size_t buflen)
/* re-check size */
if (nullptr == _data) {
const size_t data_size = _meta->o_size * _queue_size;
const size_t data_size = _meta->o_size * _meta->o_queue;
_data = (uint8_t *) px4_cache_aligned_alloc(data_size);
if (_data) {
@ -217,7 +215,7 @@ uORB::DeviceNode::write(cdev::file_t *filp, const char *buffer, size_t buflen)
/* wrap-around happens after ~49 days, assuming a publisher rate of 1 kHz */
unsigned generation = _generation.fetch_add(1);
memcpy(_data + (_meta->o_size * (generation % _queue_size)), buffer, _meta->o_size);
memcpy(_data + (_meta->o_size * (generation % _meta->o_queue)), buffer, _meta->o_size);
// callbacks
for (auto item : _callbacks) {
@ -254,13 +252,6 @@ uORB::DeviceNode::ioctl(cdev::file_t *filp, int cmd, unsigned long arg)
*(uintptr_t *)arg = (uintptr_t)this;
return PX4_OK;
case ORBIOCSETQUEUESIZE: {
lock();
int ret = update_queue_size(arg);
unlock();
return ret;
}
case ORBIOCGETINTERVAL:
*(unsigned *)arg = filp_to_subscription(filp)->get_interval_us();
return PX4_OK;
@ -389,12 +380,11 @@ uORB::DeviceNode::print_statistics(int max_topic_length)
const uint8_t instance = get_instance();
const int8_t sub_count = subscriber_count();
const uint8_t queue_size = get_queue_size();
unlock();
PX4_INFO_RAW("%-*s %2i %4i %2i %4i %s\n", max_topic_length, get_meta()->o_name, (int)instance, (int)sub_count,
queue_size, get_meta()->o_size, get_devname());
get_meta()->o_queue, get_meta()->o_size, get_devname());
return true;
}
@ -483,21 +473,6 @@ int16_t uORB::DeviceNode::process_received_message(int32_t length, uint8_t *data
}
#endif /* CONFIG_ORB_COMMUNICATOR */
int uORB::DeviceNode::update_queue_size(unsigned int queue_size)
{
if (_queue_size == queue_size) {
return PX4_OK;
}
//queue size is limited to 255 for the single reason that we use uint8 to store it
if (_data || _queue_size > queue_size || queue_size > 255) {
return PX4_ERROR;
}
_queue_size = round_pow_of_two_8(queue_size);
return PX4_OK;
}
unsigned uORB::DeviceNode::get_initial_generation()
{
ATOMIC_ENTER;

23
platforms/common/uORB/uORBDeviceNode.hpp
View File

@ -62,7 +62,7 @@ class UnitTest;
class uORB::DeviceNode : public cdev::CDev, public IntrusiveSortedListNode<uORB::DeviceNode *>
{
public:
DeviceNode(const struct orb_metadata *meta, const uint8_t instance, const char *path, uint8_t queue_size = 1);
DeviceNode(const struct orb_metadata *meta, const uint8_t instance, const char *path);
virtual ~DeviceNode();
// no copy, assignment, move, move assignment
@ -179,15 +179,6 @@ public:
void mark_as_advertised() { _advertised = true; }
/**
* Try to change the size of the queue. This can only be done as long as nobody published yet.
* This is the case, for example when orb_subscribe was called before an orb_advertise.
* The queue size can only be increased.
* @param queue_size new size of the queue
* @return PX4_OK if queue size successfully set
*/
int update_queue_size(unsigned int queue_size);
/**
* Print statistics
* @param max_topic_length max topic name length for printing
@ -195,7 +186,7 @@ public:
*/
bool print_statistics(int max_topic_length);
uint8_t get_queue_size() const { return _queue_size; }
uint8_t get_queue_size() const { return _meta->o_queue; }
int8_t subscriber_count() const { return _subscriber_count; }
@ -234,7 +225,7 @@ public:
bool copy(void *dst, unsigned &generation)
{
if ((dst != nullptr) && (_data != nullptr)) {
if (_queue_size == 1) {
if (_meta->o_queue == 1) {
ATOMIC_ENTER;
memcpy(dst, _data, _meta->o_size);
generation = _generation.load();
@ -253,12 +244,12 @@ public:
}
// Compatible with normal and overflow conditions
if (!is_in_range(current_generation - _queue_size, generation, current_generation - 1)) {
if (!is_in_range(current_generation - _meta->o_queue, generation, current_generation - 1)) {
// Reader is too far behind: some messages are lost
generation = current_generation - _queue_size;
generation = current_generation - _meta->o_queue;
}
memcpy(dst, _data + (_meta->o_size * (generation % _queue_size)), _meta->o_size);
memcpy(dst, _data + (_meta->o_size * (generation % _meta->o_queue)), _meta->o_size);
ATOMIC_LEAVE;
++generation;
@ -295,7 +286,7 @@ private:
const uint8_t _instance; /**< orb multi instance identifier */
bool _advertised{false}; /**< has ever been advertised (not necessarily published data yet) */
uint8_t _queue_size; /**< maximum number of elements in the queue */
int8_t _subscriber_count{0};

14
platforms/common/uORB/uORBManager.cpp
View File

@ -265,8 +265,7 @@ int uORB::Manager::orb_exists(const struct orb_metadata *meta, int instance)
return ret;
}
orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance,
unsigned int queue_size)
orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance)
{
#ifdef ORB_USE_PUBLISHER_RULES
@ -300,19 +299,10 @@ orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta,
return nullptr;
}
/* Set the queue size. This must be done before the first publication; thus it fails if
* this is not the first advertiser.
*/
int result = px4_ioctl(fd, ORBIOCSETQUEUESIZE, (unsigned long)queue_size);
if (result < 0 && queue_size > 1) {
PX4_WARN("orb_advertise_multi: failed to set queue size");
}
/* get the advertiser handle and close the node */
orb_advert_t advertiser;
result = px4_ioctl(fd, ORBIOCGADVERTISER, (unsigned long)&advertiser);
int result = px4_ioctl(fd, ORBIOCGADVERTISER, (unsigned long)&advertiser);
px4_close(fd);
if (result == PX4_ERROR) {

11
platforms/common/uORB/uORBManager.hpp
View File

@ -215,17 +215,15 @@ public:
* @param data A pointer to the initial data to be published.
* For topics updated by interrupt handlers, the advertisement
* must be performed from non-interrupt context.
* @param queue_size Maximum number of buffered elements. If this is 1, no queuing is
* used.
* @return nullptr on error, otherwise returns an object pointer
* that can be used to publish to the topic.
* If the topic in question is not known (due to an
* ORB_DEFINE with no corresponding ORB_DECLARE)
* this function will return nullptr and set errno to ENOENT.
*/
orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data, unsigned int queue_size = 1)
orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data = nullptr)
{
return orb_advertise_multi(meta, data, nullptr, queue_size);
return orb_advertise_multi(meta, data, nullptr);
}
/**
@ -250,16 +248,13 @@ public:
* @param instance Pointer to an integer which will yield the instance ID (0-based)
* of the publication. This is an output parameter and will be set to the newly
* created instance, ie. 0 for the first advertiser, 1 for the next and so on.
* @param queue_size Maximum number of buffered elements. If this is 1, no queuing is
* used.
* @return nullptr on error, otherwise returns a handle
* that can be used to publish to the topic.
* If the topic in question is not known (due to an
* ORB_DEFINE with no corresponding ORB_DECLARE)
* this function will return nullptr and set errno to ENOENT.
*/
orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance,
unsigned int queue_size = 1);
orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance);
/**
* Unadvertise a topic.

14
platforms/common/uORB/uORBManagerUsr.cpp
View File

@ -89,8 +89,7 @@ int uORB::Manager::orb_exists(const struct orb_metadata *meta, int instance)
return data.ret;
}
orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance,
unsigned int queue_size)
orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance)
{
/* open the node as an advertiser */
int fd = node_open(meta, true, instance);
@ -100,19 +99,10 @@ orb_advert_t uORB::Manager::orb_advertise_multi(const struct orb_metadata *meta,
return nullptr;
}
/* Set the queue size. This must be done before the first publication; thus it fails if
* this is not the first advertiser.
*/
int result = px4_ioctl(fd, ORBIOCSETQUEUESIZE, (unsigned long)queue_size);
if (result < 0 && queue_size > 1) {
PX4_WARN("orb_advertise_multi: failed to set queue size");
}
/* get the advertiser handle and close the node */
orb_advert_t advertiser;
result = px4_ioctl(fd, ORBIOCGADVERTISER, (unsigned long)&advertiser);
int result = px4_ioctl(fd, ORBIOCGADVERTISER, (unsigned long)&advertiser);
px4_close(fd);
if (result == PX4_ERROR) {

12
platforms/common/uORB/uORB_tests/uORBTest_UnitTest.cpp
View File

@ -574,8 +574,8 @@ int uORBTest::UnitTest::test_wrap_around()
bool updated{false};
// Advertise but not publish topics, only generate device_node, which is convenient for modifying DeviceNode::_generation
const int queue_size = 16;
ptopic = orb_advertise_queue(ORB_ID(orb_test_medium_wrap_around), nullptr, queue_size);
const int queue_size = orb_test_medium_s::ORB_QUEUE_LENGTH;
ptopic = orb_advertise(ORB_ID(orb_test_medium_wrap_around), nullptr);
if (ptopic == nullptr) {
return test_fail("advertise failed: %d", errno);
@ -828,9 +828,9 @@ int uORBTest::UnitTest::test_queue()
return test_fail("subscribe failed: %d", errno);
}
const int queue_size = 16;
const int queue_size = orb_test_medium_s::ORB_QUEUE_LENGTH;
orb_test_medium_s t{};
ptopic = orb_advertise_queue(ORB_ID(orb_test_medium_queue), &t, queue_size);
ptopic = orb_advertise(ORB_ID(orb_test_medium_queue), &t);
if (ptopic == nullptr) {
return test_fail("advertise failed: %d", errno);
@ -935,9 +935,9 @@ int uORBTest::UnitTest::pub_test_queue_main()
{
orb_test_medium_s t{};
orb_advert_t ptopic{nullptr};
const int queue_size = 50;
const int queue_size = orb_test_medium_s::ORB_QUEUE_LENGTH;
if ((ptopic = orb_advertise_queue(ORB_ID(orb_test_medium_queue_poll), &t, queue_size)) == nullptr) {
if ((ptopic = orb_advertise(ORB_ID(orb_test_medium_queue_poll), &t)) == nullptr) {
_thread_should_exit = true;
return test_fail("advertise failed: %d", errno);
}

20
platforms/ros2/include/uORB/Publication.hpp
View File

@ -45,28 +45,10 @@
namespace uORB
{
template <typename U> class DefaultQueueSize
{
private:
template <typename T>
static constexpr uint8_t get_queue_size(decltype(T::ORB_QUEUE_LENGTH) *)
{
return T::ORB_QUEUE_LENGTH;
}
template <typename T> static constexpr uint8_t get_queue_size(...)
{
return 1;
}
public:
static constexpr unsigned value = get_queue_size<U>(nullptr);
};
/**
* uORB publication wrapper class
*/
template<typename T, uint8_t ORB_QSIZE = DefaultQueueSize<T>::value>
template<typename T>
class Publication
{
public:

2
src/drivers/camera_trigger/camera_trigger.cpp
View File

@ -314,7 +314,7 @@ CameraTrigger::CameraTrigger() :
// Advertise critical publishers here, because we cannot advertise in interrupt context
camera_trigger_s trigger{};
_trigger_pub = orb_advertise_queue(ORB_ID(camera_trigger), &trigger, camera_trigger_s::ORB_QUEUE_LENGTH);
_trigger_pub = orb_advertise(ORB_ID(camera_trigger), &trigger);
}
CameraTrigger::~CameraTrigger()

7
src/drivers/drv_orb_dev.h
View File

@ -64,13 +64,10 @@
/** Get the priority for the topic */
#define ORBIOCGPRIORITY _ORBIOC(14)
/** Set the queue size of the topic */
#define ORBIOCSETQUEUESIZE _ORBIOC(15)
/** Get the minimum interval at which the topic can be seen to be updated for this subscription */
#define ORBIOCGETINTERVAL _ORBIOC(16)
#define ORBIOCGETINTERVAL _ORBIOC(15)
/** Check whether the topic is advertised, sets *(unsigned long *)arg to 1 if advertised, 0 otherwise */
#define ORBIOCISADVERTISED _ORBIOC(17)
#define ORBIOCISADVERTISED _ORBIOC(16)
#endif /* _DRV_UORB_H */

2
src/drivers/tone_alarm/ToneAlarm.cpp
View File

@ -45,8 +45,6 @@ using namespace time_literals;
ToneAlarm::ToneAlarm() :
ScheduledWorkItem(MODULE_NAME, px4::wq_configurations::hp_default)
{
// ensure ORB_ID(tune_control) is advertised with correct queue depth
orb_advertise_queue(ORB_ID(tune_control), nullptr, tune_control_s::ORB_QUEUE_LENGTH);
}
ToneAlarm::~ToneAlarm()

2
src/lib/adsb/AdsbConflict.h
View File

@ -151,7 +151,7 @@ private:
transponder_report_s tr{};
orb_advert_t fake_traffic_report_publisher = orb_advertise_queue(ORB_ID(transponder_report), &tr, (unsigned int)20);
orb_advert_t fake_traffic_report_publisher = orb_advertise(ORB_ID(transponder_report), &tr);
TRAFFIC_STATE _traffic_state_previous{TRAFFIC_STATE::NO_CONFLICT};

2
src/lib/events/events.cpp
View File

@ -61,7 +61,7 @@ void send(EventType &event)
orb_publish(ORB_ID(event), orb_event_pub, &event);
} else {
orb_event_pub = orb_advertise_queue(ORB_ID(event), &event, event_s::ORB_QUEUE_LENGTH);
orb_event_pub = orb_advertise(ORB_ID(event), &event);
}
pthread_mutex_unlock(&publish_event_mutex);

2
src/lib/systemlib/mavlink_log.cpp
View File

@ -73,6 +73,6 @@ __EXPORT void mavlink_vasprintf(int severity, orb_advert_t *mavlink_log_pub, con
orb_publish(ORB_ID(mavlink_log), *mavlink_log_pub, &log_msg);
} else {
*mavlink_log_pub = orb_advertise_queue(ORB_ID(mavlink_log), &log_msg, mavlink_log_s::ORB_QUEUE_LENGTH);
*mavlink_log_pub = orb_advertise(ORB_ID(mavlink_log), &log_msg);
}
}

2
src/modules/commander/HealthAndArmingChecks/HealthAndArmingChecksTest.cpp
View File

@ -55,7 +55,7 @@ public:
void SetUp() override
{
// ensure topic exists, otherwise we might lose first queued events
orb_advertise_queue(ORB_ID(event), nullptr, event_s::ORB_QUEUE_LENGTH);
orb_advertise(ORB_ID(event), nullptr);
}
};

4
src/modules/commander/commander_helper.cpp
View File

@ -153,7 +153,7 @@ int buzzer_init()
tune_durations[tune_control_s::TUNE_ID_BATTERY_WARNING_SLOW] = 800000;
tune_durations[tune_control_s::TUNE_ID_SINGLE_BEEP] = 300000;
tune_control_pub = orb_advertise_queue(ORB_ID(tune_control), &tune_control, tune_control_s::ORB_QUEUE_LENGTH);
tune_control_pub = orb_advertise(ORB_ID(tune_control), &tune_control);
return PX4_OK;
}
@ -330,7 +330,7 @@ int led_init()
led_control.mode = led_control_s::MODE_OFF;
led_control.priority = 0;
led_control.timestamp = hrt_absolute_time();
led_control_pub = orb_advertise_queue(ORB_ID(led_control), &led_control, led_control_s::ORB_QUEUE_LENGTH);
led_control_pub = orb_advertise(ORB_ID(led_control), &led_control);
/* first open normal LEDs */
fd_leds = px4_open(LED0_DEVICE_PATH, O_RDWR);

4
src/modules/mavlink/mavlink_main.cpp
View File

@ -124,13 +124,13 @@ Mavlink::Mavlink() :
// ensure topic exists, otherwise we might lose first queued commands
if (orb_exists(ORB_ID(vehicle_command), 0) == PX4_ERROR) {
orb_advertise_queue(ORB_ID(vehicle_command), nullptr, vehicle_command_s::ORB_QUEUE_LENGTH);
orb_advertise(ORB_ID(vehicle_command), nullptr);
}
_vehicle_command_sub.subscribe();
if (orb_exists(ORB_ID(event), 0) == PX4_ERROR) {
orb_advertise_queue(ORB_ID(event), nullptr, event_s::ORB_QUEUE_LENGTH);
orb_advertise(ORB_ID(event), nullptr);
}
_event_sub.subscribe();

2
src/modules/uxrce_dds_client/dds_topics.h.em
View File

@ -168,7 +168,7 @@ bool RcvTopicsPubs::init(uxrSession *session, uxrStreamId reliable_out_stream_id
{
@[ for idx, sub in enumerate(subscriptions + subscriptions_multi)]@
{
uint16_t queue_depth = uORB::DefaultQueueSize<@(sub['simple_base_type'])_s>::value * 2; // use a bit larger queue size than internal
uint16_t queue_depth = orb_get_queue_depth(ORB_ID(@(sub['simple_base_type']))) * 2; // use a bit larger queue size than internal
create_data_reader(session, reliable_out_stream_id, best_effort_in_stream_id, participant_id, @(idx), client_namespace, "@(sub['topic_simple'])", "@(sub['dds_type'])", queue_depth);
}
@[ end for]@

3
src/modules/uxrce_dds_client/vehicle_command_srv.cpp
View File

@ -39,8 +39,7 @@ VehicleCommandSrv::VehicleCommandSrv(uxrSession *session, uxrStreamId reliable_o
uxrStreamId input_stream_id, uxrObjectId participant_id, const char *client_namespace, const uint8_t index) :
SrvBase(session, reliable_out_stream_id, input_stream_id, participant_id)
{
uint16_t queue_depth = uORB::DefaultQueueSize<vehicle_command_s>::value *
2; // use a bit larger queue size than internal
uint16_t queue_depth = orb_get_queue_depth(ORB_ID(vehicle_command)) * 2; // use a bit larger queue size than internal
create_replier(input_stream_id, participant_id, index, client_namespace, "vehicle_command", "VehicleCommand",
queue_depth);
};

2
src/modules/zenoh/subscribers/uorb_subscriber.hpp
View File

@ -55,7 +55,7 @@ public:
_cdr_ops(ops)
{
int instance = 0;
_uorb_pub_handle = orb_advertise_multi_queue(_uorb_meta, nullptr, &instance, 1); //FIXME template magic qsize
_uorb_pub_handle = orb_advertise_multi(_uorb_meta, nullptr, &instance);
};
~uORB_Zenoh_Subscriber() override = default;