NXP

[开源]蜘蛛机器人V2

2020-02-11 10:17发布

站内问答 / 51单片机
16835 100 100
本帖最后由 Gorgon_Meducer 于 2014-10-28 12:01 编辑



- 2014-10-28 致歉
     由于我个人在团队管理实践上的重大错误，V2版蜘蛛可靠性不足以完成今日举行的产品展示，最终影响了飞思卡尔产品
     的展示计划。在这里，我真心的向阿莫致歉，向相信我，期待蜘蛛项目的广大坛友致歉，向飞思卡尔（上海）致歉。
    我们认识到自己能力的不足，后续将继续在硬件驱动能力上进行改进，降低机器人对电源系统的依赖。

                                                                                                                  特此致歉：王卓然（傻孩子）

     P.S 此次飞思卡尔展会将使用蜘蛛V1进行演示。


- 2014-10-23 V2版蜘蛛改进
     a. 由于驱动电路考虑不足，发现蜘蛛在joints_calibration()时由于所有的关节顺势运动时电流过大会导致驱动电路保护，
         导致很多时候无法正常工作。显然现在修改驱动电路已经来不及了，只能修改代码，让所有关节顺次启动，从而避免
         峰值电流。

  2. static void joints_calibration(joint_t *ptJoints, joint_no_t tIndex)
  3. {
  4.     if (NULL == ptJoints) {
  5.         return ;
  6.     }

  8.     switch (tIndex) {
  9.         case RIGHT_BACK_LEG_0:
  10.             JOINT_CFG(
  11.                 ptJoints[RIGHT_BACK_LEG_0],
  12.                 RIGHT_BACK_LEG_0,
  13.                 70,                         //!< offset
  14.                 110,                        //!< start angle
  15.                 200,                        //!< end angle
  16.                 270,                        //!< Max Angular Speed
  17.                 225,                        //!< Reset Position
  18.             );break;

  20.         case RIGHT_MIDDLE_LEG_0:
  21.             JOINT_CFG(
  22.                 ptJoints[RIGHT_MIDDLE_LEG_0],
  23.                 RIGHT_MIDDLE_LEG_0,
  24.                 54,                     //!< offset
  25.                 81,                     //!< start angle
  26.                 171,                    //!< end angle
  27.                 270,                    //!< Max Angular Speed
  28.                 180,                    //!< Reset Position
  29.             );break;

  31.         case RIGHT_FRONT_LEG_0:
  32.             JOINT_CFG(
  33.                 ptJoints[RIGHT_FRONT_LEG_0],
  34.                 RIGHT_FRONT_LEG_0,
  35.                 50,                     //!< offset
  36.                 40,                     //!< start angle
  37.                 130,                    //!< end angle
  38.                 270,                    //!< Max Angular Speed
  39.                 135,                    //!< Reset Position
  40.             );break;

  42.         case LEFT_FRONT_LEG_0:
  43.             JOINT_CFG(
  44.                 ptJoints[LEFT_FRONT_LEG_0],
  45.                 LEFT_FRONT_LEG_0,
  46.                 220,                     //!< offset
  47.                 0,                      //!< start angle
  48.                 270,                    //!< end angle
  49.                 270,                    //!< Max Angular Speed
  50.                 45,                      //!< Reset Position
  51.             );break;

  53.         case LEFT_MIDDLE_LEG_0:
  54.             JOINT_CFG(
  55.                 ptJoints[LEFT_MIDDLE_LEG_0],
  56.                 LEFT_MIDDLE_LEG_0,
  57.                 215,                     //!< offset
  58.                 0,                      //!< start angle
  59.                 270,                    //!< end angle
  60.                 270,                    //!< Max Angular Speed
  61.                 0,                      //!< Reset Position
  62.             );break;

  64.         case LEFT_BACK_LEG_0:
  65.             JOINT_CFG(
  66.                 ptJoints[LEFT_BACK_LEG_0],
  67.                 LEFT_BACK_LEG_0,
  68.                 195,                    //!< offset
  69.                 0,                      //!< start angle
  70.                 270,                    //!< end angle
  71.                 270,                    //!< Max Angular Speed
  72.                 315,                      //!< Reset Position
  73.             );break;

  75.         case RIGHT_BACK_LEG_1:
  76.             JOINT_CFG(
  77.                 ptJoints[RIGHT_BACK_LEG_1],
  78.                 RIGHT_BACK_LEG_1,
  79.                 35,                    //!< offset
  80.                 0,                      //!< start angle
  81.                 270,                    //!< end angle
  82.                 270,                    //!< Max Angular Speed
  83.                 225,                     //!< Reset Position
  84.             );break;

  86.         case RIGHT_MIDDLE_LEG_1:
  87.             JOINT_CFG(
  88.                 ptJoints[RIGHT_MIDDLE_LEG_1],
  89.                 RIGHT_MIDDLE_LEG_1,
  90.                 40,                    //!< offset
  91.                 0,                      //!< start angle
  92.                 270,                    //!< end angle
  93.                 270,                    //!< Max Angular Speed
  94.                 225,                     //!< Reset Position
  95.             );break;

  97.         case RIGHT_FRONT_LEG_1:
  98.             JOINT_CFG(
  99.                 ptJoints[RIGHT_FRONT_LEG_1],
  100.                 RIGHT_FRONT_LEG_1,
  101.                 33,                    //!< offset
  102.                 0,                      //!< start angle
  103.                 270,                    //!< end angle
  104.                 270,                    //!< Max Angular Speed
  105.                 225,                     //!< Reset Position
  106.             );break;
  107.             
  108.          case LEFT_BACK_LEG_1:
  109.             JOINT_CFG(
  110.                 ptJoints[LEFT_BACK_LEG_1],
  111.                 LEFT_BACK_LEG_1,
  112.                 235,                    //!< offset
  113.                 0,                      //!< start angle
  114.                 270,                    //!< end angle
  115.                 270,                    //!< Max Angular Speed
  116.                 315,                     //!< Reset Position
  117.             );break;

  119.         case LEFT_MIDDLE_LEG_1:
  120.             JOINT_CFG(
  121.                 ptJoints[LEFT_MIDDLE_LEG_1],
  122.                 LEFT_MIDDLE_LEG_1,
  123.                 240,                    //!< offset
  124.                 0,                      //!< start angle
  125.                 270,                    //!< end angle
  126.                 270,                    //!< Max Angular Speed
  127.                 315,                     //!< Reset Position
  128.             );break;

  130.         case LEFT_FRONT_LEG_1:
  131.             JOINT_CFG(
  132.                 ptJoints[LEFT_FRONT_LEG_1],
  133.                 LEFT_FRONT_LEG_1,
  134.                 245,                    //!< offset
  135.                 0,                      //!< start angle
  136.                 270,                    //!< end angle
  137.                 270,                    //!< Max Angular Speed
  138.                 315,                     //!< Reset Position
  139.             );break;

  141.         case LEFT_BACK_LEG_2:
  142.             JOINT_CFG(
  143.                 ptJoints[LEFT_BACK_LEG_2],
  144.                 LEFT_BACK_LEG_2,
  145.                 328,                    //!< offset
  146.                 0,                     //!< start angle
  147.                 270,                    //!< end angle
  148.                 270,                    //!< Max Angular Speed
  149.                 45,                     //!< Reset Position
  150.             );break;

  152.         case LEFT_MIDDLE_LEG_2:
  153.             JOINT_CFG(
  154.                 ptJoints[LEFT_MIDDLE_LEG_2],
  155.                 LEFT_MIDDLE_LEG_2,
  156.                 332,                    //!< offset
  157.                 0,                     //!< start angle
  158.                 270,                    //!< end angle
  159.                 270,                    //!< Max Angular Speed
  160.                 45,                     //!< Reset Position
  161.             );break;

  163.         case LEFT_FRONT_LEG_2:
  164.             JOINT_CFG(
  165.                 ptJoints[LEFT_FRONT_LEG_2],
  166.                 LEFT_FRONT_LEG_2,
  167.                 323,                    //!< offset
  168.                 0,                     //!< start angle
  169.                 270,                    //!< end angle
  170.                 270,                    //!< Max Angular Speed
  171.                 45,                     //!< Reset Position
  172.             );break;

  174.         case RIGHT_BACK_LEG_2:
  175.             JOINT_CFG(
  176.                 ptJoints[RIGHT_BACK_LEG_2],
  177.                 RIGHT_BACK_LEG_2,
  178.                 312,                    //!< offset
  179.                 0,                     //!< start angle
  180.                 270,                    //!< end angle
  181.                 270,                    //!< Max Angular Speed
  182.                 135,                     //!< Reset Position
  183.             );break;

  185.         case RIGHT_MIDDLE_LEG_2:
  186.             JOINT_CFG(
  187.                 ptJoints[RIGHT_MIDDLE_LEG_2],
  188.                 RIGHT_MIDDLE_LEG_2,
  189.                 311,                    //!< offset
  190.                 0,                     //!< start angle
  191.                 270,                    //!< end angle
  192.                 270,                    //!< Max Angular Speed
  193.                 135,                     //!< Reset Position
  194.             );break;

  196.         case RIGHT_FRONT_LEG_2:
  197.             JOINT_CFG(
  198.                 ptJoints[RIGHT_FRONT_LEG_2],
  199.                 RIGHT_FRONT_LEG_2,
  200.                 312,                    //!< offset
  201.                 0,                     //!< start angle
  202.                 270,                    //!< end angle
  203.                 270,                    //!< Max Angular Speed
  204.                 135,                     //!< Reset Position
  205.             );break;
  206.     }

  208. }
  209. ...

  211. IMPLEMENT_FSM(SpiderTask)
  212.     NO_INIT static uint8_t s_hwJointsCount;
  213.     PRIVATE STATE(Spider_Init) BEGIN
  214.         s_hwJointsCount = CEREBEL_JOINTS_COUNT;
  215.         //! initialize servo service
  216.         SERVO.Init ();
  217.         SERVO.Start ();
  218.         
  219.         CS_SET_EVENT(&s_wDelayEvent);
  220.         
  221.         TRANSFER_TO_STATE(Spider_Joints_Init);
  222.         EXIT_STATE;
  223.     END
  224.     PRIVATE STATE(Spider_Joints_Init) WAIT_EVENT_BEGIN(&s_wDelayEvent)
  225.         
  226.         if (s_hwJointsCount) {
  227.             request_for_delay_ms(250);
  228.             joints_calibration(s_tJoints, s_hwJointsCount - 1);
  229.             s_hwJointsCount--;
  230.         } else {

  232.             //! initialize cerebel layer
  233.             CEREBEL_CFG(&s_tJoints);
  234.             TRANSFER_TO_STATE(Spider_Task);
  235.         }

  237.         REFLEXIVE_STATE;
  238.     END
  239.     PRIVATE STATE(Spider_Task) BEGIN

  241.         CALL_ACTION(Spider_Go_Front);
  242.         REFLEXIVE_STATE;
  243.     END
  244. END_IMPLEMENT_FSM
复制代码
    b. 增加一个异步的毫秒级精确延时服务，主要是前面关节初始化的时候需要在每个关节之间插入非阻塞的延时。
       这也展示了状态机架构下如何配合调度器实现任务和时间的同步（应用代码参考a）：


  3. NO_INIT static event_t s_wDelayEvent;
  4. static volatile uint32_t s_wDelayCounter = 0;

  6. void request_for_delay_ms(uint32_t wDelayMs)
  7. {
  8.     SAFE_ATOM_CODE(
  9.         s_wDelayCounter = wDelayMs;
  10.     )
  11. }

  13. ISR(SysTick_Handler)
  14. {
  15. ...

  17.     if (s_wDelayCounter) {
  18.         s_wDelayCounter--;
  19.         if (!s_wDelayCounter) {
  20.             CS_SET_EVENT(&s_wDelayEvent);
  21.         }
  22.     }

  24. ...
  25. }
复制代码
    c. v1.2工程模板下载 SpiderRobot_Template(v1.2).rar (1.17 MB, 下载次数: 257) 2014-10-27 11:04 上传 点击文件名下载附件
   


- 2014-10-23 凌晨 V2版蜘蛛初步完成

    历经磨难，原本以为很容易搞定的新版蜘蛛机器人，总算是搞定了——上视频：
    V41023-025542.part1.rar (15 MB, 下载次数: 886) 2014-10-23 03:09 上传 点击文件名下载附件
    V41023-025542.part2.rar (15 MB, 下载次数: 843) 2014-10-23 03:10 上传 点击文件名下载附件
    V41023-025542.part3.rar (3.22 MB, 下载次数: 528) 2014-10-23 03:10 上传 点击文件名下载附件
    数字舵机是0~270度的，非常精准，校准只需要处理offset即可。另外由于安装的原因，坐标系又被迫做了镜像，
    回头软件上考虑加入处理，避免这种坐标系上的差异存在。
    睡了，好困，其它内容明天再补充。
   
工程下载 SpiderRobot_Template(v1.1).rar (551.88 KB, 下载次数: 343) 2014-10-23 03:12 上传 点击文件名下载附件



友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
100条回答
Gorgon_Meducer
2020-02-19 10:20
本帖最后由 Gorgon_Meducer 于 2014-10-24 15:37 编辑
myqiang1990 发表于 2014-10-24 14:20
适当可以用__inline~~~~在我读过的代码中，我觉得UCOS的代码是非常优美的~十分清晰有条理~而且代码整整齐 ...


有很多需要大量重复的结构性代码本身是没法用inline的，因为这只是代码片段。
另外用宏虽然看似和inline差不多，但inline很多时候是“强制”的，但用宏就赋予了编译器灵活处理的权利，
他可以inline——如果你选择速度优化的话，也可以不inline——通常是你选择size优化的时候。

宏的作用是给一些重复的代码片段赋予简单易懂的意义，同时也避免书写多次。你可以认为是一种模板，
这种模板当成为一定规模后，实际上确保了你过去用宏固定下来的“成功代码”不会在重写的时候出现
笔误或者偏差。

比如我写过一个宏模板用来产生FIFO的，用起来很方便，也不用担心每次为一个新的特定类型写FIFO
代码的时候会出现笔误或者逻辑错误。

再说个玩笑话：我觉得你属于C语言的“纯血派”。我则是强调实用主义的。我用宏并不是像你看到的文字
那样是为了追求像某种语言（最初我这么尝试过，但发现没有意义，也不好玩），我用宏的目标完全是
为了提高代码效率，降低出错效率，辅助编码规范——比如状态机写出来拥有统一格式之类的。

尤其是C不支持模板，而宏是唯一最接近这一概念的实现了。

计算机科学历来都是“唯心主义”泛滥的圣地，除了做应用与物理世界相连，或者解决数学高度相关的问题，
平时的计算机世界完全就是程序员说了算的。有影响的人可以这么解释一种语言，其它人可以附庸，也可以
提出自己的解释，最牛掰的人干脆自己创造一门语言——尤其是在自己的应用范围自己说了算的时候。

所以，“纯血派”嘛我只能笑笑。我影响我的范围，你影响你的。不过我还是很乐于沟通的。相对于其他直接
MARK的人，我真的非常开心有人说出自己的想法，认真的评论。从这点角度来说，你就是直接骂我，我都
是开心的——毕竟你说的有理有据，还专门耐心去截图。

真的，非常感谢，还请以后继续关注我的帖子。欢迎吐槽~真心的。做技术对事不对人~谢谢你。

一周热门 更多>