Don’t wait until your full project is done to find out your BTS7960 43A motor driver has a problem. ⚙️😎 A fast bench test can catch wiring mistakes, weak power, or bad behavior before they cost you time and parts. This guide uses a short Arduino sketch that makes the motor run forward, stop, reverse, and stop again in a loop. With that simple pattern, you can quickly see if the driver responds well, the motor switches direction correctly, and the setup is ready for a bigger build.
This kind of first test is useful because many motor issues do not come from the code alone. In many cases, the real problem is loose wiring, missing shared ground, mixed-up pins, or a power source that cannot support the motor well. By starting with a short and focused test, you remove extra guesswork and make the results easier to understand. If the motor behaves as expected here, you can move to a larger build with more confidence.
In this tutorial, the goal is not to build a full motor control system right away. The goal is to prove that the driver, motor, and wiring all work together in a clean and simple way. The sketch uses two PWM pins, RPWM and LPWM, to drive one direction at a time, with short stops in between. That makes the movement easy to observe and helps reduce stress on the motor and driver during direction changes. If you want to explore more beginner-friendly microcontroller guides, you can also read Raspberry Pi Pico (RP2040) | A Beginner’s Guide
Why Build?
The biggest reason to do this test first is to protect your parts and save time. A BTS7960 is built for higher current motor control, so small mistakes in wiring or power can quickly lead to heat, noise, or strange motor behavior. If you test the module before installing it in a full project, you have a much better chance of catching those issues early. That is far better than finding a problem after the motor driver is already mounted inside a robot, cart, or machine.
This test also gives you a reliable starting point for troubleshooting later. Once you know the driver and motor work in a basic setup, you have a simple reference point that you can return to if a larger build stops working. Instead of guessing whether the fault is in the driver, motor, sensors, or main code, you can compare everything against this known working test. That makes the whole debugging process much easier and much faster.
Just as important, this test helps build good habits for motor projects. It teaches you to check power first, keep grounds shared, and confirm direction control before adding more features. It also shows why short stops between forward and reverse matter, since fast direction changes can stress both the motor and the driver. Even though the setup is simple, the habits you learn here carry over into much bigger projects.
What You’ll Learn
- What the BTS7960 does: High-current H-bridge control for DC motors with forward/reverse direction.
- PWM direction control: Use RPWM for forward and LPWM for reverse, never driving both at once in this test.
- Speed setting:
analogWrite()values (0–255) map to duty cycle, which controls motor speed. - Safe switching: Add short stops between direction changes to reduce stress and current spikes.
- Power and grounding: Motor supply goes to the driver, and Arduino GND must share ground with the driver.
- Defect vs wiring symptoms: How to interpret no motion, one direction only, heating, or buzzing.
What You’ll Need
To do this test, you only need a few basic parts. The main item is the BTS7960 motor driver module, since that is the board being tested. You will also need an Arduino Uno R3 to send the PWM signals, plus a DC motor so you can see the output in action. A DC Motor 395 is enough for a simple test like this. Jumper wires handle the signal connections, and a USB Type B cable connects the Arduino to your computer.
You also need an external 12V DC 1A power supply for the BTS7960 motor side. In this setup, the Arduino is used only for the control signals and logic connection, while the external 12V supply powers the motor through the driver. This is important because the motor should not rely on the Arduino as its main power source.
It is best to keep the wiring neat and secure while testing. Loose jumper wires can cause random behavior, especially once the motor starts pulling current. Even if the code is correct, a weak connection can make the motor fail to spin, jerk, or stop without warning. Clean wiring makes the setup more stable and also makes it much easier to trace a problem if something does not work.
Circuit Diagram
Arduino to BTS7960 Connection
D5→RPWMD6→LPWM5V5V→VCCGND→GND5V→R_EN5V→R_EN
Sample Code
const int RPWM = 5;
const int LPWM = 6;
void setup() {
pinMode(RPWM, OUTPUT);
pinMode(LPWM, OUTPUT);
analogWrite(RPWM, 0);
analogWrite(LPWM, 0);
delay(500);
}
void loop() {
// Forward (speed ~70%)
analogWrite(RPWM, 180);
analogWrite(LPWM, 0);
delay(2000);
// Stop
analogWrite(RPWM, 0);
analogWrite(LPWM, 0);
delay(1000);
// Reverse
analogWrite(RPWM, 0);
analogWrite(LPWM, 180);
delay(2000);
// Stop
analogWrite(RPWM, 0);
analogWrite(LPWM, 0);
delay(1000);
}
How It Works
The sketch sets RPWM (pin 5) and LPWM (pin 6) as outputs and starts with both at zero. That ensures the driver is in a neutral state before the motor moves. A short delay after initialization helps the system settle before the first command.
In the main loop, the code drives forward by sending a PWM value (180 ≈ 70%) to RPWM while keeping LPWM at 0. After two seconds, it stops by setting both outputs to zero. Then it reverses by switching: LPWM gets the same PWM value while RPWM stays at 0, followed by another stop.
This pattern creates a simple, repeatable test cycle. If the wiring is correct and the module is healthy, the motor will spin one direction, stop cleanly, then spin the other direction. If the motor only spins one way, stutters, or the driver overheats quickly, you can narrow the issue to wiring, power, PWM pins, or a faulty board.
Applications & Extensions
Use this as your incoming inspection test for every BTS7960 module. You can confirm it works before installing it into robots, scooters, linear actuators, or heavy-load gear motors. It’s also a great “known-good” test when a motor system suddenly stops working.
Next, extend it to real controls. Add R_EN/L_EN pins if your board exposes them, and implement braking, coast, and smooth ramp-up/ramp-down. You can also read current/temperature externally to validate safe operation under load.
Finally, build full projects on top of it. Control speed with a potentiometer, add direction buttons, or integrate RC/joystick input. Once you trust the driver, you can safely scale into higher voltage motors and heavier loads—while keeping the same forward/stop/reverse logic as your debugging tool.
📹 Watch the Full Demo Video
Here’s the Motor Drive (BTS7960 43A).
