__interrupt void EPWM1_INT_ISR(void) // EPwm1 Interrupt
{
// Set interrupt priority:
volatile uint16_t TempPIEIER = PIE_getIntEnables(myPie, PIE_GroupNumber_3);
CPU_enableInt(myCpu, CPU_IntNumber_3);
CPU_disableInt(myCpu, (CPU_IntNumber_e) ~MINT3); // Set "global" priority
PIE_disableInt(myPie, PIE_GroupNumber_3, (PIE_InterruptSource_e) ~MG31); // Set "group" priority
PIE_clearAllInts(myPie); // Enable PIE interrupts
__asm(" NOP");
CPU_enableGlobalInts(myCpu);
// Insert ISR Code here.......
for(i = 1; i <= 10; i++) {}
// Restore registers saved:
CPU_disableGlobalInts(myCpu);
PIE_enableInt(myPie, PIE_GroupNumber_3, (PIE_InterruptSource_e)TempPIEIER);
// Add ISR to Trace
ISRTrace[ISRTraceIndex] = 0x0031;
ISRTraceIndex++;
}
__interrupt void ADCINT3_ISR(void) // ADC
{
// Set interrupt priority:
volatile uint16_t TempPIEIER = PIE_getIntEnables(myPie, PIE_GroupNumber_10);
CPU_enableInt(myCpu, CPU_IntNumber_10);
CPU_disableInt(myCpu, (CPU_IntNumber_e) ~MINT10); // Set "global" priority
PIE_disableInt(myPie, PIE_GroupNumber_10, (PIE_InterruptSource_e) ~MG103); // Set "group" priority
PIE_clearAllInts(myPie); // Enable PIE interrupts
__asm(" NOP");
CPU_enableGlobalInts(myCpu);
// Insert ISR Code here.......
__asm(" NOP");
// Restore registers saved:
CPU_disableGlobalInts(myCpu);
PIE_enableInt(myPie, PIE_GroupNumber_10, (PIE_InterruptSource_e)TempPIEIER);
// Add ISR to Trace
ISRTrace[ISRTraceIndex] = 0x0103;
ISRTraceIndex++;
}
void init_i2c(){
EALLOW;
// Enable Clock routing to the I2C Module
SysCtrlRegs.PCLKCR0.bit.I2CAENCLK = 1;
EDIS;
///////////////////////////////////////////////
/////// GPIO Setup //////////
////// SDA: GPIO28, SCLL GPIO29 //////////
///////////////////////////////////////////////
//Pull-ups are enabled here for ease of debugging. DISABLE pullups for production -- They are are on the master side!!!
GPIO_setPullUp(myGpio,GPIO_Number_28, GPIO_PullUp_Disable);
GPIO_setPullUp(myGpio,GPIO_Number_29, GPIO_PullUp_Disable);
// Set qualifications type on SDA and SCL to async (digital signals from another micro don't need multiple validations)
GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
GPIO_setQualification(myGpio, GPIO_Number_29, GPIO_Qual_ASync);
// Setup GPIO Modes
GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SDDA);
GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCLA);
///////////////////////////////////////////////
////////// Interrupt Setup //////////////
//////////////////////////////////////////////
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_8, PIE_SubGroupNumber_1, (intVec_t)&i2c_int1);
PIE_enableInt(myPie, PIE_GroupNumber_8, PIE_InterruptSource_I2CA1);
CPU_enableInt(myCpu,CPU_IntNumber_8); // Enable the CPU interrupt that is responsible for this PIE group
// Clear all status bits for the i2c module (reset)
I2caRegs.I2CMDR.bit.IRS = 0; // Technically this triggers a i2c reset
// Enable i2c "addressed as slave" interrupt
I2caRegs.I2CIER.bit.AAS = 1;
// Enable the XRDYINT (Transmit read condition interrupt). Enabled so I can see if data is getting to the transmit shift register
I2caRegs.I2CIER.bit.XRDY = 1;
// Change Clock divider
I2caRegs.I2CPSC.all = 2; // Prescaler - set to 128 giving module clk of SYSCLKOUT/129 => 465kHz
// More clock stuff here
I2caRegs.I2CCLKL = 5; // NOTE: must be non zero
I2caRegs.I2CCLKH = 5; // NOTE: must be non zero
// Setup the i2c module in slave mode
I2caRegs.I2CMDR.bit.MST = 0;
// Setup the i2c module as a receiver (so now we are in slave-reciever mode)
I2caRegs.I2CMDR.bit.TRX = 0;
// 7BIT address mode
I2caRegs.I2CMDR.bit.XA = 0;
// 8bit data mode
I2caRegs.I2CMDR.bit.BC = 0;
I2caRegs.I2CIER.bit.RRDY = 1; // Enable Receive Interrupt
// Set i2c address of this module
I2caRegs.I2COAR = 0x50;
I2caRegs.I2CCNT = 4; // Get/send 4 bytes
I2caRegs.I2CDXR = 0xF5; // Fill the transmission buffer
// Re-Enable the Module now that configuration is done
I2caRegs.I2CMDR.bit.IRS = 1;
}
void main(void)
{
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;
// Initialize all the handles needed for this application
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));
myPwm4 = PWM_init((void *)PWM_ePWM4_BASE_ADDR, sizeof(PWM_Obj));
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
// Perform basic system initialization
WDOG_disable(myWDog);
CLK_enableAdcClock(myClk);
(*Device_cal)();
CLK_disableAdcClock(myClk);
//Select the internal oscillator 1 as the clock source
CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
// Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2
PLL_setup(myPll, PLL_Multiplier_12, 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
// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the f2802x_SysCtrl.c file.
// InitSysCtrl();
// Step 2. Initialize GPIO:
// This example function is found in the f2802x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio(); // Skipped for this example
// InitEPwmGpio();
// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
// DINT;
// Initialize the PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the f2802x_PieCtrl.c file.
// InitPieCtrl();
// Disable CPU interrupts and clear all CPU interrupt flags:
// IER = 0x0000;
// IFR = 0x0000;
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example. This is useful for debug purposes.
// The shell ISR routines are found in f2802x_DefaultIsr.c.
// This function is found in f2802x_PieVect.c.
// InitPieVectTable();
// For this case just init GPIO pins for EPwm1, EPwm2, EPwm3, EPwm4
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);
// Setup a debug vector table and enable the PIE
PIE_setDebugIntVectorTable(myPie);
PIE_enable(myPie);
// Step 4. Initialize the Device Peripherals:
CLK_enablePwmClock(myClk, PWM_Number_1);
CLK_enablePwmClock(myClk, PWM_Number_2);
CLK_enablePwmClock(myClk, PWM_Number_3);
CLK_enablePwmClock(myClk, PWM_Number_4);
CLK_enableHrPwmClock(myClk);
// For this example, only initialize the ePWM
// Step 5. User specific code, enable interrupts:
// Calling SFO() updates the HRMSTEP register with calibrated MEP_ScaleFactor.
// HRMSTEP must be populated with a scale factor value prior to enabling
// high resolution period control.
status = SFO_INCOMPLETE;
while (status== SFO_INCOMPLETE) // Call until complete
{
status = SFO();
if (status == SFO_ERROR)
{
error(); // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
} // exceeds maximum of 255.
}
// Some useful PWM period vs Frequency values
// TBCLK = 60 MHz
//===================
// Period Freq
// 1000 30 KHz
// 800 37.5 KHz
// 600 50 KHz
// 500 60 KHz
// 250 120 KHz
// 200 150 KHz
// 100 300 KHz
// 50 600 KHz
// 30 1 MHz
// 25 1.2 MHz
// 20 1.5 MHz
// 12 2.5 MHz
// 10 3 MHz
// 9 3.3 MHz
// 8 3.8 MHz
// 7 4.3 MHz
// 6 5.0 MHz
// 5 6.0 MHz
//====================================================================
// ePWM and HRPWM register initialization
//====================================================================
Period = 500;
PeriodFine=0xFFBF;
CLK_disableTbClockSync(myClk);
HRPWM_Config(myPwm1, Period, 1);
HRPWM_Config(myPwm2, Period, 0);
HRPWM_Config(myPwm3, Period, 0);
HRPWM_Config(myPwm4, Period, 0);
CLK_enableTbClockSync(myClk);
// Software Control variables
Increment_Freq = 1;
Increment_Freq_Fine = 1;
IsrTicker = 0;
UpdatePeriod = 0;
UpdatePeriodFine = 0;
// User control variables:
UpdateCoarse = 0;
UpdateFine = 1;
// Reassign ISRs.
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1,
(intVec_t)&MainISR);
// Enable PIE group 3 interrupt 1 for EPWM1_INT
PIE_enableInt(myPie, PIE_GroupNumber_3, PIE_InterruptSource_EPWM1);
// Enable CNT_zero interrupt using EPWM1 Time-base
PWM_setIntMode(myPwm1, PWM_IntMode_CounterEqualZero); // Select INT on Zero event
PWM_enableInt(myPwm1); // Enable INT
PWM_setIntPeriod(myPwm1, PWM_IntPeriod_FirstEvent); // Generate INT on 3rd event
PWM_clearIntFlag(myPwm1);
// Enable CPU INT3 for EPWM1_INT:
CPU_enableInt(myCpu, CPU_IntNumber_3);
// Enable global Interrupts and higher priority real-time debug events:
CPU_enableGlobalInts(myCpu);
CPU_enableDebugInt(myCpu);
PWM_forceSync(myPwm1); // Synchronize high resolution phase to start HR period
for(;;)
{
// The below code controls coarse edge movement
if(UpdateCoarse==1)
{
if(Increment_Freq==1) //Increase frequency to 600 kHz
Period= Period - 1;
else
Period= Period + 1; //Decrease frequency to 300 kHz
if(Period<100 && Increment_Freq==1)
Increment_Freq=0;
else if(Period>500 && Increment_Freq==0)
Increment_Freq=1;
UpdatePeriod=1;
}
// The below code controls high-resolution fine edge movement
if(UpdateFine==1)
{
if(Increment_Freq_Fine==1) // Increase high-resolution frequency
PeriodFine=PeriodFine-1;
else
PeriodFine=PeriodFine+1; // Decrement high-resolution frequency
if(PeriodFine<=0x3333 && Increment_Freq_Fine==1)
Increment_Freq_Fine=0;
else if(PeriodFine>= 0xFFBF && Increment_Freq_Fine==0)
Increment_Freq_Fine=1;
UpdatePeriodFine=1;
}
// Call the scale factor optimizer lib function SFO()
// periodically to track for any change due to temp/voltage.
// This function generates MEP_ScaleFactor by running the
// MEP calibration module in the HRPWM logic. This scale
// factor can be used for all HRPWM channels. HRMSTEP
// register is automatically updated by the SFO function.
status = SFO(); // in background, MEP calibration module continuously updates MEP_ScaleFactor
if (status == SFO_ERROR)
{
error(); // SFO function returns 2 if an error occurs & # of MEP steps/coarse step
} // exceeds maximum of 255.
}
}// end main