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

STM32无刷电机全套开发资料(源码、原理图、PCB工程及说明文档)

作者：小小林熬夜学编程 | 2024-04-10 23:31:26

赞

踩

STM32无刷电机全套开发资料(源码、原理图、PCB工程及说明文档)

目录

1、原理图、PCB、BOOM表

2、设计描述 

2.1 前言

2.2 设计电路规范

 3、代码

4、资料清单

资料下载地址：STM32无刷电机全套开发资料(源码、原理图、PCB工程及说明文档)

1、原理图、PCB、BOOM表

 

2、设计描述 

2.1 前言

        经过一个星期的画PCB，今天终于化了，整体看上去还比较满意，具体的性能基本满足需求

2.2 设计电路规范

 1、线间距。

      这里应该遵循3W规则，所谓3W就是为了减少线间串扰，应保证线间距足够大，当线中心不少于3倍线宽，则可 保持70%的电场不互相干扰。如要达到98%的电场不互相干扰，可使用10W的间距。——这是查阅华为PCB布线规则所得。

 

     2、电源线过细。

      这里我查阅了华为PCB教程得到了下面一个表格。这里线宽跟所能承受最大电流的关系表

  3、电源环路。（用图说明）

 3、代码

  1. /*
  2.     This file is part of AutoQuad ESC32.
  4.     AutoQuad ESC32 is free software: you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation, either version 3 of the License, or
  7.     (at your option) any later version.
  9.     AutoQuad ESC32 is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  13.     You should have received a copy of the GNU General Public License
  14.     along with AutoQuad ESC32.  If not, see
  16.     Copyright © 2011, 2012, 2013  Bill Nesbitt
  17. */
  18.  
  19. #include "run.h"
  20. #include "main.h"
  21. #include "timer.h"
  22. #include "adc.h"
  23. #include "fet.h"
  24. #include "pwm.h"
  25. #include "cli.h"
  26. #include "binary.h"
  27. #include "config.h"
  28. #include "misc.h"
  29. #include "stm32f10x_exti.h"
  30. #include "stm32f10x_pwr.h"
  31. #include "stm32f10x_iwdg.h"
  32. #include "stm32f10x_dbgmcu.h"
  33. #include <math.h>
  34.  
  35. uint32_t runMilis;   //systick中断中自加.没有什么控制用途
  36. static uint32_t oldIdleCounter;  //上次main函数中,死循环次数.
  37. float idlePercent;   //空闲时间百分比(在main循环里,什么事情也不做.main死循环运行的时间)
  38. float avgAmps, maxAmps; //平均电流, 最大电流
  39. float avgVolts;      //当前ADC采集转换后的电池电压(也就是12v)
  40.  
  41. float rpm;           //当前转速(1分钟多少转) 测量值 在runRpm函数中计算出来.在runThrotLim中还要继续使用.
  42. float targetRpm;     //目标转速 设定值(只在闭环 或 闭环推力模式下使用此变量)
  43.  
  44. static float rpmI;
  45. static float runRPMFactor;
  46. static float maxCurrentSQRT;  //最大电流 平方根 后
  47. uint8_t disarmReason;//此变量没啥作用.只用于给上位机显示当前的 调试代码(或者说停止电机的原因)
  48. uint8_t commandMode; //串口通讯的模式, cli是ascii模式, binary是二进制通讯模式
  49. static uint8_t runArmCount;
  50. volatile uint8_t runMode;//运行模式 (开环模式, RPM模式, 推力模式, 伺服模式)
  51. static float maxThrust;
  52.  
  53. //执行看门狗喂狗
  54. void runFeedIWDG(void) {
  55. #ifdef RUN_ENABLE_IWDG
  56.     IWDG_ReloadCounter();
  57. #endif
  58. }
  59.  
  60. // setup the hardware independent watchdog
  61. // 初始化并开启独立看门狗
  62. uint16_t runIWDGInit(int ms)
  63. {
  64. #ifndef RUN_ENABLE_IWDG
  65.     return 0;
  66. #else
  67.         uint16_t prevReloadVal;
  68.         int reloadVal;
  69.  
  70.         IWDG_ReloadCounter();//喂狗
  71.  
  72.         DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE);//当在jtag调试的时候.停止看门狗
  73.  
  74.         // IWDG timeout equal to 10 ms (the timeout may varies due to LSI frequency dispersion)
  75.         // Enable write access to IWDG_PR and IWDG_RLR registers
  76.         IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);//允许访问IWDG_PR和IWDG_RLR寄存器
  77.  
  78.         // IWDG counter clock: LSI/4
  79.         IWDG_SetPrescaler(IWDG_Prescaler_4);
  80.  
  81.         // Set counter reload value to obtain 10ms IWDG TimeOut.
  82.         //  Counter Reload Value        = 10ms/IWDG counter clock period
  83.         //                                = 10ms / (RUN_LSI_FREQ/4)
  84.         //                                = 0.01s / (RUN_LSI_FREQ/4)
  85.         //                                = RUN_LSI_FREQ/(4 * 100)
  86.         //                                = RUN_LSI_FREQ/400
  87.         reloadVal = RUN_LSI_FREQ*ms/4000;
  88.  
  89.         if (reloadVal < 1)
  90.                 reloadVal = 1;
  91.         else if (reloadVal > 0xfff)
  92.                 reloadVal = 0xfff;
  93.  
  94.         prevReloadVal = IWDG->RLR;
  95.  
  96.         IWDG_SetReload(reloadVal);
  97.  
  98.         // Reload IWDG counter
  99.         IWDG_ReloadCounter();
  100.  
  101.         // Enable IWDG (the LSI oscillator will be enabled by hardware)
  102.         IWDG_Enable();
  103.  
  104.         return (prevReloadVal*4000/RUN_LSI_FREQ);
  105. #endif
  106. }
  107.  
  108. //esc32 非正常停止运行 进入初始化
  109. void runDisarm(int reason) {
  110.         fetSetDutyCycle(0);  //fet占空比设置为0
  111.  
  112.         timerCancelAlarm2();
  113.         state = ESC_STATE_DISARMED;
  114.         pwmIsrAllOn();
  115.  
  116.         digitalHi(statusLed);   // turn off
  117.         digitalLo(errorLed);    // turn on
  118.         disarmReason = reason;  // 设置停机原因.给上位机查看状态使用
  119. }
  120.  
  121. //手动运行
  122. void runArm(void) {
  123.         int i;
  124.  
  125.         fetSetDutyCycle(0);
  126.         timerCancelAlarm2();
  127.         digitalHi(errorLed);
  128.         digitalLo(statusLed);   // turn on
  129.  
  130.         if (runMode == SERVO_MODE) {
  131.                 state = ESC_STATE_RUNNING;
  132.         }
  133.         else {
  134.                 state = ESC_STATE_STOPPED;
  135.                 if (inputMode == ESC_INPUT_UART)
  136.                         runMode = OPEN_LOOP;
  137.                 fetSetBraking(0);
  138.         }
  139.  
  140.         // extra beeps signifying run mode
  141.         for (i = 0; i < runMode + 1; i++) {
  142.                 fetBeep(250, 600);
  143.                 timerDelay(10000);
  144.         }
  145.  
  146. //        fetBeep(150, 800);
  147. }
  148.  
  149. //电机开始运行
  150. void runStart(void) {
  151.         // reset integral bevore new motor startup
  152.         runRpmPIDReset();//先复位I值
  153.  
  154.         if ((p[START_ALIGN_TIME] == 0) && (p[START_STEPS_NUM] == 0)) {
  155.                 state = ESC_STATE_STARTING;  //设置为准备启动状态
  156.                 fetStartCommutation(0);//换向启动
  157.         }
  158.         else {
  159.                 motorStartSeqInit();//普通启动
  160.         }
  161. }
  162.  
  163. //电机停止运行
  164. void runStop(void) {
  165.     runMode = OPEN_LOOP;
  166.     fetSetDutyCycle(0);
  167. }
  168.  
  169. //设置运行的占空比 duty = 0~100
  170. uint8_t runDuty(float duty) {
  171.     uint8_t ret = 0;
  172.  
  173.     if (duty >= 0.0f || duty <= 100.0f) {
  174.                 runMode = OPEN_LOOP;
  175.                 fetSetBraking(0);
  176.                 fetSetDutyCycle((uint16_t)(fetPeriod*duty*0.01f));//最大周期 * 占空比(0~100) / 100
  177.                 ret = 1;
  178.     }
  179.  
  180.     return ret;
  181. }
  182.  
  183. //pwm.c中断中调用  或  串口命令输入调用
  184. void runNewInput(uint16_t setpoint) {
  185.         static uint16_t lastPwm;
  186.         static float filteredSetpoint = 0;
  187.  
  188.         // Lowpass Input if configured
  189.         // TODO: Make lowpass independent from pwm update rate
  190.         if (p[PWM_LOWPASS]) {
  191.                 filteredSetpoint = (p[PWM_LOWPASS] * filteredSetpoint + (float)setpoint) / (1.0f + p[PWM_LOWPASS]);
  192.                 setpoint = filteredSetpoint;
  193.         }
  194.  
  195.         if (state == ESC_STATE_RUNNING && setpoint != lastPwm)
  196.         {
  197.                 if (runMode == OPEN_LOOP)
  198.                 {
  199.                         //开环模式
  200.                         fetSetDutyCycle(fetPeriod * (int32_t)(setpoint-pwmLoValue) / (int32_t)(pwmHiValue - pwmLoValue));
  201.                 }
  202.                 else if (runMode == CLOSED_LOOP_RPM)
  203.                 {
  204.                         //闭环转速模式
  205.                         float target = p[PWM_RPM_SCALE] * (setpoint-pwmLoValue) / (pwmHiValue - pwmLoValue);
  206.  
  207.                         // limit to configured maximum
  208.                         targetRpm = (target > p[PWM_RPM_SCALE]) ? p[PWM_RPM_SCALE] : target;
  209.                 }
  210.                 // THRUST Mode
  211.                 else if (runMode == CLOSED_LOOP_THRUST)
  212.                 {
  213.                         //闭环推力模式
  214.                         float targetThrust;  // desired trust
  215.                         float target;        // target(rpm)
  216.  
  217.                         // Calculate targetThrust based on input and MAX_THRUST
  218.                         targetThrust = maxThrust * (setpoint-pwmLoValue) / (pwmHiValue - pwmLoValue);
  219.  
  220.                         // Workaraound: Negative targetThrust will screw up sqrtf() and create MAX_RPM on throttle min. Dangerous!
  221.                         if (targetThrust > 0.0f) {
  222.                                 // Calculate target(rpm) based on targetThrust
  223.                                 target = ((sqrtf(p[THR1TERM] * p[THR1TERM] + 4.0f * p[THR2TERM] * targetThrust) - p[THR1TERM] ) / ( 2.0f * p[THR2TERM] ));
  224.                         }
  225.                         // targetThrust is negative (pwm_in < pwmLoValue)
  226.                         else {
  227.                                 target = 0.0f;
  228.                         }
  229.  
  230.                         // upper limit for targetRpm is configured maximum PWM_RPM_SCALE (which is MAX_RPM)
  231.                         targetRpm = (target > p[PWM_RPM_SCALE]) ? p[PWM_RPM_SCALE] : target;
  232.                 }
  233.                 else if (runMode == SERVO_MODE)
  234.                 {
  235.                         //伺服模式下
  236.                         fetSetAngleFromPwm(setpoint);
  237.                 }
  238.  
  239.                 lastPwm = setpoint;
  240.         }
  241.         else if ((state == ESC_STATE_NOCOMM || state == ESC_STATE_STARTING) && setpoint <= pwmLoValue)
  242.         {
  243.                 fetSetDutyCycle(0);
  244.                 state = ESC_STATE_RUNNING;
  245.         }
  246.         else if (state == ESC_STATE_DISARMED && setpoint > pwmMinValue && setpoint <= pwmLoValue)
  247.         {
  248.                 runArmCount++;
  249.                 if (runArmCount > RUN_ARM_COUNT)
  250.                         runArm();
  251.         }
  252.         else {
  253.                 runArmCount = 0;
  254.         }
  255.  
  256.         if (state == ESC_STATE_STOPPED && setpoint >= pwmMinStart) {
  257.                 //电机开始运行
  258.                 runStart();
  259.         }
  260. }
  261.  
  262. //电调运行看门狗. 主要是判断电调的当前一些状态.做出停机等处理
  263. static void runWatchDog(void)
  264. {
  265.         register uint32_t t, d, p;
  266.  
  267.         //__asm volatile ("cpsid i");
  268.         //CPSID_I();
  269.         __disable_irq();
  270.         t = timerMicros;      //当前的系统tick时间
  271.         d = detectedCrossing;
  272.         p = pwmValidMicros;   //在PWM输入模式下.把timerMicros的时间赋值给此变量
  273.         //__asm volatile ("cpsie i");
  274.         //CPSIE_I();
  275.         __enable_irq();
  276.  
  277.         if (state == ESC_STATE_STARTING && fetGoodDetects > fetStartDetects) //这里要检测到fetStartDetects好的检测,才允许切换电机状态
  278.         {
  279.                 //是启动状态.切换到 运行状态
  280.                 state = ESC_STATE_RUNNING;
  281.                 digitalHi(statusLed);   // turn off
  282.         }
  283.         else if (state >= ESC_STATE_STOPPED)
  284.         {
  285.                 //运行模式状态下.会一直在这里检测状态.如果状态不对出错.会调用runDisarm函数停止
  286.  
  287.                 // running or starting
  288.                 d = (t >= d) ? (t - d) : (TIMER_MASK - d + t);
  289.  
  290.                 // timeout if PWM signal disappears
  291.                 if (inputMode == ESC_INPUT_PWM)
  292.                 {
  293.                         //PWM模式 判断PWM输入是否超时
  294.                         p = (t >= p) ? (t - p) : (TIMER_MASK - p + t);
  295.  
  296.                         if (p > PWM_TIMEOUT)
  297.                                 runDisarm(REASON_PWM_TIMEOUT);//pwm输入超时
  298.                 }
  299.  
  300.                 if (state >= ESC_STATE_STARTING && d > ADC_CROSSING_TIMEOUT)
  301.                 {
  302.                         if (fetDutyCycle > 0) {
  303.                                 runDisarm(REASON_CROSSING_TIMEOUT);//错误停止
  304.                         }
  305.                         else
  306.                         {
  307.                                 runArm();//手动运行起来
  308.                                 pwmIsrRunOn();//PWM开启输入比较
  309.                         }
  310.                 }
  311.                 else if (state >= ESC_STATE_STARTING && fetBadDetects > fetDisarmDetects)  //运行状态中  检测到错误的个数后.进入这个判断
  312.                 {
  313.                         //在运行过程中,出现错误.停止运行
  314.                         if (fetDutyCycle > 0)
  315.                                 runDisarm(REASON_BAD_DETECTS);//错误停止
  316.                 }
  317.                 else if (state == ESC_STATE_STOPPED)
  318.                 {
  319.                         //停止模式
  320.                         adcAmpsOffset = adcAvgAmps;        // record current amperage offset
  321.                 }
  322.         }
  323.         else if (state == ESC_STATE_DISARMED && !(runMilis % 100))
  324.         {
  325.                 //停止模式下
  326.                 adcAmpsOffset = adcAvgAmps;        // record current amperage offset
  327.                 digitalTogg(errorLed);
  328.         }
  329. }
  330.  
  331. void runRpmPIDReset(void) {
  332.     rpmI = 0.0f;
  333. }
  334.  
  335. //这个应该是计算PID
  336. //rpm:测量的转速值
  337. //target:目标的转速值
  338. static int32_t runRpmPID(float rpm, float target) {
  339.         float error;
  340.         float ff, rpmP;
  341.         float iTerm = rpmI;
  342.         float output;
  343.  
  344.         // feed forward
  345.         ff = ((target*target* p[FF1TERM] + target*p[FF2TERM]) / avgVolts) * fetPeriod;
  346.  
  347.         error = (target - rpm);//计算出偏差
  348.  
  349.         if (error > 1000.0f)
  350.                 error = 1000.0f;
  351.  
  352.         if (error > 0.0f) {
  353.                 rpmP = error * p[PTERM];  //P
  354.                 rpmI += error * p[ITERM]; //I
  355.         }
  356.         else {
  357.                 rpmP =  error * p[PTERM] * p[PNFAC];
  358.                 rpmI += error * p[ITERM] * p[INFAC];
  359.         }
  360.  
  361.         if (fetBrakingEnabled)
  362.         {
  363.                 //开启了制动模式
  364.                 if (rpm < 300.0f) {
  365.                         fetSetBraking(0);
  366.                 }
  367.                 else if (error <= -100.0f) {
  368.                         fetSetBraking(1);
  369.                 }
  370.                 else if (fetBraking && error > -25.0f){
  371.                         fetSetBraking(0);
  372.                 }
  373.         }
  374.  
  375.         output = ff + (rpmP + rpmI) * (1.0f / 1500.0f) * fetPeriod;
  376.  
  377.         // don't allow integral to continue to rise if at max output
  378.         if (output >= fetPeriod)
  379.                 rpmI = iTerm;
  380.  
  381.         return output;
  382. }
  383.  
  384. //计算出电机转速,根据当前转速计算出PID输出值,设置占空比
  385. static uint8_t runRpm(void)
  386. {
  387.     if (state > ESC_STATE_STARTING)
  388.         {
  389.                 //电机处于运行状态 计算出当前转速rpm
  390.                 //        rpm = rpm * 0.90f + (runRPMFactor / (float)crossingPeriod) * 0.10f;
  391.                 //        rpm -= (rpm - (runRPMFactor / (float)crossingPeriod)) * 0.25f;
  392.                 //        rpm = (rpm + (runRPMFactor / (float)crossingPeriod)) * 0.5f;
  393.                 //        rpm = (rpm + ((32768.0f * runRPMFactor) / (float)adcCrossingPeriod)) * 0.5f; // increased resolution, fixed filter here
  394.                 rpm = p[RPM_MEAS_LP] * rpm + ((32768.0f * runRPMFactor) / (float)adcCrossingPeriod) * (1.0f - p[RPM_MEAS_LP]); // increased resolution, variable filter here
  395.  
  396.                 // run closed loop control
  397.                 if (runMode == CLOSED_LOOP_RPM)
  398.                 {
  399.                         //运行在闭环模式下
  400.                         fetSetDutyCycle(runRpmPID(rpm, targetRpm));
  401.                         return 1;
  402.                 }
  403.                 // run closed loop control also for THRUST mode
  404.                 else if (runMode == CLOSED_LOOP_THRUST)
  405.                 {
  406.                         //运行在闭环推力模式
  407.                         fetSetDutyCycle(runRpmPID(rpm, targetRpm));
  408.                         return 1;
  409.                 }
  410.                 else
  411.                 {
  412.                         return 0;
  413.                 }
  414.         }
  415.         else
  416.         {
  417.                 //电机在停止状态下
  418.                 rpm = 0.0f;
  419.                 return 0;
  420.     }
  421. }
  422.  
  423. static void runSetupPVD(void) {
  424.     EXTI_InitTypeDef EXTI_InitStructure;
  425.     NVIC_InitTypeDef NVIC_InitStructure;
  426.  
  427.     // Configure EXTI Line16(PVD Output) to generate an interrupt on rising and falling edges
  428.     EXTI_ClearITPendingBit(EXTI_Line16);
  429.     EXTI_InitStructure.EXTI_Line = EXTI_Line16;
  430.     EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  431.     EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  432.     EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  433.     EXTI_Init(&EXTI_InitStructure);
  434.  
  435.     // Enable the PVD Interrupt
  436.     NVIC_InitStructure.NVIC_IRQChannel = PVD_IRQn;
  437.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  438.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  439.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  440.     NVIC_Init(&NVIC_InitStructure);
  441.  
  442.     // Configure the PVD Level to 2.2V
  443.     PWR_PVDLevelConfig(PWR_PVDLevel_2V2);//配置pvd电压等级.当电压小于2.2V的时候产生中断
  444.  
  445.     // Enable the PVD Output
  446.     PWR_PVDCmd(ENABLE);
  447. }
  448.  
  449. void runInit(void) {
  450.     runSetupPVD();
  451.     runSetConstants();
  452.     runMode = p[STARTUP_MODE];//启动 运行模式
  453.  
  454.         //系统tickcount时钟
  455.     SysTick_Config(SystemCoreClock / 1000); // 1ms
  456.     NVIC_SetPriority(SysTick_IRQn, 2);            // lower priority
  457.  
  458.     // setup hardware watchdog
  459.     runIWDGInit(20);
  460. }
  461.  
  462. #define RUN_CURRENT_ITERM        1.0f
  463. #define RUN_CURRENT_PTERM        10.0f
  464. #define RUN_MAX_DUTY_INCREASE        1.0f
  465.  
  466. float currentIState;
  467.  
  468. //根据PID计算出PWM占空比的值
  469. static int32_t runCurrentPID(int32_t duty) {
  470.     float error;
  471.     float pTerm, iTerm;
  472.  
  473.     error = avgAmps - p[MAX_CURRENT];
  474.  
  475.     currentIState += error;
  476.     if (currentIState < 0.0f)
  477.                 currentIState = 0.0f;
  478.     iTerm = currentIState * RUN_CURRENT_ITERM;
  479.  
  480.     pTerm = error * RUN_CURRENT_PTERM;
  481.     if (pTerm < 0.0f)
  482.                 pTerm = 0.0f;
  483.  
  484.     duty = duty - iTerm - pTerm;
  485.  
  486.     if (duty < 0)
  487.                 duty = 0;
  488.  
  489.     return duty;
  490. }
  491.  
  492. //计算得到实际的占空比fetActualDutyCycle
  493. //参数duty:实际上就是fetDutyCycle传递进来的.想要运行的周期
  494. static void runThrotLim(int32_t duty)
  495. {
  496.         float maxVolts; //最大的电压
  497.         int32_t maxDuty;//最大的周期
  498.  
  499.         // only if a limit is set
  500.         if (p[MAX_CURRENT] > 0.0f)
  501.         {
  502.                 //如果实际的占空比和设置的占空比不一样.那么会实时改变CPU的PWM寄存器.
  503.  
  504.                 // if current limiter is calibrated - best performance   使用电流限制器校准.性能最好
  505.                 if (p[CL1TERM] != 0.0f)
  506.                 {
  507.                         maxVolts = p[CL1TERM] + p[CL2TERM]*rpm + p[CL3TERM]*p[MAX_CURRENT] + p[CL4TERM]*rpm*maxCurrentSQRT + p[CL5TERM]*maxCurrentSQRT;
  508.                         maxDuty = maxVolts * (fetPeriod / avgVolts);
  509.  
  510.                         if (duty > maxDuty)
  511.                                 fetActualDutyCycle = maxDuty;
  512.                         else
  513.                                 fetActualDutyCycle = duty;
  514.                 }
  515.                 // otherwise, use PID - less accurate, lower performance  使用PID来计算.不大准确.性能低
  516.                 else
  517.                 {
  518.                         fetActualDutyCycle += fetPeriod * (RUN_MAX_DUTY_INCREASE * 0.01f);
  519.                         if (fetActualDutyCycle > duty)
  520.                                 fetActualDutyCycle = duty;
  521.                         fetActualDutyCycle = runCurrentPID(fetActualDutyCycle);//用PID来计算出当前要运行的占空比
  522.                 }
  523.         }
  524.         else {
  525.                 fetActualDutyCycle = duty;
  526.         }
  527.  
  528.         //设置到CPU寄存器里.算出来的实际PWM占空比
  529.         _fetSetDutyCycle(fetActualDutyCycle);
  530. }
  531.  
  532. //系统tickcount中断
  533. void SysTick_Handler(void) {
  534.     // reload the hardware watchdog
  535.     runFeedIWDG();
  536.  
  537.  
  538.     avgVolts = adcAvgVolts * ADC_TO_VOLTS;                     //转换后的电池电压(一般是12V) = ADC采集电压原始值 * 电压算法
  539.     avgAmps = (adcAvgAmps - adcAmpsOffset) * adcToAmps;        //平均电流 = (当前电流 - 停止时候的电流) * 转换公式
  540.     maxAmps = (adcMaxAmps - adcAmpsOffset) * adcToAmps;        //最大电流 = (最大电流 - 停止时候的电流) * 转换公式
  541.  
  542.  
  543.     if (runMode == SERVO_MODE)
  544.         {
  545.                 //伺服模式
  546.                 fetUpdateServo();
  547.     }
  548.     else
  549.         {
  550.                 runWatchDog();//检测电调的状态.做出相应的停机处理
  551.                 runRpm();     //计算RPM,计算PID,设置运行PWM占空比
  552.                 runThrotLim(fetDutyCycle);//计算得到实际PWM占空比.如果有偏差.那么在这里会实时改变PWM的占空比值
  553.     }
  554.  
  555.  
  556.         //计算空闲时间百分比 通过串口发送给上位机  没什么用途
  557.     idlePercent = 100.0f * (idleCounter-oldIdleCounter) * minCycles / totalCycles;
  558. //  空闲时间百分比 = 100 * (本次循环次数 - 上次循环次数) * 最小周期 / 总共周期
  559.     oldIdleCounter = idleCounter;
  560.     totalCycles = 0;
  561.  
  562.  
  563.         //处理串口数据 和串口交互使用的
  564.     if (commandMode == CLI_MODE)
  565.                 cliCheck();    //ascii模式
  566.     else
  567.                 binaryCheck(); //二进制模式
  568.  
  569.     runMilis++;
  570. }
  571.  
  572. //低电压中断
  573. void PVD_IRQHandler(void) {
  574.     // voltage dropping too low
  575.     if (EXTI_GetITStatus(EXTI_Line16) != RESET) {
  576.                 // shut everything down
  577.                 runDisarm(REASON_LOW_VOLTAGE);
  578.  
  579.                 // turn on both LEDs
  580.                 digitalLo(statusLed);
  581.                 digitalLo(errorLed);
  582.  
  583.                 EXTI_ClearITPendingBit(EXTI_Line16);
  584.     }
  585. }
  586.  
  587. void runSetConstants(void) {
  588.     int32_t startupMode = (int)p[STARTUP_MODE];
  589.     float maxCurrent = p[MAX_CURRENT];
  590.  
  591.         //运行模式
  592.     if (startupMode < 0 || startupMode >= NUM_RUN_MODES)
  593.                 startupMode = 0;
  594.  
  595.     if (maxCurrent > RUN_MAX_MAX_CURRENT)
  596.                 maxCurrent = RUN_MAX_MAX_CURRENT;
  597.     else if (maxCurrent < RUN_MIN_MAX_CURRENT)
  598.                 maxCurrent = RUN_MIN_MAX_CURRENT;
  599.  
  600.     runRPMFactor = (1e6f * (float)TIMER_MULT * 120.0f) / (p[MOTOR_POLES] * 6.0f);
  601.     maxCurrentSQRT = sqrtf(maxCurrent);
  602.  
  603.     p[MOTOR_POLES] = (int)p[MOTOR_POLES];
  604.     p[STARTUP_MODE] = startupMode;
  605.     p[MAX_CURRENT] = maxCurrent;
  606.  
  607.     // Calculate MAX_THRUST from PWM_RPM_SCALE (which is MAX_RPM) and THRxTERMs
  608.     // Based on "thrust = rpm * a1 + rpm^2 * a2"
  609.     maxThrust = p[PWM_RPM_SCALE] * p[THR1TERM] + p[PWM_RPM_SCALE] * p[PWM_RPM_SCALE] * p[THR2TERM];
  610. }

4、资料清单

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

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

  

闽ICP备14008679号