Escolar Documentos
Profissional Documentos
Cultura Documentos
INSTITUTE OF TECHNOLOGY
COIMBATORE 641 048
DEPARTMENT OF
ELECTRONICS AND COMMUNICATION ENGINEERING
LABORATORY MANUAL
Prepared by
LIST OF EXPERIMENTS
OUTCOMES:
At the end of the course, the student should be able to:
Write programs in ARM for a specific Application
Interface memory and Write programs related to memory operations
Interface A/D and D/A convertors with ARM system
Analyze the performance of interrupt
Write programmes for interfacing keyboard, display, motor and sensor.
Formulate a mini project using embedded system
AIM
To study of ARM evaluation system using TI CC3200 Launch pad with Code Composer
Studio (CCS) Integrated Development Environment (IDE) and Interfacing Board with Terminal
Emulator Software.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY
CC3200 Launch pad
The high performance CC3200 is the industry's first single-chip Microcontroller
(MCU) with built-in Wi-Fi connectivity for the LaunchPad ecosystem. Created for the Internet of
Things (IoT), the SimpleLink Wi- Fi CC3200 device is a wireless MCU that integrates a high-
performance ARM Cortex-M4 MCU allowing customers to develop an entire application with a
single IC. With on-chip Wi-Fi, internet and robust security protocols, no prior Wi-Fi experience is
needed for faster development.
The CC3200 LaunchPad is a low-cost evaluation platform for ARM Cortex-
M4F-based microcontrollers. The LaunchPad design highlights the CC3200 Internet-on-a-chip
solution and WiFi capabilities. The CC3200 LaunchPad also features programmable user buttons,
RGB LED for custom applications and onboard emulation for debugging. The stackable headers of
the CC3200 LaunchPad XL interface demonstrate how easy it is to expand the functionality of the
LaunchPad when interfacing with other peripherals on many existing BoosterPack add-on boards
such as graphical displays, audio codec, antenna selection, environmental sensing, and much more.
Figure 1 shows a photo of the CC3200 LaunchPad.
Key Features
HARDWARE FEATURES
1. CC3200, Simple Link Wi-Fi, internet-on-a-chip solution with integrated MCU40-pin
Launchpad standard that leverages the Booster Pack ecosystem.
2. FTDI-based JTAG emulation with serial port for Flash programming
a. Supports both 4-wire JTAG and 2-wire SWD(Serial Wire Debug)
3. Two buttons and three LEDs for user interaction .Virtual COM port UART through USB on
PC.
4. On-board chip antenna with U.FL (miniature RF connector) for conducted testing.
5. On-board accelerometer and temperature sensor for out-of-box demo with option to isolate
them from the inter-integrated circuit (I2C) bus.
6. Micro USB connector for power and debug connections.
7. Headers for current measurement and external JTAG connection.
8. Bus-powered device with no external power required for Wi-Fi.
9. Long range transmission with highly optimized antenna (200m typical in open air with a 6dBi
antenna AP).
10. Can be powered externally, with 2xAA or 2xAAA alkaline batteries working down to 2.3V
typical.
INTERFACING BOARD
Top View:
Overview
Code Composer Studio (CCS) is the integrated development environment for the whole
span of TI Microcontrollers, DSPs and application processors. Code Composer Studio includes a
suite of tools used to develop and debug embedded applications. For all device families, CCS
includes compilers, source code editor, project build environment, debugger, profiler, simulators
and many other features.
The C compiler converts C source code into assembly language source code.
The assembler translates assembly language source files into machine language object files.
The standard run-time libraries contain ANSI standard run-time-support functions, compiler-
utility functions, floating-point arithmetic functions and I/O functions that are supported by the
C compiler.
The linker combines object files, library files and system or BIOS configuration files into a
single object module. The .out file is the executable program for the target device.
CCS Perspectives
The Code Composer GUI has two perspectives:
The Edit Perspective
The Debug Perspective
C:\ti\CC3200SDK\cc3200-sdk\driverlib\ccs\Release\driverlib.a
Code Composer will add the named project to your workspace and display it in the Project
Explorer panel. Based on your template selection, it will also add a file called main.c, main.asm
and open it for editing. Type in your Program Code in the main.c/ main.asm file and save it.CCS
can automatically save modified source files, build the program, open the debug perspective view,
connect and download it to the target (flash device), and then run the program to the beginning of
When the Ultra-Low-Power Advisor (ULP Advisor) appears, click the Proceed button.
When the download completes, CCS is in the Debug perspective. Notice the Debug tab in the upper
right-hand corner indicating that we are now in the CCS Debug view. Click and drag the
perspective tabs to the left until you can see all of both tabs. The program ran through the C-
environment initialization routine in the runtime support library and stopped at main() in main.c.
DEBUG ENVIRONMENT
The basic buttons that control the debug environment are located in the top of the Debug
pane. If you ever accidentally close the pane, your Debug controls will vanish.
At this point your code should be at the beginning of main(). Look for a small blue arrow
left of the opening brace of main() in the middle window. The blue arrow indicates where the
Program Counter (PC) is pointing to.
Click Suspend The code should stop somewhere in the middle of the program.
The Terminate button will terminate the active debug session, close the debugger and
return CCS to the CCS Edit perspective. It also sends a reset to the Launchpad board.
NOTE FOR ALL EXPERIMENTS:
1. Make sure your Launch Pad USB DEBUG port is connected to your PC
2. The chosen project for the experiment is active.
3. Build the project by clicking the Debug button on the menu bar
4. If there is a warning that the project was created with an earlier compiler version for
experiments which are taken from the library, it can be safely ignored.
5. When you import the project, it will be automatically copied into your workspace,
preserving the original files
6. All the modifications done are in the local workspace and does not get reflected on to the
CC3200-sdk folder. So you can safely do modifications save and always retrieve the demo
code from CC3200-sdk.
7. If you delete the project, accidentally or intentionally in the CCS the project in the
workspace is only deleted and the imported project stays intact in you workspace.
8. In the dialog box it is also possible to delete files from the disk which will erase the files
from the library but that is a general OS file delete operation and should not be attempted.
Device manager is needed to check on the ports being used and what is being initialized
RESULT:
Thus the study of ARM evaluation system using TI CC3200 Launch pad with Code
Composer Studio (CCS) Integrated Development Environment (IDE) and Interfacing Board with
Terminal Emulator Software was done successfully.
(OR)
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY
Analog to Digital Converter (ADC)
The ADC peripheral converts a continuous analog voltage into a discrete digital number. The
CC3200 device includes ADC modules with four input channels. Each ADC module features 12-
bit conversion resolution for the four input channels.
Features include:
The CC32xx device has an internal ADC which is rated to work at 500Ksps at 12bits resolution.
The ADC has 8 analog inputs which are multiplexed and out of these 4 are available for the user
on external pins while the remaining 4 are used for internal signals
This creates an effective sampling rate at each pin to be 500/8 = 62.5KHz
These are available on pins 57, 58, 59, 60. Out of these pin 57 is used as UART on the
Launchpad, so this pin is not readily available while debugging.
These pins are 4 alternate pins of the ADC input mux to ensure that the pins are sampled at a
regular interval.
PROCEDURE:
1. Connect the Embedded lab kit to PC using USB cable. Jumper position for ADC(POT)
6. Open TI Pinmux tool. Select the Device CC3200 and click the start button .Select the pin 58
using TI Pin configuration tool.
General-->Build-->ARM compiler-->Add
C:\ti\CC3200-SDK\cc3200sdk\driverlib
C:\ti\CC3200-SDK\cc3200sdk\inc
C:\ti\CC3200-SDK\cc3200sdk\example\common
C:\ti\CC3200SDK\cc3200-sdk\driverlib\ccs\Release\driverlib.a
14. Change the POT values and see the changing ADC values in Expression.
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
// Driverlib includes
#include "utils.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_adc.h"
#include "hw_ints.h"
#include "hw_gprcm.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "pin.h"
#include "adc.h"
#include "hw_gpio.h"
#include "gpio.h"
float ADC;
float readADC(unsigned long uiAdcInputPin);
void main()
{
PRCMPeripheralClkEnable(PRCM_ADC, PRCM_RUN_MODE_CLK);
ADCTimerConfig(ADC_BASE,2^17);
ADCTimerEnable(ADC_BASE);
ADCEnable(ADC_BASE);
PinTypeADC(PIN_58, 0XFF);
ADCChannelEnable(ADC_BASE, ADC_CH_1);
while(1)
{
}
}
{
unsigned long ulSample;
UtilsDelay(800000);
if(MAP_ADCFIFOLvlGet(ADC_BASE, ADC_CH_1))
{
ulSample = MAP_ADCFIFORead(ADC_BASE, ADC_CH_1);
ulSample = (ulSample & 0x3ffc)>>2;
}
return ulSample;
}
RESULT:
Thus the interfacing of ADC (POT) using TI CC3200 Launch pad with Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
A soft real-time system is a system where a critical real-time task gets priority over other
tasks and retains that priority until it completes. As in hard real time systems, kernel delays
need to be bounded.
4. Describe Trigger Generator?
The Trigger generator is a representation at the mechanism used to trigger the
execution of individual jobs. It is not really a separate hardware unit, typically it is a part of
an executive software. Many of the jobs are periodic i.e. they execute regularly. The schedule
for these jobs can be obtained offline and loaded as a look up table to be used by the
scheduler.
15. What are the Advantages and disadvantages of using macro and inline functions?
Advantage: Macros and Inline functions are efficient than calling a normal function. The
times spend in calling the function is saved in case of macros and inline functions as these
are included directly into the code.
Disadvantage: Macros and inline functions increased the size of executable code.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY:
In electronics, a digital-to-analog converter (DAC, D/A, DA, D2A, or D-to-A) is a function
that converts digital data (usually binary) into an analog signal (current, voltage, or electric charge).
An analog-to-digital converter (ADC) performs the reverse function. Unlike analog signals, digital
data can be transmitted, manipulated, and stored without degradation, albeit with more complex
equipment. But a DAC is needed to convert the digital signal to analog to drive an earphone or
loudspeaker amplifier in order to produce sound (analog air pressure waves).
DACs and their inverse, ADCs, are part of an enabling technology that has contributed
greatly to the digital revolution. To illustrate, consider a typical long-distance telephone call. The
caller's voice is converted into an analog electrical signal by a microphone, then the analog signal
is converted to a digital stream by an ADC. The digital stream is then divided into packets where
it may be sent along with other digital data, not necessarily audio. The digital packets are then
received at the destination, but each packet may take a completely different route and may not
even arrive at the destination in the correct time order. The digital voice data is then extracted
from the packets and assembled into a digital data stream. A DAC converts this into an analog
electrical signal, which drives an audio amplifier, which in turn drives a loudspeaker, which
finally produces sound.
There are several DAC architectures; the suitability of a DAC for a particular application is
determined by six main parameters: physical size, power consumption, resolution, speed,
accuracy, cost. Due to the complexity and the need for precisely matched components, all but the
most specialist DACs are implemented as integrated circuits (ICs). Digital-to-analog conversion
can degrade a signal, so a DAC should be specified that has insignificant errors in terms of the
application.
DACs are commonly used in music players to convert digital data streams into analog audio
signals. They are also used in televisions and mobile phones to convert digital video data into
analog video signals which connect to the screen drivers to display monochrome or color images.
PROCEDURE:
1. Connect the Embedded lab kit to PC using USB cable.
2. Open Code Composer Studio CCS V6.1.1
3. Project-->Import CCS Projects
4. Select the Target--> Wireless connectivity MCU, CC3200,
Connection-->Stellaris In-Circuit Debug Interface
Project Name DAC
5. Replace the code of main.c with the respective DAC code.
6. Open the TI pinmux tool.
7. Select the pins 5,6,7,8 using TI pinmux tool. Download the driverlib of the pinmuxconfig.c
and pinmuxconfig.h
8. Copy and paste the pinmuxconfig.c and pinmuxconfig.h in DAC code in CCS project
explorer.
9. Change the properties of the program,
General-->Build-->ARM compiler-->Add
C:\ti\CC3200-SDK\cc3200sdk\driverlib
C:\ti\CC3200-SDK\cc3200sdk\inc
C:\ti\CC3200-SDK\cc3200sdk\example\common
10. ARM Linker-->File search path-->Add
C:\ti\CC3200SDK\cc3200-sdk\driverlib\ccs\Release\driverlib.a
11. Build and debug the DAC main.c code.
12. Resume the main.c code.
13. Check the analog output in JP17 jumper using multimeter. The output voltage value is 1.6
volt.
PROGRAM:
#include <string.h>
#include "hw_types.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_ints.h"
#include "spi.h"
#include "rom.h"
#include "rom_map.h"
#include "utils.h"
#include "prcm.h"
void main()
{
PinMuxConfig();
GPIOPinWrite(GPIOA3_BASE, 0x10, 0x10);
PRCMPeripheralClkEnable(PRCM_GSPI,PRCM_RUN_MODE_CLK);
PRCMPeripheralReset(PRCM_GSPI);
SPIReset(GSPI_BASE);
SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
SPI_IF_BIT_RATE,SPI_MODE_MASTER,SPI_SUB_MODE_1,
(SPI_SW_CTRL_CS |SPI_4PIN_MODE |SPI_TURBO_OFF | SPI_CS_ACTIVELOW
|SPI_WL_16));
SPIEnable(GSPI_BASE);
ulUserData =0x3ffc;
while(1)
{
SPICSEnable(GSPI_BASE);
SPIDataPut(GSPI_BASE,ulUserData);
SPICSDisable(GSPI_BASE);
UtilsDelay(8000);
}
RESULT:
Thus the interfacing of DAC (POT) using TI CC3200 Launch pad with Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
9. What are little endian and big endian types of storage? How can you identify which type of allocation a
system follows?
The little endian memory representation allocates the least address to the least significant
bit and the big endian is where the highest significant bit takes up the least addressed
memory space. We can identify the systems usage by defining an integer value and
accessing it as a character.
15. What is ISR? Can they be passed any parameter and can they return a value?
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY:
A light-emitting diode (LED) is a two-lead semiconductor light source. It is a pn
junction diode, which emits light when activated. When a suitable voltage is applied to the
leads, electrons are able to recombine with electron holes within the device, releasing energy in
the form of photons. This effect is called electroluminescence, and the color of the light
(corresponding to the energy of the photon) is determined by the energy band gap of the
semiconductor.
An LED is often small in area (less than 1 mm2) and integrated optical components may be
used to shape its radiation pattern.
Appearing as practical electronic components in 1962, the earliest LEDs emitted low-
intensity infrared light. Infrared LEDs are still frequently used as transmitting elements in
remote-control circuits, such as those in remote controls for a wide variety of consumer
electronics. The first visible-light LEDs were also of low intensity, and limited to red. Modern
LEDs are available across the visible, ultraviolet, and infrared wavelengths, with very high
brightness.
Early LEDs were often used as indicator lamps for electronic devices, replacing small
incandescent bulbs. They were soon packaged into numeric readouts in the form of seven-
segment displays, and were commonly seen in digital clocks. In this experiments three different
colour leds interfacing with the CC3200 Launchpad using experimenter board.
PROCEDURE:
1. Connect the Embedded lab kit to PC using USB cable.
2. Open Code Composer Studio CCS V6.1.1
3. Project-->Import CCS Projects
4. Select the Target--> Wireless connectivity MCU, CC3200,
Connection-->Stellaris In-Circuit Debug Interface
Project Name LED
PROGRAM:
// Red, Orenge, Green On Board LED's Blinky
#include <stdio.h>
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "interrupt.h"
#include "hw_apps_rcm.h"
#include "prcm.h"
#include "rom.h"
#include "rom_map.h"
#include "prcm.h"
#include "utils.h"
#include "hw_gpio.h"
#include "pin.h"
#include "pinmux.h"
void main()
PinMuxConfig();
while(1)
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
RESULT:
Thus the interfacing of LED using TI CC3200 Launch pad with Code Composer Studio
(CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done successfully.
1. Define Process?
Process is a computational unit that processes on a CPU under the control of a scheduling
kernel of an OS. It has a process structure, called Process control block. A process defines a
sequentially executing program and its state.
5. Define Scheduling?
This is defined as a process of selection which says that a process has the right to use the
processor at given time.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY:
Pulse Width Modulation (PWM) is a method of digitally encoding analog signal levels.
High-resolution digital counters are used to generate a square wave of a given frequency, and the
duty cycle of that square wave is modulated to encode the analog signal. Typical applications for
PWM are switching power supplies, motor control, servo positioning and lighting control.
Pulse Width Modulation, or PWM, is a technique for getting analog results with digital
means. Digital control is used to create a square wave, a signal switched between on and off.
This on-off pattern can simulate voltages in between full on (~3 Volts) and off (0 Volts) by
changing the portion of the time the signal spends on versus the time that the signal spends off.
The duration of on time is called the pulse width. To get varying analog values, you change, or
modulate, that pulse width. If you repeat this on-off pattern fast enough with an LED for
example, the result is as if the signal is a steady voltage between 0 and 3v controlling the
brightness of the LED.
In the graphic below, the green lines represent a regular time period. This duration or
period is the inverse of the PWM frequency. In other words, with the Launch Pads PWM
frequency at about 500Hz, the green lines would measure 2 milliseconds each. A call to analog
Write() is on a scale of 0 255, such that analog Write(255) requests a 100% duty cycle (always
on), and analog Write(127) is a 50% duty cycle (on half the time) for example.
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_apps_rcm.h"
#include "hw_common_reg.h"
#include "interrupt.h"
#include "rom.h"
#include "rom_map.h"
#include "timer.h"
#include "utils.h"
#include "prcm.h"
#include "pinmux.h"
//*****************************************************************************
//*****************************************************************************
void UpdateDutyCycle(unsigned long ulBase, unsigned long ulTimer, unsigned char ucLevel)
MAP_TimerConfigure(ulBase,ulConfig);
MAP_TimerPrescaleSet(ulBase,ulTimer,0);
MAP_TimerControlLevel(ulBase,ulTimer,ucInvert);
MAP_TimerLoadSet(ulBase,ulTimer,TIMER_INTERVAL_RELOAD);
MAP_TimerMatchSet(ulBase,ulTimer,TIMER_INTERVAL_RELOAD);
void InitPWMModules()
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA3, PRCM_RUN_MODE_CLK);
SetupTimerPWMMode(TIMERA2_BASE, TIMER_B,
SetupTimerPWMMode(TIMERA3_BASE, TIMER_A,
SetupTimerPWMMode(TIMERA3_BASE, TIMER_B,
MAP_TimerEnable(TIMERA2_BASE,TIMER_B);
MAP_TimerEnable(TIMERA3_BASE,TIMER_A);
MAP_TimerEnable(TIMERA3_BASE,TIMER_B);
void DeInitPWMModules()
{ MAP_TimerDisable(TIMERA2_BASE, TIMER_B);
MAP_TimerDisable(TIMERA3_BASE, TIMER_A);
MAP_TimerDisable(TIMERA3_BASE, TIMER_B);
MAP_PRCMPeripheralClkDisable(PRCM_TIMERA2, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralClkDisable(PRCM_TIMERA3, PRCM_RUN_MODE_CLK);
static void
BoardInit(void)
{
MAP_IntVTableBaseSet((unsigned long)&g_pfnVectors[0]);
MAP_IntMasterEnable();
MAP_IntEnable(FAULT_SYSTICK);
PRCMCC3200MCUInit();
}
void main()
{
int iLoopCnt;
BoardInit();
InitPWMModules();
while(1)
{
Timer reload interval -> determines the time period of one cycle
Timer match value -> determines the duty cycle range [0, timer reload interval]
The computation of the timer reload interval and dutycycle granularity is as described below:
New time period = 0.5004375 ms Timer match value = (update[0, 255] * duty cycle granularity)
RESULT:
Thus the generating of Pulse Width Modulation (PWM) using PWM Module on TI CC3200
Launch pad with Code Composer Studio (CCS) Integrated Development Environment (IDE) and
TI Pinmux tool was done successfully.
13. What are the two essential units of a processor on an embedded system?
14. What does the execution unit of a processor in an embedded system do?
The execution unit implements data transfer and data conversion. It includes ALU and
circuits that execute instruction for jump, interrupt, etc.,
Microprocessor
Microcontroller
Embedded processor
Digital Signal Processor
Media Processor
AIM
To Interface a Real Time Clock (RTC) with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
A real-time clock (RTC) is a computer clock (most often in the form of an integrated circuit)
that keeps track of the current time. Although the term often refers to the devices in personal
computers, servers and embedded systems, RTCs are present in almost any electronic device which
needs to keep accurate time.
The term is used to avoid confusion with ordinary hardware clocks which are only signals
that govern digital electronics, and do not count time in human units. RTC should not be
confused with real-time computing, which shares its three-letter acronym but does not directly
relate to time of day.
Although keeping time can be done without an RTC using one has benefits:
RTCs often have an alternate source of power, so they can continue to keep time while the
primary source of power is off or unavailable. This alternate source of power is normally a
lithium battery in older systems, but some newer systems use a super capacitor, because they are
rechargeable and can be soldered. The alternate power source can also supply power to battery
backed RAM.
Most RTCs use a crystal oscillator, but some use the power line frequency. In many cases,
the oscillator's frequency is 32.768 kHz. This is the same frequency used in quartz clocks and
watches, and for the same reasons, namely that the frequency is exactly 215 cycles per second,
which is a convenient rate to use with simple binary counter circuits.
// Standard includes
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "utils.h"
#include "uart.h"
#include "uart_if.h"
#include "i2c_if.h"
#include "pinmux.h"
#define FOREVER 1
#define FAILURE -1
#define SUCCESS 0
if (SUCCESS != iRetVal) \
return iRetVal;}
/*
*/
switch(day)
case 0: UART_PRINT("Sunday");
break;
case 1: UART_PRINT("Monday");
case 2: UART_PRINT("Tuesday");
break;
case 3: UART_PRINT("Wednesday");
break;
case 4: UART_PRINT("Thursday");
break;
case 5: UART_PRINT("Friday");
break;
case 6: UART_PRINT("saturday");
break;
UART_PRINT("RTC TIME:");
UART_PRINT(" ");
UART_PRINT("%d", ((pucDataBuf[4]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[4]&0x0F)));
UART_PRINT("/");
UART_PRINT("%d", ((pucDataBuf[5]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[5]&0x0F)));
UART_PRINT("/");
UART_PRINT("%d", ((pucDataBuf[6]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[6]&0x0F)));
Day_Display(pucDataBuf[3]);
UART_PRINT(" ");
UART_PRINT("%d", ((pucDataBuf[2]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[2]&0x0F)));
UART_PRINT(":");
UART_PRINT("%d", ((pucDataBuf[1]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[1]&0x0F)));
UART_PRINT(":");
UART_PRINT("%d", ((pucDataBuf[0]&0xF0)>>4));
UART_PRINT("%d", ((pucDataBuf[0]&0x0F)));
UART_PRINT("\r\n");
int ProcessReadRegCommand()
ucRegOffset = 0x00;
ucRdLen = 7;
I2C_IF_Write(0x68,&ucRegOffset,1,0);
I2C_IF_Read(0x68,&aucReadDataBuf[0], ucRdLen);
DisplayTime_RTC(aucReadDataBuf);
return SUCCESS;
int ProcessWriteRegCommand()
ucWrLen = 7;
I2C_IF_Write(0x68,&aucDataBuf[0],ucWrLen+1,1);
return SUCCESS;
int ParseNProcessCmd(int a)
int iRetVal;
switch(a)
break;
break;
default: break;
return iRetVal;
MAP_IntMasterEnable();
MAP_IntEnable(FAULT_SYSTICK);
PRCMCC3200MCUInit();
void main()
int iRetVal;
BoardInit();
PinMuxConfig();
InitTerm();
I2C_IF_Open(I2C_MASTER_MODE_FST);
iRetVal = ParseNProcessCmd(1);
error_check(iRetVal);
while(FOREVER)
iRetVal = ParseNProcessCmd(2);
error_check(iRetVal);
MAP_UtilsDelay(90000000);
RESULT:
Thus the interfacing of Real Time Clock (RTC) with TI CC3200 Launch pad using Code
Composer Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
AIM
To Interface a serial port with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
PROCEDURE:
1. Connect the Embedded lab kit to PC using USB cable.
2. Open Code Composer Studio CCS V6.1.1
3. Project-->Import CCS Projects
4. Select the Target--> Wireless connectivity MCU, CC3200,
Connection-->Stellaris In-Circuit Debug Interface
Project Name UART USB,
5. Replace the code of main.c with the respective UART USB code.
6. Open the TI pinmux tool.
7. Select the pins 55, 57. Using TI pinmux tool. Download the driverlib of the pinmuxconfig.c
and pinmuxconfig.h
8. Copy and paste the pinmuxconfig.c and pinmuxconfig.h in RTC code in CCS project
explorer.
9. Change the properties of the program,
General-->Build-->ARM compiler-->Add
C:\ti\CC3200-SDK\cc3200sdk\driverlib
C:\ti\CC3200-SDK\cc3200sdk\inc
C:\ti\CC3200-SDK\cc3200sdk\example\common
10. ARM Linker-->File search path-->Add
C:\ti\CC3200SDK\cc3200-sdk\driverlib\ccs\Release\driverlib.a
11. Build and debug the UART USB main.c code.
12. Resume the main.c code.
13. Open the Tera term. And select the Serial-->Port: COM129: CC3200LP Dual
port(COM129)
Port--> COM31
Baud rate--> 115200-->Ok
15. Output of the UART USB.
PROGRAM:
// UART1
//---------------------------------------
// 55 | | |
// 57 | | |
// | | |
// Driverlib includes
#include "rom_map.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_ints.h"
#include "uart.h"
#include "interrupt.h"
#include "utils.h"
#include "prcm.h"
#include "pin_mux_config.h"
//char ragu;
unsigned int i;
void main()
PinMuxConfig();
UARTConfigSetExpClk(UARTA1_BASE,
PRCMPeripheralClockGet(PRCM_UARTA1), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
while(1)
UARTCharPut(UARTA1_BASE, msg[i]);
RESULT:
Thus the interfacing of Serial Port with TI CC3200 Launch pad using Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
14. What are the three conditions that must be satisfied by the re-entrant function?
All the arguments pass the values and none of the argument is a pointer.
When a non-atomic operation that function should not operate on the function declared
outside.
A function does does not call a function by itself when it is not reentrant.
AIM
To Interface a Keyboard with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
A keypad is a set of buttons arranged in a block or "pad" which usually bear digits, symbols
and usually a complete set of alphabetical letters. If it mostly contains numbers then it can also be
called a numeric keypad. Keypads are found on many alphanumeric keyboards and on other
devices such as calculators, push-button telephones, combination locks, and digital door locks,
which require mainly numeric input.
A computer keyboard usually has a small numeric keypad on the side, in addition to the
other number keys on the top, but with a calculator-style arrangement of buttons that allow more
efficient entry of numerical data. This number pad (commonly abbreviated to "numpad") is
usually positioned on the right side of the keyboard because most people are right-handed.
Many laptop computers have special function keys which turn part of the alphabetical
keyboard into a numerical keypad as there is insufficient space to allow a separate keypad to be
built into the laptop's chassis. Separate external plug-in keypads can be purchased.
As a general rule, the keys on calculator-style keypads are arranged such that 123 is on
the bottom row, whereas in a telephone keypad, there will be the 123-keys at the top. A phone
key-pad also has the special buttons labelled * (star) and # (octothorpe, number sign, "pound",
"hex" or "hash") on either side of the zero key. Most of the keys on a telephone also bear letters
which have had several auxiliary uses, such as remembering area codes or whole telephone
numbers.
The keypad of a calculator contains the digits 0 through 9, from bottom upwards, together
with the four arithmetic operations, the decimal point and other more advanced mathematical
functions.
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "utils.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_adc.h"
#include "hw_ints.h"
#include "hw_gprcm.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "pin.h"
#include "hw_gpio.h"
#include "gpio.h"
#include "pin_mux_config.h"
void disp();
unsigned char seg_no[]={0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c,
0x58, 0x5e, 0x79, 0x71}; // Segment number 0,1,2,3,4,5,6,7,8,9,A,b,c,d,E,F
void main()
PinMuxConfig();
while(1)
disp(1);
a++;
x++;
disp(2);
x++;
disp(3);
a2++;
x++;
disp(4);
a3++;
x++;
disp(5);
a4++;
x++;
disp(6);
a5++;
x++;
disp(7);
a6++;
x++;
disp(8);
a7++;
x++;
a8++;
x++;
disp(10);
a9++;
x++;
disp(11);
a10++;
x++;
disp(12);
a11++;
x++;
disp(13);
a12++;
x++;
disp(14);
a13++;
x++;
disp(15);
a14++;
x++;
disp(0);
a15++;
x++;
void disp(Numb)
UtilsDelay(800);
UtilsDelay(800);
UtilsDelay(800);
UtilsDelay(800);
RESULT:
Thus the interfacing of Keyboard with TI CC3200 Launch pad using Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
3. Define stack.
A structure with a series of elements which uses LIFO mode.
An element can be pushed only at the top and only one pointer is used for POP.
Used when an element is not accessible through pointer and index, but only
through LIFO.
4. Define List.
Each element has a pointer to its next element.
Only the first element is identifiable and it is done using list-top pointer (header).
Other element has no direct access and is accessed through the first element.
8. Define Class.
A class declaration defines a new type that links code and data. It is then used to declare
objects of that class. Thus a class is an logical abstraction but an object has physical existence.
AIM
To Interface a LCD with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
A liquid-crystal display (LCD) is a flat-panel display or other electronic visual display that
uses the light-modulating properties of liquid crystals. Liquid crystals do not emit light directly.
LCDs are available to display arbitrary images (as in a general-purpose computer display) or
fixed images with low information content, which can be displayed or hidden, such as preset
words, digits, and 7-segment displays as in a digital clock. They use the same basic technology,
except that arbitrary images are made up of a large number of small pixels, while other displays
have larger elements.
LCDs are used in a wide range of applications including computer monitors,
televisions, instrument panels, aircraft cockpit displays, and signage. They are common in
consumer devices such as DVD players, gaming devices, clocks, watches, calculators, and
telephones, and have replaced cathode ray tube (CRT) displays in nearly all applications. They
are available in a wider range of screen sizes than CRT and plasma displays, and since they do
not use phosphors, they do not suffer image burn-in. LCDs are, however, susceptible to image
persistence.
//RS=15
//EN=50
//D4=03
//D5=04
//D6=05
//D7=06
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "utils.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_adc.h"
#include "hw_ints.h"
#include "hw_gprcm.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "pin.h"
#include "gpio.h"
#include "pin_mux_config.h"
void main()
PinMuxConfig();
UtilsDelay(80);
commd(0x28);
commd(0x06);
commd(0x0C);
commd(0x01);
commd(0x80);
while(1)
commd(0x01);
commd(0x80);
data(msg[j]);
UtilsDelay(2000000);
//15 rs
//50 EN
for(i=0;i<640;i++);
for(i=0;i<640;i++);
for(i=0;i<640;i++);
for(i=0;i<640;i++);
RESULT:
Thus the interfacing of LCD with TI CC3200 Launch pad using Code Composer Studio
(CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done successfully.
AIM
To Interface EEPROM with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
EEPROM:
// Standard includes
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "utils.h"
#include "uart.h"
#include "i2c_if.h"
#include "pin_mux_config.h"
#include "gpio.h"
//************************************************************************//
//!
//!
//
//*****************************************************************************
MAP_IntVTableBaseSet((unsigned long)&g_pfnVectors[0]);
MAP_IntMasterEnable();
MAP_IntEnable(FAULT_SYSTICK);
PRCMCC3200MCUInit();
BoardInit();
PinMuxConfig();
aucDataBuf[0]=0x00;
aucDataBuf[1]=0x00;
aucDataBuf[2]=0x40;
I2C_IF_Open(I2C_MASTER_MODE_FST);
while(1)
UtilsDelay(80000);
I2C_IF_Write(ucDevAddr,&aucDataBuf[0],3,0);
I2C_IF_Read(ucDevAddr,&RCVDataBuf[0],2);
UtilsDelay(800000);
RESULT:
Thus the interfacing of EEPROM and Interrupt with TI CC3200 Launch pad using Code
Composer Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
3. Define stack.
A structure with a series of elements which uses LIFO mode.
An element can be pushed only at the top and only one pointer is used for POP.
Used when an element is not accessible through pointer and index, but only
through LIFO.
4. Define List.
Each element has a pointer to its next element.
Only the first element is identifiable and it is done using list-top pointer (header).
Other element has no direct access and is accessed through the first element.
8. Define Class.
A class declaration defines a new type that links code and data. It is then used to declare
objects of that class. Thus a class is an logical abstraction but an object has physical existence.
AIM
To study of Mailbox using TI CC3200 Launch pad with Code Composer Studio (CCS)
Integrated Development Environment (IDE) and Interfacing Board with Terminal Emulator
Software.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI pinmux tool
THEORY:
Information transfer is sometimes needed among tasks or between the task and the ISR.
Information transfer can be also called inter-task communication.
There are two ways to implement it: through the global variable or by sending messages.
When using the global variable, it is important to ensure that each task or ISR possesses the
variable alone. The only way to ensure it is enabling the interrupt. When two tasks share one
variable, each task possesses the variable alone through firstly enabling then disabling the
interrupt or by the semaphore. Please note that a task can communicate with the ISR only
through the global variable and the task wont know when the global variable has been modified
by the ISR (unless the ISR sends signals to the task in manner of semaphore or the task keeps
searching the variables value). In this case, CooCox CoOS supplies the mailboxes and the
message queues to avoid the problems above.
* Mailboxes
System or the user code can send a message by the core services. A typical mail message,
also known as the exchange of information, refers to a task or an ISR using a pointer variable,
through the core services to put a message (that is, a pointer) into the mailbox. Similarly, one or
more tasks can receive this message by the core services. The tasks sending and receiving the
message promise that the content that the pointer points to is just that piece of message.
You can create a mailbox by calling CoCreateMbox ( ) in CooCox CoOS. After being created
successfully, there wont be any message inside. You can send a message to the mailbox by
calling CoPostMail ( ) or isr_PostMail ( ) respectively in a task or the ISR. You can also get a
message from the mailbox by calling CoPendMail ( ) or CoAcceptMail ( ).
*
void myTaskA(void* pdata)
{
void* pmail;
StatusType err;
..........
mboxID = CoCreateMbox(EVENT_SORT_TYPE_PRIO); //Sort by preemptive
priority pmail = CoPendMail(mboxID,0,&err);
..........
}
void myTaskB(void* pdata)
{
......
CoPostMail(mboxID,"hello,world");
......
}
void myISR(void)
{
CoEnterISR ( );
......
isr_PostMail(mboxID,"hello,CooCox");
CoExitISR ( );
}
Message queue is just an array of mailboxes used to send messages to the task in fact. The
task or the ISR can put multiple messages (that is, the pointers of the message) to the message
queue through the core services. Similarly, one or more tasks can receive this message by the
core services. The tasks sending and receiving the message promise that the content that the
pointer points to is just that piece of message.
The difference between the mailbox and the message queue is that the former can store only
one piece of message while the latter can store multiple of it. The maximum pieces of message
stored in a queue are determined by the user when creating the queue in CooCox CoOS.
In CooCox CoOS, message queue is composed of two parts: one is the struct which pointed to
the message queue; the other is the waiting list which composed of the tasks waiting for this
message queue. The waiting list supports two kinds of sorting: FIFO and preemptive priority.
The sorting mode is determined by the user when creating the message queue.
You can create a message queue by calling CoCreateQueue ( ) in CooCox CoOS. After
being created successfully, there wont be any message inside. You can send a message to the
message queue by calling CoPostQueueMail ( ) or isr_PostQueueMaill ( ) respectively in a task
or the ISR. Similarly, you can also obtain a message from the message queue by calling
CoPendQueueMail ( ) or CoAcceptQueueMail ( ).
*
void myTaskA(void* pdata)
{
void* pmail;
Void* queue[5];
StatusType err;
..........
queueID = CoCreateQueue(queue,5,EVENT_SORT_TYPE_PRIO);
//5 grade, sorting by preemptive priority
pmail = CoPendQueueMail(queueID ,0,&err);
..........
}
void myTaskB(void* pdata)
{
......
CoPostQueueMail(queueID ,"hello,world");
RESULT:
Thus the study of Mailbox concept using TI CC3200 Launch pad with Code Composer
Studio (CCS) Integrated Development Environment (IDE) and Interfacing Board with Terminal
Emulator Software was done successfully.
15. What are the three conditions that must be satisfied by the re-entrant function?
All the arguments pass the values and none of the argument is a pointer.
When a non-atomic operation that function should not operate on the function declared
outside.
A function does does not call a function by itself when it is not reentrant.
AIM
To study the interrupt performance characteristics of ARM and FPGA and determine their efficiency
APPARATUS REQUIED
ARM + FPGA (Spartan-3E [XC3S250E]) Evaluation board.
5V/2A Adapter.
USB Cable
THEORY:
The complexity of the design of a new SoC has consistently increased during the latest 10
years, due to the smartphone/tablet revolution which pushed the semiconductor industry to
release constantly faster and less power greedy chips. The time-to-market requirements have
shrunk as well, giving even more challenges to engineers working in this sector: develop a
complicated design and verify it thoroughly in a very short time, mainly through pre-silicon
verification since the increased cost of silicon masks has made Test Chips less attractive.
With the increasing complexity of cores, the validation phase now has even more
importance during the development. The risk of shipping buggy SoCs must be minimized
through careful analysis and the use of different verification and validation processes, starting
from the very beginning of the project and continuing through each design phase until the end of
the life cycle of the chip.
The design of the SoC is usually just a small part of the job compared to the entire effort
necessary to develop a new product - the majority of the costs are in the verification of the
product and developing the software to run on it.
The chart shows that the growth of the costs associated with validation and software have
been growing exponentially when compared with the process technology scale; this is the reason
why they both see a dramatic rise in importance, not only at the end of the design phase but from
the beginning of the project, where hardware design, verification and software are performed
simultaneously.
There are mainly three methods to test a design before the tape-out, each of them has
different advantages and disadvantages thus all three are used during the development of a core.
Simulation is used from the very beginning of the design because it gives a complete
view of the signals in the RTL and it is often used to verify functionality at the module level.
When the structure of the chip is close to being completed, the limits of this method start to rise
quickly: the huge computational power required for the simulation limits the speed of the
execution to 100Hz for the latest cores, requiring too much time to execute a boot of an
operating system for example.
The performance problem could be partially solved by using an emulator which, with
specialized hardware, can reach a speed of 1MHz, still keeping the same complete view of the
Last but not least is the use of FPGAs: this method has been often relegated to being used
during the later stages of validation, or to easily replicate a design for software developers, since
it does not enable a complete (and not even a sufficient) view of the status of the system which
helps the hardware developers to find the source of an error. Additionally the burden of having to
setup a FPGA with the right hardware and all the components needed to have a functional FPGA
prototyping board make this method less attractive for designers.
Even though the cost of a simulator is the cheapest and the most scalable option for
testing a design, each solution must be taken in consideration together with the number of gates
and speed achievable. In the following graph it is possible to see how the different modus
operandi compares using this new metric relative to a final silicon chip:
As can be easily deduced from the graph, the simulator has the least attractive price/speed
ratio whilst the FPGA has the most attractive one. This is the main reason that convinced ARM
to start to think about to using FPGAs as integral part of its verification process and developing a
new FPGA farm for this purpose.
The structure of the farm has been designed for scalability. Each module of the farm is
composed by a Linux server, an mbed and four pairs of FPGA boards/DSTREAM debugger. The
server is the main access for the users of the farm and, through terminal, gives access to all of the
operations that can be executed on the FPGA such as mapping the design on the FPGA to the
read/write from the serial port.
Engineers who designed the farm did not have to look very far to find a suitable FPGA
board as ARM already had what they were looking for: ARMs Versatile Express series boards
fit perfectly for the scope of the farm, giving all the necessary flexibility and scalability.
Software developers can use DS-5 Development Studio for the whole life cycle of SoC
development, from the design phase, where no silicon is available to a final product, right
through to the final product. This aspect is particularly important since the costs and time to get
familiar with different tools with different characteristics can jeopardize the advantages of
having an early access to the core in development.
The usage of the FPGA farm is not limited to CPU design within ARM: The Media
Processing Division uses it as a part of its development process to test their GPUs.The scalability
of the solution has been proven by the 86 FPGA boards currently installed in two farms in
Cambridge and more are being installed. Access to these boards is guaranteed from all ARM
RESULT:
Thus the Study of interrupt performance characteristics of ARM and FPGA was done successfully.
3. What is an antifuse?
Antifuses are widely used to permanently program integrated circuits (ICs).
Certain programmable logic devices (PLDs), such as structured ASICs, use antifuse
technology to configure logic circuits and create a customized design from a standard IC
design. Antifuse PLDs are one time programmable in contrast to other PLDs that
are SRAM based and which may be reprogrammed to fix logic bugs or add new functions.
15. The main importance of ARM micro-processors is providing operation with Low cost
and low power consumption
18. The additional duplicate register used in ARM machines are called as Banked registers
20. The addressing mode where the EA of the operand is the contents of Rn is Post-indexed
mode
AIM
To flash LEDs with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
A light-emitting diode (LED) is a two-lead semiconductor light source. It is a pn
junction diode, which emits light when activated. When a suitable voltage is applied to the
leads, electrons are able to recombine with electron holes within the device, releasing energy in
the form of photons. This effect is called electroluminescence, and the color of the light
(corresponding to the energy of the photon) is determined by the energy band gap of the
semiconductor.
An LED is often small in area (less than 1 mm2) and integrated optical components may be
used to shape its radiation pattern.
Appearing as practical electronic components in 1962, the earliest LEDs emitted low-
intensity infrared light. Infrared LEDs are still frequently used as transmitting elements in
remote-control circuits, such as those in remote controls for a wide variety of consumer
electronics. The first visible-light LEDs were also of low intensity, and limited to red. Modern
LEDs are available across the visible ,ultraviolet, and infrared wavelengths, with very high
brightness.
Early LEDs were often used as indicator lamps for electronic devices, replacing small
incandescent bulbs. They were soon packaged into numeric readouts in the form of seven-
segment displays, and were commonly seen in digital clocks.
In this experiments three different colour leds interfacing with the CC3200 launchpad using
experimenter board.
D5 GREEN (GPIO_11) Glows when the GPIO is logic-1
D6 YELLOW (GPIO_10) Glows when the GPIO is logic-1
D7 RED (GPIO_09) Glows when the GPIO is logic-1
//---------------------------------------
// 64 | GPIO09 | A1 | 0X02
// 01 | GPIO10 | A1 | 0X04
// 02 | GPIO11 | A1 | 0X08
#include <stdio.h>
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "interrupt.h"
#include "hw_apps_rcm.h"
#include "prcm.h"
#include "rom.h"
#include "rom_map.h"
#include "prcm.h"
#include "gpio.h"
#include "utils.h"
#include "pin_mux_config.h"
void main()
while(1)
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
RESULT:
Thus the flashing of LEDS with TI CC3200 Launch pad using Code Composer Studio
(CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done successfully.
19. What are the four types of data transfer used in USB?
Controlled transfer
Bulk transfer
Interrupt driven data transfer
Iso-synchronous transfer
AIM
To Interface a stepper motor with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
A stepper motor or step motor or stepping motor is a brushless DC electric motor that divides
a full rotation into a number of equal steps. The motor's position can then be commanded to
move and hold at one of these steps without any feedback sensor (an open-loop controller), as
long as the motor is carefully sized to the application in respect to torque and speed.
Switched reluctance motors are very large stepping motors with a reduced pole count, and
generally are closed-loop commutated.
DC brushed motors rotate continuously when DC voltage is applied to their terminals. The
stepper motor is known by its property to convert a train of input pulses (typically square wave
pulses) into a precisely defined increment in the shaft position. Each pulse moves the shaft
through a fixed angle.
Stepper motors effectively have multiple "toothed" electromagnets arranged around a
central gear-shaped piece of iron. The electromagnets are energized by an external driver
circuit or a microcontroller. To make the motor shaft turn, first, one electromagnet is given
power, which magnetically attracts the gear's teeth. When the gear's teeth are aligned to the first
electromagnet, they are slightly offset from the next electromagnet. This means that when the
next electromagnet is turned on and the first is turned off, the gear rotates slightly to align with
the next one. From there the process is repeated. Each of those rotations is called a "step", with
an integer number of steps making a full rotation. In that way, the motor can be turned by a
precise angle.
#include <stdio.h>
// Driverlib includes
#include "hw_types.h"
#include "hw_ints.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "interrupt.h"
#include "hw_apps_rcm.h"
#include "prcm.h"
#include "rom.h"
#include "rom_map.h"
#include "prcm.h"
#include "gpio.h"
#include "utils.h"
#include "pin_mux_config.h"
void main()
PinMuxConfig();
while(1)
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
MAP_UtilsDelay(8000000);
RESULT:
Thus the Interfacing of Stepper Motor with TI CC3200 Launch pad using Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
Microprocessor
Microcontroller
Embedded processor
Digital Signal Processor
Media Processor
7. Define FPGAs
Field Programmable Gate Arrays (FPGAs) can be used to implement just about any
hardware design. One common use is to prototype a lump of hardware that will eventually
find its way into an ASIC.
9. Define bus.
Buses: The exchange of information. Information is transferred between units of the
microcomputer by collections of conductors called buses. There will be one conductor for each
bit of information to be passed, e.g., 16 lines for a 16 bit address bus. There will be address,
control, and data buses.
12. Give the steps for accomplishing input output data transfer.
Accomplishing input/output data transfer there are three main methods used to
perform/control input/output data transfers. They are,
Software programming (scanning or polling)
interrupt controlled
Direct memory access (DMA)
AIM
To Interface temperature sensor with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
LM35
Description
The LM35 series are precision integrated-circuit temperature devices with an output voltage
linearly-proportional to the Centigrade temperature. The LM35 device has an advantage over
linear temperature sensors calibrated in Kelvin, as the user is not required to subtract a large
constant voltage from the output to obtain convenient Centigrade scaling. The LM35 device does
not require any external calibration or trimming to provide typical
Features
Calibrated Directly in Celsius (Centigrade)
Linear + 10-mV/C Scale Factor
0.5C Ensured Accuracy (at 25C)
Rated for Full 55C to 150C Range
Suitable for Remote Applications
1. Connect embedded lab kit to PC using USB cable. Jumper position for temperature sensor.
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
// Driverlib includes
#include "utils.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_adc.h"
#include "hw_ints.h"
#include "hw_gprcm.h"
#include "rom.h"
#include "rom_map.h"
#include "interrupt.h"
#include "prcm.h"
#include "pin.h"
#include "adc.h"
#include "hw_gpio.h"
#include "gpio.h"
float ADC;
void main()
ADCTimerConfig(ADC_BASE,2^17);
ADCTimerEnable(ADC_BASE);
ADCEnable(ADC_BASE);
PinTypeADC(PIN_59, 0XFF);
ADCChannelEnable(ADC_BASE, ADC_CH_2);
while(1)
ADC=readADC(PIN_59);
UtilsDelay(800000);
if(MAP_ADCFIFOLvlGet(ADC_BASE, ADC_CH_2))
return ulSample;
5. What is ISR? Can they be passed any parameter and can they return a value?
ISR refers to the Interrupt Service Routines. These are procedures stored at specific memory
addresses which are called when certain type of interrupt occurs. The ISRs cannot return a value
and they cannot be passed any parameters.
AIM
To Implement Zigbee Protocol with TI CC3200 using CCS IDE & TI Pinmux tool.
APPARATUS REQUIED
1. TI CC3200 Launch Pad
2. Computer with CCS IDE Software
3. Tera Term (Terminal Emulator) software
4. Interfacing board
5. USB Cable
6. Connecting wires
7. TI Pinmux tool
THEORY:
UART
ZIGBEE
PROCEDURE:
1. Connect the Embedded lab kit to PC using USB cable. Connect reciver zigbee module to
PC using USB cable.
2. Open Code Composer Studio CCS V6.1.1
3. Project-->Import CCS Projects
4. Select the Target--> Wireless connectivity MCU, CC3200,
Connection-->Stellaris In-Circuit Debug Interface
Project Name UART Zigbee
5. Replace the main.c code with the respective UART zigbee code.
6. Open the TI pinmux tool.
7. Select the pins 53, 45. And download the pin_mux_config.c , pin_mux_config.h.
8. Copy and paste the pinmuxconfig.c and pinmuxconfig.h in UART Zigbee code in CCS
project explorer.
9. Change the properties of the program,
General-->Build-->ARM compiler-->Add
C:\ti\CC3200-SDK\cc3200sdk\driverlib
C:\ti\CC3200-SDK\cc3200sdk\inc
C:\ti\CC3200-SDK\cc3200sdk\example\common
10. ARM Linker-->File search path-->Add
C:\ti\CC3200SDK\cc3200-sdk\driverlib\ccs\Release\driverlib.a
11. Build and debug the Led_ blinky main.c code.
12. Resume the main.c code.
13. Open the computer management ,
Device manager-->Ports-->CC3200LP Dual Port(COM31)
Note down the Port number-->COM31
14. Open the Tera term. And select the Serial-->Port:COM129: CC3200LP Dual
port(COM129)
15. Select the Setup-->Serial port.
In Serial port setup, Select
Port--> COM31
Baud rate--> 115200-->Ok
16. Output of the UART zigbee.
// UART zigbee
//---------------------------------------
// Driverlib includes
#include "rom.h"
#include "rom_map.h"
#include "hw_memmap.h"
#include "hw_common_reg.h"
#include "hw_types.h"
#include "hw_ints.h"
#include "uart.h"
#include "interrupt.h"
#include "utils.h"
#include "prcm.h"
#include "pin_mux_config.h"
unsigned int i;
void main()
UARTConfigSetExpClk(UARTA0_BASE,PRCMPeripheralClockGet(PRCM_UARTA0), 115200,
while(1)
UARTCharPut(UARTA0_BASE, msg[i]);
UtilsDelay(8000000);
RESULT:
Thus the Interfacing of Zigbee Protocol with TI CC3200 Launch pad using Code Composer
Studio (CCS) Integrated Development Environment (IDE) and TI Pinmux tool was done
successfully.
(OR)
11. What is an embedded system? Differentiate between embedded system and real-time
system.
An embedded system is some combination of computer hardware and software, either
fixed in capability or programmable, that is specifically designed for a particular function.
Real-time systems are the ones that are designed to provide a result within a specific
time-frame.
A soft real-time system is a system where a critical real-time task gets priority over other
tasks and retains that priority until it completes. As in hard real time systems, kernel delays
need to be bounded.
14. Describe Trigger Generator?
The Trigger generator is a representation at the mechanism used to trigger the
execution of individual jobs. It is not really a separate hardware unit, typically it is a part of
an executive software. Many of the jobs are periodic i.e. they execute regularly. The schedule
for these jobs can be obtained offline and loaded as a look up table to be used by the
scheduler.