Generic Chinese BMS BLE Protocolv1.0

Table of Contents

1. Overview
2. Authentication
3. BLE Service Specification
4. Packet Structure
5. Communication Flow
6. Command Set
7. Data Types and Encoding
8. State Machine
9. Error Handling
10. 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
• Challenge-Response Authentication

1.1 Authentication

Before standard commands (0xDD) are accepted, a handshake must be performed using Auth Packets (0xFF).

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  │ Action  │ Function │ Length │   Data   │ Checksum_H  │ Checksum_L  │  Tail   │
├─────────┼─────────┼──────────┼────────┼──────────┼─────────────┼─────────────┼─────────┤
│  0xDD   │ 0xA5/5A │  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

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_request_checksum(function: int, length: int, data: bytes) -> tuple[int, int]:
    """
    Calculate 16-bit checksum for REQUEST packets
    Per protocol spec: 0x10000 - sum(function + length + data)
    Returns: (high_byte, low_byte)
    """
    checksum = function + length
    for byte in data:
        checksum += byte
    
    # Protocol formula: 0x10000 - sum
    checksum = (0x10000 - checksum) & 0xFFFF
    high_byte = (checksum >> 8) & 0xFF
    low_byte = checksum & 0xFF
    
    return (high_byte, low_byte)

def calculate_response_checksum(length: int, data: bytes) -> tuple[int, int]:
    """
    Calculate 16-bit checksum for validating RESPONSE packets
    Checksum covers: length + data bytes only
    """
    checksum = length
    for byte in data:
        checksum += byte
    
    checksum = (0x10000 - checksum) & 0xFFFF
    return ((checksum >> 8) & 0xFF, checksum & 0xFF)

# Example: Read Base Info request
# Function=0x03, Length=0x00, Data=[]
# Checksum = 0x10000 - 0x03 = 0xFFFD
# Packet: DD A5 03 00 FF FD 77

Authentication Checksum

def calculate_auth_checksum(payload: bytes) -> int:
    """
    Calculate 8-bit checksum for Auth packets (Header FF, AA)
    Sum of payload bytes (Cmd + Len + Data)
    """
    checksum = 0
    for byte in payload:
        checksum += byte
    
    return checksum & 0xFF

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
        }