//#############################################################################
//
//  File:   Example_F2802xAdc_TempSensorConv.c
//
//  Title:  Example ADC Temperature Sensor Conversion to Degrees
//          Celsius/Degrees Kelvin
//
//! \addtogroup example_list
//!  <h1>ADC Temperature Sensor Conversion</h1>
//!
//!    This program shows how to convert a raw ADC temperature sensor reading
//!    into deg. C or deg. K.
//!
//!    Watch Variables:
//!    - temp
//!    - degC
//!    - degK
//
//#############################################################################
// $TI Release: F2802x Support Library v3.02.00.00 $
// $Release Date: Thu Oct 18 15:45:37 CDT 2018 $
// $Copyright:
// Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// 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.
// $
//#############################################################################

//
// Included Files
//
#include "DSP28x_Project.h"     // DSP28x Headerfile

#include "common/include/adc.h"
#include "common/include/clk.h"
#include "common/include/flash.h"
#include "common/include/gpio.h"
#include "common/include/pie.h"
#include "common/include/pll.h"
#include "common/include/wdog.h"
#include "common/include/pwm.h"
#include "common/include/spi.h"

#include "math.h"
//
// Defines
//
// Length of the word being sent
//
#define CHAR_LENGTH     SPI_CharLength_16_Bits
#define CHAR_MAX        (0xFFFF >> (SPI_CharLength_16_Bits - CHAR_LENGTH))

//
// Micro-seconds to wait for ADC conversion. Longer than necessary.
//
#define CONV_WAIT 1L


//
// Function Prototypes
//
void InitEPwm1(void);
void InitEPwm2(void);
void InitEPwm3(void);
void InitEPwm4(void);


void InitEPwm1Example(void);
void InitEPwm2Example(void);
void InitEPwm3Example(void);
void InitEPwm4Example(void);

__interrupt void epwm1_isr(void);
__interrupt void epwm2_isr(void);
__interrupt void epwm3_isr(void);
__interrupt void epwm4_isr(void);
//__interrupt void spiTxFifoIsr(void);
//__interrupt void spiRxFifoIsr(void);

void spi_xmit(uint16_t a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);


//
// Defines for the Maximum Dead Band values
//
#define EPWM1_MAX_DB   0x03FF
#define EPWM2_MAX_DB   0x03FF
#define EPWM3_MAX_DB   0x03FF

#define start1 0
#define stop1  start1+EPWM1_MAX_DB

#define start2 0x0400
#define stop2  0x0400+EPWM1_MAX_DB

#define start3 0x0800
#define stop3  0x0800+EPWM1_MAX_DB




#define EPWM1_MIN_DB   0
#define EPWM2_MIN_DB   0
#define EPWM3_MIN_DB   0

//
// Defines to keep track of which way the Dead Band is moving
//
#define DB_UP   1
#define DB_DOWN 0

CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
PWM_Handle myPwm1, myPwm2, myPwm3;

//
// Globals
//
int16_t pwm = 0x1ff;


int16_t temp; //raw temperature sensor reading
int16_t degC; //temperature in deg. C
int16_t degK; //temperature in deg. K

static uint16_t ADC0 = 0;
static uint16_t ADC1 = 0;

uint32_t  EPwm1TimerIntCount;
uint32_t  EPwm2TimerIntCount;
uint32_t  EPwm3TimerIntCount;
uint16_t  EPwm1_DB_Direction;
uint16_t  EPwm2_DB_Direction;
uint16_t  EPwm3_DB_Direction;

uint16_t sdata[2];      // Send data buffer
uint16_t rdata[2];      // Receive data buffer

uint16_t rdata_point;

static int16_t a = 0;
static int16_t c = 0;
#define PI 3.14159265358979323846

CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
SPI_Handle mySpi;

//
// Main
//
void main()
{
    uint16_t i;
    uint16_t m;

    ADC_Handle myAdc;
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;

    //
    // Initialize all the handles needed for this application
    //
    myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj));
    myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj));
    mySpi = SPI_init((void *)SPIA_BASE_ADDR, sizeof(SPI_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    //
    // Perform basic system initialization
    //
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();

    //
    // Enable SPI-A Clock
    //
    CLK_enableSpiaClock(myClk);

    //
    // Select the internal oscillator 1 as the clock source
    //
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

    //
    // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2
    //
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);

    //
    // Disable the PIE and all interrupts
    //
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);

    //
    // If running from flash copy RAM only functions to RAM
    //
#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

    //
    // Initialize GPIO
    //
    GPIO_setPullUp(myGpio, GPIO_Number_0, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_1, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_EPWM1B);

    GPIO_setPullUp(myGpio, GPIO_Number_2, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_3, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_EPWM2A);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_EPWM2B);

    GPIO_setPullUp(myGpio, GPIO_Number_4, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_5, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_4, GPIO_4_Mode_EPWM3A);
    GPIO_setMode(myGpio, GPIO_Number_5, GPIO_5_Mode_EPWM3B);

    GPIO_setPullUp(myGpio, GPIO_Number_6, GPIO_PullUp_Disable);
    GPIO_setPullUp(myGpio, GPIO_Number_7, GPIO_PullUp_Disable);
    GPIO_setMode(myGpio, GPIO_Number_6, GPIO_6_Mode_EPWM4A);
    GPIO_setMode(myGpio, GPIO_Number_7, GPIO_7_Mode_EPWM4B);


    //
    // Initialize GPIO SPI
    //
    GPIO_setPullUp(myGpio, GPIO_Number_16, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_17, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_18, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_19, GPIO_PullUp_Enable);
    GPIO_setQualification(myGpio, GPIO_Number_16, GPIO_Qual_ASync);
    GPIO_setQualification(myGpio, GPIO_Number_17, GPIO_Qual_ASync);
    GPIO_setQualification(myGpio, GPIO_Number_18, GPIO_Qual_ASync);
    GPIO_setQualification(myGpio, GPIO_Number_19, GPIO_Qual_ASync);
    GPIO_setMode(myGpio, GPIO_Number_16, GPIO_16_Mode_SPISIMOA);
    GPIO_setMode(myGpio, GPIO_Number_17, GPIO_17_Mode_SPISOMIA);
    GPIO_setMode(myGpio, GPIO_Number_18, GPIO_18_Mode_SPICLKA);
    GPIO_setMode(myGpio, GPIO_Number_19, GPIO_19_Mode_SPISTEA_NOT);

    // EPWM sync
    GPIO_setMode(myGpio, GPIO_Number_33, GPIO_33_Mode_EPWMSYNCO);
    EPwm2Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;
    EPwm3Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;
    EPwm4Regs.TBCTL.bit.SYNCOSEL = TB_SYNC_IN;




    // Enable XCLOCKOUT to allow monitoring of oscillator 1
    //
//    GPIO_setMode(myGpio, GPIO_Number_18, GPIO_18_Mode_XCLKOUT);
    CLK_setClkOutPreScaler(myClk, CLK_ClkOutPreScaler_SysClkOut_by_1);

    //
    // Setup a debug vector table and enable the PIE
    //
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);

    //
    // Register interrupt handlers in the PIE vector table
    //
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1,
                              (intVec_t)&epwm1_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_2,
                             (intVec_t)&epwm2_isr);
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_3,
                             (intVec_t)&epwm3_isr);

 //   PIE_registerPieIntHandler(myPie, PIE_GroupNumber_6, PIE_SubGroupNumber_1,
 //                             (intVec_t)&spiRxFifoIsr);
 //   PIE_registerPieIntHandler(myPie, PIE_GroupNumber_6, PIE_SubGroupNumber_2,
 //                             (intVec_t)&spiTxFifoIsr);

    spi_init();                  // Initialize SPI
    spi_fifo_init();             // Initialize the SPI FIFOs


    //
    // Initialize the send data buffer
    //
    for(i=0; i<2; i++)
    {
        sdata[i] = i;
    }
    rdata_point = 0;


    CLK_disableTbClockSync(myClk);

    InitEPwm1();
    InitEPwm2();
    InitEPwm3();


    CLK_enableTbClockSync(myClk);

    //
    // Initialize counters
    //
    EPwm1TimerIntCount = 0;
    EPwm2TimerIntCount = 0;
    EPwm3TimerIntCount = 0;


    //
    // Enable CPU INT3 which is connected to EPWM1-3 INT
    //
    CPU_enableInt(myCpu, CPU_IntNumber_3);

    //
    // Enable EPWM INTn in the PIE: Group 3 interrupt 1-3
    //
    PIE_enablePwmInt(myPie, PWM_Number_1);
    PIE_enablePwmInt(myPie, PWM_Number_2);
    PIE_enablePwmInt(myPie, PWM_Number_3);
 //   PIE_enablePwmInt(myPie, PWM_Number_4);

 //   PIE_enableInt(myPie, PIE_GroupNumber_6, PIE_InterruptSource_SPIARX);
 //   PIE_enableInt(myPie, PIE_GroupNumber_6, PIE_InterruptSource_SPIATX);
 //   CPU_enableInt(myCpu, CPU_IntNumber_6);

    //
    // Initialize the ADC
    //
    ADC_enableBandGap(myAdc);
    ADC_enableRefBuffers(myAdc);
    ADC_powerUp(myAdc);
    ADC_enable(myAdc);
    ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);

    //
    // Connect channel A5 internally to the temperature sensor
    //
    ADC_enableTempSensor(myAdc);

    //
    // Set SOC0 channel select to ADCINA5
    //
    ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A1);

    //
    // Set SOC1 channel select to ADCINA5
    //
    ADC_setSocChanNumber (myAdc, ADC_SocNumber_1, ADC_SocChanNumber_A1);

    //
    // Set SOC0 acquisition period to 37 ADCCLK
    //
    ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0,
                           ADC_SocSampleWindow_37_cycles);

    //
    // Set SOC1 acquisition period to 37 ADCCLK
    //
    ADC_setSocSampleWindow(myAdc, ADC_SocNumber_1,
                           ADC_SocSampleWindow_37_cycles);

    //
    // Connect ADCINT1 to EOC1
    //
    ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC1);

    //
    // Enable ADCINT1
    //
    ADC_enableInt(myAdc, ADC_IntNumber_1);

    //
    // Note: two channels have been connected to the temp sensor
    // so that the first sample can be discarded to avoid the
    // ADC first sample issue.  See the device errata.
    //

    //
    // Set the flash OTP wait-states to minimum. This is important
    // for the performance of the temperature conversion function.
    //
    FLASH_setup(myFlash);


    //
    // Enable global Interrupts and higher priority real-time debug events
    //
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);

    //
    // Main program loop - continually sample temperature
    //
    for(;;)
    {
        //
        // Force start of conversion on SOC0 and SOC1
        //
        ADC_forceConversion(myAdc, ADC_SocNumber_0);
        ADC_forceConversion(myAdc, ADC_SocNumber_1);

        //
        // Wait for end of conversion.
        //
        while(ADC_getIntStatus(myAdc, ADC_IntNumber_1) == 0)
        {

        }


        ADC0 = ADC_readResult(myAdc, ADC_ResultNumber_0);
        ADC1 = ADC_readResult(myAdc, ADC_ResultNumber_1);


        //
        // Clear ADCINT1
        //
        ADC_clearIntFlag(myAdc, ADC_IntNumber_1);

        //
        // Get temp sensor sample result from SOC1
        //
        temp = ADC_readResult(myAdc, ADC_ResultNumber_1);

        //
        // Convert the raw temperature sensor measurement into temperature
        //
//        degC = ADC_getTemperatureC(myAdc, temp);
//        degK = ADC_getTemperatureK(myAdc, temp);

        DELAY_US(10);

 //       DELAY_US(220);
        uint16_t data = SPI_read(mySpi);
        SPI_write(mySpi, data);

        float b = (int) (data - 0x8000); //PWM setzen

//        float b = (sin((float)PI*0.02*m))*2200;
 //      float b = (sin((float)PI*0.1*m))*2200;

       a = (int16_t) b;
       c = (int16_t) (b / 1000);
//        m++;
    }
}

//
// epwm1_isr -
//
__interrupt void
epwm1_isr(void)
{
   switch (c) {
       case 0:
           if (a>0) {
               PWM_setCmpA(myPwm1, a-start1);
               PWM_setCmpB(myPwm1, 0);
           }
           else {
               PWM_setCmpA(myPwm1, 0);
               PWM_setCmpB(myPwm1, -a+start1);
           }
           PWM_setCmpA(myPwm2, 0);
           PWM_setCmpB(myPwm2, 0);
           PWM_setCmpA(myPwm3, 0);
           PWM_setCmpB(myPwm3, 0);
           break;
       case 1:
           PWM_setCmpA(myPwm1, stop1);
           PWM_setCmpB(myPwm1, 0);
           PWM_setCmpA(myPwm2, a-start2);
           PWM_setCmpB(myPwm2, 0);
           PWM_setCmpA(myPwm3, 0);
           PWM_setCmpB(myPwm3, 0);
           break;
       case -1:
           PWM_setCmpA(myPwm1, 0);
           PWM_setCmpB(myPwm1, stop1);
           PWM_setCmpA(myPwm2, 0);
           PWM_setCmpB(myPwm2, -(a+start2));
           PWM_setCmpA(myPwm3, 0);
           PWM_setCmpB(myPwm3, 0);
           break;
       case 2:
           PWM_setCmpA(myPwm1, stop1);
           PWM_setCmpB(myPwm1, 0);
           PWM_setCmpA(myPwm2, stop2);
           PWM_setCmpB(myPwm2, 0);
           PWM_setCmpA(myPwm3, a-start3);
           PWM_setCmpB(myPwm3, 0);
           break;
       case -2:
           PWM_setCmpA(myPwm1, 0);
           PWM_setCmpB(myPwm1, stop1);
           PWM_setCmpA(myPwm2, 0);
           PWM_setCmpB(myPwm2, stop2);
           PWM_setCmpA(myPwm3, 0);
           PWM_setCmpB(myPwm3, -(a+start3));
           break;
       case 3:
           PWM_setCmpA(myPwm1, stop1);
           PWM_setCmpB(myPwm1, 0);
           PWM_setCmpA(myPwm2, stop2);
           PWM_setCmpB(myPwm2, 0);
           PWM_setCmpA(myPwm3, stop3);
           PWM_setCmpB(myPwm3, 0);
           break;
       case -3:
           PWM_setCmpA(myPwm1, 0);
           PWM_setCmpB(myPwm1, stop1);
           PWM_setCmpA(myPwm2, 0);
           PWM_setCmpB(myPwm2, stop2);
           PWM_setCmpA(myPwm3, 0);
           PWM_setCmpB(myPwm3, stop3);
           break;
       default:
           //sollte nur bei clipping auftreten
           break;
   }

    EPwm1TimerIntCount++;
    PWM_clearIntFlag(myPwm1);
    PIE_clearInt(myPie, PIE_GroupNumber_3);
}

//
// epwm2_isr -
//
__interrupt void
epwm2_isr(void)
{
    EPwm2TimerIntCount++;
    PWM_clearIntFlag(myPwm2);
    PIE_clearInt(myPie, PIE_GroupNumber_3);
}

//
// epwm3_isr -
//
__interrupt void
epwm3_isr(void)
{
    EPwm3TimerIntCount++;

    PWM_clearIntFlag(myPwm3);
    PIE_clearInt(myPie, PIE_GroupNumber_3);
}

void
InitEPwm1()
{
    CLK_enablePwmClock(myClk, PWM_Number_1);

    PWM_setPeriod(myPwm1, EPWM1_MAX_DB);        // Set timer period
    PWM_setPhase(myPwm1, 0x0000);       // Phase is 0
    PWM_setCount(myPwm1, 0x0000);       // Clear counter
    //
    // Setup TBCLK
    //
    PWM_setCounterMode(myPwm1, PWM_CounterMode_UpDown); // Count up
    PWM_disableCounterLoad(myPwm1);             // Disable phase loading
    //
    // Clock ratio to SYSCLKOUT
    //
//    PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_4);
//    PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_4);
    PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_1);
    PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_1);

    //
    // Load registers every ZERO
    //
    PWM_setShadowMode_CmpA(myPwm1, PWM_ShadowMode_Shadow);
    PWM_setShadowMode_CmpB(myPwm1, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm1, PWM_LoadMode_Zero);
    PWM_setLoadMode_CmpB(myPwm1, PWM_LoadMode_Zero);
    //
    // Setup compare
    //
    PWM_setCmpA(myPwm1, 3000);
    PWM_setCmpB(myPwm1, 3000);

    //
    // Set actions
    //
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm1, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm1, PWM_ActionQual_Set);
    PWM_setActionQual_CntUp_CmpB_PwmB(myPwm1, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpB_PwmB(myPwm1, PWM_ActionQual_Set);
    //
    // Active Low PWMs - Setup Deadband
    //
        PWM_setDeadBandOutputMode(myPwm1,
                              PWM_DeadBandOutputMode_Bypass);
    EPwm1_DB_Direction = DB_UP;
    //
    // Select INT on Zero event
    //
    PWM_setIntMode(myPwm1, PWM_IntMode_CounterEqualZero);
    PWM_enableInt(myPwm1);           // Enable INT
    //
    // Generate INT on 3rd event
    //
//    PWM_setIntPeriod(myPwm1, PWM_IntPeriod_ThirdEvent);

    PWM_setIntPeriod(myPwm1, PWM_IntPeriod_FirstEvent);
}

void
InitEPwm2()
{
    CLK_enablePwmClock(myClk, PWM_Number_2);

    PWM_setPeriod(myPwm2, EPWM2_MAX_DB);        // Set timer period
    PWM_setPhase(myPwm2, 0x0000);       // Phase is 0
    PWM_setCount(myPwm2, 0x0000);       // Clear counter
    //
    // Setup TBCLK
    //
    PWM_setCounterMode(myPwm2, PWM_CounterMode_UpDown); // Count up
    PWM_disableCounterLoad(myPwm2);             // Disable phase loading
    //
    // Clock ratio to SYSCLKOUT
    //
    PWM_setHighSpeedClkDiv(myPwm2, PWM_HspClkDiv_by_1);
    PWM_setClkDiv(myPwm2, PWM_ClkDiv_by_1);
    //
    // Load registers every ZERO
    //
    PWM_setShadowMode_CmpA(myPwm2, PWM_ShadowMode_Shadow);
    PWM_setShadowMode_CmpB(myPwm2, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm2, PWM_LoadMode_Zero);
    PWM_setLoadMode_CmpB(myPwm2, PWM_LoadMode_Zero);
    //
    // Setup compare
    //
    PWM_setCmpA(myPwm2, 3000);
    PWM_setCmpB(myPwm2, 3000);

    //
    // Set actions
    //
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm2, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm2, PWM_ActionQual_Set);
    PWM_setActionQual_CntUp_CmpB_PwmB(myPwm2, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpB_PwmB(myPwm2, PWM_ActionQual_Set);
    //
    // Active Low PWMs - Setup Deadband
    //
        PWM_setDeadBandOutputMode(myPwm2,
                              PWM_DeadBandOutputMode_Bypass);
    EPwm2_DB_Direction = DB_UP;
    //
    // Select INT on Zero event
    //
    PWM_setIntMode(myPwm2, PWM_IntMode_CounterEqualZero);
    PWM_enableInt(myPwm2);           // Enable INT
    //
    // Generate INT on 3rd event
    //
    PWM_setIntPeriod(myPwm2, PWM_IntPeriod_FirstEvent);
}

void
InitEPwm3()
{
    CLK_enablePwmClock(myClk, PWM_Number_3);

    PWM_setPeriod(myPwm3, EPWM3_MAX_DB);        // Set timer period
    PWM_setPhase(myPwm3, 0x0000);       // Phase is 0
    PWM_setCount(myPwm3, 0x0000);       // Clear counter
    //
    // Setup TBCLK
    //
    PWM_setCounterMode(myPwm3, PWM_CounterMode_UpDown); // Count up
    PWM_disableCounterLoad(myPwm3);             // Disable phase loading
    //
    // Clock ratio to SYSCLKOUT
    //
    PWM_setHighSpeedClkDiv(myPwm3, PWM_HspClkDiv_by_1);
    PWM_setClkDiv(myPwm3, PWM_ClkDiv_by_1);
    //
    // Load registers every ZERO
    //
    PWM_setShadowMode_CmpA(myPwm3, PWM_ShadowMode_Shadow);
    PWM_setShadowMode_CmpB(myPwm3, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm3, PWM_LoadMode_Zero);
    PWM_setLoadMode_CmpB(myPwm3, PWM_LoadMode_Zero);
    //
    // Setup compare
    //
    PWM_setCmpA(myPwm3, 3000);
    //
    // Set actions
    //
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm3, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm3, PWM_ActionQual_Set);
    PWM_setActionQual_CntUp_CmpB_PwmB(myPwm3, PWM_ActionQual_Clear);
    PWM_setActionQual_CntDown_CmpB_PwmB(myPwm3, PWM_ActionQual_Set);
    //

    //
    // Active Low PWMs - Setup Deadband
    //
    PWM_setDeadBandOutputMode(myPwm3,
                          PWM_DeadBandOutputMode_Bypass);
    EPwm3_DB_Direction = DB_UP;

    //
    // Select INT on Zero event
    //
    PWM_setIntMode(myPwm3, PWM_IntMode_CounterEqualZero);
    PWM_enableInt(myPwm3);           // Enable INT
    //
    // Generate INT on 3rd event
    //
    PWM_setIntPeriod(myPwm3, PWM_IntPeriod_ThirdEvent);
}

//
// delay_loop - Some Useful local functions
//
void
delay_loop()
{
    long      i;

    for (i = 0; i < 1000000; i++)
    {

    }

    return;
}


//
// error -
//
void
error(void)
{
    __asm("     ESTOP0");     //Test failed!! Stop!
    for (;;)
    {
        __asm(" NOP");
    }
}

//
// spi_init -
//
void
spi_init()
{
    CLK_enableSpiaClock(myClk);

    //
    // Reset on, rising edge, 16-bit char bits
    //
    SPI_setCharLength(mySpi, SPI_CharLength_16_Bits);

    //
    // Enable master mode, normal phase, enable talk, and SPI int disabled.
    //
    SPI_setMode(mySpi, SPI_Mode_Slave);
    SPI_enableTx(mySpi);

    SPI_setBaudRate(mySpi, SPI_BaudRate_1_MBaud);

    //
    // Relinquish SPI from Reset
    //
    SPI_enableLoopBack(mySpi);
    SPI_enable(mySpi);

    //
    // Set so breakpoints don't disturb xmission
    //
    SPI_setPriority(mySpi, SPI_Priority_FreeRun);

    return;
}

//
// spi_fifo_init -
//
void
spi_fifo_init()
{
    //
    // Initialize SPI FIFO registers
    //
    SPI_enableChannels(mySpi);
    SPI_enableFifoEnh(mySpi);
    SPI_resetTxFifo(mySpi);
    SPI_clearTxFifoInt(mySpi);
    SPI_resetRxFifo(mySpi);
    SPI_clearRxFifoInt(mySpi);
    SPI_setRxFifoIntLevel(mySpi, SPI_FifoLevel_4_Words);

    return;
}


//
// End of File
//