• uORBMain.cpp学习

    uorb_main
    1. int
    2. uorb_main(int argc, char *argv[])
    3. {
    4.     if (argc < 2) {
    5.         usage();                                                                                            //使用说明
    6.         return -EINVAL;
    7.     }

    9.     /*
    10.      * Start/load the driver.                                                                                //开始或加载驱动
    11.      */
    12.     if (!strcmp(argv[1], "start")) {

    14.         if (g_dev != nullptr) {                                                                               //判断是否已经启动
    15.             PX4_WARN("already loaded");
    16.             /* user wanted to start uorb, its already running, no error */
    17.             return 0;
    18.         }

    20.         if (!uORB::Manager::initialize()) {                                                                     //初始化uORB::Manager
    21.             PX4_ERR("uorb manager alloc failed");
    22.             return -ENOMEM;
    23.         }

    25.         /* create the driver */                                                                                //创建一个驱动设备
    26.         g_dev = uORB::Manager::get_instance()->get_device_master(uORB::PUBSUB);

    28.         if (g_dev == nullptr) {
    29.             return -errno;
    30.         }

    32. #if !defined(__PX4_QURT) && !defined(__PX4_POSIX_EAGLE) && !defined(__PX4_POSIX_EXCELSIOR)
    33.         /* FIXME: this fails on Snapdragon (see https://github.com/PX4/Firmware/issues/5406),
    34.          * so we disable logging messages to the ulog for now. This needs further investigations.
    35.          */
    36.         px4_log_initialize();
    37. #endif

    39.         return OK;
    40.     }

    42.     /*
    43.      * Print driver information.                                                                            //打印设备信息status
    44.      */
    45.     if (!strcmp(argv[1], "status")) {
    46.         if (g_dev != nullptr) {
    47.             g_dev->printStatistics(true);

    49.         } else {
    50.             PX4_INFO("uorb is not running");
    51.         }

    53.         return OK;
    54.     }
    55.                                                                                                             //topming'li
    56.     if (!strcmp(argv[1], "top")) {
    57.         if (g_dev != nullptr) {
    58.             g_dev->showTop(argv + 2, argc - 2);

    60.         } else {
    61.             PX4_INFO("uorb is not running");
    62.         }

    64.         return OK;
    65.     }

    67.     usage();
    68.     return -EINVAL;
    69. }
    uORB::Manager::initialize():
    1. bool uORB::Manager::initialize()
    2. {
    3.     if (_Instance == nullptr) {
    4.         _Instance = new uORB::Manager();                                            //创建了一个新的uORB实例
    5.     }

    7.     return _Instance != nullptr;
    8. }
    uORB::Manager:

    1. /**
    2.  * This is implemented as a singleton. This class manages creating the                                //这是一个实施的单例，这个class管理创建uORB节点给每个uORB topics
    3.  * uORB nodes for each uORB topics and also implements the behavor of the                             //并且也实施uORB的API行为
    4.  * uORB Api's.
    5.  */
    6. class uORB::Manager : public uORBCommunicator::IChannelRxHandler
    7. {
    8. public:
    9.     // public interfaces for this class.                                                                    //公共的类接口

    11.     /**                                                                                                    //初始化单例，调用这个在所有事情之前
    12.      * Initialize the singleton. Call this before everything else.
    13.      * @return true on success                                                                             //返回true是成功
    14.      */
    15.     static bool initialize();

    17.     /**                                                                                                    //获取instance的方法
    18.      * Method to get the singleton instance for the uORB::Manager.
    19.      * Make sure initialize() is called first.                                                             //确保initialize()先被调用
    20.      * @return uORB::Manager*                                                                                //返回创建的uORB：：Manager*
    21.      */
    22.     static uORB::Manager *get_instance()
    23.     {
    24.         return _Instance;
    25.     }

    27.     /**
    28.      * Get the DeviceMaster for a given Flavor. If it does not exist,                                        //给定一个flavoe，会返回DeciveMaster* 如果不存在会创建并且初始化
    29.      * it will be created and initialized.
    30.      * Note: the first call to this is not thread-safe.                                                      //第一次调用thread-safe不是这个？
    31.      * @return nullptr if initialization failed (and errno will be set)                                        //初始化失败返回一个nullptr
    32.      */
    33.     uORB::DeviceMaster *get_device_master(Flavor flavor);

    35.     // ==== uORB interface methods ====
    36.     /**
    37.      * Advertise as the publisher of a topic.                                                                    //广告作为发布话题
    38.      *
    39.      * This performs the initial advertisement of a topic; it creates the topic                                  //执行初始化的广告topic；它创造topic
    40.      * node in /obj if required and publishes the initial data.
    41.      *
    42.      * Any number of advertisers may publish to a topic; publications are atomic
    43.      * but co-ordination between publishers is not provided by the ORB.
    44.      *
    45.      * Internally this will call orb_advertise_multi with an instance of 0 and                                    //函数内部调用了orb_advertis_multi
    46.      * default priority.
    47.      *
    48.      * @param meta The uORB metadata (usually from the ORB_ID() macro)                                            //uORB metadata(通常来自ORB_ID()宏）作为topic
    49.      * for the topic.
    50.      * @param data A pointer to the initial data to be published.                                                 //数据指针
    51.      * For topics updated by interrupt handlers, the advertisement                                                //中断处理函数
    52.      * must be performed from non-interrupt context.                                                              //必须执行无中断的内容
    53.      * @param queue_size Maximum number of buffered elements. If this is 1, no queuing is                         //最大的buffer元素个数，如果是1，没有队列被使用
    54.      * used.
    55.      * @return nullptr on error, otherwise returns an object pointer                                              //返回空指针如果错误，否则返回一个类指针
    56.      * that can be used to publish to the topic.                                                                  //那个可以用来公布topic
    57.      * If the topic in question is not known (due to an                                                           //如果topic在问题中不被知道（由于ORB_DEFINE不和ORB_DECLARE一致）
    58.      * ORB_DEFINE with no corresponding ORB_DECLARE)
    59.      * this function will return nullptr and set errno to ENOENT.                                                 //这个函数将会返回nullptr并且设置errno到ENOENT
    60.      */
    61.     orb_advert_t orb_advertise(const struct orb_metadata *meta, const void *data, unsigned int queue_size = 1)
    62.     {
    63.         return orb_advertise_multi(meta, data, nullptr, ORB_PRIO_DEFAULT, queue_size);
    64.     }

    66.     /**
    67.      * Advertise as the publisher of a topic.
    68.      *
    69.      * This performs the initial advertisement of a topic; it creates the topic
    70.      * node in /obj if required and publishes the initial data.
    71.      *
    72.      * Any number of advertisers may publish to a topic; publications are atomic
    73.      * but co-ordination between publishers is not provided by the ORB.
    74.      *
    75.      * The multi can be used to create multiple independent instances of the same topic                                            //用来创建多个独立接口用于相同的topic
    76.      * (each instance has its own buffer).                                                                                         //每个接口都有自己的buff
    77.      * This is useful for multiple publishers who publish the same topic. The subscriber
    78.      * then subscribes to all instances and chooses which source he wants to use.
    79.      *
    80.      * @param meta The uORB metadata (usually from the ORB_ID() macro)                                                            //meta通常来自于ORB_ID()宏，是uORB的metadata
    81.      * for the topic.
    82.      * @param data A pointer to the initial data to be published.                                                                //data是一个初始化要发布数据的指针
    83.      * For topics updated by interrupt handlers, the advertisement                                                               //通过中断处理函数更新，
    84.      * must be performed from non-interrupt context.
    85.      * @param instance Pointer to an integer which will yield the instance ID (0-based)                                          //一个整形指针，用于接口ID（0-based)
    86.      * of the publication. This is an output parameter and will be set to the newly                                              //创建接口等等，0是第一个广告，1是下一个，如此往下
    87.      * created instance, ie. 0 for the first advertiser, 1 for the next and so on.
    88.      * @param priority The priority of the instance. If a subscriber subscribes multiple                                         //接口的优先级
    89.      * instances, the priority allows the subscriber to prioritize the best
    90.      * data source as long as its available. The subscriber is responsible to check
    91.      * and handle different priorities (@see orb_priority()).
    92.      * @param queue_size Maximum number of buffered elements. If this is 1, no queuing is                                        //最大的buffer元素个数，如果是1，没有queuing被使用
    93.      * used.
    94.      * @return ERROR on error, otherwise returns a handle                                                                        //返回ERROR在错误时，否则返回一个句柄。用于创建一个topic和publish
    95.      * that can be used to publish to the topic.
    96.      * If the topic in question is not known (due to an
    97.      * ORB_DEFINE with no corresponding ORB_DECLARE)
    98.      * this function will return -1 and set errno to ENOENT.
    99.      */
    100.     orb_advert_t orb_advertise_multi(const struct orb_metadata *meta, const void *data, int *instance,
    101.                      int priority, unsigned int queue_size = 1) ;


    104.     /**
    105.      * Unadvertise a topic.
    106.      *
    107.      * @param handle handle returned by orb_advertise or orb_advertise_multi.                                                                        //用于取消一个topic， handle是orb_advertise_multi返回的handle
    108.      * @return 0 on success
    109.      */
    110.     int orb_unadvertise(orb_advert_t handle);

    112.     /**
    113.      * Publish new data to a topic.                                                                                                                   //发布一个新的
    114.      *
    115.      * The data is atomically published to the topic and any waiting subscribers
    116.      * will be notified. Subscribers that are not waiting can check the topic
    117.      * for updates using orb_check and/or orb_stat.
    118.      *
    119.      * @param meta The uORB metadata (usually from the ORB_ID() macro)                                                                                //从ORB_ID宏的metadata
    120.      * for the topic.
    121.      * @handle The handle returned from orb_advertise.                                                                                                //orb_advertise返回的handle
    122.      * @param data A pointer to the data to be published.                                                                                             //publish的数据的指针
    123.      * @return OK on success, ERROR otherwise with errno set accordingly.                                                                             //返回OK如果成功
    124.      */
    125.     int orb_publish(const struct orb_metadata *meta, orb_advert_t handle, const void *data) ;

    127.     /**
    128.      * Subscribe to a topic.                                                                                                                          //订阅一个topic
    129.      *
    130.      * The returned value is a file descriptor that can be passed to poll()
    131.      * in order to wait for updates to a topic, as well as topic_read,
    132.      * orb_check and orb_stat.
    133.      *
    134.      * Subscription will succeed even if the topic has not been advertised;
    135.      * in this case the topic will have a timestamp of zero, it will never
    136.      * signal a poll() event, checking will always return false and it cannot
    137.      * be copied. When the topic is subsequently advertised, poll, check,
    138.      * stat and copy calls will react to the initial publication that is
    139.      * performed as part of the advertisement.
    140.      *
    141.      * Subscription will fail if the topic is not known to the system, i.e.
    142.      * there is nothing in the system that has declared the topic and thus it
    143.      * can never be published.
    144.      *
    145.      * Internally this will call orb_subscribe_multi with instance 0.
    146.      *
    147.      * @param meta The uORB metadata (usually from the ORB_ID() macro)                                                                                    //订阅主题的metadata
    148.      * for the topic.
    149.      * @return ERROR on error, otherwise returns a handle
    150.      * that can be used to read and update the topic.
    151.      */
    152.     int orb_subscribe(const struct orb_metadata *meta) ;

    154.     /**
    155.      * Subscribe to a multi-instance of a topic.                                                                                                        //订阅多个主题
    156.      *
    157.      * The returned value is a file descriptor that can be passed to poll()
    158.      * in order to wait for updates to a topic, as well as topic_read,
    159.      * orb_check and orb_stat.
    160.      *
    161.      * Subscription will succeed even if the topic has not been advertised;
    162.      * in this case the topic will have a timestamp of zero, it will never
    163.      * signal a poll() event, checking will always return false and it cannot
    164.      * be copied. When the topic is subsequently advertised, poll, check,
    165.      * stat and copy calls will react to the initial publication that is
    166.      * performed as part of the advertisement.
    167.      *
    168.      * Subscription will fail if the topic is not known to the system, i.e.
    169.      * there is nothing in the system that has declared the topic and thus it
    170.      * can never be published.
    171.      *
    172.      * If a publisher publishes multiple instances the subscriber should
    173.      * subscribe to each instance with orb_subscribe_multi
    174.      * (@see orb_advertise_multi()).
    175.      *
    176.      * @param meta The uORB metadata (usually from the ORB_ID() macro)
    177.      * for the topic.
    178.      * @param instance The instance of the topic. Instance 0 matches the
    179.      * topic of the orb_subscribe() call, higher indices
    180.      * are for topics created with orb_advertise_multi().
    181.      * @return ERROR on error, otherwise returns a handle
    182.      * that can be used to read and update the topic.
    183.      * If the topic in question is not known (due to an
    184.      * ORB_DEFINE_OPTIONAL with no corresponding ORB_DECLARE)
    185.      * this function will return -1 and set errno to ENOENT.
    186.      */
    187.     int orb_subscribe_multi(const struct orb_metadata *meta, unsigned instance) ;

    189.     /**
    190.      * Unsubscribe from a topic.
    191.      *
    192.      * @param handle A handle returned from orb_subscribe.
    193.      * @return OK on success, ERROR otherwise with errno set accordingly.
    194.      */
    195.     int orb_unsubscribe(int handle) ;                                                                                                //取消订阅一个主题,handle是orb_subscribe返回的句柄

    197.     /**
    198.      * Fetch data from a topic.
    199.      *
    200.      * This is the only operation that will reset the internal marker that
    201.      * indicates that a topic has been updated for a subscriber. Once poll
    202.      * or check return indicating that an updaet is available, this call
    203.      * must be used to update the subscription.
    204.      *
    205.      * @param meta The uORB metadata (usually from the ORB_ID() macro)
    206.      * for the topic.
    207.      * @param handle A handle returned from orb_subscribe.
    208.      * @param buffer Pointer to the buffer receiving the data, or NULL
    209.      * if the caller wants to clear the updated flag without
    210.      * using the data.
    211.      * @return OK on success, ERROR otherwise with errno set accordingly.
    212.      */
    213.     int orb_copy(const struct orb_metadata *meta, int handle, void *buffer) ;                                                        //从主题中获取数据，buffer就是接收数据存放的位置

    215.     /**
    216.      * Check whether a topic has been published to since the last orb_copy.
    217.      *
    218.      * This check can be used to determine whether to copy the topic when
    219.      * not using poll(), or to avoid the overhead of calling poll() when the
    220.      * topic is likely to have updated.
    221.      *
    222.      * Updates are tracked on a per-handle basis; this call will continue to
    223.      * return true until orb_copy is called using the same handle. This interface
    224.      * should be preferred over calling orb_stat due to the race window between
    225.      * stat and copy that can lead t
    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    从csv文件里取数据作为请求参数，和把返回数据放到一个csv文件
    记一次if控制器的使用
    记一次使用正则表达式+foreach控制器调试
    获取随机数用作入参使用
    获取返回结果作为参数并将其设置为全局变量（实现跨线程组使用）
    linux默认的目录结构
    总结fiddler抓https包
    Codeforces Round #733 (Div. 1 + Div. 2) D. Secret Santa
    Codeforces Round #733 (Div. 1 + Div. 2) C. Pursuit
    Codeforces Round #731 (Div. 3) A
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363238.html
Copyright © 2020-2023  润新知