Simon/DSP-Board
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Software c2000 hinzugefügt

Browse source 
4fach Multilevel-PWM mit i2S Empfang
This commit is contained in:
Simon 2025-04-05 10:30:58 +02:00
parent 278ef151c2
commit 2dd2cef347
1 changed files with 856 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

856
software/ADC_PWM_SPI_SLAVE.c Normal file
View file

@ -0,0 +1,856 @@
//#############################################################################
//
// 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
//