pwrctrl_sm.c

Go to the documentation of this file.

/*
    (c) 2024 Microchip Technology Inc. and its subsidiaries. You may use this
    software and any derivatives exclusively with Microchip products.
 
    THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
    EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
    WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
    PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION
    WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION.
 
    IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
    WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
    BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
    FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
    ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
    THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
 
    MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE
    TERMS.
 */
 
#include <xc.h>
#include <stdint.h> // include standard integer data types
#include <stdbool.h> // include standard boolean data types
#include <stddef.h> // include standard definition data types
                               
// DAB header files
#include "pwrctrl.h"
#include "pwm_hs/pwm.h"
 
#include "config/macros.h"
#include "device/device.h"
#include "fault/fault.h"
#include "dcdt/pwrctrl_dcdt.h"
 
//PRIVATE FUNCTIONS
static void PCS_INIT_handler(POWER_CONTROL_t* pcInstance);
static void PCS_WAIT_IF_FAULT_ACTIVE_handler(POWER_CONTROL_t* pcInstance);
static void PCS_STANDBY_handler(POWER_CONTROL_t* pcInstance);
static void PCS_SOFT_START_handler(POWER_CONTROL_t* pcInstance);
static void PCS_UP_AND_RUNNING_handler(POWER_CONTROL_t* pcInstance);
 
 
void PwrCtrl_StateMachine(POWER_CONTROL_t* pcInstance)
{ 
    switch (pcInstance->State)
    {
        case PWRCTRL_STATE_INITIALIZE:
            PCS_INIT_handler(pcInstance);
            break;    
 
        case PWRCTRL_STATE_FAULT_DETECTION:
            PCS_WAIT_IF_FAULT_ACTIVE_handler(pcInstance);
            break;
 
        case PWRCTRL_STATE_STANDBY:
            PCS_STANDBY_handler(pcInstance);
            break;
 
        case PWRCTRL_STATE_SOFT_START:
            PCS_SOFT_START_handler(pcInstance);
            break;
 
        case PWRCTRL_STATE_ONLINE:
            PCS_UP_AND_RUNNING_handler(pcInstance);
            break;
 
        default:
            pcInstance->State = PWRCTRL_STATE_INITIALIZE;
            break;      
    }
}
 
 
static void PCS_INIT_handler(POWER_CONTROL_t* pcInstance)
{
    PwrCtrl_Initialize();//enforce reinit of all compensators variables to 0, avoid glitches at a new startup
    PwrCtrl_PWM_Disable();
    PWM_Disable();
    
    #if defined (CURRENT_CALIBRATION) && (CURRENT_CALIBRATION == true)    
    // Execute current sensor offset calibration
    Dev_CurrentSensorOffsetCal();
    
    // Checks if the calibration is complete
    if (Dev_CurrentSensor_Get_CalibrationStatus())
    #endif
    {
        // Current sensor calibration is complete. Update the offset of the current sensor
        pcInstance->Data.ISecSensorOffset = Dev_CurrentSensor_Get_Offset();
   
        // Reset fault objects status bits
        Fault_Reset();
        
        // Clear power control fault active bit
        pcInstance->Status.bits.FaultActive = 0;
        // Clear power control running bit
        pcInstance->Status.bits.Running = 0;
        // Clear power control enable bit
        pcInstance->Properties.Enable = 0;
        
        // Next State assigned to STATE_FAULT_DETECTION
        pcInstance->State = PWRCTRL_STATE_FAULT_DETECTION;
    }   
}
 
 
static void PCS_WAIT_IF_FAULT_ACTIVE_handler(POWER_CONTROL_t* pcInstance)
{   
    if (pcInstance->Fault.FaultDetected == 0)
    {
        pcInstance->Status.bits.FaultActive = 0;
        pcInstance->State = PWRCTRL_STATE_STANDBY; // next state
    }
}
 
 
static void PCS_STANDBY_handler(POWER_CONTROL_t* pcInstance)
{
    // Check for fault event 
    if (pcInstance->Fault.FaultDetected)
    {
        // Clear power control enable bit
        pcInstance->Properties.Enable = 0;
        
        // State back to STATE_FAULT_DETECTION
        pcInstance->State = PWRCTRL_STATE_FAULT_DETECTION;
    }
    
    // NOTE: Power control enable is controlled externally 
    else if (pcInstance->Properties.Enable)
    {
        // Reset fault objects status bits
        Fault_Reset();
        
        PwrCtrl_PWM_DAB_DirectionSpecificSwapCfg(dab.PowerDirection);
        // Reset the power control properties and control loop histories
        PwrCtrl_Reset();
            
        #if defined (CURRENT_CALIBRATION) && (CURRENT_CALIBRATION == true) 
        // reset the PWM settings in Standby mode
        Dev_CurrentSensor_Clr_Offset();
        // Execute current sensor offset calibration
        Dev_CurrentSensorOffsetCal();
        // Checks if the calibration is complete
        if (Dev_CurrentSensor_Get_CalibrationStatus())
            #endif
        {    
            pcInstance->Data.ISecSensorOffset = Dev_CurrentSensor_Get_Offset();
 
            // Enable current control loop
            pcInstance->ILoop.Enable = true;
 
            // Update PWM distribution
            PwrCtrl_PWM_Update(&dab);
 
            // Enable PWM physical output
            PwrCtrl_PWM_Enable();
 
            // Enable power control running bit
            pcInstance->Status.bits.Running = 1;
 
            // Next State assigned to STATE_SOFT_START
            pcInstance->State = PWRCTRL_STATE_SOFT_START;
            
            
            
            if(dab.PowerDirection == PWR_CTRL_DISCHARGING)
            {    
                dab.VRamp.ptrReferenceTarget = &dab.Properties.VPriReference;
            }
            else
            {
                dab.VRamp.ptrReferenceTarget = &dab.Properties.VSecReference;
            }    
            
            
            
        }
    }
}
 
 
static void PCS_SOFT_START_handler(POWER_CONTROL_t* pcInstance)
{
    // Check for fault event 
    if (pcInstance->Fault.FaultDetected)
    {
        // Clear power control enable bit
        pcInstance->Properties.Enable = 0;
        
        // State back to STATE_FAULT_DETECTION
        pcInstance->State = PWRCTRL_STATE_FAULT_DETECTION;
    }
  
    // Check if Enable bit has been cleared
    else if (!pcInstance->Properties.Enable) 
    {
        // Disable PWM physical output
        PwrCtrl_PWM_Disable();
        
        // Clear power control running bit
        pcInstance->Status.bits.Running = 0;
        
        // State back to STATE_STANDBY
        pcInstance->State = PWRCTRL_STATE_STANDBY; 
    }
    
    else
    {   
        // Ramp Up the Voltage, Current and Power reference
        uint16_t rampComplete = PwrCtrl_RampReference(&pcInstance->VRamp);
        rampComplete &= PwrCtrl_RampReference(&pcInstance->IRamp);
        rampComplete &= PwrCtrl_RampReference(&pcInstance->PRamp);
 
        // Check if ramp up is complete
        if (rampComplete)
            // Next State assigned to STATE_ONLINE
            pcInstance->State = PWRCTRL_STATE_ONLINE; 
 
    }
}
 
 
static void PCS_UP_AND_RUNNING_handler(POWER_CONTROL_t* pcInstance)
{    
    // Check for fault event 
    if (pcInstance->Fault.FaultDetected)
    {
        // Clear power control enable bit
        pcInstance->Properties.Enable = 0;
        
        // State back to STATE_FAULT_DETECTION
        pcInstance->State = PWRCTRL_STATE_FAULT_DETECTION;
    }
    
    else
    {
        // Check if Enable bit has been cleared
        if (!pcInstance->Properties.Enable) 
        {
            // Disable PWM physical output
            PwrCtrl_PWM_Disable();
 
            // Clear power control running bit
            pcInstance->Status.bits.Running = 0;
 
            // State back to STATE_INITIALIZE
            pcInstance->State = PWRCTRL_STATE_INITIALIZE; 
        }
        
    #if defined (OPEN_LOOP_PBV) && (OPEN_LOOP_PBV == true)
        else if ((pcInstance->Pwm.ControlPeriod & ~(0x7)) != (pcInstance->Pwm.PBVPeriodTarget& ~(0x7)) || 
                (pcInstance->Pwm.ControlPhase != pcInstance->Pwm.PBVControlPhaseTarget))
            pcInstance->State = PWRCTRL_STATE_SOFT_START;
    #endif
        // Check if there is change in power control references    
        else
        {
            if(dab.PowerDirection == PWR_CTRL_CHARGING)
            { 
                if ((pcInstance->ILoop.Reference != pcInstance->Properties.IReference) ||
                    (pcInstance->VLoop.Reference != pcInstance->Properties.VSecReference) ||
                    (pcInstance->PLoop.Reference != pcInstance->Properties.PwrReference))
                // State back to STATE_SOFT_START
                pcInstance->State = PWRCTRL_STATE_SOFT_START;
            }
            if(dab.PowerDirection == PWR_CTRL_DISCHARGING)
            { 
                if ((pcInstance->ILoop.Reference != pcInstance->Properties.IReference) ||
                    (pcInstance->VLoop.Reference != pcInstance->Properties.VPriReference) ||
                    (pcInstance->PLoop.Reference != pcInstance->Properties.PwrReference))
                // State back to STATE_SOFT_START
                pcInstance->State = PWRCTRL_STATE_SOFT_START;
            }
        }
    }
}