diff --git a/software/ADC_PWM_SPI_SLAVE.c b/software/ADC_PWM_SPI_SLAVE.c new file mode 100644 index 0000000..d3cfdd4 --- /dev/null +++ b/software/ADC_PWM_SPI_SLAVE.c @@ -0,0 +1,856 @@ +//############################################################################# +// +// File: Example_F2802xAdc_TempSensorConv.c +// +// Title: Example ADC Temperature Sensor Conversion to Degrees +// Celsius/Degrees Kelvin +// +//! \addtogroup example_list +//!

ADC Temperature Sensor Conversion

+//! +//! 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 +// + +