bbzz2
bbzz2

订阅传感器数据

Step 5: 订阅传感器数据

为了做有用的事情，应用需要订阅subscribe输入并发布publish输出 (e.g. 电机 或伺服指令). PX4平台真正的硬件抽象（true hardware abstraction ）开始有用——不需要与传感器驱动以任何方式相互作用，并且电路板或者传感器升级后不需要升级。

PX4中应用间独立的消息通道被称作topics. 在这里，感兴趣的是 sensor_combined topic, 其调用整个系统的同步传感器数据。

订阅到topic非常快和干净：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. #include   
    2. 
      
      
      
      
  2. ..  
    3. 
      
      
      
      
  3. int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));  
    4. 
     
     
     
     

  
    
    
    
    
#include 
..
int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));

sensor_sub_fd 是一个文件描述符，非常高效的执行一块等待新的数据的数据块。当前的进程进入休眠，当有新的数据可用时，由调度程序自动地唤醒，在等待的时候，不占用任何CPU周期。为实现这点，使用poll()，调用 POSIX system 。

将poll() 添加到subscription看上去像：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. #include   
    2. 
      
      
      
      
  2. #include   
    3. 
      
      
      
      
  3. ..  
    4. 
      
      
      
      
  4. int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));  
    5. 
      
      
      
      
  5.    
    6. 
      
      
      
      
  6. /* one could wait for multiple topics with this technique, just using one here */  
    7. 
      
      
      
      
  7. struct pollfd fds[] = {  
    8. 
      
      
      
      
  8.          { .fd = sensor_sub_fd,   .events = POLLIN },  
    9. 
      
      
      
      
  9. };  
    10. 
      
      
      
      
  10.    
    11. 
      
      
      
      
  11. while (true) {  
    12. 
      
      
      
      
  12.          /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */  
    13. 
      
      
      
      
  13.          int poll_ret = poll(fds, 1, 1000);  
    14. 
      
      
      
      
  14. ..  
    15. 
      
      
      
      
  15.          if (fds[0].revents & POLLIN) {  
    16. 
      
      
      
      
  16.                  /* obtained data for the first file descriptor */  
    17. 
      
      
      
      
  17.                  struct sensor_combined_s raw;  
    18. 
      
      
      
      
  18.                  /* copy sensors raw data into local buffer */  
    19. 
      
      
      
      
  19.                  orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);  
    20. 
      
      
      
      
  20.                  printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",  
    21. 
      
      
      
      
  21.                                             (double)raw.accelerometer_m_s2[0],  
    22. 
      
      
      
      
  22.                                             (double)raw.accelerometer_m_s2[1],  
    23. 
      
      
      
      
  23.                                             (double)raw.accelerometer_m_s2[2]);  
    24. 
      
      
      
      
  24.          }  
    25. 
      
      
      
      
  25. }  
    26. 
     
     
     
     

  
    
    
    
    
#include 
#include 
..
int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));
 
/* one could wait for multiple topics with this technique, just using one here */
struct pollfd fds[] = {
         { .fd = sensor_sub_fd,   .events = POLLIN },
};
 
while (true) {
         /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */
         int poll_ret = poll(fds, 1, 1000);
..
         if (fds[0].revents & POLLIN) {
                 /* obtained data for the first file descriptor */
                 struct sensor_combined_s raw;
                 /* copy sensors raw data into local buffer */
                 orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);
                 printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",
                                            (double)raw.accelerometer_m_s2[0],
                                            (double)raw.accelerometer_m_s2[1],
                                            (double)raw.accelerometer_m_s2[2]);
         }
}

px4_simple_app 的完整代码如下：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. /** 
    2. 
      
      
      
      
  2.  * @file px4_simple_app.c 
    3. 
      
      
      
      
  3.  * Minimal application example for PX4 autopilot 
    4. 
      
      
      
      
  4.  * 
    5. 
      
      
      
      
  5.  * @author Example User  
    6. 
      
      
      
      
  6.  */  
    7. 
      
      
      
      
  7.    
    8. 
      
      
      
      
  8. #include   
    9. 
      
      
      
      
  9. #include   
    10. 
      
      
      
      
  10. #include   
    11. 
      
      
      
      
  11. #include   
    12. 
      
      
      
      
  12.    
    13. 
      
      
      
      
  13. #include   
    14. 
      
      
      
      
  14. #include   
    15. 
      
      
      
      
  15.    
    16. 
      
      
      
      
  16. __EXPORT int px4_simple_app_main(int argc, char *argv[]);  
    17. 
      
      
      
      
  17.    
    18. 
      
      
      
      
  18. int px4_simple_app_main(int argc, char *argv[])  
    19. 
      
      
      
      
  19. {  
    20. 
      
      
      
      
  20.           printf("Hello Sky!\n");  
    21. 
      
      
      
      
  21.    
    22. 
      
      
      
      
  22.           /* subscribe to sensor_combined topic */  
    23. 
      
      
      
      
  23.           int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));  
    24. 
      
      
      
      
  24.    
    25. 
      
      
      
      
  25.           /* one could wait for multiple topics with this technique, just using one here */  
    26. 
      
      
      
      
  26.           struct pollfd fds[] = {  
    27. 
      
      
      
      
  27.                     { .fd = sensor_sub_fd,   .events = POLLIN },  
    28. 
      
      
      
      
  28.                     /* there could be more file descriptors here, in the form like: 
    29. 
      
      
      
      
  29.                      * { .fd = other_sub_fd,   .events = POLLIN }, 
    30. 
      
      
      
      
  30.                      */  
    31. 
      
      
      
      
  31.           };  
    32. 
      
      
      
      
  32.    
    33. 
      
      
      
      
  33.           int error_counter = 0;  
    34. 
      
      
      
      
  34.    
    35. 
      
      
      
      
  35.           while (true) {  
    36. 
      
      
      
      
  36.                     /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */  
    37. 
      
      
      
      
  37.                     int poll_ret = poll(fds, 1, 1000);  
    38. 
      
      
      
      
  38.    
    39. 
      
      
      
      
  39.                     /* handle the poll result */  
    40. 
      
      
      
      
  40.                     if (poll_ret == 0) {  
    41. 
      
      
      
      
  41.                                /* this means none of our providers is giving us data */  
    42. 
      
      
      
      
  42.                                printf("[px4_simple_app] Got no data within a second\n");  
    43. 
      
      
      
      
  43.                     } else if (poll_ret < 0) {  
    44. 
      
      
      
      
  44.                                /* this is seriously bad - should be an emergency */  
    45. 
      
      
      
      
  45.                                if (error_counter < 10 || error_counter % 50 == 0) {  
    46. 
      
      
      
      
  46.                                          /* use a counter to prevent flooding (and slowing us down) */  
    47. 
      
      
      
      
  47.                                          printf("[px4_simple_app] ERROR return value from poll(): %d\n"  
    48. 
      
      
      
      
  48.                                                    , poll_ret);  
    49. 
      
      
      
      
  49.                                }  
    50. 
      
      
      
      
  50.                                error_counter++;  
    51. 
      
      
      
      
  51.                     } else {  
    52. 
      
      
      
      
  52.    
    53. 
      
      
      
      
  53.                                if (fds[0].revents & POLLIN) {  
    54. 
      
      
      
      
  54.                                          /* obtained data for the first file descriptor */  
    55. 
      
      
      
      
  55.                                          struct sensor_combined_s raw;  
    56. 
      
      
      
      
  56.                                          /* copy sensors raw data into local buffer */  
    57. 
      
      
      
      
  57.                                          orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);  
    58. 
      
      
      
      
  58.                                          printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",  
    59. 
      
      
      
      
  59.                                                    (double)raw.accelerometer_m_s2[0],  
    60. 
      
      
      
      
  60.                                                    (double)raw.accelerometer_m_s2[1],  
    61. 
      
      
      
      
  61.                                                    (double)raw.accelerometer_m_s2[2]);  
    62. 
      
      
      
      
  62.                                }  
    63. 
      
      
      
      
  63.                                /* there could be more file descriptors here, in the form like: 
    64. 
      
      
      
      
  64.                                 * if (fds[1..n].revents & POLLIN) {} 
    65. 
      
      
      
      
  65.                                 */  
    66. 
      
      
      
      
  66.                     }  
    67. 
      
      
      
      
  67.           }  
    68. 
      
      
      
      
  68.    
    69. 
      
      
      
      
  69.           return 0;  
    70. 
      
      
      
      
  70. }  
    71. 
     
     
     
     

  
    
    
    
    
/**
 * @file px4_simple_app.c
 * Minimal application example for PX4 autopilot
 *
 * @author Example User 
 */
 
#include 
#include 
#include 
#include 
 
#include 
#include 
 
__EXPORT int px4_simple_app_main(int argc, char *argv[]);
 
int px4_simple_app_main(int argc, char *argv[])
{
          printf("Hello Sky!\n");
 
          /* subscribe to sensor_combined topic */
          int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));
 
          /* one could wait for multiple topics with this technique, just using one here */
          struct pollfd fds[] = {
                    { .fd = sensor_sub_fd,   .events = POLLIN },
                    /* there could be more file descriptors here, in the form like:
                     * { .fd = other_sub_fd,   .events = POLLIN },
                     */
          };
 
          int error_counter = 0;
 
          while (true) {
                    /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */
                    int poll_ret = poll(fds, 1, 1000);
 
                    /* handle the poll result */
                    if (poll_ret == 0) {
                               /* this means none of our providers is giving us data */
                               printf("[px4_simple_app] Got no data within a second\n");
                    } else if (poll_ret < 0) {
                               /* this is seriously bad - should be an emergency */
                               if (error_counter < 10 || error_counter % 50 == 0) {
                                         /* use a counter to prevent flooding (and slowing us down) */
                                         printf("[px4_simple_app] ERROR return value from poll(): %d\n"
                                                   , poll_ret);
                               }
                               error_counter++;
                    } else {
 
                               if (fds[0].revents & POLLIN) {
                                         /* obtained data for the first file descriptor */
                                         struct sensor_combined_s raw;
                                         /* copy sensors raw data into local buffer */
                                         orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);
                                         printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",
                                                   (double)raw.accelerometer_m_s2[0],
                                                   (double)raw.accelerometer_m_s2[1],
                                                   (double)raw.accelerometer_m_s2[2]);
                               }
                               /* there could be more file descriptors here, in the form like:
                                * if (fds[1..n].revents & POLLIN) {}
                                */
                    }
          }
 
          return 0;
}

编译app，通过下面的指令：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. make  
    2. 
     
     
     
     

  
    
    
    
    
make

测试uORB订阅

运行更新后的程序。UORB app 可能已经在运行，但是重新运行一次也没关系，所以执行:

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. uorb start  
    2. 
     
     
     
     

  
    
    
    
    
uorb start

目标请求中间人已经被激活，可以启动传感器：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. sh /etc/init.d/rc.sensors  
    2. 
     
     
     
     

  
    
    
    
    
sh /etc/init.d/rc.sensors

最后一步是启动应用，但是为什么语法不同？

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. px4_simple_app &  
    2. 
     
     
     
     

  
    
    
    
    
px4_simple_app &

不同是，uorb和传感器应用作为后台程序运行Daemon(computing)。 这就允许在不失去对NuttShell控制的情况下，启动/停止其。假如忘了在行末输入& ，应用将会将现在传感器的值铺满显示屏：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. [px4_simple_app] Accelerometer:   0.0483          0.0821          0.0332  
    2. 
      
      
      
      
  2. [px4_simple_app] Accelerometer:   0.0486          0.0820          0.0336  
    3. 
      
      
      
      
  3. [px4_simple_app] Accelerometer:   0.0487          0.0819          0.0327  
    4. 
      
      
      
      
  4. [px4_simple_app] Accelerometer:   0.0482          0.0818          0.0323  
    5. 
      
      
      
      
  5. [px4_simple_app] Accelerometer:   0.0482          0.0827          0.0331  
    6. 
      
      
      
      
  6. [px4_simple_app] Accelerometer:   0.0489          0.0804          0.0328  
    7. 
     
     
     
     

  
    
    
    
    
[px4_simple_app] Accelerometer:   0.0483          0.0821          0.0332
[px4_simple_app] Accelerometer:   0.0486          0.0820          0.0336
[px4_simple_app] Accelerometer:   0.0487          0.0819          0.0327
[px4_simple_app] Accelerometer:   0.0482          0.0818          0.0323
[px4_simple_app] Accelerometer:   0.0482          0.0827          0.0331
[px4_simple_app] Accelerometer:   0.0489          0.0804          0.0328

由于不是后台程序，没有办法将其停止，只能让其运行，或者通过发起下面的命令重启自驾仪：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. reboot  
    2. 
     
     
     
     

  
    
    
    
    
reboot

或者按压PX4FMU上的reset button.如何将应用变为后台程序可以参考this tutorial 。

Step 6: 速率受限的订阅

上一步最后一步是屏幕上铺满传感器数据。通常并不需要数据以最高速率刷新，试图保持最高速率，通常会使整个系统变慢。

API接口非常简单:

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. orb_set_interval(int handle, unsigned interval);  
    2. 
     
     
     
     

  
    
    
    
    
orb_set_interval(int handle, unsigned interval);

限制topic到1 Hz, 只需添加：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. orb_set_interval(sensor_sub_fd, 1000);  
    2. 
     
     
     
     

  
    
    
    
    
orb_set_interval(sensor_sub_fd, 1000);

到示例代码这行的下面(在line 55附近):

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. /* subscribe to sensor_combined topic */  
    2. 
      
      
      
      
  2. int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));  
    3. 
     
     
     
     

  
    
    
    
    
/* subscribe to sensor_combined topic */
int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));

屏幕将会以1Hz的速率方便的打印传感器数据。

Step 7: 发布数据

为了使用计算得到的输出，下一步是发布结果。假如我们使用了一个topic，mavlink app通过该topic转发到地面站，我们甚至可以查看结果。出于这个目的，来拦截姿态 topic。

接口非常简单，初始化topic结构，并通告（advertise)topic。 

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. #include   
    2. 
      
      
      
      
  2. ..  
    3. 
      
      
      
      
  3. /* advertise attitude topic */  
    4. 
      
      
      
      
  4. struct vehicle_attitude_s att;  
    5. 
      
      
      
      
  5. memset(&att, 0, sizeof(att));  
    6. 
      
      
      
      
  6. orb_advert_t att_pub_fd = orb_advertise(ORB_ID(vehicle_attitude), &att);  
    7. 
     
     
     
     

  
    
    
    
    
#include 
..
/* advertise attitude topic */
struct vehicle_attitude_s att;
memset(&att, 0, sizeof(att));
orb_advert_t att_pub_fd = orb_advertise(ORB_ID(vehicle_attitude), &att);

在主循环中，当其准备好后，发布信息：

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [cpp] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. orb_publish(ORB_ID(vehicle_attitude), att_pub_fd, &att);  
    2. 
     
     
     
     

  
    
    
    
    
orb_publish(ORB_ID(vehicle_attitude), att_pub_fd, &att);

修改后的完整示例代码为：

[cpp] view plain copy print ?
  1. /** 
  2.  * @file px4_simple_app.c 
  3.  * Minimal application example for PX4 autopilot 
  4.  */  
  5.    
  6. #include   
  7. #include   
  8. #include   
  9. #include   
  10.    
  11. #include   
  12. #include   
  13. #include   
  14.    
  15. __EXPORT int px4_simple_app_main(int argc, char *argv[]);  
  16.    
  17. int px4_simple_app_main(int argc, char *argv[])  
  18. {  
  19.          printf("Hello Sky!\n");  
  20.    
  21.          /* subscribe to sensor_combined topic */  
  22.          int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));  
  23.          orb_set_interval(sensor_sub_fd, 1000);  
  24.    
  25.          /* advertise attitude topic */  
  26.          struct vehicle_attitude_s att;  
  27.          memset(&att, 0, sizeof(att));  
  28.          int att_pub_fd = orb_advertise(ORB_ID(vehicle_attitude), &att);  
  29.    
  30.          /* one could wait for multiple topics with this technique, just using one here */  
  31.          struct pollfd fds[] = {  
  32.                  { .fd = sensor_sub_fd,   .events = POLLIN },  
  33.                  /* there could be more file descriptors here, in the form like: 
  34.                   * { .fd = other_sub_fd,   .events = POLLIN }, 
  35.                   */  
  36.          };  
  37.    
  38.          int error_counter = 0;  
  39.    
  40.          while (true) {  
  41.                  /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */  
  42.                  int poll_ret = poll(fds, 1, 1000);  
  43.    
  44.                  /* handle the poll result */  
  45.                  if (poll_ret == 0) {  
  46.                           /* this means none of our providers is giving us data */  
  47.                           printf("[px4_simple_app] Got no data within a second\n");  
  48.                  } else if (poll_ret < 0) {  
  49.                           /* this is seriously bad - should be an emergency */  
  50.                           if (error_counter < 10 || error_counter % 50 == 0) {  
  51.                                    /* use a counter to prevent flooding (and slowing us down) */  
  52.                                    printf("[px4_simple_app] ERROR return value from poll(): %d\n"  
  53.                                             , poll_ret);  
  54.                           }  
  55.                           error_counter++;  
  56.                  } else {  
  57.    
  58.                           if (fds[0].revents & POLLIN) {  
  59.                                    /* obtained data for the first file descriptor */  
  60.                                    struct sensor_combined_s raw;  
  61.                                    /* copy sensors raw data into local buffer */  
  62.                                    orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);  
  63.                                    printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",  
  64.                                             (double)raw.accelerometer_m_s2[0],  
  65.                                             (double)raw.accelerometer_m_s2[1],  
  66.                                             (double)raw.accelerometer_m_s2[2]);  
  67.    
  68.                                    /* set att and publish this information for other apps */  
  69.                                    att.roll = raw.accelerometer_m_s2[0];  
  70.                                    att.pitch = raw.accelerometer_m_s2[1];  
  71.                                    att.yaw = raw.accelerometer_m_s2[2];  
  72.                                    orb_publish(ORB_ID(vehicle_attitude), att_pub_fd, &att);  
  73.                           }  
  74.                           /* there could be more file descriptors here, in the form like: 
  75.                            * if (fds[1..n].revents & POLLIN) {} 
  76.                            */  
  77.                  }  
  78.          }  
  79.    
  80.          return 0;  
  81. }  
/**
 * @file px4_simple_app.c
 * Minimal application example for PX4 autopilot
 */
 
#include 
#include 
#include 
#include 
 
#include 
#include 
#include 
 
__EXPORT int px4_simple_app_main(int argc, char *argv[]);
 
int px4_simple_app_main(int argc, char *argv[])
{
         printf("Hello Sky!\n");
 
         /* subscribe to sensor_combined topic */
         int sensor_sub_fd = orb_subscribe(ORB_ID(sensor_combined));
         orb_set_interval(sensor_sub_fd, 1000);
 
         /* advertise attitude topic */
         struct vehicle_attitude_s att;
         memset(&att, 0, sizeof(att));
         int att_pub_fd = orb_advertise(ORB_ID(vehicle_attitude), &att);
 
         /* one could wait for multiple topics with this technique, just using one here */
         struct pollfd fds[] = {
                 { .fd = sensor_sub_fd,   .events = POLLIN },
                 /* there could be more file descriptors here, in the form like:
                  * { .fd = other_sub_fd,   .events = POLLIN },
                  */
         };
 
         int error_counter = 0;
 
         while (true) {
                 /* wait for sensor update of 1 file descriptor for 1000 ms (1 second) */
                 int poll_ret = poll(fds, 1, 1000);
 
                 /* handle the poll result */
                 if (poll_ret == 0) {
                          /* this means none of our providers is giving us data */
                          printf("[px4_simple_app] Got no data within a second\n");
                 } else if (poll_ret < 0) {
                          /* this is seriously bad - should be an emergency */
                          if (error_counter < 10 || error_counter % 50 == 0) {
                                   /* use a counter to prevent flooding (and slowing us down) */
                                   printf("[px4_simple_app] ERROR return value from poll(): %d\n"
                                            , poll_ret);
                          }
                          error_counter++;
                 } else {
 
                          if (fds[0].revents & POLLIN) {
                                   /* obtained data for the first file descriptor */
                                   struct sensor_combined_s raw;
                                   /* copy sensors raw data into local buffer */
                                   orb_copy(ORB_ID(sensor_combined), sensor_sub_fd, &raw);
                                   printf("[px4_simple_app] Accelerometer:\t%8.4f\t%8.4f\t%8.4f\n",
                                            (double)raw.accelerometer_m_s2[0],
                                            (double)raw.accelerometer_m_s2[1],
                                            (double)raw.accelerometer_m_s2[2]);
 
                                   /* set att and publish this information for other apps */
                                   att.roll = raw.accelerometer_m_s2[0];
                                   att.pitch = raw.accelerometer_m_s2[1];
                                   att.yaw = raw.accelerometer_m_s2[2];
                                   orb_publish(ORB_ID(vehicle_attitude), att_pub_fd, &att);
                          }
                          /* there could be more file descriptors here, in the form like:
                           * if (fds[1..n].revents & POLLIN) {}
                           */
                 }
         }
 
         return 0;
}


运行最终的程序
需要一些基础应用:
  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. uorb start  
    2. 
      
      
      
      
  2. sh /etc/init.d/rc.sensors  
    3. 
      
      
      
      
  3. mavlink start -d /dev/ttyS1 -b 115200  
    4. 
     
     
     
     

  
    
    
    
    
uorb start
sh /etc/init.d/rc.sensors
mavlink start -d /dev/ttyS1 -b 115200

最终运行应用:

  
    
    
    
    

   
     
     
     
     

    
      
      
      
      

     [plain] 
     view plain
      copy
      print
     ?
    
      
      
      
      

   
     
     
     
     

   
     
     
     
     
    
      
      
      
      
  1. px4_simple_app &  
    2. 
     
     
     
     

  
    
    
    
    
px4_simple_app &

假如启动了QGroundControl或者Mission Planner, 可以检查在实时绘图中显示的传感器数据(Main Menu: Main Widget →Realtime Plot)，这些数据反映了进程正在发送的数据。

Wrap-Up

这个教程涉及到了所有需要在PX4自驾仪应用上进行增量开发所需的内容。需要知道的是，在availablehere 这里有完整的topics列表，而且头文件都被写好，并作为参考。

该示例应用在 src/examples/px4_simple_app可用. 在app配置中，注释掉Firmware/makefiles/nuttx/config_px4fmu-v2_default.mk即可。








/****************************************************************************
 * Name: nsh_main
 ****************************************************************************/

int nsh_main(int argc, char *argv[])
{
  int exitval = 0;
  int ret;

  /* Call all C++ static constructors */

#if defined(CONFIG_HAVE_CXX) && defined(CONFIG_HAVE_CXXINITIALIZE)
  up_cxxinitialize();
#endif

  /* Make sure that we are using our symbol take */

#if defined(CONFIG_LIBC_EXECFUNCS) && defined(CONFIG_EXECFUNCS_SYMTAB)
  exec_setsymtab(CONFIG_EXECFUNCS_SYMTAB, 0);
#endif

  /* Register the BINFS file system */

#if defined(CONFIG_FS_BINFS) && (CONFIG_BUILTIN)
  ret = builtin_initialize();
  if (ret < 0)
    {
     fprintf(stderr, "ERROR: builtin_initialize failed: %d\n", ret);
     exitval = 1;
   }
#endif

  /* Initialize the NSH library */

  nsh_initialize();

  /* If the Telnet console is selected as a front-end, then start the
   * Telnet daemon.
   */

#ifdef CONFIG_NSH_TELNET
  ret = nsh_telnetstart();
  if (ret < 0)
    {
     /* The daemon is NOT running.  Report the the error then fail...
      * either with the serial console up or just exiting.
      */

     fprintf(stderr, "ERROR: Failed to start TELNET daemon: %d\n", ret);
     exitval = 1;
   }
#endif

  /* If the serial console front end is selected, then run it on this thread */

#ifdef CONFIG_NSH_CONSOLE
  ret = nsh_consolemain(0, NULL);

  /* nsh_consolemain() should not return.  So if we get here, something
   * is wrong.
   */

  fprintf(stderr, "ERROR: nsh_consolemain() returned: %d\n", ret);
  exitval = 1;
#endif

  return exitval;
}


up_cxxinitialize函数我们昨天在 IO找那个已经遇到过了，是用来调用 C++中的静态构造函数的，我们就不去管它了。 “exec_setsymtab”呢缺少一个宏，不会被编译。 “builtin_initialize”函数让我想到了 “g_builtins”数组。

static struct binfmt_s g_builtin_binfmt =
{
  NULL,               /* next */
  builtin_loadbinary, /* load */
};
int builtin_initialize(void)
{
  int ret;

  /* Register ourselves as a binfmt loader */

  bvdbg("Registering Builtin Loader\n");

  ret = register_binfmt(&g_builtin_binfmt);
  if (ret != 0)
    {
      bdbg("Failed to register binfmt: %d\n", ret);
    }

  return ret;
}
int register_binfmt(FAR struct binfmt_s *binfmt)
{
  if (binfmt)
    {
      /* Add the new binary format handler to the head of the list of
       * handlers
       */

      sched_lock();
      binfmt->next = g_binfmts;
      g_binfmts    = binfmt;
      sched_unlock();
      return OK;
    }
  return -EINVAL;
}


这里的初始化可以认为是链表的初始化。只是目前我们没有看到这跟 “g_builtins”数组有什么关系。但如果真的没有猫腻又为什么要这么命名呢，是吧。而答案可能就在 “builtin_loadbinary”函数。

/****************************************************************************
 * Name: builtin_loadbinary
 *
 * Description:
 *   Verify that the file is an builtin binary.
 *
 ****************************************************************************/

static int builtin_loadbinary(struct binary_s *binp)
{
  FAR const char *filename;
  FAR const struct builtin_s *b;
  int fd;
  int index;
  int ret;

  bvdbg("Loading file: %s\n", binp->filename);

  /* Open the binary file for reading (only) */

  fd = open(binp->filename, O_RDONLY);
  if (fd < 0)
    {
      int errval = errno;
      bdbg("ERROR: Failed to open binary %s: %d\n", binp->filename, errval);
      return -errval;
    }

  /* If this file is a BINFS file system, then we can recover the name of
   * the file using the FIOC_FILENAME ioctl() call.
   */

  ret = ioctl(fd, FIOC_FILENAME, (unsigned long)((uintptr_t)&filename));
  if (ret < 0)
    {
      int errval = errno;
      bdbg("ERROR: FIOC_FILENAME ioctl failed: %d\n", errval);
      return -errval;
    }

  /* Other file systems may also support FIOC_FILENAME, so the real proof
   * is that we can look up the index to this name in g_builtins[].
   */

  index = builtin_isavail(filename);
  if (index < 0)
    {
      int errval = errno;
      bdbg("ERROR: %s is not a builtin application\n", filename);
      return -errval;
      
    }

  /* Return the load information.  NOTE: that there is no way to configure
   * the priority.  That is a bug and needs to be fixed.
   */

  b = builtin_for_index(index);
  binp->entrypt   = b->main;
  binp->stacksize = b->stacksize;
  binp->priority  = b->priority;
  return OK;
}
int builtin_isavail(FAR const char *appname)
{
  FAR const char *name;
  int i;

  for (i = 0; (name = builtin_getname(i)); i++)
    {
      if (!strncmp(name, appname, NAME_MAX))
        {
          return i;
        }
    }

  set_errno(ENOENT);
  return ERROR;
}
FAR const char *builtin_getname(int index)
{
  FAR const struct builtin_s *builtin;

  builtin = builtin_for_index(index);

  if (builtin != NULL)
    {
      return builtin->name;
    }

  return NULL;
}
extern const struct builtin_s g_builtins[];
extern const int g_builtin_count;
FAR const struct builtin_s *builtin_for_index(int index)
{
  if (index < g_builtin_count)
    {
      return &g_builtins[index];
    }
  return NULL;
}


不难看出这段代码其实就是用来调用 “g_builtins”数组中的入口函数的。只是文件操作然人会有点糊涂，不知为何要通过文件操作去获取这些入口函数。所以现在我们需要了解的是 “builtin_loadbinary”函数在哪个地方调用。
    接下来是 nsh初始化。

/****************************************************************************
 * Name: nsh_initialize
 *
 * Description:
 *   This nterfaces is used to initialize the NuttShell (NSH).
 *   nsh_initialize() should be called one during application start-up prior
 *   to executing either nsh_consolemain() or nsh_telnetstart().
 *
 * Input Parameters:
 *   None
 *
 * Returned Value:
 *   None
 *
 ****************************************************************************/

void nsh_initialize(void)
{
  /* Mount the /etc filesystem */

  (void)nsh_romfsetc();

  /* Perform architecture-specific initialization (if available) */

  (void)nsh_archinitialize();

  /* Bring up the network */

  (void)nsh_netinit();
}


通过注释我们知道，有两种方式可以用来执行 nsh： console和 telnet。 console使用串口通讯， telnet通过网络通讯。我们不使用网络所以不考了 telnet。
    在该初始化函数里边我们只需关心第一个 nsh_romfsetc，用来挂载文件系统。

int nsh_romfsetc(void)
{
  int  ret;

  /* Create a ROM disk for the /etc filesystem */

  ret = romdisk_register(CONFIG_NSH_ROMFSDEVNO, romfs_img,
                         NSECTORS(romfs_img_len), CONFIG_NSH_ROMFSSECTSIZE);
  if (ret < 0)
    {
      dbg("nsh: romdisk_register failed: %d\n", -ret);
      return ERROR;
    }

  /* Mount the file system */

  vdbg("Mounting ROMFS filesystem at target=%s with source=%s\n",
       CONFIG_NSH_ROMFSMOUNTPT, MOUNT_DEVNAME);

  ret = mount(MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, "romfs", MS_RDONLY, NULL);
  if (ret < 0)
    {
      dbg("nsh: mount(%s,%s,romfs) failed: %d\n",
          MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, errno);
      return ERROR;
    }
  return OK;
}


之前我一直都以为 romfs是根文件系统，但这里只是将 romfs挂载到 /etc目录，所以并不是根文件系统，只有 /etc的内容。而根文件系统应该是存在与内存即 sram，所以 IO板正常运行。
    那么 “nsh_consolemain”就是 nsh_main中我们最后需要去看的函数。

int nsh_consolemain(int argc, char *argv[])
{
  FAR struct console_stdio_s *pstate = nsh_newconsole();
  int ret;

  DEBUGASSERT(pstate);

  /* Execute the start-up script */

#ifdef CONFIG_NSH_ROMFSETC
  (void)nsh_initscript(&pstate->cn_vtbl);
#endif

  /* Initialize any USB tracing options that were requested */

#ifdef CONFIG_NSH_USBDEV_TRACE
  usbtrace_enable(TRACE_BITSET);
#endif

  /* Execute the session */

  ret = nsh_session(pstate);

  /* Exit upon return */

  nsh_exit(&pstate->cn_vtbl, ret);
  return ret;
}


基本上，可以以其调用的子函数将该函数划分成几个过程：nsh_newconsole、nsh_initscript和 nsh_session。
 PX4 FMU启动流程 2. 一、 nsh_newconsole

    这是一个 new函数。用来创建 stdio接口。

FAR struct console_stdio_s *nsh_newconsole(void)
{
  struct console_stdio_s *pstate = (struct console_stdio_s *)zalloc(sizeof(struct console_stdio_s));
  if (pstate)
    {
      /* Initialize the call table */

#ifndef CONFIG_NSH_DISABLEBG
      pstate->cn_vtbl.clone      = nsh_consoleclone;
      pstate->cn_vtbl.release    = nsh_consolerelease;
#endif
      pstate->cn_vtbl.write      = nsh_consolewrite;
      pstate->cn_vtbl.output     = nsh_consoleoutput;
      pstate->cn_vtbl.linebuffer = nsh_consolelinebuffer;
      pstate->cn_vtbl.redirect   = nsh_consoleredirect;
      pstate->cn_vtbl.undirect   = nsh_consoleundirect;
      pstate->cn_vtbl.exit       = nsh_consoleexit;

      /* (Re-) open the console input device */

#ifdef CONFIG_NSH_CONDEV
      pstate->cn_confd           = open(CONFIG_NSH_CONDEV, O_RDWR);
      if (pstate->cn_confd < 0)
        {
          free(pstate);
          return NULL;
        }

      /* Create a standard C stream on the console device */

      pstate->cn_constream = fdopen(pstate->cn_confd, "r+");
      if (!pstate->cn_constream)
        {
          close(pstate->cn_confd);
          free(pstate);
          return NULL;
        }
#endif

      /* Initialize the output stream */

      pstate->cn_outfd           = OUTFD(pstate);
      pstate->cn_outstream       = OUTSTREAM(pstate);
    }
  return pstate;
}


其实也就是填充了结构 “struct console_stdio_s”。这些接口基本上都可以通过函数名大致了解其作用。除了函数指针外还有两个比较特殊的指针：输出流。
 PX4 FMU启动流程 2. 二、 nsh_initscript

/****************************************************************************
 * Name: nsh_initscript
 *
 * Description:
 *   Attempt to execute the configured initialization script.  This script
 *   should be executed once when NSH starts.  nsh_initscript is idempotent
 *   and may, however, be called multiple times (the script will be executed
 *   once.
 *
 ****************************************************************************/

int nsh_initscript(FAR struct nsh_vtbl_s *vtbl)
{
  static bool initialized;
  bool already;
  int ret = OK;

  /* Atomic test and set of the initialized flag */

  sched_lock();
  already     = initialized;
  initialized = true;
  sched_unlock();

  /* If we have not already executed the init script, then do so now */

  if (!already)
    {
      ret = nsh_script(vtbl, "init", NSH_INITPATH); // /etc/init.d/rcS
    }

  return ret;
}
#ifndef CONFIG_NSH_ROMFSMOUNTPT
#define CONFIG_NSH_ROMFSMOUNTPT "/etc"
#endif
#ifndef CONFIG_NSH_INITSCRIPT
#define CONFIG_NSH_INITSCRIPT "init.d/rcS"
#endif
#undef NSH_INITPATH
#define NSH_INITPATH CONFIG_NSH_ROMFSMOUNTPT "/" CONFIG_NSH_INITSCRIPT


我们很容易得出完整的路径是： “/etc/init.d/rcS”，这是一个脚本，在系统启动的时候需要调用的一个脚本，并且由 nsh进行解析。我们到不妨稍微看看这些脚本。
    但其实我们根本就不用到： “ROMFS_ROOT”目录下去查看这些脚本，去 Bulid目录下即可查看，我们可以找到一个 “romfs_scratch”目录。

set MODE autostart
set USB autoconnect
if rgbled start
then
        set HAVE_RGBLED 1
        rgbled rgb 16 16 16
else
        set HAVE_RGBLED 0
fi
echo "[init] looking for microSD..."
if mount -t vfat /dev/mmcsd0 /fs/microsd
then
 echo "[init] card mounted at /fs/microsd"
        set HAVE_MICROSD 1
 tone_alarm start
else
 echo "[init] no microSD card found"
        set HAVE_MICROSD 0
 tone_alarm 2
        if [ $HAVE_RGBLED == 1 ]
        then
                rgbled rgb 16 0 0
        fi
fi
if [ -f /fs/microsd/etc/rc ]
then
 echo "[init] reading /fs/microsd/etc/rc"
 sh /fs/microsd/etc/rc
fi
if [ -f /fs/microsd/etc/rc.txt ]
then
 echo "[init] reading /fs/microsd/etc/rc.txt"
 sh /fs/microsd/etc/rc.txt
fi
if [ $USB != autoconnect ]
then
 echo "[init] not connecting USB"
else
 if sercon
 then
  echo "[init] USB interface connected"
 else
  echo "[init] No USB connected"
 fi
fi
if [ -f /etc/init.d/rc.APM -a $HAVE_MICROSD == 1 -a ! -f /fs/microsd/APM/nostart ]
then
 echo Running rc.APM
 sh /etc/init.d/rc.APM
else
        nshterm /dev/ttyACM0 &
fi


这其中有些是 nsh内嵌的命令，有些是 “g_builtins”数组中定义的命令。
    从脚本中我们看到，先是设置 LED，接这挂载 SD卡。 SD卡挂载上来之后就执行 SD卡中的脚本。最后再通过 “/etc/init.d/rc.APM”脚本去初始化飞控。

int nsh_script(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
               FAR const char *path)
{
  char *fullpath;
  FILE *stream;
  char *buffer;
  char *pret;
  int ret = ERROR;

  /* The path to the script may be relative to the current working directory */

  fullpath = nsh_getfullpath(vtbl, path);// /etc/init.d/rcS
  if (!fullpath)
    {
      return ERROR;
    }

  /* Get a reference to the common input buffer */

  buffer = nsh_linebuffer(vtbl);
  if (buffer)
    {
      /* Open the file containing the script */

      stream = fopen(fullpath, "r");
      if (!stream)
        {
          nsh_output(vtbl, g_fmtcmdfailed, cmd, "fopen", NSH_ERRNO);
          nsh_freefullpath(fullpath);
          return ERROR;
        }

      /* Loop, processing each command line in the script file (or
       * until an error occurs)
       */

      do
        {
          /* Get the next line of input from the file */

          fflush(stdout);
          pret = fgets(buffer, CONFIG_NSH_LINELEN, stream);
          if (pret)
            {
              /* Parse process the command.  NOTE:  this is recursive...
               * we got to cmd_sh via a call to nsh_parse.  So some
               * considerable amount of stack may be used.
               */

              ret = nsh_parse(vtbl, buffer);
            }
        }
      while (pret && ret == OK);
      fclose(stream);
    }

  nsh_freefullpath(fullpath);
  return ret;
}




这其中调用了一个核心的函数是 “nsh_parse”，该函数用于解析 nsh脚本，而且是按行进行解析的。而前面只是获取脚本的完整路径跟 buffer，然后用文件操作函数打开脚本，再接着就是按行读入并解析。
    nsh_parse函数比较长，五六百行代码。我们也就不可能把这些代码放到这里来看。我们在这里看流程关心的主要是该函数通过哪个函数把流程继续走下去的，这个函数就是：nsh_builtin。

  /* Does this command correspond to a builtin command?
   * nsh_builtin() returns:
   *
   *   -1 (ERROR)  if the application task corresponding to 'argv[0]' could not
   *               be started (possibly because it doesn not exist).
   *    0 (OK)     if the application task corresponding to 'argv[0]' was
   *               and successfully started.  If CONFIG_SCHED_WAITPID is
   *               defined, this return value also indicates that the
   *               application returned successful status (EXIT_SUCCESS)
   *    1          If CONFIG_SCHED_WAITPID is defined, then this return value
   *               indicates that the application task was spawned successfully
   *               but returned failure exit status.
   *
   * Note the priority if not effected by nice-ness.
   */

#if defined(CONFIG_NSH_BUILTIN_APPS) && (!defined(CONFIG_NSH_FILE_APPS) || !defined(CONFIG_FS_BINFS))
  ret = nsh_builtin(vtbl, argv[0], argv, redirfile, oflags);
  if (ret >= 0)
    {
      /* nsh_builtin() returned 0 or 1.  This means that the builtin
       * command was successfully started (although it may not have ran
       * successfully).  So certainly it is not an NSH command.
       */

      /* Free the redirected output file path */

      if (redirfile)
        {
          nsh_freefullpath(redirfile);
        }

      /* Save the result:  success if 0; failure if 1 */

#ifndef CONFIG_DISABLE_ENVIRON
      if (cmdline_exp != NULL)
          free(cmdline_exp);
#endif

      return nsh_saveresult(vtbl, ret != OK);
    }

  /* No, not a built in command (or, at least, we were unable to start a
   * builtin command of that name).  Treat it like an NSH command.
   */

#endif


从注释中我们知道返回值为 0的时候表示应用成功启动。当然注释并不能够告诉我们太多的细节。
    熟悉 main函数定义形式的都知道 argv数组中 argv[0]所表示的意义。 argv数组是按下面的方式构造的：

  /* Parse out the command at the beginning of the line */

  saveptr = cmdline;
  cmd = nsh_argument(vtbl, &saveptr);

  /* Handler if-then-else-fi */

#ifndef CONFIG_NSH_DISABLESCRIPT
  if (nsh_ifthenelse(vtbl, &cmd, &saveptr) != 0)
    {
      goto errout;
    }
#endif

  /* Handle nice */

#ifndef CONFIG_NSH_DISABLEBG
  if (nsh_nice(vtbl, &cmd, &saveptr) != 0)
    {
      goto errout;
    }
#endif

  /* Check if any command was provided -OR- if command processing is
   * currently disabled.
   */

#ifndef CONFIG_NSH_DISABLESCRIPT
  if (!cmd || !nsh_cmdenabled(vtbl))
#else
  if (!cmd)
#endif
    {
      /* An empty line is not an error and an unprocessed command cannot
       * generate an error, but neither should they change the last
       * command status.
       */

#ifndef CONFIG_DISABLE_ENVIRON
      if (cmdline_exp != NULL)
          free(cmdline_exp);
#endif

      return OK;
    }

  /* Parse all of the arguments following the command name.  The form
   * of argv is:
   *
   *   argv[0]:      The command name.
   *   argv[1]:      The beginning of argument (up to CONFIG_NSH_MAXARGUMENTS)
   *   argv[argc-3]: Possibly '>' or '>>'
   *   argv[argc-2]: Possibly
   *   argv[argc-1]: Possibly '&'
   *   argv[argc]:   NULL terminating pointer
   *
   * Maximum size is CONFIG_NSH_MAXARGUMENTS+5
   */

  argv[0] = cmd;
  for (argc = 1; argc < MAX_ARGV_ENTRIES-1; argc++)
    {
      argv[argc] = nsh_argument(vtbl, &saveptr);
      if (!argv[argc])
        {
          break;
        }
    }

  argv[argc] = NULL;

  /* Check if the command should run in background */

#ifndef CONFIG_NSH_DISABLEBG
  if (argc > 1 && strcmp(argv[argc-1], "&") == 0)
    {
      vtbl->np.np_bg = true;
      argv[argc-1] = NULL;
      argc--;
    }
#endif


这段代码跟注释都已经写得足够清楚了。
    举个例子，加入命令行为：“mount -t vfat /dev/mmcsd0 /fs/microsd”，那么经过解析之后在 argv数组将是：
   *   argv[0]: mount
   *   argv[1]: -t
   *   argv[2]: vfat
   *   argv[3]: /dev/mmcsd0
   *   argv[4]: /fs/microsd
   *   argv[5]: NULL terminating pointer

"&"表示把进程放到后台运行。其实熟悉 Linux的人一看到这个命令行就知道它会被解析成什么样。因为我们在 Linux应用编程中解析命令行参数的时候必须要了解这个，当然 Linux并没有要求所有的应用程序都提供解析命令行参数的功能。关于命令行参数解析的作用和意义这里就没必要说了，因为我们现在看的是流程，而不是教你怎么去解析命令行参数。

/****************************************************************************
 * Name: nsh_builtin
 *
 * Description:
 *    Attempt to execute the application task whose name is 'cmd'
 *
 * Returned Value:
 *   <0          If exec_builtin() fails, then the negated errno value
 *               is returned.
 *   -1 (ERROR)  if the application task corresponding to 'cmd' could not
 *               be started (possibly because it doesn not exist).
 *    0 (OK)     if the application task corresponding to 'cmd' was
 *               and successfully started.  If CONFIG_SCHED_WAITPID is
 *               defined, this return value also indicates that the
 *               application returned successful status (EXIT_SUCCESS)
 *    1          If CONFIG_SCHED_WAITPID is defined, then this return value
 *               indicates that the application task was spawned successfully
 *               but returned failure exit status.
 *
 ****************************************************************************/

int nsh_builtin(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
                FAR char **argv, FAR const char *redirfile, int oflags)
{
  int ret = OK;

  /* Lock the scheduler in an attempt to prevent the application from
   * running until waitpid() has been called.
   */

  sched_lock();

  /* Try to find and execute the command within the list of builtin
   * applications.
   */

  ret = exec_builtin(cmd, (FAR char * const *)argv, redirfile, oflags);
  if (ret >= 0)
    {

    }

  sched_unlock();

  /* If exec_builtin() or waitpid() failed, then return -1 (ERROR) with the
   * errno value set appropriately.
   */

  if (ret < 0)
    {
      return ERROR;
    }

  return ret;
}


容易看出来我把出错处理部分给去掉了。对于该函数的注释，其实要不要都无所谓，对英文不太懂的人像我就只是看一眼而已，更多的还是看代码。在 Linux应用编程中我们如果要调用一个 shell命令就会用到一个 “exec”函数。这这里作用是一样的。

int exec_builtin(FAR const char *appname, FAR char * const *argv,
                 FAR const char *redirfile, int oflags)
{
  FAR const struct builtin_s *builtin;
  posix_spawnattr_t attr;
  posix_spawn_file_actions_t file_actions;
  struct sched_param param;
  pid_t pid;
  int index;
  int ret;

  /* Verify that an application with this name exists */

  index = builtin_isavail(appname);
  if (index < 0)
    {
      ret = ENOENT;
      goto errout_with_errno;
    }

  /* Get information about the builtin */

  builtin = builtin_for_index(index);
  if (builtin == NULL)
    { 
      ret = ENOENT;
      goto errout_with_errno;
    }

  /* Initialize attributes for task_spawn(). */

  ret = posix_spawnattr_init(&attr);
  if (ret != 0)
    {
      goto errout_with_errno;
    }

  ret = posix_spawn_file_actions_init(&file_actions);
  if (ret != 0)
    {
      goto errout_with_attrs;
    }

  /* Set the correct task size and priority */

  param.sched_priority = builtin->priority;
  ret = posix_spawnattr_setschedparam(&attr, ¶m);
  if (ret != 0)
    {
      goto errout_with_actions;
    }

  ret = task_spawnattr_setstacksize(&attr, builtin->stacksize);
  if (ret != 0)
    {
      goto errout_with_actions;
    }

   /* If robin robin scheduling is enabled, then set the scheduling policy
    * of the new task to SCHED_RR before it has a chance to run.
    */

#if CONFIG_RR_INTERVAL > 0
  ret = posix_spawnattr_setschedpolicy(&attr, SCHED_RR);
  if (ret != 0)
    {
      goto errout_with_actions;
    }

  ret = posix_spawnattr_setflags(&attr,
                                 POSIX_SPAWN_SETSCHEDPARAM |
                                 POSIX_SPAWN_SETSCHEDULER);
  if (ret != 0)
    {
      goto errout_with_actions;
    }
#else
  ret = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSCHEDPARAM);
  if (ret != 0)
    {
      goto errout_with_actions;
    }
#endif

  /* Is output being redirected? */

  if (redirfile)
    {
      /* Set up to close open redirfile and set to stdout (1) */

      ret = posix_spawn_file_actions_addopen(&file_actions, 1,
                                             redirfile, O_WRONLY, 0644);
      if (ret != 0)
        {
          sdbg("ERROR: posix_spawn_file_actions_addopen failed: %d\n", ret);
          goto errout_with_actions;
        }
    }

  /* Start the built-in */

  ret = task_spawn(&pid, builtin->name, builtin->main, &file_actions,
                   &attr, (argv) ? &argv[1] : (FAR char * const *)NULL,
                   (FAR char * const *)NULL);
  if (ret != 0)
    {
      sdbg("ERROR: task_spawn failed: %d\n", ret);
      goto errout_with_actions;
    }

  /* Free attibutes and file actions.  Ignoring return values in the case
   * of an error.
   */

  /* Return the task ID of the new task if the task was sucessfully
   * started.  Otherwise, ret will be ERROR (and the errno value will
   * be set appropriately).
   */

  (void)posix_spawn_file_actions_destroy(&file_actions);
  (void)posix_spawnattr_destroy(&attr);
  return pid;

errout_with_actions:
  (void)posix_spawn_file_actions_destroy(&file_actions);

errout_with_attrs:
  (void)posix_spawnattr_destroy(&attr);

errout_with_errno:
  set_errno(ret);
  return ERROR;
}




记住这里有个变量： “struct builtin_s *builtin”，它是到数组 “g_builtins”中去取值。取到值之后就设置进程的属性，最后通过 “task_spawn”函数启动一个新的进程。
    这样我们就看到了 Nuttx是如何启动我们的进程的。
    突然发觉我们好像还漏掉了什么东西。因为我们知道 nsh命令不仅有我们写的命令，还有 Nuttx内嵌的命令，确切地所应该是 nsh内嵌的命令吧。那么这些命令有是如何被调用的呢？我们又到底遗漏了什么呢？我们又是否有一些比较好的方法去找到这些信息呢？
    有一个稍微简单却繁杂的方法是：找到脚本中有系统提供的命令如 mount，然后我们可以匹配到这样一些信息：

../PX4NuttX/apps/nshlib/nsh_mntcmds.c:302:int cmd_mount(FAR struct nsh_vtbl_s *vtbl, int argc, char **argv)
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:313:  /* The mount command behaves differently if no parameters are provided */
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:318:      return mount_show(vtbl, argv[0]);
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:322:  /* Get the mount options.  NOTE: getopt() is not thread safe nor re-entrant.
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:419:  /* Perform the mount */
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:421:  ret = mount(fullsource, fulltarget, filesystem, 0, NULL);
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:424:      nsh_output(vtbl, g_fmtcmdfailed, argv[0], "mount", NSH_ERRNO);
../PX4NuttX/apps/nshlib/nsh_mntcmds.c:443: * Name: cmd_nfsmount


看到 “cmd_mount”函数就有一种看到希望的感觉。因为该函数的命名很特殊，以 “cmd_”开头。我们写程序在给符号命名的时候通常会遵循一个默认的规则(记住这个不是规定更不是标准)，就是望文生义。这说明该函数提供了 Nuttx系统的 “mount”命令。就这样，我找到了一个数组：

static const struct cmdmap_s g_cmdmap[] =
{
#if CONFIG_NFILE_DESCRIPTORS > 0
# ifndef CONFIG_NSH_DISABLE_CAT
  { "cat",      cmd_cat,      2, CONFIG_NSH_MAXARGUMENTS, " [ [ ...]]" },
# endif
#ifndef CONFIG_DISABLE_ENVIRON
# ifndef CONFIG_NSH_DISABLE_CD
  { "cd",       cmd_cd,       1, 2, "[|-|~|..]" },
# endif
#endif
# ifndef CONFIG_NSH_DISABLE_CP
  { "cp",       cmd_cp,       3, 3, " " },
# endif

#ifdef CONFIG_NET
# ifndef CONFIG_NSH_DISABLE_IFCONFIG
  { "ifconfig", cmd_ifconfig, 1, 11, "[nic_name [|dhcp]] [dr|gw|gateway ] [netmask ] [dns ] [hw ]" },
# endif
# ifndef CONFIG_NSH_DISABLE_IFUPDOWN
  { "ifdown",   cmd_ifdown,   2, 2,  "" },
  { "ifup",     cmd_ifup,     2, 2,  "" },
# endif
#endif

#if CONFIG_NFILE_DESCRIPTORS > 0
# ifndef CONFIG_NSH_DISABLE_LS
  { "ls",       cmd_ls,       1, 5, "[-lRs] " },
# endif
#endif

#if !defined(CONFIG_DISABLE_MOUNTPOINT) && CONFIG_NFILE_DESCRIPTORS > 0 && defined(CONFIG_FS_WRITABLE)
# ifndef CONFIG_NSH_DISABLE_MKDIR
  { "mkdir",    cmd_mkdir,    2, 2, "" },
# endif
#endif

#if !defined(CONFIG_DISABLE_MOUNTPOINT) && CONFIG_NFILE_DESCRIPTORS > 0 && defined(CONFIG_FS_READABLE)
# ifndef CONFIG_NSH_DISABLE_MOUNT
#  ifdef CONFIG_NUTTX_KERNEL
  { "mount",    cmd_mount,    5, 5, "-t [] " },
#    else
  { "mount",    cmd_mount,    1, 5, "[-t [] ]" },
#  endif
# endif
#endif

#if defined(CONFIG_NET) && defined(CONFIG_NET_ICMP) && defined(CONFIG_NET_ICMP_PING) && \
   !defined(CONFIG_DISABLE_CLOCK) && !defined(CONFIG_DISABLE_SIGNALS)
# ifndef CONFIG_NSH_DISABLE_PING
  { "ping",     cmd_ping,     2, 6, "[-c ] [-i ] " },
# endif
#endif

#if CONFIG_NFILE_DESCRIPTORS > 0 && !defined(CONFIG_DISABLE_ENVIRON)
# ifndef CONFIG_NSH_DISABLE_PWD
  { "pwd",      cmd_pwd,      1, 1, NULL },
# endif
#endif

  { NULL,       NULL,         1, 1, NULL }
};




这个数组明显是被我裁过的，我只留下了 Linux中比较具有代表性的几个命令。其类型如下：

struct cmdmap_s
{
  const char *cmd;        /* Name of the command */
  cmd_t       handler;    /* Function that handles the command */
  uint8_t     minargs;    /* Minimum number of arguments (including command) */
  uint8_t     maxargs;    /* Maximum number of arguments (including command) */
  const char *usage;      /* Usage instructions for 'help' command */
};




跟 “g_builtins”数组一样，命令匹配由一个专门的字符串完成。既然这个数组都找到了，那么现在的问题是这个数组在哪里使用了。

bitcraze@bitcraze-vm:~/apm/PX4Firmware$ grep -nr g_cmdmap ../PX4NuttX/apps/
../PX4NuttX/apps/examples/ftpc/ftpc_main.c:81:static const struct cmdmap_s g_cmdmap[] =
../PX4NuttX/apps/examples/ftpc/ftpc_main.c:120:  for (ptr = g_cmdmap; ptr->cmd; ptr++)
../PX4NuttX/apps/examples/ftpc/ftpc_main.c:249:   for (cmdmap = g_cmdmap; cmdmap->cmd; cmdmap++)
../PX4NuttX/apps/nshlib/nsh_parse.c:97:#define NUM_CMDS      ((sizeof(g_cmdmap)/sizeof(struct cmdmap_s)) - 1)
../PX4NuttX/apps/nshlib/nsh_parse.c:147:static const struct cmdmap_s g_cmdmap[] =
../PX4NuttX/apps/nshlib/nsh_parse.c:518:          nsh_output(vtbl, "%-12s", g_cmdmap[k].cmd);
../PX4NuttX/apps/nshlib/nsh_parse.c:581:  for (cmdmap = g_cmdmap; cmdmap->cmd; cmdmap++)
../PX4NuttX/apps/nshlib/nsh_parse.c:611:  for (cmdmap = g_cmdmap; cmdmap->cmd; cmdmap++)
../PX4NuttX/apps/nshlib/nsh_parse.c:777:  for (cmdmap = g_cmdmap; cmdmap->cmd; cmdmap++)
bitcraze@bitcraze-vm:~/apm/PX4Firmware$


这个时候我才发现自己刚才匹配 “mount”是多么幸运。因为加入我匹配的是 “ls”命令，我可能就会找到 “ftpc_main.c”里边去，毕竟在那么多的匹配结果里边人是很容易犯错的。
    经过帅选，最后确定了函数 “nsh_execute”。

static int nsh_execute(FAR struct nsh_vtbl_s *vtbl, int argc, char *argv[])
{
  const struct cmdmap_s *cmdmap;
  const char            *cmd;
  cmd_t                  handler = cmd_unrecognized;
  int                    ret;

  /* The form of argv is:
   *
   * argv[0]:      The command name.  This is argv[0] when the arguments
   *               are, finally, received by the command vtblr
   * argv[1]:      The beginning of argument (up to CONFIG_NSH_MAXARGUMENTS)
   * argv[argc]:   NULL terminating pointer
   */

  cmd = argv[0];

  /* See if the command is one that we understand */

  for (cmdmap = g_cmdmap; cmdmap->cmd; cmdmap++)
    {
      if (strcmp(cmdmap->cmd, cmd) == 0)
        {
          /* Check if a valid number of arguments was provided.  We
           * do this simple, imperfect checking here so that it does
           * not have to be performed in each command.
           */

          if (argc < cmdmap->minargs)
            {
              /* Fewer than the minimum number were provided */

              nsh_output(vtbl, g_fmtargrequired, cmd);
              return ERROR;
            }
          else if (argc > cmdmap->maxargs)
            {
              /* More than the maximum number were provided */

              nsh_output(vtbl, g_fmttoomanyargs, cmd);
              return ERROR;
            }
          else
            {
              /* A valid number of arguments were provided (this does
               * not mean they are right).
               */

              handler = cmdmap->handler;
              break;
            }
        }
    }

   ret = handler(vtbl, argc, argv);
   return ret;
}




所以我们看到，最后是通过 “cmdmap->handler”找到了命令对应的函数，并通过指针 “handler”进行调用。而函数 “nsh_execute”其实有两种方式进行调用：线程和函数调用。当然这都发生在 nsh解析函数 “nsh_parse”里边。

  /* Handle the case where the command is executed in background.
   * However is app is to be started as builtin new process will
   * be created anyway, so skip this step.
   */

#ifndef CONFIG_NSH_DISABLEBG
  if (vtbl->np.np_bg)
    {
      struct sched_param param;
      struct nsh_vtbl_s *bkgvtbl;
      struct cmdarg_s *args;
      pthread_attr_t attr;
      pthread_t thread;

      /* Get a cloned copy of the vtbl with reference count=1.
       * after the command has been processed, the nsh_release() call
       * at the end of nsh_child() will destroy the clone.
       */

      /* Set up the thread attributes */

      (void)pthread_attr_init(&attr);
      (void)pthread_attr_setschedpolicy(&attr, SCHED_NSH);
      (void)pthread_attr_setschedparam(&attr, ¶m);

      /* Execute the command as a separate thread at the appropriate priority */

      ret = pthread_create(&thread, &attr, nsh_child, (pthread_addr_t)args);
      if (ret != 0)
        {
          nsh_output(vtbl, g_fmtcmdfailed, cmd, "pthread_create", NSH_ERRNO_OF(ret));
          nsh_releaseargs(args);
          nsh_release(bkgvtbl);
          goto errout;
        }

      /* Detach from the pthread since we are not going to join with it.
       * Otherwise, we would have a memory leak.
       */

      (void)pthread_detach(thread);

      nsh_output(vtbl, "%s [%d:%d]\n", cmd, thread, param.sched_priority);
    }
  else
#endif
    {
      uint8_t save[SAVE_SIZE];

      ret = nsh_execute(vtbl, argc, argv);
    }
#ifndef CONFIG_NSH_DISABLEBG
static pthread_addr_t nsh_child(pthread_addr_t arg)
{
  struct cmdarg_s *carg = (struct cmdarg_s *)arg;
  int ret;

  dbg("BG %s\n", carg->argv[0]);

  /* Execute the specified command on the child thread */

  ret = nsh_execute(carg->vtbl, carg->argc, carg->argv);

  /* Released the cloned arguments */

  dbg("BG %s complete\n", carg->argv[0]);
  nsh_releaseargs(carg);
  return (void*)ret;
}
#endif


代码比较多，我自然又忍不住删去了一些，只留下了基本的骨架。
    所以，如果我们要把系统命令放在后台运行就定义宏 “CONFIG_NSH_DISABLEBG”，否则就是直接调用。而这些过程，都是发生在调用 “nsh_builtin”函数之后。
    回过头来一看才发现函数 “nsh_parse”都已经看了个七七八八了。
 PX4 FMU启动流程 2. 三、nsh_session 

   有了前面的铺垫，这时候我们看 “nsh_session”函数就简单很多了。


int nsh_session(FAR struct console_stdio_s *pstate)
{
  int ret;

  DEBUGASSERT(pstate);

  /* Present a greeting */

  fputs(g_nshgreeting, pstate->cn_outstream);
  fflush(pstate->cn_outstream);

  /* Execute the login script */

#ifdef CONFIG_NSH_ROMFSRC
  (void)nsh_loginscript(&pstate->cn_vtbl);
#endif

  /* Then enter the command line parsing loop */

  for (;;)
    {
      /* For the case of debugging the USB console... dump collected USB trace data */

#ifdef CONFIG_NSH_USBDEV_TRACE
      nsh_usbtrace();
#endif

      /* Display the prompt string */

      fputs(g_nshprompt, pstate->cn_outstream);
      fflush(pstate->cn_outstream);

      /* Get the next line of input. readline() returns EOF on end-of-file
       * or any read failure.
       */

      ret = readline(pstate->cn_line, CONFIG_NSH_LINELEN,
                     INSTREAM(pstate), OUTSTREAM(pstate));
      if (ret != EOF)
        {
          /* Parse process the command */

          (void)nsh_parse(&pstate->cn_vtbl, pstate->cn_line);
          fflush(pstate->cn_outstream);
        }

      /* Readline normally returns the number of characters read,
       * but will return EOF on end of file or if an error occurs.
       * EOF will cause the session to terminate.
       */

      else
        {
          fprintf(pstate->cn_outstream, g_fmtcmdfailed, "nsh_session", 
                  "readline", NSH_ERRNO_OF(-ret));
          return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
        }
    }

  /* We do not get here, but this is necessary to keep some compilers happy.
   * But others will complain that this code is not reachable.
   */

  return EXIT_SUCCESS;
}




跟 “nsh_script”函数还是挺相似的。不同在于这里的命令行不是来自脚本文件，而事实来自 outstream，是什么呢？我们可以在 “nsh_newconsole”函数中找到。其实就是与用户交互的命令行终端。我们用上位机连上飞控的时候可以在一个窗口中用命令与飞控交互，这部分工作就是由这里完成的。
    应该来说，从中断读数据是不会读到文件结束标志的，所以该循环不会跳出。

PX4 FMU启动流程 3. 启动脚本 

这里所说的脚本当然不是我们前面说到的编辑脚本，而是由 nsh进行解析的脚本，如 rcS。

set MODE autostart
set USB autoconnect
if rgbled start
then
        set HAVE_RGBLED 1
        rgbled rgb 16 16 16
else
        set HAVE_RGBLED 0
fi
echo "[init] looking for microSD..."
if mount -t vfat /dev/mmcsd0 /fs/microsd
then
 echo "[init] card mounted at /fs/microsd"
        set HAVE_MICROSD 1
 tone_alarm start
else
 echo "[init] no microSD card found"
        set HAVE_MICROSD 0
 tone_alarm 2
        if [ $HAVE_RGBLED == 1 ]
        then
                rgbled rgb 16 0 0
        fi
fi
if [ -f /fs/microsd/etc/rc ]
then
 echo "[init] reading /fs/microsd/etc/rc"
 sh /fs/microsd/etc/rc
fi
if [ -f /fs/microsd/etc/rc.txt ]
then
 echo "[init] reading /fs/microsd/etc/rc.txt"
 sh /fs/microsd/etc/rc.txt
fi
if [ $USB != autoconnect ]
then
 echo "[init] not connecting USB"
else
 if sercon
 then
  echo "[init] USB interface connected"
 else
  echo "[init] No USB connected"
 fi
fi
if [ -f /etc/init.d/rc.APM -a $HAVE_MICROSD == 1 -a ! -f /fs/microsd/APM/nostart ]
then
 echo Running rc.APM
 sh /etc/init.d/rc.APM
else
        nshterm /dev/ttyACM0 &
fi


其实我们完全把它当作一个 Linux脚本来阅读就可以了。
    MODE跟 USB应该是环境变量，在 Linux中也是用 set去给一个环境变量赋值的。然后去启动 “rgbled”，这是由 “Firmware”提供的。我们很容易猜到这是用来控制那个高亮的 LED灯的。然后才是挂载 SD卡，文件系统为 vfat，挂载目录为 /fs/microsd。 SD卡挂载上来之后就去执行 SD卡中的脚本 “/fs/microsd/etc/rc”，所以我们就知道 sh是用来执行 nsh脚本的一个命令。应该来说 “/fs/microsd/etc/rc.txt”也是一个脚本，要不然也不会使用 sh命令了。 sercon你需要去看下源码才知道这是用来初始化 USB串口的。而最后则是通过调用 /etc/init.d/rc.APM脚本来真正初始化飞控。
    脚本 /etc/init.d/rc.APM有近三百行，不过别误会，我可没这闲情逸致去数它到底多少行。
    所以现在我们需要将脚本进行拆分。那怎么拆呢？其实我也头疼，只能是凭感觉了。

set deviceA /dev/ttyACM0
if [ -f /fs/microsd/APM ]
then
   echo "APM file found - renaming"
   mv /fs/microsd/APM /fs/microsd/APM.old
fi
if [ -f /fs/microsd/APM/nostart ]
then
   echo "APM/nostart found - skipping APM startup"
   sh /etc/init.d/rc.error
fi
if [ -f /bin/reboot ]
then
 echo "binfs already mounted"
else
 echo "Mounting binfs"
        if mount -t binfs /dev/null /bin
        then
                echo "binfs mounted OK"
        else
                sh /etc/init.d/rc.error
        fi
fi
set sketch NONE
if rm /fs/microsd/APM/boot.log
then
   echo "removed old boot.log"
fi
set logfile /fs/microsd/APM/BOOT.LOG
if [ ! -f /bin/ArduPilot ]
then
   echo "/bin/ardupilot not found"
   sh /etc/init.d/rc.error
fi
if mkdir /fs/microsd/APM > /dev/null
then
     echo "Created APM directory"
fi


这部分是我划出来的第一部分。先设置串口，然后一堆跟 SD卡相关的命令。其实我们将一张空的 SD卡放进去也是可以正常工作的。可能这里最让人感兴趣的就是 “ArduPilot”了，因为 APM工程就叫 “ArduPilot”。在 g_builtins数组中也有这样一行信息：

{"ArduPilot", SCHED_PRIORITY_DEFAULT, 4096, ArduPilot_main},


也就是说 PX4将 APM原来的主程序设计成了 Nuttx中的一个命令。但其实我们在使用 Linux系统的时候，可执行文件其实就等同命令。这个命令跟其他命令还是有很大不同的，这个我们后面再讨论。

if [ -f /bin/lsm303d ]
then
     echo "Detected FMUv2 board"
     set BOARD FMUv2
else
     echo "Detected FMUv1 board"
     set BOARD FMUv1
fi
if [ $BOARD == FMUv1 ]
then
   set deviceC /dev/ttyS2
   if [ -f /fs/microsd/APM/AUXPWM.en ]
   then
      set deviceD /dev/null
   else
      set deviceD /dev/ttyS1
   fi
else
   set deviceC /dev/ttyS1
   set deviceD /dev/ttyS2
fi
if uorb start
then
    echo "uorb started OK"
else
    sh /etc/init.d/rc.error
fi


从这里我们可以看到 FMUv1跟 FMUv2的差别在于 lsm303d这颗传感器。通过这颗传感器我们可以用肉眼进行区分。当然它们所使用的串口不同这个可能就无法直接看到了。
    我看了下 uorb的源码，源码中有这样一条注释：“Start/load the driver”，我没太搞懂这里 “driver”是什么，只是它用到了一个变量：PX4IO *g_dev = nullptr;，由此也只能确定这是跟 IO板相关的，更具体的就不知道了。

if [ -f /fs/microsd/APM/mkblctrl ]
then
    echo "Setting up mkblctrl driver"
    echo "Setting up mkblctrl driver" >> $logfile
    mkblctrl -d /dev/pwm_output
fi
if [ -f /fs/microsd/APM/mkblctrl_+ ]
then
    echo "Setting up mkblctrl driver +"
    echo "Setting up mkblctrl driver +" >> $logfile
    mkblctrl -mkmode + -d /dev/pwm_output
fi
if [ -f /fs/microsd/APM/mkblctrl_x ]
then
    echo "Setting up mkblctrl driver x"
    echo "Setting up mkblctrl driver x" >> $logfile
    mkblctrl -mkmode x -d /dev/pwm_output
fi


这一段我想应该是比较好理解的，就算我们不去看这个命令，因为这里是在设置机型。

set HAVE_PX4IO false
if px4io start norc
then
    set HAVE_PX4IO true
else
    echo Loading /etc/px4io/px4io.bin
    tone_alarm MBABGP
    if px4io update /etc/px4io/px4io.bin
    then
 echo "upgraded PX4IO firmware OK"
        tone_alarm MSPAA
    else
 echo "Failed to upgrade PX4IO firmware"
        tone_alarm MNGGG
    fi
    sleep 1
    if px4io start norc
    then
        set HAVE_PX4IO true
 tone_alarm start
    fi
fi
if [ $HAVE_PX4IO == true ]
then
    echo "PX4IO board OK"
    if px4io checkcrc /etc/px4io/px4io.bin
    then
        echo "PX4IO CRC OK"
    else
        echo "PX4IO CRC failure"
        echo "PX4IO CRC failure" >> $logfile    
        tone_alarm MBABGP
        if px4io forceupdate 14662 /etc/px4io/px4io.bin
        then
               sleep 1
               if px4io start norc
               then
                  echo "PX4IO restart OK"
                  echo "PX4IO restart OK" >> $logfile    
                  tone_alarm MSPAA
               else
                  echo "PX4IO restart failed"
                  echo "PX4IO restart failed" >> $logfile    
                  tone_alarm MNGGG
                  sh /etc/init.d/rc.error
               fi
        else
               echo "PX4IO update failed"
               echo "PX4IO update failed" >> $logfile    
               tone_alarm MNGGG
        fi
    fi
else
    echo "No PX4IO board found"
    echo "No PX4IO board found" >> $logfile
    if [ $BOARD == FMUv2 ]
    then
       sh /etc/init.d/rc.error
    fi
fi


这里看似很长的一段脚本，其实质做了一件事情：更新 IO板的固件。这么长的脚本处理了两种情况：一、IO板没有固件；二，IO板有固件但不是最新的。更新固件是通过 px4io命令来完成的，如果我们想知道固件是如何更新的可以去阅读该命令的源码。固件更新其实我们在分析 IO板的启动的时候已经知道是通过 CRC校验判断是否需要更新的。

if [ $BOARD == FMUv1 -a $deviceD == /dev/ttyS1 ]
then
        echo "Setting FMU mode_serial"
        fmu mode_serial
else
        echo "Setting FMU mode_pwm"
        fmu mode_pwm
fi


我粗略看了下 fmu的源码，没看明白这一段是干嘛的。

echo "Starting APM sensors"
if ms5611 start
then
    echo "ms5611 started OK"
else
    sh /etc/init.d/rc.error
fi
if adc start
then
    echo "adc started OK"
else
    sh /etc/init.d/rc.error
fi
if [ $BOARD == FMUv1 ]
then
    echo "Starting FMUv1 sensors"
    if hmc5883 start
    then
        echo "hmc5883 started OK"
        if hmc5883 calibrate
        then
          echo "hmc5883 calibrate OK"
        else 
          echo "hmc5883 calibrate failed"
          echo "hmc5883 calibrate failed" >> $logfile
          tone_alarm MSBBB
        fi
    else
        echo "hmc5883 start failed"
        echo "hmc5883 start failed" >> $logfile
        sh /etc/init.d/rc.error
    fi
    if mpu6000 start
    then
       echo "mpu6000  started OK"
    else
       sh /etc/init.d/rc.error
    fi
    if l3gd20 start
    then
       echo "l3gd20 started OK"
    else
       echo "No l3gd20"
       echo "No l3gd20" >> $logfile
    fi
else
    echo "Starting FMUv2 sensors"
    if hmc5883 -C -X start
    then
        echo "Have external hmc5883"
    else
        echo "No external hmc5883"
    fi
    if hmc5883 -C -I -R 4 start
    then
        echo "Have internal hmc5883"
    else
        echo "No internal hmc5883"
    fi
    if mpu6000 -X -R 4 start
    then
       echo "Found MPU6000 external"
       set HAVE_FMUV3 true
    else
       echo "No MPU6000 external"
       set HAVE_FMUV3 false
    fi
    if [ $HAVE_FMUV3 == true ]
    then
        if mpu6000 -R 14 start
        then
               echo "Found MPU6000 internal"
        else
               echo "No MPU6000"
               echo "No MPU6000" >> $logfile
               sh /etc/init.d/rc.error
        fi
        if l3gd20 -X -R 4 start
        then
               echo "l3gd20 external started OK"
        else
               echo "No l3gd20"
               sh /etc/init.d/rc.error
        fi
        if lsm303d -X -R 6 start
        then
               echo "lsm303d external started OK"
        else
               echo "No lsm303d"
               sh /etc/init.d/rc.error
        fi
    else
        if mpu6000 start
        then
               echo "Found MPU6000"
        else
               echo "No MPU6000"
               echo "No MPU6000" >> $logfile
        fi
        if l3gd20 start
        then
               echo "l3gd20 started OK"
        else
               sh /etc/init.d/rc.error
        fi
        if lsm303d start
        then
               echo "lsm303d started OK"
        else
               sh /etc/init.d/rc.error
        fi
    fi
fi
if ets_airspeed start
then
    echo "Found ETS airspeed sensor"
fi
if meas_airspeed start
then
    echo "Found MEAS airspeed sensor"
fi
if ll40ls start
then
    echo "Found ll40ls sensor"
fi
if mb12xx start
then
    echo "Found mb12xx sensor"
fi


从 echo那一句很容易看出这里是在启动传感器。当然，我暂时是不会去研究这些传感器是干嘛用的，只以看流程为主。从这段脚本我们也可以看出 V1跟 V2的一些区别，即 V1是内置罗盘，并且上电校准。但是 V2可以使用外置罗盘，而且上电过程是不校准的。至于陀螺为什么会有内部和外部的区别这个我没想通，也没有找到相关资料，这或许就要到源码中去寻找答案了。而源码肯定是要去看的。

echo "Trying PX4IO board"
if mtd start /fs/mtd
then
    echo "started mtd driver OK"
else
    echo "failed to start mtd driver"
    echo "failed to start mtd driver" >> $logfile
    sh /etc/init.d/rc.error           
fi
if mtd readtest /fs/mtd
then
    echo "mtd readtest OK"
else
    echo "failed to read mtd"
    echo "failed to read mtd" >> $logfile
    sh /etc/init.d/rc.error           
fi
if [ $BOARD == FMUv2 ]
then
  if mtd rwtest /fs/mtd
  then
    echo "mtd rwtest OK"
  else
    echo "failed to test mtd"
    echo "failed to test mtd" >> $logfile
    sh /etc/init.d/rc.error           
  fi
fi
echo Starting ArduPilot $deviceA $deviceC $deviceD
if ArduPilot -d $deviceA -d2 $deviceC -d3 $deviceD start
then
    echo ArduPilot started OK
else
    sh /etc/init.d/rc.error
fi
echo "rc.APM finished"


这部分脚本是对 mtd的操作，根据对 Linux的了解，我觉得这里应该跟存储设备相关。虽然没有 mount操作，但我仍然觉得这里可能是挂载存储设备，具体的仍然要到源码中去找寻答案。
    最后还有一个人脚本： rc.error，在出错的时候我们经常看到这个脚本。

echo "Error in startup"
tone_alarm MNCC
if [ $HAVE_RGBLED == 1 ]
then
        rgbled rgb 16 0 0
fi
nshterm /dev/ttyACM0 &
sleep 1
nshterm /dev/ttyS0 &
sleep 1
exit


也就是出错处理。当出错的时候输出一些信息，并且终止初始化。

PX4 IO板启动流程

1. IO板启动

    在前面分析脚本的时候我们知道 IO板的源码会在 “config_px4io-v2_default.mk”中指定。

#
# Makefile for the px4iov2_default configuration
#
#
# Board support modules
#
MODULES  += drivers/stm32
MODULES  += drivers/boards/px4io-v2
MODULES  += modules/px4iofirmware

那我们就不妨到这些目录下去看看都有些什么文件。

bitcraze@bitcraze-vm:~/apm/PX4Firmware/src$ ls drivers/stm32/
adc  drv_hrt.c  drv_pwm_servo.c  drv_pwm_servo.h  module.mk  tone_alarm
bitcraze@bitcraze-vm:~/apm/PX4Firmware/src$ ls drivers/boards/px4io-v2/
board_config.h  module.mk  px4iov2_init.c  px4iov2_pwm_servo.c
bitcraze@bitcraze-vm:~/apm/PX4Firmware/src$ ls modules/px4iofirmware/
adc.c       dsm.c  mixer.cpp  protocol.h  px4io.h      safety.c  serial.c
controls.c  i2c.c  module.mk  px4io.c     registers.c  sbus.c
bitcraze@bitcraze-vm:~/apm/PX4Firmware/src$

所以源码不是很多，除非是所使用的 lib里边有大动作，否则很难想像这里边有很复杂的算法。只是从PCB上看， SBUS和主电机都由 IO板进行控制。
    在 “drivers/boards/px4io-v2”目录下， “module.mk”文件的内容为：

#
# Board-specific startup code for the PX4IOv2
#
SRCS  = px4iov2_init.c \
    px4iov2_pwm_servo.c

在该木兰下其实也就只有这两个源文件。而头文件 “board_config.h”我们如果去阅读其内容就会发现里面基本上是 IO板的硬件资源。而源文件 “px4iov2_init.c”从名称上看就是一段初始化代码，其中也确实只有一个函数：

__EXPORT void stm32_boardinitialize(void)
{
 /* configure GPIOs */
 /* LEDS - default to off */
 stm32_configgpio(GPIO_LED1);
 stm32_configgpio(GPIO_LED2);
 stm32_configgpio(GPIO_LED3);
 stm32_configgpio(GPIO_BTN_SAFETY);
 /* spektrum power enable is active high - enable it by default */
 stm32_configgpio(GPIO_SPEKTRUM_PWR_EN);
 stm32_configgpio(GPIO_SERVO_FAULT_DETECT);
 /* RSSI inputs */
 stm32_configgpio(GPIO_TIM_RSSI); /* xxx alternate function */
 stm32_configgpio(GPIO_ADC_RSSI);
 /* servo rail voltage */
 stm32_configgpio(GPIO_ADC_VSERVO);
 stm32_configgpio(GPIO_SBUS_INPUT); /* xxx alternate function */
 stm32_configgpio(GPIO_SBUS_OUTPUT);
 
 /* sbus output enable is active low - disable it by default */
 stm32_gpiowrite(GPIO_SBUS_OENABLE, true);
 stm32_configgpio(GPIO_SBUS_OENABLE);
 stm32_configgpio(GPIO_PPM); /* xxx alternate function */
 stm32_gpiowrite(GPIO_PWM1, false);
 stm32_configgpio(GPIO_PWM1);
 stm32_gpiowrite(GPIO_PWM2, false);
 stm32_configgpio(GPIO_PWM2);
 stm32_gpiowrite(GPIO_PWM3, false);
 stm32_configgpio(GPIO_PWM3);
 stm32_gpiowrite(GPIO_PWM4, false);
 stm32_configgpio(GPIO_PWM4);
 stm32_gpiowrite(GPIO_PWM5, false);
 stm32_configgpio(GPIO_PWM5);
 stm32_gpiowrite(GPIO_PWM6, false);
 stm32_configgpio(GPIO_PWM6);
 stm32_gpiowrite(GPIO_PWM7, false);
 stm32_configgpio(GPIO_PWM7);
 stm32_gpiowrite(GPIO_PWM8, false);
 stm32_configgpio(GPIO_PWM8);
}

确切地说，这其实是一个入口函数，如果进行匹配，我们会找到这样一段信息：

../../PX4NuttX/nuttx/arch/arm/src/stm32/stm32_start.c:254:  stm32_boardinitialize();

该源文件的内容如下：

/****************************************************************************
 * Name: _start
 *
 * Description:
 *   This is the reset entry point.
 *
 ****************************************************************************/
void __start(void)
{
  const uint32_t *src;
  uint32_t *dest;
#ifdef CONFIG_ARMV7M_STACKCHECK
  /* Set the stack limit before we attempt to call any functions */
  __asm__ volatile ("sub r10, sp, %0" : : "r" (CONFIG_IDLETHREAD_STACKSIZE - 64) : );
#endif
  /* Configure the uart so that we can get debug output as soon as possible */
  stm32_clockconfig();
  stm32_fpuconfig();
  stm32_lowsetup();
  stm32_gpioinit();
  showprogress('A');
  /* Clear .bss.  We'll do this inline (vs. calling memset) just to be
   * certain that there are no issues with the state of global variables.
   */
  for (dest = &_sbss; dest < &_ebss; )
    {
      *dest++ = 0;
    }
  showprogress('B');
  /* Move the intialized data section from his temporary holding spot in
   * FLASH into the correct place in SRAM.  The correct place in SRAM is
   * give by _sdata and _edata.  The temporary location is in FLASH at the
   * end of all of the other read-only data (.text, .rodata) at _eronly.
   */
  for (src = &_eronly, dest = &_sdata; dest < &_edata; )
    {
      *dest++ = *src++;
    }
  showprogress('C');
  /* Perform early serial initialization */
#ifdef USE_EARLYSERIALINIT
  up_earlyserialinit();
#endif
  showprogress('D');
  /* For the case of the separate user-/kernel-space build, perform whatever
   * platform specific initialization of the user memory is required.
   * Normally this just means initializing the user space .data and .bss
   * segments.
   */
#ifdef CONFIG_NUTTX_KERNEL
  stm32_userspace();
  showprogress('E');
#endif
  /* Initialize onboard resources */
  stm32_boardinitialize();
  showprogress('F');
  /* Then start NuttX */
  showprogress('\r');
  showprogress('\n');
  os_start();
  /* Shoulnd't get here */
  for(;;);
}

__start函数是 Nuttx系统的入口函数。
    可能有些人就会有疑问了，C语言的入口函数不应该是 main函数的吗？确实，我们都说 C语言的入口是 main函数，而且我们也都是这么做的。但是请记住， main函数本质上也是一个函数，没有区别，只是在我们不手动指定的情况下编译器默认入口函数为 main函数，但其实入口是可以手动进行指定的。这里用的是链接脚本。编译过的源码在 “PX4Firmware/Build”目录下会有一个 “px4io-v2_default.build”目录。你可以在 “PX4Firmware/Build/px4io-v2_default.build/nuttx-export/build”目录下找到 “ld.script”文件，内容如下：

/* The STM32F100C8 has 64Kb of FLASH beginning at address 0x0800:0000 and
 * 8Kb of SRAM beginning at address 0x2000:0000.  When booting from FLASH,
 * FLASH memory is aliased to address 0x0000:0000 where the code expects to
 * begin execution by jumping to the entry point in the 0x0800:0000 address
 * range.
 */
MEMORY
{
    flash (rx) : ORIGIN = 0x08001000, LENGTH = 60K
    sram (rwx) : ORIGIN = 0x20000000, LENGTH = 8K
}
OUTPUT_ARCH(arm)
ENTRY(__start)  /* treat __start as the anchor for dead code stripping */
EXTERN(_vectors) /* force the vectors to be included in the output */
/* 
 * Ensure that abort() is present in the final object.  The exception handling
 * code pulled in by libgcc.a requires it (and that code cannot be easily avoided).
 */
EXTERN(abort)
SECTIONS
{
 .text : {
  _stext = ABSOLUTE(.);
  *(.vectors)
  *(.text .text.*)        
  *(.fixup)
  *(.gnu.warning)
  *(.rodata .rodata.*)        
  *(.gnu.linkonce.t.*)
  *(.glue_7)
  *(.glue_7t)
  *(.got)
  *(.gcc_except_table)
  *(.gnu.linkonce.r.*)
  _etext = ABSOLUTE(.);
 } > flash
 /*
  * Init functions (static constructors and the like)
  */
        .init_section : {
                _sinit = ABSOLUTE(.);
                KEEP(*(.init_array .init_array.*))
                _einit = ABSOLUTE(.);
        } > flash
 .ARM.extab : {
  *(.ARM.extab*)
 } > flash
 __exidx_start = ABSOLUTE(.);
 .ARM.exidx : {
  *(.ARM.exidx*)
 } > flash
 __exidx_end = ABSOLUTE(.);
 _eronly = ABSOLUTE(.);
 /* The STM32F100CB has 8Kb of SRAM beginning at the following address */
 .data : {
  _sdata = ABSOLUTE(.);
  *(.data .data.*)
  *(.gnu.linkonce.d.*)
  CONSTRUCTORS
  _edata = ABSOLUTE(.);
 } > sram AT > flash
 .bss : {
  _sbss = ABSOLUTE(.);
  *(.bss .bss.*)
  *(.gnu.linkonce.b.*)
  *(COMMON)
  _ebss = ABSOLUTE(.);
 } > sram
 /* Stabs debugging sections. */
 .stab 0 : { *(.stab) }
 .stabstr 0 : { *(.stabstr) }
 .stab.excl 0 : { *(.stab.excl) }
 .stab.exclstr 0 : { *(.stab.exclstr) }
 .stab.index 0 : { *(.stab.index) }
 .stab.indexstr 0 : { *(.stab.indexstr) }
 .comment 0 : { *(.comment) }
 .debug_abbrev 0 : { *(.debug_abbrev) }
 .debug_info 0 : { *(.debug_info) }
 .debug_line 0 : { *(.debug_line) }
 .debug_pubnames 0 : { *(.debug_pubnames) }
 .debug_aranges 0 : { *(.debug_aranges) }
}

我们知道 STM32的 Flash起始地址是 0x08000000，而且大小从来都没有听说做有 60K的。实际上这里用的是 64K芯片， 0x1000也正是 4K。稍微了解下 PX4都知道， PX4的两个芯片都是有 bootloader的，也就是说这 4K用来存放 bootloader。
    同时我们也看到，链接脚本中有：“ENTRY(__start)”这样一段内容，也就是这个地方指定了程序的入口。
    我们可以找到这样一个文件 “PX4NuttX/nuttx/arch/arm/src/stm32/stm32_vectors.S”，一看就知道里边定义了中断向量表。在链接脚本中我们看到，在程序开始的地方放的是中断向量表，那么这个中断向量表又有哪些内容呢？

#define IDLE_STACK  (_ebss+CONFIG_IDLETHREAD_STACKSIZE-4)
#define HEAP_BASE  (_ebss+CONFIG_IDLETHREAD_STACKSIZE)
/************************************************************************************
 * Global Symbols
 ************************************************************************************/
 .syntax  unified
 .thumb
 .file  "stm32_vectors.S"
/* Check if common ARMv7 interrupt vectoring is used (see arch/arm/src/armv7-m/up_vectors.S) */
#ifndef CONFIG_ARMV7M_CMNVECTOR
 .globl  __start
/************************************************************************************
 * Macros
 ************************************************************************************/
/* On entry into an IRQ, the hardware automatically saves the xPSR, PC, LR, R12, R0-R3
 * registers on the stack, then branches to an instantantiation of the following
 * macro.  This macro simply loads the IRQ number into R0, then jumps to the common
 * IRQ handling logic.
 */
 .macro HANDLER, label, irqno
 .thumb_func
\label:
 mov  r0, #\irqno
 b  stm32_common
 .endm
/************************************************************************************
 * Vectors
 ************************************************************************************/
 .section .vectors, "ax"
 .code  16
 .align  2
 .globl  stm32_vectors
 .type  stm32_vectors, function
stm32_vectors:
/* Processor Exceptions */
 .word IDLE_STACK   /* Vector  0: Reset stack pointer */
 .word __start    /* Vector  1: Reset vector */
 .word stm32_nmi   /* Vector  2: Non-Maskable Interrupt (NMI) */
 .word stm32_hardfault  /* Vector  3: Hard fault */
 .word stm32_mpu   /* Vector  4: Memory management (MPU) */
 .word stm32_busfault  /* Vector  5: Bus fault */
 .word stm32_usagefault /* Vector  6: Usage fault */
 .word stm32_reserved  /* Vector  7: Reserved */
 .word stm32_reserved  /* Vector  8: Reserved */
 .word stm32_reserved  /* Vector  9: Reserved */
 .word stm32_reserved  /* Vector 10: Reserved */
 .word stm32_svcall  /* Vector 11: SVC call */
 .word stm32_dbgmonitor /* Vector 12: Debug monitor */
 .word stm32_reserved  /* Vector 13: Reserved */
 .word stm32_pendsv  /* Vector 14: Pendable system service request */
 .word stm32_systick  /* Vector 15: System tick */
/* External Interrupts */

阅读过 keil中 STM32启动代码的应该大体上都能看懂这段代码。在 keil中最后是调用了一个 “__main”的符号进入 main函数的，其实就是 C语言函数汇编之后的符号。这里其实都一样，只是入口函数不再是 main函数而已。
    这里定义了堆栈大小还有 “.vectors”段，即中断向量表。 bootloader引导的时候会进入该中断向量表的复位向量即 “__start”。之后就是初始化，知道调用我们的 stm32_boardinitialize函数并启动系统。而在我们的初始化中基本上都是对 IO进行配置。
    那么现在的疑问是，当系统启动之后是如何调用我们的其他函数的？进程调用吗？这是操作系统的通用做法。而且这样做通常需要把我们自己的程序设计成操作系统中的一个进程。
    如果我们去阅读 IO板的相关源码，我们会在 px4io.c文件中看到这样一个函数：

int user_start(int argc, char *argv[])
{
    /* run C++ ctors before we go any further */
    up_cxxinitialize();

    /* reset all to zero */
    memset(&system_state, 0, sizeof(system_state));

    /* configure the high-resolution time/callout interface */
    hrt_init();

    /* calculate our fw CRC so FMU can decide if we need to update */
    calculate_fw_crc();

    /*
     * Poll at 1ms intervals for received bytes that have not triggered
     * a DMA event.
     */
#ifdef CONFIG_ARCH_DMA
    hrt_call_every(&serial_dma_call, 1000, 1000, (hrt_callout)stm32_serial_dma_poll, NULL);
#endif

    /* print some startup info */
    lowsyslog("\nPX4IO: starting\n");

    /* default all the LEDs to off while we start */
    LED_AMBER(false);
    LED_BLUE(false);
    LED_SAFETY(false);

    /* turn on servo power (if supported) */
#ifdef POWER_SERVO
    POWER_SERVO(true);
#endif

    /* turn off S.Bus out (if supported) */
#ifdef ENABLE_SBUS_OUT
    ENABLE_SBUS_OUT(false);
#endif

    /* start the safety switch handler */
    safety_init();

    /* configure the first 8 PWM outputs (i.e. all of them) */
    up_pwm_servo_init(0xff);

    /* initialise the control inputs */
    controls_init();

    /* set up the ADC */
    adc_init();

    /* start the FMU interface */
    interface_init();

    /* add a performance counter for mixing */
    perf_counter_t mixer_perf = perf_alloc(PC_ELAPSED, "mix");

    /* add a performance counter for controls */
    perf_counter_t controls_perf = perf_alloc(PC_ELAPSED, "controls");

    /* and one for measuring the loop rate */
    perf_counter_t loop_perf = perf_alloc(PC_INTERVAL, "loop");

    struct mallinfo minfo = mallinfo();
    lowsyslog("MEM: free %u, largest %u\n", minfo.mxordblk, minfo.fordblks);

    /* initialize PWM limit lib */
    pwm_limit_init(&pwm_limit);

    /*
     *    P O L I C E    L I G H T S
     *
     * Not enough memory, lock down.
     *
     * We might need to allocate mixers later, and this will
     * ensure that a developer doing a change will notice
     * that he just burned the remaining RAM with static
     * allocations. We don't want him to be able to
     * get past that point. This needs to be clearly
     * documented in the dev guide.
         *
     */
    if (minfo.mxordblk < 600) {

        lowsyslog("ERR: not enough MEM");
        bool phase = false;

        while (true) {

            if (phase) {
                LED_AMBER(true);
                LED_BLUE(false);
            } else {
                LED_AMBER(false);
                LED_BLUE(true);
            }
            up_udelay(250000);

            phase = !phase;
        }
    }

    /* Start the failsafe led init */
    failsafe_led_init();

    /*
     * Run everything in a tight loop.
     */

    uint64_t last_debug_time = 0;
        uint64_t last_heartbeat_time = 0;
    for (;;) {

        /* track the rate at which the loop is running */
        perf_count(loop_perf);

        /* kick the mixer */
        perf_begin(mixer_perf);
        mixer_tick();
        perf_end(mixer_perf);

        /* kick the control inputs */
        perf_begin(controls_perf);
        controls_tick();
        perf_end(controls_perf);

                if ((hrt_absolute_time() - last_heartbeat_time) > 250*1000) {
                    last_heartbeat_time = hrt_absolute_time();
                    heartbeat_blink();
                }

                check_reboot();

        /* check for debug activity (default: none) */
        show_debug_messages();

        /* post debug state at ~1Hz - this is via an auxiliary serial port
         * DEFAULTS TO OFF!
         */
        if (hrt_absolute_time() - last_debug_time > (1000 * 1000)) {

            struct mallinfo minfo = mallinfo();

            isr_debug(1, "d:%u s=0x%x a=0x%x f=0x%x m=%u", 
                  (unsigned)r_page_setup[PX4IO_P_SETUP_SET_DEBUG],
                  (unsigned)r_status_flags,
                  (unsigned)r_setup_arming,
                  (unsigned)r_setup_features,
                  (unsigned)minfo.mxordblk);
            last_debug_time = hrt_absolute_time();
        }
    }
}

    user_start函数之所以能够吸引我主要基于下面三点：
一、函数的定义。 “int user_start(int argc, char *argv[])”是一个标准的 main函数形式。而 main函数通常作为程序的入口，这也就意味着这是一个入口函数。而且可以推测这是应用程序入口，因为至少目前在 Linux中不会这样去写一个驱动的入口， Nuttx是类 Linux系统，我自然确信不会这么做。那么既然是入口，那肯定有人去调用。
二、这里调用了一些初始化函数，也就是说 IO板在这里进行初始化。那我们就容易想到这实际上就相当于我们跑裸机时的 main函数。
三、主循环。我们跑裸机的时候一定会有一个主循环。不管这个循环是在 mian函数还是子函数中，但肯定会有。
这三点可以说确定了 user_start函数在 IO的地位。而且我们可以找到以下内容：

../PX4NuttX/nuttx/.config:320:CONFIG_USER_ENTRYPOINT="user_start"

“.config”是 Nuttx系统的配置文件，而 “CONFIG_USER_ENTRYPOINT”的命名已经明明白白地告诉我们这是一个入口，用户入口。最后我们可以匹配到下面的内容：

../PX4NuttX/nuttx/include/nuttx/init.h:71:EXTERN int    CONFIG_USER_ENTRYPOINT(int argc,char *argv[]);
../PX4NuttX/nuttx/include/nuttx/config.h:89:#define CONFIG_USER_ENTRYPOINT user_start
../PX4NuttX/nuttx/include/nuttx/config.h:389: * with existing code,for builds whichdo not define CONFIG_USER_ENTRYPOINT.
../PX4NuttX/nuttx/include/nuttx/config.h:392:#ifndef CONFIG_USER_ENTRYPOINT
../PX4NuttX/nuttx/include/nuttx/config.h:393:# define CONFIG_USER_ENTRYPOINT user_start
../PX4NuttX/nuttx/tools/cfgdefine.c:66:  "CONFIG_USER_ENTRYPOINT",            /* Name of entry point function */
../PX4NuttX/nuttx/tools/mkconfig.c:266:  printf(" * with existing code, for builds which do not define CONFIG_USER_ENTRYPOINT.\n");
../PX4NuttX/nuttx/tools/mkconfig.c:268:  printf("#ifndef CONFIG_USER_ENTRYPOINT\n");
../PX4NuttX/nuttx/tools/mkconfig.c:269:  printf("# define CONFIG_USER_ENTRYPOINT user_start\n");
../PX4NuttX/nuttx/sched/os_bringup.c:219:   * is given by the definitions, CONFIG_USER_ENTRYPOINT.  In the kernel
../PX4NuttX/nuttx/sched/os_bringup.c:232:                       (main_t)CONFIG_USER_ENTRYPOINT,

最后一条信息实际上就告诉了我们 “CONFIG_USER_ENTRYPOINT”是如何调用的。

/****************************************************************************
 * Name: os_bringup
 *
 * Description:
 *   Start all initial system tasks.  This does the "system bring-up" after
 *   the conclusion of basic OS initialization.  These initial system tasks
 *   may include:
 *
 *   - pg_worker:   The page-fault worker thread (only if CONFIG_PAGING is
 *                  defined.
 *   - work_thread: The work thread.  This general thread can be used to
 *                  perform most any kind of queued work.  Its primary
 *                  function is to serve as the "bottom half" of device
 *                  drivers.
 *
 *   And the main application entry point:
 *   symbols:
 *
 *   - USER_ENTRYPOINT: This is the default user application entry point.
 *                 
 ****************************************************************************/

int os_bringup(void)
{
  int taskid;

  /* Setup up the initial environment for the idle task.  At present, this
   * may consist of only the initial PATH variable.  The PATH variable is
   * (probably) not used by the IDLE task.  However, the environment
   * containing the PATH variable will be inherited by all of the threads
   * created by the IDLE task.
   */

#if !defined(CONFIG_DISABLE_ENVIRON) && defined(CONFIG_PATH_INITIAL)
  (void)setenv("PATH", CONFIG_PATH_INITIAL, 1);
#endif

  /* Start the page fill worker kernel thread that will resolve page faults.
   * This should always be the first thread started because it may have to
   * resolve page faults in other threads
   */

#ifdef CONFIG_PAGING
  svdbg("Starting paging thread\n");

  g_pgworker = KERNEL_THREAD("pgfill", CONFIG_PAGING_DEFPRIO,
                             CONFIG_PAGING_STACKSIZE,
                             (main_t)pg_worker, (FAR char * const *)NULL);
  DEBUGASSERT(g_pgworker > 0);
#endif

  /* Start the worker thread that will serve as the device driver "bottom-
   * half" and will perform misc garbage clean-up.
   */

#ifdef CONFIG_SCHED_WORKQUEUE
#ifdef CONFIG_SCHED_HPWORK

#ifdef CONFIG_SCHED_LPWORK
  svdbg("Starting high-priority kernel worker thread\n");
#else
  svdbg("Starting kernel worker thread\n");
#endif

  g_work[HPWORK].pid = KERNEL_THREAD(HPWORKNAME, CONFIG_SCHED_WORKPRIORITY,
                                     CONFIG_SCHED_WORKSTACKSIZE,
                                     (main_t)work_hpthread, (FAR char *const *)NULL);
  DEBUGASSERT(g_work[HPWORK].pid > 0);

  /* Start a lower priority worker thread for other, non-critical continuation
   * tasks
   */

#ifdef CONFIG_SCHED_LPWORK

  svdbg("Starting low-priority kernel worker thread\n");

  g_work[LPWORK].pid = KERNEL_THREAD(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY,
                                     CONFIG_SCHED_LPWORKSTACKSIZE,
                                     (main_t)work_lpthread, (FAR char *const *)NULL);
  DEBUGASSERT(g_work[LPWORK].pid > 0);

#endif /* CONFIG_SCHED_LPWORK */
#endif /* CONFIG_SCHED_HPWORK */

#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_SCHED_USRWORK)
  /* Start the user-space work queue */

  DEBUGASSERT(USERSPACE->work_usrstart != NULL);
  taskid = USERSPACE->work_usrstart();
  DEBUGASSERT(taskid > 0);
#endif

#endif /* CONFIG_SCHED_WORKQUEUE */

  /* Once the operating system has been initialized, the system must be
   * started by spawning the user init thread of execution.  This is the
   * first user-mode thead.
   */

  svdbg("Starting init thread\n");

  /* Perform any last-minute, board-specific initialization, if so
   * configured.
   */

#ifdef CONFIG_BOARD_INITIALIZE
  board_initialize();
#endif

  /* Start the default application.  In a flat build, this is entrypoint
   * is given by the definitions, CONFIG_USER_ENTRYPOINT.  In the kernel
   * build, however, we must get the address of the entrypoint from the
   * header at the beginning of the user-space blob.
   */

#ifdef CONFIG_NUTTX_KERNEL
  DEBUGASSERT(USERSPACE->us_entrypoint != NULL);
  taskid = TASK_CREATE("init", SCHED_PRIORITY_DEFAULT,
                       CONFIG_USERMAIN_STACKSIZE, USERSPACE->us_entrypoint,
                       (FAR char * const *)NULL);
#else
  taskid = TASK_CREATE("init", SCHED_PRIORITY_DEFAULT,
                       CONFIG_USERMAIN_STACKSIZE,
                       (main_t)CONFIG_USER_ENTRYPOINT,
                       (FAR char * const *)NULL);
#endif
  ASSERT(taskid > 0);

  /* We an save a few bytes by discarding the IDLE thread's environment. */

#if !defined(CONFIG_DISABLE_ENVIRON) && defined(CONFIG_PATH_INITIAL)
  (void)clearenv();
#endif

  return OK;
}

在这里我们看到我们的入口函数是作为操作系统的 init进程在运行的。熟悉 Linux系统的人想必都知道 init进程在 Linux系统中的特殊地位，这里我就不介绍了。
    在分析脚本的时候，我看到 IO板没有 g_builtins数组于是就认为 IO板是跑裸机的，其实这只是其中一个原因，还有一个原因是 IO板没有使用根文件系统。因为通常跑操作系统都离不开根文件系统，这应该是我的定势思维在作祟了，于是就认为 IO板如果运行 Nuttx系统也必须有一个根文件系统。而我在观察编译输出信息的时候也确实只有核心板才会去制作根文件系统，并且进行链接。后面我看到 IO板的编译使用了 Nuttx库，于是我不得不承认 IO板确实是跑操作系统的。直到此时我心中的疑团才算是解开了，因为我们的 init进程根本就没有使用根文件系统，也没有使用 g_builtins数组，既然不使用，那自然也就不需要。
    若是我们想知道 “os_bringup”函数是如何被使用的，这倒也简单。在 “__start”函数的最后调用了一个 “os_start”函数，其源码如下：

/****************************************************************************
 * Name: os_start
 *
 * Description:
 *   This function is called to initialize the operating system and to spawn
 *   the user initization thread of execution
 *
 ****************************************************************************/

void os_start(void)
{
  int i;

  slldbg("Entry\n");

  /* Initialize RTOS Data ***************************************************/
  /* Initialize all task lists */

  dq_init(&g_readytorun);
  dq_init(&g_pendingtasks);
  dq_init(&g_waitingforsemaphore);
#ifndef CONFIG_DISABLE_SIGNALS
  dq_init(&g_waitingforsignal);
#endif
#ifndef CONFIG_DISABLE_MQUEUE
  dq_init(&g_waitingformqnotfull);
  dq_init(&g_waitingformqnotempty);
#endif
#ifdef CONFIG_PAGING
  dq_init(&g_waitingforfill);
#endif
  dq_init(&g_inactivetasks);
  sq_init(&g_delayed_kufree);
#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
  sq_init(&g_delayed_kfree);
#endif

  /* Initialize the logic that determine unique process IDs. */

  g_lastpid = 0;
  for (i = 0; i < CONFIG_MAX_TASKS; i++)
    {
      g_pidhash[i].tcb = NULL;
      g_pidhash[i].pid = INVALID_PROCESS_ID;
    }

  /* Assign the process ID of ZERO to the idle task */

  g_pidhash[ PIDHASH(0)].tcb = &g_idletcb.cmn;
  g_pidhash[ PIDHASH(0)].pid = 0;

  /* Initialize the IDLE task TCB *******************************************/
  /* Initialize a TCB for this thread of execution.  NOTE:  The default
   * value for most components of the g_idletcb are zero.  The entire
   * structure is set to zero.  Then only the (potentially) non-zero
   * elements are initialized. NOTE:  The idle task is the only task in
   * that has pid == 0 and sched_priority == 0.
   */

  bzero((void*)&g_idletcb, sizeof(struct task_tcb_s));
  g_idletcb.cmn.task_state = TSTATE_TASK_RUNNING;
  g_idletcb.cmn.entry.main = (main_t)os_start;

  /* Set the IDLE task name */

#if CONFIG_TASK_NAME_SIZE > 0
  strncpy(g_idletcb.cmn.name, g_idlename, CONFIG_TASK_NAME_SIZE-1);
#endif /* CONFIG_TASK_NAME_SIZE */

  /* Configure the task name in the argument list.  The IDLE task does
   * not really have an argument list, but this name is still useful
   * for things like the NSH PS command.
   *
   * In the kernel mode build, the arguments are saved on the task's stack
   * and there is no support that yet.
   */

#if defined(CONFIG_CUSTOM_STACK) || !defined(CONFIG_NUTTX_KERNEL)
#if CONFIG_TASK_NAME_SIZE > 0
  g_idletcb.argv[0] = g_idletcb.cmn.name;
#else
  g_idletcb.argv[0] = (char*)g_idlename;
#endif /* CONFIG_TASK_NAME_SIZE */
#endif /* CONFIG_CUSTOM_STACK || !CONFIG_NUTTX_KERNEL */

  /* Then add the idle task's TCB to the head of the ready to run list */

  dq_addfirst((FAR dq_entry_t*)&g_idletcb, (FAR dq_queue_t*)&g_readytorun);

  /* Initialize the processor-specific portion of the TCB */

  up_initial_state(&g_idletcb.cmn);

  /* Initialize RTOS facilities *********************************************/
  /* Initialize the semaphore facility(if in link).  This has to be done
   * very early because many subsystems depend upon fully functional
   * semaphores.
   */

#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (sem_initialize != NULL)
#endif
    {
      sem_initialize();
    }

  /* Initialize the memory manager */

  {
    FAR void *heap_start;
    size_t heap_size;

    /* Get the user-mode heap from the platform specific code and configure
     * the user-mode memory allocator.
     */

    up_allocate_heap(&heap_start, &heap_size);
    kumm_initialize(heap_start, heap_size);

#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
    /* Get the kernel-mode heap from the platform specific code and configure
     * the kernel-mode memory allocator.
     */

    up_allocate_kheap(&heap_start, &heap_size);
    kmm_initialize(heap_start, heap_size);
#endif
  }

  /* Initialize tasking data structures */

#if defined(CONFIG_SCHED_HAVE_PARENT) && defined(CONFIG_SCHED_CHILD_STATUS)
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (task_initialize != NULL)
#endif
    {
      task_initialize();
    }
#endif

  /* Initialize the interrupt handling subsystem (if included) */

#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (irq_initialize != NULL)
#endif
    {
      irq_initialize();
    }

  /* Initialize the watchdog facility (if included in the link) */

#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (wd_initialize != NULL)
#endif
    {
      wd_initialize();
    }

  /* Initialize the POSIX timer facility (if included in the link) */

#ifndef CONFIG_DISABLE_CLOCK
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (clock_initialize != NULL)
#endif
    {
      clock_initialize();
    }
#endif

#ifndef CONFIG_DISABLE_POSIX_TIMERS
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (timer_initialize != NULL)
#endif
    {
      timer_initialize();
    }
#endif

  /* Initialize the signal facility (if in link) */

#ifndef CONFIG_DISABLE_SIGNALS
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (sig_initialize != NULL)
#endif
    {
      sig_initialize();
    }
#endif

  /* Initialize the named message queue facility (if in link) */

#ifndef CONFIG_DISABLE_MQUEUE
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (mq_initialize != NULL)
#endif
    {
      mq_initialize();
    }
#endif

  /* Initialize the thread-specific data facility (if in link) */

#ifndef CONFIG_DISABLE_PTHREAD
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (pthread_initialize != NULL)
#endif
    {
      pthread_initialize();
    }
#endif

  /* Initialize the file system (needed to support device drivers) */

#if CONFIG_NFILE_DESCRIPTORS > 0
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (fs_initialize != NULL)
#endif
    {
      fs_initialize();
    }
#endif

  /* Initialize the network system */

#ifdef CONFIG_NET
#if 0
  if (net_initialize != NULL)
#endif
    {
      net_initialize();
    }
#endif

  /* The processor specific details of running the operating system
   * will be handled here.  Such things as setting up interrupt
   * service routines and starting the clock are some of the things
   * that are different for each  processor and hardware platform.
   */

  up_initialize();

  /* Initialize the C libraries (if included in the link).  This
   * is done last because the libraries may depend on the above.
   */

#ifdef CONFIG_HAVE_WEAKFUNCTIONS
  if (lib_initialize != NULL)
#endif
    {
      lib_initialize();
    }

  /* IDLE Group Initialization **********************************************/
  /* Allocate the IDLE group and suppress child status. */

#ifdef HAVE_TASK_GROUP
  DEBUGVERIFY(group_allocate(&g_idletcb));
#endif

  /* Create stdout, stderr, stdin on the IDLE task.  These will be
   * inherited by all of the threads created by the IDLE task.
   */

  DEBUGVERIFY(group_setupidlefiles(&g_idletcb));

  /* Complete initialization of the IDLE group.  Suppress retention
   * of child status in the IDLE group.
   */

#ifdef HAVE_TASK_GROUP
  DEBUGVERIFY(group_initialize(&g_idletcb));
  g_idletcb.cmn.group->tg_flags = GROUP_FLAG_NOCLDWAIT;
#endif

  /* Bring Up the System ****************************************************/
  /* Create initial tasks and bring-up the system */

  DEBUGVERIFY(os_bringup());

  /* The IDLE Loop **********************************************************/
  /* When control is return to this point, the system is idle. */

  sdbg("Beginning Idle Loop\n");
  for (;;)
    {
      /* Perform garbage collection (if it is not being done by the worker
       * thread).  This cleans-up memory de-allocations that were queued
       * because they could not be freed in that execution context (for
       * example, if the memory was freed from an interrupt handler).
       */

#ifndef CONFIG_SCHED_WORKQUEUE
      /* We must have exclusive access to the memory manager to do this
       * BUT the idle task cannot wait on a semaphore.  So we only do
       * the cleanup now if we can get the semaphore -- this should be
       * possible because if the IDLE thread is running, no other task is!
       */

      if (kmm_trysemaphore() == 0)
        {
          sched_garbagecollection();
          kmm_givesemaphore();
        }
#endif

      /* Perform any processor-specific idle state operations */

      up_idle();
    }
}

我们其实只关心最后一段代码就可以了。在 for循环前面通过语句 “DEBUGVERIFY(os_bringup());”调用了 “os_bringup”函数。
    以上就是 IO板启动的大致流程。而我们写程序的时候其实只需简单认为 “user_start”就是我们的入口函数，即当作裸机运行时的 main函数即可。于是我们后面的代码都将以 “user_start”函数作为起点，如果我们忽略操作系统细节的话。
2. firmware
    现在从入口函数开始分析我们的 IO板。
    在入口函数中，调用的第一个函数是 “up_cxxinitialize”：

    /* run C++ ctors before we go any further */
    up_cxxinitialize();

注释说这里调用了 C++，

/************************************************************************************
 * Private Types
 ************************************************************************************/
/* This type defines one entry in initialization array */

typedef void (*initializer_t)(void);

/************************************************************************************
 * External references
 ************************************************************************************/
/* _sinit and _einit are symbols exported by the linker script that mark the
 * beginning and the end of the C++ initialization section.
 */

extern initializer_t _sinit;
extern initializer_t _einit;

/* _stext and _etext are symbols exported by the linker script that mark the
 * beginning and the end of text.
 */

extern uint32_t _stext;
extern uint32_t _etext;

/************************************************************************************
 * Private Functions
 ************************************************************************************/

/************************************************************************************
 * Public Functions
 ************************************************************************************/

/****************************************************************************
 * Name: up_cxxinitialize
 *
 * Description:
 *   If C++ and C++ static constructors are supported, then this function
 *   must be provided by board-specific logic in order to perform
 *   initialization of the static C++ class instances.
 *
 *   This function should then be called in the application-specific
 *   user_start logic in order to perform the C++ initialization.  NOTE
 *   that no component of the core NuttX RTOS logic is involved; This
 *   function defintion only provides the 'contract' between application
 *   specific C++ code and platform-specific toolchain support
 *
 ***************************************************************************/

__EXPORT void up_cxxinitialize(void)
{
  initializer_t *initp;

  cxxdbg("_sinit: %p _einit: %p _stext: %p _etext: %p\n",
         &_sinit, &_einit, &_stext, &_etext);

  /* Visit each entry in the initialzation table */

  for (initp = &_sinit; initp != &_einit; initp++)
    {
      initializer_t initializer = *initp;
      cxxdbg("initp: %p initializer: %p\n", initp, initializer);

      /* Make sure that the address is non-NULL and lies in the text region
       * defined by the linker script.  Some toolchains may put NULL values
       * or counts in the initialization table
       */

      if ((void*)initializer > (void*)&_stext && (void*)initializer < (void*)&_etext)
        {
          cxxdbg("Calling %p\n", initializer);
          initializer();
        }
    }
}

通过源码我们看到初始化是通过段进行调用的。通过段去调用一个函数这在 Linux中国可是家常便饭，像驱动跟板子初始化可都是这么调用的。
    最直接的方式自然是去分析这个段，看下到底哪些数据被放进这个段了。不过这可不简单，费时而且费力。
    但其实我们可以在这里耍点小聪明。
    首先我知道 “_sinit”是该段的起始地址， “_einit”是该段的结束地址。而这两个地址通常都是在链接脚本中定义的，即 ld.script文件。其中就有这样一段内容：

/*
  * Init functions (static constructors and the like)
  */
        .init_section : {
                _sinit = ABSOLUTE(.);
                KEEP(*(.init_array .init_array.*))
                _einit = ABSOLUTE(.);
        } > flash

代码注释说调用的是 C++，这里注释说该段放的是构造函数。所以我们不可能到 C源文件中国去寻找这些函数。而我们在 map文件中又可以找到下面的内容：

.init_section   0x0800979c        0x4
                0x0800979c                _sinit = ABSOLUTE (.)
 *(.init_array .init_array.*)
 .init_array    0x0800979c        0x4 /home/bitcraze/apm/PX4Firmware/Build/px4io-v2_default.build//home/bitcraze/apm/PX4Firmware/src/modules/px4iofirmware/module.pre.o
                0x080097a0                _einit = ABSOLUTE (.)

我们可以从这段内容了解以下信息：
一、段地址。起始地址跟结束地址。
二、段大小。已经给出为 0x4，也可以自己计算，这刚好够放一个函数的地址。
三、该段的内容来自那个目标文件。通过这个内容我们其实可以知道具体的目录 “PX4Firmware/src/modules/px4iofirmware”。
既然知道了目录，那么我们就可以到相应的目录下去查看 “module.mk”文件。

SRCS  = adc.c \
    controls.c \
    dsm.c \
    px4io.c \
    registers.c \
    safety.c \
    sbus.c \
    ../systemlib/up_cxxinitialize.c \
    ../systemlib/perf_counter.c \
    mixer.cpp \
    ../systemlib/mixer/mixer.cpp \
    ../systemlib/mixer/mixer_group.cpp \
    ../systemlib/mixer/mixer_multirotor.cpp \
    



你可能感兴趣的:(Drone)

  • 探索未来飞行器控制方式：Node.js版AR.Drone库 毕艾琳
    探索未来飞行器控制方式：Node.js版AR.Drone库node-ar-droneAnode.jsclientforcontrollingParrotARDrone2.0quad-copters.项目地址:https://gitcode.com/gh_mirrors/no/node-ar-drone在计算机科学领域中，无人机已经成为一个重要的研究方向。近年来，随着硬件设备的发展和智能算法的进步，
  • [大译] drone delivery service 飞行器快递服务 苹果放阳台
    收听语音：http://xima.tv/x53ZdInewssource新闻来源:https://www.msn.com/en-us/news/technology/google-just-beat-amazon-to-launching-one-of-the-first-ever-drone-delivery-services/ar-BBVKRibWing,astartupownedbyGoog
  • 物联网核心协议MQTT快速入门3 发布消息与取消订阅 python测试开发
    发布信息mosquitto_pub-Vmqttv311-tsensors/drone01/altitude-m"10f"-dClient(null)sendingCONNECTClient(null)receivedCONNACK(0)Client(null)sendingPUBLISH(d0,q0,r0,m1,'sensors/drone01/altitude',...(4bytes))Clie
  • ssh wifi 登录 开发板 埋刀封剑 linuxkernel
    adbshellpasswdinputyourpasswd:xxxxxxxxxxxx(again)[email protected]#ok!!liusen@liusen:~/wkspace/hover2/src/drone_apps/[email protected]@@@@@@@@@@@@@@@@@@@@@@@
  • 私有化轻量级持续集成部署方案--05-持续部署服务-Drone（上） xuhss_com 11cigithub
    Python微信订餐小程序课程视频https://edu.csdn.net/course/detail/36074Python实战量化交易理财系统https://edu.csdn.net/course/detail/35475提示：本系列笔记全部存在于Github，可以直接在Github查看全部笔记持续部署概述持续部署是能以自动化方式，频繁而且持续性的，将软件部署到生产环境。使软件产品能够快速迭代
  • Docker 配置 Gitea + Drone 搭建 CI/CD 平台 Gettler•Main 实战Linuxdockergiteaci/cd
    Docker配置Gitea+Drone搭建CI/CD平台配置Gitea服务器来管理项目版本本文的IP地址是为了方便理解随便打的，不要乱点首先使用docker搭建Gitea服务器，用于管理代码版本，数据库选择mysqlGitea服务器的docker-compose.yml配置文件如下：version:"3"services:server:image:gitea/gitea:1.19.3contain
  • 轻量级CI/CD自动构建平台Gitea+Drone保姆级实践教程 幸福指北 Devopsdockergitdevopsci云原生
    目录1、关于Gitea1.1gitea特性1.2快速安装1.2.1环境依赖1.2.2安装gitea1.2.3启动1.2.4访问1.2.5创建一个测试仓库2关于Drone2.1CI/CD工具对比2.2快速安装2.2.1环境依赖2.2.2安装Dorne2.3启动drone2.4访问drone2.5使用pipeline2.6编写一个完整的pipeline2.6.1编写一个完整的pipeline文件，并部
  • 使用Docker安装Drone和Gogs实现自动化部署 MasonYyp 微服务Linux服务器docker容器
    1基本介绍1.1Drone简介Drone是基于GO语言开发的持续集成（Continuousintegration，CI）引擎，它可以借助Docker容器技术，用于自动化测试与构建，满足持续交付的基本需求，适合小团队开发。Drone具有简洁、轻量级、启动快、资源占用等特点。Jenkins也是CI引擎，它的特点是文档丰富、功能丰富、插件丰富、配置功能强大等特点，但资源占用较高。Drone比Jenkin
  • docker安装drone 肖码哥 dronedockerdocker容器运维自动化
    目录Drone简介docker安装drone创建Drone-server容器创建Drone-runner-docker容器访问drone-server面板操作Drone简介Drone是基于GO语言开发的持续集成（Continuousintegration，CI）引擎，它可以借助Docker容器技术，用于自动化测试与构建，满足持续交付的基本需求，适合小团队开发。Drone具有简洁、轻量级、启动快、资
  • 基于 Gogs + Drone 构建私有 CI/CD 平台 | Docker 篇 chouman5230 运维gitphp
    NomatterwhereIam,IwillreplyyouimmediatelywhenIseetheemail.MyEmail:echo"YUBzYW1lZ28uY29tCg=="|base64-d前言CI/CD(持续集成/持续部署)方案是DevOps中不可或缺的流程之一，最近也了解了部分的相关的解决方案，最终选择了Drone+Gogs基于docker容器环境来构建CI/CD，本文将分享下如何
  • 容器云平台No.10~通过gogs+drone+kubernetes实现CI/CD 空壳先生
    什么是CI/CD持续集成（ContinousIntergration，CI）是一种软件开发实践，即团队开发成员经常集成它们的工作，通常每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都需要通过自动化的编译、发布、自动化回归测试来验证，从而尽快地发现集成错误。而这些自动化的操作则由CI软件进行执行。持续部署（ContinousDelivery，CD）在持续集成的基础上，将集成后的
  • 【Drone+Gitlab】一条龙服务，直接起飞 — 从介绍-＞部署-＞配置-＞写.drone.yml流水线+常见的报错解决 秋意零
    推荐文章【kubernetes】新版helm3的三大概念+快速指南+自定义charts模板【容器】docker-comopse安装+案例练习【GitLab】使用Docker和Docker-Compose部署-个人、私有代码仓库【kubevirt】VirtualMachineInstanceReplicaSet(vmis)-扩缩容-弹性伸缩【openstack】cloudkitty组件，入门级安装（
  • Cross-Drone Transformer Network for Robust Single Object Tracking论文阅读笔记 Mrwei_418 论文阅读笔记transformer论文阅读笔记深度学习
    Cross-DroneTransformerNetworkforRobustSingleObjectTracking论文阅读笔记Abstract无人机在各种应用中得到了广泛使用，例如航拍和军事安全，这得益于它们与固定摄像机相比的高机动性和广阔视野。多无人机追踪系统可以通过从不同视角收集互补的视频片段，为目标提供丰富的信息，特别是当目标在某些视角中被遮挡或消失时。然而，在多无人机视觉追踪中处理跨无人
  • 用Go写drone插件 Tom于
    Drone是一个CI/CD的新起之秀，drone的主要特性就是所有的CI/CD流程都是借助Docker容器来构建。所以Drone的pipline非常容易书写和维护。并且由于直接把Docker容器当做一等公民，那么我们在各种场景下定制化自己的插件也将变得非常便利。因为最终Drone都是调用的插件Docker容器，所以开发团队可以使用任意自己熟练擅长的语言去定制内部自定义插件。本文我们一起动手用Go写
  • 【Docker】python flask 项目如何打包成 Docker images镜像 上传至阿里云ACR私有（共有）镜像仓库 集成Drone CI CTRA王大大 #Dronedevops#dockerpythondockerflaskDroneCI
    一、Python环境编译1、处理好venv环境要生成正常的requirements.txt文件，我们就需要先将虚拟环境处理好创建虚拟环境（可选）：在项目目录中，你可以选择使用虚拟环境，这样你的项目依赖将被隔离在一个独立的环境中。可以使用以下命令创建虚拟环境：python-mvenvvenv1.1、然后激活虚拟环境：在Windows上：venv\Scripts\activate在macOS/Linu
  • Kubernetes深度实践（六） 哦呵呵_3579
    由于我们公司之前就有自己的gitlab仓库和harbor仓库，都是通过docker-compose管理的，在我接手后先是把gitlab也搬到了K8s集群里面，而harbor仓库由于实在比较大，平时用着也比较稳定，所以就一直维持了之前的样子。目前搭建的CI和CD是分离的，实际上Drone也可以直接在K8s集群中更新我们的服务，具体为什么要分开来后续会做说明。CI一开始我使用过jenkins来做CIC
  • 超轻量级自动化部署神器Drone配合Gogs安装详细教程（图文教程） LexKun 运维部署dockerlinux运维自动化运维开发
    前言现在我们在日常开发或者生产环境中，往往会经常弄一套自动化部署方案来节约时间成本。现在比较流行的一种就是Gitlab+Jenkins实现方案，但是这种方案占用内存还是比较大，需要的服务器内存也得8G左右，不然很难流畅运行，而且部署起来也不快。最近小翔发现了一款神器Drone,轻量级的CI/CD工具，我拿来结合Gogs使用所消耗的内存占用都不到1G，这里就给大家聊聊这款工具。Drone简介Dron
  • Drone Settings 页面没有 Trusted踩坑 爱折腾的小码农 drone
    前言懒得写了，等有时间再搞解决方案1.在docker执行的时候或则docker-compose.yml中加上DRONE_USER_CREATE和DRONE_ADMIN，具体的参考如下environment:...-DRONE_ADMIN=admin-DRONE_USER_CREATE=username:admin,admin:true2.如果上面方法用了还是不行，则要检查一下你的用户名，用户名要和
  • docker+gitlab(代码托管)+k8s(rancher)+habor(存储镜像)+Drone(ci/cd流水线) java xiaohu 自动化部署运维dockergitlabk8scil
    文章目录流程图一、dockerdocker安装1.准备工作，需要关闭selinux和分区2.安装二、安装gitlabgilab安装（版本建议安装13版本，其他版本也可以）2.gitlab彻底卸载三、安装rancher四、安装harbor1.准备工作，先安装docker-compose2.安装harbor(很简单，因为harbor默认是使用https,所以关键在于生成证书)五、安装drone(很简单
  • YoloV5改进策略：独家原创，全网首发，复现Drone-Yolo，以及改进方法 静静AI学堂 YoloV5V7改进与实战——高阶篇Yolo系列小目标改进与实战YOLO
    文章目录摘要论文：《Drone-Yolo:一种高效的无人机图像目标检测神经网络方法》1、简介2、相关工作3、方法3.1、骨干3.2、Neck3.3、提出的模型4、实验与结果4.1、数据集和实验环境4.2、实验指标4.3、与基线方法的比较4.4、消融实验4.5、可视化5、结论YoloV5官方结果BiC模块改进一测试结果改进二：复现Dron-Yolo改进方法测试结果<
  • YoloV8改进策略：独家原创，全网首发，复现Drone-Yolo，以及改进方法 静静AI学堂 Yolo系列小目标改进与实战YOLO
    摘要Drone-Yolo在无人机数据集上取得了巨大的成功，mAP0.5指标上取得了显著改进，在VisDrone2019-test上增加了13.4%，在VisDrone2019-val上增加了17.40%。这篇文章我首先复现Drone-Yolo，然后，在Drone-Yolo的基础上加入我自己对小目标检测的改进。论文：《Drone-Yolo:一种高效的无人机图像目标检测神经网络方法》https://w
  • 【论文阅读笔记】Drone-YOLO: An Efficient Neural Network Method for TargetDetection in Drone Images 诸葛大庆 论文阅读笔记YOLO
    摘要:无人机(UAV)图像目标检测是各个研究领域的重要基础。然而，无人机图像提出了独特的挑战，包括大图像尺寸、小尺寸检测对象、密集分布、重叠实例和影响目标检测有效性的光照不足。在本文中，我们提出了一系列基于YOLOv8模型的多尺度无人机图像目标检测算法Drone-YOLO，旨在克服无人机图像目标检测的特定挑战。为了解决大场景尺寸和小检测对象的问题，我们对YOLOv8模型的颈部组件进行了改进。具体来
  • Drone-YOLO：一种有效的无人机图像目标检测 计算机视觉研究院 YOLO无人机目标检测人工智能计算机视觉
    点击蓝字关注我们关注并星标从此不迷路计算机视觉研究院公众号ID｜计算机视觉研究院学习群｜扫码在主页获取加入方式计算机视觉研究院专栏ColumnofComputerVisionInstitute无人机图像中的目标检测是各个研究领域的重要基础。然而，无人机图像带来了独特的挑战，包括图像尺寸大、检测对象尺寸小、分布密集、实例重叠和照明不足，这些都会影响对象检测的有效性。01前景概要今天分享中，我们提出了
  • VisDrone-DET2019: The Vision Meets Drone Object Detection in Image Challenge Results论文阅读笔记 Mrwei_418 目标检测论文阅读笔记人工智能计算机视觉
    VisDrone-DET2019:TheVisionMeetsDroneObjectDetectioninImageChallengeResults论文阅读笔记Paper：https://openaccess.thecvf.com/content_ICCVW_2019/papers/VISDrone/Du_VisDrone-DET2019_The_Vision_Meets_Drone_Object
  • Drone-Yolo:一种高效的无人机图像目标检测神经网络方法 静静AI学堂 高质量AI论文翻译YOLO无人机目标检测
    摘要https://www.mdpi.com/2504-446X/7/8/526在各种研究领域中，对无人机的图像进行目标检测是一项有意义的任务。然而，无人机的图像带来了独特的挑战，包括图像尺寸大、检测对象尺寸小、对象密集分布、对象重叠以及光线不足影响目标检测的准确性。本文提出了Drone-YOLO，这是一系列基于YOLOv8模型的多尺度UAV图像目标检测算法，旨在克服与UAV图像目标检测相关的特定
  • Drone与GitLab结合实现自动化部署 大华夏
    Drone与gitlab结合实现自动化部署GitLab设置在gitlab中注册一个账号，此账号用来对接drone，用此账号登录gitlab后,点击头像下拉里的设置,按下面截图操作image.pngimage.png点击Applications后，右边Name框输入一个名字，RedirectURI为后面安装drone服务的登录地址，格式：http://ip:port/login，ip和端口根据实际情
  • 使用 GitHub Actions 与 Docker 构建 CI/CD 系统 502-Bad-Gateway githubdockerci/cd
    文章目录技术概述技术详述CI部分工具选择技术实现CD部分工具选择技术实现编译部分部署部分CI+CD问题与解决方案总结参考文献技术概述CI/CD即持续集成/持续部署，是一种软件开发实践，通过自动化的软件流程来构建、测试、部署软件。通过使用CI/CD，开发团队可以更快地构建和交付出高质量的软件。技术详述CI部分工具选择项目开始之初，我计划使用Gitea自建Git，作为我们项目的代码仓，使用Drone作
  • Drone持续集成PHP示例 谦谦少年
    PHP配置持续集成学习Drone安装及配置时，会发现配置项有一个以.drone.yml命令的文件，代码推送至Git仓库时，会触发钩子执行Drone配置的持续集成管道，将解析yml的文件去执行。可以参考Drone提供的官方文档：Drone的PHP示例示例文件如下：kind:pipelinetype:dockername:lumen-teststeps:-name:installpull:if-not
  • drone如何发布docker服务 huningfei CICDdocker容器运维dronegogs
    上篇主要实现了drone在物理机上进行发布程序，这次介绍drone如何发布docker类型的服务。一drone.yml文件配置前提：需要提前在drone里添加文件里面所引用的密钥kind:pipeline#定义对象类型，还有secret和signature两种类型type:docker#定义流水线类型，还有kubernetes、exec、ssh等类型name:drone-miaosha#定义流水线
  • 20180416W3P1D1精读任务 徐丹的写作课
    文章Limitingthedownsidesofartificialintelligence防范人工智能的不利一面一地道表达1malicious恶意的2dystopian反乌托邦的3drone雄蜂，无人驾驶飞机4distort篡改5dualistic两面性6potency危害7roguestates流氓政府8Whereitislesscompelling不那么令人信服的可以做助于9superint
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他