21ic电子技术开发论坛 › 单片机与嵌入式系统 › DSP 技术 › F28035两轮平衡车系统设计
返回列表 发新帖我要提问

[DSP编程] F28035两轮平衡车系统设计

[复制链接]
626|10
电笔小新 发表于 2025-10-13 16:32 | 显示全部楼层 |阅读模式
系统设计, , f28035, , 两轮
本帖最后由 电笔小新 于 2025-10-13 16:35 编辑

1.设计背景
      设计初心源于去幼儿园参加小孩的家长会，老师让每个家长介绍自己的职业，我介绍自己是一个研发工程师；回家后孩子问我研发工程师是做什么的？我竞不知道怎么跟小孩解释清楚；于是决定给他做个小玩具，小孩全程介入，既能展现一个研发工程师的工作内容，又能将自己这些年学习的零零散散的现成一个闭环，输一个完整作品。具体做什么玩具查找了很多资料，最终决定做一个能够集巡线、避障、遥控的自平衡小车。
2.硬件设计
（1）主控模块：TI DSP28035
选用TI公司的DSP28035作为核心控制器，其关键特性包括：
  · 32位浮点运算单元（FPU），主频高达60MHz，满足实时控制计算需求
  · 集成12位ADC（采样速率最高2MSPS），支持多通道同步采样（用于IMU信号采集）
  · 6路增强型PWM（ePWM）模块，可生成高精度电机驱动信号（频率≥20kHz）
  · 丰富的外设接口（SPI/I2C/CAN/UART），兼容主流IMU传感器与无线通信模块
（2）感知模块：惯性测量单元（IMU）
采用MPU6050六轴传感器（集成三轴陀螺仪与三轴加速度计），通过I2C接口与DSP28035通信。陀螺仪测量角速度（量程±2000°/s，分辨率0.07°/s/LSB），加速度计测量线性加速度（量程±16g，分辨率0.0039g/LSB）。通过互补滤波或卡尔曼滤波融合两类数据，解算车体相对于竖直方向的实时倾角（θ）与角速度（ω）。
（3）避障模块：超声波测距（HC-SR04）
采用HC-SR04超声波测距模块实现前方障碍物检测，该模块通过发射40kHz超声波脉冲并接收反射回波来测量与障碍物间的距离。模块包含**的发射（Trig）与接收（Echo）引脚，通过GPIO口与DSP28035连接：Trig引脚接收至少10μs的高电平触发信号后发射8个40kHz方波脉冲，Echo引脚在检测到回波时输出高电平脉冲，其持续时间与超声波往返时间成正比。
（4）巡线模块：激光扫描
采用8路激光传感器实现地面黑线检测，该模块通过发射红色激光束照射地面，并接收反射光信号来感知黑线位置。对于多路激光传感器方案，传感器阵列沿平衡车前行方向居中布置于车体底部（距离地面约10-20mm），形成"一"字形排列，每路传感器间隔10-15mm。
（5）执行模块：直流无刷电机及驱动电路
选用12V/10W直流无刷电机（带编码器反馈，分辨率≥13线），通过H桥驱动电路实现转速与方向控制。驱动电路采用TB6612FNG全桥驱动芯片，支持PWM调制方式（频率10kHz），输入信号为DSP28035输出的6路ePWM信号（3对互补PWM控制左右电机）。
（6）电源模块
系统供电采用12V三元锂电池组（容量2Ah），通过LM2596稳压芯片生成5V电源（为DSP28035、传感器供电），通过AMS1117-3.3生成3.3V电源（为部分逻辑电路供电）。电源回路包含LC滤波电路（抑制高频噪声）及反接保护二极管（防止电池接反损坏电路）。
（7）人机交互模块
包含OLED显示屏（显示实时倾角、电池电压、电机转速等信息）、独立按键（启动/停止/模式切换）。可选配蓝牙模块（JDY-33）实现与手机APP的无线通信（查看状态/发送控制指令）。
综合上述所有硬件功能，将激光巡线功能单独做成一个PCB板，其他所有电路都集成到F28035主控板；PCBA如下：
电路图如下：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
 楼主| 电笔小新 发表于 2025-10-13 18:16 | 显示全部楼层
4. 模块组装测试


（1）检查PCB是否正常
（2）PCBA焊接
（3）整机组装
（4）底层驱动编写
（5）驱动结果显示
（6）驱动代码



本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

 楼主| 电笔小新 发表于 2025-10-13 22:36 | 显示全部楼层
5. 调试上位机搭建
在两轮平衡车调试过程中，为确保系统稳定与响应精准，需对姿态角度进行滤波处理以抑制噪声干扰，同时通过上位机实时监测与调整各环PID（比例、积分、微分）控制参数，观察其对应波形变化，从而优化控制性能，实现平衡车的精准控制与动态调参。这就必须要用到可以监控数据的上位机，通过实时显示波形数据，反馈调整控制参数。上位机平台选用C#的WindowsForms，之前看视频学习的时候，老师讲过WindowsForms程序是基于事件触发的，能理解这句话的意思，去做WindowsForms上位机就很简单。这里我主要分享基于CAN通信和Uart通信的两个画波形的上位机。
(1) CanScope上位机设计
买CAN盒都会附带二次开发的源文件，直接在源文件上面打开即可进行二次开发。选择上位机开发环境平台C#，打开工程文件。
画波形，选用chart插件，点击工具箱，输入chart，即可找到该插件。
双击进入编程界面，对接收到的can口数据进行处理显示在chart
最终上位机界面如下：
DSP下位机初始化CAN口，输出一个正弦波和余弦波
复制
  1. /******************************************************************************
    

  2.  *    FILENAME : Bsp_Can.c
    

  3.  *
    

  4.  *    PURPOSE  : Can Initialization & Support Functions.
    

  5.  *
    

  6.  *       Author: 电笔小新                      Created on: 2025年9月12日
    

  7. ******************************************************************************/
    

  8. #include "User_Include.h"
    

  9. #include "Bsp_Can.h"
    


  10. 

  11. //=============================================================================
    

  12. // *  Variables & Function_Defines
    

  13. //=============================================================================
    

  14. Uint16  CAN_command0 = 0;
    

  15. Uint16  CAN_command1 = 0;
    


  16. 

  17. CANFRAME CAN_TxBuf;
    

  18. CANFRAME CAN_RxBuf;
    


  19. 

  20. int16 SinTabCnt = 0;
    

  21. int16 CosTabCnt = 100;
    


  22. 

  23. const int16 SinCosTab[400]={
    

  24.     0,   64,  129,  193,  257,  321,  385,  449,  513,  577,
    

  25.   641,  704,  768,  831,  894,  956, 1019, 1081, 1143, 1204,
    

  26.  1266, 1327, 1387, 1448, 1508, 1567, 1627, 1686, 1744, 1802,
    

  27.  1860, 1917, 1973, 2029, 2085, 2140, 2195, 2249, 2302, 2355,
    

  28.  2408, 2459, 2510, 2561, 2611, 2660, 2709, 2757, 2804, 2850,
    

  29.  2896, 2941, 2986, 3030, 3072, 3115, 3156, 3197, 3236, 3276,
    

  30.  3314, 3351, 3388, 3423, 3458, 3492, 3526, 3558, 3589, 3620,
    

  31.  3650, 3678, 3706, 3733, 3759, 3784, 3808, 3832, 3854, 3875,
    

  32.  3896, 3915, 3933, 3951, 3967, 3983, 3997, 4011, 4023, 4035,
    

  33.  4046, 4055, 4064, 4071, 4078, 4083, 4088, 4091, 4094, 4095,
    


  34. 

  35.  4096, 4095, 4094, 4091, 4088, 4083, 4078, 4071, 4064, 4055,
    

  36.  4046, 4035, 4023, 4011, 3997, 3983, 3967, 3951, 3933, 3915,
    

  37.  3896, 3875, 3854, 3832, 3808, 3784, 3759, 3733, 3706, 3678,
    

  38.  3650, 3620, 3589, 3558, 3526, 3492, 3458, 3423, 3388, 3351,
    

  39.  3314, 3276, 3236, 3197, 3156, 3115, 3072, 3030, 2986, 2941,
    

  40.  2896, 2850, 2804, 2757, 2709, 2660, 2611, 2561, 2510, 2459,
    

  41.  2408, 2355, 2302, 2249, 2195, 2140, 2085, 2029, 1973, 1917,
    

  42.  1860, 1802, 1744, 1686, 1627, 1567, 1508, 1448, 1387, 1327,
    

  43.  1266, 1204, 1143, 1081, 1019,  956,  894,  831,  768,  704,
    

  44.   641,  577,  513,  449,  385,  321,  257,  193,  129,   64,
    


  45. 

  46.     0,  -64, -129, -193, -257, -321, -385, -449, -513, -577,
    

  47.  -641, -704, -768, -831, -894, -956,-1019,-1081,-1143,-1204,
    

  48. -1266,-1327,-1387,-1448,-1508,-1567,-1627,-1686,-1744,-1802,
    

  49. -1860,-1917,-1973,-2029,-2085,-2140,-2195,-2249,-2302,-2355,
    

  50. -2408,-2459,-2510,-2561,-2611,-2660,-2709,-2757,-2804,-2850,
    

  51. -2896,-2941,-2986,-3030,-3072,-3115,-3156,-3197,-3236,-3276,
    

  52. -3314,-3351,-3388,-3423,-3458,-3492,-3526,-3558,-3589,-3620,
    

  53. -3650,-3678,-3706,-3733,-3759,-3784,-3808,-3832,-3854,-3875,
    

  54. -3896,-3915,-3933,-3951,-3967,-3983,-3997,-4011,-4023,-4035,
    

  55. -4046,-4055,-4064,-4071,-4078,-4083,-4088,-4091,-4094,-4095,
    


  56. 

  57. -4096,-4095,-4094,-4091,-4088,-4083,-4078,-4071,-4064,-4055,
    

  58. -4046,-4035,-4023,-4011,-3997,-3983,-3967,-3951,-3933,-3915,
    

  59. -3896,-3875,-3854,-3832,-3808,-3784,-3759,-3733,-3706,-3678,
    

  60. -3650,-3620,-3589,-3558,-3526,-3492,-3458,-3423,-3388,-3351,
    

  61. -3314,-3276,-3236,-3197,-3156,-3115,-3072,-3030,-2986,-2941,
    

  62. -2896,-2850,-2804,-2757,-2709,-2660,-2611,-2561,-2510,-2459,
    

  63. -2408,-2355,-2302,-2249,-2195,-2140,-2085,-2029,-1973,-1917,
    

  64. -1860,-1802,-1744,-1686,-1627,-1567,-1508,-1448,-1387,-1327,
    

  65. -1266,-1204,-1143,-1081,-1019, -956, -894, -831, -768, -704,
    

  66.  -641, -577, -513, -449, -385, -321, -257, -193, -129,  -64,
    


  67. 

  68. };
    


  69. 

  70. //=============================================================================
    

  71. // *  FUNCTION:  SetGpio_Cana()
    

  72. // *
    

  73. // *  PURPOSE :  Initializes the GPIOs for CANa.
    

  74. //=============================================================================
    

  75. //CAN的GPIO初始化
    

  76. //这里采用GPIO30 GPIO31
    

  77. //--------------------------------------------------------------------
    

  78. void SetGpio_Cana(void)
    

  79. {
    

  80.    EALLOW;
    

  81.     GpioCtrlRegs.GPAPUD.bit.GPIO30 = 0;     // Enable pull-up for GPIO30 (CANRXA)
    

  82.     GpioCtrlRegs.GPAPUD.bit.GPIO31 = 0;     // Enable pull-up for GPIO31 (CANTXA)
    


  83. 

  84.     GpioCtrlRegs.GPAQSEL2.bit.GPIO30 = 3;   // Asynch qual for GPIO30 (CANRXA)
    


  85. 

  86.     //IO30 IO21配置为CAN外设引脚
    

  87.     GpioCtrlRegs.GPAMUX2.bit.GPIO30 = 1;    // Configure GPIO30 for CANRXA operation
    

  88.     GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 1;    // Configure GPIO31 for CANTXA operation
    


  89. 

  90.     EDIS;
    

  91. }
    


  92. 

  93. //=============================================================================
    

  94. // *  FUNCTION:  SetERegs_Cana()
    

  95. // *
    

  96. // *  PURPOSE :  Initializes the Registers for CANa.
    

  97. //=============================================================================
    

  98. void SetERegs_Cana(void)        // Initialize eCAN-A module
    

  99. {
    


  100. 

  101. /* Create a shadow register structure for the CAN control registers. This is
    

  102.  needed, since only 32-bit access is allowed to these registers. 16-bit access
    

  103.  to these registers could potentially corrupt the register contents or return
    

  104.  false data. */
    


  105. 

  106. struct ECAN_REGS ECanaShadow;
    


  107. 

  108.     EALLOW;     // EALLOW enables access to protected bits
    


  109. 

  110. /* Configure eCAN RX and TX pins for CAN operation using eCAN regs*/
    


  111. 

  112.     ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
    

  113.     ECanaShadow.CANTIOC.bit.TXFUNC = 1;
    

  114.     ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;
    


  115. 

  116.     ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
    

  117.     ECanaShadow.CANRIOC.bit.RXFUNC = 1;
    

  118.     ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;
    


  119. 

  120. /* Configure eCAN for HECC mode - (reqd to access mailboxes 16 thru 31) */
    

  121.                                     // HECC mode also enables time-stamping feature
    


  122. 

  123.     ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    

  124.     ECanaShadow.CANMC.bit.SCB = 1;               //P35  Select eCAN mode.
    

  125.     ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
    


  126. 

  127. /* Initialize all bits of 'Message Control Register' to zero */
    

  128. // Some bits of MSGCTRL register come up in an unknown state. For proper operation,
    

  129. // all bits (including reserved bits) of MSGCTRL must be initialized to zero
    


  130. 

  131.     ECanaMboxes.MBOX0.MSGCTRL.all = 0x00000000;
    

  132.     ECanaMboxes.MBOX1.MSGCTRL.all = 0x00000000;
    

  133.     ECanaMboxes.MBOX2.MSGCTRL.all = 0x00000000;
    

  134.     ECanaMboxes.MBOX3.MSGCTRL.all = 0x00000000;
    

  135.     ECanaMboxes.MBOX4.MSGCTRL.all = 0x00000000;
    

  136.     ECanaMboxes.MBOX5.MSGCTRL.all = 0x00000000;
    

  137.     ECanaMboxes.MBOX6.MSGCTRL.all = 0x00000000;
    

  138.     ECanaMboxes.MBOX7.MSGCTRL.all = 0x00000000;
    

  139.     ECanaMboxes.MBOX8.MSGCTRL.all = 0x00000000;
    

  140.     ECanaMboxes.MBOX9.MSGCTRL.all = 0x00000000;
    

  141.     ECanaMboxes.MBOX10.MSGCTRL.all = 0x00000000;
    

  142.     ECanaMboxes.MBOX11.MSGCTRL.all = 0x00000000;
    

  143.     ECanaMboxes.MBOX12.MSGCTRL.all = 0x00000000;
    

  144.     ECanaMboxes.MBOX13.MSGCTRL.all = 0x00000000;
    

  145.     ECanaMboxes.MBOX14.MSGCTRL.all = 0x00000000;
    

  146.     ECanaMboxes.MBOX15.MSGCTRL.all = 0x00000000;
    

  147.     ECanaMboxes.MBOX16.MSGCTRL.all = 0x00000000;
    

  148.     ECanaMboxes.MBOX17.MSGCTRL.all = 0x00000000;
    

  149.     ECanaMboxes.MBOX18.MSGCTRL.all = 0x00000000;
    

  150.     ECanaMboxes.MBOX19.MSGCTRL.all = 0x00000000;
    

  151.     ECanaMboxes.MBOX20.MSGCTRL.all = 0x00000000;
    

  152.     ECanaMboxes.MBOX21.MSGCTRL.all = 0x00000000;
    

  153.     ECanaMboxes.MBOX22.MSGCTRL.all = 0x00000000;
    

  154.     ECanaMboxes.MBOX23.MSGCTRL.all = 0x00000000;
    

  155.     ECanaMboxes.MBOX24.MSGCTRL.all = 0x00000000;
    

  156.     ECanaMboxes.MBOX25.MSGCTRL.all = 0x00000000;
    

  157.     ECanaMboxes.MBOX26.MSGCTRL.all = 0x00000000;
    

  158.     ECanaMboxes.MBOX27.MSGCTRL.all = 0x00000000;
    

  159.     ECanaMboxes.MBOX28.MSGCTRL.all = 0x00000000;
    

  160.     ECanaMboxes.MBOX29.MSGCTRL.all = 0x00000000;
    

  161.     ECanaMboxes.MBOX30.MSGCTRL.all = 0x00000000;
    

  162.     ECanaMboxes.MBOX31.MSGCTRL.all = 0x00000000;
    


  163. 

  164. // TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
    

  165. //  as a matter of precaution.
    

  166.     ECanaRegs.CANTA.all = 0xFFFFFFFF;   /* Clear all TAn bits */
    

  167.     ECanaRegs.CANRMP.all = 0xFFFFFFFF;  /* Clear all RMPn bits */
    

  168.     ECanaRegs.CANGIF0.all = 0xFFFFFFFF; /* Clear all interrupt flag bits */
    

  169.     ECanaRegs.CANGIF1.all = 0xFFFFFFFF;
    


  170. 

  171. /* Configure bit timing parameters for eCANA*/
    

  172.     ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    

  173.     ECanaShadow.CANMC.bit.CCR = 1 ;            // Set CCR = 1
    

  174.     ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
    


  175. 

  176.     // Wait until the CPU has been granted permission to change the configuration registers
    

  177.     do
    

  178.     {
    

  179.       ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    

  180.     } while(ECanaShadow.CANES.bit.CCE != 1 );       // Wait for CCE bit to be set..
    


  181. 

  182.     ECanaShadow.CANBTC.all = 0;
    


  183. 

  184.     //-------------------------自定义的配置------------------------------------------
    

  185.     //P47
    

  186.     /* The following block is only for 60 MHz SYSCLKOUT. (30 MHz CAN module clock Bit rate = 1 Mbps
    

  187.        See Note at end of file. */
    

  188.     //rate Bit =(SYSCLKOUT/2)/(BRP * Bit-time )
    

  189.     //BRP = BRPreg+1
    

  190.     //Bit-time = (TSEG1reg + 1) + (TSEG2reg+ 1) + 1
    

  191.     //配置TQ 和BRP ，
    

  192.     //方案一 TQ为10， 则TSEG1REG = 6， BRP = 5 ，为500K
    

  193.     //方案二，TQ为12，则TSEG1REG = 8， BRP = 4 ，为500K
    

  194.     //500KHz
    

  195.     ECanaShadow.CANBTC.bit.BRPREG = 5;
    

  196.     ECanaShadow.CANBTC.bit.TSEG2REG = 1;
    

  197.     ECanaShadow.CANBTC.bit.TSEG1REG = 6;
    

  198.     ECanaShadow.CANBTC.bit.SAM = 1;
    

  199.     ECanaRegs.CANBTC.all = ECanaShadow.CANBTC.all;
    


  200. 

  201.     ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    

  202.     ECanaShadow.CANMC.bit.CCR = 0;    // Set CCR = 0
    

  203.     ECanaShadow.CANMC.bit.STM = 0;    // 0: normal mode/1: self-test mode
    

  204.     ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
    


  205. 


  206. 


  207. 

  208.     // Wait until the CPU no longer has permission to change the configuration registers
    

  209.     do
    

  210.     {
    

  211.       ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    

  212.     } while(ECanaShadow.CANES.bit.CCE != 0 );       // Wait for CCE bit to be  cleared..
    


  213. 

  214. /* Disable all Mailboxes  */
    

  215.     ECanaRegs.CANME.all = 0;        // Required before writing the MSGIDs
    


  216. 

  217.     EDIS;
    

  218. }
    


  219. 

  220. /**********************************************************************
    

  221. * FUNCION :   SetMailbox_Cana()
    

  222. * PURPOSE :   Initializes the Mailboxes for Can.
    

  223. //-----------------------------------------------
    

  224. //配置发送、接收邮箱等操作
    

  225. //数据区8个长度字节
    

  226. //发送邮箱   1到6
    

  227. //接收邮箱   16， ID为0x0A
    

  228. //-----------------------------------------------
    

  229. **********************************************************************/
    

  230. void SetMailbox_Cana(void)
    

  231. {
    

  232.    struct ECAN_REGS ECanaShadow;
    


  233. 

  234.    EALLOW;
    

  235.     ECanaShadow.CANGAM.all = ECanaRegs.CANGAM.all;
    

  236.     ECanaShadow.CANGAM.bit.AMI=1;            // Standard and extended frames can be received.
    

  237.     ECanaRegs.CANGAM.all = ECanaShadow.CANGAM.all;
    

  238.    EDIS;
    


  239. 

  240. //P59
    

  241. //In standard identifier mode,if the IDE bit(MSGID.31) =0,the message identifier is storedin bits ID.28:18.
    

  242. //IDE =0:The RECEIVED message had a standard identifier
    

  243. //Auto answer mode bit. AAM =0 ;  Normal transmit mode
    

  244. //AME = 1 ;The corresponding acceptance mask is used
    


  245. 

  246. //MSGID.31=IDE; MSGID.30=AME; MSGID.29=AAM
    

  247. // Mailboxs can be written to 16-bits or 32-bits at a time
    


  248. 

  249.    // Mailboxes can be written to 16-bits or 32-bits at a time
    

  250.       // Write to the MSGID field of TRANSMIT mailboxes MBOX0 - 15
    

  251.       ECanaMboxes.MBOX0.MSGID.all = ( (TXCanId0_Std|0x10000000)<<18); // stand Identifier
    

  252.       ECanaMboxes.MBOX1.MSGID.all = ( (TXCanId1_Std|0x10000000)<<18); // stand Identifier
    


  253. 

  254.       // Write to the MSGID field of RECEIVE mailboxes MBOX16 - 31
    

  255.       ECanaMboxes.MBOX16.MSGID.all = ((RXCanId0_Std|0x10000000)<<18); // stand Identifier
    

  256.       ECanaMboxes.MBOX17.MSGID.all = ((RXCanId1_Std|0x10000000)<<18); // stand Identifier
    


  257. 

  258.       // Configure Mailboxes 0-15 as Tx, 16-31 as Rx
    

  259.       // Since this write is to the entire register (instead of a bit
    

  260.       // field) a shadow register is not required.
    

  261.       ECanaRegs.CANMD.all = 0xFFFF0000;
    


  262. 

  263.     // Specify that 8 bits will be sent/received //8字节数据
    

  264.       ECanaMboxes.MBOX0.MSGCTRL.bit.DLC  = 8;
    

  265.       ECanaMboxes.MBOX1.MSGCTRL.bit.DLC  = 8;
    


  266. 

  267. ////////////////////////////////////////////////////////////////////////////////////
    

  268.     EALLOW;
    

  269.     ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    

  270.     ECanaShadow.CANMC.bit.DBO = 1;
    

  271.     ECanaShadow.CANMC.bit.SCB = 1;//Select eCAN mode
    

  272.     ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
    


  273. 

  274.     // Configure Mailboxes 0-15 as Tx, 16-31 as Rx
    

  275.     ECanaRegs.CANMD.all = 0xFFFF0000;
    


  276. 

  277.     // Since this write is to the entire register (instead of a bit
    

  278.     // field) a shadow register is not required.
    

  279.     ECanaRegs.CANME.all = 0x00030003;
    

  280.     EDIS;
    

  281. }
    


  282. 


  283. 


  284. 


  285. 

  286. //=============================================================================
    

  287. // *  FUNCTION:  SetInterrupt_Cana()
    

  288. // *
    

  289. // *  PURPOSE :  Initializes the ISR for CANa.
    

  290. //=============================================================================
    

  291. void SetInterrupt_Cana(void)
    

  292. {
    

  293. /* Create a shadow register structure for the CAN control registers. This is
    

  294.  needed, since only 32-bit access is allowed to these registers. 16-bit access
    

  295.  to these registers could potentially corrupt the register contents or return
    

  296.  false data. */
    

  297.     struct ECAN_REGS ECanaShadow;
    


  298. 


  299. 

  300.     EALLOW;     // EALLOW enables access to protected bits
    

  301.     ECanaShadow.CANMIL.all = ECanaRegs.CANMIL.all;
    

  302.     ECanaShadow.CANMIL.all = 0xFFFFFFFF ;            //P76, mailbox interrupts to level 1
    

  303.     ECanaRegs.CANMIL.all = ECanaShadow.CANMIL.all;
    


  304. 


  305. 

  306.     ECanaShadow.CANMIM.all = ECanaRegs.CANMIM.all;
    

  307.     ECanaShadow.CANMIM.all =0x00010000 ;            //P48,相应的邮箱中断使能位 Mailbox interrupt is enabled.
    

  308.     ECanaRegs.CANMIM.all = ECanaShadow.CANMIM.all;
    


  309. 

  310.     //1-32号邮箱中断在中断线0上产生
    

  311.     ECanaShadow.CANMIL.all = ECanaRegs.CANMIL.all;
    

  312.     ECanaShadow.CANMIL.all = 0;
    

  313.     ECanaRegs.CANMIL.all = ECanaShadow.CANMIL.all;
    


  314. 


  315. 

  316.     //------------中断配置步骤-----1
    

  317.     //中断线0使能
    

  318.     ECanaShadow.CANGIM.all = ECanaRegs.CANGIM.all;
    

  319.     ECanaShadow.CANGIM.bit.I0EN = 1;
    

  320. //    ECanaShadow.CANGIM.bit.I1EN = 1;
    

  321.     ECanaRegs.CANGIM.all = ECanaShadow.CANGIM.all;
    


  322. 


  323. 

  324. // TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
    

  325. //  as a matter of precaution.
    


  326. 

  327.     ECanaRegs.CANTA.all   = 0xFFFFFFFF;   /* Clear all TAn bits */
    

  328.     ECanaRegs.CANRMP.all  = 0xFFFFFFFF;  /* Clear all RMPn bits */
    

  329.     ECanaRegs.CANGIF0.all = 0xFFFFFFFF; /* Clear all interrupt flag bits */
    

  330.     ECanaRegs.CANGIF1.all = 0xFFFFFFFF;
    


  331. 

  332. //------------中断配置步骤-----3
    

  333. // Enable CAN in PIE
    

  334.    PieCtrlRegs.PIEIER9.bit.INTx5 = 1;      // Enable INT 9.5 in the PIE
    

  335. //   PieCtrlRegs.PIEIER9.bit.INTx6 = 1;      // Enable INT 9.6 in the PIE
    


  336. 

  337. //------------中断配置步骤-----4
    

  338.    IER |= M_INT9;                          // Enable CPU Interrupt 9
    


  339. 

  340.    EINT;
    

  341.    ERTM;
    

  342.    EDIS;
    


  343. 

  344. }
    


  345. 

  346. //=============================================================================
    

  347. // *  FUNCTION:  InitCana()
    

  348. // *
    

  349. // *  PURPOSE :   Initializes the Enhanced Can modules.
    

  350. //=============================================================================
    

  351. void InitCana(void)
    

  352. {
    


  353. 

  354.     SetGpio_Cana();
    

  355.     SetERegs_Cana();
    

  356.     SetMailbox_Cana();
    

  357.     SetInterrupt_Cana();
    

  358. }
    


  359. 


  360. 

  361. //=============================================================================
    

  362. // *  FUNCTION:  sCanHdRead()
    

  363. // *
    

  364. // *  PURPOSE :   Read Can Data From Registers And Save Into Buffer.
    

  365. //=============================================================================
    

  366. void sCanHdRead(const Uint8 ubMailBox,CANFRAME *pdata)
    

  367. {
    

  368.     volatile struct MBOX *pMailbox;
    


  369. 

  370.     pMailbox = &ECanaMboxes.MBOX0 + ubMailBox;
    


  371. 

  372.     pdata->CanId.all = pMailbox->MSGID.all;
    

  373.     pdata->CanData0 = pMailbox->MDL.word.LOW_WORD;
    

  374.     pdata->CanData1 = pMailbox->MDL.word.HI_WORD;
    

  375.     pdata->CanData2 = pMailbox->MDH.word.LOW_WORD;
    

  376.     pdata->CanData3 = pMailbox->MDH.word.HI_WORD;
    

  377. }
    


  378. 

  379. //=============================================================================
    

  380. // *  FUNCTION:  sCanHdSend()
    

  381. // *
    

  382. // *  PURPOSE :  Write Can Data Into Registers And Send.
    

  383. //=============================================================================
    

  384. void sCanHdSend(const Uint8 ubMailBox,const CANFRAME *pdata)
    

  385. {
    

  386.     struct ECAN_REGS ECanShadow;
    

  387.     volatile struct MBOX *pMailbox;
    


  388. 

  389.     pMailbox = &ECanaMboxes.MBOX0 + ubMailBox;
    


  390. 

  391.     /*step3: Load the message to the MSGID Registers of the object*/
    

  392.     pMailbox->MSGID.all= pdata->CanId.all;
    


  393. 

  394.     /*step4: configure the data length*/
    

  395.     pMailbox->MSGCTRL.bit.DLC = 8;
    


  396. 


  397. 

  398.     /*step5: Write the message data to the mail box data field*/
    

  399.     pMailbox->MDL.word.LOW_WORD = pdata->CanData0;
    

  400.     pMailbox->MDL.word.HI_WORD = pdata->CanData1;
    

  401.     pMailbox->MDH.word.LOW_WORD = pdata->CanData2;
    

  402.     pMailbox->MDH.word.HI_WORD = pdata->CanData3;
    


  403. 

  404.     /* Enable transmit mailbox*/
    

  405.     ECanShadow.CANME.all = ECanaRegs.CANME.all;
    

  406.     ECanShadow.CANME.all |= ((Uint32)1 << ubMailBox);
    

  407.     ECanaRegs.CANME.all = ECanShadow.CANME.all;
    


  408. 

  409.     ECanShadow.CANTRS.all=0;
    

  410.     ECanShadow.CANTRS.all|= ((Uint32)1 << ubMailBox);
    

  411.     ECanaRegs.CANTRS.all= ECanShadow.CANTRS.all;
    


  412. 

  413.     ECanShadow.CANTA.all = 0;
    

  414.     ECanShadow.CANTA.all |= ((Uint32)1 << ubMailBox);  // Clear all TAn
    

  415.     ECanaRegs.CANTA.all=ECanShadow.CANTA.all;
    


  416. 

  417. }
    


  418. 

  419. //---------------------------------------------------------------------------
    

  420. // Can_Task:
    

  421. //---------------------------------------------------------------------------
    

  422. void Can_Task(void)
    

  423. {
    

  424.    SinTabCnt++;
    

  425.    if(SinTabCnt>399)
    

  426.     {
    

  427.        SinTabCnt=0;
    

  428.     }
    

  429.    CosTabCnt++;
    

  430.    if(CosTabCnt>399)
    

  431.     {
    

  432.        CosTabCnt=0;
    

  433.     }
    

  434.    CAN_TxBuf.CanId.all = ((TXCanId0_Std|0x10000000)<<18); // stand Identifier
    

  435.    CAN_TxBuf.CanData0 = SinCosTab[SinTabCnt];
    

  436.    CAN_TxBuf.CanData1 = SinCosTab[CosTabCnt];
    

  437.    CAN_TxBuf.CanData2 = 0x5432;
    

  438.    CAN_TxBuf.CanData3 = 0x9876;
    

  439.    sCanHdSend(0,&CAN_TxBuf);
    


  440. 


  441. 

  442. }
    


  443. 


  444. 

  445. //---------------------------------------------------------------------------
    

  446. // INT_ISR for Ecana_RX
    

  447. //---------------------------------------------------------------------------
    

  448. //// INT9.5
    

  449. interrupt void ECAN0INTA_ISR(void)  // eCAN-A
    

  450. {
    


  451. 

  452.     struct ECAN_REGS ECanaShadow;
    

  453.     // Insert ISR Code here
    

  454.     ECanaShadow.CANRMP.all=ECanaRegs.CANRMP.all;
    

  455.     if(ECanaShadow.CANRMP.bit.RMP16==1)
    

  456.     {
    

  457.         ECanaShadow.CANRMP.bit.RMP16=1;
    

  458.         ECanaRegs.CANRMP.all=ECanaShadow.CANRMP.all;
    

  459.         sCanHdRead(16,&CAN_RxBuf);
    


  460. 


  461. 

  462.     }
    


  463. 

  464.     PieCtrlRegs.PIEACK.all = PIEACK_GROUP9;     // Must acknowledge the PIE group
    

  465. }
    


  466. 

  467. //=============================================================================
    

  468. // End of file.
    

  469. //=============================================================================
下位机跟上位机波形传输联调如下：

上位机安装包和CAN驱动代码：


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

中国英茂科工 发表于 2025-10-14 05:52 | 显示全部楼层
牛啊牛，我在做Arduino的
回复

收藏 举报

dirtwillfly 发表于 2025-10-14 08:17 | 显示全部楼层
CAN调试我习惯用TSMaster
回复

收藏 举报

asdsfgwsafd 发表于 2025-10-14 09:11 | 显示全部楼层
教应届生都不敢拿这个上手，老哥你直接给幼儿园的灌
回复

收藏 举报

 楼主| 电笔小新 发表于 2025-10-14 12:09 | 显示全部楼层
电笔小新 发表于 2025-10-13 22:36
5. 调试上位机搭建在两轮平衡车调试过程中，为确保系统稳定与响应精准，需对姿态角度进行滤波处理以抑制噪 ...

(2) UartScope上位机设计
串口上位机使用的是虚拟示波器，网上直接找到的，个人感觉还是非常的好用。
DSP下位机函数接口代码
复制
  1. /******************************************************************************
    

  2.  *    FILENAME : User_IPMOS.c
    

  3.  *
    

  4.  *    PURPOSE  : Interface of software oscilloscope
    

  5.  *
    

  6.  *       Author: 电笔小新                      Created on: 2025年9月12日
    

  7. ******************************************************************************/
    

  8. #include "User_Include.h"
    

  9. #include "User_IPMOS.h"
    


  10. 

  11. //=============================================================================
    

  12. // *  Variables & Function_Defines
    

  13. //=============================================================================
    


  14. 

  15. Uint8   wScopeSelect=10;
    

  16. int16   uwScope[30];
    


  17. 

  18. typedef int (*pFunc1)(void);
    


  19. 

  20. extern Uint16 LinaWrite( Uint8 *pBuf, Uint16 u16Length);
    

  21. extern Uint16 SciWrite(Uint16 SciId, Uint8 *pBuf, Uint16 u16Length);
    

  22. /******************************variable definition******************************/
    


  23. 

  24. Uint16  u16IPOMS_GraphDataBuff[4][400];
    

  25. Uint16  u16IPOMS_TransmitDataBuff[500];
    


  26. 

  27. Uint16  u16IPOMS_CommandLength  = 0;
    

  28. Uint16  u16IPOMS_Interval       = 0;
    

  29. Uint16  u16IPOMS_Interval1      = 0;
    

  30. Uint16  u16IPOMS_SnatchDataCnt  = 0;
    

  31. Uint16  u16IPOMS_SaveDataCnt    = 0;
    

  32. Uint16  u16IPOMS_TransmitCnt    = 0;
    

  33. Uint16  u16IPOMS_CompareVal     = 0;
    

  34. Uint8   *pIPOMS_CommandIn0;
    


  35. 

  36. Uint8   u8IPOMS_UserDataBuf0[80];
    

  37. Uint8   u8IPOMS_CommandBuffer0[50];
    

  38. Uint8   u8IPOMS_RxBuffer0[50];
    


  39. 

  40. Uint8   u8IPOMS_DataKind[4]     = {0,0,0,0};
    

  41. Uint8   u8IPOMS_SnatchGraphEnable= 1;
    

  42. Uint8   u8IPOMS_SendHighHalfByte = 1;
    

  43. Uint8   u8IPOMS_wTriggerSource  = 0;
    

  44. Uint8   u8IPOMS_wTrigger        = 0;
    

  45. Uint8   u8IPOMS_HighByte        = 0;
    

  46. Uint8   u8IPOMS_LowByte         = 0;
    

  47. Uint8   u8IPOMS_Sign            = 0;
    


  48. 

  49. Uint16 wTriggerWaiting = 0;
    


  50. 


  51. 

  52. /******************************function list******************************/
    

  53. Uint8 IPOMS_SnatchGraph(void);
    

  54. void  IPOMS_SCI(void);
    

  55. Uint8  IPOMS_Write(Uint16 SciId, Uint8 *pBuf, Uint16 u16Length);
    


  56. 

  57. void FlashProgramming(void);
    

  58. void  IPOMS_Parsing(void);
    


  59. 


  60. 

  61. void  IPOMS_Q1Command(void);
    

  62. void  IPOMS_Q2Command(void);
    

  63. void  IPOMS_Q3Command(void);
    

  64. void  IPOMS_QDCommand(void);
    


  65. 

  66. int16 IPOMS_GraphicView_0(void);
    

  67. int16 IPOMS_GraphicView_1(void);
    

  68. int16 IPOMS_GraphicView_2(void);
    

  69. int16 IPOMS_GraphicView_3(void);
    

  70. int16 IPOMS_GraphicView_4(void);
    

  71. int16 IPOMS_GraphicView_5(void);
    

  72. int16 IPOMS_GraphicView_6(void);
    

  73. int16 IPOMS_GraphicView_7(void);
    

  74. int16 IPOMS_GraphicView_8(void);
    

  75. int16 IPOMS_GraphicView_9(void);
    

  76. int16 IPOMS_GraphicView_10(void);
    


  77. 

  78. Uint8 sbNumToAscii(Uint16 u16Number, int8 i8Exponent, Uint8 *pbBuffer);
    

  79. void IPOMS_WriteBinary(Uint16 *pstart, Uint16 u16Length);
    


  80. 


  81. 

  82. /******************************function list******************************/
    

  83. pFunc1 GetDataSubArray[] =
    

  84. {
    


  85. 

  86.  IPOMS_GraphicView_0,  // Note: Don't set "Channel x ID" to 0 in "Graphic View"
    

  87.                        // in IPOMS. 0 is invalid.
    


  88. 

  89.  IPOMS_GraphicView_1,  // 1- is the number set to "Channelx ID"
    

  90.  IPOMS_GraphicView_2,
    

  91.  IPOMS_GraphicView_3,
    

  92.  IPOMS_GraphicView_4,
    

  93.  IPOMS_GraphicView_5,
    

  94.  IPOMS_GraphicView_6,
    

  95.  IPOMS_GraphicView_7,
    

  96.  IPOMS_GraphicView_8,
    

  97.  IPOMS_GraphicView_9,
    

  98.  IPOMS_GraphicView_10,
    

  99. };
    


  100. 


  101. 

  102. //=============================================================================
    

  103. // *  FUNCTION:  IPOMS_Write()
    

  104. // *
    

  105. // *  PURPOSE :  Use IPOMS to Write data.
    

  106. //=============================================================================
    

  107. Uint8 IPOMS_Write(Uint16 SciId, Uint8 *pBuf, Uint16 u16Length)
    

  108. {
    

  109.     Uint8 u8IPOMS_temp;
    

  110.     switch(SciId)
    

  111.         {
    

  112.             case ID_SCIA:
    

  113.                  u8IPOMS_temp=SciWrite(ID_SCIA, pBuf,u16Length);
    

  114.             break;
    


  115. 

  116.             case ID_LINA:
    

  117.                  u8IPOMS_temp=LinaWrite(pBuf,u16Length);
    

  118.             break;
    


  119. 

  120.             default:
    

  121.                 u8IPOMS_temp=1;
    

  122.                break;
    

  123.         }
    


  124. 

  125.         return u8IPOMS_temp;
    

  126. }
    


  127. 


  128. 

  129. //=============================================================================
    

  130. // *  FUNCTION:  SCI_IPOMS()
    

  131. // *
    

  132. // *  PURPOSE :  Software OSC for debug.
    

  133. //=============================================================================
    

  134. void IPOMS_SCI(void)
    

  135. {
    

  136.     Uint8 u8IPOMS_temp;
    

  137.     while(1)
    

  138.     {
    

  139.         u8IPOMS_temp = SciRead(ID_IPOMS, pIPOMS_CommandIn0);
    


  140. 

  141.         if(SCI_RX_EMPTY == u8IPOMS_temp)
    

  142.         {
    

  143.             break;
    

  144.         }
    

  145.         if(u16IPOMS_CommandLength >= con_MAX_COMMAND_LENGTH)
    

  146.         {
    

  147.             pIPOMS_CommandIn0 = u8IPOMS_CommandBuffer0;
    

  148.             u16IPOMS_CommandLength = 0;
    

  149.         }
    

  150.         else if(0xDD == (*pIPOMS_CommandIn0))
    

  151.         {
    

  152.             FlashProgramming();
    

  153.             pIPOMS_CommandIn0 = u8IPOMS_CommandBuffer0;
    

  154.             u16IPOMS_CommandLength = 0;
    

  155.         }
    

  156.         else if((con_CHAR_ENTER == (*pIPOMS_CommandIn0)) || (0x0A == (*pIPOMS_CommandIn0)))  //Deal with command with 0x0a
    

  157.         {
    

  158.             IPOMS_Parsing();
    

  159.             pIPOMS_CommandIn0 = u8IPOMS_CommandBuffer0;
    

  160.             u16IPOMS_CommandLength = 0;
    

  161.         }
    

  162.         else
    

  163.         {
    

  164.             u16IPOMS_CommandLength++;
    

  165.             pIPOMS_CommandIn0++;
    

  166.         }
    

  167.     }
    

  168. }
    


  169. 

  170. //=============================================================================
    

  171. // *  FUNCTION:  FlashProgramming()
    

  172. // *
    

  173. // *  PURPOSE :  Online update User Code.
    

  174. //=============================================================================
    

  175. void FlashProgramming(void)
    

  176. {
    

  177.     if((u8IPOMS_CommandBuffer0[1] == 0x1A)&(u8IPOMS_CommandBuffer0[2] == 0x2A))
    

  178.     {
    

  179. /*------------------------------------------------------------------
    

  180.    Disable CPU interrupts and clear all CPU interrupt flags.
    

  181. ------------------------------------------------------------------*/
    

  182.         DINT;
    

  183.         DRTM;
    

  184.         IER = 0x0000;
    

  185.         IFR = 0x0000;
    


  186. 

  187. /*------------------------------------------------------------------
    

  188.  Jump to BootLoader.
    

  189. ------------------------------------------------------------------*/
    

  190.         asm("  LB  0x3F7FF6");
    

  191.     }
    


  192. 

  193. }
    


  194. 

  195. /*=============================================================================*
    

  196.  * FUNCTION: IPOMS_Parsing(void)
    

  197.  * PURPOSE : IPOMS Command Parse
    

  198.  * INPUT:
    

  199.  *     void
    

  200.  *
    

  201.  * RETURN:
    

  202.  *     void
    

  203.  *
    

  204.  * CALLS:
    

  205.  *     IPOMS_Q1Command();
    

  206.  *     IPOMS_Q3Command();
    

  207.  *     IPOMS_QDCommand();
    

  208.  *
    

  209.  * CALLED BY:
    

  210.  *     TSK_F_IPOMS()
    

  211.  *
    

  212.  *============================================================================*/
    

  213. void IPOMS_Parsing(void)
    

  214. {
    


  215. 

  216.     switch(u8IPOMS_CommandBuffer0[0])
    

  217.     {
    

  218.     case 'Q':
    

  219.         {
    


  220. 

  221.             if('1' == u8IPOMS_CommandBuffer0[1])
    

  222.             {
    

  223.                 IPOMS_Q1Command();
    

  224.             }
    

  225.              if('2' == u8IPOMS_CommandBuffer0[1])
    

  226.             {
    

  227.                 IPOMS_Q2Command();
    

  228.             }
    

  229.             if('3' == u8IPOMS_CommandBuffer0[1])
    

  230.             {
    

  231.                 IPOMS_Q3Command();
    

  232.             }
    

  233.             if('D' == u8IPOMS_CommandBuffer0[1])
    

  234.             {
    

  235.                 IPOMS_QDCommand();
    

  236.             }
    

  237.         }
    

  238.     break;
    

  239.     default:
    

  240.     break;
    

  241.     }
    

  242. }
    

  243. /*=============================================================================*
    

  244.  * FUNCTION: IPOMS_Q1Command(void)
    

  245.  * PURPOSE : Send Data to IPOMS For Q1 Command
    

  246.  * INPUT:
    

  247.  *     void  // TRUE:disable the dog锟斤拷FALSE:enable the dog
    

  248.  *
    

  249.  * RETURN:
    

  250.  *     void
    

  251.  *
    

  252.  * CALLS:
    

  253.  *     //sbNumToAscii();
    

  254.  *     //IPOMS_Write();
    

  255.  *
    

  256.  *
    

  257.  *
    

  258.  * CALLED BY:
    

  259.  *   //  INT32 IPOMS_Parsing()
    

  260.  *
    

  261.  *============================================================================*/
    

  262.     void IPOMS_Q1Command(void)
    

  263.     {
    

  264.         Uint8   bStrLen;
    

  265.         Uint8   bStrLen1;
    

  266.         Uint8   *pDataBuf;
    


  267. 

  268.         bStrLen1 = 0;
    

  269.         bStrLen = 0;
    


  270. 

  271.         bStrLen = sbNumToAscii(0, 0, u8IPOMS_UserDataBuf0);//0
    

  272.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  273. 

  274.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  275.         bStrLen1 = sbNumToAscii(uwScope[1], 0, pDataBuf); //1//
    

  276.         bStrLen += bStrLen1;
    

  277.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  278. 

  279.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  280.         bStrLen1 = sbNumToAscii(uwScope[2], 0, pDataBuf); //2//
    

  281.         bStrLen += bStrLen1;
    

  282.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  283. 

  284.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  285.         bStrLen1 = sbNumToAscii(uwScope[3], 0, pDataBuf);  //3//
    

  286.         bStrLen += bStrLen1;
    

  287.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  288. 

  289.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  290.         bStrLen1 = sbNumToAscii(uwScope[4], 0, pDataBuf);  //4//
    

  291.         bStrLen += bStrLen1;
    

  292.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  293. 

  294.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  295.         bStrLen1 = sbNumToAscii(uwScope[5], 0, pDataBuf);  //5//
    

  296.         bStrLen += bStrLen1;
    

  297.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  298. 

  299.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  300.         bStrLen1 = sbNumToAscii(uwScope[6], 0, pDataBuf);  //6//
    

  301.         bStrLen += bStrLen1;
    

  302.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  303. 

  304.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  305.         bStrLen1 = sbNumToAscii(uwScope[7], 0, pDataBuf);  //7//
    

  306.         bStrLen += bStrLen1;
    

  307.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  308. 

  309.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  310.         bStrLen1 = sbNumToAscii(uwScope[8], 0, pDataBuf);  //8//
    

  311.         bStrLen += bStrLen1;
    

  312.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  313. 

  314.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  315.         bStrLen1 = sbNumToAscii(uwScope[9], 0, pDataBuf);  //9//
    

  316.         bStrLen += bStrLen1;
    

  317.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  318. 

  319.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  320.         bStrLen1 = sbNumToAscii(10, 0, pDataBuf);    //10//
    

  321.         bStrLen += bStrLen1;
    

  322.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  323. 

  324.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  325.         bStrLen1 = sbNumToAscii(11, 0, pDataBuf);    //11//
    

  326.         bStrLen += bStrLen1;
    

  327.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  328. 


  329. 

  330.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  331.         bStrLen1 = sbNumToAscii(12, 0, pDataBuf);    //12//
    

  332.         bStrLen += bStrLen1;
    

  333.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  334. 

  335.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  336.         bStrLen1 = sbNumToAscii(13, 0, pDataBuf);    //13//
    

  337.         bStrLen += bStrLen1;
    

  338.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  339. 

  340.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  341.         bStrLen1 = sbNumToAscii(14, 0, pDataBuf);    //14//
    

  342.         bStrLen += bStrLen1;
    

  343.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  344. 

  345.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  346.         bStrLen1 = sbNumToAscii(15, 0, pDataBuf);    //15//
    

  347.         bStrLen += bStrLen1;
    

  348.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  349. 

  350.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  351.         bStrLen1 = sbNumToAscii(16, 0, pDataBuf);  //16//
    

  352.         bStrLen += bStrLen1;
    

  353.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  354. 

  355.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  356.         bStrLen1 = sbNumToAscii(17, 0, pDataBuf);  //17//
    

  357.         bStrLen += bStrLen1;
    

  358.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  359. 

  360.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  361.         bStrLen1 = sbNumToAscii(18, 0, pDataBuf);  //18//
    

  362.         bStrLen += bStrLen1;
    

  363.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  364. 

  365.         pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  366.         bStrLen1 = sbNumToAscii(19, 0, pDataBuf);  //19//
    

  367.         bStrLen += bStrLen1;
    

  368.         u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  369. 

  370.         IPOMS_Write(ID_IPOMS, u8IPOMS_UserDataBuf0, bStrLen);
    

  371.     }
    


  372. 

  373. void IPOMS_Q2Command(void)
    

  374. {
    

  375.     Uint8   bStrLen;
    

  376.     Uint8   bStrLen1;
    

  377.     Uint8   *pDataBuf;
    


  378. 

  379.     bStrLen1 = 0;
    

  380.     bStrLen = 0;
    


  381. 

  382.     bStrLen = sbNumToAscii(0, 0, u8IPOMS_UserDataBuf0);//0
    

  383.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  384. 

  385.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  386.     bStrLen1 = sbNumToAscii(uwScope[1], 0, pDataBuf); //1//
    

  387.     bStrLen += bStrLen1;
    

  388.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  389. 

  390.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  391.     bStrLen1 = sbNumToAscii(uwScope[2] , 0, pDataBuf); //2//
    

  392.     bStrLen += bStrLen1;
    

  393.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  394. 

  395.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  396.     bStrLen1 = sbNumToAscii(uwScope[3], 0, pDataBuf);  //3//
    

  397.     bStrLen += bStrLen1;
    

  398.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  399. 

  400.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  401.     bStrLen1 = sbNumToAscii(uwScope[4], 0, pDataBuf);  //4//
    

  402.     bStrLen += bStrLen1;
    

  403.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  404. 

  405.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  406.     bStrLen1 = sbNumToAscii(uwScope[5], 0, pDataBuf);  //5//
    

  407.     bStrLen += bStrLen1;
    

  408.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  409. 

  410.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  411.     bStrLen1 = sbNumToAscii(uwScope[6], 0, pDataBuf);  //6//
    

  412.     bStrLen += bStrLen1;
    

  413.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  414. 

  415.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  416.     bStrLen1 = sbNumToAscii(uwScope[7], 0, pDataBuf);  //7//
    

  417.     bStrLen += bStrLen1;
    

  418.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  419. 

  420.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  421.     bStrLen1 = sbNumToAscii(uwScope[8], 0, pDataBuf);  //8//
    

  422.     bStrLen += bStrLen1;
    

  423.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  424. 

  425.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  426.     bStrLen1 = sbNumToAscii(uwScope[9], 0, pDataBuf);  //9//
    

  427.     bStrLen += bStrLen1;
    

  428.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  429. 

  430.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  431.     bStrLen1 = sbNumToAscii(uwScope[10], 0, pDataBuf);  //10//
    

  432.     bStrLen += bStrLen1;
    

  433.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  434. 

  435.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  436.     bStrLen1 = sbNumToAscii(uwScope[11], 0, pDataBuf);  //11//
    

  437.     bStrLen += bStrLen1;
    

  438.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  439. 


  440. 

  441.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  442.     bStrLen1 = sbNumToAscii(uwScope[12], 0, pDataBuf);  //12//
    

  443.     bStrLen += bStrLen1;
    

  444.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  445. 

  446.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  447.     bStrLen1 = sbNumToAscii(uwScope[13], 0, pDataBuf);  //13//
    

  448.     bStrLen += bStrLen1;
    

  449.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  450. 

  451.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  452.     bStrLen1 = sbNumToAscii(uwScope[14], 0, pDataBuf);  //14//
    

  453.     bStrLen += bStrLen1;
    

  454.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  455. 

  456.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  457.     bStrLen1 = sbNumToAscii(uwScope[15], 0, pDataBuf);  //15//
    

  458.     bStrLen += bStrLen1;
    

  459.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  460. 

  461.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  462.     bStrLen1 = sbNumToAscii(0, 0, pDataBuf);  //16//
    

  463.     bStrLen += bStrLen1;
    

  464.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  465. 

  466.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  467.     bStrLen1 = sbNumToAscii(0, 0, pDataBuf);  //17//
    

  468.     bStrLen += bStrLen1;
    

  469.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  470. 

  471.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  472.     bStrLen1 = sbNumToAscii(0, 0, pDataBuf);  //18//
    

  473.     bStrLen += bStrLen1;
    

  474.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  475. 

  476.     pDataBuf = &u8IPOMS_UserDataBuf0[bStrLen];
    

  477.     bStrLen1 = sbNumToAscii(0, 0, pDataBuf);  //19//
    

  478.     bStrLen += bStrLen1;
    

  479.     u8IPOMS_UserDataBuf0[bStrLen++] = 32;
    


  480. 

  481.     IPOMS_Write(ID_IPOMS, u8IPOMS_UserDataBuf0, bStrLen);
    


  482. 

  483. }
    


  484. 

  485. /*=============================================================================*
    

  486.  * FUNCTION: IPOMS_Q3Command(void)
    

  487.  * PURPOSE : Pick up parameter for Snatch Graph fuction
    

  488.  * INPUT:
    

  489.  *     void  // TRUE:disable the dog锟斤拷FALSE:enable the dog
    

  490.  *
    

  491.  * RETURN:
    

  492.  *     void
    

  493.  *
    

  494.  * CALLS:
    

  495.  *    //IPOMS_Write
    


  496. 

  497.  * CALLED BY:
    

  498.  * //    INT32 IPOMS_Parsing()
    

  499.  *
    

  500.  *============================================================================*/
    

  501. void IPOMS_Q3Command(void)
    

  502. {
    

  503.     Uint16 u16SnatchDataCntTemp, u16IntervalTemp;
    

  504.     Uint8 u8DataKindTemp1, u8DataKindTemp2, u8DataKindTemp3, u8DataKindTemp4;
    

  505.     Uint8 u8TriggerSourceTemp, u8TriggerTemp, u8SignTemp;
    

  506.     Uint16 i, u16LengthTemp, u16CompareValTemp;
    


  507. 

  508.     u16LengthTemp = u16IPOMS_CommandLength;
    


  509. 

  510.     for(i = 0;i < u16LengthTemp;i++)
    

  511.     {
    

  512.         u8IPOMS_UserDataBuf0[i] = u8IPOMS_CommandBuffer0[i];
    

  513.     }
    


  514. 

  515.       IPOMS_Write(ID_IPOMS, u8IPOMS_UserDataBuf0, u16LengthTemp);
    


  516. 

  517.     //aaa
    

  518.     u16SnatchDataCntTemp = (u8IPOMS_CommandBuffer0[2] - 48) * 100 + (u8IPOMS_CommandBuffer0[3] - 48) * 10 + u8IPOMS_CommandBuffer0[4] - 48;
    

  519.     //bbb
    

  520.     u16IntervalTemp = (u8IPOMS_CommandBuffer0[6] - 48) * 100 + (u8IPOMS_CommandBuffer0[7] - 48) * 10 + u8IPOMS_CommandBuffer0[8] - 48;
    

  521.     //cc
    

  522.     u8DataKindTemp1 = (u8IPOMS_CommandBuffer0[10] - 48) * 10 + u8IPOMS_CommandBuffer0[11] - 48;
    

  523.     //dd
    

  524.     u8DataKindTemp2 = (u8IPOMS_CommandBuffer0[13] - 48) * 10 + u8IPOMS_CommandBuffer0[14] - 48;
    

  525.     //ee
    

  526.     u8DataKindTemp3 = (u8IPOMS_CommandBuffer0[16] - 48) * 10 + u8IPOMS_CommandBuffer0[17] - 48;
    

  527.     //ff
    

  528.     u8DataKindTemp4 = (u8IPOMS_CommandBuffer0[19] - 48) * 10 + u8IPOMS_CommandBuffer0[20] - 48;
    

  529.     //gg
    

  530.     u8TriggerSourceTemp = (u8IPOMS_CommandBuffer0[22] - 48) * 10 + u8IPOMS_CommandBuffer0[23] - 48;
    

  531.     //h
    

  532.     u8TriggerTemp = u8IPOMS_CommandBuffer0[25] - 48;
    

  533.     //+/-
    

  534.     u8SignTemp = u8IPOMS_CommandBuffer0[27] - 48;
    

  535.     //iiiii
    

  536.     u16CompareValTemp = (u8IPOMS_CommandBuffer0[29] - 48) * 10000 + (u8IPOMS_CommandBuffer0[30] - 48) * 1000 \
    

  537.      + (u8IPOMS_CommandBuffer0[31] - 48) * 100 + (u8IPOMS_CommandBuffer0[32] - 48) * 10 + u8IPOMS_CommandBuffer0[33] - 48;
    


  538. 

  539.     if((u16SnatchDataCntTemp > 500) ||(u16IntervalTemp > 500) ||(u8TriggerTemp > 4))
    

  540.     {
    

  541.         return;
    

  542.     }
    


  543. 

  544.     u16IPOMS_SaveDataCnt = 0;
    

  545.     u16IPOMS_SnatchDataCnt = u16SnatchDataCntTemp;
    

  546.     u16IPOMS_Interval = u16IntervalTemp;
    

  547.     u16IPOMS_Interval1 = u16IPOMS_Interval;
    


  548. 

  549.     u8IPOMS_DataKind[0] = u8DataKindTemp1;
    

  550.     u8IPOMS_DataKind[1] = u8DataKindTemp2;
    

  551.     u8IPOMS_DataKind[2] = u8DataKindTemp3;
    

  552.     u8IPOMS_DataKind[3] = u8DataKindTemp4;
    

  553.     u8IPOMS_wTriggerSource = u8TriggerSourceTemp;
    

  554.     u8IPOMS_wTrigger = u8TriggerTemp;
    

  555.     u8IPOMS_Sign = u8SignTemp;
    


  556. 

  557.     u16IPOMS_CompareVal = u16CompareValTemp;
    

  558.     u16IPOMS_TransmitCnt = 0;
    


  559. 

  560.     if ((u8IPOMS_wTriggerSource != 0) && (u8IPOMS_wTrigger != 0))
    

  561.     {
    

  562.         wTriggerWaiting = 1;
    

  563.     }
    

  564.     else
    

  565.     {
    

  566.         wTriggerWaiting=0;
    

  567.     }
    

  568. }
    

  569. /*=============================================================================*
    

  570.  * FUNCTION:  IPOMS_QDCommand(void)
    

  571.  * PURPOSE :  Send Data to IPOMS For QD Command
    

  572.  * INPUT:
    

  573.  *     void  // TRUE:disable the dog 锟斤拷 FALSE:enable the dog
    

  574.  *
    

  575.  * RETURN:
    

  576.  *     void
    

  577.  *
    

  578.  * CALLS:
    

  579.  *      //IPOMS_WriteBinary()
    

  580.  *
    

  581.  *
    

  582.  * CALLED BY:
    

  583.  *     //INT32 IPOMS_Parsing()
    

  584.  *
    

  585.  *============================================================================*/
    

  586. void IPOMS_QDCommand(void)
    

  587. {
    

  588.     Uint8 u8Temp;
    

  589.     int16 i;
    

  590.     int32 i32CheckSum;
    


  591. 

  592.     u8Temp = u8IPOMS_CommandBuffer0[2] - 48;
    


  593. 

  594.     if((u8Temp >=4 ) || (0 == u16IPOMS_TransmitCnt))
    

  595.     {
    

  596.         return;
    

  597.     }
    

  598.     u16IPOMS_TransmitDataBuff[0] = 0x01;        //SOH
    

  599.     u16IPOMS_TransmitDataBuff[1] = u16IPOMS_TransmitCnt;    //length
    


  600. 

  601.     i32CheckSum =(int32)(0x01 + u16IPOMS_TransmitCnt);
    

  602.     for(i = 0;i < u16IPOMS_TransmitCnt;i++)
    

  603.     {
    

  604.         u16IPOMS_TransmitDataBuff[2 + i] = u16IPOMS_GraphDataBuff[u8Temp][i];
    

  605.         i32CheckSum += u16IPOMS_GraphDataBuff[u8Temp][i];
    

  606.     }
    


  607. 

  608.     u16IPOMS_TransmitDataBuff[2 + u16IPOMS_TransmitCnt] = (Uint16)(i32CheckSum & 0x0000FFFF);
    


  609. 

  610.     IPOMS_WriteBinary(u16IPOMS_TransmitDataBuff, u16IPOMS_TransmitCnt + 3);
    


  611. 

  612. }
    

  613. /*=============================================================================*
    

  614.  * FUNCTION:  IPOMS_SnatchGraph(void)
    

  615.  * PURPOSE :  SnatchGraph Data in the switching interrupt
    

  616.  * INPUT:
    

  617.  *     void  // TRUE:disable the dog 锟斤拷 FALSE:enable the dog
    

  618.  *
    

  619.  * RETURN:
    

  620.  *     void
    

  621.  *
    

  622.  * CALLS:
    

  623.  *
    

  624.  * CALLED BY:
    

  625.  *     //INT32 IPOMS_QDCommand()
    

  626.  *
    

  627.  *============================================================================*/
    

  628. Uint8 IPOMS_SnatchGraph(void)
    

  629. {
    

  630.     int16 i,j;
    


  631. 

  632.     //trigger condition check
    

  633.     if(0 == u8IPOMS_SnatchGraphEnable)
    

  634.     {
    

  635.       return(false);
    

  636.     }
    


  637. 

  638.     if(0 == u8IPOMS_wTrigger)
    

  639.     {
    

  640.       return(false);
    

  641.     }
    


  642. 

  643.     if( wTriggerWaiting==1 )
    

  644.     {
    

  645.         if (u8IPOMS_wTrigger==2 )
    

  646.         {
    

  647.             if (GetDataSubArray[u8IPOMS_wTriggerSource]()<((int)u16IPOMS_CompareVal) )
    

  648.             {
    

  649.                 wTriggerWaiting=0;
    

  650.             }
    

  651.             /*if (u8IPOMS_Sign=='+')
    

  652.             {
    

  653.                 if (GetDataSubArray[u8IPOMS_wTriggerSource]()<((int)u16IPOMS_CompareVal) )
    

  654.                 {
    

  655.                     wTriggerWaiting=0;
    

  656.                 }
    

  657.             }
    

  658.             else if ( u8IPOMS_Sign=='-')
    

  659.             {
    

  660.                 if (GetDataSubArray[u8IPOMS_wTriggerSource]() < -((int)u16IPOMS_CompareVal) )
    

  661.                 {
    

  662.                     wTriggerWaiting=0;
    

  663.                 }
    

  664.             }*/
    

  665.         }
    

  666.         else if (u8IPOMS_wTrigger == 3)
    

  667.         {
    

  668.             if (GetDataSubArray[u8IPOMS_wTriggerSource]() > ((int)u16IPOMS_CompareVal))
    

  669.             {
    

  670.                 wTriggerWaiting = 0;
    

  671.             }
    

  672.         }
    

  673.         else if (u8IPOMS_wTrigger == 4)
    

  674.         {
    

  675.             if (GetDataSubArray[u8IPOMS_wTriggerSource]() == ((int)u16IPOMS_CompareVal))
    

  676.             {
    

  677.                 wTriggerWaiting=0;
    

  678.             }
    

  679.         }
    

  680.         return(false);
    

  681.     }
    


  682. 

  683.     if(u16IPOMS_Interval1 > 0)
    

  684.     {
    

  685.         if(0 == (--u16IPOMS_Interval1))
    

  686.         {
    

  687.             u16IPOMS_Interval1 = u16IPOMS_Interval;
    

  688.         }
    

  689.         else
    

  690.         {
    

  691.             return(false);
    

  692.         }
    

  693.     }
    


  694. 

  695.  /*   for(i = 0;i < 2;i++)
    

  696.     {
    

  697.         j=u8IPOMS_DataKind[i];
    

  698.         if(0 == j)
    

  699.         {
    

  700.             continue;
    

  701.         }
    

  702.         u16IPOMS_GraphDataBuff[i][u16IPOMS_SaveDataCnt] = (Uint16)GetDataSubArray[j]();
    

  703.     }*/
    

  704.     for(i = 0;i < 4;i++)
    

  705.     {
    

  706.         j=u8IPOMS_DataKind[i];
    

  707.         if(0 == j)
    

  708.         {
    

  709.             continue;
    

  710.         }
    

  711.         u16IPOMS_GraphDataBuff[i][u16IPOMS_SaveDataCnt] = (Uint16)GetDataSubArray[j]();
    

  712.     }
    


  713. 

  714.     ++u16IPOMS_SaveDataCnt;
    

  715.     if(u16IPOMS_SaveDataCnt == u16IPOMS_SnatchDataCnt)
    

  716.     {
    

  717.         u16IPOMS_TransmitCnt = u16IPOMS_SnatchDataCnt;
    

  718.         u16IPOMS_SnatchDataCnt = 0;
    

  719.         u16IPOMS_SaveDataCnt = 0;
    

  720.         u8IPOMS_wTrigger = 0;
    

  721.         u8IPOMS_wTriggerSource = 0;
    

  722.         u8IPOMS_SnatchGraphEnable = 1;
    

  723.         return(true);
    

  724.     }
    


  725. 

  726.     return(false);
    

  727. }
    


  728. 

  729. //=============================================================================
    

  730. // *  FUNCTION:  IPOMS_GraphicView_x()
    

  731. // *
    

  732. // *  PURPOSE :  Assign variable shown in Graphic View screen of IPOMS.
    

  733. //=============================================================================
    


  734. 

  735. int16 IPOMS_GraphicView_0(void)
    

  736. {
    

  737.     return(uwScope[0]);
    

  738. }
    

  739. int16 IPOMS_GraphicView_1(void)
    

  740. {
    

  741.     return(uwScope[1]);
    

  742. }
    

  743. int16 IPOMS_GraphicView_2(void)
    

  744. {
    

  745.     return(uwScope[2]);
    

  746. }
    

  747. int16 IPOMS_GraphicView_3(void)
    

  748. {
    

  749.     return(uwScope[3]);
    

  750. }
    


  751. 

  752. int16 IPOMS_GraphicView_4(void)
    

  753. {
    

  754.     return(uwScope[4]);
    

  755. }
    


  756. 

  757. int16 IPOMS_GraphicView_5(void)
    

  758. {
    

  759.     return(uwScope[5]);
    

  760. }
    


  761. 

  762. int16 IPOMS_GraphicView_6(void)
    


  763. 

  764. {
    

  765.     return(uwScope[6]);
    

  766. }
    


  767. 

  768. int16 IPOMS_GraphicView_7(void)
    

  769. {
    

  770.     return(uwScope[7]);
    

  771. }
    


  772. 

  773. int16 IPOMS_GraphicView_8(void)
    

  774. {
    

  775.     return(uwScope[8]);
    

  776. }
    


  777. 

  778. int16 IPOMS_GraphicView_9(void)
    

  779. {
    

  780.     return(uwScope[9]);
    

  781. }
    


  782. 

  783. int16 IPOMS_GraphicView_10(void)
    

  784. {
    

  785.     return(uwScope[10]);
    

  786. }
    


  787. 


  788. 

  789. /*=============================================================================*
    

  790.  * FUNCTION: sbNumToAscii
    

  791.  * PURPOSE :  Convert input u16Number into max. 8 digital numbers including
    

  792.  *            decimal represented byASCII code.
    

  793.  * INPUT:
    

  794.  *     void  // TRUE:disable the dog 锟斤拷 FALSE:enable the dog
    

  795.  *
    

  796.  * RETURN:
    

  797.  *     void
    

  798.  *
    

  799.  * CALLS:
    

  800.  *     void
    

  801.  *
    

  802.  * CALLED BY:
    

  803.  *
    

  804.  * IPOMS_Q1Command
    

  805.  *
    

  806.  *============================================================================*/
    

  807. Uint8 sbNumToAscii(Uint16 u16Number, int8 i8Exponent, Uint8 *pbBuffer)
    

  808. {
    

  809.     Uint8 u8No;
    

  810.     int8 i,j;
    

  811.     Uint8 bArrayTemp[8] = {0,0,0,0,0,0,0,0};
    

  812.     Uint32 u32NumberTemp;
    

  813.     j = 0;
    


  814. 

  815.     if((0 == u16Number) || ((u16Number != 0) && (i8Exponent < -6)))
    

  816.     {
    

  817.         *pbBuffer = '0';
    

  818.         u8No = 1;
    

  819.     }
    

  820.     else
    

  821.     {
    

  822.         u32NumberTemp = (Uint32)u16Number;
    

  823.         for(i = 0;i < i8Exponent;i++)
    

  824.         {
    

  825.             if(u32NumberTemp <= 9999999)
    

  826.             {
    

  827.                 u32NumberTemp = u32NumberTemp * 10;
    

  828.             }
    

  829.             else
    

  830.             {
    

  831.                 u32NumberTemp = 99999999;
    

  832.             }
    

  833.         }
    

  834.         while ((u32NumberTemp > 0) || (i8Exponent < 0))
    

  835.         {
    

  836.             i = u32NumberTemp % 10;
    

  837.             u32NumberTemp = u32NumberTemp / 10;
    

  838.             bArrayTemp[j] = i + 0x30;
    

  839.             j++;
    


  840. 

  841.             i8Exponent++;
    

  842.             if(0 == i8Exponent)
    

  843.             {
    

  844.                 bArrayTemp[j] = '.';
    

  845.                 j++;
    

  846.                 if(0 == u32NumberTemp)
    

  847.                 {
    

  848.                     bArrayTemp[j] = '0';
    

  849.                     j++;
    

  850.                 }
    

  851.             }
    

  852.         }
    

  853.         u8No = 0;
    

  854.         j--;
    

  855.         while (j >= 0)
    

  856.         {
    

  857.             *(pbBuffer + u8No) = bArrayTemp[j];
    

  858.             u8No++;
    

  859.             j--;
    

  860.         }
    

  861.     }/* end of number !=0 */
    

  862.     return(u8No);/* char length*/
    

  863. }
    


  864. 

  865. /*=============================================================================*
    

  866.  * FUNCTION:  IPOMS_WriteBinary
    

  867.  * PURPOSE :  Write a 16bit data to  IPOMS Tx Port
    

  868.  * INPUT:
    

  869.  *     void  // TRUE:disable the dog 锟斤拷 FALSE:enable the dog
    

  870.  *
    

  871.  * RETURN:
    

  872.  *     void
    

  873.  *
    

  874.  * CALLS:
    

  875.  *    // void sSplit()
    

  876.  *
    

  877.  * CALLED BY:
    

  878.  *     IPOMS_QDCommand()
    

  879.  *
    

  880.  *============================================================================*/
    

  881. void IPOMS_WriteBinary(Uint16 *pstart, Uint16 u16Length)
    

  882. {
    

  883.     int8 i;
    

  884.     int8 j;
    

  885.     Uint16 *pData;
    

  886.     Uint8  u8Data;
    


  887. 

  888.     u8IPOMS_SendHighHalfByte = 1;
    

  889.     pData = pstart;
    

  890.     for(i = 0;i < u16Length;i++)
    

  891.     {
    

  892.         //split
    

  893.         //sSplit(*pData);
    


  894. 

  895.         for(j = 0;j < 2;j++)
    

  896.         {
    

  897.             if(1 == u8IPOMS_SendHighHalfByte)
    

  898.             {   //write high 8bit
    

  899.                 u8Data = GET_HBYTE_OF_WORD(*pData);
    

  900.                 while(IPOMS_Write(ID_IPOMS, &u8Data, 1));
    

  901.                 u8IPOMS_SendHighHalfByte = 0;
    

  902.             }
    

  903.             else
    

  904.             {   //write low 8bit
    

  905.                 u8Data = GET_LBYTE_OF_WORD(*pData);
    

  906.                 while(IPOMS_Write(ID_IPOMS, &u8Data, 1));
    

  907.                 u8IPOMS_SendHighHalfByte = 1;
    

  908.             }
    

  909.         }
    


  910. 

  911.         ++pData;
    

  912.     }
    

  913. }
    


  914. 

  915. //=============================================================================
    

  916. // End of file.
    

  917. //=============================================================================
    


  918.
上位机和下位机动态联调（下位机发送4路正弦信号，上位机显示波形，并可以调整显示数据的长度）
上位机安装包和串口示波器驱动代码：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

hbzjt2011 发表于 2025-10-14 12:53 | 显示全部楼层
很详细的实践教程，谢谢分享
回复

收藏 举报

 楼主| 电笔小新 发表于 2025-10-14 14:50 | 显示全部楼层
本帖最后由 电笔小新 于 2025-10-14 14:57 编辑

6.控制策略设计
整个平衡车的控制，最重要的是平衡车角度的计算获取，如果角度没拟合好，就不用谈后面的车身平衡控制了；我是用上位机将原始角度数据跟滤波后的角度数据打印出来，通过观察波形来判断拟合结果；角度的拟合算法用了卡尔曼滤波和互补滤波；
通过上位机观察静止波形输出，通道一为原始数据，通道二为卡尔曼滤波，通道三为互补滤。
静止状态下两种滤波效果都挺好，把原始数据的噪音全滤掉了。
动态波形滤波测试，将车子直立，然后用手扶住平衡车，在水平方向使车子正负30度左右摇晃，记录输出波形。
从上面波形上看，动态时，角速度对滤波的加权值太大，需修改输入的角速度量程
调整输入角速度幅值，直到滤波效果比较正常，在晃动的条件下，滤波角度考虑到了角速度的惯量，加大了输出角度，更准确的输出了平衡车的当前状态。
角度拟合OK后，就可以给系统上控制代码，控制环路主要分车子平衡控制、车子速度控制、车子转向控制

车子平衡控制代码如下：通过输入车子的倾角和角加速度，计算需要将车子回到直立状态的驱动量；
复制
  1. //============================================================================
    

  2. //* 函 数 名: Balance
    

  3. //* 功能说明: 直立PD控制
    

  4. //* 形    参: Angle->角度；Gyro->角速度
    

  5. //* 返 回 值: balance->直立控制PWM
    

  6. //============================================================================
    

  7. #define Middle_angle 0
    

  8. int Balance(float Angle,float Gyro)
    

  9. {
    

  10.     float Angle_bias,Gyro_bias;
    

  11.     int balance;
    

  12.     Angle_bias=Middle_angle-Angle;               //求出平衡的角度中值 和机械相关
    

  13.     Gyro_bias=0-Gyro;
    


  14. 

  15.     balance=-Balance_Kp/B_Kp*Angle_bias-Gyro_bias*Balance_Kd/B_Kd; //计算平衡控制的电机PWM  PD控制   kp是P系数 kd是D系数
    

  16.     uwScope[1]=B_Kp;
    

  17.     uwScope[2]=B_Kd;
    


  18. 

  19.     uwScope[8]=Balance_Kp/B_Kp*Angle_bias;
    

  20.     uwScope[9]=Gyro_bias*Balance_Kd/B_Kd;
    

  21.     return balance;
    

  22. }

车子速度控制代码如下：通过输入车子两个轮子的转速，计算需要将车子速度控制为零，稳定站立的驱动量；
复制
  1. //============================================================================
    

  2. //* 函 数 名: Velocity
    

  3. //* 功能说明: 速度控制PWM
    

  4. //* 形    参: encoder_left->左轮编码器读数；encoder_right->右轮编码器读数
    

  5. //* 返 回 值: 速度控制PWM
    

  6. //============================================================================
    

  7. //修改前进后退速度，请修改Target_Velocity
    

  8. int Velocity(int encoder_left,int encoder_right)
    

  9. {
    

  10.     static float velocity,Encoder_Least,Encoder_bias,Movement;
    

  11.       static float Encoder_Integral,Target_Velocity;
    


  12. 

  13.    //================速度PI控制器=====================//
    

  14.         Encoder_Least =0-(encoder_left+encoder_right);                    //获取最新速度偏差=目标速度（此处为零）-测量速度（左右编码器之和）
    

  15.         Encoder_bias *= 0.84;                                                 //一阶低通滤波器
    

  16.         Encoder_bias += Encoder_Least*0.16;                               //一阶低通滤波器，减缓速度变化
    

  17.         Encoder_Integral +=Encoder_bias;                                  //积分出位移 积分时间：10ms
    


  18. 

  19.         Encoder_Integral=Encoder_Integral+Movement;                       //接收遥控器数据，控制前进后退
    

  20.         if(Encoder_Integral>2000)      Encoder_Integral=2000;             //积分限幅
    

  21.         if(Encoder_Integral<-2000)   Encoder_Integral=-2000;            //积分限幅
    


  22. 

  23.         velocity=-Encoder_bias*Velocity_Kp/V_Kp-Encoder_Integral*Velocity_Ki/V_Ki;     //速度控制
    

  24.         if(Turn_Off(Angle_Balance,Bat_volt)==1||Flag_Stop==1) Encoder_Integral=0;//电机关闭后清除积分
    

  25.         uwScope[3]=V_Kp;
    

  26.         uwScope[4]=V_Kd;
    


  27. 

  28.         uwScope[10]=Encoder_bias*Velocity_Kp/V_Kp;
    

  29.         uwScope[11]=Encoder_Integral*Velocity_Ki/V_Kd;
    

  30.       return velocity;
    

  31. }

车子转向控制代码如下：当前使用的是开环，强制给左右两个电机给定固定的偏移量。
复制
  1. //============================================================================
    

  2. //* 函 数 名: Turn
    

  3. //* 功能说明: 转向控制
    

  4. //* 形    参: Z轴陀螺仪
    

  5. //* 返 回 值: 转向控制PWM
    

  6. //============================================================================
    

  7. int Turn(float gyro)
    

  8. {
    

  9.     static float Turn_Target,Turn_Amplitude=40;
    

  10.    
    

  11.     if(1==Flag_Left)        Turn_Target=-Turn_Amplitude/2;
    

  12.     else if(1==Flag_Right)  Turn_Target=Turn_Amplitude/2;
    

  13.     else                    Turn_Target=0;
    


  14. 

  15.     return Turn_Target;             //转向环PWM右转为正，左转为负
    

  16. }

实际上调试只需要车子平衡控制和车子速度控制两个环路的总共四个参数；为了方便调试，直接将调试参数由上位机下发指令动态修改参数，根据反馈数据进行修改；
复制
  1. void IPOMS_Parsing(void)
    

  2. {
    


  3. 

  4.     switch(u8IPOMS_CommandBuffer0[0])
    

  5.     {
    

  6.     case 'Q':
    

  7.         {
    


  8. 

  9.             if('1' == u8IPOMS_CommandBuffer0[1])
    

  10.             {
    

  11.                 IPOMS_Q1Command();
    

  12.             }
    

  13.              if('2' == u8IPOMS_CommandBuffer0[1])
    

  14.             {
    

  15.                 IPOMS_Q2Command();
    

  16.             }
    

  17.             if('3' == u8IPOMS_CommandBuffer0[1])
    

  18.             {
    

  19.                 IPOMS_Q3Command();
    

  20.             }
    

  21.             if('D' == u8IPOMS_CommandBuffer0[1])
    

  22.             {
    

  23.                 IPOMS_QDCommand();
    

  24.             }
    

  25.             if('4' == u8IPOMS_CommandBuffer0[1])
    

  26.             {
    

  27.                 B_Kp++;
    

  28.             }
    

  29.             if('5' == u8IPOMS_CommandBuffer0[1])
    

  30.             {
    

  31.                 B_Kp--;
    

  32.             }
    

  33.             if('6' == u8IPOMS_CommandBuffer0[1])
    

  34.             {
    

  35.                 B_Kd++;
    

  36.             }
    

  37.             if('7' == u8IPOMS_CommandBuffer0[1])
    

  38.             {
    

  39.                 B_Kd--;
    

  40.             }
    

  41.             if('8' == u8IPOMS_CommandBuffer0[1])
    

  42.             {
    

  43.                 V_Kp++;
    

  44.             }
    

  45.             if('9' == u8IPOMS_CommandBuffer0[1])
    

  46.             {
    

  47.                 V_Kp--;
    

  48.             }
    

  49.             if('H' == u8IPOMS_CommandBuffer0[1])
    

  50.               {
    

  51.                   V_Kd++;
    

  52.               }
    

  53.             if('I' == u8IPOMS_CommandBuffer0[1])
    

  54.               {
    

  55.                   V_Kd--;
    

  56.               }
    

  57.             if('L' == u8IPOMS_CommandBuffer0[1])
    

  58.             {
    

  59.                 Flag_Left=1;    //左转
    

  60.                 Flag_Right=0;
    

  61.                 Flag_front=0;
    

  62.                 Flag_back=0;
    

  63.             }
    

  64.             if('R' == u8IPOMS_CommandBuffer0[1])
    

  65.             {
    

  66.                 Flag_Left=0;
    

  67.                 Flag_Right=1;  //右转
    

  68.                 Flag_front=0;
    

  69.                 Flag_back=0;
    

  70.             }
    

  71.             if('F' == u8IPOMS_CommandBuffer0[1])
    

  72.             {
    

  73.                 Flag_Left=0;
    

  74.                 Flag_Right=0;
    

  75.                 Flag_front=1;  //前进
    

  76.                 Flag_back=0;
    

  77.             }
    

  78.             if('B' == u8IPOMS_CommandBuffer0[1])
    

  79.             {
    

  80.                 Flag_Left=0;
    

  81.                 Flag_Right=0;
    

  82.                 Flag_front=0;
    

  83.                 Flag_back=1;  //后退
    

  84.             }
    

  85.             if('S' == u8IPOMS_CommandBuffer0[1])
    

  86.             {
    

  87.                 Flag_Left=0;  //停止
    

  88.                 Flag_Right=0;
    

  89.                 Flag_front=0;
    

  90.                 Flag_back=0;
    

  91.             }
    

  92.         }
    

  93.     break;
    

  94.     default:
    

  95.     break;
    

  96.     }
    

  97. }

参数调试经验分享：对于四个参数个人的调试理解，先调试车子平衡控制的两个参数，然后在调试车子速度控制的两个参数；最后在微调四个参数，实现更理想控制；
对于车子平衡控制的两个参数，B_Kp是快速矫正车子状态回到直立；B_Kd是快速消除车子抖动；
先调试B_Kp值使得车子在外力干扰偏离直立状态，环路控制使得车子在直立状态左右状态（震荡幅度越小说明参数更合适）；调试B_Kd值，可以先将B_Kp清零，调整B_Kd值使得用手晃动明显感觉车子非常僵硬；最后就是联合调试B_Kp和B_Kd值，使得车子能够直立；这时候车子是不可能固定站住的（最好是拿细绳绑住车子，吊起来调试，防止车子调试过程乱跑撞坏），车子可能有一个向前或向后的动力；这已经完成了车子平衡控制的初步控制；
对于车子速度控制的两个参数，V_Kp是快速减弱子速度；V_KI是控制车子回到原理静止位置；先调试V_Kp值使得车子在速度上升的时候有阻尼起到减速效果，后面调试V_KI使得车子能够在原地站住；
   最后就是微调四个参数，使得车子在收到前进、后退、左转、右转指令后能够更稳定运行；
调试结果展示：
稳定在原地，受外力干扰能快速稳定，回到原来位置：
用激光反馈黑线位置，控制车子跟巡黑线：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

 楼主| 电笔小新 发表于 2025-10-14 16:26 | 显示全部楼层
7.在线升级Bootloader
用烧录器下载程序，每次插拔下载接口都非常的费劲。就想着能够实现无线烧录程序就好；查了相关资料，需要先写一个Bootloader下载到F28035主控板，然后使用上位机通过无线串口对主控板实现升级；对DSP内部存储器的调用得用官方提供的API库；安装C2000ware之后，在下面路径可以搜索到API_lib;而且有例程可以参考；

直接打开参考例程，进行修改即可得到一个F28035的BootLoader;
复制
  1. /******************************************************************************
    

  2.  *    FILENAME : User_Bootloader.c
    

  3.  *
    

  4.  *    PURPOSE  : BootLoader APP Code.
    

  5.  *
    

  6.  *       Author: ���С��                      Created on: 2025��9��24��
    

  7. ******************************************************************************/
    


  8. 

  9. #include "User_Include.h"
    

  10. #include "User_Bootloader.h"
    


  11. 

  12. //=============================================================================
    

  13. // *  Variables & Function_Defines
    

  14. //=============================================================================
    

  15. Uint8   u8Program_Cnt=0;
    


  16. 

  17. Uint32  u32ReadDataBuff[8];
    

  18. Uint8   u8CompanionRxbuffer[5];
    

  19. Uint16  UpdataFlag16[8]={0x0101,0x0202,0x0303,0x0404,0x0505,0x0606,0x0707,0x0808};
    

  20. Uint32  UpdataFlag32[4]={0x02020101,0x04040303,0x06060505,0x08080707};
    


  21. 

  22. tSCIDataDef    tSCICom;
    

  23. tFlashDataDef  tUpdateFlash;
    

  24. /*--- Global variables used to interface to the flash routines */
    


  25. 

  26. FLASH_ST FlashStatus;
    


  27. 


  28. 

  29. SECTOR Sector[8] = {
    

  30.         (Uint16 *) 0x3E8000,(Uint16 *) 0x3E9FFF,
    

  31.         (Uint16 *) 0x3EA000,(Uint16 *) 0x3EBFFF,
    

  32.         (Uint16 *) 0x3EC000,(Uint16 *) 0x3EDFFF,
    

  33.         (Uint16 *) 0x3EE000,(Uint16 *) 0x3EFFFF,
    

  34.         (Uint16 *) 0x3F0000,(Uint16 *) 0x3F1FFF,
    

  35.         (Uint16 *) 0x3F2000,(Uint16 *) 0x3F3FFF,
    

  36.         (Uint16 *) 0x3F4000,(Uint16 *) 0x3F5FFF,
    

  37.         (Uint16 *) 0x3F6000,(Uint16 *) 0x3F7FFF
    

  38. };
    


  39. 

  40. Uint16 WriteVerfyData(void);
    

  41. void UpdateReplyData(void);
    


  42. 

  43. //============================================================================
    

  44. // * Function    :  BootloaderAPP()
    

  45. // * Purpose     :  This function initializes the BootloaderAPP.
    

  46. // * Parameters  :  Null
    

  47. // * Return      :  Null
    

  48. //============================================================================
    

  49. #pragma CODE_SECTION(BootloaderAPP,"ramfuncs");
    

  50.  void BootloaderAPP(void)
    

  51.  {
    

  52.     Uint16 Status;
    

  53.     Uint32 u32OffsetAddress = 0;
    

  54.     Uint16 u16ProgramCount  = 0;
    

  55.     Uint16 u16VerityCount   = 0;
    

  56.     Uint32 u32TimerCount    = 0;
    


  57. 

  58.     u8Program_Cnt=0;
    

  59.     memset(&tSCICom, 0, sizeof(tSCICom));
    

  60.     memset(&tSCICom.u8SCIRXBuffer, 0, (PacketSize+8));
    


  61. 

  62.     while(1)
    

  63.     {
    


  64. 

  65.         tUpdateFlash.u8UpdateDataFlag = 1;
    

  66.         while(tUpdateFlash.u8UpdateDataFlag == 1)
    

  67.         {
    

  68.             u32TimerCount++;
    

  69.             if(u32TimerCount > 15000000)
    

  70.             {
    

  71.                 u32TimerCount = 0;
    


  72. 

  73.                 Status = Flash_Verify((Uint16 *)VerifyAddr,(Uint16 *)UpdataFlag16,8,&FlashStatus);
    

  74.                 if(Status == STATUS_SUCCESS)
    

  75.                 {
    

  76.                    return;
    

  77.                 }
    

  78.             }
    

  79.         }
    

  80.         if(tUpdateFlash.u8UpdateDataStatus == 0)
    

  81.         {
    

  82.             switch(tSCICom.u8SCIRXBuffer[Data_Commad])
    

  83.             {
    

  84.             case Update_Keep:
    

  85.                 tUpdateFlash.u8UpdateDataStatus = M_ACK;
    

  86.                 //============================OLED��ʾ==============================//
    

  87.                    OLED_Clear();
    

  88.                    OLED_ShowString(20,10,"<-BootAPP->");
    

  89.                    OLED_ShowString(0,30,"Link_Success");
    

  90.                    OLED_Refresh_Gram();
    

  91.                //================================================================//
    

  92.                 break;
    


  93. 

  94.             case Update_EraseAll:
    

  95.                 DINT;
    

  96.                 Status = Flash_Erase((SECTORD|SECTORE|SECTORF|SECTORG|SECTORH),&FlashStatus);
    

  97.                 EINT;
    

  98.                 if(Status == STATUS_SUCCESS)
    

  99.                 {
    

  100.                     tUpdateFlash.u8UpdateDataStatus = EraseAll_Success;
    

  101.                 //============================OLED��ʾ==============================//
    

  102.                     OLED_Clear();
    

  103.                     OLED_ShowString(20,10,"<-BootAPP->");
    

  104.                     OLED_ShowString(0,30,"Erase_Success");
    

  105.                     OLED_Refresh_Gram();
    

  106.                 //================================================================//
    

  107.                 }
    

  108.                 else
    

  109.                 {
    

  110.                   tUpdateFlash.u8UpdateDataStatus = Com_Fail;
    

  111.                 }
    

  112.                 break;
    


  113. 

  114.             case Update_ProgramCommand:
    

  115.                 u32OffsetAddress = ((long)tSCICom.u8SCIRXBuffer[4]<<8)+((long)tSCICom.u8SCIRXBuffer[5]);
    

  116.                 if(u32OffsetAddress <= 0xFFFF)
    

  117.                 {
    

  118.                     for(u16ProgramCount = 0; u16ProgramCount < (tSCICom.u16UpdateDataLength/2); u16ProgramCount++)
    

  119.                     {
    

  120.                         tSCICom.Update_Buffer[u16ProgramCount]=(tSCICom.u8SCIRXBuffer[2*u16ProgramCount+6] << 8)+(tSCICom.u8SCIRXBuffer[2*u16ProgramCount+7]);
    

  121.                     }
    


  122. 

  123.                     for(u16VerityCount = 0; u16VerityCount < (tSCICom.u16UpdateDataLength/4); u16VerityCount++)
    

  124.                     {
    

  125.                         tSCICom.Verify_Buffer[u16VerityCount]=((Uint32)tSCICom.u8SCIRXBuffer[2*u16VerityCount+1] << 16)+((Uint32)tSCICom.u8SCIRXBuffer[2*u16VerityCount]);
    

  126.                     }
    


  127. 


  128. 

  129.                     Status = Flash_Program((Uint16 *)(u32OffsetAddress + Flash_ProjectStart),(Uint16 *)tSCICom.Update_Buffer,tSCICom.u16UpdateDataLength/2,&FlashStatus);
    


  130. 

  131.                     if(Status == STATUS_SUCCESS)
    

  132.                     {
    

  133.                         tUpdateFlash.u8UpdateDataStatus = ProgramCommand_Success;
    

  134.                     //============================OLED��ʾ==============================//
    

  135.                         u8Program_Cnt++;
    

  136.                         OLED_ShowString(20,10,"<-BootAPP->");
    

  137.                         OLED_ShowString(0,30,"Programming  ");
    

  138.                         OLED_ShowNumber(96,30,u8Program_Cnt,3,12);
    

  139.                         OLED_Refresh_Gram();
    

  140.                     //================================================================//
    

  141.                     }
    

  142.                     else
    

  143.                    {
    

  144.                      tUpdateFlash.u8UpdateDataStatus = Com_Fail;
    

  145.                    }
    

  146.                 }
    

  147.                 else
    

  148.                 {
    

  149.                     tUpdateFlash.u8UpdateDataStatus = Com_Fail;
    

  150.                 }
    

  151.                 break;
    


  152. 

  153.             case Update_End:
    

  154.                  tUpdateFlash.u8UpdateDataStatus = M_NACK;
    

  155.                  break;
    

  156.             }
    

  157.         }
    

  158.         UpdateReplyData();
    

  159.         tSCICom.u16BuffCountNum = 0;
    

  160.         u32TimerCount = 0;
    

  161.         if(tUpdateFlash.u8UpdateDataStatus == M_NACK)
    

  162.         {
    

  163.             WriteVerfyData();
    

  164.         //============================OLED��ʾ==============================//
    

  165.             u8Program_Cnt=0;
    

  166.             OLED_Clear();
    

  167.             OLED_ShowString(20,10,"<-BootAPP->");
    

  168.             OLED_ShowString(0,30,"Upgrade_Success");
    

  169.             OLED_Refresh_Gram();
    

  170.         //================================================================//
    

  171.             memset(&tSCICom , 0 , sizeof(tSCICom));
    

  172.             memset(tSCICom.u8SCIRXBuffer , 0xFF , (PacketSize+8));
    

  173.             break;
    

  174.         }
    


  175. 


  176. 

  177.    }
    

  178. }
    


  179. 


  180. 

  181.  //=============================================================================
    

  182.  // *  FUNCTION:  WriteVerfyData()
    

  183.  // *
    

  184.  // *  PURPOSE :
    

  185.  //=============================================================================
    


  186. 

  187.   Uint16 WriteVerfyData(void)
    

  188.  {
    

  189.      Uint16  Status;
    


  190. 

  191.      Status = Flash_Program((Uint16 *)VerifyAddr,(Uint16 *)UpdataFlag16,8,&FlashStatus);
    

  192.      if(Status != STATUS_SUCCESS)
    

  193.      {
    

  194.          return Status;
    

  195.      }
    

  196.      Status = Flash_Verify((Uint16 *)VerifyAddr,(Uint16 *)UpdataFlag16,8,&FlashStatus);
    

  197.      if(Status != STATUS_SUCCESS)
    

  198.      {
    

  199.          return Status;
    

  200.      }
    

  201.      return Status;
    

  202.  }
    


  203. 

  204. //=============================================================================
    

  205. // *  FUNCTION:  UpdateReplyData()
    

  206. // *
    

  207. // *  PURPOSE :
    

  208. //=============================================================================
    

  209. #pragma CODE_SECTION(UpdateReplyData,"ramfuncs");
    

  210. void UpdateReplyData(void)
    

  211. {
    

  212.   Uint8  u8ReplyData[5];
    

  213.   Uint16 u16CRCcheck;
    


  214. 

  215.   u8ReplyData[0] = 0xAA;
    

  216.   u8ReplyData[1] = 0x00;
    

  217.   u8ReplyData[2] = tUpdateFlash.u8UpdateDataStatus;
    

  218.   u16CRCcheck = (u8ReplyData[0] + u8ReplyData[1] + u8ReplyData[2]);
    

  219.   u8ReplyData[3] = (Uint8)(u16CRCcheck >> 8);
    

  220.   u8ReplyData[4] = (Uint8)(u16CRCcheck & 0xFF);
    


  221. 

  222.   LinaWrite(u8ReplyData, 5);
    


  223. 

  224. }
    


  225. 


  226. 

  227. //=============================================================================
    

  228. // *  FUNCTION:  u8UpdateDataCheck()
    

  229. // *
    

  230. // *  PURPOSE :
    

  231. //=============================================================================
    

  232. Uint16 u8UpdateDataCheck(Uint16 u16Buffcount)
    

  233. {
    

  234.     Uint16 CRC_Check = 0;
    

  235.     Uint16 DataLength = 0;
    

  236.     if(u16Buffcount == Data_Start)
    

  237.     {
    

  238.         if(tSCICom.u8SCIRXBuffer[u16Buffcount] != Update_StartSign)
    

  239.         {
    

  240.             return 0;
    

  241.         }
    

  242.     }
    


  243. 

  244.     if(u16Buffcount == Data_Lenght)                         //���ݳ���λ
    

  245.     {
    

  246.         DataLength = ((uint16_t)tSCICom.u8SCIRXBuffer[1]<<8)+((uint16_t)tSCICom.u8SCIRXBuffer[2]);
    

  247.         if(DataLength <= PacketSize)
    

  248.          {
    

  249.             tSCICom.u16UpdateDataLength = DataLength;
    

  250.          }
    

  251.         else
    

  252.         {
    

  253.             memset(tSCICom.u8SCIRXBuffer, 0, 3);
    

  254.             return 0;
    

  255.         }
    

  256.     }
    


  257. 

  258.     if(u16Buffcount == (tSCICom.u16UpdateDataLength + 7))              //����У��λ
    

  259.          {
    


  260. 

  261.              CRC_Check = Cal_CRC16(tSCICom.u8SCIRXBuffer, (u16Buffcount + 1));
    

  262.              if(CRC_Check == 0)
    

  263.              {
    

  264.                  tUpdateFlash.u8UpdateDataStatus = 0;
    

  265.                  tUpdateFlash.u8UpdateDataFlag   = 0;              //�����ȴ���¼whileѭ��
    

  266.              }
    

  267.              else
    

  268.              {
    

  269.                  tUpdateFlash.u8UpdateDataStatus = Check_Fail;
    

  270.                  return 0;
    

  271.              }
    

  272.          }
    


  273. 

  274.     return 1;
    

  275. }
    


  276. 

  277. //=============================================================================
    

  278. // End of file.
    

  279. //=============================================================================

BootLoader写好后，就要设计在线升级上位机，前面讲过C#，也已经打通了电脑对DSP之间的串口通信回路，上位机只要根据下位机在线升级的通讯协议进行通讯，即可对烧录文件进行解析，然后下发烧录到DSP内部的flash；
烧录演示如下：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

 楼主| 电笔小新 发表于 2025-10-14 18:02 | 显示全部楼层
8. 软件系统架构升级
以前做一些逆变器项目，系统比较复杂，任务之间的优先级需要严格考虑，常用的是CCS自带的Bios操作系统，这个系统比较封闭，只能用于CCS编程环境。对于既写MCU和DSP两个平台的软件工程师来说，要是能够统一用FreeRTOS 或者Ucos操作系统，那管理软件代码的工作量就小很多了；所以在工作之余就有尝试自己去在CCS编程环境下去做FreeRTOS和Ucos的移植。在公司领导不让用，说非官方移植的说不定有很多软件Bug，要把控好软件风险。刚好这次就拿着个平衡车平台做一下验证。
其实下载最新版本的C2000ware，里面已经有FreeRTOS的demo例程，说明TI现在也开始服软，没那么强硬强推自己的Bios。Demo例程只是提供了一些比较新的芯片，像F28335、F28035就没有例程提供。
F28035_FreeRTOS的移植我在是官方C2000_F28003x_C28x_CCS_DEMO的工程上进行移植的，只需将相关的F28003X文件更换成F2803X文件即可：
使用FreeRTOS任务管理初始化如下：
复制
  1. /******************************************************************************
    

  2.  *    FILENAME : Main.c
    

  3.  *
    

  4.  *    PURPOSE  : FreeRTOS V10.4.6 + F28035 ������̬����
    

  5.  *
    

  6.  *    Author: ���С��                      Created on: 2025��9��12��
    

  7. ******************************************************************************/
    

  8. #include "User_Include.h"
    


  9. 

  10. #include "FreeRTOS.h"
    

  11. #include "task.h"
    

  12. #include "semphr.h"
    


  13. 

  14. //=============================================================================
    

  15. // *  Variables & Function_Defines
    

  16. //=============================================================================
    


  17. 

  18. //Idle_task
    

  19. #define STACK_SIZE  256U
    

  20. static StaticTask_t idleTaskBuffer;
    

  21. static StackType_t  idleTaskStack[STACK_SIZE];
    


  22. 

  23. //Start_task
    

  24. #define START_TASK_PRIO       1          //�������ȼ�
    

  25. #define START_STK_SIZE        128U        //�����ջ��С
    

  26. TaskHandle_t StartTask_Handle;           //������
    

  27. static StaticTask_t StartTaskBuffer;
    

  28. static StackType_t  StartTaskStack[START_STK_SIZE];
    

  29. void Start_task(void* pvParameters);     //������
    


  30. 


  31. 

  32. //App_task1
    

  33. #define APP_TASK1_PRIO        4
    

  34. #define TASK1_STK_SIZE        256U
    

  35. TaskHandle_t AppTask1_Handle;
    

  36. static StaticTask_t AppTask1Buffer;
    

  37. static StackType_t  AppTask1Stack[TASK1_STK_SIZE];
    

  38. void App_task1(void * pvParameters);
    


  39. 

  40. //App_task2
    

  41. #define APP_TASK2_PRIO        2
    

  42. #define TASK2_STK_SIZE        256U
    

  43. TaskHandle_t AppTask2_Handle;
    

  44. static StaticTask_t AppTask2Buffer;
    

  45. static StackType_t  AppTask2Stack[TASK2_STK_SIZE];
    

  46. void App_task2(void* pvParameters);
    


  47. 

  48. //App_task3
    

  49. #define APP_TASK3_PRIO        3
    

  50. #define TASK3_STK_SIZE        512U
    

  51. TaskHandle_t AppTask3_Handle;
    

  52. static StaticTask_t AppTask3Buffer;
    

  53. static StackType_t  AppTask3Stack[TASK3_STK_SIZE];
    

  54. void App_task3(void* pvParameters);
    


  55. 

  56. //-------------------------------------------------------------------------------------------------
    

  57. void vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName )
    

  58. {
    

  59.     while(1);
    

  60. }
    


  61. 

  62. //-------------------------------------------------------------------------------------------------
    

  63. void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
    

  64. {
    

  65.     *ppxIdleTaskTCBBuffer = &idleTaskBuffer;
    

  66.     *ppxIdleTaskStackBuffer = idleTaskStack;
    

  67.     *pulIdleTaskStackSize = STACK_SIZE;
    

  68. }
    


  69. 

  70. //============================================================================
    

  71. // * Function    :  main()
    

  72. // * Purpose     :  �������������.
    

  73. // * Parameters  :
    

  74. // * Return      :  Null
    

  75. //============================================================================
    

  76. void main(void)
    

  77. {
    

  78.     InitDSPSystem();
    

  79.     InitParameter();
    


  80. 

  81. /* ����Start_task���� */
    

  82.     StartTask_Handle = xTaskCreateStatic((TaskFunction_t ) Start_task,           // Function that implements the task.
    

  83.                                          (const char*    ) "Start_task",         // Text name for the task.
    

  84.                                          (uint16_t       ) START_STK_SIZE,       // Number of indexes in the xStack array.
    

  85.                                          (void*          ) NULL,                 // Parameter passed into the task.
    

  86.                                          (UBaseType_t    ) START_TASK_PRIO,      // Priority at which the task is created.
    

  87.                                          (StackType_t*   ) StartTaskStack,       // Array to use as the task's stack.
    

  88.                                          (StaticTask_t*  ) &StartTaskBuffer );   // Variable to hold the task's data structure.
    

  89.     vTaskStartScheduler();
    

  90. }
    


  91. 

  92. //============================================================================
    

  93. // * Function    :  Start_task()
    

  94. // * Purpose     :  Ϊ�˷���������е����񴴽����������������������.
    

  95. // * Parameters  :
    

  96. // * Return      :  Null
    

  97. //============================================================================
    

  98. void Start_task(void* pvParameters)
    

  99. {
    


  100. 

  101.   taskENTER_CRITICAL(); //�����ٽ���
    


  102. 

  103. /* ����APP_task1���� */
    

  104.   AppTask1_Handle = xTaskCreateStatic((TaskFunction_t ) App_task1,           // Function that implements the task.
    

  105.                                       (const char*    ) "App_task1",         // Text name for the task.
    

  106.                                       (uint16_t       ) TASK1_STK_SIZE,      // Number of indexes in the xStack array.
    

  107.                                       (void*          ) NULL,                // Parameter passed into the task.
    

  108.                                       (UBaseType_t    ) APP_TASK1_PRIO,      // Priority at which the task is created.
    

  109.                                       (StackType_t*   ) AppTask1Stack,       // Array to use as the task's stack.
    

  110.                                       (StaticTask_t*  ) &AppTask1Buffer );   // Variable to hold the task's data structure.
    


  111. 

  112. /* ����APP_task2���� */
    

  113.   AppTask2_Handle = xTaskCreateStatic((TaskFunction_t ) App_task2,           // Function that implements the task.
    

  114.                                       (const char*    ) "App_task2",         // Text name for the task.
    

  115.                                       (uint16_t       ) TASK2_STK_SIZE,      // Number of indexes in the xStack array.
    

  116.                                       (void*          ) NULL,                // Parameter passed into the task.
    

  117.                                       (UBaseType_t    ) APP_TASK2_PRIO,      // Priority at which the task is created.
    

  118.                                       (StackType_t*   ) AppTask2Stack,       // Array to use as the task's stack.
    

  119.                                       (StaticTask_t*  ) &AppTask2Buffer );   // Variable to hold the task's data structure.
    


  120. 

  121. /* ����APP_task3���� */
    

  122.   AppTask3_Handle = xTaskCreateStatic((TaskFunction_t ) App_task3,           // Function that implements the task.
    

  123.                                       (const char*    ) "App_task3",         // Text name for the task.
    

  124.                                       (uint16_t       ) TASK3_STK_SIZE,      // Number of indexes in the xStack array.
    

  125.                                       (void*          ) NULL,                // Parameter passed into the task.
    

  126.                                       (UBaseType_t    ) APP_TASK3_PRIO,      // Priority at which the task is created.
    

  127.                                       (StackType_t*   ) AppTask3Stack,       // Array to use as the task's stack.
    

  128.                                       (StaticTask_t*  ) &AppTask3Buffer );   // Variable to hold the task's data structure.
    


  129. 


  130. 

  131.   vTaskDelete(StartTask_Handle); //ɾ��AppTaskCreate����
    


  132. 

  133.   taskEXIT_CRITICAL();    //�˳��ٽ���
    

  134. }
    


  135. 

  136. //---------------------------------------------------------------------------
    

  137. // App_task1:
    

  138. //---------------------------------------------------------------------------
    

  139. void App_task1(void * pvParameters)
    

  140. {
    

  141.     int Balance_Pwm,Velocity_Pwm,Turn_Pwm;              //ƽ�⻷PWM�������ٶȻ�PWM������ת��PWM��
    


  142. 

  143.     while (1)
    

  144.     {
    


  145. 

  146.         TEST1_H;
    


  147. 

  148.         Key_Scan();                                 //ɨ�谴��״̬
    

  149.         Laser_Scan();                               //��ȡ����ɨ����
    

  150.         Bat_volt=Get_battery_volt();                //��ȡ��ص�ѹ
    

  151.         UR_distance=Get_Distance();                 //��ȡ��������������ֵ
    

  152.         Encoder_Left=Read_Encoder(Left);            //��ȡ���ֱ�������ֵ��ǰ��Ϊ��������Ϊ��
    

  153.         Encoder_Right=Read_Encoder(Right);          //��ȡ���ֱ�������ֵ��ǰ��Ϊ��������Ϊ��
    

  154.         Get_Velocity_Form_Encoder(Encoder_Left,Encoder_Right);    //���㳵���ٶȣ�mm/s��
    

  155.         Get_Angle(Way_Angle);                       //������̬��10msһ�Σ����ߵIJ���Ƶ�ʿ��Ը��ƿ������˲��ͻ����˲���Ч��
    


  156. 

  157.         Balance_Pwm=Balance(Angle_Balance,Gyro_Balance);    //ƽ��PID���� Gyro_Balanceƽ����ٶȼ��ԣ�ǰ��Ϊ��������Ϊ��
    

  158.         Velocity_Pwm=Velocity(Encoder_Left,Encoder_Right);  //�ٶȻ�PID����  ��ס���ٶȷ�����������������С�����ʱ��Ҫ����������Ҫ���ܿ�һ��
    

  159.         Turn_Pwm=Turn(Gyro_Turn);
    


  160. 


  161. 

  162.         Motor_Left=Balance_Pwm+Velocity_Pwm+Turn_Pwm;       //�������ֵ������PWM
    

  163.         Motor_Right=Balance_Pwm+Velocity_Pwm-Turn_Pwm;      //�������ֵ������PWM
    

  164.                                                             //PWMֵ����ʹС��ǰ��������ʹС������
    


  165. 

  166.         Motor_Left=Output_Limit(Motor_Left,5800,-5800);
    

  167.         Motor_Right=Output_Limit(Motor_Right,5800,-5800);          //PWM�޷�
    


  168. 

  169.         if(Pick_Up(Acceleration_Z,Angle_Balance,Encoder_Left,Encoder_Right))//����Ƿ�С��������
    

  170.         Flag_Stop=1;                                                //���������͹رյ��
    


  171. 

  172.         Choose(Encoder_Left,Encoder_Right);                     //ת������ѡ��С��ģʽ
    

  173.         if(Turn_Off(Angle_Balance,Bat_volt)==0)                  //����������쳣
    

  174.         Set_Pwm(Motor_Left,Motor_Right);                    //��ֵ��PWM�Ĵ���
    


  175. 


  176. 

  177.         uwScope[5]=Balance_Pwm;
    

  178.         uwScope[6]=Velocity_Pwm;
    

  179.         uwScope[7]=Turn_Pwm;
    


  180. 


  181. 

  182.         IPOMS_SnatchGraph();
    

  183.         TEST1_L;
    


  184. 

  185.         vTaskDelay(6 / portTICK_PERIOD_MS);
    

  186.     }
    

  187. }
    


  188. 

  189. //---------------------------------------------------------------------------
    

  190. // App_task2:
    

  191. //---------------------------------------------------------------------------
    

  192. void App_task2(void * pvParameters)
    

  193. {
    

  194.     while (1)
    

  195.     {
    

  196.         LED1_TOGGLE;
    


  197. 

  198.         oled_show();  //OLED��ʾ
    

  199.         APP_Show();   //�ֻ�APP��ʾ
    


  200. 

  201.         vTaskDelay(100 / portTICK_PERIOD_MS);
    

  202.     }
    

  203. }
    


  204. 

  205. //---------------------------------------------------------------------------
    

  206. // App_task3:
    

  207. //---------------------------------------------------------------------------
    

  208. void App_task3(void * pvParameters)
    

  209. {
    

  210.     while (1)
    

  211.     {
    

  212.         LED2_TOGGLE;
    

  213.         TEST2_H;
    

  214.         pIPOMS_CommandIn0 = u8IPOMS_CommandBuffer0;
    

  215.         IPOMS_SCI();    //������λ����ʾ
    

  216.         TEST2_L;
    

  217.         vTaskDelay(500 / portTICK_PERIOD_MS);
    

  218.     }
    

  219. }
    


  220. 

  221. //============================================================================
    

  222. // End of file.
    

  223. //============================================================================
    


  224.
Ucos的移植也是一样的道理，在工程里面加入Ucos系统官方文件：
使用Ucos任务管理初始化如下：
复制
  1. /******************************************************************************
    

  2.  *    FILENAME : Main.c
    

  3.  *
    

  4.  *    PURPOSE  : uC/OS-II V2.9x + F28035 ������̬����
    

  5.  *
    

  6.  *    Author: ���С��                      Created on: 2025��9��12��
    

  7. ******************************************************************************/
    

  8. #include "User_Include.h"
    


  9. 

  10. //=============================================================================
    

  11. // *  Variables & Function_Defines
    

  12. //=============================================================================
    


  13. 

  14. CPU_STK_SIZE App_TaskStartStk[APP_TASK_STK_SIZE];
    


  15. 

  16. CPU_STK_SIZE App_Task1Stk[APP_TASK1_STK_SIZE];
    

  17. CPU_STK_SIZE App_Task2Stk[APP_TASK2_STK_SIZE];
    

  18. CPU_STK_SIZE App_Task3Stk[APP_TASK3_STK_SIZE];
    


  19. 

  20. //static OS_EVENT *AppTaskObjSem;
    


  21. 

  22. static void App_TaskStart(void *p_arg);
    


  23. 

  24. static void App_Task1(void *p_arg);
    

  25. static void App_Task2(void *p_arg);
    

  26. static void App_Task3(void *p_arg);
    


  27. 

  28. /*============================================================================*/
    


  29. 

  30. void main(void) 
    

  31. {
    

  32.     InitDSPSystem();
    

  33.     InitParameter();
    


  34. 

  35.         OSInit();
    

  36.         OSTaskCreateExt(App_TaskStart,
    

  37.                         (void     *)0,
    

  38.                         (CPU_STK  *)&App_TaskStartStk[0],
    

  39.                         (INT8U     )APP_TASK_START_PRIO,
    

  40.                         (INT16U    )APP_TASK_START_ID,
    

  41.                         (CPU_STK  *)&App_TaskStartStk[APP_TASK_STK_SIZE-1u],
    

  42.                         (INT32U    )APP_TASK_STK_SIZE,
    

  43.                         (void     *)0,
    

  44.                         (INT16U    )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
    

  45.         OSStart();
    


  46. 

  47. }
    


  48. 


  49. 

  50. //---------------------------------------------------------------------------
    

  51. // App_Functions:
    

  52. //---------------------------------------------------------------------------
    

  53. void APP_Tick_Init(void)
    

  54. {
    

  55.     EALLOW;
    

  56.     PieVectTable.OS_CPU_RTOSINT = &OS_CPU_RTOSINT_Handler;   //RTOS
    

  57.     InitCpuTimers();
    

  58.     ConfigCpuTimer(&CpuTimer0, 60, 1000);   //��ʱ��0��ʼ�����ڶ�������ΪCPU SYSCLK = 60M�� ����������Ϊ�趨�����ڣ�us��λ
    

  59.     CpuTimer0Regs.TCR.bit.TSS = 0;          // To start or restart the CPU-timer, set TSS to 0
    


  60. 

  61.     PieCtrlRegs.PIEIER1.bit.INTx7 = 1;      //Enable TINT0 in the PIE
    

  62.     IER |= M_INT1;                          //Enable group_1 interrupt
    


  63. 

  64.     EINT;                                   //Enable Global interrupt INTM
    

  65.     ERTM;                                   //Enable Global interrupt DBGM
    

  66. }
    


  67. 


  68. 

  69. static void App_TaskStart(void *p_arg)
    

  70. {
    

  71. //   volatile CPU_INT08U os_err;
    


  72. 

  73.    (void)&p_arg;
    

  74.    APP_Tick_Init();
    


  75. 

  76. //   AppTaskObjSem = OSSemCreate(0);
    

  77.    OSTaskCreateExt(App_Task1,
    

  78.                       (void     *)0,
    

  79.                       (CPU_STK  *)&App_Task1Stk[0],
    

  80.                       (INT8U     )APP_TASK1_PRIO,
    

  81.                       (INT16U    )APP_TASK1_ID,
    

  82.                       (CPU_STK  *)&App_Task1Stk[APP_TASK1_STK_SIZE-1u],
    

  83.                       (INT32U    )APP_TASK_STK_SIZE,
    

  84.                       (void     *)0,
    

  85.                       (INT16U    )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
    


  86. 

  87.    OSTaskCreateExt(App_Task2,
    

  88.                       (void     *)0,
    

  89.                       (CPU_STK  *)&App_Task2Stk[0],
    

  90.                       (INT8U     )APP_TASK2_PRIO,
    

  91.                       (INT16U    )APP_TASK2_ID,
    

  92.                       (CPU_STK  *)&App_Task2Stk[APP_TASK2_STK_SIZE-1u],
    

  93.                       (INT32U    )APP_TASK_STK_SIZE,
    

  94.                       (void     *)0,
    

  95.                       (INT16U    )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
    


  96. 

  97.    OSTaskCreateExt(App_Task3,
    

  98.                       (void     *)0,
    

  99.                       (CPU_STK  *)&App_Task3Stk[0],
    

  100.                       (INT8U     )APP_TASK3_PRIO,
    

  101.                       (INT16U    )APP_TASK3_ID,
    

  102.                       (CPU_STK  *)&App_Task3Stk[APP_TASK3_STK_SIZE-1u],
    

  103.                       (INT32U    )APP_TASK3_STK_SIZE,
    

  104.                       (void     *)0,
    

  105.                       (INT16U    )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
    

  106. //   while(DEF_TRUE){
    

  107. // //        os_err = OSSemPost(AppTaskObjSem);
    

  108. //         OSTimeDlyHMSM(0, 0, 0, 1);
    

  109. //     }
    

  110.      OSTaskDel (APP_TASK_START_PRIO);  //ɾ��App_TaskStart����
    


  111. 

  112. }
    


  113. 

  114. //---------------------------------------------------------------------------
    

  115. // App_task1:
    

  116. //---------------------------------------------------------------------------
    

  117. static void App_Task1(void *p_arg)
    

  118. {
    

  119.     (void)&p_arg;
    

  120.     int Balance_Pwm,Velocity_Pwm,Turn_Pwm;              //ƽ�⻷PWM�������ٶȻ�PWM������ת��PWM��
    

  121.     while (DEF_TRUE){
    


  122. 

  123.          TEST1_H;
    

  124.          Key_Scan();                                 //ɨ�谴��״̬
    

  125.          Laser_Scan();                               //��ȡ����ɨ����
    

  126.          Bat_volt=Get_battery_volt();                //��ȡ��ص�ѹ
    

  127.          UR_distance=Get_Distance();                 //��ȡ��������������ֵ
    

  128.          Encoder_Left=Read_Encoder(Left);            //��ȡ���ֱ�������ֵ��ǰ��Ϊ��������Ϊ��
    

  129.          Encoder_Right=Read_Encoder(Right);          //��ȡ���ֱ�������ֵ��ǰ��Ϊ��������Ϊ��
    

  130.          Get_Velocity_Form_Encoder(Encoder_Left,Encoder_Right);    //���㳵���ٶȣ�mm/s��
    

  131.          Get_Angle(Way_Angle);                       //������̬��10msһ�Σ����ߵIJ���Ƶ�ʿ��Ը��ƿ������˲��ͻ����˲���Ч��
    


  132. 

  133.          Balance_Pwm=Balance(Angle_Balance,Gyro_Balance);    //ƽ��PID���� Gyro_Balanceƽ����ٶȼ��ԣ�ǰ��Ϊ��������Ϊ��
    

  134.          Velocity_Pwm=Velocity(Encoder_Left,Encoder_Right);  //�ٶȻ�PID����  ��ס���ٶȷ�����������������С�����ʱ��Ҫ����������Ҫ���ܿ�һ��
    

  135.          Turn_Pwm=Turn(Gyro_Turn);
    


  136. 


  137. 

  138.          Motor_Left=Balance_Pwm+Velocity_Pwm+Turn_Pwm;       //�������ֵ������PWM
    

  139.          Motor_Right=Balance_Pwm+Velocity_Pwm-Turn_Pwm;      //�������ֵ������PWM
    

  140.                                                              //PWMֵ����ʹС��ǰ��������ʹС������
    


  141. 

  142.          Motor_Left=Output_Limit(Motor_Left,5800,-5800);
    

  143.          Motor_Right=Output_Limit(Motor_Right,5800,-5800);          //PWM�޷�
    


  144. 

  145.          if(Pick_Up(Acceleration_Z,Angle_Balance,Encoder_Left,Encoder_Right))//����Ƿ�С��������
    

  146.          Flag_Stop=1;                                                //���������͹رյ��
    


  147. 

  148.          Choose(Encoder_Left,Encoder_Right);                     //ת������ѡ��С��ģʽ
    

  149.          if(Turn_Off(Angle_Balance,Bat_volt)==0)                  //����������쳣
    

  150.          Set_Pwm(Motor_Left,Motor_Right);                    //��ֵ��PWM�Ĵ���
    


  151. 


  152. 

  153.          uwScope[5]=Balance_Pwm;
    

  154.          uwScope[6]=Velocity_Pwm;
    

  155.          uwScope[7]=Turn_Pwm;
    


  156. 

  157.          IPOMS_SnatchGraph();
    

  158.          TEST1_L;
    


  159. 

  160.         OSTimeDlyHMSM(0, 0, 0, 6);
    

  161.     }
    

  162. }
    


  163. 

  164. //---------------------------------------------------------------------------
    

  165. // App_task2:
    

  166. //---------------------------------------------------------------------------
    

  167. static void App_Task2(void *p_arg)
    

  168. {
    

  169.     (void)&p_arg;
    

  170.     while (DEF_TRUE){
    

  171.         LED1_TOGGLE;
    

  172.         oled_show();  //OLED��ʾ
    

  173.         APP_Show();   //�ֻ�APP��ʾ
    

  174.         OSTimeDlyHMSM(0, 0, 0, 100);
    

  175.     }
    

  176. }
    


  177. 

  178. //---------------------------------------------------------------------------
    

  179. // App_task3:
    

  180. //---------------------------------------------------------------------------
    

  181. static void App_Task3(void *p_arg)
    

  182. {
    

  183.     (void)&p_arg;
    

  184.     while (DEF_TRUE){
    


  185. 

  186.         LED2_TOGGLE;
    

  187.         TEST2_H;
    

  188.         pIPOMS_CommandIn0 = u8IPOMS_CommandBuffer0;
    

  189.         IPOMS_SCI();    //������λ����ʾ
    

  190.         TEST2_L;
    


  191. 

  192.         OSTimeDlyHMSM(0, 0, 0, 500);
    

  193.     }
    

  194. }
    

  195. //=============================================================================
    

  196. // End of file.
    

  197. //=============================================================================
    


  198. 


  199. 

  200.
下面两台车子分别用了Ucos和FreeRTOS，虽然没有用示波器去观看任务优先级，但是从两台车子运行的流畅度看，应该是没什么大问题，后续如果需要增加新功能可以直接在这两个系统上去增加管理任务。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

电笔小新

14

主题

23

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部