//###########################################################################
//
// FILE:    Example_281xEV.c
//
// TITLE:   DSP281x EV  transmission and reception in 
//          SELF-TEST mode or generally mode
//
// ASSUMPTIONS:
//
//          This program requires the DSP281x V1.00 header files.  
//          As supplied, this project is configured for "boot to H0" operation.
//
//          Other then boot mode configuration, no other hardware configuration
//          is required.    
//
// DESCRIPTION:
//
//          This test transmits data back-to-back at high speed without 
//          stopping.
//          The received data is verified. Any error is flagged. 
//          MBX0 transmits to MBX16, MBX1 transmits to MBX17 and so on....
//          This program illustrates the use of self-test mode
//
//###########################################################################
//
//  Ver | dd mmm yyyy | Who  | Description of changes
// =====|=============|======|===============================================
//  1.00| 11 Sep 2003 | L.H. | Original Author H.J.
//      |             |      | Changes since previous version (v.58 Alpha)
//      |             |      | Updated to reflect bit name corrections in 
//      |             |      |    the DSP281x_ECan.h file
//###########################################################################

#include "DSP281x_Device.h"     // DSP281x Headerfile Include File
#include "DSP281x_Examples.h"   // DSP281x Examples Include File
// 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);
interrupt void eva_cap1_isr(void);
interrupt void eva_cap2_isr(void);

void init_eva_timer1(void);
void init_eva_timer2(void);
void init_evb_timer3(void);
void init_evb_timer4(void);
void init_eva_capa(void);
// Global counts used in this example
Uint32  EvaTimer1InterruptCount;
Uint32  EvaTimer2InterruptCount;
Uint32  EvbTimer3InterruptCount;
Uint32  EvbTimer4InterruptCount;

void init_eva_timer1(void)
{
    // 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 = 0xffff;       // Period
    EvaRegs.T1CMPR = 0xffff;     // Compare Reg
   
    // Enable Period interrupt bits for GP timer 1
    // Count up, x64, internal clk, disable 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 = 0x1640;

    // Start EVA ADC Conversion on timer 1 Period interrupt
//    EvaRegs.GPTCONA.bit.T1TOADC = 2;

}

void init_eva_timer2(void)
{
    // 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;
}



void init_evb_timer3(void)
{
    // 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;
}

void init_evb_timer4(void)
{
    // 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;
} 




void init_eva_capa(void)
{
    EvaRegs.CAP1FIFO = 0;  //CAP1 FIFO STACK
    EvaRegs.CAP2FIFO = 0;  //CAP2 FIFO STACK
    
    EvaRegs.CAP1FBOT = 0;  //botm register of capture fifo stack
    EvaRegs.CAP2FBOT = 0;  //botm register of capture fifo stack
    
    EvaRegs.CAPCONA.bit.CAPRES=0; // capture reset  clear all register of capture
    EvaRegs.CAPCONA.bit.CAP12EN=01;// enable capture 1 and 2
    EvaRegs.CAPCONA.bit.CAP12TSEL=1;// select GP timer1 
    EvaRegs.CAPCONA.bit.CAP1EDGE=01;//detects rising edge cap1
    EvaRegs.CAPCONA.bit.CAP2EDGE=01;//detects rising edge cap2

    EvaRegs.EVAIMRC.bit.CAP1INT=1;//enable cap1
    EvaRegs.EVAIMRC.bit.CAP2INT=1;//enable cap2
    EvaRegs.EVAIFRC.bit.CAP1INT=1;//clear flag
    EvaRegs.EVAIFRC.bit.CAP2INT=1;//clear flag

//    EvaRegs.CAPCONA.bit.CAPRES=1; // 
}

interrupt void eva_timer1_isr(void)
{
   EvaTimer1InterruptCount++;

   // 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 receive more interrupts from PIE group 2
   PieCtrlRegs.PIEACK.all = PIEACK_GROUP2;
}

interrupt void eva_timer2_isr(void)
{
  EvaTimer2InterruptCount++;
  // 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 receive more interrupts from PIE group 3
  PieCtrlRegs.PIEACK.all = PIEACK_GROUP3;
}

interrupt void evb_timer3_isr(void)
{
  EvbTimer3InterruptCount++;
  // 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 receive more interrupts from PIE group 4
  PieCtrlRegs.PIEACK.all = PIEACK_GROUP4;
}

interrupt void evb_timer4_isr(void)
{
   EvbTimer4InterruptCount++;
   // 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 receive more interrupts from PIE group 5
   PieCtrlRegs.PIEACK.all = PIEACK_GROUP5;

}

//===========================================================================
// No more.
//===========================================================================