Emb Lab Manual Final

List of Experiments
1. Study of ARM Evaluation System

2. Interfacing ADC and DAC
3. Interfacing PWM and LED
4. Interfacing Real-time clock and Serial Port
5. Interfacing Keypad and LCD
6. Interfacing EEPROM and Interrupt
7. Mailbox
8. Interrupt performance characteristics of ARM and FPGA
9. Flashing of LED
10. Interfacing Stepper motor and Temperature sensor
11. Interfacing Zig-bee Protocol and ARM
1
EC6711 Embedded Systems Laboratory
User Manual
Overview of the Board
1. VSK – 2148
The ARM7 LPC2148 Syllabus Board based on a 32/16 Bit ARM7TDMI-s CPU with real
time Emulation and Embedded Trace support, that combines with microcontroller with
embedded high speed 512KB flash memory. It can also work in 16-bit Thumb Mode.
With the interfaced peripherals and onboard peripherals, plentiful practical codes can be
implemented with ARM7 LPC2148 Syllabus Board. The board has fast and reliable tools
that can satisfy the needs of experienced engineers and beginners alike.
2
User Manual
ARM7 LPC2148 Syllabus Boards achieve their small size through Modern SMD
technology and Multilayer Design. All Controller signals and ports extend from the
controller to high density pitch Connectors of the board.
ARM7 LPC2148 Syllabus Board Hardware Manual Describes the board’s design and
functions. Precise Specifications for the NXP LPC2148 Microcontroller can be found in
the enclosed Microcontroller Data sheet/User’s Manual. In this hardware manual,
schematic diagrams and Block Diagrams are attached.
IAR Embedded Workbench is the preferable IDE for this VSK-2148 board.
2. VLEDD – 02
The VLEDD – 02 boards is having 12 LEDs. The LEDs are controlled by two transistors.
The operating voltage can be varied as per the industrial requirement. The possible
3
voltages are 3.3V, 5V and 12V. The operational voltage can be selected depending on the
hardware design.
The LED sequence D1, D2, D3, D7, D8 and D9 are controlled by the transistor Q1 and
the sequence D4, D5, D6, D10, D11 and D12 are controlled by the transistor Q2.
The board is also having an LDR. The LEDs can be used to lighten the zone with this
output of the LDR.
3. Vi -XBB
The Xbee board is a Wireless board that has to be interfaced with the controller. It can be
interfaced either by RS232 cable or USB cable. A switch is provided to select the mode
of communication.
4
User Manual
Vi Microsystems Pvt. Ltd.
About the Software
IAR EMBEDDED WORKBENCH FOR ARM

The IAR Embedded Workbench® IDE is a very powerful Integrated Development
Environment, which allows you to develop and manage complete embedded application
projects.
The IAR Embedded Workbench IDE
The IDE is the framework where all necessary tools are seamlessly integrated:
 The highly optimizing IAR C/C++ Compiler
 The IAR Assembler
 The versatile IAR ILINK Linker, including accompanying tools
 A powerful editor
 A project manager
 A command line build utility
 The IAR C-SPY® Debugger, a state-of-the-art high-level language

debugger.
IAR Embedded Workbench is available for many microprocessors and

microcontrollers in the 8-, 16-, and 32-bit segments, allowing you to stay within a well-
known development environment also for your next project. It provides an easy-to-learn
and highly efficient development environment with maximum code inheritance
capabilities, comprehensive and specific target support. IAR Embedded Workbench
promotes a useful working methodology, and you can reduce your development time
significantly by using the IAR Systems tools.
5
User Manual
FEATURES
The IDE is a flexible integrated development environment, allowing you to

develop applications for a variety of target processors. It provides a convenient Windows
interface for rapid development and debugging.
PROJECT MANAGEMNET
The IDE comes with functions that will help you to stay in control of all project
modules, for example, C or C++ source code files, assembler files, include files, and
other related modules. You create workspaces and let them contain one or several
projects. Files can be grouped, and options can be set on all levels—project, group, or
file. Changes are tracked so that a request for rebuild will retranslate all required
modules, making sure that no executable files contain out-of-date modules. This list
shows some additional features:
 Project templates to create a project that can be built and executed out of
the box for a smooth development startup
 Hierarchical project representation
 Source browser with an hierarchical symbol presentation
 Options can be set globally, on groups of source files, or on individual source files
 The Make command automatically detects changes and performs only the
required operations.
 Text-based project files
 Custom Build utility to expand the standard tool chain in an easy way
 Command lines build with the project file as input.
6
User Manual
FLASH MAGIC
NXP Semiconductors produce a range of Microcontrollers that feature both on-

chip Flash Memory and the ability to be reprogrammed using In-System Programming
technology. Flash Magic is Windows software that allows easy access to all the ISP
features provided by the devices. These features include:
 Erasing the Flash memory (individual blocks or the whole device)

 Programming the Flash memory and Reading Flash memory
 Modifying the Boot Vector and Status Byte
 Performing a blank check on a section of Flash memory
 Reading the signature bytes and Reading and writing the security bits
 Direct load of a new baud rate (high speed communications)
 Sending commands to place device in Boot loader mode
Flash Magic provides a clear and simple user interface to these features and more
as described in the following sections. Under Windows, only one application may have
access the COM Port at any one time, preventing other applications from using the COM
Port. Flash Magic only obtains access to the selected COM Port when ISP operations are
being performed. This means that other applications that need to use the COM Port, such
as debugging tools, may be used while Flash Magic is loaded.
Win X talk
Win X talk software is windows software that allows send and receives the data
from serial port. COM port configuration is variable.
7
User Manual
IAR EMBEDDED WORKBENCH
The IAR Embedded Workbench® IDE is a very powerful Integrated Development

Environment, which allows you to develop and manage complete embedded application
projects. It is a development platform, with all the features you would expect to find in
your everyday working place.

The IDE is the framework where all necessary tools are seamlessly integrated:

The highly optimizing IAR C/C++ Compiler

The IAR Assembler

The versatile IAR ILINK Linker, including accompanying tools

A powerful editor

A project manager

A command line build utility

IAR C-SPY® Debugger, a state-of-the-art high-level language debugger.
IAR Embedded Workbench is available for many microprocessors and

microcontrollers in the 8-, 16-, and 32-bit segments, allowing you to stay within a well-
known development environment also for your next project. It provides an easy-to-learn
and highly efficient development environment with maximum code inheritance
capabilities, comprehensive and specific target support. IAR Embedded Workbench
promotes a useful working methodology, and you can reduce your development time
significantly by using the IAR Systems tools. We call this concept “Different
Architectures. One Solution”.
IAR C/C++ COMPILER

The IAR C/C++ Compiler for ARM is a state-of-the-art compiler that offers the
standard features of the C or C++ languages, plus many extensions designed to take
8
User Manual
advantage of the ARM- specific facilities. The compiler is integrated with other IAR
Systems software in the IDE.
FEATURES
The compiler provides the following features:
CODE GENERATION
 Generic and ARM-specific optimization techniques produce very efficient

machine code
 Comprehensive output options, including relocatable object code,

assembler source code, and list files with optional assembler mnemonics
 Support for ARM EABI ELF/DWARF object format
 The object code can be linked together with assembler routines
 Generation of extensive debug information.
LANGUAGE FACILITIES
 Support for the C and C++ programming languages
 Support for IAR Extended EC++ with features such as full template
support, namespace support, the cast operators static_cast, const_cast, and
reinterpret_cast,
as well as the Standard Template Library (STL).
 Conformance to the ISO/ANSI C standard for a free-standing environment
 Target-specific language extensions, such as special function types,

extended keywords, program directives, predefined symbols, intrinsic functions,
absolute
allocation, and inline assembler
9
User Manual
 Standard library of functions applicable to embedded systems
 IEEE-compatible floating-point arithmetic
IAR Assembler
The IAR Assembler is integrated with other IAR Systems software for the ARM
core. It is a powerful relocating macro assembler (supporting the Intel/Motorola style)
with a versatile set of directives and expression operators. The assembler features a built-
in C language preprocessor and supports conditional assembly. The assembler uses the
same mnemonics and operand syntax as the Advanced RISC Machines Ltd Assembler for
ARM, which simplifies the migration of existing code.
FEATURES
The IAR Assembler provides these features:
 C preprocessor
 List file with extensive cross-reference output
 Number of symbols and program size limited only by available memory
 Support for complex expressions with external references
 255 significant characters in symbol names
 Support for ARM EABI ELF/DWARF object format.
10
User Manual
HOW TO CREATE A NEW PROJECT

1. CREATING A NEW PROJECT:
IAR Embedded Workbench Installation is completed; Shortcut ICON is placed at your
desktop. Just make a double click on that ICON. New Window is open as given below.
1. To create a new project, choose Project>Create New Project. The Create New
Project
Dialog box appears, which lets you base your new project on a project template.
11
User Manual
2. Make sure the Tool chain is set to ARM, and click OK.
3. Select the project template Empty project, and click ok button. This simply creates
an empty project that uses default project setting.
4. In the standard Save As dialog box that appears, specify where you want to place
your project file, that is, in your newly created projects directory. Type your
project name in the File name box, and click Save to create the new project.
E.g. LED.
The project will appear in the Workspace window
12
User Manual
To Creating your Application ‘C’ file, Choose FILE menu and select NEW>File
Edit the application code in C Language. E.g. Led.c
13
User Manual
To Save your ‘C’ file, Choose File>Save As. In the standard Save As dialog box that
appears, specify where you want to place your project file, that is, in your project
directory. Type your filename in the File name box, and click Save to create the new
project. E.g. Led.c
2. ADDING FILES TO THE PROJECT
1. In the Workspace window, select the destination to which you want to add a
source file; a group or, as in this case, directly to the project.
2. Choose Project>Add Files to open a standard browse dialog box. Locate the files
led.c
Select them in the file selection list, and click Open to add them to the project.
14
User Manual
15
User Manual
To save your work space, Choose File>Save Workspace and specify where you
want to place your workspace file. In this tutorial, you should place it in your newly
created project directory. Type LED in the File name box, and click save button.
3. SETTING PROJECT OPTIONS
Now you will set the project options. For application projects, options can be set
on all levels of nodes. First you will set the general options to suit the processor
configuration in this tutorial. Because these options must be the same for the whole build
configuration, they must be set on the project node.
1. Select the project folder icon LED - Debug in the Workspace window and choose
Project>Options. Then select Output Converter in the Category list to display the
linker option pages.
16
User Manual
The Output options are used for specifying details about the output format and the
level of debugging information included in the output file.
Select “option” on the popup menu. After selecting popup menu window shows as given
below.
17
User Manual
Select output format as “Intel Extended”, output file in the format of .hex format.
Select the linker file menu, linker configuration file available at project directory. To
Compile your Project, Choose Project>Rebuild ALL
18
User Manual
If your project has no error, then it will show Building successfully and the Hex file will
be generated.
19
User Manual
HOW TO CREATE RTOS PROGRAMS

μC/OS-II Porting with IAR Embedded Workbench
1. Create a New Project
1. To create a new project, choose Project>Create New Project. The Create New
Project
Dialog box appears, which lets you base your new project on a project template.
2. Make sure the Tool chain is set to ARM, and click OK.
3. Select the project template Empty project, and click ok button. This simply creates
an empty project that uses default project settings.
4. In the standard Save As dialog box that appears, specify where you want to place
your project file, that is, in your newly created projects directory. Type your
project name in the File name box, and click Save to create the new project. E.g.
LED.
20
User Manual
RTOS Package comprises set of ‘C’ files and headed files. C Files are classified as
Application file, CPU files, μC/OS-II Files and BSP.
In this project, we have to split the C files according to the functions. So these files are
integrated under separate folder.
Project Group Names are
 APP
 BSP
 CPU
 UCOS-II
- PORT
- SOURCE
21
User Manual
2. ADDING Groups TO THE PROJECT

1. Creating several groups is a possibility for you to organize your source files
logically according to your project needs.
2. To create new group Choose Project>Add Group.
3. Type your group name and click ok button.
Now create APP group
22
User Manual
Add files to APP group
Create new group
23
User Manual
Add files to BSP Group
Create new group
24
User Manual
Add Files to CPU Group
Create new group
25
User Manual
Under ucos-ii group, create two group named as source and ports.
26
User Manual
Add Corresponding files to above mentioned group
27
User Manual
3. SETTING PROJECT OPTIONS

Now you will set the project options. For application projects, options can be set
on all levels of nodes. First you will set the general options to suit the processor
configuration in this tutorial. Because these options must be the same for the whole build
configuration, they must be set on the project node.
1. Select the project folder icon UART - Debug in the Workspace window and
choose Project>Options. Then select C/C++ Compiler where you have select
CODE menu, enable ARM Processor Mode.
After that Select Preprocessor menu from same window.
At Preprocessor, we have to include all the directories as given

below $PROJ_DIR$
$PROJ_DIR$\..\uCOS-II\ports
$PROJ_DIR$\..\uCOS-
II\source $PROJ_DIR$\..\BSP
$PROJ_DIR$\..\CPU
28
User Manual
For Creating the Hex file, we choose output file format as given below.
29
User Manual
Select Linker file as given below.
To Compile this Project, Choose Project>Rebuild ALL
If there is no error, Message window shows like this. Now Hex file is created.
30
User Manual
ISP UTILITY
NXP Semiconductors produce a range of Microcontrollers that feature both on-

chip Flash memory and the ability to be reprogrammed using In-System Programming
technology. Flash Magic is Windows software that allows easy access to all the ISP
features provided by the devices. These features include:
• Erasing the Flash memory (individual blocks or the whole device)
• Programming the Flash memory
• Modifying the Boot Vector and Status Byte
• Reading Flash memory
• Performing a blank check on a section of Flash memory
• Reading the signature bytes
• Reading and writing the security bits
• Direct load of a new baud rate (high speed communications)
• Sending commands to place device in Boot loader mode
Under Windows, only one application may have access the COM Port at any one
time, preventing other applications from using the COM Port. Flash Magic only obtains
access to the selected COM Port when ISP operations are being performed. This means
that other applications that need to use the COM Port, such as debugging tools, may be
used while Flash Magic is loaded. Note that in this manual third party Compilers are
listed alphabetically. No preferences are indicated or implied.
31
User Manual
HOW TO DOWNLOAD A CODE TO OUR CONTROLLER
Procedure:
1. Select the COM Port

2. Select the Baud Rate
3. Select Device ( Eg.LPC2148)
4. Interface – None ISP
5. Select Osc. Frequency – 12Mhz
6. Enable “ Erase Blocks used by Hex files”
7. Select the Hex File to be downloaded.
8. Click start
32
User Manual
Processing……..
33
User Manual
After downloaded completely, window shows like this
34
User Manual
Syllabus Programs in ‘C’
Hardware and software Requirements
1. VSK-2148 Development board

2. IAR Embedded workbench version 5.40 or above
3. Flash Magic
4. Win X-Talk
5. PC/Laptop
Instruction:
Follow the given steps for getting started with the syllabus experiments:
1. Install IAR Embedded Workbench IDE software and Win X-Talk software.
2. After successful installation of IAR, Install Flash Magic.
3. Connect the RS232 cable/USB cable provided to the PC and the LPC2148 Syllabus
Board, and Power on the VSK-2148 Development Board.
4. If you are using USB cable, then install the required USB to Serial driver (FTDI for
on beard converter).
5. Search/Set the COM Port no here :
Start >> My Computer >> Manage (on right click) >> Device Manager >>
Ports (COM & LPT).
6. Now, Identify the Mode-Select-Switch provided on the VSK 2148 Board marked
with the text PROG & EXEC.
 PROG: Programming Mode used for downloading the code/program into the
flash memory.
 EXEC: Execution Mode used for executing program after downloading.
35
User Manual
After selecting any position (PROG / EXEC) press the reset switch provided on
the board.
7. After setting the proper COM port number & selecting the Mode-Select-Switch
position properly, Extract the “VSK-2148 SOURCE CODES V 1.0” (WinRAR
archive) file.
8. Open the project and follow the instructions given in each experiment.
36
User Manual
Experiment 1
Study of ARM Evaluation System
Aim
To learn about the evolution, core features, general characteristics and applications of
ARM processors.
Theory
The LPC2148 microcontrollers are based on a 32/16 bit ARM7TDMI-S CPU with
real-time emulation and embedded trace support, that combines the microcontroller with
embedded high speed flash memory ranging from 32 kB to 512 kB. A 128-bit wide
memory interface and unique accelerator architecture enable 32-bit code execution at the
maximum clock rate. For critical code size applications, the alternative 16-bit Thumb
mode reduces code by more than 30 % with minimal performance penalty.
Due to their tiny size and low power consumption, LPC2148 are ideal for
applications where miniaturization is a key requirement, such as access control and point-
of-sale. A blend of serial communications interfaces ranging from a USB 2.0 Full Speed
device, multiple UARTS, SPI, SSP to I2Cs and on-chip SRAM of 8 kB up to 40 kB,
make these devices very well suited for communication gateways and protocol
converters, soft modems, voice recognition and low end imaging, providing both large
buffer size and high processing power. Various 32-bit timers, single or dual 10-bit
ADC(s), 10-bit DAC, PWM channels and 45 fast GPIO lines with up to nine edge or
level sensitive external interrupt pins make these microcontrollers particularly suitable for
industrial control and medical systems.
37
User Manual
FEATURES
 16/32-bit ARM7TDMI-S microcontroller in a tiny LQFP64 package.
 8 to 40 kB of on-chip static RAM and 32 to 512 kB of on-chip flash program

memory.
 128 bit wide interface/accelerator enables high speed 60 MHz operation.
 In-System/In-Application Programming (ISP/IAP) via on-chip boot-loader

software.
 Single flash sector or full chip erase in 400 ms and programming of 256 bytes in
1 ms.
 Embedded ICE RT and Embedded Trace interfaces offer real-time debugging

with the on-chip Real Monitor software and high speed tracing of instruction
execution.
 USB 2.0 Full Speed compliant Device Controller with 2 kB of endpoint RAM.
In addition, the LPC2146/8 provides 8 kB of on-chip RAM accessible to USB by
DMA.
 One or two (LPC2141/2 vs. LPC2144/6/8) 10-bit A/D converters provide a total
of 6/14 analog inputs, with conversion times as low as 2.44 s per channel.
 Single 10-bit D/A converter provide variable analog output.
 Two 32-bit timers/external event counters (with four capture and four compare
channels each), PWM unit (six outputs) and watchdog.
 Low power real-time clock with independent power and dedicated 32 kHz clock
input.
 Multiple serial interfaces including two UARTs (16C550), two Fast I2C-bus
(400 Kbit/s), SPI and SSP with buffering and variable data length capabilities.
 Vectored interrupt controller with configurable priorities and vector addresses.
 Up to 45 of 5 V tolerant fast general purpose I/O pins in a tiny LQFP64 package.
38
User Manual
 Up to nine edge or level sensitive external interrupt pins available.
 60 MHz maximum CPU clock available from programmable on-chip PLL with
settling time of 100s
 On-chip integrated oscillator operates with an external crystal in range from 1

MHz to 30 MHz and with an external oscillator up to 50 MHz
 Power saving modes include idle and Power-down.
 Individual enable/disable of peripheral functions as well as peripheral clock

scaling for additional power optimization.
 Processor wake-up from Power-down mode via external interrupt, USB, Brown-
Out Detect (BOD) or Real-Time Clock (RTC).
 Single power supply chip with Power-On Reset (POR) and BOD circuits:
- CPU operating voltage range of 3.0 V to 3.6 V (3.3 V 10 %) with 5 V
tolerant I/O
ARCHITECTURE OVERVIEW
The LPC2148 consists of an ARM7TDMI-S CPU with emulation support, the
ARM7 Local Bus for interface to on-chip memory controllers, the AMBA Advanced
High-performance Bus AHB for interface to the interrupt controller, and the VLSI
Peripheral Bus (A compatible superset of ARM’s AMBA Advanced Peripheral Bus) for
connection to on-chip peripheral functions. The LPC2148 configures the ARM7TDMI-S
processor in little-endian byte order. AHB peripherals are allocated a 2 megabyte range
of addresses at the very top of the 4 gigabyte ARM memory space. Each AHB peripheral
is allocated a 16 kB address space within the AHB address space. LPC2148 peripheral
functions are connected to the VPB bus. The AHB to VPB Bridge interfaces the VPB bus
to the AHB bus. VPB peripherals are also allocated a 2 megabyte range of addresses,
beginning at the 3.5 gigabyte address point. Each VPB peripheral is allocated a 16 kB
39
User Manual
address space within the VPB address space. The connection of on-chip peripherals to
device pins is controlled by a Pin Connect Block. This must be configured by software to
fit specific application requirements for the use of peripheral functions and pins.
ARM7TDMI PROCESSOR
The ARM7TDMI-S is a general purpose 32-bit microprocessor, which offers high
performance and very low power consumption. The ARM architecture is based on
Reduced Instruction Set Computer (RISC) principles, and the instruction set and related
decode mechanism are much simpler than those of micro programmed Complex
Instruction Set Computers. This simplicity results in a high instruction throughput and
impressive real-time interrupt response from a small and cost-effective processor core.
Pipeline techniques are employed so that all parts of the processing and memory
systems can operate continuously. Typically, while one instruction is being executed, its
successor is being decoded, and a third instruction is being fetched from memory. The
ARM7TDMI-S processor also employs a unique architectural strategy known as
THUMB, which makes it ideally suited to high-volume applications with memory
restrictions, or applications where code density is an issue. The key idea behind THUMB
is that of a super-reduced instruction set. Essentially, the ARM7TDMI-S processor has
two instruction sets:
 The standard 32-bit ARM instruction set.
 A 16-bit THUMB instruction set.

The THUMB set’s 16-bit instruction length allows it to approach twice the density
of standard ARM code while retaining most of the ARM’s performance advantage over a
traditional 16-bit processor using 16-bit registers. This is possible because THUMB code
operates on the same 32-bit register set as ARM code. THUMB code is able to provide
up to 65% of the code size of ARM, and 160% of the performance of an equivalent ARM
processor connected to a 16-bit memory system.
40
User Manual
BLOCK DIAGRAM
41
User Manual
Result
The evolution, core features, general characteristics and the applications of ARM
processors has been studied and is evaluated.
42
User Manual
Experiment 2
Interfacing ADC and DAC
Aim
To develop a C-Language program for reading an on-chip ADC, convert into

decimal and to display it in PC and to generate a square wave depending on this ADC
reading. The ADC input is connected to any analog sensor/ on board potentiometer.
Apparatus & Software Required
1. LPC2148 syllabus board.
2. IAR IDE software.
3. Flash Magic.
4. CRO
5. USB cable.
Theory
i) ADC
The LPC 2148 has 10-bit successive approximation analog to digital converter. Basic
clocking for the A/D converters is provided by the VPB clock. A programmable divider
is included in each converter, to scale this clock to the 4.5 MHz (max) clock needed by
the successive approximation process. A fully accurate conversion requires 11 of these
clocks. The ADC cell can measure the voltage on any of the ADC input signals.
43
User Manual
VSK-2148 has one potentiometer for working with A/D Converter. Potentiometer outputs
are in the range of 0V to 3.3V. Short the J4 jumper for reading the Potentiometer
value by ADC.
Procedure
1. Follow the steps 1 of How to create a New project

2. Type the below code and save it with the name dac.c (anyname.c)
3. Follow the steps 2 and 3 of How to create a New Project to compile and build
the program
4. Follow the procedures in How to Download a Code to Our Controller to
download your code.
44
User Manual
Program
/* - - - - - HEADER FILES - - - - -
*/ #include<nxp/iolpc2148.h>
#include<stdio.h>
#include "uart.h"
#include "adc.h"
/* - - - - - User defined Variables - - - - - */
unsigned int val=0,volt;
/* - - - - - MAIN FUNCTION STARTS HERE - - - - - */
void main(void)
{
PINSEL1_bit.P0_28=1;
init(); /* Call the initialization function. Function definition is in
“uart.h” */
uart_inital(); /* Call the uart function. Function definition is in “uart.h” */
adc(); /* Call adc function. Function definition is in “adc.h” */
PINSEL1=0X01000000; //ADC0.1
while(1)
{
while(AD0DR_bit.DONE==0); // Start A/D Conversion
val=AD0DR1_bit.RESULT;
printf("adc = %d \n\r",val);
}
}
45
User Manual
Procedure to View the Result:

Compile, Debug & Simulate the above code in IAR.

Connect the RS232 cable/USB cable provided to the PC/Laptop and the VSK-
2148 Board, and Power on the Board.

For seeing the output in real-time, select the PROG mode, reset the board and
download the code on to the board using Flash Magic through UART0/USB.

Now change the Mode-Selection-Switch to EXEC position and reset the board.

Open Win X-Talk, and select the COM port and the baud rate as 9600.

Now vary the on board potentiometer knob and observe the values displayed in
PC.

As you tune the knob, the values displayed in the PC/Laptop should vary from 0 to
1023 and there will be a shift in the position of the load line depending on the
values in the ADC.

You can interface any other analog sensor also (range 0-3.3V) to measure and
display the following parameters: temp./pressure/force/flow/acceleration/humidity
etc.
46
User Manual
ii) DAC
The two 10-bit buffered DAC channels can be used to convert digital signals
into analog voltage signal outputs.
The features of the DAC in LPC2148 are
1. 10 bit digital to analog converter
2. Resistor string architecture
3. Buffered output
4. Power-down mode
5. Selectable speed vs. power
Procedure

2. Type the below code and save it with the name dac.c (anyname.c)
the program
download your code.
4
7
User Manual
Program
/* - - - - - Header Files - - - - - */
#include<nxp/iolpc2148.h>
#define DAC_BIAS 0x00010000 /*The settling time of the DAC is 2.5 µs and the maximum
current is 350 µA when BIAS=1*/
/* - - - - - delay routine - - - - - */
void delay(unsigned int x)
for(int i=0;i<=x;i++);
/* - - - - - main function - - - - -*/
void main()
PINSEL1=0X00080000;
while(1)
DACR = (1023 << 6) | DAC_BIAS; /* The Datas has to be passed or moved on to the VALUE bits
i.e 15 - 6 and the result will be (VALUE/(1024*Vref)) */
delay(100000); delay(100000);
delay(100000); delay(100000);
DACR = (0 << 6) | DAC_BIAS; /* The Datas has to be passed or moved on to the VALUE bits
i.e 15 - 6 and the result will be (VALUE/(1024*Vref)) */
delay(100000); delay(100000);
delay(100000); delay(100000);
48
User Manual


Connect the RS232 cable/USB cable provided to the PC/Laptop and the VSK-



Connect the +ve terminal of the CRO probe to Aout and _ve terminal to AGND
pins on the board to see the variation in the pulse.
49
User Manual
Experiment 3
Interfacing LED and PWM
Aim
To write a C program to generate a PWM and to vary the brightness of the LED
depending on the duty cycle.
3. Flash Magic.
4. CRO
5. LED board Setup
Theory
The PWM is based on the standard timer block and inherits all of its features, although
only the PWM function is pinned out on the LPC2148. The timer is designed to count
cycles of the peripheral clock (PCLK) and optionally generate interrupts or perform other
actions when specified timer values occur, based on seven match registers. The PWM
function is also based on match register events
50
User Manual
Procedure
2. Type the below code and save it with the name (anyname.c)
the program
download your code.
51
User Manual
Program pwm.c
/* - - - - - Header Files - - - - - */
#include<nxp\iolpc2148.h>
/* - - - - - User Defined Variables - - - - - */
int x;
/* - - - - - delay Routine - - - - - */
void delay()
{
for( int i=0;i<=1500;i++);
}
/* - - - - - PWM function - - - - - */
void pwm(int x)
{
PINSEL0 = 0X000A0005; /* To select Port pin P0.8 and also p0.9 as pwm4 and
pwm6 */
PWMPR = 0X00000000; /* To set Prescaler register value to one */
PWMPCR = 0X00005000; /* To select pwm2 as single edge controlled */
PWMMCR = 0X00000002; /* To Reset pwm timer counter when matches occur
PWMMR0 = 1200 ; */ /* To set total time period of pwm output */
PWMMR4 = x; PWMMR6
= 600; PWMTCR =
0X00000002; PWMTCR = /* To reset pwm timer */
0X00000009;
}
/* - - - - - main function starts here - - - - - */
void main()
{
PINSEL1_bit.P0_21=1;
IO0DIR_bit.P0_21=1;
PINSEL2 = 0X00000000;
IO1DIR = 0XFF000000;
int i;
while(1)
{
52
User Manual
for(i=0;i<=1200;i++)
{
pwm(x);
delay();
x=x+1;
if(i>=1200)
{
x=0;
}
}
}
}
53
User Manual
Procedure To View the Result
1. Compile, Debug & Simulate the above code in IAR.

2. Connect the RS232 cable/USB cable provided to the PC/Laptop and the VSK-
3. For seeing the output in real-time, select the PROG mode, reset the board and
4. Now change the Mode-Selection-Switch to EXEC position and reset the board.
5. Press the Switch and we can observe the variation in the intensity of the LEDs
depending on the duty cycle of the PWM
Result
The C code to generate a PWM and to vary the intensity of the LEDs is developed and is
verified.
54
User Manual
Experiment 4
Interfacing Real Time Clock and Serial Port
Aim
To develop a C-Language program for reading the RTC, convert into decimal and to
display it.
3. Flash Magic.
Theory
RTC
The Real Time Clock (RTC) is a set of counters for measuring time when system power
is on, and optionally when it is off. It uses little power in Power-down mode. On the
LPC2141/2/4/6/8, the RTC can be clocked by a separate 32.768 KHz oscillator, or by a
programmable prescale divider based on the VPB clock. Also, the RTC is powered by its
own power supply pin, VBAT, which can be connected to a battery or to the same 3.3 V
supply used by the rest of the device
Serial Communication
Serial communication takes a byte of data and transmits the 8 bits in the byte one at a
time. The advantage is that a serial port needs only one wire to transmit the 8 bits (while
55
User Manual
a parallel port needs 8). The disadvantage is that it takes 8 times longer to transmit the
data than it would if there were 8 wires. Serial ports lower cable costs and make cables
smaller.
Procedure
2. Type the below code and save it with the name rtc.c (anyname.c)
the program
download your code.
56
User Manual
Program rtc.c
/* - - - - - Header Files - - - - - */
#include<stdio.h>
#include<string.h>
#include "uart.h"
/* - - - - - Real Time Clock Initialization - - - - - */
void RTC_Init()
{
ILR = 3; /* Disable 32'768 interrupt */
CCR = 0x11; /* Clock enable + 32'767Hz quartz enable; starts the RTC */
CIIR = 0x01; /* Interupt every second */
PREINT = 0x0000016D; /* the integer portion of the prescale value */
PREFRAC = 0x00001B00; /* fractional portion of the prescale value */

YEAR = 2015; /* Year */
MONTH = 05; /* Month */
DOM = 09; /* Day of month loads the date as 09.05.2015 */
DOY = 129; /* Day of year */
DOW = 04; /* Day of week */
HOUR = 10; /* Hours */
MIN = 21; /* Minutes loads the time as 10:21:00 */
SEC = 00; /* Seconds */
/* Hint: ARM processor crystal freq. = 12 MHz = 12,000,000 Hz

RTC crystal freq. = 32.768 KHz = 32,768 Hz
Calculate,
PREINT = (12,000,000 / 32,768)-1 = 365 in Decimal = 0x16D in Hex.
57
User Manual
PREFRAC = 12,000,000 - (365+1)*32,768 = 6912 in Decimal = 0x1B00 in Hex.
And, for
CIIR = Counter Increment Interrupt Register,
CCR = Clock Control Register
ILR = Interrupt Location Register
Refer, "Volume 1: LPC214x User Manual" PDF Document */

}
/* - - - - - Start the Clock - - - - - */
void RTCStart( void )
{
CCR |= 0x01; /* CTC Reset */
ILR = 0x01; /* Interrupt location Register */
}
/* - - - - - Read Clock - - - - - */
void Read_rtc( void )

{
printf("TIME--->%d:%d:%d\t",HOUR,MIN,SEC);
printf("DATE--->%d:%d:%d\n",DOM,MONTH,YEAR);
}
/* - - - - - main function starts - - - - - */
void main()
{
baudrate_settings(); /* call function baudrate_settings */
RTC_Init(); /* call function RTC_Init */
RTCStart(); /* call function RTCStart */

58
User Manual
while(1)
{
Read_rtc(); /* call function Read_rtc */
}
}
59
User Manual


Connect the RS232 cable / USB cable provided to the PC / Laptop and the VSK -

download the code in the board using Flash Magic through UART0.


Open Win X- Talk, Select COM port and Baud rate as 9600

Now observe the output data in the PC, it should display the digital clock running
with Hr., Min., & Sec. Digits following format: “HH:MM:SS “. along with the
Day as “DD:MM:YYYY”

Digital Clock will start running from 10:21:00 as programmed by default, you can
modify the code and you can load your desired timing also.

Apart from timing it can be programmed to display AM-PM (12Hr mode) also.
Result
The C-Language program for reading RTC and displaying it in PC was written &
output is verified with running the RTC from a default/specified time.
60
User Manual
Experiment 5
Interfacing Keyboard and LCD
Aim
To develop a C-Language program for displaying the Key pressed in the Keypad in the
LCD module. The display should come in the desired line and column.
3. Flash Magic.
Theory
Keypad
The Matrix keyboard is used to minimize the number of I/O lines. Normally it is possible
to connect only one key or switch with an I/O line. If the number of keys in the system
exceeds the more I/O lines are required. To reduce the number of I/O lines the keys are
connected in the matrix circuit. Keyboards use a matrix with the rows and columns made
up of wires. Each key acts like a switch. When a key is pressed a column wire makes
contact with row wire and completes a circuit.
For example 16 keys arranged in a matrix circuit uses only 8 I/O lines.
In VSK-2148 board Dip-switch and matrix keypad lines are multiplexed.
61
User Manual
LCD
Liquid crystals are a phase of matter whose order is intermediate between that of a liquid
and that of a crystal. The molecules are typically rod-shaped organic matters about 25
Angstroms in length and their ordering is a function of temperature. The molecular
orientation can be controlled with applied electric fields.
CHARACTER BASED LCD
A standard character LCD is probably the most widely used data Visualization
component.
Character LCDs are available in various kinds of models.
1. No. Of characters x Lines: 8x1, 16x1, 16x2, 16x4, 20x4, 40x4…
2. Color: Yellow, Green, Gray, Blue…
62
User Manual
The Character LCD communicates with the microcontroller via 8 bit data bus. The pin
description for character LCD is given below.
VCC, GND AND V0 - While VCC and VSS provide +5V and ground, respectively; V0
is used for controlling LCD contrast.
RS (Register Select) - If RS = 0, the instruction command code register is selected,
allowing the user to send a command such as clear display, cursor at home, etc.
If RS = 1, the data register is selected, allowing the user to send data to be displayed on
the LCD.
RW (Read/Write) - RW allows the user to write information to the LCD or read
information from it. RW=1 when reading; RW=0 when writing.
EN (Enable) - The LCD to latch information presented to its data pins uses the enable
pin. When data is supplied to data pins, a high to low pulse must be applied to this pin in
order for the LCD to latch in the data present at the data pins.
D0 – D7 - The 8-bit data pins, are used to send information to the LCD or read the
contents of the LCD’s internal registers. To display letters and numbers, we send ASCII
codes for the letters A-Z, a-z, and numbers 0-9 to these pins while making RS = 1.
63
User Manual
Procedure
2. Type the below code and save it with the name keypad.c (anyname.c)
the program
download your code.
64
User Manual
Program keypad.c
/* Keypad Interface
/ K1 TO K8 : P0.16 TO P0.23
/ Key Value is displayed on UART0
// SCAN LINES : P0.20 TO P0.23 (OUTPUT)
// READ LINES : PO.16 TO P0.19 (INPUT) */
/* - - - - - Header Files - - - - - */
#include<stdio.h>
# include "lcd.h"
#include "key.h"
void main()
{
PINSEL2 = 0x00000000; /* P0.16 TO P0.23 Configured as GPIO. */
IO0DIR = 0X00F00F05; /* P0.20 TO P0.23 (O/P), P0.16 TO P0.19(I/P) */
IO1DIR=0x00FF0000; /* LCD data pins as output */
comm(command); /* function to call LCD commands */
data1("Press any Key"); /* call the function to display the data in LCD */
while(1)
{
scomm(0xC0); /* function to write single datas in LCD location C0 */
key(); /* call the keypad function*/
}
}
65
User Manual
Procedure to see OUTPUT:



2148 Boards, and Power on the Board.

download the code in VSK-2148 board using Flash Magic through UART0.


Now observe the LCD output, it should display the Alphabets & Numbers.
 st
1 line (upper line) should display the Alphabets Press any Key and the
 nd
2 line (lower line) should display the corresponding data as the Key is Pressed

You can change Address for upper line from 0x80 to 0x8F and
For lower line from 0xC0 to 0xCF.
Result
The C-Language program for displaying the Key pressed in the Keyboard is displayed in
the LCD module and the output was verified on the LCD on the desires line and
column/address.
66
User Manual
Experiment 6
Interfacing EEPROM and Interrupt
Aim
To develop a C-Language program to write and read a data in EEPROM and also to
analyze its performance with the interrupt
3. Flash Magic.
Theory
Serial-interface EEPROM’s are used in a broad spectrum of consumer, automotive,

telecommunication, medical, industrial and PC related markets. Primarily used to store
personal preference data and configuration/setup data, Serial EEPROM’s are the most
flexible type of nonvolatile memory utilized today. Compared to other NVM solutions,
Serial EEPROM devices offer a lower pin count, smaller packages, lower voltages, as
well as lower power consumption.
67
User Manual
Procedure
the program
download your code.
68
User Manual
Program
/* - - - - - Header Files - - - - - */
#include<stdio.h>
#include "intrinsics.h"
void TIMER0(void);
void TIMER1(void);
#include "int.h"
#include "uart.h"
#include "timer.h"

void main()
{
uart_init(); /* call the uart initialization function. Function definition is in “uart.h” */
timer_config(); /* call the timer configuration function. Function definition is in “timer.h”*/
timerenable(); /* call the timer interrupt function. Function definition is in “int.h” */
while(1)
{
printf("\n Welcome... ");
}
}
69
User Manual



Connect the RS232 cable /USB cable provided to the PC / Laptop and the VSK -
2148 Syllabus Board, and Power on the Board.



Open Win X – Talk and select the COM port and the Desired Baud rate as 9600.

The main function will execute continuously. The Timer Interrupt function will
execute for every 1 second.

For every 1 second the Interrupt data will be printed in the PC
Result
The C-Language program to write and read a data in EEPROM and also to analyze its
performance with the interrupt is developed and is verified.
70
User Manual
Experiment 7
Mailbox
Aim
To develop a ‘C’ code to create a mailbox and to understand the RTOS functions.
3. Flash Magic.
Theory
Real-time and embedded systems operate in constrained environments in which computer

memory and processing power are limited. They often need to provide their services
within strict time deadlines to their users and to the surrounding world. It is these
memory, speed and timing constraints that dictate the use of real-time operating systems
in embedded software.
The "kernel" of a real-time operating system ("RTOS") provides an "abstraction layer"

that hides from application software the hardware details of the processor (or set of
processors) upon which the application software will run.
71
User Manual
In providing this "abstraction layer" the RTOS kernel supplies five main categories of
basic services to application software
The most basic category of kernel services is Task Management. This set of services
allows application software developers to design their software as a number of separate
"chunks" of software -- each handling a distinct topic, a distinct goal, and perhaps its own
real-time deadline. Each separate "chunk" of software is called a "task." The main RTOS
service in this category is the scheduling of tasks as the embedded system is in operation.
The second category of kernel services is Intertask Communication and Synchronization.

These services make it possible for tasks to pass information from one to another, without
danger of that information ever being damaged. They also make it possible for tasks to
coordinate, so that they can productively cooperate with one another. Without the help of
these RTOS services, tasks might well communicate corrupted information or otherwise
interfere with each other.
Since many embedded systems have stringent timing requirements, most RTOS kernels
also provide some basic Timer services, such as task delays and time-outs.
Many (but not all) RTOS kernels provide Dynamic Memory Allocation services. This
category of services allows tasks to "borrow" chunks of RAM memory for temporary use
in application software. Often these chunks of memory are then passed from task to task,
as a means of quickly communicating large amounts of data between tasks. Some very
small RTOS kernels that are intended for tightly memory-limited environments, do not
offer Dynamic memory allocation.
Many (but not all) RTOS kernels also provide a "Device I/O Supervisor" category of
services. These services, if available, provide a uniform framework for organizing and
accessing the many hardware device drivers that are typical of an embedded system.
72
User Manual
Procedure
1. Follow the steps 1 of How To Create Rtos Programs
2. Type the below code and save it with the name main.c (anyname.c)
the program
download your code.
73
User Manual
Program main.c
/* - - - - - Header Files - - - - - */
#include <includes.h>
#include <intrinsics.h>
#include<stdio.h>
#include “uart.h”
/* - - - - - User Defined Variables - - - - - */
OS_EVENT *comm;
INT8U err;
/* - - - - - OS TASK STACK ALLOCATION - - - - - */
OS_STK Task1stk[100];
OS_STK Task2stk[100];
/* - - - - - TASK FUNCTION - - - - - */
void Task1(void *pdata)

{
pdata = pdata;
INT32U temp;
while(1)
{
temp=123; OSMboxPost(comm,
(void *)&temp);
OSTimeDlyHMSM(0, 0, 0, 10);
}
}
void Task2(void *pdata)

{
INT8U err;
INT8U *msg;
char val1;
while(1)
{
msg = OSMboxPend(comm,0,&err);
74
User Manual
val1 = *msg;
printf("\n data = %d ",val1);
OSTimeDlyHMSM(0, 0, 0, 100);
}
}
void main (void)

{
uart_init(); /* call the Uart initialization functions */

//BSP_IntDisAll(); /* Disable all interrupts until we are ready to accept them */
BSP_Init(); /* Call Board Supporting packages */
OSInit(); /* Initialize "uC/OS-II, The Real-Time Kernel" */
OSTaskCreate(Task1,0,&Task1stk[99],0);
OSTaskCreate(Task2,0,&Task2stk[99],1);
comm = OSMboxCreate((void *)0);

OSStart(); /* Start multitasking (i.e. give control to uC/OS-II) */
}
75
User Manual



Connect the RS232 cable /USB cable provided to the PC / Laptop and the VSK -
2148 Syllabus Board, and Power on the Board.



Open Win X – Talk and select the COM port and the Desired Baud rate as 9600.

The tasks will run alternatively. The first task will post a data whereas the second
task will receive the data and display it in PC.
Result
The C-Language program to create a mailbox and to understand the about the RTOS
functions is developed and is verified.
76
User Manual
Experiment 8
Interrupt Performance Characteristics of ARM and FPGA
Aim
To study about the Interrupt performance characteristics between ARM and FPGA

3. Flash Magic
4. Xilinx FPGA Spartan 6
5. Xilinx ISE Design suite
6. ModelSim SE
7. JTAG 5.5
8. CRO
Theory
The ARM7 CPU has two external interrupt lines for the fast interrupt request (FIQ) and
general purpose interrupt IRQ request modes. As a generalization, in an ARM7 system
there should only be one interrupt source which generates an FIQ interrupt so that the
processor can enter this mode and start processing the interrupt as fast as possible. This
means that all the other interrupt sources must be connected to the IRQ interrupt. In a
simple system they could be connected through a large OR gate. This would mean that
77
User Manual
when an interrupt was asserted the CPU would have to check each peripheral in order to
determine the source of the interrupt. This could take many cycles. Clearly a more
sophisticated approach is required. In order to handle the external interrupts efficiently an
on-chip module called the Vector Interrupt Controller (VIC) has been added.
Procedure for ARM

2. Type the below code and save it with the name led.c (anyname.c)
the program
download your code
78
User Manual
Program (ARM)
#include<stdio.h>
#include "intrinsics.h"
#define led1 IO0PIN_bit.P0_12
#define led2 IO0PIN_bit.P0_13
void TIMER0(void);
void TIMER1(void);
#pragma vector=0x18
__irq __arm void irq_handler (void)
void (*intrrupt_function)();
unsigned int vector; vector
= VICVectAddr;
intrrupt_function = (void(*)())vector;
(*intrrupt_function)();
VICVectAddr = 0;
__fiq __arm void fiq_handler(void)
79
User Manual
while(1);
void timerenable()
VICIntSelect&=~(1<<VIC_TIMER0);
VICVectAddr0=(unsigned int)& TIMER0;
VICVectCntl0=0X20|(VIC_TIMER0);
VICIntEnable|=(1<<VIC_TIMER0);
VICIntSelect&=~(1<<VIC_TIMER1);
VICVectAddr1=(unsigned int)& TIMER1;
VICVectCntl1=0X20|(VIC_TIMER1);
VICIntEnable|=(1<<VIC_TIMER1);
__enable_interrupt();
void TIMER0(void)
led2=0;
printf("\n vimicrosystem \n");
T0IR=1;
void TIMER1(void)
led1=0;
80
User Manual
led2=0;
printf("\n chennai \n");
T1IR=1;
int putchar(int ch)
if (ch=='\n')
while ((U0LSR&0x20)!=0x20); //wait until Transmit Holding Register is empty
U0THR=0x0d; //then store to Transmit Holding Register
U0THR=ch;
while ((U0LSR&0x20)!=0x20) ; //wait until Transmit Holding Register is empty
return(ch); //then store to Transmit Holding Register
void main()
PINSEL0=0X00000005;
IO0DIR=0X00003000;
VPBDIV=0X01;
U0LCR=0X83;
U0DLL=0X4E;
81
User Manual
U0DLM=0X00;
U0LCR=0X03;
T0IR=0XFF;
T0TC=0;
T0PR=0;
//T0MR0=0X00000000C;
T0MR0=0X002255100;
T0MCR=3;
T0TCR=1;
T1IR=0XFF;
T1TC=0;
T1PR=0;
T1MR0=0X000002EE0;
T1MCR=3;
T1TCR=1;
while(1)
timerenable(); printf("\n
working... \n"); led1=1;
82
User Manual
Procedure to View Result In ARM



download the code in board using Flash Magic through UART0.


Run/Execute the program on the VSK – 2148 board and observe the variation in
the main process as an interrupt occurred.

The variations can be viewed in the CRO.
Interrupt performance in FPGA
Procedure for FPGA
Step 1: Create a “New project” in Xilinx ISE Project Navigator from File
Button.
Step 2: Assign a “Name” of the project and click “Next”
Step 3: Check/ modify the properties for the FPGA hardware and click
“Next”.
Step 4: Click “Finish” for the Summary window.(Now the new project
window has been displayed in the ISE Project Navigator.)
Step 5: Right click on the Xilinx FPGA hardware in the Hierarchy window pane
and select add “New Source”.
Step 6: Select “VHDL Module” and enter the file name before clicking
“Next”.
83
User Manual
Step 7: Define the “port details” of the VHDL module and click “Next”.
Step 8: Now click “Finish” the Summary window pane.
Step 9: Now copy and paste the below program in the module.
(Follow the same procedure from “Step 5 to Step 8” for adding
the VHDL modules for the below program.)
Step 10: Right click on the Xilinx FPGA hardware in the Hierarchy window
pane and select add “New Source”.
Step 11: Select “Implementation Constraint File” and enter the file name
before clicking “Next”.
Step 12: Copy and Paste the Implementation Constraint File module in the
appropriate module.
Step 13: Click “Generate Programming File” in the Processes pane for the
entire project.(Now the .bit file has been generated for the project)
Step 14: Before continuing with the further process please Connect the
FPGA hardware kit with the CPU by using serial cable and Switch
“ON”.
Step 15: Now Open the JTAG 5.5 software from Start menu in your
computer and initialize the FPGA device for dumping the
program into it.
Step 16: While initializing please “Assign” the “.bit file” and “Program”
your FPGA by in the JTAG 5.5 application.
(Now the coded instructions have been loaded in the FPGA hardware kit.
84
User Manual
Program (FPGA)
Top module
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
-- DECLARATION OF THE PORT DETAILS IN TOP MODULE SECTION
ENTITY TOP_MODULE IS
PORT ( CLK : IN STD_LOGIC;
GEN_CLK1 : OUT STD_LOGIC;
INPUT1 : IN STD_LOGIC; ---- SQUARE SIGNAL

RISING_INTERRUPT : OUT STD_LOGIC;
RISING_INTERRUPT1: OUT STD_LOGIC;
RISING_INTERRUPT2: OUT STD_LOGIC
);
END TOP_MODULE;
ARCHITECTURE BEHAVIORAL OF TOP_MODULE IS

-- DECLARATION OF THE PORT DETAILS IN INPUT SIGNAL MODULE--
COMPONENT CLK_GEN IS PORT ( CLK : IN STD_LOGIC;
GEN_CLK1
: OUT STD_LOGIC;
GEN_CLK2
: OUT STD_LOGIC;
GEN_CLK3
: OUT STD_LOGIC
);
END COMPONENT;
-- DECLARATION OF THE PORT DETAILS IN INTERRUPT ROUTINE MODULE--

COMPONENT INTERRUPT IS PORT ( CLK : IN STD_LOGIC;
INPUT1
: IN STD_LOGIC; ---- SQUARE SIGNAL
INPUT2
INPUT3
RISING_INTERRUPT : OUT STD_LOGIC;
RISING_INTERRUPT1: OUT STD_LOGIC;
RISING_INTERRUPT2: OUT STD_LOGIC );
END COMPONENT;
85
User Manual
BEGIN
--DECLARING THE SIGNAL DETAILS OF THE COMPONENTS FOR PORT MAPPING --
CLK_SECTION :CLK_GEN PORT MAP
(CLK,GEN_CLK1,GEN_CLK2,GEN_CLK3);
INTERRUPT_SECTION :INTERRUPT PORT MAP
(CLK,INPUT1,INPUT2,INPUT3,RISING_INTERRUPT,RISING_INTERRUPT1,RISING
_INTERRUPT2);
END BEHAVIORAL;
CLK_GEN
LIBRARY IEEE;
-- DECLARATION OF PORT DETAILS --
ENTITY CLK_GEN IS
PORT ( CLK : IN STD_LOGIC;
GEN_CLK3 : OUT STD_LOGIC);
END CLK_GEN;
ARCHITECTURE BEHAVIORAL OF CLK_GEN IS
SIGNAL FREQ :INTEGER :=0; -- SIGNAL DECLARATION OF FREQ

BEGIN
PROCESS(CLK) -- INPUT CLOCK SIGNAL FOR GENERATING 3 INPUT SIGNALS
BEGIN
IF RISING_EDGE (CLK) THEN -- ROUTINE FOLLOWS WITH REFERENCE TO THE
CLOCK SIGNAL
FREQ <= FREQ +1; -- GENGERATING THE COUNTER FOR THE SIGNAL
FREQ
IF(FREQ >0 AND FREQ <= 10000)THEN -- FOR GETTING 1KHZ SIGNAL WE
ARE EQUALLY SPLITTING UP THE TIMING VALUES '0' FOR 10000 COUNTS AND
'1' FOR 10000 COUNTS
GEN_CLK1 <= '1'; -- STATE OF '1' FOR 1ST INPUT SIGNAL AT 2KHZ
ELSIF (FREQ >10000 AND FREQ <= 20000)THEN
86
User Manual
ELSIF (FREQ > 20000)THEN

FREQ <= 0; -- COUNTER RESETS TO '0' IT IT EXCEEDS 20000 COUNTS
END IF;
END IF; -- PROCESS ENDS BY GENERATING THE 3 INPUT SIGNALS
END PROCESS;
END BEHAVIORAL;
Interrupt
-------------------------------------------------------------------------
-- LIBRARY PART --
-------------------------------------------------------------------------
LIBRARY IEEE;
-------------------------------------------------------------------------
-- PORT DECLARATION PART --
-------------------------------------------------------------------------
ENTITY INTERRUPT IS
PORT ( CLK : IN STD_LOGIC ; -- INPUT
CLOCK
INPUT1 : IN STD_LOGIC; -- SQUARE
SIGNAL
SIGNAL
SIGNAL
RISING_INTERRUPT : OUT STD_LOGIC; -- INTERRUPT OUTPUT
1
RISING_INTERRUPT1 : OUT STD_LOGIC; -- INTERRUPT OUTPUT
2
RISING_INTERRUPT2 : OUT STD_LOGIC -- INTERRUPT OUTPUT
3
);
END INTERRUPT ;
-------------------------------------------------------------------------
--DESIGN ARCHITECTURE BEGIN'S --
-------------------------------------------------------------------------
ARCHITECTURE BEHAVIORAL OF INTERRUPT IS

SIGNAL C1,C2,C3 : INTEGER :=0 ; --
INTERNAL INTEGER SIGNAL DECLARATION FOR GLOBAL PURPOSE
SIGNAL RISING,RISING1,RISING2,X,Y,Z: STD_LOGIC:='0'; --INTERNAL BINARY
OR SINGLE BIT SIGNAL FOR GLOBAL USE
BEGIN
87
User Manual
--------------------------------------------------------------------------
-- FIRST INTERRUT DESIGN --
--------------------------------------------------------------------------
PROCESS(CLK,INPUT1) --SENSITIVITY LIST

FOR INPUT USE
VARIABLE A,B,C,D,E,F,G,H,I,J,K,L,M,N : INTEGER :=0 ; --INTERNAL
VARIABLE'S DECLARATION FOR INTERNAL PROCESS
BEGIN
IF RISING_EDGE(CLK) THEN --CLOCK SIGNAL
RISING_INTERRUPT<= RISING;
-- ASSIGNING RISING_INTERRUPT AS RISING VALUE
CASE X IS
-- SUBJECTING X VALUE WITH THE STANDARD LOGIC
FUNCTION '0' AND '1'
WHEN '0' =>
IF INPUT1='1' THEN --ROUTINE WILL CONINUE IF INPUT1
IN ON CONDITION
RISING<='1'; -- RISING VALUE SHOULD BE
ON & X VALUE SHOULD BE ON
X<='1';
END IF;
WHEN '1'=>
IF INPUT1='0' THEN --ROUTINE WILL CONTINUE IF INPUT
1 IN OFF CONDITION
X<='0'; -- VALUE OF X TENDS
TO '0'
END IF;
WHEN OTHERS=> -- IF ANY CONDITION OTHER
THAN '0' AND '1' THEN THE SUBJECT SHOULD BE ENDED.
END CASE;
IF RISING='1' THEN -- IF THE SIGNAL FOUND AS RISING EDGE
THEN THE BELOW OPERATION SHOULD BE FOLLOWED BY THE PROCESSOR
A := 30000+300000; -- ADDITION OPERATION

B:= 5669*6587; --MULTIPLICATION OPERATION
C:= 5456496/564; --DIVISION OPERATION
E:=684986-546657; --SUBTRACTION OPERATION
F:=4858*555; --MULTIPLICATION OPERATION
G:=45587486/6484; --DIVISION OPERATION
H:=5847962-45134; --SUBTRACTION OPERATION
I:=6872678+2587; -- ADDITION OPERATION
J:=245231+5454; -- ADDITION OPERATION
K:=86748/654; --DIVISION OPERATION
L:=816784*864; --MULTIPLICATION OPERATION
M:=54341/64112; --DIVISION OPERATION
N:=46845*4816; --MULTIPLICATION OPERATION
C1<=C1+1; -- HERE THE COUNTER STARTS TO SUPPORT THE DELAY
8
8
User Manual
IF C1>= 9000 THEN -- WE CAN MANUALLY SET THE LIMIT AS OUR

CONVENIENCE
RISING<='0'; -- ONCE THE COUNTER
EXCEEDS THE VALUE OF 9000 THEN THE STATE OF RISING SHOULD BE '0'. THEN THE
ROUTINE WILL END UP.
C1<=0; --ONCE THE COUNTER
EXCEEDS OUR GIVEN LIMIT THEN THE COUNTER VALUE RESETS TO 0.
END IF; -- RISING = '1' CONDITION
ENDS HERE.
END IF;
END IF; -- ENTIRE PROCESS

ENDS UP ONCE THE COUNTER EXCEEDS THE GIVEN LIMIT ALOND WITH THE GIVEN
ARITHMETIC OPERATIONS..
END PROCESS; -- THESE ABOVE CONDITIONS
PROVIDE US THE INTERRUPT PERFORMANCE OFTHE GIVEN INPUT SIGNAL THRU
RISING_INTERRUPT SIGNAL.
--------------------------------------------------------------------------
-- SECOND INTERRUPT DESIGN --
--------------------------------------------------------------------------
PROCESS(CLK,INPUT2) --SENSITIVITY LIST FOR INPUT USE
VARIABLE A,B,C,D,E,F,G,H,I,J,K,L,M,N:INTEGER :=0; --INTERNAL VARIABLE'S
DECLARATION FOR INTERNAL PROCESS
BEGIN
IF RISING_EDGE(CLK) THEN --CLOCK SIGNAL
RISING_INTERRUPT1<= RISING1; -- ASSIGNING RISING_INTERRUPT AS

RISING VALUE
CASE Y IS WHEN '0' => -- SUBJECTING Y VALUE WITH THE

STANDARD LOGIC FUNCTION '0' AND '1'
IF INPUT2='1' THEN --ROUTINE WILL CONINUE IF
INPUT1 IN ON CONDITION
RISING1<='1'; -- RISING VALUE SHOULD BE '1' &

X VALUE SHOULD BE ON
Y<='1';
END IF;
WHEN '1'=>
IF INPUT2='0' THEN --ROUTINE WILL CONTINUE IF INPUT 1 IN
'0' CONDITION
Y<='0'; -- VALUE OF X
TENDS TO '0'
END IF;
89
User Manual
WHEN OTHERS=> -- IF ANY CONDITION OTHER

THAN '0' AND '1' THEN THE SUBJECT SHOULD BE ENDED.
END CASE;
IF RISING1 ='1' THEN -- IF THE SIGNAL FOUND AS

RISING EDGE THEN THE BELOW OPERATION SHOULD BE FOLLOWED BY THE PROCESSOR
A := 30000+300000; -- ADDITION OPERATION

B:= 5669*6587; --MULTIPLICATION OPERATION
C:= 5456496/564; --DIVISION OPERATION
E:=684986-546657; --SUBTRACTION OPERATION
F:=4858*555; --MULTIPLICATION
OPERATION
G:=45587486/6484; --DIVISION OPERATION
H:=5847962-45134; --SUBTRACTION OPERATION
I:=6872678+2587; -- ADDITION OPERATION
J:=245231+5454; -- ADDITION OPERATION
K:=86748/654; --DIVISION OPERATION
L:=816784*864; --MULTIPLICATION OPERATION
M:=54341/64112; --DIVISION OPERATION
N:=46845*4816; --MULTIPLICATION OPERATION
C2<=C2+1; -- HERE THE COUNTER

STARTS TO SUPPORT THE DELAY OF THE SIGNAL
IF C2>= 6000 THEN -- WE CAN MANUALLY SET THE LIMIT AS OUR

CONVENIENCE
RISING1<='0'; -- ONCE THE COUNTER EXCEEDS
THE VALUE OF 6000 THEN THE STATE OF RISING SHOULD BE '0'. THEN THE ROUTINE
WILL END UP.
C2<=0; --ONCE THE

COUNTER EXCEEDS OUR GIVEN LIMIT THEN THE COUNTER VALUE RESETS TO 0.
END IF; --THE RISING =

'1' CONDITION ENDS HERE.
END IF; -- ENTIRE

PROCESS ENDS UP ONCE THE COUNTER EXCEEDS THE GIVEN LIMIT ALOND WITH THE
GIVEN ARITHMETIC OPERATIONS..
END IF; -- THESE ABOVE

CONDITIONS PROVIDE US THE INTERRUPT PERFORMANCE OF THE GIVEN INPUT SIGNAL
THRU RISING_INTERRUPT SIGNAL.
END PROCESS;
END BEHAVIORAL;
90
User Manual
Procedure to View Result in FPGA
By connecting the probes of CRO/MSO/DSO to the Desired Input and Output pins of the
I/O connectors we will acquire the result of the Interrupt performance of FPGA device.
Procedure to View Result in Simulation:
Step 1: Run the Simulation process of the Project by selecting “Simulation” in the
“View” pane and select the Simulator (ModelSim) in the Processes pane.
Step 2: Force clock input to the CLK variable by right clicking the variable Step
3: Now you can observe the Input and output result in the Simulator.
91
User Manual
Experiment 9
Flashing of LEDS
Aim
To develop a ‘C’ program to make the LED blink (including delay routine). Upon change
in the delay program the speed should vary.
11. Flash Magic.
Theory
LEDs are based on the semiconductor diode. When the diode is forward biased (switched
on), electrons are able to recombine with holes and energy is released in the form of light.
This effect is called electroluminescence and the color of the light is determined by the
energy gap of the semiconductor.
VSK-2148 has 8 LEDs that are connected to the Microcontroller Port
Line. Used Port Lines: LED0 – LED7: P1.24 – P1.31
92
User Manual
Procedure
2. Type the below code and save it with the name led.c (anyname.c)
the program
download your code.
93
User Manual
Program led.c
/* - - - - - Header File - - - - - */
/* - - - - - delay Routine - - - - - */
void delay()
{
for(int i=0x00;i<=0xff;i++)
for(int j=0x00;j<=0xFf;j++);
/* - - - - - mian function starts - - - - - */

void main()
{
PINSEL2 = 0X00000000; /* P1.24 TO P1.31 as GPIO */
IO1DIR = 0XFF000000; /* P1.24 TO P1.31 Configured as Output port. */
while(1)
{
IO1SET=0XFF000000; /* P1.24 TO P1.31 goes to high state */
delay(); /* delay */
IO1CLR=0XFF000000; /* P1.24 TO P1.31 goes to low state */
delay(); /*delay */
}
}
94
User Manual


download the code in board using Flash Magic through UART0.


Run/Execute the program on the VSK – 2148 board and observe the LED blink
duration (on/off).
Result
The C-Language program to make the LED blink was developed and output was
verified. Upon change in the delay program the speed variation was verified.
95
User Manual
Experiment 10
Interfacing Stepper Motor and Temperature Sensor
Aim
To write C Programs for running stepper motor either in clock-wise or counter-clock-

wise and the direction of the rotation of the stepper motor depends on the variation in the
temperature sensor.
3. Flash Magic.
4. Stepper motor
Theory
Stepper motors, effectively have multiple "toothed" electromagnets arranged around a
central metal gear. To make the motor shaft turn, first one electromagnet is given power,
which makes the gear's teeth magnetically attracted to the electromagnet's teeth. When
the gear's teeth are thus aligned to the first electromagnet, they are slightly offset from the
next electromagnet.
So when the next electromagnet is turned on and the first will turn off, the gear rotates
slightly to align with the next one and from there the process is repeated. Each of those
slight rotations is called a "step." In that way, the motor can be turned to a precised angle.
There are two basic arrangements for the electromagnetic coils: bipolar and unipolar.
96
User Manual
Jumper Position
Closed 1 and 2 - Internal voltage for stepper motor.
Closed 2 and 3 - External voltage for stepper motor.
Procedure
2. Type the below code and save it with the name step.c (anyname.c)
the program
download your code.
97
User Manual
Program step.c
/* - - - - - header files - - - - - */
#include<stdio.h>
#include "uart.h"
#include "stepper.h"
#include "adc.h"
/* - - - - - user defined variables - - - - - */
unsigned int temp;

/* - - - - - main function - - - - - */
void main()
{
init(); /* call function initializations. Function definition is in “uart.h”*/
adc(); /* call function adc. Function definition is in “adc.h” */
uart_inital(); /* call function uart initializations. Function definition is in

“uart.h”*/
printf( "%d \n" ,

temp ); while(1)
{
temp=AD0DR_bit.RESULT; /* When DONE is 1, this field contains a binary fraction
representing the voltage on the AIN pin, divided by
the voltage on the VREF pin (V/VREF). */
if(temp>=70)
{
fwd(); /* call the forward rotation function of stepper motor. Function definition is in
“stepper.h” */
98
User Manual
else if(temp<=70)
{
rev(); /* call the reverse rotation function of stepper motor. Function definition is in
“stepper.h” */
}
}
}
99
User Manual





Now connect/interface the stepper motor at the motor port available in the VSK -
2148 Board with proper polarity.

Now check the jumpers J4 and J6. Jumper J4 has to be left opened whereas
jumper J6 has to be closed.


Open Win X- Talk and select the COM port and the desired baud rate as 9600.

The variations in the temperature is displayed in the PC and the motor will rotate
in clock-wise direction if the temperature in below 70 and will rotate in anti –
clock-wise, if the temperature is above 70.

Modify the program as per your desire/logic and verify the output.
Result
The C-Language program for running stepper motor either in clock-wise or

counter-clock-wise depending on the temperature is developed and the output is verified.
100
User Manual
Experiment 11
Implementing Zigbee Protocol with ARM
Theory
The X Bee/X Bee-PRO ZNet 2.5 (formerly known as Series 2 and Series 2 PRO) RF
Modules were directed to operate within the ZigBee protocol. The modules provide
reliable delivery of data between remote devices. Zigbee is the communication protocol
like wifi and Bluetooth. Xbee is the module using Zigbee protocol
Some of its features are:
 ZigBee is targeted at radio-frequency (RF) applications
 Low data rate, long battery life, and secure networking
 Transmission range is between 10 and 75 meters (33~246 feet)
 The addressing space allows of extreme node density—up to

18,450,000,000,000,000,000 devices (64 bit IEEE address)
 using local addressing, simple networks of more than 65,000 nodes can be
configured, with reduced address overhead
 The radios use direct-sequence spread spectrum coding, which is managed

by the digital stream into the modulator.
 To ensure reliable data transmission
 Binary phase shift keying (BPSK) in the 868/915 MHz
 Offset quadrature phase shift keying (O-QPSK) at 2.4 GHz
101
User Manual
Xbee interfacing with PC
102
User Manual
Xbee interfacing with microcontroller
11.1 Interfacing ADC and Stepper Motor via Xbee
Aim
To write C Programs to control the rotation of a stepper motor connected with a

controller from the variation in the ADC of another controller and the controllers
has to communicate via Xbee.
3. Flash Magic.
4. Xbee modules 2 Nos.
Procedure
the program
download your code.
103
User Manual
Program main.c
/* - - - - - header files - - - - - */
#include<stdio.h>
#include "stdlib.h"
#include "uart.h"
#include "stepper.h"
unsigned int temp;

int i,z;
char s,out[20];
/* - - - - - main - - - - - */
void main()
{
init(); /* call initialization function */
uart_inital(); /* call uart initialization */
while(1)
{
for(i=0;i<4;i++)
{
out[i]= serial_rx(); /* receive the datas serially and store it in an array */
}
out[i]='\0';
z=atoi(out); /* convert array to integer */
104
User Manual
printf("%d ",z);
if(z >70)
{
fwd(); /* stepper motor forward rotation */
}
}
}
105
User Manual





Connect 2 Xbee modules with 2 VSK-2148 boards.


Based on the Variation in the ADC value the stepper motor will start rotating in
the clock-wise direction.
Result
The C Programs to control the rotation of a stepper motor connected with a controller
depending on the variation in the ADC of another controller is developed and is verified.
106
User Manual
Experiment 11
11.2 Keypad
Aim
To transmit the data or the key pressed in the keypad via Xbee and view the output
data in the PC.
3. Flash Magic.
4. Xbee modules 2 Nos.
Procedure
the program
download your code.
107
User Manual
Program main.c
/* Keypad Interface
/ K1 TO K8 : P0.16 TO P0.23
/ Key Value is displayed on UART0
// SCAN LINES : P0.20 TO P0.23 (OUTPUT)
// READ LINES : PO.16 TO P0.19 (INPUT) */
/* - - - - - header files - - - - - */
#include<stdio.h>
#include "uart.h"
int i;
unsigned char dat[16]="Press Any Key";
/* - - - - - delay routine - - - - - */
void delay()
{
long int i;
for(i=0;i<50000;i++);
}
/* - - - - - main function - - - - - */
void main()
{
PINSEL2 = 0x00000000; /* P0.16 TO P0.23 Configured as GPIO. */
IO0DIR = 0X00F00F05; /* P0.20 TO P0.23 (O/P), P0.16 TO P0.19(I/P) */
IO1DIR=0x00ff0000;
uart_inital();
10
8
User Manual
printf("\n\r 4 x 4 Matrix Key Pad Interface ");

printf("\n\r Press any Key Pad Interface ");
while(1)
{
IO0PIN=0x00E00000; /* Scan First Line */
if(( IO0PIN & 0x000F0000 )!= 0x000F0000) /* Check if any key is pressed in 4th row */
{
switch(IO0PIN & 0x000F0000) /* Check which one of the key is pressed */
{
case 0x00070000 : printf("F"); break;
case 0x000B0000 : printf("B"); break;
case 0x000D0000 : printf("7"); break;
case 0x000E0000 : printf("3"); break;
}
}
IO0PIN=0x00D00000; /* Scan second line */
if(( IO0PIN & 0x000F0000 )!= 0x000F0000) /* Check if any key is pressed in 3rd row */
{
switch(IO0PIN & 0x000F0000) /*check which one of the key is pressed.*/
{
case 0x00070000 : printf("E"); break;
case 0x000B0000 : printf("A"); break;

}
109
User Manual
}
IO0PIN=0x00B00000; /* Move 3rd scan data to port line */
if(( IO0PIN & 0x000F0000 )!= 0x0F000000) /* Scan any key is pressed in 2nd row */
{
switch(IO0PIN & 0x000F0000) /* Check which one of the key is pressed in 2nd row */
case 0x00070000 : printf("D"); break;

case 0x000B0000 : printf("9"); break;
}
}
IO0PIN=0x00700000; /* Move 4th scan data to port line */
if(( IO0PIN & 0x000F0000 )!= 0x000F0000) /* Check any key is pressed in 1st row */
{
switch(IO0PIN & 0x000F0000) /*Check which one of the key is pressed in 1st row */
case 0x00070000 : printf("C"); break;

case 0x000B0000 : printf("8"); break;
}
}
}
}
110
User Manual





Connect 1 Xbee module with the board and other with the PC.


The keys that are pressed in the board will be displayed in the PC.
Result
The C-Language program for displaying the Key pressed in the Keyboard is displayed in
PC via Xbee.
111

Emb Lab Manual Final

Uploaded by

Copyright:

Available Formats

Emb Lab Manual Final

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Emb Lab Manual Final

Uploaded by

Copyright:

Available Formats

List of Experiments

1. Study of ARM Evaluation System

Overview of the Board

About the Software

IAR EMBEDDED WORKBENCH FOR ARM

The IAR Embedded Workbench IDE

 The IAR C-SPY® Debugger, a state-of-the-art high-level language

IAR Embedded Workbench is available for many microprocessors and

The IDE is a flexible integrated development environment, allowing you to

NXP Semiconductors produce a range of Microcontrollers that feature both on-

 Erasing the Flash memory (individual blocks or the whole device)

IAR EMBEDDED WORKBENCH

The IAR Embedded Workbench® IDE is a very powerful Integrated Development

IAR Embedded Workbench is available for many microprocessors and

IAR C/C++ COMPILER

The compiler provides the following features:

 Generic and ARM-specific optimization techniques produce very efficient

 Comprehensive output options, including relocatable object code,

 Support for the C and C++ programming languages

 Target-specific language extensions, such as special function types,

 Standard library of functions applicable to embedded systems

 IEEE-compatible floating-point arithmetic

The IAR Assembler provides these features:

HOW TO CREATE A NEW PROJECT

The project will appear in the Workspace window

Edit the application code in C Language. E.g. Led.c

2. ADDING FILES TO THE PROJECT

3. SETTING PROJECT OPTIONS

HOW TO CREATE RTOS PROGRAMS

Project Group Names are

2. ADDING Groups TO THE PROJECT

Now create APP group

Add files to APP group

Create new group

Add files to BSP Group

Create new group

Add Files to CPU Group

Create new group

Add Corresponding files to above mentioned group

3. SETTING PROJECT OPTIONS

After that Select Preprocessor menu from same window.

At Preprocessor, we have to include all the directories as given

Select Linker file as given below.

To Compile this Project, Choose Project>Rebuild ALL

NXP Semiconductors produce a range of Microcontrollers that feature both on-

HOW TO DOWNLOAD A CODE TO OUR CONTROLLER

1. Select the COM Port

After downloaded completely, window shows like this

Syllabus Programs in ‘C’

Hardware and software Requirements

1. VSK-2148 Development board

Study of ARM Evaluation System

 8 to 40 kB of on-chip static RAM and 32 to 512 kB of on-chip flash program

 In-System/In-Application Programming (ISP/IAP) via on-chip boot-loader

 Embedded ICE RT and Embedded Trace interfaces offer real-time debugging

 Up to nine edge or level sensitive external interrupt pins available.

 On-chip integrated oscillator operates with an external crystal in range from 1

 Individual enable/disable of peripheral functions as well as peripheral clock

 A 16-bit THUMB instruction set.