automotive-ecu-systems

Automotive Ecu Systems

Bcm Body Control

BCM (Body Control Module) - Comfort and Convenience Systems

Overview

The Body Control Unit (BCM) manages exterior/interior lighting, HVAC integration, door locks, windows, wipers, keyless entry, anti-theft systems, and power distribution across body electronics. This skill covers production-ready BCM development with LIN bus mastering.

Core Responsibilities

1. Exterior/Interior Lighting Control

/* bcm_lighting_control.c - Comprehensive lighting management */
#include "bcm_lighting_control.h"
#include <stdint.h>
#include <stdbool.h>

#define PWM_FREQUENCY_HZ 1000
#define DIM_STEP_PERCENT 5
#define AUTO_HEADLIGHT_THRESHOLD_LUX 100

typedef enum {
    LIGHT_MODE_OFF = 0,
    LIGHT_MODE_PARKING,
    LIGHT_MODE_DAYTIME_RUNNING,
    LIGHT_MODE_LOW_BEAM,
    LIGHT_MODE_HIGH_BEAM,
    LIGHT_MODE_AUTO
} HeadlightMode_t;

typedef struct {
    bool left_turn_signal_active;
    bool right_turn_signal_active;
    bool hazard_active;
    uint8_t turn_signal_phase;  /* 0-100% for flashing */
    uint32_t last_toggle_ms;
} TurnSignalState_t;

typedef struct {
    HeadlightMode_t mode;
    uint8_t brightness_percent;
    bool high_beam_assist_active;
    bool adaptive_lighting_active;
} HeadlightState_t;

static TurnSignalState_t g_turn_signals = {0};
static HeadlightState_t g_headlights = {0};

void BCM_Lighting_Init(void) {
    /* Initialize PWM channels for LED control */
    PWM_Init(PWM_CHANNEL_LEFT_HEADLIGHT, PWM_FREQUENCY_HZ);
    PWM_Init(PWM_CHANNEL_RIGHT_HEADLIGHT, PWM_FREQUENCY_HZ);
    PWM_Init(PWM_CHANNEL_DOME_LIGHT, PWM_FREQUENCY_HZ);
    PWM_Init(PWM_CHANNEL_AMBIENT_LIGHT, PWM_FREQUENCY_HZ);

    /* Set initial state */
    g_headlights.mode = LIGHT_MODE_OFF;
    g_headlights.brightness_percent = 100;

    /* Load saved settings from EEPROM */
    NvM_ReadBlock(NVM_BLOCK_LIGHTING_SETTINGS, &g_headlights);
}

void BCM_TurnSignals_Update(void) {
    uint32_t current_time = GetSystemTime_ms();

    /* Flash at 1 Hz (500ms on, 500ms off) */
    if ((current_time - g_turn_signals.last_toggle_ms) > 500) {
        g_turn_signals.turn_signal_phase = (g_turn_signals.turn_signal_phase == 0) ? 100 : 0;
        g_turn_signals.last_toggle_ms = current_time;
    }

    /* Left turn signal */
    if (g_turn_signals.left_turn_signal_active || g_turn_signals.hazard_active) {
        PWM_SetDutyCycle(PWM_CHANNEL_LEFT_TURN_FRONT, g_turn_signals.turn_signal_phase);
        PWM_SetDutyCycle(PWM_CHANNEL_LEFT_TURN_REAR, g_turn_signals.turn_signal_phase);
    } else {
        PWM_SetDutyCycle(PWM_CHANNEL_LEFT_TURN_FRONT, 0);
        PWM_SetDutyCycle(PWM_CHANNEL_LEFT_TURN_REAR, 0);
    }

    /* Right turn signal */
    if (g_turn_signals.right_turn_signal_active || g_turn_signals.hazard_active) {
        PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_TURN_FRONT, g_turn_signals.turn_signal_phase);
        PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_TURN_REAR, g_turn_signals.turn_signal_phase);
    } else {
        PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_TURN_FRONT, 0);
        PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_TURN_REAR, 0);
    }
}

void BCM_Headlights_Update(void) {
    uint16_t ambient_light_lux = BCM_LightSensor_Read();

    switch (g_headlights.mode) {
        case LIGHT_MODE_OFF:
            PWM_SetDutyCycle(PWM_CHANNEL_LEFT_HEADLIGHT, 0);
            PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_HEADLIGHT, 0);
            break;

        case LIGHT_MODE_PARKING:
            /* 20% brightness for parking lights */
            PWM_SetDutyCycle(PWM_CHANNEL_LEFT_HEADLIGHT, 20);
            PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_HEADLIGHT, 20);
            break;

        case LIGHT_MODE_DAYTIME_RUNNING:
            /* 50% brightness for DRL */
            PWM_SetDutyCycle(PWM_CHANNEL_LEFT_HEADLIGHT, 50);
            PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_HEADLIGHT, 50);
            break;

        case LIGHT_MODE_LOW_BEAM:
            PWM_SetDutyCycle(PWM_CHANNEL_LEFT_HEADLIGHT, g_headlights.brightness_percent);
            PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_HEADLIGHT, g_headlights.brightness_percent);
            break;

        case LIGHT_MODE_HIGH_BEAM:
            /* Full brightness for high beam */
            PWM_SetDutyCycle(PWM_CHANNEL_LEFT_HEADLIGHT, 100);
            PWM_SetDutyCycle(PWM_CHANNEL_RIGHT_HEADLIGHT, 100);
            PWM_SetDutyCycle(PWM_CHANNEL_HIGH_BEAM, 100);
            break;

        case LIGHT_MODE_AUTO:
            /* Automatic headlight control based on ambient light */
            if (ambient_light_lux < AUTO_HEADLIGHT_THRESHOLD_LUX) {
                /* Dark: enable low beams */
                g_headlights.mode = LIGHT_MODE_LOW_BEAM;
            } else {
                /* Bright: enable DRL only */
                g_headlights.mode = LIGHT_MODE_DAYTIME_RUNNING;
            }
            break;
    }

    /* High beam assist: automatically switch to low beam when oncoming traffic detected */
    if (g_headlights.high_beam_assist_active && g_headlights.mode == LIGHT_MODE_HIGH_BEAM) {
        bool oncoming_detected = ADAS_Camera_DetectOncomingVehicle();
        if (oncoming_detected) {
            g_headlights.mode = LIGHT_MODE_LOW_BEAM;
        }
    }
}

/* Interior dome light with fade-in/fade-out */
void BCM_DomeLight_SetState(bool on, bool fade) {
    static uint8_t current_brightness = 0;
    uint8_t target_brightness = on ? 100 : 0;

    if (fade) {
        /* Fade gradually */
        while (current_brightness != target_brightness) {
            if (current_brightness < target_brightness) {
                current_brightness += DIM_STEP_PERCENT;
            } else {
                current_brightness -= DIM_STEP_PERCENT;
            }

            PWM_SetDutyCycle(PWM_CHANNEL_DOME_LIGHT, current_brightness);
            OsTask_Sleep(50);  /* 50ms steps for smooth fade */
        }
    } else {
        /* Immediate switch */
        current_brightness = target_brightness;
        PWM_SetDutyCycle(PWM_CHANNEL_DOME_LIGHT, current_brightness);
    }
}