AM32 电调学习--tenKhzRoutine()函数分析

最新推荐文章于 2024-08-20 12:20:23 发布
最新推荐文章于 2024-08-20 12:20:23 发布
阅读量1.1k 收藏 19
点赞数 20
文章标签： 学习 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ashang2002/article/details/138809030
版权

AM32 电调学习–输入获取分析

#define INTERVAL_TIMER TIM2 ; 过零时间测量
psc=31
#define TEN_KHZ_TIMER TIM6 ;tenKhzRoutine frq=1M load=1M/20k
psc=63
#define UTILITY_TIMER TIM17
#define COM_TIMER TIM14 //PeriodElapsedCallback 过零后等待时间中断
psc=31
#define IC_TIMER_REGISTER TIM3
psc=0
PB4 tim3_chn1

一、使用到的变量

dma1chan1 interrupt transfercomplete:

  1. uint16_t signaltimeout = 0;
  2. out_put: 0:receiveDshotDma1:
    1:sendDshotDma
  3. char dshot_telemetry = 0; dshort检测到标志
processDshot(EXTI4_15_IRQHandler)<--DMA1_Channel1_IRQHandler
  1. ic_timer_prescaler char ic_timer_prescaler = CPU_FREQUENCY_MHZ / 5;
  2. output_timer_prescaler
        if (CPU_FREQUENCY_MHZ > 100) {
            output_timer_prescaler = 1;
        } else {
            output_timer_prescaler = 0;
        }
  1. char inputSet = 0; 输入方式是否已经决定标志

二、输入端口设置

  1. PB4设置为tim3 channel1.
  2. dma1 channel1 ,方向per(halfword)–>memory(word)
  3. 分频为0
  4. 双沿触发

三、开始处理

  1. 在main初始化中调用receiveDshotDma().
  2. 在dma中断中处理transfercomplete()
void transfercomplete()
{
    signaltimeout = 0;
    if (armed && dshot_telemetry) {
        if (out_put) {
            receiveDshotDma();
            compute_dshot_flag = 2;
            return;
        } else {
            sendDshotDma();
            compute_dshot_flag = 1;
            return;
        }
    }
    if (inputSet == 0) {
        detectInput();
        receiveDshotDma();
        return;
    }
    if (inputSet == 1) {

        if (dshot_telemetry) {
            if (out_put) {
                make_dshot_package(e_com_time);
                computeDshotDMA();
                receiveDshotDma();
                return;
            } else {
                sendDshotDma();
                return;
            }
        } else {

            if (dshot == 1) {
                computeDshotDMA();
                receiveDshotDma();
            }
            if (servoPwm == 1) {
                if (getInputPinState()) {
                    buffersize = 3;
                } else {
                    buffersize = 2;
                    computeServoInput();
                }
                receiveDshotDma();
            }
        }
        if (!armed) {
            if (dshot && (average_count < 8) && (zero_input_count > 5)) {
                average_count++;
                average_packet_length = average_packet_length + (dma_buffer[31] - dma_buffer[0]);
                if (average_count == 8) {
                    dshot_frametime_high = (average_packet_length >> 3) + (average_packet_length >> 7);
                    dshot_frametime_low = (average_packet_length >> 3) - (average_packet_length >> 7);
                }
            }
            if (adjusted_input < 0) {
                adjusted_input = 0;
            }
            if (adjusted_input == 0 && calibration_required == 0) { // note this in input..not newinput so it
                                                                    // will be adjusted be main loop
                zero_input_count++;
            } else {
                zero_input_count = 0;
                if (adjusted_input > 1500) {
                    if (getAbsDif(adjusted_input, last_input) > 50) {
                        enter_calibration_count = 0;
                    } else {
                        enter_calibration_count++;
                    }

                    if (enter_calibration_count > 50 && (!high_calibration_set)) {
                        playBeaconTune3();
                        calibration_required = 1;
                        enter_calibration_count = 0;
                    }
                    last_input = adjusted_input;
                }
            }
        }
    }
}
  1. 判定输入方式
    (A) PPM信号的最小间隔在150us–1500us之间
    (B) dshot600的最小间距在100ns-700ns
    dshot300的最小间隔城200-1400ns之间
void detectInput()
{
    smallestnumber = 20000;
    average_signal_pulse = 0;
    int lastnumber = dma_buffer[0];
    for (int j = 1; j < 31; j++) {
        if (dma_buffer[j] - lastnumber > 0) {
            if ((dma_buffer[j] - lastnumber) < smallestnumber) {
                smallestnumber = dma_buffer[j] - lastnumber;
            }
            average_signal_pulse += (dma_buffer[j] - lastnumber);
        }
        lastnumber = dma_buffer[j];
    }
    average_signal_pulse = average_signal_pulse / 32;

    if (dshot == 1) {
        checkDshot();
    }
    if (servoPwm == 1) {
        checkServo();
    }

    if (!dshot && !servoPwm) {
        checkDshot();
        checkServo();
    }
}

void checkServo()
{
    if (smallestnumber > 200 && smallestnumber < 20000) {
        servoPwm = 1;
        ic_timer_prescaler = CPU_FREQUENCY_MHZ - 1;
        buffersize = 2;
        inputSet = 1;
    }
}

void checkDshot()
{
    if ((smallestnumber > 1) && (smallestnumber <= 4) && (average_signal_pulse < 60)) {
        ic_timer_prescaler = 0;
        if (CPU_FREQUENCY_MHZ > 100) {
            output_timer_prescaler = 1;
        } else {
            output_timer_prescaler = 0;
        }
        //	dshot_runout_timer = 1000;
        dshot = 1;
        buffer_padding = 14;
        buffersize = 32;
        inputSet = 1;
    }
    if ((smallestnumber > 4) && (smallestnumber <= 8) && (average_signal_pulse < 100)) {
        dshot = 1;
        ic_timer_prescaler = 1;
        if (CPU_FREQUENCY_MHZ > 100) {
            output_timer_prescaler = 3;
        } else {
            output_timer_prescaler = 1;
        }
        buffer_padding = 7;
        buffersize = 32;
        inputSet = 1;
    }
}

四、dma的输入和输出

  1. 输入
void receiveDshotDma()
{
#ifdef USE_TIMER_3_CHANNEL_1
    RCC->APBRSTR1 |= LL_APB1_GRP1_PERIPH_TIM3;
    RCC->APBRSTR1 &= ~LL_APB1_GRP1_PERIPH_TIM3;
    IC_TIMER_REGISTER->CCMR1 = 0x61;  //fdts/4  N=6,  fdts 是clk_int/ckd[cr1]
    IC_TIMER_REGISTER->CCER = 0xa;   //cc1np cc1p =11,双沿触发  output disable
#endif
#ifdef USE_TIMER_16_CHANNEL_1
    LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_TIM16); // de-init timer 2
    LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_TIM16);
    IC_TIMER_REGISTER->CCMR1 = 0x61;
    IC_TIMER_REGISTER->CCER = 0xa;
#endif

    IC_TIMER_REGISTER->PSC = ic_timer_prescaler;
    IC_TIMER_REGISTER->ARR = 0xFFFF;
    IC_TIMER_REGISTER->EGR |= TIM_EGR_UG;
    out_put = 0;
    IC_TIMER_REGISTER->CNT = 0;
    DMA1_Channel1->CMAR = (uint32_t)&dma_buffer;
    DMA1_Channel1->CPAR = (uint32_t)&IC_TIMER_REGISTER->CCR1;
    DMA1_Channel1->CNDTR = buffersize;
    DMA1_Channel1->CCR = 0x98b;     //9：m-32b p-16b 8:  minc  接收   b: en/tc/te
    IC_TIMER_REGISTER->DIER |= TIM_DIER_CC1DE;    //dma int enable
    IC_TIMER_REGISTER->CCER |= IC_TIMER_CHANNEL;
    IC_TIMER_REGISTER->CR1 |= TIM_CR1_CEN;  //counter enable
}
  1. 输出：
void sendDshotDma()
{
#ifdef USE_TIMER_3_CHANNEL_1
    RCC->APBRSTR1 |= LL_APB1_GRP1_PERIPH_TIM3;
    RCC->APBRSTR1 &= ~LL_APB1_GRP1_PERIPH_TIM3;
    IC_TIMER_REGISTER->CCMR1 = 0x60;
    IC_TIMER_REGISTER->CCER = 0x3;  //output enable ,activate low
#endif
#ifdef USE_TIMER_16_CHANNEL_1
    LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_TIM16); // de-init timer 2
    LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_TIM16);
    IC_TIMER_REGISTER->CCMR1 = 0x60;
    IC_TIMER_REGISTER->CCER = 0x3;
#endif
    IC_TIMER_REGISTER->PSC = output_timer_prescaler;
    IC_TIMER_REGISTER->ARR = 92;
    out_put = 1;
    LL_TIM_GenerateEvent_UPDATE(IC_TIMER_REGISTER);

    DMA1_Channel1->CMAR = (uint32_t)&gcr;
    DMA1_Channel1->CPAR = (uint32_t)&IC_TIMER_REGISTER->CCR1;
    DMA1_Channel1->CNDTR = 23 + buffer_padding;
    DMA1_Channel1->CCR = 0x99b;   //9：m-32b p-16b 9:  minc 发送  b: en/tc/te
    IC_TIMER_REGISTER->DIER |= TIM_DIER_CC1DE;
    IC_TIMER_REGISTER->CCER |= IC_TIMER_CHANNEL;
    IC_TIMER_REGISTER->BDTR |= TIM_BDTR_MOE;  //输出enable
    IC_TIMER_REGISTER->CR1 |= TIM_CR1_CEN;
}

五、ppm解码

void computeServoInput()
{
    if (((dma_buffer[1] - dma_buffer[0]) > 800) && ((dma_buffer[1] - dma_buffer[0]) < 2200)) {

        if (calibration_required) {
            if (!high_calibration_set) {
                if (high_calibration_counts == 0) {
                    last_high_threshold = dma_buffer[1] - dma_buffer[0];
                }
                high_calibration_counts++;
                if (getAbsDif(last_high_threshold, servo_high_threshold) > 50) {
                    calibration_required = 0;
                } else {
                    servo_high_threshold = ((7 * servo_high_threshold + (dma_buffer[1] - dma_buffer[0])) >> 3);
                    if (high_calibration_counts > 50) {
                        servo_high_threshold = servo_high_threshold - 25;
                        eepromBuffer[33] = (servo_high_threshold - 1750) / 2;
                        high_calibration_set = 1;
                        playDefaultTone();
                    }
                }
                last_high_threshold = servo_high_threshold;
            }
            if (high_calibration_set) {
                if (dma_buffer[1] - dma_buffer[0] < 1250) {
                    low_calibration_counts++;
                    servo_low_threshold = ((7 * servo_low_threshold + (dma_buffer[1] - dma_buffer[0])) >> 3);
                }
                if (low_calibration_counts > 75) {
                    servo_low_threshold = servo_low_threshold + 25;
                    eepromBuffer[32] = (servo_low_threshold - 750) / 2;
                    calibration_required = 0;
                    saveEEpromSettings();
                    low_calibration_counts = 0;
                    playChangedTone();
                }
            }
            signaltimeout = 0;
        } else {
            if (bi_direction) {
                if (dma_buffer[1] - dma_buffer[0] <= servo_neutral) {
                    servorawinput = map((dma_buffer[1] - dma_buffer[0]),
                        servo_low_threshold, servo_neutral, 0, 1000);
                } else {
                    servorawinput = map((dma_buffer[1] - dma_buffer[0]), servo_neutral + 1,
                        servo_high_threshold, 1001, 2000);
                }
            } else {
                servorawinput = map((dma_buffer[1] - dma_buffer[0]), servo_low_threshold,
                    servo_high_threshold, 47, 2047);
                if (servorawinput <= 48) {
                    servorawinput = 0;
                }
            }
            signaltimeout = 0;
        }
    } else {
        zero_input_count = 0; // reset if out of range
    }

    if (servorawinput - newinput > max_servo_deviation) {
        newinput += max_servo_deviation;
    } else if (newinput - servorawinput > max_servo_deviation) {
        newinput -= max_servo_deviation;
    } else {
        newinput = servorawinput;
    }
}

六、dshot解码

void computeDshotDMA()
{
    int j = 0;
    dshot_frametime = dma_buffer[31] - dma_buffer[0];
    halfpulsetime = dshot_frametime >> 5;
    if ((dshot_frametime > dshot_frametime_low) && (dshot_frametime < dshot_frametime_high)) {
        for (int i = 0; i < 16; i++) {
            dpulse[i] = ((dma_buffer[j + (i << 1) + 1] - dma_buffer[j + (i << 1)]) > (halfpulsetime));
        }
        uint8_t calcCRC = ((dpulse[0] ^ dpulse[4] ^ dpulse[8]) << 3 | (dpulse[1] ^ dpulse[5] ^ dpulse[9]) << 2 | (dpulse[2] ^ dpulse[6] ^ dpulse[10]) << 1 | (dpulse[3] ^ dpulse[7] ^ dpulse[11]));
        uint8_t checkCRC = (dpulse[12] << 3 | dpulse[13] << 2 | dpulse[14] << 1 | dpulse[15]);

        if (!armed) {
            if (dshot_telemetry == 0) {
                if (getInputPinState()) { // if the pin is high for 100 checks between
                                          // signal pulses its inverted
                    high_pin_count++;
                    if (high_pin_count > 100) {
                        dshot_telemetry = 1;
                    }
                }
            }
        }
        if (dshot_telemetry) {
            checkCRC = ~checkCRC + 16;
        }

        int tocheck = (dpulse[0] << 10 | dpulse[1] << 9 | dpulse[2] << 8 | dpulse[3] << 7 | dpulse[4] << 6 | dpulse[5] << 5 | dpulse[6] << 4 | dpulse[7] << 3 | dpulse[8] << 2 | dpulse[9] << 1 | dpulse[10]);

        if (calcCRC == checkCRC) {
            signaltimeout = 0;
            dshot_goodcounts++;
            if (dpulse[11] == 1) {
                send_telemetry = 1;
            }
            if (tocheck > 47) {
                if (EDT_ARMED) {
                    newinput = tocheck;
                    dshotcommand = 0;
                    command_count = 0;
                    return;
                }
            }

            if ((tocheck <= 47) && (tocheck > 0)) {
                newinput = 0;
                dshotcommand = tocheck; //  todo
            }
            if (tocheck == 0) {
                if (EDT_ARM_ENABLE == 1) {
                    EDT_ARMED = 0;
                }
                newinput = 0;
                dshotcommand = 0;
                command_count = 0;
            }

            if ((dshotcommand > 0) && (running == 0) && armed) {
                if (dshotcommand != last_command) {
                    last_command = dshotcommand;
                    command_count = 0;
                }
                if (dshotcommand < 5) { // beacons
                    command_count = 6; // go on right away
                }
                command_count++;
                if (command_count >= 6) {
                    command_count = 0;
                    switch (dshotcommand) { // todo

                    case 1:
                        play_tone_flag = 1;
                        break;
                    case 2:
                        play_tone_flag = 2;
                        break;
                    case 3:
                        play_tone_flag = 3;
                        break;
                    case 4:
                        play_tone_flag = 4;
                        break;
                    case 5:
                        play_tone_flag = 5;
                        break;
                    case 7:
                        dir_reversed = 0;
                        forward = 1 - dir_reversed;
                        //	play_tone_flag = 1;
                        break;
                    case 8:
                        dir_reversed = 1;
                        forward = 1 - dir_reversed;
                        //	play_tone_flag = 2;
                        break;
                    case 9:
                        bi_direction = 0;
                        break;
                    case 10:
                        bi_direction = 1;
                        break;
                    case 12:
                        saveEEpromSettings();
                        play_tone_flag = 1 + dir_reversed;
                        //	NVIC_SystemReset();
                        break;
                    case 13:
                        dshot_extended_telemetry = 1;
                        send_extended_dshot = 0b111000000000;
                        if (EDT_ARM_ENABLE == 1) {
                            EDT_ARMED = 1;
                        }
                        break;
                    case 14:
                        dshot_extended_telemetry = 0;
                        send_extended_dshot = 0b111011111111;
                        //	make_dshot_package();
                        break;
                    case 20:
                        forward = 1 - dir_reversed;
                        break;
                    case 21:
                        forward = dir_reversed;
                        break;
                    }
                    last_dshot_command = dshotcommand;
                    dshotcommand = 0;
                }
            }
        } else {
            dshot_badcounts++;
        }
    }
}

stm32定时器学习

  1. 定时器复位
     RCC->APBRSTR1 |= LL_APB1_GRP1_PERIPH_TIM3;
    RCC->APBRSTR1 &= ~LL_APB1_GRP1_PERIPH_TIM3;
  1. ppm 信号，每个脉宽是0.5ms （15us — 1500us)
    在这里插入图片描述
  2. dshot信号
    在这里插入图片描述
    dshot600: frq: 600k 周期: 1s/600k = 1667ns T0h=625ns T1h=1250ns
    dshot100: 1s/100k=10000ns
    dshot300: 1s/300k = 3300ns
    dshot1200: 1s/1200k = 832ns
ashang2002
关注
好盈无刷电调驱动-stm32与arduino控制电调
weixin_42119432的博客
11-08 1万+
好盈无刷电调驱动-stm32与arduino控制电调电调驱动原理以及试验，附源码与试验结果。
无刷电调刷blheli固件软件教程打包
01-29
无刷电调（BLHeli）固件是用于无刷电机控制器的重要软件，它负责管理电机的运行，包括速度控制、动态响应优化等关键功能。本教程将详细讲解如何为你的无刷电调刷写BLHeli固件，以实现更顺畅的操作和显著的动力提升。...
AM32开源代码之代码分析 - DSHOT/BDSHOT
最新发布
lida2003的专栏
08-20 692
从目前库上代码看，还有很多DSHOT命令相关的代码上没有合入， AM32的代码可能更多的还是需要从历史版本中查询。#62#55。
AM32 电调学习
ashang2002的博客
05-10 443
【代码】AM32 电调学习。
AM32 多旋翼电调固件安装与使用教程
gitblog_01048的博客
08-08 589
AM32 多旋翼电调固件安装与使用教程 AM32-MultiRotor-ESC-firmwareFirmware for stm32f051 based speed controllers for use with mutirotors项目地址:https://gitcode.com/gh_mirrors/am/AM32-MultiRotor-ESC-firmware 项目介绍 AM32 多旋...
【AM32 电调学习】
ashang2002的博客
05-14 1400
（0）换相过程简述 开始启动时：old_routine设置，tenKhzRoutine()任务中检测反相电动势，获取到零点后，执行zcfoundroutine().标志zcfound守护到换相结束。 zcfoundroutine （1）六步换相定义 pid am32 esc 一、使用的变量 armed 电机识别标志 TLM_ON_INTERVAL dshot需要发送telemetry uint8_t telemetry_interval_ms = 30;
探索AM32多旋翼电调固件：解锁飞行控制的新境界
gitblog_00036的博客
04-14 1020
探索AM32多旋翼电调固件：解锁飞行控制的新境界 AM32-MultiRotor-ESC-firmwareFirmware for stm32f051 based speed controllers for use with mutirotors项目地址:https://gitcode.com/gh_mirrors/am/AM32-MultiRotor-ESC-firmware 在无人机和多旋翼...
无刷电机学习-方波电调 程序篇1（AM32）
m0_46521000的博客
01-23 4358
AM32学习程序篇1
Arduino_STM32-master.zip
02-17
GitHub上下载的Roger Clark的库，是STM32的Arduino支持包。下载后放在Arduino的hardware目录下即可对STM32写程序，相比keil开发更简单。这个文件比较大，Github上面下载超级慢，而且下载一旦断开就得重新下载，所以...
f051bldc:无刷电机控制STM32F051
05-22
f051bldc 2021年1月更新 此项目不再更新，建议使用AM32固件安装 无刷电机控制stm32f051 2020年1月更新，全新启动。 项目已移至cubeIDE，因此可以下载整个目录并可以在该IDE中打开。 对于其他IDELinux，最好打开cubeMX文件并为相应的ide生成外围设备设置代码，然后复制main.c和_it.c 当前工作：车辆模式， eeprom模式或多转子（保存的设置），使用dshot命令启用3d模式或电机方向。 履带，推进器模式（可逆，全制动，无惯性运行，正弦启动） 遥控车模式，倒车可调节制动器，双击可倒车 没有eeprom，要测试设置 互补的pwm开/关选项。 输入自动检测，dshot 300、600或pwm（其他已在固件中，但现在已禁用，单发，多发，proshot） 变频pwm输出，在大多数使用范围内与电动机旋转相匹配（动态变化范围为24-4
ATMega8制作无感无刷（BLDC）电调全套资料（C源程序固件SCH和PCB）
03-29
1. "偶做的电调实物图1.jpg" 和 "偶做的电调实物图2.jpg"：这可能是作者制作的电调实物的照片，展示了实际的硬件组装效果，对理解和学习硬件布局有帮助。 2. "BLDC-M8.pdf"：这可能是一个详细的项目指南或技术报告，...
AM32电调学习笔记
ashang2002的博客
05-08 1542
【代码】AM32电调学习笔记。
无刷电机学习-方波电调 电路篇
m0_46521000的博客
01-23 3804
经过Buck电路后输入的电压已经变成了4.8V，而单片机的供电一般都是3.3V。想要彻底的理解无刷电机的驱动，那必然少不了学习他的驱动电路和程序。LDO芯片虽然也可以降压，但是发热大，输入输出的电压差不能太大，优点是稳定性好，负载响应快，输出纹波小，所以进行小压差降压后给主芯片供电。DC-DC芯片的作用是构成buck电路进行降压，效率高，输入电压范围较宽，可以高效的将一个较高电压给降到一个较低电压范围。（1）芯片的概述和特点。一个基本的无刷电机驱动电路大致包含电源电路、电流电压采样、电机驱动电路。
STM32固件库编成基础教程
XYJ_Tiger的博客
05-15 1667
STM32固件库编成教程， 1. 初识什么是固件库 2. 如何创建固件库工程模板 3. Keil 5 的一些使用小技巧
Dshot的使用说明书
weixin_39939185的博客
08-02 4192
Dshot - Digital Shot，是一个非常流行的，用于飞控与电调进行通信的通信协议。在四轴飞行器爱好者圈子中，它现在几乎是标准协议。该协议用于将目标油门值从飞控发送到电调，然后电调对其进行解码并相应地驱动电机。
STM32F051 MK电调 BLDC 直流无刷电机控制
2301_76674121的博客
02-24 442
基于STM32F051 cortex-M0的电调开发板，包含原理图 PCB工程文件，程序源码，BLDC控制入门资料，供初学者入门学习了解。STM32F051 MK电调 BLDC 直流无刷电机控制。
【AM32 电调学习–main()】
ashang2002的博客
05-15 681
am32 主程序流程
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值