app_power_control.c

 
/*
 * File:   app_power_control.c
 * Author: M91406
 *
 * Created on March 12, 2020, 11:55 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 <stddef.h> // include standard definition data types
 
#include "config/hal.h" // include hardware abstraction layer declarations
#include "app_power_control.h" // include applicaiton layer power control header file
 
#include "./devices/dev_buck_converter.h" // include buck converter device
#include "fault_handler/app_fault_monitor.h" // include fault monitor application object declarations
 
 
 
volatile struct BUCK_CONVERTER_s buck;
 
/* PRIVATE FUNCTION PROTOTYPES */
 
extern volatile uint16_t appPowerSupply_ConverterObjectInitialize(void);
extern volatile uint16_t appPowerSupply_ControllerInitialize(void);
extern volatile uint16_t appPowerSupply_PeripheralsInitialize(void);
 
void __attribute__((always_inline)) appPowerSupply_CurrentBalancing(void); 
 
 
/* *************************************************************************************************
 * PUBLIC FUNCTIONS
 * ************************************************************************************************/
 
 
 
volatile uint16_t appPowerSupply_Execute(void)
{ 
    volatile uint16_t retval=1;
    volatile uint16_t _i=0;
    volatile uint16_t i_dummy=0;
 
    // Capture most recent samples
    buck.data.v_in = BUCK_VIN_ADCBUF;
 
    // Collecting all phase current samples
    buck.data.i_sns[0] = BUCK_ISNS1_ADCBUF;
    buck.data.i_sns[1] = BUCK_ISNS2_ADCBUF;
 
    // Accumulate phase currents
    for (_i=0; _i<buck.set_values.no_of_phases; _i++) 
    { 
        if(buck.data.i_sns[_i] < buck.feedback.ad_isns[_i].scaling.offset)
            buck.data.i_sns[_i] = 0;
        else
            buck.data.i_sns[_i] -= buck.feedback.ad_isns[_i].scaling.offset;
 
        i_dummy += buck.data.i_sns[_i]; 
    }
 
    buck.data.i_out = i_dummy; // Set output current value
 
    // Execute buck converter state machine
    retval &= drv_BuckConverter_Execute(&buck);
    
    // Execute slower, advanced control options
//    appPowerSupply_CurrentBalancing();
 
    // Buck regulation error is only active while controller is running
    // and while being tied to a valid reference
    if((buck.state_id.bits.opstate_id >= BUCK_OPSTATE_RAMPUP) && 
       (buck.state_id.bits.substate_id >= BUCK_OPSTATE_V_RAMP_UP))
    {
        // During and after startup, the dynamic compare object needs to be assigned to the correct source
        fltobj_BuckRegErr.ReferenceObject.ptrObject = buck.v_loop.controller->Ports.ptrControlReference;
        
        // Regulation Error and Over Current Protection fault objects only work if the converter is running
        // Hence, they need to be enabled/disabled with the control loops
        #if (PLANT_MEASUREMENT == false)
        fltobj_BuckRegErr.Status.bits.Enabled = buck.v_loop.controller->status.bits.enabled;
        fltobj_BuckOCP.Status.bits.Enabled = buck.v_loop.controller->status.bits.enabled;
        #endif
    }
    else 
    {
        fltobj_BuckRegErr.Status.bits.Enabled = false;
        fltobj_BuckOCP.Status.bits.Enabled = false;
    }
    
    return(retval); 
}
 
 
volatile uint16_t appPowerSupply_Initialize(void)
{ 
    volatile uint16_t retval=1;
 
    // Run initialization sequence
    retval &= appPowerSupply_ConverterObjectInitialize();
    retval &= appPowerSupply_ControllerInitialize();
    retval &= appPowerSupply_PeripheralsInitialize();
 
    // Initialize Control Interrupt
    _BUCK_VLOOP_ISR_IP = BUCK_VOUT_ISR_PRIORITY;
    _BUCK_VLOOP_ISR_IF = 0;
    _BUCK_VLOOP_ISR_IE = true;
    
    // Start power supply engine
    retval &= appPowerSupply_Start();
    
    // Enable Buck Converter
    buck.status.bits.enabled = true;
    
    return(retval); 
}
 
 
volatile uint16_t appPowerSupply_Start(void)
{
    volatile uint16_t retval=1;
 
    retval &= drv_BuckConverter_Start(&buck); // Start PWM with outputs disabled to start ADC triggering
 
    return(retval); 
}
 
 
volatile uint16_t appPowerSupply_Stop(void)
{
    volatile uint16_t retval=1;
 
    retval &= drv_BuckConverter_Stop(&buck); // Shut down all power supply peripherals and data objects
 
    return(retval); 
}
 
 
volatile uint16_t appPowerSupply_Suspend(void)
{ 
    volatile uint16_t retval=1;
 
    retval &= drv_BuckConverter_Suspend(&buck); // Shut down PWM immediately
 
    return(retval); 
}
 
 
volatile uint16_t appPowerSupply_Resume(void)
{ 
    volatile uint16_t retval=0;
 
    retval &= drv_BuckConverter_Resume(&buck); // Shut down PWM immediately
    
    return(retval); 
}
 
 
inline void appPowerSupply_CurrentBalancing(void) 
{
    static int16_t offset=0;
    
    // Current balancing is only executed in nominal running mode
    if(buck.state_id.bits.opstate_id != BUCK_OPSTATE_ONLINE) 
        return;
    
    // if current in phase #1 is higher than phase current #2...
    if(buck.data.i_sns[0] > buck.data.i_sns[1]) 
    { // .. add 1 tick to phase #2 duty cycle
        offset = (((++offset)>0x07) ? 0x07 : offset);
    }
    else 
    { // .. sub 1 tick from phase #2 duty cycle
        offset = (((--offset)<0x00) ? 0x00 : offset);
    }
 
    buck.v_loop.controller->Ports.AltTarget.Offset = (uint16_t)offset;
 
}
 
// ____________________________
// end of file