// TI File $Revision: /main/2 $
// Checkin $Date: July 30, 2009   18:45:31 $
//###########################################################################
//// FILE:    Example_2833xSci_Echoback.c
//
// TITLE:   DSP2833x Device SCI Echoback.
//
// ASSUMPTIONS:
//
//    This program requires the DSP2833x header files.
//    As supplied, this project is configured for "boot to SARAM" operation.
//
//    Connect the SCI-A port to a PC via a transciever and cable.
//    The PC application 'hypterterminal' can be used to view the data
//    from the SCI and to send information to the SCI.  Characters recieved
//    by the SCI port are sent back to the host.
//
//    As supplied, this project is configured for "boot to SARAM"
//    operation.  The 2833x Boot Mode table is shown below.
//    For information on configuring the boot mode of an eZdsp,

//    please refer to the documentation included with the eZdsp,
//       $Boot_Table:
//
//         GPIO87   GPIO86     GPIO85   GPIO84
//          XA15     XA14       XA13     XA12
//           PU       PU         PU       PU
//        ==========================================
//            1        1          1        1    Jump to Flash

//            1        1          1        0    SCI-A boot

//            1        1          0        1    SPI-A boot

//            1        1          0        0    I2C-A boot


//            1        0          1        1    eCAN-A boot
//            1        0          1        0    McBSP-A boot

//            1        0          0        1    Jump to XINTF x16

//            1        0          0        0    Jump to XINTF x32
//            0        1          1        1    Jump to OTP

//            0        1          1        0    Parallel GPIO I/O boot

//            0        1          0        1    Parallel XINTF boot


//            0        1          0        0    Jump to SARAM       <- "boot to SARAM"

//            0        0          1        1    Branch to check boot mode


//            0        0          1        0    Boot to flash, bypass ADC cal


//            0        0          0        1    Boot to SARAM, bypass ADC cal

//            0        0          0        0    Boot to SCI-A, bypass ADC cal

//                                              Boot_Table_End$
//
// DESCRIPTION:
//
//

//    This test recieves and echo-backs data through the SCI-A port.
//

//    1) Configure hyperterminal:

//       Use the included hyperterminal configuration file SCI_96.ht.
//       To load this configuration in hyperterminal: file->open

//       and then select the SCI_96.ht file.

//    2) Check the COM port.

//       The configuration file is currently setup for COM1.

//       If this is not correct, disconnect Call->Disconnect
//       Open the File-Properties dialog and select the correct COM port.

//    3) Connect hyperterminal Call->Call
//       and then start the 2833x SCI echoback program execution.

//    4) The program will print out a greeting and then ask you to

//       enter a character which it will echo back to hyperterminal.


//

//    As is, the program configures SCI-A for 9600 baud with


//    SYSCLKOUT = 150MHz and LSPCLK = 37.5 MHz
//    SYSCLKOUT = 100MHz and LSPCLK = 25.0 Mhz

//

//
//    Watch Variables:

//       LoopCount for the number of characters sent

//       ErrorCount

//###########################################################################
// $TI Release: 2833x/2823x Header Files V1.32 $
// $Release Date: June 28, 2010 $
//###########################################################################
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
// Prototype statements for functions found within this file.
void scib_echoback_init(void);
void scib_fifo_init(void);
interrupt void scib_rx_isr(void);
void scib_msg(char *msg);
void scib_xmit(int a);

//Global counts used in this example
Uint16 LoopCount;
Uint16 ErrorCount;
Uint16 b,c,d,e,f,g,h,j=0, ans;
volatile Uint16 a=0;
//Uint16 factor;
float voltage,Vb;
float v[50];
Uint16 number=0x0;
void main(void)

{
    int i,l=0,j=0;
    char *msg;

   // Step 1. Initialize System Control:
 // PLL, WatchDog, enable Peripheral Clocks

    // This example function is found in the DSP2833x_SysCtrl.c file.


   InitSysCtrl();


  // Step 2. Initalize GPIO:



    // This example function is found in the DSP2833x_Gpio.c file and

    // illustrates how to set the GPIO to it's default state.

   // InitGpio(); Skipped for this example

// For this example, only init the pins for the SCI-A port.

 // This function is found in the DSP2833x_Sci.c file.

  InitScibGpio();
//Step 3. Clear all interrupts and initialize PIE vector table:
 // Disable CPU interrupts
 DINT;
// Initialize 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 DSP2833x_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 DSP2833x_DefaultIsr.c.
// This function is found in DSP2833x_PieVect.c.
  InitPieVectTable();
   // Step 4. Initialize all the Device Peripherals:
   // This function is found in DSP2833x_InitPeripherals.c
 // InitPeripherals(); // Not required for this example
 EnableInterrupts();
  // Step 5. User specific code:

 LoopCount = 0;

 ErrorCount = 0;
   // factor = 0x2710;

  scib_fifo_init();      // Initialize the SCI FIFO
  scib_echoback_init();  // Initalize SCI for echoback
  msg = "\nNew Data:";

  for(;;)

   {
      scib_msg(msg);
    // Wait for inc character
       while(ScibRegs.SCIFFRX.bit.RXFFST !=0) { } // wait for RXDY =1 for empty state,i.e until FIFO has one word
       //DELAY_US(1000000);
    a = ScibRegs.SCIRXBUF.all;
       // Get character
    if (a != '\0') // wait till transmission starts ,note that null condition will stand true even
                  //if voltage data sends zero,to avoid that the flag bits being sent are other then zero
    {

     d=a & 0x70; // extracts the flag bitset at the tranciever to identify the bit(MSB/LSB)

        c=a & 0x0F; // extracts the actual databit

    if(d==0x40)  // MSB i.e. bit b3
    {
        e=c*0x03E8;
        l++;
    }
    if(d==0x30)  //bit b2
    {
        f=c*0x64;
        l++;
    }
    if(d==0x20) //bit b1
    {
        g=c*0xA;
        l++;
    }
    if(d==0x10) //bit b0
    {
        h=c*0x01;
        l++;
    }
    ans=e+f+g+h;
  if(l==4)
  {

    voltage = (ans * 3.3)/4096;
    Vb = voltage/0.04324;
    if(j<51)
    {
    v[j]= Vb;
    j++;
    }
    else
    {
        j=0;
        v[j]= Vb;
        j++;
    }
    l=0;

 }
        LoopCount++;

    }

    }
}

// Test 1,SCIA  DLB, 8-bit word, baud rate 0x000F, default, 1 STOP bit, no parity
void scib_echoback_init()
   // Note: Clocks were turned on to the SCIA peripheral // in the InitSysCtrl() function
{
   ScibRegs.SCICCR.all =0x0007;   // 1 stop bit,  No loopback
                                    // No parity,8 char bits,
                                        // async mode, idle-line protocol
  ScibRegs.SCICTL1.all =0x0001;  // disable TX, enable RX, internal SCICLK,(earlier 0003 correct one)
                                  // Disable RX ERR, SLEEP, TXWAKE
  ScibRegs.SCICTL2.all =0x0002;    // initially the correct oneis 0003
                                      //ScibRegs.SCICTL2.bit.TXINTENA =1;
   ScibRegs.SCICTL2.bit.RXBKINTENA =1;

#if (CPU_FRQ_150MHZ)
   ScibRegs.SCIHBAUD    =0x0001;  // 9600 baud @LSPCLK = 37.5MHz.
   ScibRegs.SCILBAUD    =0x00E7;
#endif
#if (CPU_FRQ_100MHZ)
    ScibRegs.SCIHBAUD    =0x0001;  // 9600 baud @LSPCLK = 20MHz.
    ScibRegs.SCILBAUD    =0x0044;
#endif


    ScibRegs.SCICTL1.all =0x0021;  // Relinquish SCI from Reset(initially 0023)

}


// Transmit a character from the SCI
void scib_xmit(int a)
{
   while (ScibRegs.SCIFFTX.bit.TXFFST != 0) {}
     ScibRegs.SCITXBUF=a;
}
// Initalize the SCI FIFO
void scib_msg(char *msg)
{
    int i=0;
    while(msg[i] != '\0')
    {
        scib_xmit(msg[i]);
        i++;
    }
}
void scib_fifo_init()
{
    // ScibRegs.SCIFFTX.all=0xE040;

   ScibRegs.SCIFFRX.all=0x204f;
   ScibRegs.SCIFFCT.all=0x0;

}