C2000 LAUNCHPAD

C2000 Launchpad Unboxing

In the above video the descriptions about the C2000 Launchpad would have been explained .

The Schematic Diagram of the Launchpad is given below.



  You can right click and download this images for better Zooming or just click on the images.

You need to install the CCSv5.5 and also the ControlSuite Software from the TI websites 

The following are the links for downloading CCSv5.5 and ControlSuite

http://www.ti.com/lsds/ti/tools-software/devtools.page

http://www.ti.com/tool/controlsuite


Now how to create a new project in CCSv5.5 for C2000 Launchpad 


In the above video how to create a new Project is explained , for better Explanation
continue below(You can even download these images)

                             Click on ProjectàNew CCS Project
  


     In the new CCS project window , plz. configure the

setting ‘s as shown in the window


Click Finish


      Right Click on the ProjectàProject Properties  



                               Click on Include Options and add button in the second/bottom tab window and add the linker
"C:\ti\controlSUITE\development_kits\C2000_LaunchPad"




   Click on C2000 linkeràFile Search Path and add button in the First/Top tab window and add the linker

"C:\ti\controlSUITE\development_kits\C2000_LaunchPad\f2802x_common\lib\driverlib.lib"                                                                                      



Click Finish and you are ready to start


Building Your First Project 




In the Above video i would have shown You how to create and execute a
new project


The Code for Blinking the first Led is 

/*
 * main.c
 */

#include "DSP28x_Project.h"     // DSP28x Headerfile

#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/wdog.h"


#ifdef _FLASH
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif


void main()
{
 WDOG_Handle myWDog;
 myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
 WDOG_disable(myWDog);

 CLK_Handle myClk;
 PLL_Handle myPll;
 myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
 myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));

  CLK_setOscSrc(myClk, CLK_OscSrc_Internal);  ///selecting Internal Oscillator

  PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);  // Selecting 60Mhz InternalClock

  GPIO_Handle myGpio;
  myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));

  GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
  GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_GeneralPurpose);
  GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);

  GPIO_setHigh(myGpio, GPIO_Number_0);
  GPIO_setHigh(myGpio, GPIO_Number_1);
  GPIO_setHigh(myGpio, GPIO_Number_2);
  GPIO_setHigh(myGpio, GPIO_Number_3);

  while(1)
  {
    GPIO_setLow(myGpio, GPIO_Number_0);
    DELAY_US(1000000);
    GPIO_setHigh(myGpio, GPIO_Number_0);
    DELAY_US(1000000);
  }

}



Now i am going to show how to create an Timer Module and generate a program to vary the LED Brightness for every 500ms  




#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

//#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/timer.h"
#include "f2802x_common/include/wdog.h"

// Prototype statements for functions found within this file.
interrupt void cpu_timer0_isr(void);

uint16_t interruptCount = 0;

//ADC_Handle myAdc;
CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
TIMER_Handle myTimer;
unsigned int Count=0,Cnt=0;
void main(void)
{

    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));
    myTimer = TIMER_init((void *)TIMER0_BASE_ADDR, sizeof(TIMER_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();

    //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

    // 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_1, PIE_SubGroupNumber_7, (intVec_t)&cpu_timer0_isr);

    // Configure CPU-Timer 0 to interrupt every 500 milliseconds:
    // 50MHz CPU Freq, 50 millisecond Period (in uSeconds)
    //    ConfigCpuTimer(&CpuTimer0, 60, 500000);
    TIMER_stop(myTimer);
    TIMER_setPeriod(myTimer, 50 * 500000);
    TIMER_setPreScaler(myTimer, 0);
    TIMER_reload(myTimer);
    TIMER_setEmulationMode(myTimer, TIMER_EmulationMode_StopAfterNextDecrement);
    TIMER_enableInt(myTimer);

    TIMER_start(myTimer);


    // Configure GPIO 0-3 as outputs
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_0_Mode_GeneralPurpose);

    GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);

    GPIO_setLow(myGpio, GPIO_Number_0);
    GPIO_setHigh(myGpio, GPIO_Number_1);
    GPIO_setLow(myGpio, GPIO_Number_2);
    GPIO_setHigh(myGpio, GPIO_Number_3);

    // Enable CPU INT1 which is connected to CPU-Timer 0:
    CPU_enableInt(myCpu, CPU_IntNumber_1);

    // Enable TINT0 in the PIE: Group 1 interrupt 7
    PIE_enableTimer0Int(myPie);

    // Enable global Interrupts and higher priority real-time debug events
    CPU_enableGlobalInts(myCpu);
    CPU_enableDebugInt(myCpu);

    for(;;){
        asm(" NOP");
        Count++;
        if(Count < 3000)
        {
  if(Count < Cnt)
  {
  // Toggle GPIOs
  GPIO_setLow(myGpio, GPIO_Number_0);
  GPIO_setLow(myGpio, GPIO_Number_1);
  GPIO_setLow(myGpio, GPIO_Number_2);
  GPIO_setLow(myGpio, GPIO_Number_3);
  }
  else
    {
 // Toggle GPIOs
 GPIO_setHigh(myGpio, GPIO_Number_0);
 GPIO_setHigh(myGpio, GPIO_Number_1);
 GPIO_setHigh(myGpio, GPIO_Number_2);
 GPIO_setHigh(myGpio, GPIO_Number_3);
 }

        }
        else
        {
        Count = 0;
        Cnt++;
        if(Cnt > 2500)Cnt = 0;
        }

    }

}


interrupt void cpu_timer0_isr(void)
{
    interruptCount++;
//    Cnt++;
 /*  if(interruptCount <5)    {
    // Toggle GPIOs
    GPIO_setLow(myGpio, GPIO_Number_0);
    GPIO_setLow(myGpio, GPIO_Number_1);
    GPIO_setLow(myGpio, GPIO_Number_2);
    GPIO_setLow(myGpio, GPIO_Number_3);
    }
    else
    {
       // Toggle GPIOs
       GPIO_setHigh(myGpio, GPIO_Number_0);
       GPIO_setHigh(myGpio, GPIO_Number_1);
       GPIO_setHigh(myGpio, GPIO_Number_2);
       GPIO_setHigh(myGpio, GPIO_Number_3);
       }
    if(interruptCount >20)interruptCount = 0;
*/
  //  GPIO_setHigh(myGpio, GPIO_Number_0);
  //  GPIO_toggle(myGpio, GPIO_Number_1);
  //  GPIO_toggle(myGpio, GPIO_Number_2);
  //  GPIO_toggle(myGpio, GPIO_Number_3);

    // Acknowledge this interrupt to receive more interrupts from group 1
    PIE_clearInt(myPie, PIE_GroupNumber_1);
}


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


Here is the Time Period Calculation

Timer Calculation in C2000

If   for example CPU is running in 50 MHz

Time period   = 1/frequency

Time period   =1/ (50 x 10^6)

Time Period = 20ns

   ie., 20ns/instruction

Register used to modify the Time Period for the Timer

TIMER_setPeriod(TIMER_Handle timerHandle,
                     const uint32_t period);

Time period required = Time Period of CPU x PRD value

PRD Value is the Maximum counter (32 - bit) value defined by the user

For example for 500ms,

Time period Required = 20 ns x 25000000

Time period Required = 500000000/10^6


Time period Required= 500ms




Now i am going to show you how to create an ADC Module and vary the ADC values using a POT









//#############################################################################
/* ADC PROGRAM       */
//#############################################################################

#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/wdog.h"

#include "f2802x_common/include/pie.h"

#include "f2802x_common/include/adc.h"

void ADC_INIT_Fn();
void ADC_SETUP_Fn();


CLK_Handle   myClk;
FLASH_Handle myFlash;
GPIO_Handle  myGpio;
PLL_Handle   myPll;
WDOG_Handle  myWDog;
PIE_Handle   myPie;
ADC_Handle   myAdc;

//#include "f2802x_common/include/steps.h"

uint16_t Digital_Result =0;
interrupt void adc_isr(void)
{
    //discard ADCRESULT0 as part of the workaround to the 1st sample errata for rev0
    Digital_Result = ADC_readResult(myAdc, ADC_ResultNumber_0);
    ADC_clearIntFlag(myAdc, ADC_IntNumber_1);   // Clear ADCINT1 flag reinitialize for next SOC
    PIE_clearInt(myPie, PIE_GroupNumber_10);// Acknowledge interrupt to PIE
    return;
}


void main(void)
{
myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
 myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
 myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
  myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));


// Disable the PIE and all interrupts
  PIE_disable(myPie);
  PIE_disableAllInts(myPie);


    // Perform basic system initialization


    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);  //Select the internal oscillator 1 as the clock source
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);  // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2

    // If running from flash copy RAM only functions to RAM
/* #ifdef _FLASH
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif
*/



    PIE_enable(myPie);
     // Register interrupt handlers in the PIE vector table

    ADC_INIT_Fn();
    ADC_SETUP_Fn();

    while(1)
    {
    ADC_forceConversion(myAdc, ADC_SocNumber_0);// Wait for ADC interrupt
    }

}
void ADC_INIT_Fn()
{
  ADC_enableBandGap(myAdc);
  ADC_enableRefBuffers(myAdc);
  ADC_powerUp(myAdc);
  ADC_enable(myAdc);
  ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);
}

void ADC_SETUP_Fn()
{
 PIE_registerPieIntHandler(myPie, PIE_GroupNumber_10, PIE_SubGroupNumber_1, (intVec_t)&adc_isr);
  PIE_enableAdcInt(myPie, ADC_IntNumber_1); // Enable ADCINT1 in PIE
  //Note: Channel ADCINA1  will be double sampled to workaround the ADC 1st sample issue for rev0 silicon errata
  ADC_setIntPulseGenMode(myAdc, ADC_IntPulseGenMode_Prior);               //ADCINT1 trips after AdcResults latch
  ADC_enableInt(myAdc, ADC_IntNumber_1);                                  //Enabled ADCINT1
  ADC_setIntMode(myAdc, ADC_IntNumber_1, ADC_IntMode_ClearFlag);          //Disable ADCINT1 Continuous mode
  ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC0);                 //setup EOC0 to trigger ADCINT1 to fire
  ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4);    //set SOC0 channel select to ADCINA4
  ADC_setSocTrigSrc(myAdc, ADC_SocNumber_0, ADC_SocTrigSrc_Sw);     //set SOC0 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1
  ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles);   //set SOC0 S/H Window to 7 ADC Clock Cycles, (6 ACQPS plus 1)
}


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

//===========================================================================


Now i am going to show you how to communicate C2000 launchpad with PC through SCI 



//#############################################################################
/* Communication Protocol with SCI       */
//#############################################################################

SCI Transmission Only

#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/wdog.h"


void scia_init();
void scia_xmit(int a);
void send_msg();
unsigned char msg[]="\nHaiiii....";



CLK_Handle myClk;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;


void main(void)
     {
   myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
   myCpu = CPU_init((void *)NULL, sizeof(CPU_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));
   mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
   myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));


   WDOG_disable(myWDog);
   CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
   PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

   // Initalize GPIO
   GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
   GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
   GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
   GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
   GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);


   scia_init();



   while(1)
   {
    send_msg();DELAY_US(2000000);
   }
}

//-------------------------- UART -----------------------------------

void scia_init()
{
    CLK_enableSciaClock(myClk);
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits); 
    SCI_enableTx(mySci);    
    SCI_setBaudRate(mySci, SCI_BaudRate_9_6_kBaud);
    SCI_enable(mySci);
}


void scia_xmit(int a)
{
    while(SCI_getTxFifoStatus(mySci) != SCI_FifoStatus_Empty);  //while (SciaRegs.SCIFFTX.bit.TXFFST != 0) {}
    SCI_putDataBlocking(mySci, a);  // SciaRegs.SCITXBUF=a;
}

void send_msg()
{
int i=0;
while(msg[i]!='\0')
{
scia_xmit(msg[i]);
i++;
}
}


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

//===========================================================================


SCI Transmission and Reception



#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/wdog.h"

interrupt void sciaRxIsr(void);
void scia_init();
void scia_xmit(int a);
void scia_intpt_en();
void send_msg();
void send_back(char data);
unsigned char msg[]="send any data now- Controller will send back it";
unsigned char msg2[]="\nYou Sent:";
unsigned char rx_data;


CLK_Handle myClk;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;


void main(void)
     {
   myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
   myCpu = CPU_init((void *)NULL, sizeof(CPU_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));
   mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
   myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));


   WDOG_disable(myWDog);
   CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
   PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

   // Initalize GPIO
   GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
   GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
   GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
   GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
   GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);

   scia_intpt_en();
   scia_init();
   send_msg();


   while(1);
}

//-------------------------- UART -----------------------------------
interrupt void sciaRxIsr(void)
{
rx_data = SCI_getData(mySci);
send_back(rx_data);
PIE_clearInt(myPie, PIE_GroupNumber_9);
}

void scia_init()
{
    CLK_enableSciaClock(myClk);
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits);
    SCI_enableRx(mySci);
    SCI_enableTx(mySci);
    SCI_enableRxInt(mySci);
    SCI_setBaudRate(mySci, SCI_BaudRate_9_6_kBaud);
    SCI_enable(mySci);
}

void scia_intpt_en()
{
PIE_enable(myPie);
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_9, PIE_SubGroupNumber_1, (intVec_t)&sciaRxIsr);
PIE_enableInt(myPie, PIE_GroupNumber_9, PIE_InterruptSource_SCIARX);
CPU_enableInt(myCpu, CPU_IntNumber_9);
CPU_enableGlobalInts(myCpu);  // Enable Global Interrupts
}

void scia_xmit(int a)
{
    while(SCI_getTxFifoStatus(mySci) != SCI_FifoStatus_Empty);  //while (SciaRegs.SCIFFTX.bit.TXFFST != 0) {}
    SCI_putDataBlocking(mySci, a);  // SciaRegs.SCITXBUF=a;
}

void send_msg()
{
int i=0;
while(msg[i]!='\0')
{
scia_xmit(msg[i]);
i++;
}
}

void send_back(char data)
{
int i=0;
while(msg2[i]!='\0')
{
scia_xmit(msg2[i]);
i++;
}
scia_xmit(rx_data);
}


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

//===========================================================================



Now i am going to show you how to send ADC values through SCI from C2000 to PC

//#############################################################################
/* Communication Protocol with SCI       */
//############################################################################



#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/wdog.h"

#include "f2802x_common/include/adc.h"

// Prototype statements for functions found within this file.
void scia_echoback_init(void);
void scia_fifo_init(void);
void scia_xmit(int a);
void scia_msg(char *msg);

interrupt void adc_isr(void);
void Adc_Config(void);
void delay();
void ADC_INIT_Fn();
void ADC_SETUP_Fn();
void send_result(int res);

int Vin;

CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;
ADC_Handle myAdc;

void main(void)
{
    char *msg;

    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));
    mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();

    //Select the internal oscillator 1 as the clock source
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
    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

    PIE_enable(myPie);
    // Register interrupt handlers in the PIE vector table
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_10, PIE_SubGroupNumber_1, (intVec_t)&adc_isr);

    PIE_enableAdcInt(myPie, ADC_IntNumber_1); // Enable ADCINT1 in PIE
    CPU_enableInt(myCpu, CPU_IntNumber_10); // Enable CPU Interrupt 1
    CPU_enableGlobalInts(myCpu); // Enable Global interrupt INTM
    CPU_enableDebugInt(myCpu); // Enable Global realtime interrupt DBGM

    // Initalize GPIO
    GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
    GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
    GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
    GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);

    scia_echoback_init();  // Initalize SCI for echoback
    scia_fifo_init();      // Initialize the SCI FIFO

    ADC_INIT_Fn();// Initialize the ADC
    ADC_SETUP_Fn();// Configure ADC

    msg = "\nNew Data:";

    while(1)
    {
    scia_msg(msg);
    delay();
    ADC_forceConversion(myAdc, ADC_SocNumber_0);

    }
}

interrupt void adc_isr(void)
{
Vin = ADC_readResult(myAdc, ADC_ResultNumber_0);
send_result(Vin);
ADC_clearIntFlag(myAdc, ADC_IntNumber_1);// Clear ADCINT1 flag reinitialize for next SOC
    PIE_clearInt(myPie, PIE_GroupNumber_10);// Acknowledge interrupt to PIE
    return;
}

void ADC_INIT_Fn()
{
ADC_enableBandGap(myAdc);
ADC_enableRefBuffers(myAdc);
ADC_powerUp(myAdc);
ADC_enable(myAdc);
ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);
}

void ADC_SETUP_Fn()
{
//Note: Channel ADCINA4  will be double sampled to workaround the ADC 1st sample issue for rev0 silicon errata
ADC_setIntPulseGenMode(myAdc, ADC_IntPulseGenMode_Prior);               //ADCINT1 trips after AdcResults latch
ADC_enableInt(myAdc, ADC_IntNumber_1);                                  //Enabled ADCINT1
ADC_setIntMode(myAdc, ADC_IntNumber_1, ADC_IntMode_ClearFlag);          //Disable ADCINT1 Continuous mode
ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC0);                 //setup EOC2 to trigger ADCINT1 to fire
ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4);    //set SOC0 channel select to ADCINA4
ADC_setSocTrigSrc(myAdc, ADC_SocNumber_0, ADC_SocTrigSrc_Sw);     //set SOC0 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1
ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles);   //set SOC0 S/H Window to 7 ADC Clock Cycles, (6 ACQPS plus 1)
}
// Test 1,SCIA  DLB, 8-bit word, baud rate 0x000F, default, 1 STOP bit, no parity
void scia_echoback_init()
{
    CLK_enableSciaClock(myClk);
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits);
    SCI_enableTx(mySci);

#if (CPU_FRQ_60MHZ)
    SCI_setBaudRate(mySci, SCI_BaudRate_9_6_kBaud);
#elif (CPU_FRQ_50MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)162);
#elif (CPU_FRQ_40MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)129);
#endif

    SCI_enable(mySci);
    return;
}

// Transmit a character from the SCI
void scia_xmit(int a)
{
    while(SCI_getTxFifoStatus(mySci) != SCI_FifoStatus_Empty);  //while (SciaRegs.SCIFFTX.bit.TXFFST != 0) {}
    SCI_putDataBlocking(mySci, a);  // SciaRegs.SCITXBUF=a;
}

void scia_msg(char *msg)
{
    int i=0;
    while(msg[i] != '\0')
    {
        scia_xmit(msg[i]);
        i++;
    }
}

// Initalize the SCI FIFO
void scia_fifo_init()
{
    SCI_enableFifoEnh(mySci);
    SCI_resetTxFifo(mySci);
    SCI_clearTxFifoInt(mySci);
    SCI_resetChannels(mySci);
    SCI_setTxFifoIntLevel(mySci, SCI_FifoLevel_Empty);

    SCI_resetRxFifo(mySci);
    SCI_clearRxFifoInt(mySci);
    SCI_setRxFifoIntLevel(mySci, SCI_FifoLevel_4_Words);
    return;
}

void send_result(int res)
{
int b3,b2,b1,b0;
b3 = (res/1000)+48;
b2 = ((res%1000)/100)+48;
b1 = ((res%100)/10)+48;
b0 = (res%10)+48;
scia_xmit(b3);
scia_xmit(b2);
scia_xmit(b1);
scia_xmit(b0);
return;
}

void delay()
{
    unsigned int i, j;
    for (i=0; i<4500; i++)
    {
    for(j=0; j<1000; j++);
    }
}
//===========================================================================
// No more.

//===========================================================================




PWM Generation using C2000 Launchpad




//#############################################################################
/* PWM Genereation Using C2000 Launchpad       */
//############################################################################


/*
PWM Frequency = 1 KHz  (GPIO 0)
Dutycycle = 75%
*/
//#############################################################################
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/pwm.h"
#include "f2802x_common/include/wdog.h"
void pwm_Init_();
//void set_freq(int freq);
//void set_dutycycle(int duty);
#define TBPRD  12500  // Period register
#define CMPA   6250  //start the pwm at 50% duty cycle


CLK_Handle myClk;
GPIO_Handle myGpio;
PWM_Handle myPwm1;
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));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
    PLL_setup(myPll, PLL_Multiplier_1, PLL_DivideSelect_ClkIn_by_4);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);
    // Initalize GPIO
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
    //set_freq(10);
    //set_dutycycle(75);
    CLK_disableTbClockSync(myClk);
    pwm_Init_();
    CLK_enableTbClockSync(myClk);
    while(1);
}

/*void set_freq(int freq)
{
float Tpwm,c;
Tpwm = 1/freq;
c = Tpwm/0.000008;
TBPRD = (int)12500.98;
}
void set_dutycycle(int duty)
{
float div;
div = 100/duty;
CMPA = (int)(TBPRD/div);
CMPA = (int)6250.123;
}*/
void pwm_Init_()
{
    CLK_enablePwmClock(myClk, PWM_Number_1);
    // Setup TBCLK
    PWM_setPeriod(myPwm1, TBPRD);   // Set timer period 801 TBCLKs
    PWM_setPhase(myPwm1, 0x0000);   // Phase is 0
    PWM_setCount(myPwm1, 0x0000);   // Clear counter
    // Set Compare values
    PWM_setCmpA(myPwm1, CMPA);      // Set compare A value
    // Setup counter mode
    PWM_setCounterMode(myPwm1, PWM_CounterMode_UpDown); // Count up and down
    PWM_disableCounterLoad(myPwm1);                     // Disable phase loading
    PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_10); // Clock ratio to SYSCLKOUT
    PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_1);
    // Setup shadowing
    PWM_setShadowMode_CmpA(myPwm1, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm1, PWM_LoadMode_Zero);
    // Set actions
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm1, PWM_ActionQual_Clear);      // Set PWM1A on event A, up count
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm1, PWM_ActionQual_Set);  // Clear PWM1A on event A, down count
}

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

//===========================================================================




Next is Controlling PWM Duty Cycle using ADC values






//#############################################################################
/* PWM Duty Cycle Control with respect to ADC Values     */

//############################################################################



#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/timer.h"
#include "f2802x_common/include/wdog.h"
#include "f2802x_common/include/pwr.h"
#include "f2802x_common/include/pwm.h"


void pwm_Init_();

unsigned int TBPRD = 4096;
unsigned int CMPA=0; //32500;

ADC_Handle   myAdc;
CLK_Handle   myClk;
FLASH_Handle myFlash;
GPIO_Handle  myGpio;
PIE_Handle   myPie;
TIMER_Handle myTimer;
CPU_Handle   myCpu;
PLL_Handle   myPll;
WDOG_Handle  myWDog;
PWM_Handle myPwm1;
PWR_Handle myPwr;

uint16_t Digital_Result =0;

void globaldisable();
void globalenable();
void ADC_INIT_Fn();
void ADC_SETUP_Fn();
void set_duty(int a);

int adcresult=2048;

interrupt void adc_isr(void)
{
    //discard ADCRESULT0 as part of the workaround to the 1st sample errata for rev0
    Digital_Result = ADC_readResult(myAdc, ADC_ResultNumber_0);

    adcresult =Digital_Result;

     set_duty(adcresult);
 //   pwm_Init_();

    ADC_clearIntFlag(myAdc, ADC_IntNumber_1);   // Clear ADCINT1 flag reinitialize for next SOC
    PIE_clearInt(myPie, PIE_GroupNumber_10);// Acknowledge interrupt to PIE
    return;
}




void main(void)
{
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));
 myTimer = TIMER_init((void *)TIMER0_BASE_ADDR, sizeof(TIMER_Obj));
 myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
 myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));
 myPwr = PWR_init((void *)PWR_BASE_ADDR, sizeof(PWR_Obj));

 globaldisable();
    // Perform basic system initialization
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);  //Select the internal oscillator 1 as the clock source
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);  // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2


    globalenable();
    ADC_INIT_Fn();
    ADC_SETUP_Fn();

    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);

      //set_freq(10);
      //set_dutycycle(75);

      CLK_disableTbClockSync(myClk);
      pwm_Init_();

  //

      CLK_enableTbClockSync(myClk);
    while(1)
    {
    ADC_forceConversion(myAdc, ADC_SocNumber_0);// Wait for ADC interrupt
    }

}
void globaldisable()
{
  // Disable the PIE and all interrupts
  PIE_disable(myPie);
  PIE_disableAllInts(myPie);
  CPU_disableGlobalInts(myCpu);
  CPU_clearIntFlags(myCpu);
}

void globalenable()
{
  PIE_enable(myPie);
  // Register interrupt handlers in the PIE vector table
  CPU_enableInt(myCpu, CPU_IntNumber_10); // Enable CPU Interrupt 1
  CPU_enableGlobalInts(myCpu);    // Enable Global interrupt INTM
  CPU_enableDebugInt(myCpu); // Enable Global realtime interrupt DBGM


      // Enable XINT1 in the PIE: Group 1 interrupt 4 & 5
      // Enable INT1 which is connected to WAKEINT
      PIE_enableInt(myPie, PIE_GroupNumber_1, PIE_InterruptSource_XINT_1);
  CPU_enableInt(myCpu, CPU_IntNumber_1);

     // GPIO0 is XINT1, GPIO1 is XINT2
     GPIO_setExtInt(myGpio, GPIO_Number_12, CPU_ExtIntNumber_1);

     // Configure XINT1
     PIE_setExtIntPolarity(myPie, CPU_ExtIntNumber_1, PIE_ExtIntPolarity_RisingEdge);

     // Enable XINT1 and XINT2
     PIE_enableExtInt(myPie, CPU_ExtIntNumber_1);
}

void ADC_INIT_Fn()
{
  ADC_enableBandGap(myAdc);
  ADC_enableRefBuffers(myAdc);
  ADC_powerUp(myAdc);
  ADC_enable(myAdc);
  ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);
}

void ADC_SETUP_Fn()
{
 PIE_registerPieIntHandler(myPie, PIE_GroupNumber_10, PIE_SubGroupNumber_1, (intVec_t)&adc_isr);
  PIE_enableAdcInt(myPie, ADC_IntNumber_1); // Enable ADCINT1 in PIE
  //Note: Channel ADCINA1  will be double sampled to workaround the ADC 1st sample issue for rev0 silicon errata
  ADC_setIntPulseGenMode(myAdc, ADC_IntPulseGenMode_Prior);               //ADCINT1 trips after AdcResults latch
  ADC_enableInt(myAdc, ADC_IntNumber_1);                                  //Enabled ADCINT1
  ADC_setIntMode(myAdc, ADC_IntNumber_1, ADC_IntMode_ClearFlag);          //Disable ADCINT1 Continuous mode
  ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC0);                 //setup EOC0 to trigger ADCINT1 to fire
  ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4);    //set SOC0 channel select to ADCINA4
  ADC_setSocTrigSrc(myAdc, ADC_SocNumber_0, ADC_SocTrigSrc_Sw);     //set SOC0 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1
  ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles);   //set SOC0 S/H Window to 7 ADC Clock Cycles, (6 ACQPS plus 1)
}

void pwm_Init_()
{
    CLK_enablePwmClock(myClk, PWM_Number_1);
    // Setup TBCLK
    PWM_setPeriod(myPwm1, TBPRD);   // Set timer period 801 TBCLKs
    PWM_setPhase(myPwm1, 0x0000);   // Phase is 0
    PWM_setCount(myPwm1, 0x0000);   // Clear counter
    // Set Compare values

    //CMPA = (TBPRD/100)*adcresult;

 //   interrupt void adc_isr(void);

  //  CMPA = adcresult;

    //PWM_setCmpA(myPwm1, CMPA);      // Set compare A value

 //   set_duty();

    // Setup counter mode
    PWM_setCounterMode(myPwm1, PWM_CounterMode_UpDown); // Count up and down
    PWM_disableCounterLoad(myPwm1);                     // Disable phase loading
    PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_10); // Clock ratio to SYSCLKOUT
    PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_1);
    // Setup shadowing
    PWM_setShadowMode_CmpA(myPwm1, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm1, PWM_LoadMode_Zero);
    // Set actions
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm1, PWM_ActionQual_Clear);      // Set PWM1A on event A, up count
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm1, PWM_ActionQual_Set);  // Clear PWM1A on event A, down count
}
void set_duty( int a)
{
CMPA = a;
PWM_setCmpA(myPwm1, CMPA);      // Set compare A value
}

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

//===========================================================================



Next is to control PWM Duty Cycle Using SCI







//#############################################################################
/* PWM Duty Cycle Control with respect to SCI Values     */

//############################################################################


#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/wdog.h"

interrupt void sciaRxIsr(void);
void scia_init();
void scia_xmit(int a);
void scia_intpt_en();
void send_msg();
unsigned char msg[]="\nsend duty cycle:";

void pwm_Init_();
void set_duty();
unsigned int TBPRD = 65535; // Period register
unsigned int CMPA=0; //32500;
int duty = 50;

CLK_Handle myClk;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;
CPU_Handle myCpu;
PLL_Handle myPll;
WDOG_Handle myWDog;
PWM_Handle myPwm1;

void main(void)
     {
   myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
   myCpu = CPU_init((void *)NULL, sizeof(CPU_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));
   mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
   myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
   myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));

   WDOG_disable(myWDog);
   CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
   PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

   // Initalize GPIO
   GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
   GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
   GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
   GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
   GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);

   scia_intpt_en();
   scia_init();
   send_msg();

   GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_EPWM1A);
   CLK_disableTbClockSync(myClk);
   pwm_Init_();
   CLK_enableTbClockSync(myClk);

   while(1);
}

//-------------------------- UART -----------------------------------
interrupt void sciaRxIsr(void)
{
duty = SCI_getData(mySci);
set_duty();
PIE_clearInt(myPie, PIE_GroupNumber_9);
}

void scia_init()
{
    CLK_enableSciaClock(myClk);
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits);
    SCI_enableRx(mySci);
    SCI_enableTx(mySci);
    SCI_enableRxInt(mySci);
    SCI_setBaudRate(mySci, SCI_BaudRate_9_6_kBaud);
    SCI_enable(mySci);
}

void scia_intpt_en()
{
PIE_enable(myPie);
PIE_registerPieIntHandler(myPie, PIE_GroupNumber_9, PIE_SubGroupNumber_1, (intVec_t)&sciaRxIsr);
PIE_enableInt(myPie, PIE_GroupNumber_9, PIE_InterruptSource_SCIARX);
CPU_enableInt(myCpu, CPU_IntNumber_9);
CPU_enableGlobalInts(myCpu);  // Enable Global Interrupts
}

void scia_xmit(int a)
{
    while(SCI_getTxFifoStatus(mySci) != SCI_FifoStatus_Empty);  //while (SciaRegs.SCIFFTX.bit.TXFFST != 0) {}
    SCI_putDataBlocking(mySci, a);  // SciaRegs.SCITXBUF=a;
}

void send_msg()
{
int i=0;
while(msg[i]!='\0')
{
scia_xmit(msg[i]);
i++;
}
}
//--------------------------------- PWM ------------------------------------

void pwm_Init_()
{
    CLK_enablePwmClock(myClk, PWM_Number_1);
    // Setup TBCLK
    PWM_setPeriod(myPwm1, TBPRD);   // Set timer period 801 TBCLKs
    PWM_setPhase(myPwm1, 0x0000);   // Phase is 0
    PWM_setCount(myPwm1, 0x0000);   // Clear counter
    // Set Compare values for duty cycle
    set_duty();
    // Setup counter mode
    PWM_setCounterMode(myPwm1, PWM_CounterMode_UpDown); // Count up and down
    PWM_disableCounterLoad(myPwm1);                     // Disable phase loading
    PWM_setHighSpeedClkDiv(myPwm1, PWM_HspClkDiv_by_10); // Clock ratio to SYSCLKOUT
    PWM_setClkDiv(myPwm1, PWM_ClkDiv_by_2);
    // Setup shadowing
    PWM_setShadowMode_CmpA(myPwm1, PWM_ShadowMode_Shadow);
    PWM_setLoadMode_CmpA(myPwm1, PWM_LoadMode_Zero);
    // Set actions
    PWM_setActionQual_CntUp_CmpA_PwmA(myPwm1, PWM_ActionQual_Clear);      // Set PWM1A on event A, up count
    PWM_setActionQual_CntDown_CmpA_PwmA(myPwm1, PWM_ActionQual_Set);  // Clear PWM1A on event A, down count
}

void set_duty()
{
CMPA = (TBPRD/100)*duty;
PWM_setCmpA(myPwm1, CMPA);      // Set compare A value
}


/////////note  while opening the terminal select decimal option for input



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

//===========================================================================



Next is Interfacing C2000 Launchpad with Stepper Motor

//#############################################################################
/* Interfacing C2000 launchpad with Stepper Motor   */

//############################################################################



#include "DSP28x_Project.h"     // DSP28x Headerfile
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/wdog.h"
CLK_Handle myClk;
WDOG_Handle myWDog;
PLL_Handle myPll;
void main() {

myWDog = WDOG_init((void *) WDOG_BASE_ADDR, sizeof(WDOG_Obj));
WDOG_disable(myWDog);



myClk = CLK_init((void *) CLK_BASE_ADDR, sizeof(CLK_Obj));
myPll = PLL_init((void *) PLL_BASE_ADDR, sizeof(PLL_Obj));

CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

GPIO_Handle myGpio;
myGpio = GPIO_init((void *) GPIO_BASE_ADDR, sizeof(GPIO_Obj));
DELAY_US(1000000);
GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);

GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);




while (1) {
GPIO_setLow(myGpio, GPIO_Number_3);
GPIO_setHigh(myGpio, GPIO_Number_0);
//GPIO_setHigh(myGpio, GPIO_Number_3);
DELAY_US(9000);
GPIO_setLow(myGpio, GPIO_Number_0);
// GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
DELAY_US(9000);
GPIO_setLow(myGpio, GPIO_Number_1);
// GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
DELAY_US(9000);
GPIO_setLow(myGpio, GPIO_Number_2);
// GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);
DELAY_US(6000);
GPIO_setHigh(myGpio, GPIO_Number_3);
GPIO_setHigh(myGpio, GPIO_Number_1);
DELAY_US(9000);

/* GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setLow(myGpio, GPIO_Number_3);
DELAY_US(1000000);

GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setLow(myGpio, GPIO_Number_0);
DELAY_US(1000000);

GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setLow(myGpio, GPIO_Number_1);
DELAY_US(1000000);

GPIO_setHigh(myGpio, GPIO_Number_3);
GPIO_setLow(myGpio, GPIO_Number_2);
DELAY_US(1000000);*/

// GPIO_setLow(myGpio, GPIO_Number_2);




}

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

//===========================================================================


Next controlling  STEPPER Motor with respect to ADC Values 



//#############################################################################
/* Controlling  Stepper Motor with respect to adc values  */


//############################################################################

 #include "DSP28x_Project.h"     // DSP28x Headerfile
#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/wdog.h"
#include "f2802x_common/include/sci.h"
CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
ADC_Handle myAdc;
int16_t temp; //raw ADC Result Data
void main() {

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));
   myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

   // Perform basic system initialization
   WDOG_disable(myWDog);
   CLK_enableAdcClock(myClk);
   (*Device_cal)();

   //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
//DELAY_US(1000000);
//    PIE_setDebugIntVectorTable(myPie);
      PIE_enable(myPie);

      // Initialize the ADC
      ADC_enableBandGap(myAdc);
      ADC_enableRefBuffers(myAdc);
      ADC_powerUp(myAdc);
      ADC_enable(myAdc);
      ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);
      ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4);    //Set SOC0 channel select to ADCINA5
      ADC_setSocChanNumber (myAdc, ADC_SocNumber_1, ADC_SocChanNumber_A4);    //Set SOC1 channel select to ADCINA5
      ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles);   //Set SOC0 acquisition period to 7 ADCCLK
      ADC_setSocSampleWindow(myAdc, ADC_SocNumber_1, ADC_SocSampleWindow_7_cycles);   //Set SOC1 acquisition period to 7 ADCCLK
      ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC1);                 //Connect ADCINT1 to EOC1
      ADC_enableInt(myAdc, ADC_IntNumber_1);                                  //Enable ADCINT1
      FLASH_setup(myFlash);
GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_1, GPIO_1_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_2, GPIO_2_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
GPIO_setMode(myGpio, GPIO_Number_3, GPIO_3_Mode_GeneralPurpose);
GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);
GPIO_setHigh(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);




while (1)
{
        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) {
        }

        // Clear ADCINT1
        ADC_clearIntFlag(myAdc, ADC_IntNumber_1);

        // Get temp sensor sample result from SOC1
       temp = ADC_readResult(myAdc, ADC_ResultNumber_1);
       temp = temp+6000;
GPIO_setLow(myGpio, GPIO_Number_3);
GPIO_setHigh(myGpio, GPIO_Number_0);
DELAY_US(temp);
GPIO_setLow(myGpio, GPIO_Number_0);
GPIO_setHigh(myGpio, GPIO_Number_1);
DELAY_US(temp);
GPIO_setLow(myGpio, GPIO_Number_1);
GPIO_setHigh(myGpio, GPIO_Number_2);
DELAY_US(temp);
GPIO_setLow(myGpio, GPIO_Number_2);
GPIO_setHigh(myGpio, GPIO_Number_3);
DELAY_US(temp);
GPIO_setHigh(myGpio, GPIO_Number_3);
GPIO_setHigh(myGpio, GPIO_Number_1);
DELAY_US(temp);





}


}

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

//===========================================================================


Next is Activating the Internal Temperature Sensor




#include <stdio.h>
#include <file.h>

#include "DSP28x_Project.h"     // DSP28x Headerfile
#include "ti_ascii.h"

#include "f2802x_common/include/adc.h"
#include "f2802x_common/include/clk.h"
#include "f2802x_common/include/flash.h"
#include "f2802x_common/include/gpio.h"
#include "f2802x_common/include/pie.h"
#include "f2802x_common/include/pll.h"
#include "f2802x_common/include/sci.h"
#include "f2802x_common/include/sci_io.h"
#include "f2802x_common/include/wdog.h"

#define CONV_WAIT 1L //Micro-seconds to wait for ADC conversion. Longer than necessary.

extern void DSP28x_usDelay(Uint32 Count);

static unsigned short indexX=0;
static unsigned short indexY=0;

const unsigned char escRed[] = {0x1B, 0x5B, '3','1', 'm'};
const unsigned char escWhite[] = {0x1B, 0x5B, '3','7', 'm'};
const unsigned char escLeft[] = {0x1B, 0x5B, '3','7', 'm'};
const unsigned char pucTempString[] = "Current Temperature:";



int16_t referenceTemp;
int16_t currentTemp;

ADC_Handle myAdc;
CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
SCI_Handle mySci;

int16_t sampleTemperature(void)
{

    //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) {
    }

    // Clear ADCINT1
    ADC_clearIntFlag(myAdc, ADC_IntNumber_1);

    // Get temp sensor sample result from SOC1
    return (ADC_readResult(myAdc, ADC_ResultNumber_1));
    
}

void drawTILogo(void)
{
    unsigned char ucChar, lastChar;
    
    putchar('\n');
    while(indexY<45)
    {
        if(indexY<45){
            if(indexX<77){
                ucChar = ti_ascii[indexY][indexX++] ;
                
                //We are in the TI logo make it red
                if(ucChar != '7' && lastChar=='7'){
                    putchar(escRed[0]);
                    putchar(escRed[1]);
                    putchar(escRed[2]);
                    putchar(escRed[3]);
                    putchar(escRed[4]);
                }
                    
                //We are in the TI logo make it red
                if(ucChar == '7' && lastChar!='7'){
                    putchar(escWhite[0]);
                    putchar(escWhite[1]);
                    putchar(escWhite[2]);
                    putchar(escWhite[3]);
                    putchar(escWhite[4]);
                }
                    
                putchar(ucChar);
                lastChar = ucChar;
            }else{
                ucChar = 10;
                putchar(ucChar);
                ucChar = 13;
                putchar(ucChar);
                indexX=0;
                indexY++;
            }
        }
    }
}

void clearTextBox(void)
{
    
    putchar(0x08);
    
    // Move back 24 columns
    putchar(0x1B);
    putchar('[');
    putchar('2');
    putchar('6');
    putchar('D');
    
    // Move up 3 lines
    putchar(0x1B);
    putchar('[');
    putchar('3');
    putchar('A');
    
    //Change to Red text
    putchar(escRed[0]);
    putchar(escRed[1]);
    putchar(escRed[2]);
    putchar(escRed[3]);
    putchar(escRed[4]);
    
    printf((char*)pucTempString);
    
    // Move down 1 lines
    putchar(0x1B);
    putchar('[');
    putchar('1');
    putchar('B');
    
    // Move back 20 columns
    putchar(0x1B);
    putchar('[');
    putchar('2');
    putchar('0');
    putchar('D');
    
    // Save cursor position
    putchar(0x1B);
    putchar('[');
    putchar('s');
    
}

void updateTemperature(void)
{
    // Restore cursor position
    putchar(0x1B);
    putchar('[');
    putchar('u');
    
    printf("%d Celcius = Ref + %d ", currentTemp, (currentTemp - referenceTemp));
    
}

// SCIA  8-bit word, baud rate 0x000F, default, 1 STOP bit, no parity
void scia_init()
{

    CLK_enableSciaClock(myClk);

    // 1 stop bit,  No loopback
    // No parity,8 char bits,
    // async mode, idle-line protocol
    SCI_disableParity(mySci);
    SCI_setNumStopBits(mySci, SCI_NumStopBits_One);
    SCI_setCharLength(mySci, SCI_CharLength_8_Bits);
    
    SCI_enableTx(mySci);
    SCI_enableRx(mySci);
    SCI_enableTxInt(mySci);
    SCI_enableRxInt(mySci);

    // SCI BRR = LSPCLK/(SCI BAUDx8) - 1
    // Configured for 115.2kbps
#if (CPU_FRQ_60MHZ)
    SCI_setBaudRate(mySci, SCI_BaudRate_115_2_kBaud);    
#elif (CPU_FRQ_50MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)13);
#elif (CPU_FRQ_40MHZ)
    SCI_setBaudRate(mySci, (SCI_BaudRate_e)10);
#endif

    SCI_enableFifoEnh(mySci);
    SCI_resetTxFifo(mySci);
    SCI_clearTxFifoInt(mySci);
    SCI_resetChannels(mySci);
    SCI_setTxFifoIntLevel(mySci, SCI_FifoLevel_Empty);

    SCI_resetRxFifo(mySci);
    SCI_clearRxFifoInt(mySci);
    SCI_setRxFifoIntLevel(mySci, SCI_FifoLevel_4_Words);

    SCI_setPriority(mySci, SCI_Priority_FreeRun);
    
    SCI_enable(mySci);
  
    return;
}

void main()
{
    volatile int status = 0;
    volatile FILE *fid;
    
    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));
    mySci = SCI_init((void *)SCIA_BASE_ADDR, sizeof(SCI_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

    // Perform basic system initialization    
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    
    //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_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      

    // Initalize GPIO
    // 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);   

    // Initialize SCIA
    scia_init();
    
    // Initialize the ADC
    ADC_enableBandGap(myAdc);
    ADC_enableRefBuffers(myAdc);
    ADC_powerUp(myAdc);
    ADC_enable(myAdc);
    ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);

    ADC_enableTempSensor(myAdc);                                            //Connect channel A5 internally to the temperature sensor
    ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A5);    //Set SOC0 channel select to ADCINA5
    ADC_setSocChanNumber (myAdc, ADC_SocNumber_1, ADC_SocChanNumber_A5);    //Set SOC1 channel select to ADCINA5
    ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_7_cycles);   //Set SOC0 acquisition period to 7 ADCCLK
    ADC_setSocSampleWindow(myAdc, ADC_SocNumber_1, ADC_SocSampleWindow_7_cycles);   //Set SOC1 acquisition period to 7 ADCCLK
    ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC1);                 //Connect ADCINT1 to EOC1
    ADC_enableInt(myAdc, ADC_IntNumber_1);                                  //Enable ADCINT1

    // Set the flash OTP wait-states to minimum. This is important
    // for the performance of the temperature conversion function.
    FLASH_setup(myFlash);

    // Initalize GPIO
    GPIO_setPullUp(myGpio, GPIO_Number_28, GPIO_PullUp_Enable);
    GPIO_setPullUp(myGpio, GPIO_Number_29, GPIO_PullUp_Disable);
    GPIO_setQualification(myGpio, GPIO_Number_28, GPIO_Qual_ASync);
    GPIO_setMode(myGpio, GPIO_Number_28, GPIO_28_Mode_SCIRXDA);
    GPIO_setMode(myGpio, GPIO_Number_29, GPIO_29_Mode_SCITXDA);
    
    // Configure GPIO 0-3 as outputs
    GPIO_setMode(myGpio, GPIO_Number_0, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_1, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_2, GPIO_0_Mode_GeneralPurpose);
    GPIO_setMode(myGpio, GPIO_Number_3, GPIO_0_Mode_GeneralPurpose);
    
    GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_1, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_2, GPIO_Direction_Output);
    GPIO_setDirection(myGpio, GPIO_Number_3, GPIO_Direction_Output);
    
    GPIO_setMode(myGpio, GPIO_Number_12, GPIO_12_Mode_GeneralPurpose);
    GPIO_setDirection(myGpio, GPIO_Number_12, GPIO_Direction_Input);
    GPIO_setPullUp(myGpio, GPIO_Number_12, GPIO_PullUp_Disable);
    
    //Redirect STDOUT to SCI
    status = add_device("scia", _SSA, SCI_open, SCI_close, SCI_read, SCI_write, SCI_lseek, SCI_unlink, SCI_rename);
    fid = fopen("scia","w");
    freopen("scia:", "w", stdout);
    setvbuf(stdout, NULL, _IONBF, 0);
    
    //Print a TI Logo to STDOUT
    drawTILogo();
        
    //Scan the LEDs until the pushbutton is pressed
    while(GPIO_getData(myGpio, GPIO_Number_12) != 1)
    {       
        GPIO_setHigh(myGpio, GPIO_Number_0);
        GPIO_setHigh(myGpio, GPIO_Number_1);
        GPIO_setHigh(myGpio, GPIO_Number_2);
        GPIO_setLow(myGpio, GPIO_Number_3);
        DELAY_US(50000);

        GPIO_setHigh(myGpio, GPIO_Number_0);
        GPIO_setHigh(myGpio, GPIO_Number_1);
        GPIO_setLow(myGpio, GPIO_Number_2);
        GPIO_setHigh(myGpio, GPIO_Number_3);
        DELAY_US(50000);

        GPIO_setHigh(myGpio, GPIO_Number_0);
        GPIO_setLow(myGpio, GPIO_Number_1);
        GPIO_setHigh(myGpio, GPIO_Number_2);
        GPIO_setHigh(myGpio, GPIO_Number_3);
        DELAY_US(50000);

        GPIO_setLow(myGpio, GPIO_Number_0);
        GPIO_setHigh(myGpio, GPIO_Number_1);
        GPIO_setHigh(myGpio, GPIO_Number_2);
        GPIO_setHigh(myGpio, GPIO_Number_3);
        DELAY_US(500000);
    }
    
    //Clear out one of the text boxes so we can write more info to it
    clearTextBox();
    
    // Sample the temperature and save it as our reference
    referenceTemp = ADC_getTemperatureC(myAdc, sampleTemperature());
    
    // Light up the binary display with a median value (0x08)
    GPIO_setPortData(myGpio, GPIO_Port_A, (~0x08) & 0x0F);
    

    //Main program loop - continually sample temperature
    for(;;) {
        
        // Convert the raw temperature sensor measurement into temperature
        currentTemp = ADC_getTemperatureC(myAdc, sampleTemperature());
        
        updateTemperature();
        
        GPIO_setPortData(myGpio, GPIO_Port_A, (~(0x08 + (currentTemp - referenceTemp))) & 0x0F);
        
        DELAY_US(1000000);
        
        if(GPIO_getData(myGpio, GPIO_Number_12) == 1) {
            
            referenceTemp = ADC_getTemperatureC(myAdc, sampleTemperature());
        }
        
    }
}



22 comments:

  1. Vikram6 March 2014 at 09:44

    hey how to generate spwm?

    ReplyDelete
  2. Unknown18 April 2014 at 22:28

    Hello Azim, I have a problem about SCI because I want to send my ADC values to Matlab but it always receives an array of 512 numbers and these ones are not the correct values given by the ADC.
    Can you help me?

    ReplyDelete
    Replies
    1. Unknown19 April 2014 at 02:36

      hey check out ADC with SCI program above ...........use the same source code ............chk the video for connections

      Delete
    2. Unknown19 April 2014 at 10:27

      OK thank you. I have another question, how can I modify the sample rate of the ADC?

      Delete
    3. Unknown1 May 2014 at 05:42

      You cannot modify the sample rate because it is completely dependent on TI chip design . Refer the Datasheet .

      If u want to sample at lower time domain like around for example 1ms conversion per sample , u can use the timer module .....but if u want around 1ns ..then it is not possible ........ refer the sampling time in the adc document available in TI website

      Delete
    4. Anonymous7 May 2015 at 03:45

      Hi Mohamed
      would you mind posting some a tutorial about the I2C modules?
      Cheers.

      Delete
    5. Unknown22 June 2017 at 20:16

      Hii Azim, i need a code for single phase bridge inverter to control induction motor. can i use that stepper motor code to run induction motor?

      Delete
  3. Unknown30 April 2014 at 00:16

    God of C2000 launchpad... Bow you sir.. Great work and great initiative..!!! God bless you..!!!

    ReplyDelete
  4. Unknown19 September 2014 at 13:51

    Hi, do you have programs for the microcontroller FRDM-KL25Z??

    ReplyDelete
  5. Unknown19 September 2014 at 13:51

    Hi, i was wondering, if you have some examples for freedom kinetis kl25 by freescale?.
    Thank you

    ReplyDelete
  6. Ritu5 October 2014 at 18:22

    how to drive leds on gpio using pwm, to dim or brighten them?

    ReplyDelete
  7. Unknown4 December 2014 at 17:46

    Hi, i was wondering, if you have the UART example to send/receive more than 1 byte ?????
    Thank you

    ReplyDelete
  8. Unknown4 December 2014 at 19:11

    Hi, i was wondering, if you have the SPI example ? Thank you

    ReplyDelete
  9. Unknown2 September 2015 at 11:55

    Can we use DELAY_US function in active-flash programs??

    ReplyDelete
  10. Unknown16 October 2015 at 04:49

    Can we use PWM1B like PWM1A hight resolution outputs? Because I need 6 pwm outputs for 6 pulse inverter program.

    ReplyDelete
  11. Unknown12 February 2016 at 00:21

    Hi,please help us to get the outputs in below programs
    1).Develop a program to generate pwm pulse using adc .Set the adc sample frequency 5khz and generate pwm pulse whose duty cycle must vary in sinusoidal fashion (sine pwm).
    2).Develop a program to generate N-pulse of power frequency(50hz) and the pulse must vary in a sinusoidal pattern and the duty cycle should be adjustable.

    ReplyDelete
  12. Anonymous22 August 2016 at 04:59

    Where i will find ti_ascii.h file ??

    ReplyDelete
  13. Anonymous27 October 2016 at 11:16

    Dear author,
    Could you please send us i2c data receive and data write program. I can not be able to communicate with MPU6050.
    Thanks for everything.

    ReplyDelete
  14. logosfree18 January 2018 at 03:39

    Ram Logo Vectors

    ReplyDelete
  15. N.G.Kulkarni12 July 2018 at 02:16

    Dear Author,
    I want to check ADC values on monitor. I am using
    Matlab 6,CCS v3.1 with DSP TMS320F2812.I am checking program "ADC control of PWM duty cycle" in embedded.
    I have connected function generator output to ADC input ADCINA0 on ezdspF2812.Connected output of PWM on ezdspF2812 to the analog input of oscilloscope. I have also applied a pulse waveform toggling between 0.39 and 1.17 v every 2 sec.
    Can you please tell me how to read and check adc values
    on monitor? and How to change ADC values?
    My query is HOW TO CHECK ADC VALUES ON MONITOR?

    ReplyDelete
  16. Anonymous17 October 2018 at 14:52

    hello, i have been testing the transmission and reception code with the launchpad f28027 but somehow the reception when i type on putty it doesnt send back the data. can you assist?

    ReplyDelete
  17. Unknown10 December 2018 at 06:31

    does anyone know how to do phase shifting?

    ReplyDelete

Subscribe to: Posts (Atom)