1.Time-Based Advancement Method:

typedef struct {
    uint8_t current_hall;
    uint32_t last_hall_time;
    float advance_angle;  // in degrees
    float motor_speed;    // in RPM
} MotorState_t;

uint8_t getAdvancedCommutation(MotorState_t* motor) {
    uint8_t hall_state = readHallState();
    uint32_t current_time = HAL_GetTick();
    
    // Calculate speed
    float time_diff = (current_time - motor->last_hall_time) / 1000.0f; // in seconds
    motor->motor_speed = (60.0f / 6.0f) / time_diff; // RPM (assuming 6 steps per revolution)
    
    // Calculate time to advance
    float advance_time = (motor->advance_angle / 360.0f) * (1.0f / (motor->motor_speed / 60.0f));
    
    // Predict next state based on current speed and desired advance
    uint8_t predicted_step = HALL_TO_STEP[hall_state];
    predicted_step = (predicted_step + 1) % 6;
    
    motor->last_hall_time = current_time;
    return predicted_step;
}


2.Look-up Table Based Advancement:

// Advanced commutation tables for different advance angles
const uint8_t BLDC_STEPS_0_DEG[] =   {0b101, 0b001, 0b011, 0b010, 0b110, 0b100};
const uint8_t BLDC_STEPS_15_DEG[] =  {0b001, 0b011, 0b010, 0b110, 0b100, 0b101};
const uint8_t BLDC_STEPS_30_DEG[] =  {0b011, 0b010, 0b110, 0b100, 0b101, 0b001};

uint8_t getPhaseAdvancedPattern(uint8_t hall_state, float speed) {
    uint8_t base_step = HALL_TO_STEP[hall_state];
    
    // Select advance based on speed
    if(speed < 1000) {
        return BLDC_STEPS_0_DEG[base_step];
    } else if(speed < 2000) {
        return BLDC_STEPS_15_DEG[base_step];
    } else {
        return BLDC_STEPS_30_DEG[base_step];
    }
}

3. Dynamic Calculation Method:
typedef struct {
    float electrical_angle;    // 0-360 degrees
    float advance_angle;       // advance angle in degrees
    float speed;              // current speed
} AdvanceState_t;

void calculateAdvancedAngle(AdvanceState_t* state) {
    // Base electrical angle from Hall sensors (60° segments)
    uint8_t hall_state = readHallState();
    float base_angle = HALL_TO_ANGLE[hall_state];
    
    // Calculate dynamic advance based on speed
    float speed_factor = state->speed / RATED_SPEED;
    float dynamic_advance = state->advance_angle * speed_factor;
    
    // Calculate final electrical angle
    state->electrical_angle = base_angle + dynamic_advance;
    if(state->electrical_angle >= 360.0f) {
        state->electrical_angle -= 360.0f;
    }
}

void applyAdvancedCommutation(AdvanceState_t* state) {
    // Convert electrical angle to PWM values
    float angle_rad = state->electrical_angle * (PI / 180.0f);
    
    // Generate sinusoidal PWM patterns
    uint16_t pwm_a = (uint16_t)(sinf(angle_rad) * PWM_PERIOD);
    uint16_t pwm_b = (uint16_t)(sinf(angle_rad - (2.0f * PI / 3.0f)) * PWM_PERIOD);
    uint16_t pwm_c = (uint16_t)(sinf(angle_rad + (2.0f * PI / 3.0f)) * PWM_PERIOD);
    
    // Apply PWM values
    updatePhasePWM(pwm_a, pwm_b, pwm_c);
}


4.Integrated Implementation:
typedef struct {
    float advance_angle;
    float speed;
    uint8_t current_step;
    uint32_t last_update;
    AdvanceMode_t mode;
} MotorControl_t;

void updateMotorAdvance(MotorControl_t* motor) {
    uint8_t hall_state = readHallState();
    uint32_t current_time = HAL_GetTick();
    
    // Update speed
    updateSpeed(motor, current_time);
    
    // Calculate advance based on mode
    switch(motor->mode) {
        case ADVANCE_MODE_FIXED:
            // Fixed advance angle
            motor->current_step = getFixedAdvance(hall_state, motor->advance_angle);
            break;
            
        case ADVANCE_MODE_DYNAMIC:
            // Dynamic advance based on speed
            motor->current_step = getDynamicAdvance(hall_state, motor->speed);
            break;
            
        case ADVANCE_MODE_OPTIMAL:
            // Optimal advance calculation
            motor->current_step = getOptimalAdvance(hall_state, motor->speed, motor->load);
            break;
    }
    
    // Apply commutation
    applyCommutation(motor->current_step);
    motor->last_update = current_time;
}

// Helper function for optimal advance calculation
float calculateOptimalAdvance(float speed, float load) {
    // Example of a simple optimal advance calculation
    float base_advance = 15.0f; // base advance angle
    float speed_factor = speed / RATED_SPEED;
    float load_factor = load / RATED_LOAD;
    
    return base_advance * speed_factor * (1.0f + 0.2f * load_factor);
}


Important considerations:

1.Speed Limitations:
Phase advance becomes more important at higher speeds
Need to handle mechanical limitations
Consider maximum safe operating speed

2.Dynamic Response:

// Smooth advance angle changes
void smoothAdvanceTransition(MotorControl_t* motor, float target_advance) {
    float delta = target_advance - motor->advance_angle;
    float max_change = MAX_ADVANCE_CHANGE_PER_UPDATE;
    
    if(fabs(delta) > max_change) {
        delta = (delta > 0) ? max_change : -max_change;
    }
    
    motor->advance_angle += delta;
}

3.Protection:
bool isAdvanceSafe(float advance_angle, float speed) {
    if(speed > MAX_SAFE_SPEED) return false;
    if(advance_angle > MAX_SAFE_ADVANCE) return false;
    return true;
}

Remember:

Start with small advance angles
Test thoroughly at each speed range
Monitor motor temperature
Consider efficiency vs. performance tradeoffs
Implement proper error handling
Use appropriate filtering for speed measurement
Consider system dynamics and response time
The optimal implementation depends on your specific requirements for:

Speed range
Efficiency requirements
Dynamic response needs
Processing capabilities
Sensor resolution and accuracy