AI32位8051交流社区，车规 AEC-Q100 Grade1 › BLDC/144MHz-PWM-硬件移相/45路PWM+3路CCP/7组不同周期的PWM/DAC › 分享一个低成本STC8H1K08无刷小电调，支持oneshot125协议

bhx 发表于 2025-4-27 20:34:40

分享一个低成本STC8H1K08无刷小电调，支持oneshot125协议

非常便宜的STC小电调，成本不到3元，长宽1cm*1cm，
可以用在小飞机上，支持oneshot125协议，开启了PWM互补输出，
响应速度很快，适合用在四轴小飞机上，固定翼也能用，
但是开互补PWM会更费电一点。

我接3元老王电机测试过2S 5042三叶桨满油门发热很小，
主要是因为这个电机电流小，具体能承受多大电流我没测过，
没找到合适的电机测试，我拿它做了个小四轴没什么问题。
这个是参考梁工的BLDC方案修改来的，原帖传送门。

硬件和软件
相比梁工原方案，硬件软件上做了一些修改，把原来的三极管反向换成了mos反向，mos用了集成P+Nmos，体积很小，一个半桥才3*3mm。
反馈电阻上并联的10nf滤波电容去掉了，这个本来是设计用来过滤PWM干扰，如果没有的话PWM会干扰过零检测，尤其是低速状态下非常明显，
我在程序上做了一些处理，启动的时候让过零检测和PWM同步，这样可以避开PWM干扰，具体说起来可能有点复杂，有空我再详细介绍一下。
启动部分的程序也重写了一遍，在启动时也检测过零信号，根据过零信号换向，转速到一定阈值后结束启动。
输入信号用PWM捕获检测oneshot125信号的高电平时间，转换成8位油门信号。

测试视频



源码和keil工程


#include "STC8Hxxx.h"
#include "intrins.h"

#define MAIN_Fosc 37000000UL                            //定义主时钟
#define BRT (65536UL - (MAIN_Fosc / 115200UL + 2) / 4)//串口波特率
#define STARTUP_INTERVAL 12000UL                        //启动时两次换向的最大间隔时间 us为单位
#define STARTUP_POWER 20                              //启动时的功率
#define STARTUP_THROTTLE 10                           //启动油门, 输入高于此值就启动电机
#define STOP_THROTTLE 10

sbit PWM1 = P1 ^ 0;
sbit PWM1_L = P1 ^ 1;
sbit PWM2 = P1 ^ 2;
sbit PWM2_L = P1 ^ 3;
sbit PWM3 = P1 ^ 4;
sbit PWM3_L = P1 ^ 5;

#define ADC_START (1 << 6) /* 自动清0 */
#define ADC_FLAG (1 << 5)/* 软件清0 */
#define ADC_SPEED 1      /* 0~15, ADC时钟 = SYSclk/2/(n+1) */
#define RES_FMT (1 << 5)   /* ADC结果格式 0: 左对齐, ADC_RES: D9 D8 D7 D6 D5 D4 D3 D2, ADC_RESL: D1 D0 000000 */
#define CSSETUP (0 << 7)   /* 0~1,ADC通道选择时间      0: 1个ADC时钟, 1: 2个ADC时钟,默认0(默认1个ADC时钟) */
#define CSHOLD (1 << 5)    /* 0~3,ADC通道选择保持时间(n+1)个ADC时钟, 默认1(默认2个ADC时钟)                */
#define SMPDUTY 20         /* 10~31, ADC模拟信号采样时间(n+1)个ADC时钟, 默认10(默认11个ADC时钟)       */
                           /* ADC转换时间: 10位ADC固定为10个ADC时钟, 12位ADC固定为12个ADC时钟.      */
bit B_Timer2_OverFlow, flag_4ms, B_RUN, B_start;
char step;
u8 p16cnt, p17cnt, PWM_Value, PWM_Set, TimeOut, TimeIndex, Demagnetize, gpio_state, edgeState, inputSigCnt, delayCnt, startDone;
u16 SIG_IN, PhaseTimeTmp, PWM_input, commutation_time, commutation_num, restart_delay, stallCnt, PhaseTime, commutate_interval;
u32 commutation_time_sum;
u16 ADC_Value;//电位器ADC值

typedef enum {
MOTOR_IDLE = 0,
MOTOR_PRE_POSITION,
MOTOR_STARTING,
MOTOR_STOP_STALL,
MOTOR_RESTART,
BYTE_LOW_VOLTAGE,
} runFlagType;
runFlagType run_flag;

//========================================================================
// 函数: u16      Get_ADC10bitResult(u8 channel))      //channel = 0~15
//========================================================================
u16 Get_ADC10bitResult(u8 channel)//channel = 0~15
{
u8 i;
ADC_RES = 0;
ADC_RESL = 0;
ADC_CONTR = 0x80 | ADC_START | channel;
NOP(5);//
         //      while((ADC_CONTR & ADC_FLAG) == 0)      ;      //等待ADC结束
i = 255;
while (i != 0) {
    i--;
    if ((ADC_CONTR & ADC_FLAG) != 0) break;//等待ADC结束
}
ADC_CONTR &= ~ADC_FLAG;
return ((u16)ADC_RES * 256 + (u16)ADC_RESL);
}
void ADC_config(void)//ADC初始化函数(为了使用ADC输入端做比较器信号, 实际没有启动ADC转换)
{
// P1n_pure_input(0xc0);      //设置为高阻输入
// P0n_pure_input(0x0f);      //设置为高阻输入
// ADC_CONTR = 0x80 + 6;      //ADC on + channel
ADCCFG = RES_FMT + ADC_SPEED;
ADCTIM = CSSETUP + CSHOLD + SMPDUTY;
}


void delay_us(u8 us)//N us延时函数
{
do {
    NOP(20);//@24MHz
} while (--us);
}

void Delay_500ns(void) {
NOP(6);
}

#define USE_CONTEMPRATY_PWM 1//互补PWM

void commutate(void) {
EA = 0;
if (++step >= 6) step = 0;
switch (step) {
    case 0:// ABPWM1, PWM2_L=1
      PWMA_ENO = 0x00;
      PWM1_L = 0;
      PWM3_L = 0;
      // Delay_500ns();
      PWMA_ENO = 0x01 + 0x02 * USE_CONTEMPRATY_PWM;
      PWM2_L = 1;
      ADC_CONTR = 0x80 + 11;
      if (!B_start) CMPCR1 = 0x8c + 0x10;
      break;
    case 1:// ACPWM1, PWM3_L=1
      PWMA_ENO = 0x01 + 0x02 * USE_CONTEMPRATY_PWM;
      PWM1_L = 0;
      PWM2_L = 0;
      // Delay_500ns();
      PWM3_L = 1;
      ADC_CONTR = 0x80 + 12;
      if (!B_start) CMPCR1 = 0x8c + 0x20;
      break;
    case 2:// BCPWM2, PWM3_L=1
      PWMA_ENO = 0x00;
      PWM1_L = 0;
      PWM2_L = 0;
      // Delay_500ns();
      PWMA_ENO = 0x04 + 0x08 * USE_CONTEMPRATY_PWM;
      PWM3_L = 1;
      ADC_CONTR = 0x80 + 13;
      if (!B_start) CMPCR1 = 0x8c + 0x10;
      break;
    case 3:// BAPWM2, PWM1_L=1
      PWMA_ENO = 0x04 + 0x08 * USE_CONTEMPRATY_PWM;
      PWM2_L = 0;
      PWM3_L = 0;
      // Delay_500ns();
      PWM1_L = 1;
      ADC_CONTR = 0x80 + 11;
      if (!B_start) CMPCR1 = 0x8c + 0x20;
      break;
    case 4:// CAPWM3, PWM1_L=1
      PWMA_ENO = 0x00;
      PWM2_L = 0;
      PWM3_L = 0;
      // Delay_500ns();
      PWMA_ENO = 0x10 + 0x20 * USE_CONTEMPRATY_PWM;
      PWM1_L = 1;
      // ADC_Value = ((ADC_Value * 7) >> 3) + Get_ADC10bitResult(8);
      ADC_CONTR = 0x80 + 12;
      if (!B_start) CMPCR1 = 0x8c + 0x10;
      break;
    case 5:// CBPWM3, PWM2_L=1
      PWMA_ENO = 0x10 + 0x20 * USE_CONTEMPRATY_PWM;
      PWM1_L = 0;
      PWM3_L = 0;
      // Delay_500ns();
      PWM2_L = 1;
      ADC_CONTR = 0x80 + 13;
      if (!B_start) CMPCR1 = 0x8c + 0x20;
      break;

    default:
      break;
}
EA = 1;
}

void PWMA_init(void) {
PWM1 = PWM1_L = PWM2 = PWM2_L = PWM3 = PWM3_L = 0;
P1n_push_pull(0x3f);// 0011 1111

PWMA_PSCR = 7;// 预分频寄存器, 分频 Fck_cnt = Fck_psc/(PSCR[15:0}+1), 边沿对齐PWM频率 = SYSclk/((PSCR+1)*(AAR+1)), 中央对齐PWM频率 = SYSclk/((PSCR+1)*(AAR+1)*2).
PWMA_DTR = 64;// 死区时间配置, n=0~127: DTR= n T,   0x80 ~(0x80+n), n=0~63: DTR=(64+n)*2T,

PWMA_ARR = 255;// 自动重装载寄存器,控制PWM周期
PWMA_CCER1 = 0;
PWMA_CCER2 = 0;
PWMA_SR1 = 0;
PWMA_SR2 = 0;
PWMA_ENO = 0;
PWMA_PS = 0;
PWMA_IER = 0;

PWMA_CCMR1 = 0x68;   // 通道模式配置, PWM模式1, 预装载允许
PWMA_CCR1 = 0;       // 比较值, 控制占空比(高电平时钟数)
PWMA_CCER1 |= 0x05;// 开启比较输出, 高电平有效
PWMA_PS |= 0;      // 选择IO, 0:选择P1.0 P1.1, 1:选择P2.0 P2.1, 2:选择P6.0 P6.1,

PWMA_CCMR2 = 0x68;    // 通道模式配置, PWM模式1, 预装载允许
PWMA_CCR2 = 0;      // 比较值, 控制占空比(高电平时钟数)
PWMA_CCER1 |= 0x50;   // 开启比较输出, 高电平有效
PWMA_PS |= (0 << 2);// 选择IO, 0:选择P1.2 P1.3, 1:选择P2.2 P2.3, 2:选择P6.2 P6.3,

PWMA_CCMR3 = 0x68;    // 通道模式配置, PWM模式1, 预装载允许
PWMA_CCR3 = 0;      // 比较值, 控制占空比(高电平时钟数)
PWMA_CCER2 |= 0x05;   // 开启比较输出, 高电平有效
PWMA_PS |= (0 << 4);// 选择IO, 0:选择P1.4 P1.5, 1:选择P2.4 P2.5, 2:选择P6.4 P6.5,

PWMA_CCMR4 = 0x68;   // 通道模式配置, PWM模式1, 预装载允许
PWMA_CCER2 |= 0x50;// 开启比较输出, 高电平有效
PWMA_CCR4 = 0xF0;    //PWM4触发中断, 同步采样, 在PWM周期快结束时对比较器采样，这时候没有PWM干扰


PWMA_BKR = 0x80;// 主输出使能 相当于总开关
PWMA_CR1 = 0x81;// 使能计数器, 允许自动重装载寄存器缓冲, 边沿对齐模式, 向上计数,bit7=1:写自动重装载寄存器缓冲(本周期不会被打扰), =0:直接写自动重装载寄存器本(周期可能会乱掉)
PWMA_EGR = 0x01;//产生一次更新事件, 清除计数器和与分频计数器, 装载预分频寄存器的值
}

void UART_init() {
SCON = 0x50;   //8位数据,可变波特率
AUXR = 0x40;   //定时器时钟1T模式
TMOD = 0x00;   //设置定时器模式
TL1 = BRT;       //设置定时初始值
TH1 = BRT >> 8;//设置定时初始值
TR1 = 1;         //定时器1开始计时
}

void CMP_init(void) {//比较器初始化程序
CMPCR1 = 0x8C;       // 1000 1100 打开比较器，P3.6作为比较器的反相输入端，ADC引脚作为正输入端
CMPCR2 = 60;         //60个时钟滤波   比较结果变化延时周期数, 0~63
}
u8 PhaseTimeTMP2;
void CMP_ISR(void) interrupt 21 {//比较器中断函数, 检测到反电动势过0事件
u8 i;
CMPCR1 &= ~0x40;// 需软件清除中断标志位
CMPCR1 = 0x8C;    // 关中断

if (Demagnetize == 0)//消磁后才检测过0事件,   Demagnetize=1:需要消磁, =2:正在消磁, =0已经消磁
{
    // P17=(++p17cnt)&1;
    AUXR &= ~0x10;          //停止定时器
    if (B_Timer2_OverFlow)//切换时间间隔(Timer3)有溢出
    {
      B_Timer2_OverFlow = 0;
      PhaseTime = 18000;//换相时间最大8ms, 2212电机12V空转最高速130us切换一相(200RPS 12000RPM), 480mA
    } else {
      PhaseTime = (((u16)T2H << 8) + T2L);      //单位为1us
      if (PhaseTime >= 8000) PhaseTime = 8000;//换相时间最大8ms, 2212电机12V空转最高速130us切换一相(200RPS 12000RPM), 480mA
    }

    T2H = 0;
    T2L = 0;
    AUXR |= 0x10;                                                            //开定时器
    commutation_time = PhaseTime;                                 //保存一次换相时间
    if (++TimeIndex >= 4) TimeIndex = 0;                                       //累加8次
    for (PhaseTime = 0, i = 0; i <= 3; i++) PhaseTime += commutation_time;//求换相时间累加和
    PhaseTime = PhaseTime >> 3;                                                //换相时间的平均值的一半, 即30度电角度
    if ((PhaseTime >= 30) && (PhaseTime <= 15000)) TimeOut = 2;                //堵转超时
    else PhaseTime = 30;
    PhaseTime = 0 - PhaseTime * 3;//T0是1/3us每个计数
    TR0 = 0;
    TH0 = (u8)(PhaseTime >> 8);//装载30度角延时
    TL0 = (u8)PhaseTime;
    TR0 = ET0 = Demagnetize = 1;//1:需要消磁, 2:正在消磁, 0已经消磁
}
}

void Timer0_init(void) {//Timer0初始化函数
Timer0_16bit();
Timer0_12T();
TH0 = 0;
TL0 = 0;
ET0 = 1;// 允许T0中断
}

void Timer0_ISR(void) interrupt TIMER0_VECTOR {

TR0 = 0;
if (Demagnetize == 1)//标记需要消磁. 每次检测到过0事件后第一次中断为30度角延时, 设置消磁延时.
{
    TH0 = (u8)((65536UL - 60) >> 8);//装载消磁延时20us左右
    TL0 = (u8)(65536UL - 60);
    TR0 = 1;
    Demagnetize = 2;//1:需要消磁, 2:正在消磁, 0已经消磁
    if (B_RUN)      //电机正在运行
    {
      commutate();
    }
} else if (Demagnetize == 2) {
    Demagnetize = 0;            //1:需要消磁, 2:正在消磁, 0已经消磁
    if (step & 1) CMPCR1 = 0xAC;//上升沿中断
    else CMPCR1 = 0x9C;         //下降沿中断
}
}

void Timer2_init(void) {
TM2PS = 2;
AUXR &= ~0x1c;//0001 1100 //停止计数, 定时模式, 12T模式
T2H = 0;
T2L = 0;
INTCLKO &= ~0x04;// 不输出时钟
// IE2 = ET2;      //允许中断
AUXR |= 0x10;//定时器2开始运行
}

void Timer2_Isr(void) interrupt TIMER2_VECTOR {
B_Timer2_OverFlow = 1;//溢出标志
}


void PWMB_init(void) {//检测输入PWM用
PWMB_PS = 4;          //输出选择PWM6_2
PWMB_PSCR = 1;      //分频
//CC5捕获TI6上升沿,CC6捕获TI6下降沿, 读取油门信号脉宽
PWMB_CCER1 = 0x00;   //先复位
PWMB_CCMR1 = 0x02;   //CC5为输入模式,且映射到TI6FP5上
PWMB_CCMR2 = 0x01;   //CC6为输入模式,且映射到TI6FP6上
PWMB_CCER1 = 0x11;   //使能CC5/CC6上的捕获功能
PWMB_CCER1 |= 0x00;//设置捕获极性为CC5的上升沿
PWMB_CCER1 |= 0x20;//设置捕获极性为CC6的下降沿

PWMB_CCER2 = 0x00;   //写CCMRx前必须先清零CCERx关闭通道
PWMB_CCMR3 = 0x60;   //设置CC7为PWM输出模式
PWMB_CCER2 = 0x01;   //使能CC7通道
PWMB_CCR3 = 0xEFFF;//设置占空比时间

// PWMB_IER = 1<<2; //使能捕获中断
// PWMB_IER = 8;       //任务定时器中断
PWMB_CR1 = 0x01;//使能计数器
}

void startMotor() {
u16 temp_commutation_time = (u16)(T2H << 8) | T2L;
u8 zcFound = 0;    //反电势过零信号
u8 pin_state = 0;//比较器状态计数, 连续8次相同状态才认为是有效比较器信号

switch (run_flag) {

    case MOTOR_PRE_POSITION:
      {
      CMPCR1 = 0x8C;// 关比较器中断
      ET0 = IE2 = 0;// 关闭定时器3 定时器4中断
      // 设置启动占空比
      PWM_Value = STARTUP_POWER;
      PWMA_CCR1L = STARTUP_POWER;
      PWMA_CCR2L = STARTUP_POWER;
      PWMA_CCR3L = STARTUP_POWER;

      if (((T2H << 8) | T2L) >= STARTUP_INTERVAL) {
          commutation_time = 6000;
          commutation_time = 6000;
          commutation_time = 6000;
          commutation_time = 6000;
          commutation_time = 6000;
          commutation_time = 6000;
          commutation_time_sum = commutation_time + commutation_time + commutation_time + commutation_time;
          // 清空定时器计数器值
          AUXR &= ~0x10;// 停止定时器
          T2L = 0;
          T2H = 0;
          AUXR |= 0x10;// 开启定时器
          commutate();
          run_flag = MOTOR_STARTING;
          stallCnt = 0;
          commutation_num = 0;
          // SBUF=(T2H<<8)|T2L;
      }
      }
      break;
    case MOTOR_STARTING:
      {
      // 通过位移的方式, 将电平数据存入变量中, 连续8次检测到相同电平才认为有效
      gpio_state = (gpio_state << 1) | edgeState;
      if (step & 1) {
          // 上升沿
          if (gpio_state == 0xFF)//(gpio_state == 0xFF)
          {
            zcFound = 1;
            gpio_state = 0xFF;
          }

      } else {
          //下降沿
          if (gpio_state == 0)//gpio_state == 0
          {
            zcFound = 1;
            gpio_state = 0x00;
          }
      }
      if (zcFound) {
          // P17=(p17cnt++)&1;
          AUXR &= ~0x10;// 停止定时器
          T2L = 0;
          T2H = 0;
          AUXR |= 0x10;// 开启定时器

          // 堵转计数清空
          stallCnt = 0;
          commutation_num++;
          commutation_time = temp_commutation_time;
          //滤波
          commutation_time_sum = commutation_time + commutation_time + commutation_time + commutation_time + commutation_time + commutation_time;
          // 等待30度
          commutate_interval = commutation_time_sum / 15;//这里应该是/12才对, 但是发现15好像好一点
          while (((u16)(T2H << 8) | T2L) <= commutate_interval - 450)
            ;//-450补偿检测换向的时间
          commutate();
          // P16=1;
          if ((commutation_num >= 11) && (commutation_time_sum <= 10000)) {
            // P16=0;

            commutation_time = commutation_time = commutation_time = commutation_time = commutation_time_sum / 6;
            startDone = 1;
            B_start = 0;
            B_RUN = 1;
            Demagnetize = 0;
            TimeOut = 200;

            PWM_Value = STARTUP_POWER;
            // PWMA_CCR1L = 0;
            // PWMA_CCR2L = 0;
            // PWMA_CCR3L = 0;

            delay_us(50);
            CMPCR1 &= ~0x40;            // 清除中断标志位
            if (step & 1) CMPCR1 = 0xAC;//上升沿中断
            else CMPCR1 = 0x9C;         //下降沿中断
            IE2 |= (1 << 5);            //允许T2中断
            return;
          }

      } else if (((u16)(T2H << 8) | T2L) >= STARTUP_INTERVAL) {
          AUXR &= ~0x10;// 停止定时器
          T2L = 0;
          T2H = 0;
          AUXR |= 0x10;                   // 开启定时器
          commutate();                  //P17=(p17cnt++)&1;
          run_flag = MOTOR_PRE_POSITION;//MOTOR_PRE_POSITION
      }
      }
      break;

    case MOTOR_IDLE://MOTOR_IDLE
      {
      B_RUN = 0;
      PWMA_CCR1L = 0;
      PWMA_CCR2L = 0;
      PWMA_CCR3L = 0;
      }
      break;
}
}


void PWMA_Isr() interrupt PWMA_VECTOR// CMP sample, read CMP state
{
edgeState = CMPCR1 & 1;
PWMA_SR1 = 0;         //clear INT flag
PWMA_IER &= ~(1 << 4);//disable PWMA 4 INT
startMotor();
if (B_RUN) PWMA_IER = 0;//disable PWMA 4 INT
else PWMA_IER = 1 << 4;   //enable PWMA 4 INT
}

void delay_ms(u8 dly) {
u16 j;
do {
    j = MAIN_Fosc / 10000;
    while (--j)
      ;
} while (--dly);
}
/*********************   main   *************************/

void main(void) {
PWM1 = PWM1_L = PWM2 = PWM2_L = PWM3 = PWM3_L = 0;
P1n_push_pull(0x3f);// 0011 1111
P_SW2 |= 0x80;      //SFR enable
PWMA_init();
PWMB_init();
CMP_init();
Timer0_init();// Timer0初始化函数
Timer2_init();// Timer2初始化函数
UART_init();
ADC_config();
PWM_Set = 0;
TimeOut = 0;

EA = 1;// 打开总中断

PWMB_SR1 = 0;
ADC_Value = 0;
delay_ms(250);
PWMB_SR1 &= ~0x04;

while (1) {
    if (PWMB_SR1 & 0x04) {
      SIG_IN = PWMB_CCR2 - PWMB_CCR1;//PWM输入捕获, 差值即为输入信号高电平宽度
                                       // SBUF=SIG_IN;
      if (SIG_IN < 0x08EC) SIG_IN = 0x08EC;
      if (SIG_IN > 0x1146) SIG_IN = 0x1146;
      SIG_IN = (((SIG_IN - 0x8EC) << 3) / 0x43);//换算为8位整数
      PWM_Set = SIG_IN;
      // SBUF=SIG_IN;

      if (B_RUN && (startDone == 0) && (B_start == 0)) {
      PWMA_CCR1L = PWM_Set;
      PWMA_CCR2L = PWM_Set;
      PWMA_CCR3L = PWM_Set;
      }
    }

    if (RI == 1) {
      RI = 0;
      if (SBUF == 0x7f) IAP_CONTR = 0X60;
    }//自动下载

    if (PWMB_SR1 & 8)// 4ms时
    {
      PWMB_SR1 &= ~8;

      if (TimeOut != 0) {
      if (--TimeOut == 0)//堵转超时
      {
          CMPCR1 = 0x8C;// 关比较器中断
          B_start = B_RUN = PWM_Value = 0;
          run_flag = MOTOR_IDLE;
      }
      }

      if (!B_RUN && (PWM_Set >= STARTUP_THROTTLE))// 占空比大于设定值, 并且电机未运行, 则启动电机
      {
      CMPCR1 = 0x8C;      // 关比较器中断
      PWMA_IER = 1 << 4;//使能PWMA 4 中断, 让过零采样与PWM同步, 避开PWM干扰
      B_start = 1;      //启动模式
      if (run_flag == MOTOR_IDLE) {
          AUXR |= 0x10;// 开启定时器2
          run_flag = MOTOR_PRE_POSITION;
      }
      } else if (PWM_Set == 0) run_flag = MOTOR_IDLE;

      if (B_RUN && startDone)//启动完成后让油门缓慢变化
      {
      if (PWM_Value < PWM_Set) PWM_Value++;//油门跟随电位器
      if (PWM_Value > PWM_Set) PWM_Value--;
      if (++startDone >= 150) startDone = 0;

      PWMA_CCR1L = PWM_Value;
      PWMA_CCR2L = PWM_Value;
      PWMA_CCR3L = PWM_Value;
      } else startDone = 0;

      PWMB_SR1 &= ~0x04;
    }
}
}

Jeffray415 发表于 2025-5-8 14:48:26

麻烦问一下，这三个是？

Jeffray415 发表于 2025-5-8 15:02:08

是这三个电阻吗？

bhx 发表于 2025-5-9 21:17:30

Jeffray415 发表于 2025-5-8 15:02
是这三个电阻吗？

对，就是这几个上拉电阻，要用0603的，功率大一点

神农鼎 发表于 2025-5-15 12:41:52

oneshot125，是为了发送速度更快而定义的协议，跟老的协议类似（1~2ms宽度），
就是速度快了8（125~250us）倍或16倍（62.5~125us），
通常用在要求响应速度快的穿越机上。属于脉位调制（PPM）。

DShot150/300/600/1200是数字协议，使用数字通信方式栓地控制数据，
每个目标16位数据（11位油门信号 + 1位电调信息回传 + 4位循环冗余校验），
150/300/600/1200表示位速率，
比如DShot600表示600Kbit/S，一位时间为1.667us，
数据0高电平0.625us（占空比为37.5%），数据1高电平1.25us（占空比为75%）。

QQ624353765 发表于 2025-5-17 08:18:05

你这反电动势有点问题啊？
ADC引脚上的电压要将近6V了

bhx 发表于 2025-5-17 18:22:20

QQ624353765 发表于 2025-5-17 08:18
你这反电动势有点问题啊？
ADC引脚上的电压要将近6V了

对，这个确实有点问题，从别的电路图改过来忘了改电源了，实际是用2节锂电供电，再高得换分压电阻比值

QQ624353765 发表于 2025-5-17 20:05:13

bhx 发表于 2025-5-17 18:22
对，这个确实有点问题，从别的电路图改过来忘了改电源了，实际是用2节锂电供电，再高得换分压电阻比值 ...

我玩无刷电机已经有大半年了，现在已经在哪吃灰了，还没有驱动成功。能不能指导我一下，我也是用官方的例程改的，还是有不解之处，能不能加个QQ
6-2-4-3-5-3-7-6-5

bhx 发表于 2025-5-18 20:57:17

QQ624353765 发表于 2025-5-17 20:05
我玩无刷电机已经有大半年了，现在已经在哪吃灰了，还没有驱动成功。能不能指导我一下，我也是用官方的例 ...

先直接拿梁工原版硬件软件做一个一模一样的，能正常转起来再一点点修改。我加你了。

电控小白 发表于 2025-5-20 17:06:26

bhx 发表于 2025-5-18 20:57
先直接拿梁工原版硬件软件做一个一模一样的，能正常转起来再一点点修改。我加你了。 ...

这个是逐飞＋梁工的结合啊

查看完整版本: 分享一个低成本STC8H1K08无刷小电调，支持oneshot125协议