|
//
// TMDX ALPHA RELEASE
// Intended for product evaluation purposes
//
//###########################################################################
//
// FILE: DSP28_28xFlash.c
//
// TITLE: DSP28 Flash example.
//
// ASSUMPTIONS:
//
// This program requires the DSP28 header files. To compile the
// program as is, it should reside in the DSP28/examples/flash
// sub-directory.
//
// As supplied, this project is configured for "boot to Flash" operation.
//
// DESCRIPTION:
//
// This example runs the EV Timer Period example from the
// Flash.
//
// 1) Build the project
// 2) Flash the .out file into the device. This program will fit on
// an F2812 or an F2810
// 3) Set the hardware jumpers to boot to Flash
// 4) Use the included GEL file to load the project, symbols
// defined within the project and the variables into the watch
// window.
//
// This program sets up EVA Timer 1, EVA Timer 2, EVB Timer 3
// and EVB Timer 4 to fire an interrupt on a period overflow.
// A count is kept each time each interrupt passes through
// the interrupt service routine.
//
// EVA Timer 1 has the shortest period while EVB Timer4 has the
// longest period.
//
// ISR Locations:
// eva_timer1_isr executed from RAM, puts flash in sleep mode
// eva_timer2_isr executed from RAM, puts flash in standby mode
// evb_timer3_isr executed from RAM, puts flash in sleep mode
// and later moves it to standby
// evb_timer4_isr executed from FLASH
//
// Watch Variables:
//
// EvaTimer1InterruptCount;
// EvaTimer2InterruptCount;
// EvbTimer3InterruptCount;
// EvbTimer4InterruptCount;
//
//###########################################################################
//
// Ver | dd mmm yyyy | Who | Description of changes
// =====|=============|======|===============================================
// 0.58| 28 Jun 2002 | L.H. | First Release
//###########################################################################
// Step 0. Include required header files
// DSP28_Device.h: device specific definitions #include statements for
// all of the peripheral .h definition files.
// DSP28_Example.h is specific for the given example.
#include "DSP28_Device.h"
// Functions that will be run from RAM need to be assigned to
// a different section. This section will then be mapped using
// the linker cmd file.
#pragma CODE_SECTION(eva_timer1_isr, "ramfuncs");
#pragma CODE_SECTION(eva_timer2_isr, "ramfuncs");
#pragma CODE_SECTION(evb_timer3_isr, "ramfuncs");
// Information on the location of functions that are going
// to be relocated to RAM
#define RAM_FUNC_LOAD 0x3EC000 // Source location in Flash
#define RAM_FUNC_LENGTH 0x000080 // Number of 32-bit values to copy
#define RAM_FUNC_RUN 0x008000 // Destination location in RAM
// Prototype statements for functions found within this file.
interrupt void eva_timer1_isr(void);
interrupt void eva_timer2_isr(void);
interrupt void evb_timer3_isr(void);
interrupt void evb_timer4_isr(void);
// Global counts used in this example
Uint32 EvaTimer1InterruptCount;
Uint32 EvaTimer2InterruptCount;
Uint32 EvbTimer3InterruptCount;
Uint32 EvbTimer4InterruptCount;
Uint32 LoopCount;
void main(void)
{
Uint32 * pSourceAddr;
Uint32 * pDestAddr;
Uint16 i;
// Step 1. Initialize System Control registers, PLL, WatchDog, Clocks to default state:
// This function is found in the DSP28_SysCtrl.c file.
InitSysCtrl();
// Step 2. Select GPIO for the device or for the specific application:
// This function is found in the DSP28_Gpio.c file.
// InitGpio(); // Skip for this test
// Step 3. Initialize PIE vector table:
// The PIE vector table is initialized with pointers to shell Interrupt
// Service Routines (ISR). The shell routines are found in DSP28_DefaultIsr.c.
// Insert user specific ISR code in the appropriate shell ISR routine in
// the DSP28_DefaultIsr.c file.
// Disable and clear all CPU interrupts:
DINT;
IER = 0x0000;
IFR = 0x0000;
// Initialize Pie Control Registers To Default State:
// This function is found in the DSP28_PieCtrl.c file.
InitPieCtrl();
// Initialize the PIE Vector Table To a Known State:
// This function is found in DSP28_PieVect.c.
// This function populates the PIE vector table with pointers
// to the shell ISR functions found in DSP28_DefaultIsr.c.
InitPieVectTable();
// Step 4. Initialize all the Device Peripherals to a known state:
// This function is found in DSP28_InitPeripherals.c
// InitPeripherals();
// Step 5. User specific functions, Reassign vectors (optional), Enable Interrupts:
// Copy time critical code and Flash setup code to RAM
// This includes the following ISR functions: EvaTimer1(), EvaTimer2()
// EvbTimer3 and and InitFlash();
pSourceAddr = (Uint32 *)RAM_FUNC_LOAD;
pDestAddr = (Uint32 *)RAM_FUNC_RUN;
for(i = 0; i < RAM_FUNC_LENGTH; i++)
{
*pDestAddr++ = *pSourceAddr++;
}
// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM
InitFlash();
// Initialize count values to 0
EvaTimer1InterruptCount = 0;
EvaTimer2InterruptCount = 0;
EvbTimer3InterruptCount = 0;
EvbTimer4InterruptCount = 0;
LoopCount = 0;
// Initialize EVA Timer 1:
// Setup Timer 1 Registers (EV A)
EvaRegs.GPTCONA.all = 0;
// Set the Period for the GP timer 1 to 0x0200;
EvaRegs.T1PR = 0x0200; // Period
EvaRegs.T1CMPR = 0x0000; // Compare Reg
// Enable Period interrupt bits for GP timer 1
// Count up, x128, internal clk, enable compare, use own period
EvaRegs.EVAIMRA.bit.T1PINT = 1;
EvaRegs.EVAIFRA.bit.T1PINT = 1;
// Clear the counter for GP timer 1
EvaRegs.T1CNT = 0x0000;
EvaRegs.T1CON.all = 0x1742;
// Start EVA ADC Conversion on timer 1 Period interrupt
EvaRegs.GPTCONA.bit.T1TOADC = 2;
// Initialize EVA Timer 2:
// Setup Timer 2 Registers (EV A)
EvaRegs.GPTCONA.all = 0;
// Set the Period for the GP timer 2 to 0x0200;
EvaRegs.T2PR = 0x0400; // Period
EvaRegs.T2CMPR = 0x0000; // Compare Reg
// Enable Period interrupt bits for GP timer 2
// Count up, x128, internal clk, enable compare, use own period
EvaRegs.EVAIMRB.bit.T2PINT = 1;
EvaRegs.EVAIFRB.bit.T2PINT = 1;
// Clear the counter for GP timer 2
EvaRegs.T2CNT = 0x0000;
EvaRegs.T2CON.all = 0x1742;
// Start EVA ADC Conversion on timer 2 Period interrupt
EvaRegs.GPTCONA.bit.T2TOADC = 2;
// Initialize EVB Timer 3:
// Setup Timer 3 Registers (EV B)
EvbRegs.GPTCONB.all = 0;
// Set the Period for the GP timer 3 to 0x0200;
EvbRegs.T3PR = 0x0800; // Period
EvbRegs.T3CMPR = 0x0000; // Compare Reg
// Enable Period interrupt bits for GP timer 3
// Count up, x128, internal clk, enable compare, use own period
EvbRegs.EVBIMRA.bit.T3PINT = 1;
EvbRegs.EVBIFRA.bit.T3PINT = 1;
// Clear the counter for GP timer 3
EvbRegs.T3CNT = 0x0000;
EvbRegs.T3CON.all = 0x1742;
// Start EVA ADC Conversion on timer 3 Period interrupt
EvbRegs.GPTCONB.bit.T3TOADC = 2;
// Initialize EVB Timer 4:
// Setup Timer 4 Registers (EV B)
EvbRegs.GPTCONB.all = 0;
// Set the Period for the GP timer 4 to 0x0200;
EvbRegs.T4PR = 0x1000; // Period
EvbRegs.T4CMPR = 0x0000; // Compare Reg
// Enable Period interrupt bits for GP timer 4
// Count up, x128, internal clk, enable compare, use own period
EvbRegs.EVBIMRB.bit.T4PINT = 1;
EvbRegs.EVBIFRB.bit.T4PINT = 1;
// Clear the counter for GP timer 4
EvbRegs.T4CNT = 0x0000;
EvbRegs.T4CON.all = 0x1742;
// Start EVA ADC Conversion on timer 4 Period interrupt
EvbRegs.GPTCONB.bit.T4TOADC = 2;
// Reassign ISRs.
// Reassign the PIE vector for T1PINT, T2PINT, T3PTINT,
// and T4PINT to point to a different
// ISR then the shell routine found in DSP28_DefaultIsr.c.
// This is done if the user does not want to use the shell ISR routine
// but instead wants to use their own ISR. This step is optional:
EALLOW; // This is needed to write to EALLOW protected registers
PieVectTable.T1PINT = &eva_timer1_isr;
PieVectTable.T2PINT = &eva_timer2_isr;
PieVectTable.T3PINT = &evb_timer3_isr;
PieVectTable.T4PINT = &evb_timer4_isr;
EDIS; // This is needed to disable write to EALLOW protected registers
// Enable PIE group 2 interrupt 4 for T1PINT
PieCtrlRegs.PIEIER2.all = M_INT4;
// Enable PIE group 3 interrupt 1 for T2PINT
PieCtrlRegs.PIEIER3.all = M_INT1;
// Enable PIE group 4 interrupt 4 for T3PINT
PieCtrlRegs.PIEIER4.all = M_INT4;
// Enable PIE group 5 interrupt 1 for T4PINT
PieCtrlRegs.PIEIER5.all = M_INT1;
// Enable CPU INT2 for T1PINT, INT3 for T2PINT, INT4 for T3PINT
// and INT5 for T4PINT:
IER |= (M_INT2 | M_INT3 | M_INT4 | M_INT5);
// Enable global Interrupts and higher priority real-time debug events:
EINT; // Enable Global interrupt INTM
ERTM; // Enable Global realtime interrupt DBGM
// Step 6. IDLE loop. Just sit and loop forever:
while(1)
{
LoopCount++;
}
}
// Step 7. Insert all local Interrupt Service Routines (ISRs) and functions here:
// If local ISRs are used, reassign vector addresses in vector table as
// shown in Step 5
// This ISR MUST be executed from RAM as it will put the Flash into Sleep
interrupt void eva_timer1_isr(void)
{
Uint16 i;
// Put the Flash to sleep
FlashRegs.FPWR.bit.PWR = FLASH_SLEEP;
EvaTimer1InterruptCount++;
// Short Delay to simulate some ISR Code
for(i = 1; i < 0x03FF; i++) {}
// Enable more interrupts from this timer
EvaRegs.EVAIMRA.bit.T1PINT = 1;
// Note: To be safe, use a mask value to write to the entire
// EVAIFRA register. Writing to one bit will cause a read-modify-write
// operation that may have the result of writing 1's to clear
// bits other then those intended.
EvaRegs.EVAIFRA.all = BIT7;
// Acknowledge interrupt to recieve more interrupts from PIE group 2
PieCtrlRegs.PIEACK.all = PIEACK_GROUP2;
}
// This ISR MUST be executed from RAM as it will put the Flash into Standby
interrupt void eva_timer2_isr(void)
{
Uint16 i;
// Put the Flash into standby
FlashRegs.FPWR.bit.PWR = FLASH_STANDBY;
EvaTimer2InterruptCount++;
// Short Delay to simulate some ISR Code
for(i = 1; i < 0x02FF; i++) {}
// Enable more interrupts from this timer
EvaRegs.EVAIMRB.bit.T2PINT = 1;
// Note: To be safe, use a mask value to write to the entire
// EVAIFRB register. Writing to one bit will cause a read-modify-write
// operation that may have the result of writing 1's to clear
// bits other then those intended.
EvaRegs.EVAIFRB.all = BIT0;
// Acknowledge interrupt to recieve more interrupts from PIE group 3
PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}
// This ISR MUST be executed from RAM as it will put the Flash to sleep
// and then later move it to Standby
interrupt void evb_timer3_isr(void)
{
Uint16 i;
// Put the Flash to sleep
FlashRegs.FPWR.bit.PWR = FLASH_SLEEP;
EvbTimer3InterruptCount++;
// Short Delay to simulate some ISR Code
for(i = 1; i < 0x01FF; i++) {}
// Sometime later, move the Flash to standby
FlashRegs.FPWR.bit.PWR = FLASH_STANDBY;
// Note: To be safe, use a mask value to write to the entire
// EVBIFRA register. Writing to one bit will cause a read-modify-write
// operation that may have the result of writing 1's to clear
// bits other then those intended.
EvbRegs.EVBIFRA.all = BIT7;
// Acknowledge interrupt to recieve more interrupts from PIE group 4
PieCtrlRegs.PIEACK.all = PIEACK_GROUP4;
}
// This ISR will be executed out of Flash
interrupt void evb_timer4_isr(void)
{
Uint16 i;
EvbTimer4InterruptCount++;
// Short Delay to simulate some ISR Code
for(i = 1; i < 0x00FF; i++) {}
// Note: To be safe, use a mask value to write to the entire
// EVBIFRB register. Writing to one bit will cause a read-modify-write
// operation that may have the result of writing 1's to clear
// bits other then those intended.
EvbRegs.EVBIFRB.all = BIT0;
// Acknowledge interrupt to recieve more interrupts from PIE group 5
PieCtrlRegs.PIEACK.all = PIEACK_GROUP5;
}
//===========================================================================
// No more.
//===========================================================================
|
