Generic Chinese BMS BLE Protocolv1.0

Protocol Type: Binary, Master-Slave
Transport: Bluetooth Low Energy (BLE)

Table of Contents

1. Overview
2. BLE Service Specification
3. Packet Structure
4. Communication Flow
5. Command Set
6. Data Types and Encoding
7. State Machine
8. Error Handling
9. Implementation Guidelines

1. Overview

This protocol enables communication between a client device and a Battery Management System (BMS) over Bluetooth Low Energy. It supports real-time monitoring of battery pack parameters including voltage, current, temperature, and protection states.

Key Features

• Binary command-response protocol
• CRC-based data integrity
• Asynchronous notification support
• Multi-cell voltage monitoring
• Temperature sensor array support
• State-based recording triggers

2. BLE Service Specification

GATT Profile

Connection Parameters

• MTU: Minimum 23 bytes (default BLE)
• Connection Interval: Recommended 7.5-15ms for optimal throughput
• Supervision Timeout: 5000ms
• Enable Notifications: Required for receiving responses

3. Packet Structure

Request Packet Format

┌─────────┬─────────┬──────┬────────┬──────────┬─────────────┬─────────────┬─────────┐
│ Header  │ Command │ Mode │ Length │   Data   │ Checksum_H  │ Checksum_L  │  Tail   │
├─────────┼─────────┼──────┼────────┼──────────┼─────────────┼─────────────┼─────────┤
│  0xDD   │ 1 byte  │0xA5  │1 byte  │ N bytes  │   1 byte    │   1 byte    │  0x77   │
└─────────┴─────────┴──────┴────────┴──────────┴─────────────┴─────────────┴─────────┘
   Byte 0    Byte 1  Byte 2  Byte 3  Bytes 4-N    Byte N+4      Byte N+5     Byte N+6

Total Length = Data Length + 7 bytes

Response Packet Format

┌─────────┬─────────┬────────┬────────┬──────────┬─────────────┬─────────────┬─────────┐
│ Header  │Response │ Status │ Length │   Data   │ Checksum_H  │ Checksum_L  │  Tail   │
├─────────┼─────────┼────────┼────────┼──────────┼─────────────┼─────────────┼─────────┤
│  0xDD   │ 1 byte  │ 1 byte │1 byte  │ N bytes  │   1 byte    │   1 byte    │  0x77   │
└─────────┴─────────┴────────┴────────┴──────────┴─────────────┴─────────────┴─────────┘
   Byte 0    Byte 1   Byte 2  Byte 3  Bytes 4-N    Byte N+4      Byte N+5     Byte N+6

Field Descriptions

4. Communication Flow

Basic Request-Response

Client                                    BMS Device
  |                                            |
  |-- Write Request Packet ------------------>|
  |                                            |
  |                                            |-- Process Command
  |                                            |
  |<-- Notify Response Packet ----------------|
  |                                            |
    

Timing Constraints

5. Command Set

0x03 - Read Base Information

Request: DD 03 A5 00 ...

0x04 - Read Cell Voltages

Request: DD 04 A5 00 ...

6. Data Types and Encoding

All multi-byte integers use Big-Endian (most significant byte first) encoding.

Checksum Algorithm

def calculate_checksum(command: int, data: bytes) -> tuple[int, int]:
    """
    Calculate 16-bit checksum
    Returns: (high_byte, low_byte)
    """
    checksum = command
    for byte in data:
        checksum += byte
    
    # Apply modulo and split into bytes
    checksum = checksum % 65536
    high_byte = (checksum >> 8) & 0xFF
    low_byte = checksum & 0xFF
    
    return (high_byte, low_byte)

7. State Machine

8. Error Handling

9. Implementation Guidelines

Internal Resistance Calculation

When RSOC is between 45-90% during discharge transition:

For each cell i:
    R[i] = (V_pre[i] - V_post[i]) / |I_discharge|

Where:
    V_pre[i]  = Cell voltage before discharge (PRE_DISCHARGE state)
    V_post[i] = Cell voltage after discharge starts (DISCHARGE state)
    I_discharge = Discharge current

Sample Implementation

class BMSProtocol:
    HEADER = 0xDD
    TAIL = 0x77
    MODE_READ = 0xA5
    
    def parse_base_info(self, data: bytes) -> dict:
        """Parse base information response"""
        voltage = int.from_bytes(data[0:2], 'big') / 10.0  # 0.1V units
        current = int.from_bytes(data[2:4], 'big', signed=True) / 10.0  # 0.1A
        capacity = int.from_bytes(data[4:6], 'big') / 100.0  # 0.01Ah
        temp_count = data[6]
        
        temperatures = []
        for i in range(temp_count):
            temp_raw = data[7 + i]
            temperatures.append(temp_raw - 40)  # Offset by 40°C
        
        return {
            'voltage': voltage,
            'current': current,
            'capacity': capacity,
            'temperatures': temperatures
        }