Automotive Body Control Module (BCM)

About

A production-grade Body Control Module (BCM) implementation for automotive systems, written in C11 with a focus on embedded best practices. This project demonstrates expertise in:

• Embedded Systems Design — Message-driven architecture with deterministic timing
• Automotive Protocols — CAN bus communication with proper frame validation
• State Machine Implementation — Explicit FSMs for door, lighting, and turn signal control
• Defensive Programming — Input validation, checksums, rolling counters, fault management
• Testing Methodology — Unit tests (CppUTest), Software-in-the-Loop (SIL) simulation
• Zero Dynamic Allocation — All memory statically allocated (~1.6KB RAM footprint)

Built as a portfolio project showcasing automotive embedded software development skills.

---

Features

• Door Control: Lock/unlock with state machine transitions
• Lighting Control: Headlights (off/on/auto), interior lights, high beam
• Turn Signals: Left/right/hazard with proper flash timing, auto-off timeout
• Fault Management: Checksum/counter validation, fault logging, status reporting
• CAN Interface: 11-bit standard IDs, rolling counter, XOR checksum
• Event Log: Ring buffer for state transition history

Architecture

┌─────────────────────────────────────────────────────┐
│ Door Control Lighting Turn Signal Fault │
│ State Machine State M/C State M/C Manager │
├─────────────────────────────────────────────────────┤
│ BCM Core │
│ Message routing, periodic scheduler │
├─────────────────────────────────────────────────────┤
│ CAN Interface Layer │
│ BCM_SIL=1: SocketCAN | BCM_SIL=0: Stub │
└─────────────────────────────────────────────────────┘

Project Structure

automotive-bcm/
├── config/
│ ├── can_ids.h # CAN message schema with byte layouts
│ └── bcm_config.h # BCM configuration parameters
├── include/
│ ├── bcm.h # BCM core interface
│ ├── door_control.h # Door control module
│ ├── lighting_control.h # Lighting control module
│ ├── turn_signal.h # Turn signal module
│ ├── fault_manager.h # Fault management
│ ├── can_interface.h # CAN abstraction layer
│ └── system_state.h # Centralized state
├── src/
│ ├── main.c # Application entry point
│ ├── bcm.c # BCM core implementation
│ ├── door_control.c # Door state machine
│ ├── lighting_control.c # Lighting state machine
│ ├── turn_signal.c # Turn signal state machine
│ ├── fault_manager.c # Fault recording/reporting
│ ├── system_state.c # State management
│ └── can_interface.c # SocketCAN/stub implementation
├── tests/ # CppUTest unit tests
├── tools/
│ └── can_simulator.py # Python CAN test tool
└── docs/ # Architecture documentation

Build Instructions

Prerequisites

• CMake 3.16+
• C11-compatible compiler (GCC, Clang)
• CppUTest (for testing, optional - auto-fetched if not found)

macOS / Linux (Stub Mode)

# Clone and buildcd automotive-bcm
mkdir build &&cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .# Run
./bcm_app

Linux with SocketCAN (SIL Mode)

# Create virtual CAN interface
sudo modprobe vcan
sudo ip link add dev vcan0 type vcan
sudo ip link set up vcan0
# Build with SocketCAN support
mkdir build &&cd build
cmake -DCMAKE_BUILD_TYPE=Release -DBCM_SIL=ON ..
cmake --build .# Run
./bcm_app -i vcan0

Building Tests

mkdir build &&cd build
cmake -DBUILD_TESTS=ON ..
cmake --build .# Run tests
ctest --output-on-failure
# Or run directly with verbose output
./bcm_tests -v

Running

Stub Mode (Default)

./bcm_app
# Output:# ========================================# BCM - Body Control Module# Version: 1.0.0# ========================================## [CAN] Initialized (stub mode)# [DOOR] Initialized# [LIGHT] Initialized# [TURN] Initialized# [FAULT] Initialized# [BCM] Initialized successfully## [MAIN] BCM running. Press Ctrl+C to exit.# [ 1.000s] Doors:UUUU | Head:OFF | Turn:OFF[--] | Faults:0

SIL Mode with Simulator

Terminal 1 (BCM):

./bcm_app -i vcan0

Terminal 2 (Simulator):

python3 tools/can_simulator.py -i vcan0 --interactive
# Commands:> door unlock # Unlock all doors> light on # Headlights on> turn left # Left turn signal> hazard on # Hazard lights> scenario 1 # Run predefined scenario

CAN Message Format

Command Frames (RX)

All commands use 4-byte format:

• Byte 0: Command code
• Byte 1: Parameter
• Byte 2: [7:4] Version, [3:0] Counter (0-15)
• Byte 3: Checksum (XOR with 0xAA seed)

ID	Name	Commands
0x100	DOOR_CMD	0x01=Lock all, 0x02=Unlock all, 0x03/0x04=Single
0x110	LIGHTING_CMD	0x00=Off, 0x01=On, 0x02=Auto, 0x03/0x04=High beam
0x120	TURN_SIGNAL_CMD	0x00=Off, 0x01=Left, 0x02=Right, 0x03/0x04=Hazard

Status Frames (TX)

ID	Name	Period	DLC
0x200	DOOR_STATUS	100ms	6
0x210	LIGHTING_STATUS	100ms	6
0x220	TURN_SIGNAL_STATUS	100ms	6
0x230	FAULT_STATUS	500ms	8
0x240	BCM_HEARTBEAT	1000ms	4

Sample Output

Normal Operation

[DOOR] Door 0: UNLOCKING
[DOOR] Door 0: UNLOCKED
[DOOR] Door 1: UNLOCKING
[DOOR] Door 1: UNLOCKED
[LIGHT] Headlight mode: 0 -> 1
[TURN] LEFT ON
[ 5.000s] Doors:UUUU | Head:ON | Turn:LEFT[L-] | Faults:0
[ 6.000s] Doors:UUUU | Head:ON | Turn:LEFT[--] | Faults:0

Fault Injection

[DOOR] Command error: 1
[FAULT] SET: 0x23
[ 8.000s] Doors:UUUU | Head:OFF | Turn:OFF[--] | Faults:1

Event Log (on exit)

[MAIN] Event Log (8 entries):
[ 1000 ms] Type=1 Data=[00 00 00 00]
[ 1500 ms] Type=3 Data=[00 00 01 00]
[ 2000 ms] Type=5 Data=[00 01 00 00]
[ 3000 ms] Type=9 Data=[01 FF 00 00]

Testing

Unit Tests

# Run all tests
./bcm_tests
# Verbose output
./bcm_tests -v
# Specific test group
./bcm_tests -g DoorLockCommands
# Specific test
./bcm_tests -n "DoorCommandValidation::RejectsInvalidChecksum"

Test Coverage

• Door control: Lock/unlock, state transitions, validation
• Lighting: Mode changes, auto logic, high beam
• Turn signals: Flash timing, hazard, timeout
• Fault manager: Set/clear, flags, status frame
• Edge cases: Counter wrap, max faults, invalid inputs

SIL Scenarios

# Run predefined scenarios
python3 tools/can_simulator.py -s 1 # Basic operation
python3 tools/can_simulator.py -s 2 # Hazard lights
python3 tools/can_simulator.py -s 3 # Fault injection
python3 tools/can_simulator.py -s all # All scenarios

Documentation

• automotive-bcm/docs/architecture.md - System design, CAN schema
• automotive-bcm/docs/state_machines.md - State diagrams, transitions
• automotive-bcm/docs/testing_strategy.md - Test approach, coverage

Design Constraints

• No dynamic allocation - All memory statically allocated
• Defensive coding - All inputs validated
• C11 standard - No compiler extensions
• Embedded-friendly - ~1.6KB RAM footprint

Technologies

Category	Technologies
Language	C11
Build	CMake 3.16+
Testing	CppUTest, CTest
Protocol	CAN 2.0A (11-bit IDs)
SIL	Linux SocketCAN, vcan
Tools	Python 3, python-can

Author

Developed as a demonstration of automotive embedded software engineering skills.

License

Copyright (c) 2026. All rights reserved.