app_PBV_psfb_frame_map.c

 
#include "app_PBV_psfb_frame_map.h"
 
#include "system/pins.h"
#include "pwm_hs/pwm.h"
 
#include "pwrctrl/pwrctrl_comm_interface.h"
#include "fault/fault_comm_interface.h"
#include "pwrctrl/pwrctrl.h"
#include "config/version.h"
 
 
#include "pwrctrl/pwrctrl_pwm.h"
 
 
#define FIRMWARE_PROTOCOL_ID              0x1000          
 
#define PBV_GUI_BUTTONS                   0x202            
#define PBV_GUI_SLIDERS                   0x203            
#define PBV_SYSTEM_TO_GUI_ID              0x204             
#define PBV_LOG_ID                        0x300            
 
 
// 
 
static PBV_Datatype_TX_t App_PBV_psfb_TX;          
static PBV_Datatype_RX_t App_PBV_psfb_RX;          
static PBV_Datatype_TX_t App_PBV_psfb_ASCII;       
 
static PBV_Datatype_TX_t * App_PBV_psfb_TX_Ptr = &App_PBV_psfb_TX;        
static PBV_Datatype_RX_t * App_PBV_psfb_RX_Ptr = &App_PBV_psfb_RX;        
static PBV_Datatype_TX_t * App_PBV_psfb_ASCII_Ptr = &App_PBV_psfb_ASCII;  
 
uint8_t buffer_eight_rx[64];
uint16_t buffer_sixteen_rx[32];
 
uint8_t buffer_eight_tx[64];
uint16_t buffer_sixteen_tx[32];
 
static uint32_t tick_counter = 0;
static uint8_t transmit_firmware_id = 1;
 
//temporary variables
static uint16_t slider_PS_PP = 0 ;
static uint16_t dead_time_right = 0;
static uint16_t voltage_ref = 0;
static uint16_t current_ref = 0;
static uint16_t current_slider_ref = 0;
 
 
 static uint8_t button_start = 0;
static uint8_t button_start_sync = 0;
float temp_;
// static int16_t charge_en = 0;
 
 
void App_PBV_psfb_Build_Frame(void);
void App_PBV_psfb_Process_Buttons(uint16_t * data);
void App_PBV_psfb_Process_Sliders(uint16_t * data);
void App_PBV_psfb_Frame_Parser(uint16_t protocol_ID, uint16_t length, uint8_t * data);
 
 
void App_PBV_psfb_Init()
{
    App_PBV_psfb_TX_Ptr->PBV_Protcol_ID        = PBV_SYSTEM_TO_GUI_ID;
    App_PBV_psfb_TX_Ptr->PBV_Signal_Ascii      = PBV_SIGNAL_MODE;
    App_PBV_psfb_TX_Ptr->PBV_Message_State     = PBV_MESSAGE_INIT;
    App_PBV_psfb_TX_Ptr->Length                = 64;
 
    App_PBV_psfb_RX_Ptr->PBV_Message_State     = PBV_MESSAGE_READY_TO_RECEIVE;
 
    App_PBV_psfb_ASCII_Ptr->PBV_Protcol_ID     = FIRMWARE_PROTOCOL_ID;
    App_PBV_psfb_ASCII_Ptr->PBV_Signal_Ascii   = PBV_ASCII_MODE;
    App_PBV_psfb_ASCII_Ptr->PBV_Message_State  = PBV_MESSAGE_INIT;
    App_PBV_psfb_ASCII_Ptr->Length             = 64;
 
    app_PBV_Init(App_PBV_psfb_TX_Ptr, App_PBV_psfb_ASCII_Ptr, App_PBV_psfb_RX_Ptr);
 
    
    dead_time_right = PG1DTH;
    
    current_slider_ref = DAC3DATH;
}
 
 
void App_PBV_psfb_Task_10ms(void)
{
    // Reading received message
    if (App_PBV_psfb_RX_Ptr->PBV_Message_State == PBV_MESSAGE_RECEIVED)
    {        
        app_Read_Received_From_PBV(App_PBV_psfb_RX_Ptr);       
        App_PBV_psfb_Frame_Parser(App_PBV_psfb_RX_Ptr->PBV_Protcol_ID, App_PBV_psfb_RX_Ptr->Length, App_PBV_psfb_RX_Ptr->Data_Buffer);
        
        // msg read. Read another
        app_Receive_From_PBV(App_PBV_psfb_RX_Ptr); 
    } 
    if (++tick_counter > 11)
    {
        App_PBV_psfb_Build_Frame();
        app_Send_To_PBV(App_PBV_psfb_TX_Ptr);  
        tick_counter = 0;
    }    
}
 
 
void App_PBV_psfb_Task_1s(void)
{
    if (App_PBV_psfb_ASCII_Ptr->PBV_Protcol_ID == FIRMWARE_PROTOCOL_ID)
    {
        App_PBV_psfb_ASCII_Ptr->Data_Buffer = "Firmware Version 1.0.0.0.......................................!";
        app_Send_To_PBV(App_PBV_psfb_ASCII_Ptr);
        App_PBV_psfb_ASCII_Ptr->PBV_Protcol_ID = PBV_LOG_ID;
        transmit_firmware_id = 1;
        return;
    }
    if (App_PBV_psfb_ASCII_Ptr->PBV_Protcol_ID == PBV_LOG_ID)
    {
        if (transmit_firmware_id) app_PBV_Re_Init(App_PBV_psfb_ASCII_Ptr);     
        transmit_firmware_id = 0; 
    }
    App_PBV_psfb_ASCII_Ptr->Data_Buffer = "Log Message From Protocol ID 0x300.............................\r";
    app_Send_To_PBV(App_PBV_psfb_ASCII_Ptr);
   
    //average = Dev_Temp_Get_Temperature_Celcius();
}
 
 
PBV_Datatype_TX_t * App_PB_psfb_Get_TX_ASCII_ptr(void){
    if (App_PBV_psfb_ASCII_Ptr ->PBV_Message_State == PBV_MESSAGE_TRANSMITTING)
        return 0;
    return App_PBV_psfb_ASCII_Ptr;
}
 
 
 
void App_PBV_psfb_Build_Frame()
{
    // send back one "flag word" which combines fault and status and enable control flag
    uint16_t enabled = Dev_PwrCtrl_Get_EnableFlag();
    uint16_t fault_flags = Fault_GetFlags();
    uint16_t status_flags = Dev_PwrCtrl_Get_Status();
    uint16_t flag_word = enabled + ((status_flags & 0x0003)<<1) + (fault_flags<<3);
 
    buffer_sixteen_tx[0] = (1<<Dev_PwrCtrl_Get_State());
    buffer_sixteen_tx[1] = flag_word;
    buffer_sixteen_tx[2] = FAULT_EN_GetValue() + 
                            (psfb_ptr->SecRec.SR_Flag<<1) + (psfb_ptr->ILoop.Enable<<2) + (psfb_ptr->ILoop.Enable<<3)+ (psfb_ptr->Precharge.PrechargeEnabled<<4);
    buffer_sixteen_tx[3] = Dev_PwrCtrl_GetAdc_Vpri() ; 
    buffer_sixteen_tx[4] = PwrCtrl_GetAdc_Vrail_5V();
    buffer_sixteen_tx[5] = (PwrCtrl_GetAdc_Temperature() > 497) ? (PwrCtrl_GetAdc_Temperature() - 497 ) : 0;
 
    // I-CT
    buffer_sixteen_tx[6] = PwrCtrl_GetAdc_Ipri_ct();
    buffer_sixteen_tx[7] = DAC3DATH;
    buffer_sixteen_tx[8] = Dev_PwrCtrl_GetIPri_Offset();
    buffer_sixteen_tx[9] = DAC3DATH - Dev_PwrCtrl_GetIPri_Offset();
    
    // I-SHUNT
    buffer_sixteen_tx[10] = PwrCtrl_GetAdc_Isec_shunt();
    buffer_sixteen_tx[11] = Dev_PwrCtrl_GetIsec_Offset();
    //buffer_sixteen_tx[12] = psfb_ptr->Properties.IReference;
    buffer_sixteen_tx[12] = psfb_ptr->VLoop.Output;     // output of vloop will be reference of the iloop
    buffer_sixteen_tx[13] = psfb_ptr->ILoop.Output;
    buffer_sixteen_tx[14] = psfb_ptr->SecRec.Threshold_high;
    buffer_sixteen_tx[15] = psfb_ptr->SecRec.Threshold_low;
 
    // Vout
    buffer_sixteen_tx[16] = Dev_PwrCtrl_GetAdc_Vsec();
 
    // Vcap
    buffer_sixteen_tx[17] = Dev_PwrCtrl_GetVoltage_Vcap();
    buffer_sixteen_tx[18] = psfb_ptr->VLoop.Reference;
    buffer_sixteen_tx[19] = psfb_ptr->Properties.VSecReference;
    buffer_sixteen_tx[20] = psfb_ptr->VLoop.Output;
 
    // phase
    buffer_sixteen_tx[21] = PG1TRIGC;
    buffer_sixteen_tx[22] = psfb_ptr->Precharge.maxDutyCycle;
    
    //(PwrCtrl_GetAdc_Temperature() > 497) ? (PwrCtrl_GetAdc_Temperature() - 497 ) : 0;
    //temp_ = psfb_ptr->ISecAveraging.AverageValue;
    buffer_sixteen_tx[23] = psfb_ptr->ISecAveraging.AverageValue;
    buffer_sixteen_tx[24] = psfb_ptr->Droop.ref_diff;
    
    buffer_sixteen_tx[25] = psfb_ptr->VoutCalibrate.calculated_value;
    buffer_sixteen_tx[26] = psfb_ptr->VoutCalibrate.real_value;
 
    float temp = (float)buffer_sixteen_tx[16] * psfb_ptr->VoutCalibrate.gain_factor ;
 
    buffer_sixteen_tx[27] = (uint16_t)temp;
 
    buffer_sixteen_tx[28] = psfb_ptr->Secondary_Rolling_val;
 
    buffer_sixteen_tx[29] = abs(psfb_ptr->VoutCalibrate.real_value - psfb_ptr->VoutCalibrate.calculated_value); 
 
 
    PBV_Change_from_Sixteen_to_Eight(buffer_sixteen_tx, buffer_eight_tx, 30);
    
    App_PBV_psfb_TX_Ptr->Data_Buffer = buffer_eight_tx;
    App_PBV_psfb_TX_Ptr->Length = 30 * 2 ;
}
 
 
 
void App_PBV_psfb_Process_Buttons(uint16_t * data) {
    uint16_t switchcase = data[0];
    switch (switchcase) {
        case 0x0001:
            if (psfb_ptr->Precharge.precharged == 1)
                PwrCtrl_SetEnable(true);
            break;
        case 0x0000:
            PwrCtrl_SetEnable(false);
            psfb_ptr->Precharge.PrechargeEnabled = 0;
            //FAULT_EN_SetLow();
            break;
 
        case 0xaa00:
//          Dev_Reset_Average_Buffer();
            Fault_Reset();
            PwrCtrl_Reset();
            break;
 
        case 0x00aa:
            //FAULT_EN_SetHigh();
            // charge_en = 1;
 
            PwrCtrl_MaxDutyCycle();
            psfb_ptr->Precharge.PrechargeEnabled = 1;      
            PwrCtrl_PWM_Enable();
            break;
        case 0x00bb:
            FAULT_EN_SetLow();
            // charge_en = 0;
            break;
            
        default:
            break;
    }
//    status_controller_state = button_start | (button_start_sync << 1) | (button_random_action << 2)| (dev_fan_data_ptr->override_flag << 3) ;
}
 
 
void App_PBV_psfb_Process_Sliders(uint16_t * data) {
    uint16_t switchcase = data[0];
    uint16_t temp = 0;
    
    Nop();
    Nop();
    Nop();
    Nop();
    
    switch (switchcase) {
        case 0xaa:
            if (psfb_ptr->ILoop.Enable == 1) 
                break;
            else {
                slider_PS_PP = data[1];
 
            PwrCtrl_SetPhaseTarget(data[1]);
            //PWM_TriggerCCompareValueSet(1, data[1] * 56);
            //GPIO_Debug_high();
            PwrCtrl_PWM_Update();
            //GPIO_Debug_Low();
            // PG1STATbits.UPDREQ = 1; // Set manual update (can be automated later)
            }
            break;
 
        case 0xbb:
            //current slider ref -- DACDATH update here.
            dead_time_right = data[1];
//            temp = 0.5 + (data[1] * 0.18);
//            temp = ( temp * 4095 )/3.3 ; 
//            current_dac_value = temp;
//            DAC1DATH = temp;
                PG1DTH = data[1];   // set dead time to 150ns
                PG1DTL = data[1];   // set dead time to 150ns
 
                PG3DTH = data[1];   // set dead time to 150ns
                PG3DTL = data[1];   // set dead time to 150ns
//                PG2DTH = 0;     // no dead time on PWMxH
//                PG2DTL = 1000;  // set dead time to 250ns
//                PG3DTH = data[1];   // set dead time to 150ns
//                PG3DTL = data[1];   // set dead time to 150ns
//                PG4DTH = 0;     // no dead time on PWMxH
//                PG4DTL = 1000;  // set dead time to 250ns
                PG1STATbits.UPDREQ = 1; // Set manual update (can be automated later)
 
            break;
            
        case 0xcc:
            //voltage_ref = data[1];
            //PwrCtrl_SetVSecReference(voltage_ref);
            current_ref = data[1];
            PwrCtrl_SetIReference(current_ref);
            break;
 
        case 0xee:
            voltage_ref = data[1];
            float vreftemp;
            if (psfb_ptr->VoutCalibrate.gain_factor>0){
                 vreftemp = (float)voltage_ref / psfb_ptr->VoutCalibrate.gain_factor;
            } 
            else{  
                 vreftemp = (float)voltage_ref * 1;
            }
            //if (abs(vreftemp - voltage_ref)>372) vreftemp = (float)voltage_ref; // if difference is greater than 0.3 v
            
            PwrCtrl_SetVSecReference((uint16_t)vreftemp);
            psfb_ptr->Droop.Droop_Voltage_Reference_from_PBV = (uint16_t)vreftemp;
            break;
        
        case 0xdd:
            //current slider ref -- DACDATH update here.
//            temp = data[1];
//            current_slider_ref = temp;
            DAC3DATH = data[1];
            break;
        
        default:
            break;
    }
}
 
void App_PBV_psfb_Frame_Parser(uint16_t protocol_ID, uint16_t length, uint8_t * data){
    PBV_Change_from_Eight_to_Sixteen(data, buffer_sixteen_rx, length);
    switch (protocol_ID){
        case PBV_GUI_BUTTONS:
            App_PBV_psfb_Process_Buttons(buffer_sixteen_rx);
            break;
        case PBV_GUI_SLIDERS:
            App_PBV_psfb_Process_Sliders(buffer_sixteen_rx);
            break;
    }
}