dev_buck_opstates.c

/*
 * File:   dev_buck_opstates.c
 * Author: M91406
 * Created on October 9, 2020, 9:16 AM
 */
 
 
#include <xc.h> // include processor files - each processor file is guarded.  
#include <stdint.h> // include standard integer data types
#include <stdbool.h> // include standard boolean data types
 
#include "dev_buck_pconfig.h" // include buck converter
#include "dev_buck_typedef.h" // include buck converter data object declarations
#include "dev_buck_substates.h" // include state machine sub-state declarations
#include "dev_buck_special_functions.h" // include buck converter special function declarations
 
 
// Private function prototypes of state functions
 
volatile uint16_t __attribute__((always_inline)) State_Error(volatile struct BUCK_CONVERTER_s *buckInstance);
volatile uint16_t __attribute__((always_inline)) State_Initialize(volatile struct BUCK_CONVERTER_s *buckInstance);
volatile uint16_t __attribute__((always_inline)) State_Reset(volatile struct BUCK_CONVERTER_s *buckInstance);
volatile uint16_t __attribute__((always_inline)) State_Standby(volatile struct BUCK_CONVERTER_s *buckInstance);
volatile uint16_t __attribute__((always_inline)) State_RampUp(volatile struct BUCK_CONVERTER_s *buckInstance);
volatile uint16_t __attribute__((always_inline)) State_Online(volatile struct BUCK_CONVERTER_s *buckInstance);
 
// Declaration of function pointer array listing op-state functions in order of execution
volatile uint16_t (*BuckConverterStateMachine[])(volatile struct BUCK_CONVERTER_s *buckInstance) = 
{
    State_Error,        
    State_Initialize,   
    State_Reset,        
    State_Standby,      
    State_RampUp,       
    State_Online        
};
 
// Declaration variable capturing the size of the sub-state function pointer array 
volatile uint16_t BuckStateList_size = (sizeof(BuckConverterStateMachine)/sizeof(BuckConverterStateMachine[0])); 
 
 
volatile uint16_t State_Initialize(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    volatile uint16_t _i=0;
    
    buckInstance->startup.power_on_delay.counter = 0;   // Reset power on counter
    buckInstance->startup.power_good_delay.counter = 0; // Reset power good counter
 
    // Reset all status bits
    buckInstance->status.bits.adc_active = false;
 
    // Initiate current sensor calibration flag bit
    if (buckInstance->set_values.control_mode == BUCK_CONTROL_MODE_VMC)
        buckInstance->status.bits.cs_calib_complete = true; 
    else if (buckInstance->status.bits.cs_calib_enable)
        buckInstance->status.bits.cs_calib_complete = false; 
    else 
        buckInstance->status.bits.cs_calib_complete = true; 
    
    // Disable control loops
    buckInstance->v_loop.controller->status.bits.enabled = false; // Disable voltage loop
    
    if (buckInstance->set_values.control_mode == BUCK_CONTROL_MODE_ACMC) // In current mode...
    {
        for (_i=0; _i<buckInstance->set_values.no_of_phases; _i++) {
            buckInstance->i_loop[_i].controller->status.bits.enabled = false; // Disable current loop
        }        
    }
    
    // Clear busy bit
    buckInstance->status.bits.busy = false; // Clear BUSY bit
    buckInstance->status.bits.ready = true; // Set READY bit indicating state machine has passed INITIALIZED state
    
    // Transition to STATE_RESET
    return(BUCK_OPSRET_COMPLETE); 
    
}
 
 
volatile uint16_t State_Reset(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    volatile uint16_t retval=1;
    volatile uint16_t _i=0;
 
    // Disable all PWM outputs & control loops (immediate power cut-off)
    retval &= buckPWM_Suspend(buckInstance); // Disable PWM outputs
    
    // Disable voltage loop controller and reset control loop histories
    buckInstance->v_loop.controller->status.bits.enabled = false; // disable voltage control loop
    buckInstance->v_loop.ctrl_Reset(buckInstance->v_loop.controller); // Reset control histories of outer voltage controller
    *buckInstance->v_loop.controller->Ports.Target.ptrAddress = 
        buckInstance->v_loop.controller->Limits.MinOutput;
 
    // Disable current loop controller and reset control loop histories
    if (buckInstance->set_values.control_mode == BUCK_CONTROL_MODE_ACMC) 
    {   // Disable all current control loops and reset control loop histories
        for (_i=0; _i<buckInstance->set_values.no_of_phases; _i++) {
            buckInstance->i_loop[_i].controller->status.bits.enabled = false; 
            buckInstance->i_loop[_i].ctrl_Reset(buckInstance->i_loop[_i].controller); 
            *buckInstance->i_loop[_i].controller->Ports.Target.ptrAddress = 
                buckInstance->i_loop[_i].controller->Limits.MinOutput;
        }
    }
 
    // Reset the bulk voltage settling counters
    buckInstance->startup.power_on_delay.counter = 0; // Clear Power On Delay counter
    buckInstance->startup.power_good_delay.counter = 0; // Clear Power Good Delay counter
 
    // Reset all status bits
    buckInstance->status.bits.adc_active = false;
    buckInstance->status.bits.busy = false; // Clear BUSY bit
    
    // If any sub-function call went unsuccessful, reset state machine
    // else, move on to next state
    
    if (retval)
        return(BUCK_OPSRET_COMPLETE);
    else
        return(BUCK_OPSRET_ERROR);
    
}
                
 
volatile uint16_t State_Standby(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    volatile uint16_t retval=0;
 
    // if the 'autorun' option is set, automatically set the GO bit when the 
    // converter is enabled
    if ((buckInstance->status.bits.enabled) && (buckInstance->status.bits.autorun))
    { buckInstance->status.bits.GO = true; }
 
    // If current sense feedback offset calibration is enabled, 
    // call calibration sub-state routine
    retval = drv_BuckConverter_SpecialFunctionExecute(buckInstance, CS_OFSET_CALIBRATION);
        
    switch (retval)
    {
        case BUCK_OPSRET_COMPLETE:
            buckInstance->status.bits.cs_calib_complete = true; // Set CS Calibration Flag to COMPLETE
            buckInstance->status.bits.busy = false; // Clear BUSY bit indicating on-going activity
            break;
        case BUCK_OPSRET_REPEAT:
            buckInstance->status.bits.cs_calib_complete = false; // Set CS Calibration Flag to COMPLETE
            buckInstance->status.bits.busy = true; // Set BUSY bit indicating on-going activity
            return(BUCK_OPSRET_REPEAT);
            break;
        default:
            buckInstance->status.bits.cs_calib_complete = false; // Set CS Calibration Flag to COMPLETE
            buckInstance->status.bits.busy = false; // Clear BUSY bit indicating on-going activity
            return(BUCK_OPSRET_ERROR);
            break;
    }
 
    // Wait for all startup conditions to be met
    if ((buckInstance->status.bits.enabled) &&          // state machine needs to be enabled
        (buckInstance->status.bits.GO) &&               // GO-bit needs to be set
        (buckInstance->status.bits.adc_active) &&       // ADC needs to be running
        (buckInstance->status.bits.pwm_active) &&       // PWM needs to be running 
        (!buckInstance->status.bits.fault_active) &&    // No active fault is present
        (!buckInstance->status.bits.suspend) &&         // Power supply is not held in suspend mode
        (buckInstance->status.bits.cs_calib_complete)   // Current Sensor Calibration complete
        )
    {
        buckInstance->status.bits.GO = false;
        return(BUCK_OPSRET_COMPLETE);
    }
    else
    // Remain in current state until bit-test becomes true
    {
        return(BUCK_OPSRET_REPEAT);
    }
    
}
 
 
volatile uint16_t State_RampUp(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    volatile uint16_t retval=0;
    
    // If sub-state pointer index is out of range, reset to ZERO
    if ((uint16_t)(buckInstance->state_id.bits.substate_id) >= (uint16_t)(BuckRampUpSubStateList_size))
        buckInstance->state_id.bits.substate_id = 0;
    
    // If selected sub-state index contains a NULL-pointer, exit here
    if (BuckConverterRampUpSubStateMachine[buckInstance->state_id.bits.substate_id] == NULL)
        return(BUCK_OPSRET_ERROR);
    
    // Execute ramp-up sub-state
    retval = BuckConverterRampUpSubStateMachine[buckInstance->state_id.bits.substate_id](buckInstance);
    
    // Validate sub-state function return
    switch (retval) 
    {   
        // If the sub-state returns a REPEAT, leave the sub-state pointer at the recent 
        // index and return REPEAT to the outer state machine to call State_RampUp again
        case BUCK_OPSRET_REPEAT:
            
            retval = BUCK_OPSRET_REPEAT;
            
            break;
 
        // If the sub-state returns a COMPLETE, increment the sub-state pointer to call the 
        // next sub-state next time and return REPEAT to the outer state machine to call
        // State_RampUp again
        case BUCK_OPSRET_COMPLETE:
 
            // Increment sub-state pointer by one tick
            buckInstance->state_id.bits.substate_id++;
            
            // CHeck if pointer is out of range
            if ((uint16_t)(buckInstance->state_id.bits.substate_id) < (uint16_t)(BuckRampUpSubStateList_size))
            { // if execution list is not complete yet, return op-state as REPEAT
                retval = BUCK_OPSRET_REPEAT;
 
                if (buckInstance->state_id.bits.substate_id == BUCK_OPSTATE_I_RAMP_UP)
                { // if the next state is set to "I Ramp-Up", check if converter supports
                  // this sub-state in its current configuration and step over it if not
 
                    if (buckInstance->set_values.control_mode == BUCK_CONTROL_MODE_VMC)
                        buckInstance->state_id.bits.substate_id++; // Increment sub-state pointer
                    
                }
 
            }
            else
            {
            // if last item of execution list is complete. return op-state as COMPLETE
                retval = BUCK_OPSRET_COMPLETE;
            }
            
            break;
 
        // If the sub-state returns any other value, something went wrong. In this case
        // return ERROR to outer state machine triggering a main state machine reset.
        default:
            // if any other return value is received, switch immediately to ERROR
            retval = BUCK_OPSRET_ERROR;        
            
            break;
    }
    
    return(retval);
}
 
 
volatile uint16_t State_Online(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    if(buckInstance->set_values.v_ref != buckInstance->v_loop.reference) 
    {
        // Set the BUSY bit indicating a delay/ramp period being executed
        buckInstance->status.bits.busy = true;
 
        // New reference value is less than controller reference value => ramp down
        if(buckInstance->set_values.v_ref < buckInstance->v_loop.reference){
            // decrement reference until new reference level is reached
            buckInstance->v_loop.reference -= buckInstance->startup.v_ramp.ref_inc_step; // decrement reference
            if(buckInstance->v_loop.reference < buckInstance->set_values.v_ref) { // check if ramp is complete
                buckInstance->v_loop.reference = buckInstance->set_values.v_ref; // clamp reference level to setting
            }
 
        }
        // New reference value is greater than controller reference value => ramp up
        else if(buckInstance->set_values.v_ref > buckInstance->v_loop.reference){
            // increment reference until new reference level is reached
            buckInstance->v_loop.reference += buckInstance->startup.v_ramp.ref_inc_step; // increment reference
            if(buckInstance->v_loop.reference > buckInstance->set_values.v_ref) { // check if ramp is complete
                buckInstance->v_loop.reference = buckInstance->set_values.v_ref; // clamp reference level to setting
            }
 
        }
 
    }
    else{
        // Clear the BUSY bit indicating "no state machine activity"
        buckInstance->status.bits.busy = false;
    }
 
    // remain in STATE_ONLINE
    return(BUCK_OPSRET_REPEAT);
    
}
 
 
volatile uint16_t State_Error(volatile struct BUCK_CONVERTER_s *buckInstance)
{
    volatile uint16_t retval=0;
    
    // If this function is ever called, bring state machine back on track 
    // by resetting it to INITIALIZE
    
    retval = buckPWM_Suspend(buckInstance);             // Hold PWM output (turning off power)
    buckInstance->status.bits.busy = false;             // Reset busy bit
 
    if(retval)
        retval = BUCK_OPSRET_COMPLETE;
    else
        retval = BUCK_OPSRET_ERROR;
 
    
    return(retval);
}
 
 
// ______________________________________
// end of file