devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【研发日记】Matlab/Simulink软件优化(二)——通信负载柔性均衡算法

作者：AllinToyou | 2024-06-12 08:04:02

赞

踩

【研发日记】Matlab/Simulink软件优化(二)——通信负载柔性均衡算法

文章目录

前言

背景介绍

初始代码

优化代码

分析和应用

总结

前言

        见《【研发日记】Matlab/Simulink软件优化(一)——动态内存负荷压缩》

背景介绍

        在一个嵌入式软件开发项目中，需要设计一个ECU节点的CAN网路数据发送，需求是在500k的通信波特率上，动态发送10到40帧报文，发送一轮的时间最长不能超过50ms。示例如下：

初始代码

        一开始算法开发的思路非常简单，就是设置一个50ms的任务，用for循环把要发送的数据装入CAN发送Buffer。示例如下：

        以上模型生成的代码如下：

  1.  
  2. #include "untitled.h"
  3. #include "untitled_private.h"
  4.  
  5. /* Block signals (default storage) */
  6. B_untitled_T untitled_B;
  7.  
  8. /* Block states (default storage) */
  9. DW_untitled_T untitled_DW;
  10.  
  11. /* Real-time model */
  12. static RT_MODEL_untitled_T untitled_M_;
  13. RT_MODEL_untitled_T *const untitled_M = &untitled_M_;
  14.  
  15. /* Model step function */
  16. void untitled_step(void)
  17. {
  18.   int32_T i;
  19.   int32_T rtb_Gain;
  20.   int32_T s6_iter;
  21.   char_T *sErr;
  22.   void *inputMsgRef;
  23.  
  24.   /* Outputs for Enabled SubSystem: '<Root>/Subsystem' incorporates:
  25.    *  EnablePort: '<S3>/Enable'
  26.    */
  27.   /* RelationalOperator: '<S1>/Compare' incorporates:
  28.    *  Constant: '<S1>/Constant'
  29.    *  UnitDelay: '<S2>/Output'
  30.    */
  31.   if (untitled_DW.Output_DSTATE == 0) {
  32.     if (!untitled_DW.Subsystem_MODE) {
  33.       /* Enable for Iterator SubSystem: '<S3>/For Iterator Subsystem' */
  34.       /* Enable for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  35.       sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  36.       LibReset(&untitled_DW.CANTransmit_CANTransmit[0U]);
  37.       LibStart(&untitled_DW.CANTransmit_CANTransmit[0U]);
  38.       if (*sErr != 0) {
  39.         rtmSetErrorStatus(untitled_M, sErr);
  40.         rtmSetStopRequested(untitled_M, 1);
  41.       }
  42.  
  43.       /* End of Enable for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  44.       /* End of Enable for SubSystem: '<S3>/For Iterator Subsystem' */
  45.       untitled_DW.Subsystem_MODE = true;
  46.     }
  47.  
  48.     /* Outputs for Iterator SubSystem: '<S3>/For Iterator Subsystem' incorporates:
  49.      *  ForIterator: '<S6>/For Iterator'
  50.      */
  51.     for (s6_iter = 0; s6_iter < 40; s6_iter++) {
  52.       /* Gain: '<S6>/Gain' */
  53.       rtb_Gain = s6_iter << 3;
  54.       for (i = 0; i < 8; i++) {
  55.         /* Selector: '<S6>/Selector' incorporates:
  56.          *  Constant: '<Root>/Constant'
  57.          */
  58.         untitled_B.Selector[i] = untitled_ConstP.Constant_Value[i + rtb_Gain];
  59.       }
  60.  
  61.       /* S-Function (scanpack): '<S6>/CAN Pack' */
  62.       /* S-Function (scanpack): '<S6>/CAN Pack' */
  63.       untitled_B.CANPack.ID = 10U;
  64.       untitled_B.CANPack.Length = 8U;
  65.       untitled_B.CANPack.Extended = 0U;
  66.       untitled_B.CANPack.Remote = 0;
  67.       untitled_B.CANPack.Data[0] = 0;
  68.       untitled_B.CANPack.Data[1] = 0;
  69.       untitled_B.CANPack.Data[2] = 0;
  70.       untitled_B.CANPack.Data[3] = 0;
  71.       untitled_B.CANPack.Data[4] = 0;
  72.       untitled_B.CANPack.Data[5] = 0;
  73.       untitled_B.CANPack.Data[6] = 0;
  74.       untitled_B.CANPack.Data[7] = 0;
  75.  
  76.       {
  77.         (void) memcpy((untitled_B.CANPack.Data), &untitled_B.Selector[0],
  78.                       8 * sizeof(uint8_T));
  79.       }
  80.  
  81.       /* S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  82.       sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  83.  
  84.       /* S-Function (scanpack): '<S6>/CAN Pack' incorporates:
  85.        *  S-Function (svntcantransmit): '<S6>/CAN Transmit'
  86.        */
  87.       inputMsgRef = &untitled_B.CANPack;
  88.  
  89.       /* S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  90.       LibOutputs_CANTransmit(&untitled_DW.CANTransmit_CANTransmit[0U],
  91.         inputMsgRef, 1);
  92.       if (*sErr != 0) {
  93.         rtmSetErrorStatus(untitled_M, sErr);
  94.         rtmSetStopRequested(untitled_M, 1);
  95.       }
  96.     }
  97.  
  98.     /* End of Outputs for SubSystem: '<S3>/For Iterator Subsystem' */
  99.   } else {
  100.     if (untitled_DW.Subsystem_MODE) {
  101.       /* Disable for Iterator SubSystem: '<S3>/For Iterator Subsystem' */
  102.       /* Disable for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  103.       sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  104.       LibReset(&untitled_DW.CANTransmit_CANTransmit[0U]);
  105.       if (*sErr != 0) {
  106.         rtmSetErrorStatus(untitled_M, sErr);
  107.         rtmSetStopRequested(untitled_M, 1);
  108.       }
  109.  
  110.       /* End of Disable for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  111.       /* End of Disable for SubSystem: '<S3>/For Iterator Subsystem' */
  112.       untitled_DW.Subsystem_MODE = false;
  113.     }
  114.   }
  115.  
  116.   /* End of RelationalOperator: '<S1>/Compare' */
  117.   /* End of Outputs for SubSystem: '<Root>/Subsystem' */
  118.  
  119.   /* Switch: '<S5>/FixPt Switch' incorporates:
  120.    *  Constant: '<S4>/FixPt Constant'
  121.    *  Constant: '<S5>/Constant'
  122.    *  Sum: '<S4>/FixPt Sum1'
  123.    *  UnitDelay: '<S2>/Output'
  124.    */
  125.   if ((uint8_T)(untitled_DW.Output_DSTATE + 1U) > 49) {
  126.     untitled_DW.Output_DSTATE = 0U;
  127.   } else {
  128.     untitled_DW.Output_DSTATE++;
  129.   }
  130.  
  131.   /* End of Switch: '<S5>/FixPt Switch' */
  132. }
  133.  
  134. /* Model initialize function */
  135. void untitled_initialize(void)
  136. {
  137.   {
  138.     int32_T bitParams[4];
  139.     char_T *sErr;
  140.  
  141.     /* Start for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  142.     sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  143.     CreateHostLibrary("slhostlibcantransmit.dll",
  144.                       &untitled_DW.CANTransmit_CANTransmit[0U]);
  145.     if (*sErr == 0) {
  146.       bitParams[0U] = 1;
  147.       bitParams[1U] = 4;
  148.       bitParams[2U] = 3;
  149.       bitParams[3U] = 1;
  150.       LibCreate_CANTransmit(&untitled_DW.CANTransmit_CANTransmit[0U], "vector",
  151.                             "slvectorxlwrapper.dll", "Virtual", 0, 1, 1, 1,
  152.                             "canslconverter", "vectorxlplugin", 500000.0,
  153.                             &bitParams[0U], 0, 0, 0, 1.0, 0);
  154.     }
  155.  
  156.     if (*sErr == 0) {
  157.       LibStart(&untitled_DW.CANTransmit_CANTransmit[0U]);
  158.     }
  159.  
  160.     if (*sErr != 0) {
  161.       rtmSetErrorStatus(untitled_M, sErr);
  162.       rtmSetStopRequested(untitled_M, 1);
  163.     }
  164.  
  165.     /* End of Start for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  166.     /* End of SystemInitialize for SubSystem: '<S3>/For Iterator Subsystem' */
  167.     /* End of SystemInitialize for SubSystem: '<Root>/Subsystem' */
  168.   }
  169. }
  170.  
  171. /* Model terminate function */
  172. void untitled_terminate(void)
  173. {
  174.   char_T *sErr;
  175.  
  176.   /* Terminate for Enabled SubSystem: '<Root>/Subsystem' */
  177.   /* Terminate for Iterator SubSystem: '<S3>/For Iterator Subsystem' */
  178.   /* Terminate for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  179.   sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  180.   LibTerminate(&untitled_DW.CANTransmit_CANTransmit[0U]);
  181.   if (*sErr != 0) {
  182.     rtmSetErrorStatus(untitled_M, sErr);
  183.     rtmSetStopRequested(untitled_M, 1);
  184.   }
  185.  
  186.   LibDestroy(&untitled_DW.CANTransmit_CANTransmit[0U], 0);
  187.   DestroyHostLibrary(&untitled_DW.CANTransmit_CANTransmit[0U]);
  188.  
  189.   /* End of Terminate for S-Function (svntcantransmit): '<S6>/CAN Transmit' */
  190.   /* End of Terminate for SubSystem: '<S3>/For Iterator Subsystem' */
  191.   /* End of Terminate for SubSystem: '<Root>/Subsystem' */
  192. }

        按照上述示例生成的代码，调试时监测到CAN网络上的瞬时负载率，在0%和100%之间来回跳变。0%和100%各自占用一段时间，两者的比例随着发送报文数量的多少变化。当报文数为最大的40帧时，100%瞬时负载率会持续10ms左右，如下图所示：

        分析上述网络通信的特点，100%瞬时负载率持续的10ms时间段里，肯定会有其他ECU节点也发出报文，这时候CAN网络就会自动根据ID的优先级分配谁先发，谁等待后发，即出现冲突抢占现象。在CAN网络中如果冲突抢占是偶发的，那就不会有太大影响，但是如果冲突抢占是持续的，那就不是我们希望看到的了。

优化代码

        根据对上述问题的分析，我们发现每个50ms周期里边都还有至少40ms是没有利用的，那么只要把前面拥挤的报文分散开到后面一部分，就能解决前面的问题了。然后如果还有剩余的时间没有利用，那么我们就柔性地缩短50ms的周期时长，提高数据发送的频率。这样既能解决前面的问题，又能把总线资源充分利用起来，用于提高我们网络通信的性能。示例如下：

        以上模型生成的代码如下：

  1. #include "untitled.h"
  2. #include "untitled_private.h"
  3.  
  4. /* Named constants for Chart: '<S1>/Chart' */
  5. #define untitled_IN_a                  ((uint8_T)1U)
  6. #define untitled_IN_a1                 ((uint8_T)2U)
  7.  
  8. /* Block signals (default storage) */
  9. B_untitled_T untitled_B;
  10.  
  11. /* Block states (default storage) */
  12. DW_untitled_T untitled_DW;
  13.  
  14. /* Real-time model */
  15. static RT_MODEL_untitled_T untitled_M_;
  16. RT_MODEL_untitled_T *const untitled_M = &untitled_M_;
  17.  
  18. /* Model step function */
  19. void untitled_step(void)
  20. {
  21.   real_T rtb_Gain;
  22.   int32_T i;
  23.   char_T *sErr;
  24.   void *inputMsgRef;
  25.  
  26.   /* Chart: '<S1>/Chart' incorporates:
  27.    *  Constant: '<Root>/Constant3'
  28.    */
  29.   if (untitled_DW.is_active_c3_untitled == 0U) {
  30.     untitled_DW.is_active_c3_untitled = 1U;
  31.     untitled_DW.is_c3_untitled = untitled_IN_a;
  32.     untitled_B.FrameIndex = 0.0;
  33.   } else if (untitled_DW.is_c3_untitled == untitled_IN_a) {
  34.     untitled_DW.is_c3_untitled = untitled_IN_a1;
  35.     untitled_B.FrameIndex++;
  36.   } else {
  37.     /* case IN_a1: */
  38.     if (untitled_B.FrameIndex >= 39.0) {
  39.       untitled_DW.is_c3_untitled = untitled_IN_a;
  40.       untitled_B.FrameIndex = 0.0;
  41.     }
  42.   }
  43.  
  44.   /* End of Chart: '<S1>/Chart' */
  45.  
  46.   /* Gain: '<S1>/Gain' */
  47.   rtb_Gain = 8.0 * untitled_B.FrameIndex;
  48.   for (i = 0; i < 8; i++) {
  49.     /* Selector: '<S1>/Selector' incorporates:
  50.      *  Constant: '<Root>/Constant2'
  51.      */
  52.     untitled_B.Selector[i] = untitled_ConstP.Constant2_Value[i + (int32_T)
  53.       rtb_Gain];
  54.   }
  55.  
  56.   /* S-Function (scanpack): '<S1>/CAN Pack' */
  57.   /* S-Function (scanpack): '<S1>/CAN Pack' */
  58.   untitled_B.CANPack.ID = 10U;
  59.   untitled_B.CANPack.Length = 8U;
  60.   untitled_B.CANPack.Extended = 0U;
  61.   untitled_B.CANPack.Remote = 0;
  62.   untitled_B.CANPack.Data[0] = 0;
  63.   untitled_B.CANPack.Data[1] = 0;
  64.   untitled_B.CANPack.Data[2] = 0;
  65.   untitled_B.CANPack.Data[3] = 0;
  66.   untitled_B.CANPack.Data[4] = 0;
  67.   untitled_B.CANPack.Data[5] = 0;
  68.   untitled_B.CANPack.Data[6] = 0;
  69.   untitled_B.CANPack.Data[7] = 0;
  70.  
  71.   {
  72.     (void) memcpy((untitled_B.CANPack.Data), &untitled_B.Selector[0],
  73.                   8 * sizeof(uint8_T));
  74.   }
  75.  
  76.   /* S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  77.   sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  78.  
  79.   /* S-Function (scanpack): '<S1>/CAN Pack' incorporates:
  80.    *  S-Function (svntcantransmit): '<S1>/CAN Transmit'
  81.    */
  82.   inputMsgRef = &untitled_B.CANPack;
  83.  
  84.   /* S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  85.   LibOutputs_CANTransmit(&untitled_DW.CANTransmit_CANTransmit[0U], inputMsgRef,
  86.     1);
  87.   if (*sErr != 0) {
  88.     rtmSetErrorStatus(untitled_M, sErr);
  89.     rtmSetStopRequested(untitled_M, 1);
  90.   }
  91. }
  92.  
  93. /* Model initialize function */
  94. void untitled_initialize(void)
  95. {
  96.   {
  97.     int32_T bitParams[4];
  98.     char_T *sErr;
  99.  
  100.     /* Start for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  101.     sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  102.     CreateHostLibrary("slhostlibcantransmit.dll",
  103.                       &untitled_DW.CANTransmit_CANTransmit[0U]);
  104.     if (*sErr == 0) {
  105.       bitParams[0U] = 1;
  106.       bitParams[1U] = 4;
  107.       bitParams[2U] = 3;
  108.       bitParams[3U] = 1;
  109.       LibCreate_CANTransmit(&untitled_DW.CANTransmit_CANTransmit[0U], "vector",
  110.                             "slvectorxlwrapper.dll", "Virtual", 0, 1, 1, 1,
  111.                             "canslconverter", "vectorxlplugin", 500000.0,
  112.                             &bitParams[0U], 0, 0, 0, 1.0, 0);
  113.     }
  114.  
  115.     if (*sErr == 0) {
  116.       LibStart(&untitled_DW.CANTransmit_CANTransmit[0U]);
  117.     }
  118.  
  119.     if (*sErr != 0) {
  120.       rtmSetErrorStatus(untitled_M, sErr);
  121.       rtmSetStopRequested(untitled_M, 1);
  122.     }
  123.  
  124.     /* End of Start for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  125.  
  126.     /* Enable for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  127.     sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  128.     LibReset(&untitled_DW.CANTransmit_CANTransmit[0U]);
  129.     LibStart(&untitled_DW.CANTransmit_CANTransmit[0U]);
  130.     if (*sErr != 0) {
  131.       rtmSetErrorStatus(untitled_M, sErr);
  132.       rtmSetStopRequested(untitled_M, 1);
  133.     }
  134.  
  135.     /* End of Enable for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  136.   }
  137. }
  138.  
  139. /* Model terminate function */
  140. void untitled_terminate(void)
  141. {
  142.   char_T *sErr;
  143.  
  144.   /* Terminate for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  145.   sErr = GetErrorBuffer(&untitled_DW.CANTransmit_CANTransmit[0U]);
  146.   LibTerminate(&untitled_DW.CANTransmit_CANTransmit[0U]);
  147.   if (*sErr != 0) {
  148.     rtmSetErrorStatus(untitled_M, sErr);
  149.     rtmSetStopRequested(untitled_M, 1);
  150.   }
  151.  
  152.   LibDestroy(&untitled_DW.CANTransmit_CANTransmit[0U], 0);
  153.   DestroyHostLibrary(&untitled_DW.CANTransmit_CANTransmit[0U]);
  154.  
  155.   /* End of Terminate for S-Function (svntcantransmit): '<S1>/CAN Transmit' */
  156. }

        按照上述示例生成的代码，调试时监测到CAN网络上的瞬时负载率非常均匀地保持在25%左右。并且不管报文数量的如何变化，软件都能自动地柔性处理，既不会负载率过高，也不会总线资源浪费，同时又能将报文频率性能发挥到最大。如下图所示：

        分析上述网络通信的特点，已实现了项目中的需求，同时也利用通信负载柔性均衡算法把性能发挥到了最优。

分析和应用

        通信负载均衡，在不同的软件开发项目中重要性是不一样的。一种是实时性要求高的的应用（例如底盘控制），每一帧消息都要在准确的时间发送出去，不允许冲突抢占导致的延误。另一种是网络通信资源非常小的总线（例如低速CAN），单位时间内能发送的报文数量本来就比较少，所以更要仔细计算充分利用，要不然很容易因为负载不均衡导致报文阻塞。

        使用通信负载柔性均衡算法时，需要注意如下几点：

        1、不同波特率，理想负载率下，单位时间对应的报文数量需要仔细的计算，才能设定出最优的算法。例如：500k波特率，在25%理想负载率下，1ms对应的报文数量就是1帧。同理如果1M波特率，那么1ms对应的报文数量就是2帧。

        2、计算好最优的理论算法之后，还要更具自己处理器的性能，设定一个合适的控制粒度。例如：自己的软件最快可以1ms运算一圈，那么就可以1ms控制一次发送1帧或者2帧。如果自己的软件最快只能5ms运算一圈，那么同理就5ms控制一次发送5帧或者10帧。这里的控制粒度越小，负载均衡的效果也越好，但是并非所有的平台都能达到理论极限，只要在自己平台的基础上发挥到最优即可。

        3、对于有网络管理机制的应用场景，需求方可能不希望我们的50ms周期发生变化。例如，网络上的主ECU节点利用同步信号，控制着各个从ECU节点分别占用这50ms中的一小段。当我们自己节点的报文发送完之后，需要等着下一个50ms的到来，或者下一个同步信号的到来。这时候就要把FrameIndex的循环Limit固定成50ms，然后在Transmit模块上加一个使能条件FrameIndex < FrameNum。这样也能达到我们通信负载柔性均衡的目的，同时也满足主ECU节点的网络管理。

总结

        以上就是本人在嵌入式软件开发中处理通信负载率不均衡问题时，一些个人理解和分析的总结，首先介绍了它的背景情况，然后展示它的初始设计和优化设计，最后分析了通信负载均衡算法的注意事项和应用场景。

        后续还会分享另外几个最近总结的软件优化知识点，欢迎评论区留言、点赞、收藏和关注，这些鼓励和支持都将成文本人持续分享的动力。

        另外，上述例程使用的Demo工程，可以到笔者的主页查找和下载。

        版权声明：原创文章，转载和引用请注明出处和链接，侵权必究！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/707172
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号