pwrctrl_dcdt.c

Go to the documentation of this file.

 
#include <xc.h>
 
#include "pwrctrl_dcdt.h"
 
 
 
SMPS_2P2Z_T VMC_2p2z;
 
SMPS_2P2Z_T IMC_2p2z;
 
SMPS_2P2Z_T PMC_2p2z; 
 
//==============================================================================
//==============================================================================
 
 
SMPS_2P2Z_T VMC_2p2z_Rev;
 
SMPS_2P2Z_T IMC_2p2z_Rev;
 
SMPS_2P2Z_T PMC_2p2z_Rev; 
 
//==============================================================================
//==============================================================================
 
 
 
int16_t   VMC_2p2zACoefficients[2]__attribute__((space(xmemory)));
 
int16_t   VMC_2p2zBCoefficients[3] __attribute__((space(xmemory)));
 
int16_t   VMC_2p2zControlHistory[2] __attribute__((space(ymemory), far));
 
int16_t   VMC_2p2zErrorHistory[3] __attribute__((space(ymemory), far));
 
//==============================================================================
 
int16_t   IMC_2p2zACoefficients[2]__attribute__((space(xmemory)));
 
int16_t   IMC_2p2zBCoefficients[3] __attribute__((space(xmemory)));
 
int16_t   IMC_2p2zControlHistory[2] __attribute__((space(ymemory), far));
 
int16_t   IMC_2p2zErrorHistory[3] __attribute__((space(ymemory), far));
 
//==============================================================================
 
int16_t   PMC_2p2zACoefficients[2]__attribute__((space(xmemory)));
 
int16_t   PMC_2p2zBCoefficients[3] __attribute__((space(xmemory)));
 
int16_t   PMC_2p2zControlHistory[2] __attribute__((space(ymemory), far));
 
int16_t   PMC_2p2zErrorHistory[3] __attribute__((space(ymemory), far));
 
 
//==============================================================================
//==============================================================================
 
 
int16_t   VMC_2p2zACoefficients_Rev[2]__attribute__((space(xmemory)));
 
int16_t   VMC_2p2zBCoefficients_Rev[3] __attribute__((space(xmemory)));
 
int16_t   VMC_2p2zControlHistory_Rev[2] __attribute__((space(ymemory), far));
 
int16_t   VMC_2p2zErrorHistory_Rev[3] __attribute__((space(ymemory), far));
 
//==============================================================================
 
int16_t   IMC_2p2zACoefficients_Rev[2]__attribute__((space(xmemory)));
 
int16_t   IMC_2p2zBCoefficients_Rev[3] __attribute__((space(xmemory)));
 
int16_t   IMC_2p2zControlHistory_Rev[2] __attribute__((space(ymemory), far));
 
int16_t   IMC_2p2zErrorHistory_Rev[3] __attribute__((space(ymemory), far));
 
//==============================================================================
 
int16_t   PMC_2p2zACoefficients_Rev[2]__attribute__((space(xmemory)));
 
int16_t   PMC_2p2zBCoefficients_Rev[3] __attribute__((space(xmemory)));
 
int16_t   PMC_2p2zControlHistory_Rev[2] __attribute__((space(ymemory), far));
 
int16_t   PMC_2p2zErrorHistory_Rev[3] __attribute__((space(ymemory), far));
 
 
 
void PwrCtrl_VComp_Initialize(void)
{
  //charger direction, PSVO,   Primary to Secondary V Out loop  
  VMC_2p2z.aCoefficients =  &VMC_2p2zACoefficients[0]; // Set up pointer to derived coefficients
  VMC_2p2z.bCoefficients =  &VMC_2p2zBCoefficients[0]; // Set up pointer to derived coefficients
  VMC_2p2z.controlHistory = &VMC_2p2zControlHistory[0]; // Set up pointer to controller history
  VMC_2p2z.errorHistory =   &VMC_2p2zErrorHistory[0]; // Set up pointer to error history
 
  VMC_2p2z.preShift =   DAB_PSVO_COMP_2P2Z_PRESHIFT;  
  VMC_2p2z.postScaler = DAB_PSVO_COMP_2P2Z_POSTSCALER;
  VMC_2p2z.postShift =  DAB_PSVO_COMP_2P2Z_POSTSHIFT;
  VMC_2p2z.minOutput =  DAB_PSVO_COMP_2P2Z_MIN_CLAMP;
  VMC_2p2z.maxOutput =  DAB_PSVO_COMP_2P2Z_MAX_CLAMP; 
  
  VMC_2p2zACoefficients[0] = DAB_PSVO_COMP_2P2Z_COEFF_A1;
  VMC_2p2zACoefficients[1] = DAB_PSVO_COMP_2P2Z_COEFF_A2;
  VMC_2p2zBCoefficients[0] = DAB_PSVO_COMP_2P2Z_COEFF_B0;
  VMC_2p2zBCoefficients[1] = DAB_PSVO_COMP_2P2Z_COEFF_B1;
  VMC_2p2zBCoefficients[2] = DAB_PSVO_COMP_2P2Z_COEFF_B2; 
  
   //explicit clear to 0
  VMC_2p2zControlHistory[0] = 0;
  VMC_2p2zControlHistory[1] = 0;
  VMC_2p2zErrorHistory[0] = 0;
  VMC_2p2zErrorHistory[1] = 0;
  VMC_2p2zErrorHistory[2] = 0;
   
  SMPS_Controller2P2ZInitialize(&VMC_2p2z);  
  
    //discharger direction, SPVO,   Secondary to Primary V Out loop
  VMC_2p2z_Rev.aCoefficients =  &VMC_2p2zACoefficients_Rev[0]; // Set up pointer to derived coefficients
  VMC_2p2z_Rev.bCoefficients =  &VMC_2p2zBCoefficients_Rev[0]; // Set up pointer to derived coefficients
  VMC_2p2z_Rev.controlHistory = &VMC_2p2zControlHistory_Rev[0]; // Set up pointer to controller history
  VMC_2p2z_Rev.errorHistory =   &VMC_2p2zErrorHistory_Rev[0]; // Set up pointer to error history
 
  VMC_2p2z_Rev.preShift =   DAB_SPVO_COMP_2P2Z_PRESHIFT;  
  VMC_2p2z_Rev.postScaler = DAB_SPVO_COMP_2P2Z_POSTSCALER;
  VMC_2p2z_Rev.postShift =  DAB_SPVO_COMP_2P2Z_POSTSHIFT;
  VMC_2p2z_Rev.minOutput =  DAB_SPVO_COMP_2P2Z_MIN_CLAMP;
  VMC_2p2z_Rev.maxOutput =  DAB_SPVO_COMP_2P2Z_MAX_CLAMP; 
  
  VMC_2p2zACoefficients_Rev[0] = DAB_SPVO_COMP_2P2Z_COEFF_A1;
  VMC_2p2zACoefficients_Rev[1] = DAB_SPVO_COMP_2P2Z_COEFF_A2;
  VMC_2p2zBCoefficients_Rev[0] = DAB_SPVO_COMP_2P2Z_COEFF_B0;
  VMC_2p2zBCoefficients_Rev[1] = DAB_SPVO_COMP_2P2Z_COEFF_B1;
  VMC_2p2zBCoefficients_Rev[2] = DAB_SPVO_COMP_2P2Z_COEFF_B2; 
  
   //explicit clear to 0
  VMC_2p2zControlHistory_Rev[0] = 0;
  VMC_2p2zControlHistory_Rev[1] = 0;
  VMC_2p2zErrorHistory_Rev[0] = 0;
  VMC_2p2zErrorHistory_Rev[1] = 0;
  VMC_2p2zErrorHistory_Rev[2] = 0;
   
  SMPS_Controller2P2ZInitialize(&VMC_2p2z_Rev);  
  
}
 
 
void PwrCtrl_IComp_Initialize(void)
{
   //charger, PSIO,   Primary to Secondary I Out loop
   IMC_2p2z.aCoefficients =  &IMC_2p2zACoefficients[0]; // Set up pointer to derived coefficients
   IMC_2p2z.bCoefficients =  &IMC_2p2zBCoefficients[0]; // Set up pointer to derived coefficients
   IMC_2p2z.controlHistory = &IMC_2p2zControlHistory[0]; // Set up pointer to controller history
   IMC_2p2z.errorHistory =   &IMC_2p2zErrorHistory[0]; // Set up pointer to error history
 
   IMC_2p2z.preShift =   DAB_PSIO_COMP_2P2Z_PRESHIFT;
   IMC_2p2z.postScaler = DAB_PSIO_COMP_2P2Z_POSTSCALER;
   IMC_2p2z.postShift =  DAB_PSIO_COMP_2P2Z_POSTSHIFT;
   IMC_2p2z.minOutput =  DAB_PSIO_COMP_2P2Z_MIN_CLAMP;
   IMC_2p2z.maxOutput =  DAB_PSIO_COMP_2P2Z_MAX_CLAMP;
   
   
   IMC_2p2zACoefficients[0] = DAB_PSIO_COMP_2P2Z_COEFF_A1;
   IMC_2p2zACoefficients[1] = DAB_PSIO_COMP_2P2Z_COEFF_A2;
   IMC_2p2zBCoefficients[0] = DAB_PSIO_COMP_2P2Z_COEFF_B0;
   IMC_2p2zBCoefficients[1] = DAB_PSIO_COMP_2P2Z_COEFF_B1;
   IMC_2p2zBCoefficients[2] = DAB_PSIO_COMP_2P2Z_COEFF_B2;
  
  //explicit clear to 0
   IMC_2p2zControlHistory[0] =0;
   IMC_2p2zControlHistory[1] =0;
   IMC_2p2zErrorHistory[0] =0;
   IMC_2p2zErrorHistory[1] =0;
   IMC_2p2zErrorHistory[2] =0;
   
   SMPS_Controller2P2ZInitialize(&IMC_2p2z);
   
   //discharger, SPIO,   Secondary to Primary I Out loop
   IMC_2p2z_Rev.aCoefficients =  &IMC_2p2zACoefficients_Rev[0]; // Set up pointer to derived coefficients
   IMC_2p2z_Rev.bCoefficients =  &IMC_2p2zBCoefficients_Rev[0]; // Set up pointer to derived coefficients
   IMC_2p2z_Rev.controlHistory = &IMC_2p2zControlHistory_Rev[0]; // Set up pointer to controller history
   IMC_2p2z_Rev.errorHistory =   &IMC_2p2zErrorHistory_Rev[0]; // Set up pointer to error history
 
   IMC_2p2z_Rev.preShift =   DAB_SPIO_COMP_2P2Z_PRESHIFT;//SPIO TBD
   IMC_2p2z_Rev.postScaler = DAB_SPIO_COMP_2P2Z_POSTSCALER;
   IMC_2p2z_Rev.postShift =  DAB_SPIO_COMP_2P2Z_POSTSHIFT;
   IMC_2p2z_Rev.minOutput =  DAB_SPIO_COMP_2P2Z_MIN_CLAMP;
   IMC_2p2z_Rev.maxOutput =  DAB_SPIO_COMP_2P2Z_MAX_CLAMP;
   
   
   IMC_2p2zACoefficients_Rev[0] = DAB_SPIO_COMP_2P2Z_COEFF_A1;
   IMC_2p2zACoefficients_Rev[1] = DAB_SPIO_COMP_2P2Z_COEFF_A2;
   IMC_2p2zBCoefficients_Rev[0] = DAB_SPIO_COMP_2P2Z_COEFF_B0;
   IMC_2p2zBCoefficients_Rev[1] = DAB_SPIO_COMP_2P2Z_COEFF_B1;
   IMC_2p2zBCoefficients_Rev[2] = DAB_SPIO_COMP_2P2Z_COEFF_B2;
  
  //explicit clear to 0
   IMC_2p2zControlHistory_Rev[0] =0;
   IMC_2p2zControlHistory_Rev[1] =0;
   IMC_2p2zErrorHistory_Rev[0] =0;
   IMC_2p2zErrorHistory_Rev[1] =0;
   IMC_2p2zErrorHistory_Rev[2] =0;
   
   SMPS_Controller2P2ZInitialize(&IMC_2p2z_Rev);
}
 
 
void PwrCtrl_PComp_Initialize(void)  //only battery has power sense option. should be bidirectional
{
    //charger, PSPO,   Primary to Secondary Power Out loop
   PMC_2p2z.aCoefficients =  &PMC_2p2zACoefficients[0]; // Set up pointer to derived coefficients
   PMC_2p2z.bCoefficients =  &PMC_2p2zBCoefficients[0]; // Set up pointer to derived coefficients
   PMC_2p2z.controlHistory = &PMC_2p2zControlHistory[0]; // Set up pointer to controller history
   PMC_2p2z.errorHistory =   &PMC_2p2zErrorHistory[0]; // Set up pointer to error history
 
   PMC_2p2z.preShift =   DAB_PSPO_COMP_2P2Z_PRESHIFT;
   PMC_2p2z.postScaler = DAB_PSPO_COMP_2P2Z_POSTSCALER;
   PMC_2p2z.postShift =  DAB_PSPO_COMP_2P2Z_POSTSHIFT;
   PMC_2p2z.minOutput =  DAB_PSPO_COMP_2P2Z_MIN_CLAMP;
   PMC_2p2z.maxOutput =  DAB_PSPO_COMP_2P2Z_MAX_CLAMP; 
   
   PMC_2p2zACoefficients[0] = DAB_PSPO_COMP_2P2Z_COEFF_A1;
   PMC_2p2zACoefficients[1] = DAB_PSPO_COMP_2P2Z_COEFF_A2;
   PMC_2p2zBCoefficients[0] = DAB_PSPO_COMP_2P2Z_COEFF_B0;
   PMC_2p2zBCoefficients[1] = DAB_PSPO_COMP_2P2Z_COEFF_B1;
   PMC_2p2zBCoefficients[2] = DAB_PSPO_COMP_2P2Z_COEFF_B2;
  
    //explicit clear to 0
   PMC_2p2zControlHistory[0] =0;
   PMC_2p2zControlHistory[1] =0;
   PMC_2p2zErrorHistory[0] =0;
   PMC_2p2zErrorHistory[1] =0;
   PMC_2p2zErrorHistory[2] =0;
   
   SMPS_Controller2P2ZInitialize(&PMC_2p2z);  
   
   
   //discharger, SPPO,   Primary to Secondary Power Out loop
   PMC_2p2z_Rev.aCoefficients =  &PMC_2p2zACoefficients_Rev[0]; // Set up pointer to derived coefficients
   PMC_2p2z_Rev.bCoefficients =  &PMC_2p2zBCoefficients_Rev[0]; // Set up pointer to derived coefficients
   PMC_2p2z_Rev.controlHistory = &PMC_2p2zControlHistory_Rev[0]; // Set up pointer to controller history
   PMC_2p2z_Rev.errorHistory =   &PMC_2p2zErrorHistory_Rev[0]; // Set up pointer to error history
 
   PMC_2p2z_Rev.preShift =   DAB_SPPO_COMP_2P2Z_PRESHIFT;
   PMC_2p2z_Rev.postScaler = DAB_SPPO_COMP_2P2Z_POSTSCALER;
   PMC_2p2z_Rev.postShift =  DAB_SPPO_COMP_2P2Z_POSTSHIFT;
   PMC_2p2z_Rev.minOutput =  DAB_SPPO_COMP_2P2Z_MIN_CLAMP;
   PMC_2p2z_Rev.maxOutput =  DAB_SPPO_COMP_2P2Z_MAX_CLAMP; 
   
   PMC_2p2zACoefficients_Rev[0] = DAB_SPPO_COMP_2P2Z_COEFF_A1;
   PMC_2p2zACoefficients_Rev[1] = DAB_SPPO_COMP_2P2Z_COEFF_A2;
   PMC_2p2zBCoefficients_Rev[0] = DAB_SPPO_COMP_2P2Z_COEFF_B0;
   PMC_2p2zBCoefficients_Rev[1] = DAB_SPPO_COMP_2P2Z_COEFF_B1;
   PMC_2p2zBCoefficients_Rev[2] = DAB_SPPO_COMP_2P2Z_COEFF_B2;
  
    //explicit clear to 0
   PMC_2p2zControlHistory_Rev[0] =0;
   PMC_2p2zControlHistory_Rev[1] =0;
   PMC_2p2zErrorHistory_Rev[0] =0;
   PMC_2p2zErrorHistory_Rev[1] =0;
   PMC_2p2zErrorHistory_Rev[2] =0;
   
   SMPS_Controller2P2ZInitialize(&PMC_2p2z_Rev);  
   
}
 
 
void PwrCtrl_ResetControlLoopHistories(void)
{
  //explicit clear to 0
  VMC_2p2zControlHistory[0] = 0;
  VMC_2p2zControlHistory[1] = 0;
  VMC_2p2zErrorHistory[0] = 0;
  VMC_2p2zErrorHistory[1] = 0;
  VMC_2p2zErrorHistory[2] = 0;
  
   //explicit clear to 0
   IMC_2p2zControlHistory[0] = 0;
   IMC_2p2zControlHistory[1] = 0;
   IMC_2p2zErrorHistory[0] = 0;
   IMC_2p2zErrorHistory[1] = 0;
   IMC_2p2zErrorHistory[2] = 0;
   
   //explicit clear to 0
   PMC_2p2zControlHistory[0] = 0;
   PMC_2p2zControlHistory[1] = 0;
   PMC_2p2zErrorHistory[0] = 0;
   PMC_2p2zErrorHistory[1] = 0;
   PMC_2p2zErrorHistory[2] = 0;
   
     //explicit clear to 0
  VMC_2p2zControlHistory_Rev[0] = 0;
  VMC_2p2zControlHistory_Rev[1] = 0;
  VMC_2p2zErrorHistory_Rev[0] = 0;
  VMC_2p2zErrorHistory_Rev[1] = 0;
  VMC_2p2zErrorHistory_Rev[2] = 0;
  
   //explicit clear to 0
   IMC_2p2zControlHistory_Rev[0] = 0;
   IMC_2p2zControlHistory_Rev[1] = 0;
   IMC_2p2zErrorHistory_Rev[0] = 0;
   IMC_2p2zErrorHistory_Rev[1] = 0;
   IMC_2p2zErrorHistory_Rev[2] = 0;
   
   //explicit clear to 0
   PMC_2p2zControlHistory_Rev[0] = 0;
   PMC_2p2zControlHistory_Rev[1] = 0;
   PMC_2p2zErrorHistory_Rev[0] = 0;
   PMC_2p2zErrorHistory_Rev[1] = 0;
   PMC_2p2zErrorHistory_Rev[2] = 0;
   
}