dev_buck_typedef.h

 
/* 
 * File:   dev_buck_typedef.h
 * Author: M91406
 * Comments: Type definitions of single- and multiphase Buck Converter data object
 * Revision history: 
 * 1.0  initial release
 * 1.1  restructured phase arrays in data object to optimize code execution and stay with unified API
 *      with regards to other power converter object libraries
 */
 
// This is a guard condition so that contents of this file are not included
// more than once.  
#ifndef BUCK_CONVERTER_TYPE_DEF_H
#define BUCK_CONVERTER_TYPE_DEF_H
 
#include <xc.h> // include processor files - each processor file is guarded.  
#include <stdint.h> // include standard integer number data types
#include <stdbool.h> // include standard boolean data types (true/false)
#include <stddef.h> // include standard definition data types
#include <dsp.h> // include DSP related standard data types
 
#include "power_control/drivers/npnz16b.h"
#include "config/hal.h"
 
 
 
#define BUCK_MPHASE_COUNT           BUCK_NO_OF_PHASES
 
// Controller Status Bits
 
enum BUCK_STATUS_FLAGS_e 
{  
    BUCK_STAT_READY                = 0b0000000000000001,
    BUCK_STAT_ADC_ACTIVE           = 0b0000000000000010,
    BUCK_STAT_PWM_ACTIVE           = 0b0000000000000100,
    BUCK_STAT_POWERSOURCE_DETECTED = 0b0000000000001000,
    BUCK_STAT_CS_SENSE_READY       = 0b0000000000010000,
    
    BUCK_STAT_FORCED_SHUT_DOWN     = 0b0000000010000000,
    BUCK_STAT_BUSY                 = 0b0000000100000000,
 
// Controller Control Bits
    BUCK_STAT_GO                   = 0b0010000000000000,
    BUCK_STAT_AUTORUN              = 0b0100000000000000,
    BUCK_STAT_NO_AUTORUN           = 0b0000000000000000,
    
    BUCK_STAT_ENABLED              = 0b1000000000000000,
    BUCK_STAT_DISABLED             = 0b0000000000000000
}; 
typedef enum BUCK_STATUS_FLAGS_e BUCK_STATUS_FLAGS_t;
 
 
enum BUCK_OPSTATES_e {  
    
    BUCK_OPSTATE_ERROR          = 0x00,  
    BUCK_OPSTATE_INITIALIZE     = 0x01,  
    BUCK_OPSTATE_RESET          = 0x02,  
    BUCK_OPSTATE_STANDBY        = 0x03,  
    BUCK_OPSTATE_RAMPUP         = 0x04,  
    BUCK_OPSTATE_ONLINE         = 0x05   
        
}; 
typedef enum BUCK_OPSTATES_e BUCK_OPSTATE_t; 
 
 
enum BUCK_SUBSTATES_e {  // Enumeration of state machine operating sub-states
 
    BUCK_OPSTATE_POWER_ON_DELAY = 0x00,  
    BUCK_OPSTATE_PREPARE_V_RAMP = 0x01,  
    BUCK_OPSTATE_V_RAMP_UP      = 0x02,  
    BUCK_OPSTATE_I_RAMP_UP      = 0x03,  
    BUCK_OPSTATE_PWRGOOD_DELAY  = 0x04   
    
}; 
typedef enum BUCK_SUBSTATES_e BUCK_OP_SUBSTATES_t; 
 
 
enum BUCK_OPSTATE_RETURNS_e {  // Enumeration of state machine operating state return values
    
    BUCK_OPSRET_ERROR           = 0x0000,  
    BUCK_OPSRET_COMPLETE        = 0x0001,  
    BUCK_OPSRET_REPEAT          = 0x0002   
        
}; // Enumeration of state machine operating state return values
typedef enum BUCK_OPSTATE_RETURNS_e BUCK_OPSTATE_RETURNS_t; // State Machine Operating State Return Values
 
 
enum BUCK_CONTROL_MODE_e{
    
    BUCK_CONTROL_MODE_VMC  = 0,         
    BUCK_CONTROL_MODE_PCMC = 1,         
    BUCK_CONTROL_MODE_ACMC = 2          
        
}; 
typedef enum BUCK_CONTROL_MODE_e BUCK_CONTROL_MODE_t; 
 
 
struct BUCK_CONVERTER_CONSTANTS_s
{
    volatile enum BUCK_STATUS_FLAGS_e StatusFlags; 
    volatile enum BUCK_OPSTATES_e OpStateOpCodes;  
    volatile enum BUCK_SUBSTATES_e SubStateOpCodes;  
    volatile enum BUCK_OPSTATE_RETURNS_e OpStateReturnValues;  
    volatile enum BUCK_CONTROL_MODE_e ControlModes;  
};
typedef struct BUCK_CONVERTER_CONSTANTS_s BUCK_CONVERTER_CONSTANTS_t;
 
 
extern volatile struct BUCK_CONVERTER_CONSTANTS_s BuckConverterConstants;
 
 
struct BUCK_CONVERTER_STATUS_s
{
    union {
    struct{
        volatile bool ready:1;                  
        volatile bool adc_active:1;             
        volatile bool pwm_active:1;             
        volatile bool fault_active :1;          
        volatile bool fault_latch :1;           
        volatile bool cs_calib_complete :1;     
        volatile bool suspend :1;               
        volatile bool busy :1;                  
 
        volatile bool cs_calib_enable :1;       
        volatile bool async_mode :1;            
        volatile unsigned :1;                   
        volatile unsigned :1;                   
        volatile unsigned :1;                   
        volatile bool GO :1;                    
        volatile bool autorun :1;               
        volatile bool enabled :1;               
    } __attribute__((packed)) bits;             
 
    volatile uint16_t value; // buffer for 16-bit word read/write operations
    };
}; // Buck Converter Status & Control word
typedef struct BUCK_CONVERTER_STATUS_s BUCK_CONVERTER_STATUS_t; // Buck Converter Status & Control word data type
 
 
struct BUCK_STATE_ID_s 
{
    union {
    struct { 
        volatile enum BUCK_OPSTATES_e opstate_id;   
        volatile enum BUCK_SUBSTATES_e substate_id; 
    } bits;
    volatile uint32_t value; // full state ID value access to main and sub-state machine state
    };
}; // Buck Converter State Machine operating state ID
typedef struct BUCK_STATE_ID_s BUCK_STATE_ID_t;  // Buck Converter State Machine operating state ID data type
 
 
struct BUCK_STARTUP_PERIOD_HANDLER_s {
    
    volatile uint16_t counter;      
    volatile uint16_t period;       
    volatile uint16_t reference;    
    volatile uint16_t ref_inc_step; 
    
}; // Power converter soft-start auxiliary variables
typedef struct BUCK_STARTUP_PERIOD_HANDLER_s BUCK_STARTUP_PERIOD_HANDLER_t; // Power converter soft-start auxiliary variables data types
 
 
 struct BUCK_CONVERTER_STARTUP_s {
    
    volatile struct BUCK_STARTUP_PERIOD_HANDLER_s power_on_delay;
    volatile struct BUCK_STARTUP_PERIOD_HANDLER_s power_good_delay;
    volatile struct BUCK_STARTUP_PERIOD_HANDLER_s i_ramp;
    volatile struct BUCK_STARTUP_PERIOD_HANDLER_s v_ramp;
    
}; // Power converter start-up settings and variables
typedef struct BUCK_CONVERTER_STARTUP_s  BUCK_CONVERTER_STARTUP_t; // Power converter start-up settings and variables data type
 
 
struct BUCK_CONVERTER_DATA_s {
    
    volatile uint16_t i_sns[BUCK_MPHASE_COUNT];     
    volatile uint16_t i_out;                        
    volatile uint16_t v_in;                         
    volatile uint16_t v_out;                        
    volatile uint16_t temp;                         
    
    volatile uint16_t control_input;                
    volatile uint16_t control_error;                
    volatile uint16_t control_output;               
    
}; // BUCK runtime data buffer
typedef struct BUCK_CONVERTER_DATA_s BUCK_CONVERTER_DATA_t; // BUCK runtime data buffer data type
 
 
struct BUCK_CONVERTER_SETTINGS_s {
    
    volatile enum BUCK_CONTROL_MODE_e control_mode;  
    volatile uint16_t no_of_phases;             
    volatile uint16_t v_ref;                    
    volatile uint16_t i_ref;                    
    
};  
typedef struct BUCK_CONVERTER_SETTINGS_s BUCK_CONVERTER_SETTINGS_t;  
 
 
struct BUCK_LOOP_SETTINGS_s {
    
    // Properties (user settings)
    volatile uint16_t reference;            
    volatile uint16_t feedback_offset;      
    volatile uint16_t trigger_offset;       
    volatile uint16_t minimum;              
    volatile uint16_t maximum;              
    // Control Loop Object
    volatile struct NPNZ16b_s* controller;  
    // Function pointers
    volatile uint16_t (*ctrl_Initialize)(volatile struct NPNZ16b_s*); 
    void (*ctrl_Reset)(volatile struct NPNZ16b_s*); 
    void (*ctrl_Update)(volatile struct NPNZ16b_s*); 
    void (*ctrl_Precharge)(volatile struct NPNZ16b_s*, volatile fractional, volatile fractional); 
    
}; 
typedef struct BUCK_LOOP_SETTINGS_s BUCK_LOOP_SETTINGS_t; 
 
 
struct BUCK_SLOPE_COMP_SETTINGS_s
{
    volatile uint16_t dac_instance; 
    volatile uint16_t cmp_instance; 
    volatile uint16_t cmp_input; 
    volatile uint16_t pwm_trigger_input; 
    volatile uint16_t slew_rate; 
    volatile uint16_t slope_start_trigger; 
    volatile uint16_t slope_stop_trigger; 
    volatile uint16_t initial_dac_value; 
    volatile uint16_t* ptr_duty_cycle; 
    volatile uint16_t duty_cycle_limit; 
    
}; 
typedef struct BUCK_SLOPE_COMP_SETTINGS_s BUCK_SLOPE_COMP_SETTINGS_t; 
 
 
struct BUCK_SWITCH_NODE_SETTINGS_s {
    
    volatile uint16_t pwm_instance;         
    volatile uint16_t gpio_instance;        
    volatile uint16_t gpio_high;            
    volatile uint16_t gpio_low;             
    volatile bool     swap_outputs;         
    volatile bool     master_period_enable; 
    volatile bool     high_resolution_enable; 
    volatile bool     sync_drive;           
    volatile uint16_t period;               
    volatile uint16_t phase;                
    volatile uint16_t duty_ratio_init;      
    volatile uint16_t duty_ratio_min;       
    volatile uint16_t duty_ratio_max;       
    volatile uint16_t dead_time_rising;     
    volatile uint16_t dead_time_falling;    
    volatile uint16_t leb_period;           
    volatile uint16_t adc_trigger_scaler;   
    volatile uint16_t adc_trigger_offset;   
    
    volatile struct BUCK_SLOPE_COMP_SETTINGS_s slope_compensation; 
    
}; 
typedef struct BUCK_SWITCH_NODE_SETTINGS_s  BUCK_SWITCH_NODE_SETTINGS_t; 
 
 
 
struct BUCK_ADC_INPUT_SCALING_s {
    
    volatile int16_t factor; 
    volatile int16_t scaler; 
    volatile int16_t offset; 
 
}; 
typedef struct BUCK_ADC_INPUT_SCALING_s BUCK_ADC_INPUT_SCALING_t; 
 
 
struct BUCK_ADC_INPUT_SETTINGS_s {
    
    volatile bool enabled;                  
    volatile uint16_t* adc_buffer;          
    volatile uint16_t gpio_instance;        
    volatile uint8_t adc_input;             
    volatile uint8_t adc_core;              
    volatile uint8_t trigger_source;        
    volatile bool interrupt_enable;         
    volatile bool early_interrupt_enable;   
    volatile bool differential_input;       
    volatile bool signed_result;            
    volatile bool level_trigger;            
    volatile struct BUCK_ADC_INPUT_SCALING_s scaling; 
 
}; 
typedef struct BUCK_ADC_INPUT_SETTINGS_s BUCK_ADC_INPUT_SETTINGS_t; 
 
 
struct BUCK_FEEDBACK_SETTINGS_s {
    
    volatile struct BUCK_ADC_INPUT_SETTINGS_s ad_vin;                       
    volatile struct BUCK_ADC_INPUT_SETTINGS_s ad_vout;                      
    volatile struct BUCK_ADC_INPUT_SETTINGS_s ad_isns[BUCK_MPHASE_COUNT];   
    volatile struct BUCK_ADC_INPUT_SETTINGS_s ad_temp;                      
    
}; 
typedef struct BUCK_FEEDBACK_SETTINGS_s BUCK_FEEDBACK_SETTINGS_t; 
 
 
struct BUCK_GPIO_INSTANCE_s {
    
    volatile bool enabled;      
    volatile uint16_t port;     
    volatile uint16_t pin;      
    volatile uint16_t polarity; 
    volatile uint16_t io_type;  
 
}; 
typedef struct BUCK_GPIO_INSTANCE_s BUCK_GPIO_INSTANCE_t; 
 
 
struct BUCK_GPIO_SETTINGS_s {
    
    volatile struct BUCK_GPIO_INSTANCE_s EnableInput; 
    volatile struct BUCK_GPIO_INSTANCE_s PowerGood; 
 
}; 
typedef struct BUCK_GPIO_SETTINGS_s BUCK_GPIO_SETTINGS_t; 
 
 
struct BUCK_CONVERTER_s 
{
    volatile struct BUCK_CONVERTER_STATUS_s status;     
    volatile struct BUCK_STATE_ID_s state_id;           
    volatile struct BUCK_CONVERTER_STARTUP_s startup;   
    volatile struct BUCK_CONVERTER_SETTINGS_s set_values;
    volatile struct BUCK_CONVERTER_DATA_s data;         
    volatile struct BUCK_FEEDBACK_SETTINGS_s feedback;  
 
    volatile struct BUCK_SWITCH_NODE_SETTINGS_s sw_node[BUCK_MPHASE_COUNT]; 
    volatile struct BUCK_GPIO_SETTINGS_s gpio;          
    
    volatile struct BUCK_LOOP_SETTINGS_s v_loop;        
    volatile struct BUCK_LOOP_SETTINGS_s i_loop[BUCK_MPHASE_COUNT]; 
    
}; 
typedef struct BUCK_CONVERTER_s BUCK_CONVERTER_t; 
 
 
//#else
//    #pragma message "Warning: dev_buck_typedef.h inclusion bypassed"
#endif  /* BUCK_CONVERTER_TYPE_DEF_H */