PX4（PIXHAWK）源码开发人员文档（三）——进程间通讯的开发者指南

最新推荐文章于 2024-04-22 15:16:48 发布

就是很难啊

最新推荐文章于 2024-04-22 15:16:48 发布

阅读量3.7k

点赞数 3

分类专栏： PIXHAWK 文章标签：无人机源码 PX4 开发人员文档

PIXHAWK 专栏收录该内容

3 篇文章 2 订阅

订阅专栏

进程/应用之间的通信（例如将传感器应用的传感器数据发送到姿态滤波应用）是PX4软件架构的关键部分。进程（通常又被叫做节点（node））通过命名为总线（buses）进行消息交换的过程被称作订阅主题（topics）。

在PX4中，一个订阅主题仅包含一个消息类型，比如vehicle_attitude订阅主题传输一个包含姿态结构（滚转、俯仰和偏航估计）的消息。

节点可以在总线/订阅主题上发布（publish）一个消息（发送数据）或者订阅（subscribe）一个总线/订阅主题（接收数据）。应用并不知道在与谁通信，1个订阅主题可以有多个发布器和订阅器。

这种设计模式阻止了锁定的问题（locking issues），在机器人领域非常常见。为了使这更为高效，通常在总线上只有一个消息，并且不会有队列。

这种发布/订阅机制由微对象请求处理器microobject request broker (uORB)实现。

快速开始

这是一个简单但是完整的发布器（publisher） /订阅器（subscriber）组合，发布器发布一个叫做random_integer 的订阅主题，并使用随机的整数更新订阅主题。订阅器检查并打印这些更新。

topic.h

/* declare the topic */
ORB_DECLARE(random_integer);
/* define the data structure that will be published where subscribers cansee it */
struct random_integer_data{
          int r;
};

publisher.c

#include <topic.h>
 /* create topic metadata */
ORB_DEFINE(random_integer); 
/* file handle that will be used for publishing */
staticint topic_handle; 
int init()
{
          /* generate the initial data for first publication*/
          struct random_integer_data rd={ .r= random(),};
          /* advertise the topic and make the initialpublication */
          topic_handle = orb_advertise(ORB_ID(random_integer),&rd);
}
int update_topic()
{
          /* generate a new random number forpublication */
          struct random_integer_data rd={ .r= random(),};
          /* publish the new data structure */
          orb_publish(ORB_ID(random_integer), topic_handle,&rd);
}

subscriber.c

#include <topic.h>
 /* file handle that will be used forsubscribing */
staticint topic_handle;
int init()
{
          /* subscribe to the topic */
          topic_handle = orb_subscribe(ORB_ID(random_integer));
}
 voidcheck_topic()
{
          bool updated;
          struct random_integer_data rd; 
          /* check to see whether the topic has updatedsince the last time we read it */
          orb_check(topic_handle,&updated);
          if(updated){
                    /* make a local copy of the updated datastructure */
                    orb_copy(ORB_ID(random_integer), topic_handle,&rd);
                    printf("Random integer is now %d\n", rd.r);
          }
}

发布过程

发布过程包含三个独立却相关联的动作：定义订阅主题，通告订阅主题，并且发布更新。

定义订阅主题

作为一种在元件之间提供通用接口的方式，系统定义了许多标准的订阅主题。如果一个发布器希望使用某一标准的订阅主题和其相关的数据结构，不需要再做额外的工作。

常规订阅主题

为了定义一个常规的订阅主题，发布器需要为订阅器建一个可用的头文件（上面的topic.h）。在这个头文件里必须包含：

将订阅主题的名字作为参数的一个ORB_DECLARE() 宏实例。
一个用于描述将发布数据结构的结构定义。

订阅主题的名字应该是描述性的；PX4的命名规则是是使用下划线分开订阅主题的名字；组件的名字应该首先使用通用的词汇。

例如，原始传感器数据在sensors_raw订阅主题中进行发布。

除了头文件，发布器必须包含一个ORB_DEFINE()宏实例在源文件中，该文件可以在构建固件时被编译和链接（见publisher.c示例）。这个宏来构建由ORB使用的数据结构，从而唯一表示这个topic。

可选的订阅主题（optionaltopic）

如果一个由软件组件发布的订阅主题是可选的，并且可能不会出现在固件中，头文件可以使用 ORB_DECLARE_OPTIONAL()宏代替。以这种方式声明的订阅主题需要由发布器进行特别的处理，但是还有一些以下需要讨论的考虑，订阅器在处理可选订阅主题时必须要注意。

通告（advertise）订阅主题

在数据发布到一个订阅主题时，必须首先通告。发布器使用如下的API通告一个新的订阅主题：

/**
 * Advertise as the publisher of atopic.
 *
 * This performs the initialadvertisement of a topic; it creates the topic
 * node in /obj if required andwrites the initial data.
 *
 * @param meta                 The uORB metadata (usually fromthe ORB_ID() macro)
 *                             forthe topic. topic uORB元数据（通常来自ORB_ID()宏）
 * @param data                 A pointer to the initial datato be published.指向将要publish初始数据的指针。
 *                             Fortopics published by interrupt handlers, the advertisement
 *                             mustbe performed from non-interrupt context.
 * @return           ERROR on error, otherwise returns a handle
 *                             thatcan be used to publish to the topic.
 *                             Ifthe topic in question is not known (due to an
 *                             ORB_DEFINE_OPTIONALwith no corresponding ORB_DECLARE)
 *                             thisfunction will return -1 and set errno to ENOENT.
 */
externint          orb_advertise(conststruct orb_metadata *meta,constvoid*data);

通告同时为订阅主题发布初始数据。

API的meta参数是由ORB_DEFINE()宏产生的数据指针，通常使用ORB_ID() 宏提供，该宏执行从订阅主题名到元数据结构名的转换。

需要注意的是，可以从中断句柄中发布实时更新，但是通告订阅主题必须在常规线程的情况下。

多个发布器

一个发布器一次只能通告一个订阅主题，然而发布器可能会关闭订阅主题句柄（这是个文件句柄，可以简单的传递到close（）函数），然后由另外一个发布器通告订阅主题。

发布更新

一个订阅主题被通告后，从通告那里返回的句柄可以使用如下的API，用于对订阅主题发布更新：

/**
 * Publish new data to a topic.
 *
 * The data is atomically publishedto the topic and any waiting subscribers
 * will be notified.  Subscribers that are not waiting can checkthe topic
 * for updates using orb_checkand/or orb_stat.
 *
 * @handle           The handle returned from orb_advertise.
 * @param meta                 The uORB metadata (usually fromthe ORB() macro)
 *                             forthe topic.
 * @param data                 A pointer to the data to bepublished.
 * @return           OK on success, ERROR otherwise with errno set accordingly.
 */
externint          orb_publish(conststruct orb_metadata *meta,int handle,constvoid*data);

需要注意的是ORB并不缓存多个更新，当订阅器检查订阅主题时，只会看到最近的一个更新。

订阅一个订阅主题需要如下：

一个ORB_DEFINE()或者ORB_DEFINE_OPTIONAL()宏（例如，在订阅器中包含的头文件）
在订阅主题中发布的数据结构定义。（通常来自相同的头文件）

假如这些条件都满足，订阅器使用下面的API来订阅一个订阅主题。

/**
 * Subscribe to a topic.
 *
 * The returned value is a filedescriptor that can be passed to poll()
 * in order to wait for updates to atopic, as well as orb_read,
 * orb_check and orb_stat.
 *
 * Subscription will succeed even ifthe topic has not been advertised;
 * in this case the topic will havea timestamp of zero, it will never
 * signal a poll() event, checkingwill always return false and it cannot
 * be copied. When the topic issubsequently advertised, poll, check,
 * stat and copy calls will react tothe initial publication that is
 * performed as part of theadvertisement.
 *
 * Subscription will fail if thetopic is not known to the system, i.e.
 * there is nothing in the systemthat has defined the topic and thus it
 * can never be published.
 *
 * @param meta                 The uORB metadata (usually fromthe ORB_ID() macro)
 *                             forthe topic.
 * @return           ERROR on error, otherwise returns a handle
 *                             thatcan be used to read and check the topic for updates.
 *                             Ifthe topic in question is not known (due to an
 *                             ORB_DEFINE_OPTIONALwith no corresponding ORB_DECLARE)
 *                             thisfunction will return -1 and set errno to ENOENT.
 */
externint          orb_subscribe(conststruct orb_metadata *meta);

订阅一个可选的订阅主题时，如果订阅主题不存在的话，将会失败。然而其他的所有订阅都会成功，并创建订阅主题，即使这并没有经发布器通告。这极大的降低了仔细安排系统启动顺序的需要。

对一项任务可以执行的订阅数目并没有具体的限制。

取消对一个订阅主题的订阅，使用如下的API：

/**
 * Unsubscribe from a topic.
 *
 * @param handle     A handle returned from orb_subscribe.
 * @return           OK on success, ERROR otherwise with errno set accordingly.
 */
externint          orb_unsubscribe(int handle);

从订阅主题中拷贝数据

订阅器并不是引用存储在ORB中的数据，或者与其他订阅器共享数据；而是在其请求下，将数据从ORB中拷贝出来存放在每一个订阅器对应的临时缓冲区中。这一拷贝就避免了锁定问题，并使得发布器和订阅器的API都变的简单。也允许订阅器及时根据自己的使用需求对数据进行修改。

当订阅器希望得到发布到订阅主题的最近数据拷贝时，使用如下的API：

/**
 * Fetch data from a topic.
 *
 * @param meta                 The uORB metadata (usually fromthe ORB() macro)
 *                             forthe topic.
 * @param handle     A handle returned from orb_subscribe.
 * @param buffer     Pointer to the buffer receiving the data.
 * @return           OK on success, ERROR otherwise with errno set accordingly.
 */
externint          orb_copy(conststruct orb_metadata *meta,int handle,void*buffer);

复制可以保证数据是最新发布的。

更新检查

在订阅器调用orb_copy函数后，可以使用如下的API检查从上一个时间开始，订阅主题是否接收到了新的发布。

/**
 * Check whether a topic has beenpublished to since the last orb_copy.
 *
 * This check can be used todetermine whether to copy from the topic when
 * not using poll(), or to avoid theoverhead of calling poll() when the
 * topic is likely to have updated.
 *
 * Updates are tracked on aper-handle basis; this call will continue to
 * return true until orb_copy iscalled using the same handle. This interface
 * should be preferred over callingorb_stat due to the race window between
 * stat and copy that can lead tomissed updates.
 *
 * @param handle     A handle returned from orb_subscribe.
 * @param updated    Set to true if the topic has been publishedsince the
 *                             lasttime it was copied using this handle.
 * @return           OK if the check was successful, ERROR otherwise with
 *                             errnoset accordingly.
 */
externint          orb_check(int handle, bool *updated);

当订阅主题在通告之前，已经被订阅，这个API将会返回没有更新，直到订阅主题被通告。

发布时间戳

订阅器可以使用如下的API检查订阅主题最近一次发布的时间：

/**
 * Return the last time that thetopic was published.
 *
 * @param handle     A handle returned from orb_subscribe.
 * @param time                 Returns the time that the topicwas published, or zero if it has
 *                             neverbeen published/advertised.
 * @return           OK on success, ERROR otherwise with errno set accordingly.
 */
externint          orb_stat(int handle,uint64_t*time);

当调用这个功能时，需要仔细检查，因为并不能保证在调用返回后订阅主题不会紧接着就发布。

等待更新

依赖于发布作为数据源的订阅器，其可以同时具有任意数量等待发布的订阅。这一功能通过使用 poll() 函数实现，与文件描述符等待数据具有相同的方式。这之所以可以工作，是因为订阅本身实际上也是文件描述符。

下面的例子展示的是，订阅器具有三个独立的订阅，等待到每一个的发布，当收到这些发布时进行回应。如果第二轮没有到任意订阅的更新，更新超时计数器，并发布给其他订阅器。

color_counter.h

ORB_DECLARE(color_red);
ORB_DECLARE(color_green);
ORB_DECLARE(color_blue);
ORB_DECLARE(color_timeouts);
 
/* structure published to color_red, color_green, color_blue andcolor_timeouts */
struct color_update
{
          int number;
};
color_counter.c
#include <poll.h>
 
ORB_DEFINE(color_timeouts,struct color_update);
 
void
subscriber(void)
{
          int       sub_red, sub_green, sub_blue;
          int       pub_timeouts;
          int       timeouts=0;
          struct color_update cu;
 
          /* subscribe to color topics */
          sub_red = orb_subscribe(ORB_ID(color_red));
          sub_green = orb_subscribe(ORB_ID(color_green));
          sub_blue = orb_subscribe(ORB_ID(color_blue));
 
          /* advertise the timeout topic */
          cu.number=0;
          pub_timeouts = orb_advertise(ORB_ID(color_timeouts),&cu);
 
          /* loop waiting for updates */
          for(;;){
 
                    /* wait for updates or a 1-second timeout */
                    struct pollfd fds[3]={
                               { .fd= sub_red,   .events= POLLIN },
                               { .fd= sub_green, .events= POLLIN },
                               { .fd= sub_blue,  .events= POLLIN }
                    };
                    int ret= poll(fds,3,1000);
 
                    /* check for a timeout */
                    if(ret==0){
                               puts("timeout");
                               cu.number=++timeouts;
                               orb_publish(ORB_ID(color_timeouts), pub_timeouts,&cu);
 
                    /* check for color updates */
                    }else{
 
                               if(fds[0].revents& POLLIN){
                                         orb_copy(ORB_ID(color_red), sub_red,&cu);
                                        printf("red is now %d\n", cu.number);
                               }
                               if(fds[1].revents& POLLIN){
                                         orb_copy(ORB_ID(color_green), sub_green,&cu);
                                        printf("green is now %d\n", cu.number);
                               }
                               if(fds[2].revents& POLLIN){
                                         orb_copy(ORB_ID(color_blue), sub_blue,&cu);
                                        printf("blue is now %d\n", cu.number);
                               }
                    }
          }
}

限制更新的速率

订阅器可能希望限制在订阅主题上接收更新的速率，这可以由下面的API完成。

/**
 * Set the minimum interval betweenwhich updates are seen for a subscription.
 *
 * If this interval is set, thesubscriber will not see more than one update
 * within the period.
 *
 * Specifically, the first time anupdate is reported to the subscriber a timer
 * is started. The update willcontinue to be reported via poll and orb_check, but
 * once fetched via orb_copy anotherupdate will not be reported until the timer
 * expires.
 *
 * This feature can be used to pacea subscriber that is watching a topic that
 * would otherwise update tooquickly.
 *
 * @param handle     A handle returned from orb_subscribe.
 * @param interval   An interval period in milliseconds.
 * @return           OK on success, ERROR otherwise with ERRNO set accordingly.
 */
externint          orb_set_interval(int handle,unsigned interval);

速率限制是具体到某一个订阅的，一个订阅主题可能具有多于一个的订阅器，分别具有不同的速率限制。