pwm.h

Go to the documentation of this file.

/* --COPYRIGHT--,BSD
 * Copyright (c) 2015, 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--*/
#ifndef _PWM_H_
#define _PWM_H_



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

#include "sw/modules/types/src/types.h"

#include "sw/drivers/cpu/src/32b/f28x/f2806x/cpu.h"





#ifdef __cplusplus
extern "C" {
#endif


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


#define PWM_ePWM1_BASE_ADDR          (0x00006800)

#define PWM_ePWM2_BASE_ADDR          (0x00006840)

#define PWM_ePWM3_BASE_ADDR          (0x00006880)

#define PWM_ePWM4_BASE_ADDR          (0x000068C0)

#define PWM_ePWM5_BASE_ADDR          (0x00006900)

#define PWM_ePWM6_BASE_ADDR          (0x00006940)

#define PWM_ePWM7_BASE_ADDR          (0x00006980)

#define PWM_ePWM8_BASE_ADDR          (0x000069C0)

#define PWM_AQCTL_ZRO_BITS              (3 << 0)

#define PWM_AQCTL_PRD_BITS              (3 << 2)

#define PWM_AQCTL_CAU_BITS              (3 << 4)

#define PWM_AQCTL_CAD_BITS              (3 << 6)

#define PWM_AQCTL_CBU_BITS              (3 << 8)

#define PWM_AQCTL_CBD_BITS              (3 << 10)

#define PWM_AQCSFRC_CSFA_BITS           (3 << 0)

#define PWM_AQCSFRC_CSFB_BITS           (3 << 2)

#define PWM_CMPCTL_LOADAMODE_BITS       (3 << 0)

#define PWM_CMPCTL_LOADBMODE_BITS       (3 << 2)

#define PWM_CMPCTL_SHDWAMODE_BITS       (1 << 4)

#define PWM_CMPCTL_SHDWBMODE_BITS       (1 << 6)

#define PWM_CMPCTL_SHDWAFULL_BITS       (1 << 8)

#define PWM_CMPCTL_SHDWBFULL_BITS       (1 << 9)


#define PWM_DBCTL_OUTMODE_BITS          (3 << 0)

#define PWM_DBCTL_POLSEL_BITS           (3 << 2)

#define PWM_DBCTL_INMODE_BITS           (3 << 4)

#define PWM_DBCTL_HALFCYCLE_BITS        (1 << 15)


#define PWM_ETCLR_INT_BITS              (1 << 0)

#define PWM_ETCLR_SOCA_BITS             (1 << 2)

#define PWM_ETCLR_SOCB_BITS             (1 << 3)


#define PWM_ETPS_INTPRD_BITS            (3 << 0)

#define PWM_ETPS_INTCNT_BITS            (3 << 2)

#define PWM_ETPS_SOCAPRD_BITS           (3 << 8)

#define PWM_ETPS_SOCACNT_BITS           (3 << 10)

#define PWM_ETPS_SOCBPRD_BITS           (3 << 12)

#define PWM_ETPS_SOCBCNT_BITS           (3 << 14)


#define PWM_ETSEL_INTSEL_BITS           (7 << 0)

#define PWM_ETSEL_INTEN_BITS            (1 << 3)

#define PWM_ETSEL_SOCASEL_BITS          (7 << 8)

#define PWM_ETSEL_SOCAEN_BITS           (1 << 11)

#define PWM_ETSEL_SOCBSEL_BITS          (7 << 12)

#define PWM_ETSEL_SOCBEN_BITS           (1 << 15)


#define PWM_PCCTL_CHPEN_BITS            (1 << 0)

#define PWM_PCCTL_OSHTWTH_BITS          (15 << 1)

#define PWM_PCCTL_CHPFREQ_BITS          (7 << 5)

#define PWM_PCCTL_CHPDUTY_BITS          (7 << 8)

#define PWM_HRCNFG_EDGMODE_BITS         (3 << 0)

#define PWM_HRCNFG_CTLMODE_BITS         (1 << 2)

#define PWM_HRCNFG_HRLOAD_BITS          (3 << 3)

#define PWM_HRCNFG_SELOUTB_BITS         (1 << 5)

#define PWM_HRCNFG_AUTOCONV_BITS        (1 << 6)

#define PWM_HRCNFG_SWAPAB_BITS          (1 << 7)

#define PWM_HRPCTL_HRPE_BITS            (1 << 0)

#define PWM_HRPCTL_PWMSYNCSEL_BITS      (1 << 1)

#define PWM_HRPCTL_TBPHSHRLOADE_BITS    (1 << 2)

#define PWM_TBCTL_CTRMODE_BITS          (3 << 0)

#define PWM_TBCTL_PHSEN_BITS            (1 << 2)

#define PWM_TBCTL_PRDLD_BITS            (1 << 3)

#define PWM_TBCTL_SYNCOSEL_BITS         (3 << 4)

#define PWM_TBCTL_SWFSYNC_BITS          (1 << 6)

#define PWM_TBCTL_HSPCLKDIV_BITS        (7 << 7)

#define PWM_TBCTL_CLKDIV_BITS           (7 << 10)

#define PWM_TBCTL_PHSDIR_BITS           (1 << 13)

#define PWM_TBCTL_FREESOFT_BITS         (3 << 14)


#define PWM_TZCLR_INT_BITS              (1 << 0)

#define PWM_TZCLR_CBC_BITS              (1 << 1)

#define PWM_TZCLR_OST_BITS              (1 << 2)

#define PWM_TZCLR_DCAEVT1_BITS          (1 << 3)

#define PWM_TZCLR_DCAEVT2_BITS          (1 << 4)

#define PWM_TZCLR_DCBEVT1_BITS          (1 << 5)

#define PWM_TZCLR_DCBEVT2_BITS          (1 << 6)


#define PWM_TZCTL_TZA_BITS              (3 << 0)

#define PWM_TZCTL_TZB_BITS              (3 << 2)

#define PWM_TZCTL_DCAEVT1_BITS          (3 << 4)

#define PWM_TZCTL_DCAEVT2_BITS          (3 << 6)

#define PWM_TZCTL_DCBEVT1_BITS          (3 << 8)

#define PWM_TZCTL_DCBEVT2_BITS          (3 << 10)


#define PWM_TZFRC_CBC_BITS              (1 << 1)

#define PWM_TZFRC_OST_BITS              (1 << 2)

#define PWM_TZFRC_DCAEVT1_BITS          (1 << 3)

#define PWM_TZFRC_DCAEVT2_BITS          (1 << 4)

#define PWM_TZFRC_DCBEVT1_BITS          (1 << 5)

#define PWM_TZFRC_DCBEVT2_BITS          (1 << 6)


#define PWM_TZDCSEL_DCAEVT1_BITS          (7 << 0)

#define PWM_TZDCSEL_DCAEVT2_BITS          (7 << 3)

#define PWM_TZDCSEL_DCBEVT1_BITS          (7 << 6)

#define PWM_TZDCSEL_DCBEVT2_BITS          (7 << 9)


#define PWM_DCTRIPSEL_DCAHCOMPSEL_BITS          (15 << 0)

#define PWM_DCTRIPSEL_DCALCOMPSEL_BITS          (15 << 4)

#define PWM_DCTRIPSEL_DCBHCOMPSEL_BITS          (15 << 8)

#define PWM_DCTRIPSEL_DCBLCOMPSEL_BITS          (15 << 12)


#define PWM_DCFCTL_SRCSEL_BITS          (3 << 0)

#define PWM_DCFCTL_BLANKE_BITS          (1 << 2)

#define PWM_DCFCTL_BLANKINV_BITS          (1 << 3)

#define PWM_DCFCTL_PULSESEL_BITS          (3 << 4)


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

typedef enum
{
    PWM_ActionQual_Disabled=0,
    PWM_ActionQual_Clear,
    PWM_ActionQual_Set,
    PWM_ActionQual_Toggle
} PWM_ActionQual_e;


typedef enum
{
  PWM_ActionQualContSWForce_Disabled=0,
  PWM_ActionQualContSWForce_Clear,
  PWM_ActionQualContSWForce_Set
} PWM_ActionQualContSWForce_e;


typedef enum
{
    PWM_ClkDiv_by_1=(0 << 10),
    PWM_ClkDiv_by_2=(1 << 10),
    PWM_ClkDiv_by_4=(2 << 10),
    PWM_ClkDiv_by_8=(3 << 10),
    PWM_ClkDiv_by_16=(4 << 10),
    PWM_ClkDiv_by_32=(5 << 10),
    PWM_ClkDiv_by_64=(6 << 10),
    PWM_ClkDiv_by_128=(7 << 10)
} PWM_ClkDiv_e;


typedef enum
{
    PWM_ChoppingClkFreq_SysClkOut_by_1=(0 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_2=(1 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_3=(2 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_4=(3 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_5=(4 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_6=(5 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_7=(6 << 5),
    PWM_ChoppingClkFreq_SysClkOut_by_8=(7 << 5)
} PWM_ChoppingClkFreq_e;


typedef enum
{
    PWM_ChoppingDutyCycle_One_Eighth=(0 << 8),
    PWM_ChoppingDutyCycle_Two_Eighths=(1 << 8),
    PWM_ChoppingDutyCycle_Three_Eighths=(2 << 8),
    PWM_ChoppingDutyCycle_Four_Eighths=(3 << 8),
    PWM_ChoppingDutyCycle_Five_Eighths=(4 << 8),
    PWM_ChoppingDutyCycle_Six_Eighths=(5 << 8),
    PWM_ChoppingDutyCycle_Seven_Eighths=(6 << 8)
} PWM_ChoppingDutyCycle_e;


typedef enum
{
    PWM_ChoppingPulseWidth_One_Eighth_SysClkOut=(0 << 1),
    PWM_ChoppingPulseWidth_Two_Eighths_SysClkOut=(1 << 1),
    PWM_ChoppingPulseWidth_Three_Eighths_SysClkOut=(2 << 1),
    PWM_ChoppingPulseWidth_Four_Eighths_SysClkOut=(3 << 1),
    PWM_ChoppingPulseWidth_Five_Eighths_SysClkOut=(4 << 1),
    PWM_ChoppingPulseWidth_Six_Eighths_SysClkOut=(5 << 1),
    PWM_ChoppingPulseWidth_Seven_Eighths_SysClkOut=(6 << 1),
    PWM_ChoppingPulseWidth_Eight_Eighths_SysClkOut=(7 << 1),
    PWM_ChoppingPulseWidth_Nine_Eighths_SysClkOut=(8 << 1),
    PWM_ChoppingPulseWidth_Ten_Eighths_SysClkOut=(9 << 1),
    PWM_ChoppingPulseWidth_Eleven_Eighths_SysClkOut=(10 << 1),
    PWM_ChoppingPulseWidth_Twelve_Eighths_SysClkOut=(11 << 1),
    PWM_ChoppingPulseWidth_Thirteen_Eighths_SysClkOut=(12 << 1),
    PWM_ChoppingPulseWidth_Fourteen_Eighths_SysClkOut=(13 << 1),
    PWM_ChoppingPulseWidth_Fifteen_Eighths_SysClkOut=(14 << 1),
    PWM_ChoppingPulseWidth_Sixteen_Eighths_SysClkOut=(15 << 1)
} PWM_ChoppingPulseWidth_e;


typedef enum
{
    PWM_CounterMode_Up=(0 << 0),
    PWM_Countermode_Down=(1 << 0),
    PWM_CounterMode_UpDown=(2 << 0),
    PWM_CounterMode_Stop=(3 << 0)
} PWM_CounterMode_e;


typedef enum
{
    PWM_DeadBandInputMode_EPWMxA_Rising_and_Falling=(0 << 4),
    PWM_DeadBandInputMode_EPWMxA_Falling_EPWMxB_Rising=(1 << 4),
    PWM_DeadBandInputMode_EPWMxA_Rising_EPWMxB_Falling=(2 << 4),
    PWM_DeadBandInputMode_EPWMxB_Rising_and_Falling=(3 << 4)
} PWM_DeadBandInputMode_e;


typedef enum
{
    PWM_DeadBandOutputMode_Bypass=(0 << 0),
    PWM_DeadBandOutputMode_EPWMxA_Disable_EPWMxB_Falling=(1 << 0),
    PWM_DeadBandOutputMode_EPWMxA_Rising_EPWMxB_Disable=(2 << 0),
    PWM_DeadBandOutputMode_EPWMxA_Rising_EPWMxB_Falling=(3 << 0)
} PWM_DeadBandOutputMode_e;


typedef enum
{
    PWM_DeadBandPolarity_EPWMxA_EPWMxB=(0 << 2),
    PWM_DeadBandPolarity_EPWMxA_Inverted=(1 << 2),
    PWM_DeadBandPolarity_EPWMxB_Inverted=(2 << 2),
    PWM_DeadBandPolarity_EPWMxA_Inverted_EPWMxB_Inverted=(3 << 2)
} PWM_DeadBandPolarity_e;


typedef enum
{
    PWM_DigitalCompare_A_High = 0,
    PWM_DigitalCompare_A_Low = 4,
    PWM_DigitalCompare_B_High = 8,
    PWM_DigitalCompare_B_Low = 12
} PWM_DigitalCompare_Input_e;


typedef enum
{
    PWM_DigitalCompare_InputSel_TZ1=(0 << 0),
    PWM_DigitalCompare_InputSel_TZ2=(1 << 0),
    PWM_DigitalCompare_InputSel_TZ3=(2 << 0),
    PWM_DigitalCompare_InputSel_COMP1OUT=(8 << 0),
    PWM_DigitalCompare_InputSel_COMP2OUT=(9 << 0),
    PWM_DigitalCompare_InputSel_COMP3OUT=(10 << 0)
} PWM_DigitalCompare_InputSel_e;


typedef enum
{
    PWM_DigitalCompare_FilterSrc_DCAEVT1=0,
    PWM_DigitalCompare_FilterSrc_DCAEVT2,
    PWM_DigitalCompare_FilterSrc_DCBEVT1,
    PWM_DigitalCompare_FilterSrc_DCBEVT2
} PWM_DigitalCompare_FilterSrc_e;


typedef enum
{
    PWM_DigitalCompare_PulseSel_CTRPRD=0,
    PWM_DigitalCompare_PulseSel_CTR0
} PWM_DigitalCompare_PulseSel_e;


typedef enum
{
    PWM_HspClkDiv_by_1=(0 << 7),
    PWM_HspClkDiv_by_2=(1 << 7),
    PWM_HspClkDiv_by_4=(2 << 7),
    PWM_HspClkDiv_by_6=(3 << 7),
    PWM_HspClkDiv_by_8=(4 << 7),
    PWM_HspClkDiv_by_10=(5 << 7),
    PWM_HspClkDiv_by_12=(6 << 7),
    PWM_HspClkDiv_by_14=(7 << 7)
} PWM_HspClkDiv_e;

typedef enum
{
    PWM_HrControlMode_Duty = (0 << 2),
    PWM_HrControlMode_Phase = (1 << 2)
} PWM_HrControlMode_e;


typedef enum
{
    PWM_HrEdgeMode_Disabled = (0 << 0),
    PWM_HrEdgeMode_Rising = (1 << 0),
    PWM_HrEdgeMode_Falling = (2 << 0),
    PWM_HrEdgeMode_Both = (3 << 0)
} PWM_HrEdgeMode_e;


typedef enum
{
    PWM_HrShadowMode_CTR_EQ_0 = (0 << 3),
    PWM_HrShadowMode_CTR_EQ_PRD = (1 << 3),
    PWM_HrShadowMode_CTR_EQ_0_OR_PRD = (2 << 3)
} PWM_HrShadowMode_e;

typedef enum
{
    PWM_IntMode_CounterEqualZero=(1 << 0),
    PWM_IntMode_CounterEqualPeriod=(2 << 0),
    PWM_IntMode_CounterEqualZeroOrPeriod=(3 << 0),
    PWM_IntMode_CounterEqualCmpAIncr=(4 << 0),
    PWM_IntMode_CounterEqualCmpADecr=(5 << 0),
    PWM_IntMode_CounterEqualCmpBIncr=(6 << 0),
    PWM_IntMode_CounterEqualCmpBDecr=(7 << 0)
} PWM_IntMode_e;


typedef enum
{
    PWM_IntPeriod_Disable=(0 << 0),
    PWM_IntPeriod_FirstEvent=(1 << 0),
    PWM_IntPeriod_SecondEvent=(2 << 0),
    PWM_IntPeriod_ThirdEvent=(3 << 0)
} PWM_IntPeriod_e;


typedef enum
{
    PWM_LoadMode_Zero=0,
    PWM_LoadMode_Period,
    PWM_LoadMode_Either,
    PWM_LoadMode_Freeze
} PWM_LoadMode_e;


typedef enum
{
    PWM_Number_1=0,
    PWM_Number_2,
    PWM_Number_3,
    PWM_Number_4,
    PWM_Number_5,
    PWM_Number_6,
    PWM_Number_7,
    PWM_Number_8
} PWM_Number_e;


typedef enum
{
    PWM_PeriodLoad_Shadow=(0 << 3),
    PWM_PeriodLoad_Immediate=(1 << 3)
} PWM_PeriodLoad_e;


typedef enum
{
    PWM_PhaseDir_CountDown=(0 << 13),
    PWM_PhaseDir_CountUp=(1 << 13)
} PWM_PhaseDir_e;


typedef enum
{
    PWM_RunMode_SoftStopAfterIncr=(0 << 14),
    PWM_RunMode_SoftStopAfterDecr=(0 << 14),
    PWM_RunMode_SoftStopAfterCycle=(1 << 14),
    PWM_RunMode_FreeRun=(2 << 14)
} PWM_RunMode_e;


typedef enum
{
    PWM_ShadowMode_Shadow=0,
    PWM_ShadowMode_Immediate
} PWM_ShadowMode_e;


typedef enum
{
    PWM_ShadowStatus_NotFull=0,
    PWM_ShadowStatus_Full
} PWM_ShadowStatus_e;


typedef enum
{
    PWM_SocPeriod_Disable=0,
    PWM_SocPeriod_FirstEvent,
    PWM_SocPeriod_SecondEvent,
    PWM_SocPeriod_ThirdEvent
} PWM_SocPeriod_e;


typedef enum
{
    PWM_SocPulseSrc_DcEvt=0,
    PWM_SocPulseSrc_CounterEqualZero,
    PWM_SocPulseSrc_CounterEqualPeriod,
    PWM_SocPulseSrc_CounterEqualZeroOrPeriod,
    PWM_SocPulseSrc_CounterEqualCmpAIncr,
    PWM_SocPulseSrc_CounterEqualCmpADecr,
    PWM_SocPulseSrc_CounterEqualCmpBIncr,
    PWM_SocPulseSrc_CounterEqualCmpBDecr
} PWM_SocPulseSrc_e;


typedef enum
{
    PWM_SyncMode_EPWMxSYNC=(0 << 4),
    PWM_SyncMode_CounterEqualZero=(1 << 4),
    PWM_SyncMode_CounterEqualCounterCompareZero=(2 << 4),
    PWM_SyncMode_Disable=(3 << 4)
} PWM_SyncMode_e;


typedef enum
{
    PWM_TripZoneSrc_CycleByCycle_TZ1_NOT=(1 << 0),
    PWM_TripZoneSrc_CycleByCycle_TZ2_NOT=(1 << 1),
    PWM_TripZoneSrc_CycleByCycle_TZ3_NOT=(1 << 2),
    PWM_TripZoneSrc_CycleByCycle_TZ4_NOT=(1 << 3),
    PWM_TripZoneSrc_CycleByCycle_TZ5_NOT=(1 << 4),
    PWM_TripZoneSrc_CycleByCycle_TZ6_NOT=(1 << 5),
    PWM_TripZoneSrc_CycleByCycle_CmpA=(1 << 6),
    PWM_TripZoneSrc_CycleByCycle_CmpB=(1 << 7),
    PWM_TripZoneSrc_OneShot_TZ1_NOT=(1 << 8),
    PWM_TripZoneSrc_OneShot_TZ2_NOT=(1 << 9),
    PWM_TripZoneSrc_OneShot_TZ3_NOT=(1 << 10),
    PWM_TripZoneSrc_OneShot_TZ4_NOT=(1 << 11),
    PWM_TripZoneSrc_OneShot_TZ5_NOT=(1 << 12),
    PWM_TripZoneSrc_OneShot_TZ6_NOT=(1 << 13),
    PWM_TripZoneSrc_OneShot_CmpA=(1 << 14),
    PWM_TripZoneSrc_OneShot_CmpB=(1 << 15)
} PWM_TripZoneSrc_e;


typedef enum
{
    PWM_TripZoneState_HighImp=0,
    PWM_TripZoneState_EPWM_High,
    PWM_TripZoneState_EPWM_Low,
    PWM_TripZoneState_DoNothing
} PWM_TripZoneState_e;

typedef enum
{
    PWM_TripZoneFlag_Global = (1 << 0),    
    PWM_TripZoneFlag_CBC = (1 << 1),       
    PWM_TripZoneFlag_OST = (1 << 2),       
    PWM_TripZoneFlag_DCAEVT1 = (1 << 3),   
    PWM_TripZoneFlag_DCAEVT2 = (1 << 4),   
    PWM_TripZoneFlag_DCBEVT1 = (1 << 5),   
    PWM_TripZoneFlag_DCBEVT2 = (1 << 6)    
} PWM_TripZoneFlag_e;

typedef enum
{
    PWM_TripZoneDCEventSel_Disabled = (0 << 0),       
    PWM_TripZoneDCEventSel_DCxHL_DCxLX = (1 << 0),    
    PWM_TripZoneDCEventSel_DCxHH_DCxLX = (2 << 0),    
    PWM_TripZoneDCEventSel_DCxHx_DCxLL = (3 << 0),    
    PWM_TripZoneDCEventSel_DCxHx_DCxLH = (4 << 0),    
    PWM_TripZoneDCEventSel_DCxHL_DCxLH = (5 << 0)     
} PWM_TripZoneDCEventSel_e;


typedef struct _PWM_Obj_
{
  volatile uint16_t   TBCTL;       
  volatile uint16_t   TBSTS;       
  volatile uint16_t   TBPHSHR;     
  volatile uint16_t   TBPHS;       
  volatile uint16_t   TBCTR;       
  volatile uint16_t   TBPRD;       
  volatile uint16_t   TBPRDHR;     
  volatile uint16_t   CMPCTL;      
  volatile uint16_t   CMPAHR;      
  volatile uint16_t   CMPA;        
  volatile uint16_t   CMPB;        
  volatile uint16_t   AQCTLA;      
  volatile uint16_t   AQCTLB;      
  volatile uint16_t   AQSFRC;      
  volatile uint16_t   AQCSFRC;     
  volatile uint16_t   DBCTL;       
  volatile uint16_t   DBRED;       
  volatile uint16_t   DBFED;       
  volatile uint16_t   TZSEL;       
  volatile uint16_t   TZDCSEL;     
  volatile uint16_t   TZCTL;       
  volatile uint16_t   TZEINT;      
  volatile uint16_t   TZFLG;       
  volatile uint16_t   TZCLR;       
  volatile uint16_t   TZFRC;       
  volatile uint16_t   ETSEL;       
  volatile uint16_t   ETPS;        
  volatile uint16_t   ETFLG;       
  volatile uint16_t   ETCLR;       
  volatile uint16_t   ETFRC;       
  volatile uint16_t   PCCTL;       
  volatile uint16_t   rsvd_1;      
  volatile uint16_t   HRCNFG;      
  volatile uint16_t   HRPWR;       
  volatile uint16_t   rsvd_2[4];   
  volatile uint16_t   HRMSTEP;     
  volatile uint16_t   rsvd_3;      
  volatile uint16_t   HRPCTL;      
  volatile uint16_t   rsvd_4;      
  volatile uint16_t   TBPRDHRM;    
  volatile uint16_t   TBPRDM;      
  volatile uint16_t   CMPAHRM;     
  volatile uint16_t   CMPAM;       
  volatile uint16_t   rsvd_5[2];   
  volatile uint16_t   DCTRIPSEL;   
  volatile uint16_t   DCACTL;      
  volatile uint16_t   DCBCTL;      
  volatile uint16_t   DCFCTL;      
  volatile uint16_t   DCCAPCTL;    
  volatile uint16_t   DCFOFFSET;   
  volatile uint16_t   DCFOFFSETCNT;
  volatile uint16_t   DCFWINDOW;   
  volatile uint16_t   DCFWINDOWCNT;
  volatile uint16_t   DCCAP;       
  
} PWM_Obj;


typedef struct _PWM_Obj_ *PWM_Handle;


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


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

static inline void PWM_clearIntFlag(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;


    // set the bits
    pwm->ETCLR = PWM_ETCLR_INT_BITS;

    return;
} // end of PWM_clearIntFlag() function


static inline void PWM_clearOneShotTrip(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;


    ENABLE_PROTECTED_REGISTER_WRITE_MODE;

    // set the bits
    pwm->TZCLR = PWM_TZCLR_OST_BITS;

    DISABLE_PROTECTED_REGISTER_WRITE_MODE;

    return;
} // end of PWM_clearOneShotTrip() function


static inline void PWM_clearSocAFlag(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;


    // set the bits
    pwm->ETCLR = PWM_ETCLR_SOCA_BITS;

    return;
} // end of PWM_clearSocAFlag() function


static inline void PWM_clearSocBFlag(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;


    // set the bits
    pwm->ETCLR = PWM_ETCLR_SOCB_BITS;

    return;
} // end of PWM_clearSocBFlag() function

extern void PWM_clearTripZone(PWM_Handle pwmHandle, const PWM_TripZoneFlag_e tripZoneFlag);


extern void PWM_decrementDeadBandFallingEdgeDelay(PWM_Handle pwmHandle);


extern void PWM_decrementDeadBandRisingEdgeDelay(PWM_Handle pwmHandle);

extern void PWM_disableAutoConvert(PWM_Handle pwmHandle);

extern void PWM_disableChopping(PWM_Handle pwmHandle);


extern void PWM_disableCounterLoad(PWM_Handle pwmHandle);


extern void PWM_disableDeadBand(PWM_Handle pwmHandle);


extern void PWM_disableDeadBandHalfCycle(PWM_Handle pwmHandle);


extern void PWM_disableDigitalCompareBlankingWindow(PWM_Handle pwmHandle);


extern void PWM_disableDigitalCompareBlankingWindowInversion(PWM_Handle pwmHandle);

extern void PWM_disableHrPeriod(PWM_Handle pwmHandle);


extern void PWM_disableHrPhaseSync(PWM_Handle pwmHandle);

extern void PWM_disableInt(PWM_Handle pwmHandle);


extern void PWM_disableSocAPulse(PWM_Handle pwmHandle);


extern void PWM_disableSocBPulse(PWM_Handle pwmHandle);


extern void PWM_disableTripZones(PWM_Handle pwmHandle);


extern void PWM_disableTripZoneInt(PWM_Handle pwmHandle, const PWM_TripZoneFlag_e interruptSource);


extern void PWM_disableTripZoneSrc(PWM_Handle pwmHandle,const PWM_TripZoneSrc_e src);

extern void PWM_enableAutoConvert(PWM_Handle pwmHandle);

extern void PWM_enableChopping(PWM_Handle pwmHandle);


extern void PWM_enableCounterLoad(PWM_Handle pwmHandle);


extern void PWM_enableDeadBandHalfCycle(PWM_Handle pwmHandle);


extern void PWM_enableDigitalCompareBlankingWindow(PWM_Handle pwmHandle);


extern void PWM_enableDigitalCompareBlankingWindowInversion(PWM_Handle pwmHandle);

extern void PWM_enableHrPeriod(PWM_Handle pwmHandle);


extern void PWM_enableHrPhaseSync(PWM_Handle pwmHandle);

extern void PWM_enableInt(PWM_Handle pwmHandle);


extern void PWM_enableSocAPulse(PWM_Handle pwmHandle);


extern void PWM_enableSocBPulse(PWM_Handle pwmHandle);


extern void PWM_enableTripZoneInt(PWM_Handle pwmHandle, const PWM_TripZoneFlag_e interruptSource);


extern void PWM_enableTripZoneSrc(PWM_Handle pwmHandle,const PWM_TripZoneSrc_e src);


static inline uint16_t PWM_get_CmpA(PWM_Handle pwmHandle)
{
  PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

  return pwm->CMPA;
} // end of PWM_get_CmpA() function


static inline uint16_t PWM_get_CmpAM(PWM_Handle pwmHandle)
{
  PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

  return pwm->CMPAM;
} // end of PWM_get_CmpAM() function


static inline uint16_t PWM_get_CmpB(PWM_Handle pwmHandle)
{
  PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

  return pwm->CMPB;
} // end of PWM_get_CmpB() function


static inline void PWM_forceSync(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    pwm->TBCTL |= PWM_TBCTL_SWFSYNC_BITS;

    return;
} // end of PWM_forceSync() function


extern uint16_t PWM_getDeadBandFallingEdgeDelay(PWM_Handle pwmHandle);


extern uint16_t PWM_getDeadBandRisingEdgeDelay(PWM_Handle pwmHandle);


extern uint16_t PWM_getIntCount(PWM_Handle pwmHandle);


static inline uint16_t PWM_getPeriod(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    return (pwm->TBPRD);
} // end of PWM_getPeriod() function


static inline uint16_t PWM_getCmpA(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    return (pwm->CMPA);
} // end of PWM_getCmpA() function

static inline uint16_t PWM_getCmpAHr(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    return (pwm->CMPAHR);
} // end of PWM_getCmpAHr() function

static inline uint16_t PWM_getCmpB(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    return (pwm->CMPB);
} // end of PWM_getCmpB() function


extern uint16_t PWM_getSocACount(PWM_Handle pwmHandle);


extern uint16_t PWM_getSocBCount(PWM_Handle pwmHandle);

extern void PWM_setHrControlMode(PWM_Handle pwmHandle, const PWM_HrControlMode_e controlMode);


extern void PWM_setHrEdgeMode(PWM_Handle pwmHandle, const PWM_HrEdgeMode_e edgeMode);


extern void PWM_setHrShadowMode(PWM_Handle pwmHandle, const PWM_HrShadowMode_e shadowMode);

extern void PWM_incrementDeadBandFallingEdgeDelay(PWM_Handle pwmHandle);


extern void PWM_incrementDeadBandRisingEdgeDelay(PWM_Handle pwmHandle);


extern PWM_Handle PWM_init(void *pMemory,const size_t numBytes);


extern void PWM_setActionQual_CntDown_CmpA_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntDown_CmpA_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntDown_CmpB_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntDown_CmpB_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntUp_CmpA_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntUp_CmpA_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntUp_CmpB_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_CntUp_CmpB_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQualContSWForce_PwmA(PWM_Handle pwmHandle,
                                              const PWM_ActionQualContSWForce_e actionQualContSWForce);


extern void PWM_setActionQualContSWForce_PwmB(PWM_Handle pwmHandle,
                                              const PWM_ActionQualContSWForce_e actionQualContSWForce);


extern void PWM_setActionQual_Period_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_Period_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_Zero_PwmA(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setActionQual_Zero_PwmB(PWM_Handle pwmHandle,const PWM_ActionQual_e actionQual);


extern void PWM_setChoppingClkFreq(PWM_Handle pwmHandle,const PWM_ChoppingClkFreq_e clkFreq);


extern void PWM_setChoppingDutyCycle(PWM_Handle pwmHandle,const PWM_ChoppingDutyCycle_e dutyCycle);


extern void PWM_setChoppingPulseWidth(PWM_Handle pwmHandle,const PWM_ChoppingPulseWidth_e pulseWidth);


extern void PWM_setClkDiv(PWM_Handle pwmHandle,const PWM_ClkDiv_e clkDiv);


extern void PWM_setCount(PWM_Handle pwmHandle,const uint16_t count);


extern void PWM_setCounterMode(PWM_Handle pwmHandle,const PWM_CounterMode_e counterMode);


extern void PWM_setDeadBandFallingEdgeDelay(PWM_Handle pwmHandle,const uint16_t delay);


extern void PWM_setDeadBandInputMode(PWM_Handle pwmHandle,const PWM_DeadBandInputMode_e inputMode);


extern void PWM_setDeadBandOutputMode(PWM_Handle pwmHandle,const PWM_DeadBandOutputMode_e outputMode);


extern void PWM_setDeadBandPolarity(PWM_Handle pwmHandle,const PWM_DeadBandPolarity_e polarity);


extern void PWM_setDeadBandRisingEdgeDelay(PWM_Handle pwmHandle,const uint16_t delay);


extern void PWM_setDigitalCompareFilterSource(PWM_Handle pwmHandle, 
                                const PWM_DigitalCompare_FilterSrc_e input);
                                

extern void PWM_setDigitalCompareBlankingPulse(PWM_Handle pwmHandle, 
                                const PWM_DigitalCompare_PulseSel_e pulseSelect);
                                
                                
extern void PWM_setDigitalCompareFilterOffset(PWM_Handle pwmHandle, 
                                const uint16_t offset);
                                
                                
extern void PWM_setDigitalCompareFilterWindow(PWM_Handle pwmHandle, 
                                const uint16_t window);
                                                                

extern void PWM_setDigitalCompareInput(PWM_Handle pwmHandle, 
                                const PWM_DigitalCompare_Input_e input, 
                                const PWM_DigitalCompare_InputSel_e inputSel);
                                
                                
extern void PWM_setDigitalCompareAEvent1(PWM_Handle pwmHandle, 
                                const bool selectFilter,
                                const bool disableSync,
                                const bool enableSoc,
                                const bool generateSync);
                                
                                
extern void PWM_setDigitalCompareAEvent2(PWM_Handle pwmHandle, 
                                const bool selectFilter,
                                const bool disableSync);
                                
                                
extern void PWM_setDigitalCompareBEvent1(PWM_Handle pwmHandle, 
                                const bool selectFilter,
                                const bool disableSync,
                                const bool enableSoc,
                                const bool generateSync);
                                
                                
extern void PWM_setDigitalCompareBEvent2(PWM_Handle pwmHandle, 
                                const bool selectFilter,
                                const bool disableSync);


extern void PWM_setHighSpeedClkDiv(PWM_Handle pwmHandle,const PWM_HspClkDiv_e clkDiv);


extern void PWM_setIntMode(PWM_Handle pwmHandle,const PWM_IntMode_e intMode);


extern void PWM_setIntPeriod(PWM_Handle pwmHandle,const PWM_IntPeriod_e intPeriod);


extern void PWM_setLoadMode_CmpA(PWM_Handle pwmHandle,const PWM_LoadMode_e loadMode);


extern void PWM_setLoadMode_CmpB(PWM_Handle pwmHandle,const PWM_LoadMode_e loadMode);


extern void PWM_setPeriodLoad(PWM_Handle pwmHandle,const PWM_PeriodLoad_e periodLoad);


static inline void PWM_setOneShotTrip(PWM_Handle pwmHandle)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;


    ENABLE_PROTECTED_REGISTER_WRITE_MODE;

    // set the bits
    pwm->TZFRC |= PWM_TZFRC_OST_BITS;

    DISABLE_PROTECTED_REGISTER_WRITE_MODE;

    return;
} // end of PWM_setOneShotTrip() function


extern void PWM_setPeriod(PWM_Handle pwmHandle,const uint16_t period);

extern void PWM_setPeriodHr(PWM_Handle pwmHandle,const uint16_t period);

extern void PWM_setPhase(PWM_Handle pwmHandle,const uint16_t phase);


extern void PWM_setPhaseDir(PWM_Handle pwmHandle,const PWM_PhaseDir_e phaseDir);


extern void PWM_setRunMode(PWM_Handle pwmHandle,const PWM_RunMode_e runMode);


extern void PWM_setSocAPeriod(PWM_Handle pwmHandle,const PWM_SocPeriod_e intPeriod);


extern void PWM_setSocAPulseSrc(PWM_Handle pwmHandle,const PWM_SocPulseSrc_e pulseSrc);


extern void PWM_setSocBPeriod(PWM_Handle pwmHandle,const PWM_SocPeriod_e intPeriod);


extern void PWM_setSocBPulseSrc(PWM_Handle pwmHandle,const PWM_SocPulseSrc_e pulseSrc);


extern void PWM_setShadowMode_CmpA(PWM_Handle pwmHandle,const PWM_ShadowMode_e shadowMode);


extern void PWM_setShadowMode_CmpB(PWM_Handle pwmHandle,const PWM_ShadowMode_e shadowMode);


extern void PWM_setSwSync(PWM_Handle pwmHandle);


extern void PWM_setSyncMode(PWM_Handle pwmHandle,const PWM_SyncMode_e syncMode);


extern void PWM_setTripZoneDCEventSelect_DCAEVT1(PWM_Handle pwmHandle, const PWM_TripZoneDCEventSel_e tripZoneEvent);


extern void PWM_setTripZoneDCEventSelect_DCAEVT2(PWM_Handle pwmHandle, const PWM_TripZoneDCEventSel_e tripZoneEvent);


extern void PWM_setTripZoneDCEventSelect_DCBEVT1(PWM_Handle pwmHandle, const PWM_TripZoneDCEventSel_e tripZoneEvent);


extern void PWM_setTripZoneDCEventSelect_DCBEVT2(PWM_Handle pwmHandle, const PWM_TripZoneDCEventSel_e tripZoneEvent);


extern void PWM_setTripZoneState_DCAEVT1(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


extern void PWM_setTripZoneState_DCAEVT2(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


extern void PWM_setTripZoneState_DCBEVT1(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


extern void PWM_setTripZoneState_DCBEVT2(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


extern void PWM_setTripZoneState_TZA(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


extern void PWM_setTripZoneState_TZB(PWM_Handle pwmHandle,const PWM_TripZoneState_e tripZoneState);


static inline void PWM_write_CmpA(PWM_Handle pwmHandle,const uint16_t pwmData)
{
  PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

  pwm->CMPA = pwmData;

  return;
} // end of PWM_write_CmpA() function


static inline void PWM_setCmpA(PWM_Handle pwmHandle,const uint16_t pwmData)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    pwm->CMPA = pwmData;

    return;
} // end of PWM_setCmpA() function

static inline void PWM_setCmpAHr(PWM_Handle pwmHandle,const uint16_t pwmData)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    pwm->CMPAHR = pwmData;

    return;
} // end of PWM_setCmpAHr() function

static inline void PWM_write_CmpB(PWM_Handle pwmHandle,const uint16_t pwmData)
{
  PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

  pwm->CMPB = pwmData;

  return;
} // end of PWM_write_CmpB() function


static inline void PWM_setCmpB(PWM_Handle pwmHandle,const uint16_t pwmData)
{
    PWM_Obj *pwm = (PWM_Obj *)pwmHandle;

    pwm->CMPB = pwmData;

    return;
} // end of PWM_setCmpB() function


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

#endif  // end of _PWM_H_ definition