Vibrating problem with 48V 23A BLDC motor

FurBlood · March 25, 2026, 6:23am

Hello everyone,

I am new to SimpleFOC and I’m struggling to get a smooth rotation with a high-power 48V 23A BLDC hub motor. I am using a custom board based on the STM32F405 MCU.

The Problem:

The motor is not spinning as expected. It vibrates violently (like a jackhammer) even at low speed commands (like 1 rad/s). I’ve tried setting a very low voltage limit (around 1V), but the motor remains stationary. Increasing the voltage limit only increases the vibration. I attempted to tune the PID values for closed-loop speed control, but I believe I need to achieve smooth open loop or basic rotation before moving to advanced tuning.

Hardware & Configuration:

Motor: BLDC Hub Motor (Shaft)
Pole Pairs: 23
Phase Resistance: 0.140 ohm (Phase-to-Phase). I entered 0.07 ohm in the BLDCmotor constructor.
Power Supply: 48V
Sensors: Built-in Hall Sensors
Current Sensing: Low-side sensing with 0.0005 ohm shunt resistors.
Library: SimpleFOC v2.4

Has anyone encountered this “jackhammer” vibration with high pole-pair hub motors?

Any guidance on how to get this motor spinning smoothly would be greatly appreciated. Thanks!"

Motor link: Motor link

25.03.2026 Edit: Typo corrections

Regards,

dekutree64 · March 25, 2026, 10:09am

Sounds like one phase is disconnected or has wrong PWM pin configured. Try an even lower speed command. With 23pp, 1rad/s will give 3.66Hz vibration. If it’s slowed down enough, you should be able to see it gradually rotate forward and then jump back.

FurBlood · March 25, 2026, 7:55pm

Thank you for the feedback, @dekutree64 .

I conducted a standalone driver test using the example project and double-checked the PWM pins and driver outputs; everything is configured correctly.

I also performed a continuity test on the motor phases with a multimeter. It turns out that one phase occasionally fails the test. This inconsistency might be the root cause of the issue.

I’m sharing the code I used for the low-speed test. After uploading and running it, I set the values to L: 4 and T: 1. As expected, the motor changes its rotation direction on its own (it jumps back), which confirms the behavior you described.

Youtube video link: Youtube Link

#include <SimpleFOC.h>

HardwareSerial Serialx(PC11, PC10);

BLDCMotor motor = BLDCMotor(23);
BLDCDriver6PWM driver = BLDCDriver6PWM(PA10, PB15, PA9, PB14, PA8, PB13);

Commander command = Commander(Serialx);
void doTarget(char* cmd) { command.scalar(&motor.target, cmd); }
void doLimit(char* cmd) { command.scalar(&motor.voltage_limit, cmd); }

void setup() {
  Serialx.begin(115200);
  SimpleFOCDebug::enable(&Serialx);
  
  driver.pwm_frequency = 20000;
  driver.voltage_power_supply = 48;
  driver.voltage_limit = 24;
  driver.dead_zone = 0.05f;

  if (!driver.init()){
    Serialx.println("Driver init failed!");
    return;
  }

  motor.linkDriver(&driver);
  motor.voltage_limit = 0.1;
  motor.controller = MotionControlType::velocity_openloop;

  if(!motor.init()){
    Serialx.println("Motor init failed!");
    return;
  }

  motor.target = 1;

  command.add('T', doTarget, "target velocity");
  command.add('L', doLimit, "voltage limit");

  Serialx.println("Motor ready!");
  Serialx.println("Set target velocity [rad/s]");
  _delay(1000);
}

void loop() {
  motor.loopFOC();

  // open loop velocity movement
  motor.move();

  // user communication
  command.run();
}

dekutree64 · March 25, 2026, 9:28pm

Hmm, that’s different. A disconnected phase would rotate about 10 degrees (360/23pp=~15° per electrical revolution, 1/3 of which isn’t working) and then jump back, repeating that pattern. Yours is stuttering (most likely once per electrical revolution) but still managing to move forward several electrical revolutions. And reversing to do several electrical revolutions in the opposite direction doesn’t make any sense at all.

Try a different motor and see if it does the same thing.

Antun_Skuric · March 26, 2026, 8:18am

It might be the dead time that is a bit too high.
Given that you have such a high supply voltage 48V and such low voltage limit 0.1V.

In SimpleFOC we use 12 bit PWM resolution by default 0-4096 so this already means that your voltage setting is very limited 4096/0.1*48 = 8.5, you’re setting the PWM values in the range [-8, +8] Which is very low.

In that case then, maybe the 5% dead-zone is just too much making for voltages applied which are not sinusoidal any more.

So you can try:

lower the dead-zone to under 1% this should work for most of the modern mosfets and gate drivers
increase the voltage limit to 1V for example. For a short test at least your motor seems more than capable of handling it

Good luck!

FurBlood · March 29, 2026, 8:36am

I don’t get it. I tried with much smaller motor (4A) and it works smoothly.

FurBlood · March 29, 2026, 9:02am

Thanks for the suggestions @Antun_Skuric . Here is an update on my tests,

I reduced the dead-zone to 1%, which significantly improved the behavior. I also tried with 0.005f, and the ‘back and forth’ jumping issue seems to have disappeared.

However, the vibration/stuttering persists under certain conditions:

I set the voltage_limit to 1V and slowly increased the target speed.
The motor spins, but once it hits a certain speed threshold, it starts stuttering and shaking violently again.
If I increase the voltage_limit (e.g., from 1V to 4V) via the Commander, the threshold where the shaking starts moves higher, and the intensity of the vibration decreases, but it doesn’t disappear completely.

But if I increase the voltage limit too much like 7V the power suplly fan’s starts to scream. I am guessing that drive consumes too much current. Also If I increase the target speed while increasing voltage limit like L to 7 and T to 6 motor drive uses less current.

Video link: Video link

Edit: Some text edits.

Antun_Skuric · March 29, 2026, 10:07am

Hi @FurBlood,

Awesome!

Ok so the second behavior you’re describing is normal for open loop control actually.

You can read more in the docs about different torque and motion control strategies.

I suggest you to use estimated current mode, rather than voltage mode. You need to provide the library with the phase résistance and the KV rating of the motor.
Once you set the current limit, the library will automatically calculate the voltage_limit that will be proportional to the velocity. If you set the Paramus well you should be able to run the motor at almost full range of velocities.

But it will still be worse and less efficient than in closed loop control mode.

FurBlood · March 29, 2026, 10:31am

Thank you @Antun_Skuric ,

My custom motor driver has low-side current sensing (with 0.5mOhm shunts), and I want to implement it properly. Before enabling the full FOC current loop, I want to verify if the ADC readings are accurate.Is there a healthy way to test the current sensing and compare the values with a multimeter?

My Plan:I am thinking of printing the values to the Serial Monitor. How can I print out the current values?
Also should I run the motor in a specific test mode (like a static voltage on one phase) to get a stable DC current reading for comparison?
Since my shunts are very low (0.0005ohm), I am worried about the signal-to-noise ratio. What is the best way to calibrate the gain and offset in SimpleFOC to match my multimeter readings?
Any advice on a ‘sanity check’ procedure for current sensing would be very helpful.

Antun_Skuric · March 29, 2026, 10:51am

There is an example code in the library for this sanity check.

You can find ti here:

github.com/simplefoc/Arduino-FOC

examples/utils/current_sense_test/align_current_sense/align_current_sense.ino

master

/**
 * This is an example code for visual aligning current sense and the driver phases as well 
 * it is used to test the current sense implementation.
 * 
 * In this example it uses the BLDCMotor and BLDCDriver3PWM classes to control a BLDC motor
 * and the InlineCurrentSense class to read the phase currents.
 * > In your application you can use any other motor, driver and current sense implementation.
 * > The rest of the code will stay the same
 * 
 * The example uses the teleplot (https://teleplot.fr) service to visualize the phase currents and voltages.
 * Its really awesome tool and you can use it to visualize any data you want.  
 */
#include <SimpleFOC.h>

// BLDC motor & driver instance
// NOTE: replace with your motor and driver configuration
BLDCMotor motor = BLDCMotor(11);
BLDCDriver3PWM driver = BLDCDriver3PWM(6, 10, 5, 8);

// Current sense instance

This file has been truncated. show original

Adapt it a bit to your sistem, but the code should work out of the box more or less.
Use teleplot.fr for visualizing signals. And you can use the commander to inverse the currents and so on, and add additional features if necessary.

If you have the closed loop control working you can also go quickly through the getting started section of the docs:

The getting started guide is more focused on the control than the measurement accuracy so it only helps to very that you have qualitatively good values in tyou d and s currents.

It is also worth noting that SimpleFOC does do auto alignement of the current sense and the motor, and it verifies that the currents are well measured before it starts the FOC loop. It is definitely bulletproof but if you want you can also just try the full foc code and see if it will work out of the box.
In most cases it will be ok.

FurBlood · March 29, 2026, 11:37am

What should I expect from the plots?
Only thing that I see is noise from my sight.

Also my multimeter shows 8-9 Amps on phases.

Antun_Skuric · March 29, 2026, 12:26pm

You’re looking for having two things:

sinusoidal currents and sinusoidal voltages.
voltages ab and c aligned with currents a b and c. Basically that current has the same waveform as voltage a. The same for b and c. ( The magnitude is not important, only the waveform)

It looks like there is an issue with your current sensing. Are you using the low side current sense?

FurBlood · March 29, 2026, 12:28pm

I am using low-side current sensing.

FurBlood · March 30, 2026, 5:57pm

Hello again,

I think there is a problem on the current sense side. So I tried with estimated current control. As a result I can control the velocity of the motor better that open loop control. However motor can’t reach 650 rpm which is writing on the datasheet.
Why am I facing with this? For example although I velocity command is 20 rad/s, motor can not exceed the 17 rad/s.

Motor specs:
max velocity: 650 rpm
rated voltage: 48v
rated current 23A, 48A max
Motor specs link

The power supply specs that I am using is:
Meanwell 48V, 21A, RSP-1000-48

#include <SimpleFOC.h>

HardwareSerial Serialx(PC11, PC10);

BLDCMotor motor = BLDCMotor(23);
BLDCDriver6PWM driver = BLDCDriver6PWM(PA10, PB15, PA9, PB14, PA8, PB13);

HallSensor sensor = HallSensor(PC0, PC1, PC2, 23);
void doA(){sensor.handleA();}
void doB(){sensor.handleB();}
void doC(){sensor.handleC();}

Commander command = Commander(Serialx);
// void doTarget(char* cmd) { command.scalar(&motor.target, cmd); }
// void doLimit(char* cmd) { command.scalar(&motor.voltage_limit, cmd); }
void doMotor(char* cmd) { command.motor(&motor, cmd); }

void setup() {
  Serialx.begin(115200);
  motor.useMonitoring(Serialx);
  SimpleFOCDebug::enable(&Serialx);

  sensor.pullup = Pullup::USE_EXTERN;
  sensor.init();
  sensor.enableInterrupts(doA, doB, doC);
  
  driver.pwm_frequency = 20000;
  driver.voltage_power_supply = 48;
  driver.voltage_limit = 48;
  driver.dead_zone = 0.005f;

  if (!driver.init()){
    Serialx.println("Driver init failed!");
    return;
  }
  
  motor.linkSensor(&sensor);
  motor.monitor_variables = _MON_TARGET | _MON_VOLT_Q | _MON_VEL | _MON_ANGLE | _MON_CURR_Q;
  motor.monitor_downsample = 10000;
  motor.KV_rating = NOT_sET;
  motor.axis_inductance.q = NOT_SET;
  motor.phase_resistance = 0.3;
  motor.linkDriver(&driver);
  // motor.voltage_sensor_align = 3;
  motor.zero_electric_angle = 1.05;
  motor.sensor_direction = Direction::CW;
  motor.current_limit = 20;
  motor.voltage_limit = 24;
  motor.velocity_limit = 50;
  // motor.controller = MotionControlType::velocity_openloop;
  motor.torque_controller = TorqueControlType::estimated_current;
  motor.controller = MotionControlType::velocity;

  if(!motor.init()){
    Serialx.println("Motor init failed!");
    return;
  }

  if(!motor.initFOC()){
    Serial.println("FOC init failed!");
    return;
  }

  motor.updateCurrentLimit(40.0);
  motor.target = 0;

  // command.add('T', doTarget, "target velocity");
  // command.add('L', doLimit, "voltage limit");
  command.add('M', doMotor, "Motor");

  Serialx.println("Motor ready!");
  Serialx.println("Set target velocity [rad/s]");
  _delay(1000);
}

void loop() {
  motor.loopFOC();

  // open loop velocity movement
  motor.move();

  // user communication
  command.run();

  motor.monitor();
}

Also If I give the measured phase resistance (0.07) and motor KV (650rpm/48V) motor not moves. Vlues in the code snipped are empirical values which are can able the turn the motor.

Motor makes so much noise. What would be the cause?

Edit: text added
Edit#2: extra question

Antun_Skuric · March 31, 2026, 8:28am

Hey @FurBlood,

So there are a couple of things that seem to be going on at the same time.

You’re testing your own board that might have some issues right? At the moment the current sensing is not really working well? But let’s assume that everything works except the current sensing.

The KV rating is set to NOT_SET in your code, this basically means that the code is not using it at all. Is that what you ended up using?

Did you try using the torque control mode only (I would suggest staying in this mode until you resolve your issues) and try to set the target current relatively high. The motor should accelerate to the max speed.
You can stay in the voltage mode too and set the target voltage at 24V.

If you cannot reach the max speed (or at least in the ball park, for example above 55 rad/s) there are a couple of options

hall sensors are generating too many interrrupts. Try using the HallSensor without interrups: Hall sensors | Arduino-FOC
If you’re in velocity mode the PID values are maybe not well set… Use the torque control mode until you can get to the desired velocity
If all this does not work, try adding KV and inducrance values. Use this guide: Testing and Tuning Motor Parameters | Arduino-FOC

Real foc with current sensing will be able to reach higher speeds than voltage or estimated current control.

Did you try debugging the current sense some more?