drv8301kit_revD/f28x/f2806x/src/float/hal.h

Go to the documentation of this file.

#ifndef _HAL_H_
#define _HAL_H_
/* --COPYRIGHT--,BSD
 * Copyright (c) 2012, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --/COPYRIGHT--*/



// **************************************************************************
// the includes


// platforms
#include "sw/modules/math/src/float/math.h"
#include "hal_obj.h"




#ifdef __cplusplus
extern "C" {
#endif


// **************************************************************************
// the defines

#define DRV8301_SPI

#define Device_cal (void   (*)(void))0x3D7C80


#define FP_SCALE 32768

#define FP_ROUND FP_SCALE/2

#define OSC_POSTRIM 32
#define OSC_POSTRIM_OFF FP_SCALE*OSC_POSTRIM



#define getOsc1FineTrimSlope() (*(int16_t (*)(void))0x3D7E90)()

#define getOsc1FineTrimOffset() (*(int16_t (*)(void))0x3D7E93)()

#define getOsc1CoarseTrim() (*(int16_t (*)(void))0x3D7E96)()

#define getOsc2FineTrimSlope() (*(int16_t (*)(void))0x3D7E99)()

#define getOsc2FineTrimOffset() (*(int16_t (*)(void))0x3D7E9C)()

#define getOsc2CoarseTrim() (*(int16_t (*)(void))0x3D7E9F)()

#define getRefTempOffset() (*(int16_t (*)(void))0x3D7EA2)()


#define HAL_PWM_DBFED_CNT         (uint16_t)(0.050 * (float_t)USER_SYSTEM_FREQ_MHz)            // 50 ns


#define HAL_PWM_DBRED_CNT        (uint16_t)(0.050 * (float_t)USER_SYSTEM_FREQ_MHz)            // 50 ns


#define HAL_readSW                HAL_readGpio


#define HAL_turnLedOff            HAL_setGpioLow


#define HAL_turnLedOn             HAL_setGpioHigh


#define HAL_toggleLed             HAL_toggleGpio


// **************************************************************************
// the typedefs


typedef enum
{
  HAL_Gpio_LED2=GPIO_Number_31,  
  HAL_Gpio_LED3=GPIO_Number_34   
} HAL_LedNumber_e;


typedef enum
{
  HAL_Gpio_SW1=GPIO_Number_9,  
  HAL_Gpio_SW2=GPIO_Number_7   
} HAL_SwNumber_e;


typedef enum
{
  HAL_PwmFreq_2_kHz = 22500,  
  HAL_PwmFreq_3_kHz = 15000,  
  HAL_PwmFreq_4_kHz = 11250,  
  HAL_PwmFreq_5_kHz =  9000,  
  HAL_PwmFreq_6_kHz =  7500,  
  HAL_PwmFreq_8_kHz =  5625,  
  HAL_PwmFreq_9_kHz =  5000,  
  HAL_PwmFreq_10_kHz = 4500,  
  HAL_PwmFreq_12_kHz = 3750,  
  HAL_PwmFreq_15_kHz = 3000,  
  HAL_PwmFreq_18_kHz = 2500,  
  HAL_PwmFreq_20_kHz = 2250,  
  HAL_PwmFreq_24_kHz = 1875,  
  HAL_PwmFreq_25_kHz = 1800,  
  HAL_PwmFreq_30_kHz = 1500,  
  HAL_PwmFreq_36_kHz = 1250,  
  HAL_PwmFreq_40_kHz = 1125,  
  HAL_PwmFreq_45_kHz = 1000,  
  HAL_PwmFreq_50_kHz =  900,  
  HAL_PwmFreq_60_kHz =  750,  
  HAL_PwmFreq_75_kHz =  600,  
  HAL_PwmFreq_90_kHz =  500,  
  HAL_PwmFreq_100_kHz = 450,  
  HAL_PwmFreq_120_kHz = 375,  
  HAL_PwmFreq_125_kHz = 360,  
  HAL_PwmFreq_150_kHz = 300   
} HAL_PwmFreq_e;


typedef enum
{
  HAL_SensorType_Current=0,      
  HAL_SensorType_Voltage         
} HAL_SensorType_e;


// **************************************************************************
// the globals

extern interrupt void led2ISR(void);
extern interrupt void led3OffISR(void);
extern interrupt void led3OnISR(void);
extern interrupt void mainISR(void);


// **************************************************************************
// the function prototypes

extern void HAL_AdcCalChanSelect(HAL_Handle handle, const ADC_SocChanNumber_e chanNumber);


extern uint16_t HAL_AdcCalConversion(HAL_Handle handle);


extern void HAL_AdcOffsetSelfCal(HAL_Handle handle);



static inline void HAL_acqAdcInt(HAL_Handle handle,const ADC_IntNumber_e intNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;


  // clear the ADC interrupt flag
  ADC_clearIntFlag(obj->adcHandle,intNumber);


  // Acknowledge interrupt from PIE group 10 
  PIE_clearInt(obj->pieHandle,PIE_GroupNumber_10);

  return;
} // end of HAL_acqAdcInt() function


static inline void HAL_acqPwmInt(HAL_Handle handle,const PWM_Number_e pwmNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;


  // clear the PWM interrupt flag
  PWM_clearIntFlag(obj->pwmHandle[pwmNumber]);


  // clear the SOCA flag
  PWM_clearSocAFlag(obj->pwmHandle[pwmNumber]);


  // Acknowledge interrupt from PIE group 3
  PIE_clearInt(obj->pieHandle,PIE_GroupNumber_3);

  return;
} // end of HAL_acqPwmInt() function


extern void HAL_cal(HAL_Handle handle);


extern void HAL_disableGlobalInts(HAL_Handle handle);


static inline void HAL_disablePwm(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  PWM_setOneShotTrip(obj->pwmHandle[PWM_Number_1]);
  PWM_setOneShotTrip(obj->pwmHandle[PWM_Number_2]);
  PWM_setOneShotTrip(obj->pwmHandle[PWM_Number_3]);

  return;
} // end of HAL_disablePwm() function


static inline void HAL_disableTbClockSync(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  CLK_disableTbClockSync(obj->clkHandle);

  return;
} // end of HAL_disableTbClockSync() function


extern void HAL_enableAdcInts(HAL_Handle handle);


extern void HAL_enableDebugInt(HAL_Handle handle);


extern void HAL_enableGlobalInts(HAL_Handle handle);


extern void HAL_enableDrv(HAL_Handle handle);


static inline void HAL_enablePwm(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  PWM_clearOneShotTrip(obj->pwmHandle[PWM_Number_1]);
  PWM_clearOneShotTrip(obj->pwmHandle[PWM_Number_2]);
  PWM_clearOneShotTrip(obj->pwmHandle[PWM_Number_3]);

  return;
} // end of HAL_enablePwm() function


extern void HAL_enablePwmInt(HAL_Handle handle);


static inline void HAL_enableTbClockSync(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  CLK_enableTbClockSync(obj->clkHandle);

  return;
} // end of HAL_enableTbClockSync() function


static inline ADC_SocSampleDelay_e HAL_getAdcSocSampleDelay(HAL_Handle handle,
                                                            const ADC_SocNumber_e socNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  return(ADC_getSocSampleDelay(obj->adcHandle,socNumber));
} // end of HAL_getAdcSocSampleDelay() function


static inline float_t HAL_getBias(HAL_Handle handle,
                                  const HAL_SensorType_e sensorType,
                                  uint_least8_t sensorNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  float_t bias = 0.0;

  if(sensorType == HAL_SensorType_Current)
    {
      bias = obj->adcBias.I_A.value[sensorNumber];
    }
  else if(sensorType == HAL_SensorType_Voltage)
    {
      bias = obj->adcBias.V_V.value[sensorNumber];
    }

  return(bias);
} // end of HAL_getBias() function


static inline float_t HAL_getCurrentScaleFactor(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  return(obj->current_sf);
} // end of HAL_getCurrentScaleFactor() function


static inline void HAL_getDutyCycles(HAL_Handle handle,uint16_t *pDutyCycles)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  pDutyCycles[0] = PWM_get_CmpA(obj->pwmHandle[PWM_Number_1]);
  pDutyCycles[1] = PWM_get_CmpA(obj->pwmHandle[PWM_Number_2]);
  pDutyCycles[2] = PWM_get_CmpA(obj->pwmHandle[PWM_Number_3]);

  return;
} // end of HAL_getDutyCycles() function


static inline uint_least8_t HAL_getNumCurrentSensors(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  return(obj->numCurrentSensors);
} // end of HAL_getNumCurrentSensors() function


static inline uint_least8_t HAL_getNumVoltageSensors(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  return(obj->numVoltageSensors);
} // end of HAL_getNumVoltageSensors() function


static inline float_t HAL_getVoltageScaleFactor(HAL_Handle handle)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  return(obj->voltage_sf);
} // end of HAL_getVoltageScaleFactor() function


extern void HAL_setupFaults(HAL_Handle handle);


extern HAL_Handle HAL_init(void *pMemory,const size_t numBytes);


extern void HAL_OscTempComp(HAL_Handle handle);


extern void HAL_osc1Comp(HAL_Handle handle, const int16_t sensorSample);


extern void HAL_osc2Comp(HAL_Handle handle, const int16_t sensorSample);


extern uint16_t HAL_computeOscTrimValue(int16_t coarse, int16_t fine);


static inline void HAL_initIntVectorTable(HAL_Handle handle)
 {
  HAL_Obj *obj = (HAL_Obj *)handle;
  PIE_Obj *pie = (PIE_Obj *)obj->pieHandle;


  ENABLE_PROTECTED_REGISTER_WRITE_MODE;

//  pie->EPWM1_INT = &led2ISR;
//  pie->ADCINT1 = &led3OffISR;
//  pie->ADCINT2 = &led3OnISR;
  pie->ADCINT6 = &mainISR;

  DISABLE_PROTECTED_REGISTER_WRITE_MODE;

  return;
 } // end of HAL_initIntVectorTable() function


static inline void HAL_readAdcData(HAL_Handle handle,HAL_AdcData_t *pAdcData)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  float_t value;
  float_t current_sf = HAL_getCurrentScaleFactor(handle);
  float_t voltage_sf = HAL_getVoltageScaleFactor(handle);


  // convert phase A current
  // sample the first sample twice due to errata sprz342f, ignore the first sample
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_1);
  value = value * current_sf - obj->adcBias.I_A.value[0];
  pAdcData->I_A.value[0] = value;

  // convert phase B current
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_2);
  value = value * current_sf - obj->adcBias.I_A.value[1];
  pAdcData->I_A.value[1] = value;

  // convert phase C current
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_3);
  value = value * current_sf - obj->adcBias.I_A.value[2];
  pAdcData->I_A.value[2] = value;

  // convert phase A voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_4);
  value = value * voltage_sf - obj->adcBias.V_V.value[0];
  pAdcData->V_V.value[0] = value;

  // convert phase B voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_5);
  value = value * voltage_sf - obj->adcBias.V_V.value[1];
  pAdcData->V_V.value[1] = value;

  // convert phase C voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_6);
  value = value * voltage_sf - obj->adcBias.V_V.value[2];
  pAdcData->V_V.value[2] = value;

  // convert dcBus voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_7);
  value = value * voltage_sf;
  pAdcData->dcBus_V = value;

  return;
} // end of HAL_readAdcData() function


static inline void HAL_readAdcDataWithOffsets(HAL_Handle handle,HAL_AdcData_t *pAdcData)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  float_t value;
  float_t current_sf = HAL_getCurrentScaleFactor(handle);
  float_t voltage_sf = HAL_getVoltageScaleFactor(handle);


  // convert phase A current
  // sample the first sample twice due to errata sprz342f, ignore the first sample
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_1);
  pAdcData->I_A.value[0] = value * current_sf;

  // convert phase B current
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_2);
  pAdcData->I_A.value[1] = value * current_sf;

  // convert phase C current
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_3);
  pAdcData->I_A.value[2] = value * current_sf;

  // convert phase A voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_4);
  pAdcData->V_V.value[0] = value * voltage_sf;

  // convert phase B voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_5);
  pAdcData->V_V.value[1] = value * voltage_sf;

  // convert phase C voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_6);
  pAdcData->V_V.value[2] = value * voltage_sf;

  // convert dcBus voltage
  value = (float_t)ADC_readResult(obj->adcHandle,ADC_ResultNumber_7);
  pAdcData->dcBus_V = value * voltage_sf;

  return;
} // end of HAL_readAdcDataWithOffsets() function


static inline bool HAL_readGpio(HAL_Handle handle, const GPIO_Number_e gpioNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  bool result = false;

  result = GPIO_read(obj->gpioHandle, gpioNumber);

  return result;
} // end of HAL_readGpio() function


static inline uint32_t HAL_readTimerCnt(HAL_Handle handle,const uint_least8_t timerNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  uint32_t timerCnt = TIMER_getCount(obj->timerHandle[timerNumber]);

  return(timerCnt);
} // end of HAL_readTimerCnt() function


static inline void HAL_resetPwmCount(HAL_Handle handle,
                                     PWM_Number_e pwmNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  PWM_setCount(obj->pwmHandle[pwmNumber],0);

  return;
} // HAL_resetPwmCount() function


static inline void HAL_setAdcSocSampleDelay(HAL_Handle handle,
                                            const ADC_SocNumber_e socNumber,
                                            const ADC_SocSampleDelay_e sampleDelay)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  ADC_setSocSampleDelay(obj->adcHandle,socNumber,sampleDelay);

  return;
} // end of HAL_setAdcSocSampleDelay() function


static inline void HAL_setBias(HAL_Handle handle,
                               const HAL_SensorType_e sensorType,
                               uint_least8_t sensorNumber,
                               const float_t bias)
{
  HAL_Obj *obj = (HAL_Obj *)handle;


  if(sensorType == HAL_SensorType_Current)
    {
      obj->adcBias.I_A.value[sensorNumber] = bias;
    }
  else if(sensorType == HAL_SensorType_Voltage)
    {
      obj->adcBias.V_V.value[sensorNumber] = bias;
    }

  return;
} // end of HAL_setBias() function


static inline void HAL_setCurrentScaleFactor(HAL_Handle handle,const float_t current_sf)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  obj->current_sf = current_sf;

  return;
} // end of HAL_setCurrentScaleFactor() function


static inline void HAL_setGpioHigh(HAL_Handle handle,const GPIO_Number_e gpioNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  // set GPIO high
  GPIO_setHigh(obj->gpioHandle,gpioNumber);

  return;
} // end of HAL_setGpioHigh() function


static inline void HAL_setGpioLow(HAL_Handle handle,const GPIO_Number_e gpioNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  // set GPIO low
  GPIO_setLow(obj->gpioHandle,gpioNumber);

  return;
} // end of HAL_setGpioLow() function


static inline void HAL_setNumCurrentSensors(HAL_Handle handle,const uint_least8_t numCurrentSensors)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  obj->numCurrentSensors = numCurrentSensors;

  return;
} // end of HAL_setNumCurrentSensors() function


static inline void HAL_setNumVoltageSensors(HAL_Handle handle,const uint_least8_t numVoltageSensors)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  

  obj->numVoltageSensors = numVoltageSensors;

  return;
} // end of HAL_setNumVoltageSensors() function


static inline void HAL_setPwmFreq_kHz(HAL_Handle handle,
                                      PWM_Number_e pwmNumber,
                                      HAL_PwmFreq_e pwmFreq_kHz)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  PWM_setPeriod(obj->pwmHandle[pwmNumber],pwmFreq_kHz);

  return;
} // HAL_setPwmFreq_Hz() function


static inline void HAL_setVoltageScaleFactor(HAL_Handle handle,const float_t voltage_sf)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  
  obj->voltage_sf = voltage_sf;

  return;
} // end of HAL_setVoltageScaleFactor() function


extern void HAL_setParams(HAL_Handle handle,const USER_Params *pUserParams);


extern void HAL_setupAdcs(HAL_Handle handle);


extern void HAL_setupClks(HAL_Handle handle);


extern void HAL_setupFaults(HAL_Handle handle);


void HAL_setupGate(HAL_Handle handle);


extern void HAL_setupGpios(HAL_Handle handle);


extern void HAL_setupFlash(HAL_Handle handle);


extern void HAL_setupPeripheralClks(HAL_Handle handle);


extern void HAL_setupPie(HAL_Handle handle);


extern void HAL_setupPll(HAL_Handle handle,const PLL_ClkFreq_e clkFreq);


extern void HAL_setupPwms(HAL_Handle handle,
                          const float_t systemFreq_MHz,
                          const float_t pwmPeriod_usec,
                          const uint_least16_t numPwmTicksPerIsrTick);


extern void HAL_setupPwmDacs(HAL_Handle handle,
                             const float_t systemFreq_MHz,
                             const float_t dacFreq_kHz);


void HAL_setupQEP(QEP_Handle qepHandle,const USER_Params *pUserParams,const uint32_t unitTimerFreq_Hz);


extern void HAL_setupSpiA(HAL_Handle handle);


extern void HAL_setupSpiB(HAL_Handle handle);


void HAL_setupTimers(HAL_Handle handle,const float_t systemFreq_MHz);


static inline void HAL_toggleGpio(HAL_Handle handle,const GPIO_Number_e gpioNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;


  // toggle the GPIO
  GPIO_toggle(obj->gpioHandle,gpioNumber);

  return;
} // end of HAL_toggleGpio() function


static inline void HAL_updateAdcBias(HAL_Handle handle,
                                     OFFSET_Handle *pOffsetHandle_I,
                                     OFFSET_Handle *pOffsetHandle_V)
{
  uint_least8_t cnt;


  // update the current bias
  for(cnt=0;cnt<HAL_getNumCurrentSensors(handle);cnt++)
    {
      float_t bias = HAL_getBias(handle,HAL_SensorType_Current,cnt);
      
      bias += OFFSET_getOffset(pOffsetHandle_I[cnt]);

      HAL_setBias(handle,HAL_SensorType_Current,cnt,bias);
    }


  // update the voltage bias
  for(cnt=0;cnt<HAL_getNumVoltageSensors(handle);cnt++)
    {
      float_t bias = HAL_getBias(handle,HAL_SensorType_Voltage,cnt);

      bias += OFFSET_getOffset(pOffsetHandle_V[cnt]);

      HAL_setBias(handle,HAL_SensorType_Voltage,cnt,bias);
    }

  return;
} // end of HAL_updateAdcBias() function


static inline void HAL_writeDacData(HAL_Handle handle,const HAL_DacData_t *pDacData)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  uint_least8_t pwmCnt;
  uint_least8_t dataCnt=0;

  for(pwmCnt=0;pwmCnt<3;pwmCnt++)
    {
      PWM_Obj *pwm = (PWM_Obj *)obj->pwmDacHandle[pwmCnt];

      // compute the value
      float_t period = (float_t)(pwm->TBPRD);
      float_t V_pu = pDacData->value[dataCnt];
      float_t V_sat_pu = MATH_sat(V_pu,0.5,-0.5);
      float_t V_sat_dc_pu = V_sat_pu + 0.5;
      int16_t pwmValue  = (int16_t)(V_sat_dc_pu * period);

      // increment the data counter
      dataCnt++;

      // write the PWM data value
      PWM_write_CmpA(obj->pwmDacHandle[pwmCnt],pwmValue);

      if(pwmCnt == 0)
        {
          float_t V_pu = pDacData->value[dataCnt];
          float_t V_sat_pu = MATH_sat(V_pu,0.5,-0.5);
          float_t V_sat_dc_pu = V_sat_pu + 0.5;
          int16_t pwmValue  = (int16_t)(V_sat_dc_pu * period);
          
          // write the PWM data value
          PWM_write_CmpB(obj->pwmDacHandle[pwmCnt],pwmValue);

          // increment the data counter
          dataCnt++;
        }
    }

  return;
} // end of HAL_writeDacData() function


static inline void HAL_writePwmData(HAL_Handle handle,const HAL_PwmData_t *pPwmData)
{
  HAL_Obj *obj = (HAL_Obj *)handle;
  uint_least8_t pwmCnt;

  for(pwmCnt=0;pwmCnt<3;pwmCnt++)
    {
      PWM_Obj *pwm = (PWM_Obj *)obj->pwmHandle[pwmCnt];

      // compute the value
      float_t period = (float_t)(pwm->TBPRD);
      float_t V_pu = -pPwmData->Vabc_pu.value[pwmCnt];
      float_t V_sat_pu = MATH_sat(V_pu,0.5,-0.5);
      float_t V_sat_dc_pu = V_sat_pu + 0.5;
      int16_t pwmValue  = (int16_t)(V_sat_dc_pu * period);

      // write the PWM data value
      PWM_write_CmpA(obj->pwmHandle[pwmCnt],pwmValue);
    }

  return;
} // end of HAL_writePwmData() function

static inline uint16_t HAL_readPwmPeriod(HAL_Handle handle,const PWM_Number_e pwmNumber)
{
  HAL_Obj *obj = (HAL_Obj *)handle;

  // the period value to be returned
  uint16_t pwmPeriodValue;

  pwmPeriodValue = PWM_getPeriod(obj->pwmHandle[pwmNumber]);

  return(pwmPeriodValue);
} // end of HAL_readPwmPeriod() function


void HAL_writeDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars);


void HAL_readDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars);


void HAL_setupDrvSpi(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars);


#ifdef __cplusplus
}
#endif // extern "C"



#endif // end of _HAL_H_ definition