Electric bikes have revolutionized personal transportation by combining the convenience of traditional bicycles with the power of electric motors. One of the most critical components of an e-bike is the speed controller, which manages the power delivery from the battery to the motor. While commercial speed controllers are readily available, building your own automatic speed controller using Arduino offers greater customization, cost-effectiveness, and learning opportunities for electronics enthusiasts and DIY builders.
An automatic speed controller serves as the brain of your electric bike's propulsion system, regulating motor speed based on various inputs such as throttle position, pedal assist sensors, and safety parameters. By leveraging Arduino's versatility and programmability, you can create a sophisticated control system that rivals commercial alternatives while maintaining full control over its functionality and features.
This comprehensive guide will walk you through the entire process of designing, building, and programming an automatic speed controller for your electric bike using Arduino. We'll cover everything from understanding the fundamental principles to implementing advanced features like regenerative braking, multiple riding modes, and safety systems.
Understanding Electric Bike Speed Controllers
Basic Principles of Speed Control
Electric bike speed controllers work by modulating the power delivered to the motor through a technique called Pulse Width Modulation (PWM). This method rapidly switches the power on and off at high frequencies, effectively controlling the average voltage and current supplied to the motor. The duty cycle of these pulses determines the motor's speed – a higher duty cycle results in more power and faster rotation.
The controller acts as an intermediary between the battery pack and the motor, converting the DC voltage from the battery into a controlled output that matches the motor's requirements. Modern electric bike motors typically operate on 24V, 36V, or 48V systems, with power ratings ranging from 250W to 1500W or more.
Types of Electric Bike Motors
Understanding your motor type is crucial for designing an effective speed controller. The three main types of motors used in electric bikes are:
Brushed DC Motors: These traditional motors use physical brushes to commutate the windings. They're simple to control but require regular maintenance and have lower efficiency compared to brushless alternatives.
Brushless DC (BLDC) Motors: These motors use electronic commutation instead of physical brushes, resulting in higher efficiency, longer lifespan, and quieter operation. However, they require more complex control algorithms.
Hub Motors: These are typically brushless motors integrated directly into the wheel hub. They can be either direct drive or geared, with geared motors providing higher torque at lower speeds.
Control Methods and Algorithms
Arduino-based speed controllers can implement various control methods depending on the motor type and desired performance characteristics. The most common approaches include:
Open-Loop Control: This simple method controls motor speed based solely on throttle input without feedback from the motor's actual speed or position. While easy to implement, it may not provide optimal performance under varying load conditions.
Closed-Loop Control: This advanced method uses feedback sensors to monitor actual motor performance and adjust control signals accordingly. This results in more precise speed control and better efficiency.
Sensor-based Control: For BLDC motors, Hall effect sensors or encoders provide position feedback, enabling more sophisticated control algorithms and features like regenerative braking.
Required Components and Materials
Building an Arduino-based speed controller requires careful selection of components to ensure reliable operation and adequate performance. Here's a comprehensive list of required materials organized by category:
Core Processing Components
| Component | Specifications | Quantity | Purpose |
|---|---|---|---|
| Arduino Mega 2560 | 16MHz, 256KB Flash, 54 I/O pins | 1 | Main microcontroller |
| Arduino Uno | Alternative if fewer I/O pins needed | 1 | Backup option |
| Real-time Clock Module | DS3231 or similar | 1 | Timing and logging |
| MicroSD Card Module | SPI interface | 1 | Data logging |
Power Electronics Components
| Component | Specifications | Quantity | Purpose |
|---|---|---|---|
| MOSFETs | IRF3205 or equivalent, 55V/110A | 6-12 | Power switching |
| Gate Drivers | IR2110 or similar | 3-6 | MOSFET control |
| Current Sensors | ACS712 30A modules | 2-3 | Current monitoring |
| Voltage Dividers | Precision resistors | Multiple | Voltage sensing |
| Capacitors | Various values, 63V+ rating | Multiple | Filtering and decoupling |
| Inductors | 100µH-1mH power inductors | 2-4 | Current smoothing |
Input and Control Components
| Component | Specifications | Quantity | Purpose |
|---|---|---|---|
| Throttle Sensor | Hall effect or potentiometer | 1 | Speed input |
| Brake Sensors | Magnetic or mechanical switches | 2 | Safety cutoffs |
| Display Module | OLED or LCD, I2C interface | 1 | System status |
| Rotary Encoder | With push button | 1 | Settings adjustment |
| Temperature Sensors | DS18B20 waterproof probes | 2-3 | Thermal monitoring |
Safety and Protection Components
Proper protection is essential for safe operation of high-current electric bike systems. The following components provide multiple layers of safety:
Fuses and Circuit Breakers: High-current automotive fuses rated for your system voltage and maximum current, typically 30-60A for most e-bike applications.
Voltage Protection: Over-voltage and under-voltage protection circuits prevent damage from battery charging/discharging extremes.
Thermal Protection: Temperature monitoring and automatic shutdown capabilities protect against overheating.
Emergency Shutdown: Multiple redundant safety switches and emergency stop mechanisms.
Circuit Design and Schematic
The circuit design for an Arduino-based electric bike speed controller involves several interconnected subsystems, each responsible for specific functions. Understanding these subsystems and their interactions is crucial for successful implementation.
Power Supply Design
The power supply subsystem must provide stable, clean power to the Arduino and associated electronics while operating in the harsh environment of an electric bike. The design typically includes multiple voltage rails:
48V/36V/24V Main Rail: Direct connection to the battery pack, used for motor power delivery. This rail requires robust filtering and protection against voltage spikes and reverse polarity.
12V Auxiliary Rail: Created using a DC-DC converter from the main rail, this powers gate drivers and other medium-power components. The converter should be isolated and capable of handling the full voltage range of your battery pack.
5V Logic Rail: Generated from the 12V rail using a linear or switching regulator, this powers the Arduino and digital logic components. Clean, stable 5V is critical for reliable microcontroller operation.
3.3V Sensor Rail: Some sensors require 3.3V operation. This can be generated on the Arduino board or using an external regulator for better noise performance.
MOSFET Driver Circuit Design
The MOSFET driver circuit is the heart of the power electronics, translating low-voltage control signals from the Arduino into high-current switching actions. For a three-phase BLDC motor controller, you'll need six MOSFETs arranged in three half-bridge configurations.
Each half-bridge consists of a high-side and low-side MOSFET. The high-side MOSFET connects the motor winding to the positive battery terminal, while the low-side MOSFET connects it to ground. Proper gate drive circuitry ensures clean switching transitions and prevents shoot-through conditions that could damage the MOSFETs.
Gate drivers like the IR2110 provide the necessary voltage levels and drive current to rapidly switch the MOSFETs. These drivers include built-in dead-time generation, which creates a small delay between turning off one MOSFET and turning on its complement, preventing both MOSFETs in a half-bridge from conducting simultaneously.
Current Sensing and Feedback
Accurate current measurement is essential for implementing advanced control features and protecting the system from overcurrent conditions. The ACS712 current sensor modules provide isolated current measurement with good linearity and reasonable accuracy for this application.
Position the current sensors to monitor both the total battery current and individual phase currents. Battery current monitoring enables features like power limiting and energy consumption tracking, while phase current monitoring allows for more sophisticated motor control algorithms.
The current sensor outputs are analog voltages that require careful scaling and filtering before input to the Arduino's analog-to-digital converters. Use RC filters to reduce noise and ensure the voltage levels remain within the Arduino's 0-5V input range.
Sensor Integration
Multiple sensors provide feedback and monitoring capabilities essential for safe and efficient operation:
Hall Effect Sensors: For BLDC motors, three Hall sensors provide rotor position information. These sensors are typically built into the motor and provide digital outputs that change state as the rotor rotates.
Temperature Sensors: Monitor controller temperature, motor temperature, and battery temperature. DS18B20 sensors provide good accuracy and can be daisy-chained on a single digital pin.
Voltage Monitoring: Use precision voltage dividers to monitor battery voltage and individual cell voltages if using a multi-cell pack.
Speed Sensors: Reed switches or optical encoders on the wheel provide actual vehicle speed information for closed-loop control and display purposes.
Arduino Programming and Code Structure
The software running on the Arduino is responsible for coordinating all aspects of the speed controller's operation. A well-structured program ensures reliable operation, easy maintenance, and the ability to add new features over time.
Main Program Structure
The Arduino program should follow a modular structure with clearly defined functions for each major subsystem. Here's the recommended organization:
cpp
// Global variables and constants
#define MOTOR_POLES 14
#define MAX_RPM 1000
#define PWM_FREQUENCY 20000
// System state variables
volatile bool motorRunning = false;
volatile int throttleValue = 0;
volatile int motorSpeed = 0;
float batteryVoltage = 0.0;
float motorCurrent = 0.0;
// Interrupt service routines
void throttleISR() {
// Handle throttle input changes
}
void hallSensorISR() {
// Handle Hall sensor state changes
}
void setup() {
// Initialize hardware
initializePWM();
initializeSensors();
initializeDisplay();
initializeInterrupts();
Serial.begin(115200);
Serial.println("E-bike Controller Starting...");
}
void loop() {
// Main control loop
readSensors();
updateDisplay();
calculateMotorControl();
updatePWMOutputs();
checkSafetyConditions();
delay(10); // 100Hz update rate
}PWM Generation and Motor Control
For brushless DC motor control, you need to generate six PWM signals with precise timing and dead-time insertion. The Arduino's hardware PWM capabilities can be configured for high-frequency operation:
cpp
void initializePWM() {
// Configure Timer 1 for PWM generation
TCCR1A = 0;
TCCR1B = 0;
ICR1 = 800; // 20kHz PWM frequency at 16MHz
// Configure PWM mode
TCCR1A |= (1 << WGM11);
TCCR1B |= (1 << WGM13) | (1 << WGM12);
// Set prescaler
TCCR1B |= (1 << CS10);
// Enable PWM outputs
TCCR1A |= (1 << COM1A1) | (1 << COM1B1);
}
void updatePWMOutputs() {
if (motorRunning && throttleValue > 0) {
// Calculate commutation sequence based on Hall sensor inputs
int hallState = readHallSensors();
int pwmDuty = map(throttleValue, 0, 1023, 0, ICR1);
// Apply appropriate PWM pattern for current commutation state
switch (hallState) {
case 1: // 001
OCR1A = pwmDuty;
OCR1B = 0;
// Set appropriate MOSFET states
break;
case 2: // 010
OCR1A = 0;
OCR1B = pwmDuty;
break;
// ... additional cases for all six states
}
} else {
// Turn off all PWM outputs
OCR1A = 0;
OCR1B = 0;
}
}Sensor Reading and Processing
Efficient sensor reading is crucial for responsive control. Use interrupt-driven reading where possible and implement appropriate filtering for analog sensors:
cpp
void readSensors() {
// Read throttle position
int rawThrottle = analogRead(A0);
throttleValue = constrain(map(rawThrottle, 100, 900, 0, 1023), 0, 1023);
// Read battery voltage
int rawVoltage = analogRead(A1);
batteryVoltage = (rawVoltage * 5.0 / 1023.0) * 15.0; // Voltage divider factor
// Read motor current
int rawCurrent = analogRead(A2);
motorCurrent = (rawCurrent - 512) * 30.0 / 1023.0; // ACS712 scaling
// Apply filtering
static float filteredCurrent = 0;
filteredCurrent = 0.9 * filteredCurrent + 0.1 * motorCurrent;
motorCurrent = filteredCurrent;
}
int readHallSensors() {
int hallA = digitalRead(2);
int hallB = digitalRead(3);
int hallC = digitalRead(4);
return (hallA << 2) | (hallB << 1) | hallC;
}Safety Systems Implementation
Safety is paramount in electric bike controllers. Implement multiple layers of protection:
cpp
void checkSafetyConditions() {
// Check emergency brake inputs
if (digitalRead(BRAKE_PIN_1) || digitalRead(BRAKE_PIN_2)) {
emergencyStop();
return;
}
// Check overcurrent condition
if (abs(motorCurrent) > MAX_CURRENT) {
emergencyStop();
Serial.println("OVERCURRENT PROTECTION ACTIVATED");
return;
}
// Check overvoltage/undervoltage
if (batteryVoltage > MAX_VOLTAGE || batteryVoltage < MIN_VOLTAGE) {
emergencyStop();
Serial.println("VOLTAGE OUT OF RANGE");
return;
}
// Check controller temperature
float temperature = readTemperature();
if (temperature > MAX_TEMP) {
emergencyStop();
Serial.println("THERMAL PROTECTION ACTIVATED");
return;
}
}
void emergencyStop() {
motorRunning = false;
OCR1A = 0;
OCR1B = 0;
// Turn off all MOSFET gates
digitalWrite(GATE_ENABLE_PIN, LOW);
}Advanced Control Features
Modern electric bike controllers benefit from sophisticated control algorithms that improve performance, efficiency, and user experience. These advanced features set DIY controllers apart from basic commercial alternatives.
Regenerative Braking Implementation
Regenerative braking converts the motor's kinetic energy back into electrical energy during deceleration, extending battery range and providing additional braking force. Implementation requires careful coordination between the motor controller and brake sensors:
cpp
bool regenerativeBrakingEnabled = true;
int regenStrength = 30; // Percentage of maximum regen
void handleRegenerativeBraking() {
if (!regenerativeBrakingEnabled) return;
bool frontBrake = digitalRead(FRONT_BRAKE_PIN);
bool rearBrake = digitalRead(REAR_BRAKE_PIN);
if (frontBrake || rearBrake) {
// Calculate regenerative braking strength based on speed
float currentSpeed = getCurrentSpeed(); // From wheel sensor
float regenCurrent = (currentSpeed / MAX_SPEED) * (regenStrength / 100.0) * MAX_REGEN_CURRENT;
// Apply regenerative braking by reversing motor operation
if (currentSpeed > 5.0) { // Only above minimum speed
applyRegenerativeBraking(regenCurrent);
}
}
}
void applyRegenerativeBraking(float regenCurrent) {
// Modify PWM patterns to create regenerative current flow
// This requires sophisticated commutation control
int hallState = readHallSensors();
int regenPWM = (int)(regenCurrent / MAX_CURRENT * ICR1);
// Apply braking commutation sequence (opposite to motoring)
// Implementation depends on specific motor configuration
}Multiple Riding Modes
Different riding conditions require different performance characteristics. Implementing selectable riding modes enhances versatility:
cpp
enum RidingMode {
ECO_MODE = 0,
NORMAL_MODE = 1,
SPORT_MODE = 2,
TURBO_MODE = 3
};
RidingMode currentMode = NORMAL_MODE;
struct ModeSettings {
int maxPower; // Percentage of total power
int acceleration; // Acceleration curve steepness
bool regenEnabled; // Regenerative braking availability
int topSpeed; // Maximum speed limit
};
ModeSettings modeConfigs[4] = {
{40, 30, true, 20}, // Eco: 40% power, gentle acceleration, regen on, 20 km/h max
{70, 50, true, 32}, // Normal: 70% power, moderate acceleration, regen on, 32 km/h max
{90, 80, true, 45}, // Sport: 90% power, aggressive acceleration, regen on, 45 km/h max
{100, 100, false, 50} // Turbo: 100% power, maximum acceleration, no regen, 50 km/h max
};
void applyRidingMode() {
ModeSettings settings = modeConfigs[currentMode];
// Scale throttle response based on mode
int scaledThrottle = (throttleValue * settings.maxPower) / 100;
// Apply acceleration curve
static int lastThrottle = 0;
int throttleDelta = scaledThrottle - lastThrottle;
int maxDelta = (settings.acceleration * 10) / 100; // Limit change rate
if (abs(throttleDelta) > maxDelta) {
scaledThrottle = lastThrottle + (throttleDelta > 0 ? maxDelta : -maxDelta);
}
lastThrottle = scaledThrottle;
// Enable/disable regenerative braking
regenerativeBrakingEnabled = settings.regenEnabled;
// Apply speed limiting
float currentSpeed = getCurrentSpeed();
if (currentSpeed > settings.topSpeed) {
scaledThrottle = 0; // Cut power when speed limit exceeded
}
// Use scaled throttle for motor control
calculateMotorControl(scaledThrottle);
}Pedal Assist Integration
Pedal assist systems (PAS) provide motor assistance proportional to pedaling effort, creating a natural riding experience:
cpp
volatile int pedalCadence = 0;
volatile unsigned long lastPedalTime = 0;
int assistLevel = 3; // 1-5 assist levels
void pedalSensorISR() {
unsigned long currentTime = micros();
unsigned long timeDelta = currentTime - lastPedalTime;
if (timeDelta > 100000) { // Debounce: minimum 100ms between pulses
pedalCadence = 60000000 / timeDelta; // RPM calculation
lastPedalTime = currentTime;
}
}
void calculatePedalAssist() {
static unsigned long lastCadenceUpdate = 0;
// Reset cadence if no pedaling detected
if (millis() - lastPedalTime > 3000) {
pedalCadence = 0;
}
// Calculate assist power based on cadence and assist level
int assistPower = 0;
if (pedalCadence > 10) { // Minimum pedaling threshold
float assistMultiplier = assistLevel * 0.2; // 20% per assist level
assistPower = (int)(pedalCadence * assistMultiplier * 10);
assistPower = constrain(assistPower, 0, 1023);
}
// Combine with throttle input
int combinedThrottle = max(throttleValue, assistPower);
calculateMotorControl(combinedThrottle);
}Smart Battery Management
Intelligent battery management extends battery life and improves performance:
cpp
struct BatteryState {
float voltage;
float current;
float temperature;
int stateOfCharge; // Percentage
bool balancing;
unsigned long cycleCount;
};
BatteryState battery;
void updateBatteryManagement() {
battery.voltage = readBatteryVoltage();
battery.current = readBatteryCurrent();
battery.temperature = readBatteryTemperature();
// Calculate state of charge using voltage and current integration
battery.stateOfCharge = calculateSOC();
// Apply power limiting based on battery state
if (battery.stateOfCharge < 20) {
// Reduce maximum power in low battery condition
applyPowerLimiting(0.7); // 70% of normal power
} else if (battery.stateOfCharge < 10) {
// Severe power reduction in critical battery condition
applyPowerLimiting(0.4); // 40% of normal power
}
// Temperature-based protection
if (battery.temperature > 45.0) {
applyPowerLimiting(0.5); // Reduce power when battery is hot
} else if (battery.temperature < 0.0) {
applyPowerLimiting(0.6); // Reduce power when battery is cold
}
}
void applyPowerLimiting(float limitFactor) {
// Reduce maximum available power
int limitedThrottle = (int)(throttleValue * limitFactor);
calculateMotorControl(limitedThrottle);
}User Interface and Display System
A comprehensive user interface provides riders with essential information and allows customization of controller settings. Modern e-bike controllers benefit from clear, informative displays that work well in various lighting conditions.
OLED Display Integration
OLED displays offer excellent visibility and low power consumption, making them ideal for e-bike applications:
cpp
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
void initializeDisplay() {
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println("SSD1306 allocation failed");
return;
}
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.display();
}
void updateMainDisplay() {
display.clearDisplay();
// Speed display (large font)
display.setTextSize(3);
display.setCursor(0, 0);
display.print((int)getCurrentSpeed());
display.setTextSize(1);
display.print(" km/h");
// Battery level indicator
int batteryPercent = battery.stateOfCharge;
display.setCursor(0, 35);
display.print("Batt: ");
display.print(batteryPercent);
display.print("%");
// Draw battery icon
drawBatteryIcon(90, 35, batteryPercent);
// Riding mode
display.setCursor(0, 45);
display.print("Mode: ");
switch(currentMode) {
case ECO_MODE: display.print("ECO"); break;
case NORMAL_MODE: display.print("NORM"); break;
case SPORT_MODE: display.print("SPORT"); break;
case TURBO_MODE: display.print("TURBO"); break;
}
// Power output
display.setCursor(0, 55);
display.print("Power: ");
display.print((int)(motorCurrent * batteryVoltage));
display.print("W");
display.display();
}
void drawBatteryIcon(int x, int y, int percent) {
// Battery outline
display.drawRect(x, y, 30, 12, WHITE);
display.drawRect(x + 30, y + 3, 2, 6, WHITE);
// Battery fill based on percentage
int fillWidth = (28 * percent) / 100;
display.fillRect(x + 1, y + 1, fillWidth, 10, WHITE);
}Menu System Implementation
A hierarchical menu system allows users to adjust settings without requiring external programming tools:
cpp
enum MenuState {
MAIN_DISPLAY,
MAIN_MENU,
SETTINGS_MENU,
ASSIST_MENU,
DISPLAY_MENU,
INFO_MENU
};
MenuState currentMenuState = MAIN_DISPLAY;
int menuSelection = 0;
bool menuChanged = true;
void handleMenuNavigation() {
static unsigned long lastButtonPress = 0;
static bool buttonPressed = false;
// Read rotary encoder and button
int encoderChange = readRotaryEncoder();
bool buttonState = !digitalRead(MENU_BUTTON_PIN);
// Handle button press with debouncing
if (buttonState && !buttonPressed && (millis() - lastButtonPress > 200)) {
buttonPressed = true;
lastButtonPress = millis();
handleMenuSelect();
} else if (!buttonState) {
buttonPressed = false;
}
// Handle encoder rotation
if (encoderChange != 0) {
menuSelection += encoderChange;
menuChanged = true;
}
// Update display if menu changed
if (menuChanged) {
updateMenuDisplay();
menuChanged = false;
}
}
void handleMenuSelect() {
switch (currentMenuState) {
case MAIN_DISPLAY:
currentMenuState = MAIN_MENU;
menuSelection = 0;
break;
case MAIN_MENU:
switch (menuSelection % 4) {
case 0: currentMenuState = SETTINGS_MENU; break;
case 1: currentMenuState = ASSIST_MENU; break;
case 2: currentMenuState = DISPLAY_MENU; break;
case 3: currentMenuState = INFO_MENU; break;
}
menuSelection = 0;
break;
case SETTINGS_MENU:
handleSettingsSelect();
break;
default:
// Return to main display from any submenu
currentMenuState = MAIN_DISPLAY;
break;
}
menuChanged = true;
}
void updateMenuDisplay() {
display.clearDisplay();
display.setTextSize(1);
switch (currentMenuState) {
case MAIN_MENU:
displayMainMenu();
break;
case SETTINGS_MENU:
displaySettingsMenu();
break;
case ASSIST_MENU:
displayAssistMenu();
break;
// ... other menu cases
}
display.display();
}
void displayMainMenu() {
display.setCursor(0, 0);
display.println("MAIN MENU");
display.println();
const char* menuItems[] = {"Settings", "Assist", "Display", "Info"};
for (int i = 0; i < 4; i++) {
if (i == (menuSelection % 4)) {
display.print("> ");
} else {
display.print(" ");
}
display.println(menuItems[i]);
}
}Data Logging and Diagnostics
Comprehensive logging helps track performance and diagnose issues:
cpp
#include <SD.h>
File logFile;
unsigned long lastLogTime = 0;
const unsigned long LOG_INTERVAL = 1000; // Log every second
void initializeDataLogging() {
if (!SD.begin(10)) {
Serial.println("SD card initialization failed");
return;
}
// Create new log file with timestamp
char filename[20];
sprintf(filename, "ride_%08lu.csv", millis());
logFile = SD.open(filename, FILE_WRITE);
if (logFile) {
// Write CSV header
logFile.println("Time,Speed,Current,Voltage,Power,Mode,Battery%,Temp");
logFile.close();
}
}
void logData() {
if (millis() - lastLogTime < LOG_INTERVAL) return;
logFile = SD.open("current_ride.csv", FILE_WRITE);
if (logFile) {
// Log timestamp
logFile.print(millis());
logFile.print(",");
// Log speed
logFile.print(getCurrentSpeed());
logFile.print(",");
// Log electrical parameters
logFile.print(motorCurrent);
logFile.print(",");
logFile.print(batteryVoltage);
logFile.print(",");
logFile.print(motorCurrent * batteryVoltage);
logFile.print(",");
// Log system state
logFile.print(currentMode);
logFile.print(",");
logFile.print(battery.stateOfCharge);
logFile.print(",");
logFile.println(readTemperature());
logFile.close();
lastLogTime = millis();
}
}
void displayDiagnostics() {
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0, 0);
display.println("DIAGNOSTICS");
display.println();
// System status
display.print("Uptime: ");
display.print(millis() / 1000);
display.println("s");
display.print("Hall: ");
display.println(readHallSensors(), BIN);
display.print("Throttle: ");
display.println(throttleValue);
display.print("Temp: ");
display.print(readTemperature());
display.println("C");
display.print("Errors: ");
display.println(getErrorCount());
display.display();
}Safety Systems and Protection Features
Safety is the most critical aspect of electric bike controller design. Multiple protection systems must work together to prevent accidents and component damage while maintaining reliable operation under all conditions.
Overcurrent and Overvoltage Protection
Current and voltage protection systems form the first line of defense against electrical faults:
cpp
// Protection thresholds
const float MAX_MOTOR_CURRENT = 30.0; // Amperes
const float MAX_BATTERY_VOLTAGE = 54.6; // For 48V system
const float MIN_BATTERY_VOLTAGE = 39.0; // For 48V system
const float OVERCURRENT_TIME_LIMIT = 10; // Seconds before shutdown
// Protection state variables
bool overcurrentProtectionActive = false;
unsigned long overcurrentStartTime = 0;
bool overvoltageProtectionActive = false;
bool undervoltageProtectionActive = false;
void checkElectricalProtection() {
// Monitor motor current
float absoluteCurrent = abs(motorCurrent);
if (absoluteCurrent > MAX_MOTOR_CURRENT) {
if (!overcurrentProtectionActive) {
overcurrentProtectionActive = true;
overcurrentStartTime = millis();
Serial.println("WARNING: Overcurrent detected");
}
// Allow brief overcurrent for
