DMI COLLEGE OF ENGINEERINGdmice.ac.in/wp-content/uploads/2017/05/EC6711.pdf · 2018-12-24 · dmi...

DMI COLLEGE OF ENGINEERING

(AFFILIATED TO ANNA UNIVERSITY – CHENNAI 600 025)

PALANCHUR, CHENNAI – 602 123.

DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGINEERING

EC6711 – EMBEDDED LABORATORY MANUAL

B.E. – SEVENTH SEMESTER

REGULATION (2013)

INDEX

S.NO LIST OF EXPERIMENTS PAGE

NO.

1. Study of ARM Evaluation system 7

2. Flashings of LEDs 10

3. Interfacing LED and PWM 11

4. Interfacing ADC and DAC 13

5. Interfacing Real Time clock and serial port 18

6. Interfacing stepper motor and temperature sensor 22

7. Interfacing EEPROM and interrupt 26

8. Implementing ZIGBEE protocol with ARM 32

9. Interrupt performance characteristics of ARM and FPGA

40

10. Mail Box 46

CONTENT BEYOND THE SYLLABUS

11 Interfacing Bluetooth Module 50

12 Interfacing GPS Module 53

EC6711-Embedded.Lab Dept of Electronics & Communication Engg

DMI College Of Engineering 1

Vision of the Department

To develop committed and competent technologists in electronics and communication

engineering to be on par with global standards coupled with cultivating the innovations and

ethical values.

Mission of the Department

DM 1: To be a centre of excellence in teaching learning process promoting active learning with

critical thinking.

DM 2: To strengthen the student’s core domain and to sustain collaborative industry interaction

with internship and incorporating entrepreneur skills.

DM 3: To prepare the students for higher education and research oriented activities imbibed with

ethical values for addressing the social need.

PROGRAM EDUCATIONAL OBJECTIVES (PEOs):

PEO1. CORE COMPETENCY WITH EMPLOYABILITY SKILLS: Building on

fundamental knowledge, to analyze, design and implement electronic circuits and systems

in Electronics and Communication Engineering by applying knowledge of mathematics

and science or in closely related fields with employability skills.

PEO2. PROMOTE HIGHER EDUCATION AND RESEARCH AND

DEVELOPMENT: To develop the ability to demonstrate technical competence and

innovation that initiates interest for higher studies and research.

PEO3. INCULCATING ENTREPRENEUR SKILLS: To motivate the students to

become Entrepreneurs in multidisciplinary domain by adapting to the latest trends in

technology catering the social needs.

PEO4. ETHICAL PROFESSIONALISM: To develop the graduates to attain

professional excellence with ethical attitude, communication skills, team work and

develop solutions to the problems and exercise their capabilities.



PROGRAM OUTCOMES (POs)

The Program Outcomes (POs) are described as.

1. Engineering Knowledge: Apply the knowledge of mathematics, science, engineering

fundamentals and an engineering specialization to the solution of complex engineering

problems.

2. Problem Analysis: Identify, formulate, review research literature, and analyze

complex engineering problems reaching substantiated conclusions using first principles

of mathematics, natural sciences, and engineering sciences.

3. Design / Development of solutions: Design solutions for complex engineering

problems and design system components or processes that meet the specified needs with

appropriate consideration for the public health and safety, and the cultural, societal, and

environmental considerations.

4. Conduct investigations of complex problems: Use research-based knowledge and

research methods including design of experiments, analysis and interpretation of data,

and synthesis of the information to provide valid conclusions.

5. Modern tool usage: Create, select, and apply appropriate techniques, resources, and

modern engineering and IT tools including prediction and modeling to complex

engineering activities with an understanding of the limitations.

6. The engineer and society: Apply reasoning informed by the contextual knowledge to

assess societal, health, safety, legal and cultural issues and the consequent

responsibilities relevant to the professional engineering practice.

7. Environment and sustainability: Understand the impact of the professional

engineering solutions in societal and environmental contexts, and demonstrate the

knowledge of, and need for sustainable development.

8. Ethics: Apply ethical principles and commit to professional ethics and responsibilities

and norms of the engineering practice.



9. Individual and team work: Function effectively as an individual and as a member or

leader in diverse teams, and in multidisciplinary settings.

10. Communication: Communicate effectively on complex engineering activities with

the engineering community and with society at large, such as, being able to comprehend

and write effective reports and design documentation, make effective presentations, and

give and receive clear instructions.

11. Project management and finance: Demonstrate knowledge and understanding of

the engineering management principles and apply these to one’s own work, as a member

and leader in a team, to manage projects and in multidisciplinary environments.

12. Life-long learning: Recognize the need for and have the preparation and ability to

engage in independent and lifelong learning in the broadest context of technological

change.

PROGRAM SPECIFIC OUTCOMES (PSOs):

PSO1. Analyze and design the analog and digital circuits or systems for a given

specification and function.

PSO2. Implement functional blocks of hardware-software co-designs for signal

processing and communication applications.

PSO3. Design, develop and test electronic and embedded systems for applications with

real time constraint and to develop managerial skills with ethical behavior to work in a

sustainable environment.



INSTRUCTIONS TO STUDENTS FOR WRITING THE RECORD

In the record, the index page should be filled properly by writing the corresponding

experiment number, experiment name, date on which it was done and the page number.

On the right side page of the record following has to be written:

1. Title: The title of the experiment should be written in the page in capital letters.

2. In the left top margin, experiment number and date should be written.

3. Aim: The purpose of the experiment should be written clearly.

4. Apparatus/Tools/Equipments/Components used: A list of the Apparatus/Tools/

Equipments/ Components used for doing the experiment should be entered.

5. Theory: Simple working of the circuit/experimental set up/algorithm should be written.

6. Procedure: Steps for doing the experiment and recording the readings should be briefly

described(flow chart/ Circuit Diagrams / programs in the case of computer/processor

related experiments)

7. Results: The results of the experiment must be summarized in writing and should be

fulfilling the aim. On the Left side page of the record following has to be recorded: a) Circuit/Program: Neatly drawn circuit diagrams for the experimental set up.

b) Design: The design of the circuit components for the experimental set up for

selecting the components should be clearly shown if necessary.

3. Observations:

i) Data should be clearly recorded using Tabular Columns.

ii) Unit of the observed data should be clearly mentioned

iii) Relevant calculations should be shown. If repetitive calculations are needed, only show a

sample calculation and summarize the others in a table.



EC6711 EMBEDDED LABORATORY L T P C

0 0 3 2

LIST OF EXPERIMENTS:

1. Study of ARM evaluation system 2. Interfacing ADC and DAC. 3. Interfacing LED and PWM. 4. Interfacing real time clock and serial port. 5. Interfacing keyboard and LCD. 6. Interfacing EPROM and interrupt. 7. Mailbox. 8. Interrupt performance characteristics of ARM and FPGA. 9. Flashing of LEDS. 10. Interfacing stepper motor and temperature sensor. 11. Implementing zigbee protocol with ARM.

TOTAL: 45 PERIODS



Course outcomes:

CO 1 Student will be able to write programs in ARM for a specific Application

CO 2 Student will be Interface memory and Write programs related to memory operations

CO 3 Analyse the performance of interrupt

CO 4 Write programmes for interfacing keyboard, display, motor and sensor.

CO 5 Formulate a mini project using embedded system

CO PO, PSO Mappings.

Course Code

and Course

name

CO Program Outcomes PSO

1 2 3 4 5 6 7 8 9 10 11 12 1 2 3

EC6711

Embedded

Laboratory

CO 1 3 - - - - 3 2 3 2 3 2 3 3 2 2

CO 2 3 - - - - 2 3 2 3 3 2 3 3 2 2

CO 3 3 - - - - 1 2 3 2 3 3 2 3 3 3

CO 4 3 - - - - 3 2 3 2 3 3 2 3 3 3

CO 5 3 - - - - 2 3 3 2 3 3 2 3 3 3

Average 3 - - - - 2 2.4 2.8 2 3 3 2.4 3 3 3



INDEX

S.NO LIST OF EXPERIMENTS PAGE

NO.

1. Study of ARM Evaluation system 12

2. Flashings of LEDs 15

3. Interfacing LED and PWM 17

4. Interfacing ADC and DAC 20

5. Interfacing Real Time clock and serial port 27

6. Interfacing Keyboard and LCD 32

7. Interfacing stepper motor and temperature sensor 37

8. Interfacing EEPROM and interrupt 44

9. Implementing ZIGBEE protocol with ARM 53

10. Interrupt performance characteristics of ARM and FPGA

59 11. Mail Box

64


12. Interfacing Bluetooth Module 67

13. Interfacing GPS Module 70



INTRODUCTION TO KEIL ΜVISION4 SOFTWARE The μVision4 IDE is a Windows-based software development platform that combines a robust

editor, project manager, and makes facility. μVision4 integrates all tools including the C

compiler, macro assembler, linker/locator, and HEX file generator. μVision4 helps expedite the

development process of your embedded applications by providing the following:

Full-featured source code editor,

Device database for configuring the development tool setting,

Project manager for creating and maintaining your projects,

Integrated make facility for assembling, compiling, and linking your embedded

applications,

Dialogs for all development tool settings,

True integrated source-level Debugger with high-speed CPU and peripheral simulator,

Advanced GDI interface for software debugging in the target hardware and for

connection to Keil ULINK,

Flash programming utility for downloading the application program into Flash ROM,

Links to development tools manuals, device datasheets & user’s guides.

The μVision4 IDE offers numerous features and advantages that help you quickly and

successfully develop embedded applications. They are easy to use and are guaranteed to help you

achieve your design goals.



INTRODUCTION TO 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 from the Embedded Systems Academy 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 Bootloader 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. Note that in this manual third party Compilers are listed alphabetically. No

preferences are indicated or implied.



ARM 7 LPC2148TRAINER KIT

ARM 7 LPC2148 Trainer Kit designed for educational training purpose and the embedded

device from NXP. This document is a User’s guide which describes the complete hardware

design of the ARM 7 LPC2148 Trainer Kit.

Features:

Device daughter card, easy and flexible to upgrade the device.

Four 10 pin individual digital or analog I/O ports are available.

One16 pin digital I/O port is available.

Inbuilt LEDs are available for PWM output.

Inbuilt push to on switch for Reset.

Inbuilt push to on switch for External Interrupt.

USB ISP programmer inbuilt. And On board Serial to USB bridge is available



FRC CABLE CONNECTION



EXP.NO: 1 Study of ARM

Aim:

To study ARM Processor

Apparatus Required:

ARM Trainer Kit

Block Diagram of ARM Processor:

Theory:

The LPC2141/2/4/6/8 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 a

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, LPC2141/2/4/6/8 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.

ARCHITECTURAL OVERVIEW

The LPC2141/2/4/6/8 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 ARM Peripheral Bus

(APB, a compatible superset of ARM’s AMBA Advanced Peripheral Bus) for connection to on-

chip peripheral functions. The LPC2141/24/6/8 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. LPC2141/2/4/6/8 peripheral functions (other than the interrupt

controller) are connected to the APB bus. The AHB to APB bridge interfaces the APB bus to the

AHB bus. APB peripherals are also allocated a 2 megabyte range of addresses, beginning at the

3.5 gigabyte address point. Each APB peripheral is allocated a 16 kB address space within the

APB address space.

The connection of on-chip peripherals to device pins is controlled by a Pin Connect

Block (see chapter "Pin Connect Block" on page 58). This must be configured by software to fit

specific application requirements for the use of peripheral functions and pins.



ARM7TDMI-S 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.

The ARM7TDMI-S processor is described in detail in the ARM7TDMI-S Datasheet that can be

found on official ARM website.

Result:

The study of ARM Processor is completed.



EXP.NO: 2 Flashing of LEDs

Aim:

To write a program for Flashing LEDs.

Apparatus Required: ARM Trainer Kit

LED Card

PC

Software Required:

Keil μVision4

Flash Magic

Theory:

Light Emitting Diodes (LEDs) are popularly used display components used to indicate

the On and OFF state of system. These are also used to realize various counters like binary

counters experimentally. These LEDs can be easily interfaced with the port pins of any

Microcontroller by using current limiting resistors of the order of 220 Ohms.

The diagram below shows the interfacing of LED array ot the Port1 pins of LPC20148

ARM 7 microcontroller. This program blinks the LEDs continuously with a small delay. The

LEDs are connected to the Port 0 Pins P0.00 to P0.07 and the these Pins are configured as

general Purpose output pins.



Program:

#include <LPC214X.H> void DELAY(unsigned long VALUE); unsigned char A = 0x01; int main() {

IO0DIR = 0x000000FF; while(1) {

/* Port0 00-07 as output*/

/* Infinite loop*/

IO0SET |= A;

/* Port0 00-07 High

*/

DELAY(1000000); IO0CLR |= A;

/* Port0 00-07 High

*/

A <<=1; if(A==0x00) A=0x01; DELAY(1000000);

} } void DELAY(unsigned long VALUE) {

while(VALUE>0) {

VALUE--; }

}

Result:

Thus the Flashing of LEDs are verified and executed.



EXP.NO: 3 Interfacing LED and PWM

Aim:

To write a program for Interfacing LED and PWM


LED Card

PC

Software Required:

Keil μVision4

Flash Magic

Interfacing LED and PWM:

Program:

#include<LPC214x.h> /* ******************************************************************************

**************** * Function : PwmInit * Description : Routine for 120 Khz Frequency Generation * Parameters : None



****************************************************************************** ****************

*/

void INIT_ADC(void); int READ_ADC(void);

unsigned int PWM=0;

void PwmInit() {

PINSEL0 = 0X00008000; // Enable PWM2 -- P0.7 PWMLER = 0X00000004; // Set latch register PWMPR = 0X00000000; // Prescale 0 PWMMR0 = 0X000003FF; // 120 KHz Frequency

PWMMCR = 0X00000002; // Set only Match0 control PWMPCR = 0X00000400; PWMTCR = 0X00000009;

}

int main() {

PwmInit(); INIT_ADC(); //IO0DIR = 0x000000FF; //IO0CLR &= 0x000000FF; while(1) { PWM = READ_ADC(); if(PWM>0x000003FF) PWM=0x000003FF; PWMMR2 = PWM; PWMTCR = 0X00000000; PWMTCR = 0X00000009;

} }

void INIT_ADC() {

PINSEL1 |= 0x01000000; AD0CR = 0x00200602;

} int READ_ADC() {

int VAL; AD0CR |= 0x01000000;

/* Start A/D Conversion

*/

do {



VAL = AD0DR1; /* Read A/D Data Register */ }

while (!(VAL & 0x80000000)); /* Wait for end of A/D Conversion */

AD0CR &= ~0x01000000; /* Stop A/D Conversion */

VAL >>=6; VAL = VAL & 0x3FF; return(VAL);

}

Result:

Thus the interfacing of LED and PWM is executed.



EXP.NO: 4 Interfacing ADC and DAC

Aim:

To write a program for Interfacing ADC and DAC.


ADC and DAC Card

PC

Software Required: Keil μVision4

Flash Magic

Interfacing Analog to Digital Converter –

ADC Theory:

LPC2148 controller has two on n-chip ADCs. In the present program the ADC0 with channel 3 is used and configured to convert the analog input signal into its equivalent digital output. The configuring of on chip ADC is given below.

The ARM7 LPC21xx processor is interfaced to the 2x16 LCD module in 8-bit mode. The interface diagram is shown. The eight data pins are connected with eight data bits (P1.16 – P1.23 pins to bits D0 -D7), address bit (RS – P0.23), read / write bit (R/W – P0.22) and control signal (E – P0.21) to make LCD display complete. The pins D0, D1, D2, D3 are left free without any connections.



16X 2LCD is a 16 pin module. In which pins 1 & 16 are grounded, 2 & 15 are given to

Vcc and 3rd pin is given to potentiometer in order adjust the contrast of LCD. Pin 4, 5 & 6 corresponds to RS, R/W & EN respectively. Pins 8 to 15 are data lines from D0 to D7 respectively. Here the LCD is used in 8 bit mode. i.e., 8 bits are used to transfer the data with MSB first and LSB next. Port 0 pins i.e. from P0.09 to 11, are used for both data and control signals. The interfacing diagram of 16X2 LCD is shown.

Program:

FOR ADC

#include <LPC214x.H> #include <STRING.H>

void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CMD(unsigned int); void LCD_INIT(void); int READ_ADC(void); void INIT_ADC(void); void CONVERT_ADC(unsigned int);

unsigned int E = 0x00000800; // P1.21 ENABLE LCD unsigned int RW = 0x00000400; // P1.22 READ/WRITE LCD unsigned int RS = 0x00000200; // P1.23 REGISTER SELECT LCD

unsigned int TEMP=0,ADC=0; unsigned long temp_adv=0,temp_sum=0; unsigned int count=0;

int main() {

INIT_PLL(); INIT_GPIO(); LCD_INIT();

INIT_ADC(); LCDSTR(0x00000080," ADC "); LCDSTR(0x000000C0,"VOLTAGE = ");

while(1) {

for(count=0;count<10000;count++) {

temp_sum = temp_sum+READ_ADC(); }

temp_adv=temp_sum/10000;



TEMP=temp_adv; temp_sum=0; ADC = 1000*(TEMP*(3.901/1024)); LCD_CMD(0x000000CA);

CONVERT_ADC(ADC); }

} void DELAY(unsigned int VALUE) {

unsigned int i,j; for(i=0;i<VALUE;i++)

{ for(j=1;j<1200;j++);

} }

void INIT_GPIO() {

IO0DIR =0x00000E00; IO1DIR =0X00FF0000;

// P0.8 ----- P0.15 // P1.21 --- P1.23

LCD DATA LCD CONTROL

} void INIT_PLL() {

PLL0CFG=0x00000024; // TO GENERATE 60 MHZ CCLK

PLL0CON=0x00000001; PLL0FEED=0x000000AA;

// UPDATE THE PLL REGISTER

PLL0FEED=0x00000055; while(!(PLL0STAT & 0x00000400)); // CHECK WHETHRT THE CCLK

IS GENERATED EXAXT VALUE PLL0CON=0x00000003; PLL0FEED=0x000000AA;

// CONNECT PLL

// UPDATE THE PLL REGISTER PLL0FEED=0x00000055; VPBDIV=0x00000002;

// PCLK=1/2*CCLK

} void LCD_DATA(unsigned char VALUE) {

unsigned int b,TEMP; TEMP = VALUE; for(b=0;b<16;b++)

{ TEMP = TEMP<<1;

} IO1SET = TEMP; IO1CLR = ~TEMP; IO0CLR = RW; IO0SET = RS; IO0SET = E;



DELAY(50); IO0CLR = E;

} void LCD_CMD(unsigned int LCMD) {

unsigned int b; for(b=0;b<16;b++)

{ LCMD = LCMD<<1;

} IO1SET = LCMD; IO1CLR = ~LCMD; IO0CLR = RW; IO0CLR = RS; IO0SET = E; DELAY(50); IO0CLR = E;

} void LCDSTR(unsigned char ADDRESS,char *MSG)

{ unsigned char COUNT,LENGTH;

LCD_CMD(ADDRESS); LENGTH = strlen(MSG);

for(COUNT=0;COUNT<LENGTH;COUNT++) {

LCD_DATA(*MSG); MSG++;

} }

void LCD_INIT() {

LCD_CMD(0x00000038); LCD_CMD(0x0000000C); LCD_CMD(0x00000001); LCD_CMD(0x00000006);

} void INIT_ADC() {

PINSEL1 |= 0x01000000; AD0CR = 0x00200602;

}

int READ_ADC() {

int VAL; AD0CR |= 0x01000000; /* Start A/D Conversion */ do



{ VAL = AD0DR1;

/* Read A/D Data Register

*/

} while (!(VAL & 0x80000000)); /* Wait for end of A/D Conversion

*/ AD0CR &= ~0x01000000; /* Stop A/D Conversion

*/


} void CONVERT_ADC(unsigned int ADC)

{ unsigned int CNT1,CNT2,CNT3,CNT4;

unsigned char DATA1,DATA2,DATA3,DATA4; CNT1 = ADC % 10000/1000;

CNT2 = ADC % 1000/100; CNT3 = ADC % 100/10; CNT4 = ADC % 10/1;

DATA1 = CNT1 | 0x30; DATA2 = CNT2 | 0x30; DATA3 = CNT3 | 0x30; DATA4 = CNT4 | 0x30;

LCD_DATA(DATA1); LCD_DATA('.'); LCD_DATA(DATA2);

LCD_DATA(DATA3); LCD_DATA(DATA4);

return; }

Interfacing of Digital to Analog Converter- DAC Theory:



A digital to analog converter is a device for converting a digital signal into an analog

signal (current or voltage). Digital to analog converters are the interface between the abstract digital world and the analog real world. Simple switches, a network of resistors, current source or capacitors many be used to implement this conversion. A DAC inputs a binary number and output an analog voltage or current signal.

The Microchip Technology Inc. MCP4921 is 2.7 – 5.5V, low power, 12-Bit Digital to Analog Converter (DAC) with SPI interface. The MCP4921 DAC to provides high accuracy and low noise performance for industrial applications where calibration or compensation of signals is required.

With an SPI connection there is always one master device (usually a microcontroller) which controls the peripheral devices. Typically there are three lines common to all the devices.

Master In Slave Out (MISO) – The Slave line for sending data to the master Master Out Salve In (MOSI) – The master Line for sending data to the peripherals Serial Clock (SCK) – The Clock pulses which synchronize data transmission generated by the master Slave Select Pin – The pin on each device that the master can be used to enable and disable specific devices.

When device’s Slave Select pin is low, it communicates with the master. When it’s high , it ignores the master. In SPI, the clock signal is controlled by the master devices LPC2148. All data is clocked in and out using this pin. These lines need to be connected to the relevant pins on the LPC21xx processor. Any unused GIO pin can be used for CS, instead pull this pin high. Conversion speed is the time it takes for the DAC – SPI connections with LPC21xx have four I/O lines (P0.4 – P0.7) required. The analog output is generated by using these four lines.

Program:

FOR DAC (Sin Wave)

#include<lpc214x.h> #include"math.h"

unsigned int t;

void Delay(unsigned long b) {

while (--b!=0); }

int main() {

int value=0x3ff; PINSEL1 = 0X00080000;

while(1) {



value = 512+400*sin(t*0.01745); DACR = value<<6; if(++t==360)t=0;

} }

Result:

Thus interfacing ADC and DAC are executed.



EXP.NO: 5 Interfacing Real Time Clock and Serial Port

Aim:

To write a program for Interfacing Real Time Clock and Serial Port


LCD Card

PC

Software Required:

Keil μVision4

Flash Magic

Theory:


16X 2LCD is a 16 pin module. In which pins 1 & 16 are grounded, 2 & 15 are given to Vcc and 3rd pin is given to potentiometer in order adjust the contrast of LCD. Pin 4, 5 & 6 corresponds to RS, R/W & EN respectively. Pins 8 to 15 are data lines from D0 to D7 respectively. Here the LCD is used in 8 bit mode. i.e., 8 bits are used to transfer the data with MSB first and LSB next. Port 0 pins i.e. from P0.09 to 11, are used for both data and control signals. The interfacing diagram of 16X2 LCD is shown.



Program:

For Real Time Clock:


void DELAY(unsigned int); void INIT_GPIO(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CMD(unsigned int); void LCD_INIT(void); void SETTIME(void);


void SETTIME(void) {

CCR = 0x02; HOUR = 0; MIN = 0; SEC = 0; CCR = 0x11;

}

int main() {

SETTIME(); INIT_GPIO(); LCD_INIT();

LCDSTR(0x00000080,"REAL TIME CLOCK "); LCDSTR(0x000000C0," "); while(1) {

LCD_CMD (0x000000C3); LCD_DATA(HOUR/10 + '0'); LCD_DATA(HOUR%10 + '0'); LCD_DATA(':') ; LCD_DATA(MIN/10 + '0'); LCD_DATA(MIN%10 + '0'); LCD_DATA(':') ; LCD_DATA(SEC/10 + '0'); LCD_DATA(SEC%10 + '0');

}



}

void DELAY(unsigned int VALUE) {


{ for(j=1;j<1200;j++);

} }

void INIT_GPIO() {

IO0DIR =0x00000E00; // P0.8 ----- P0.15

LCD DATA


unsigned int b,TEMP; TEMP = VALUE;

for(b=0;b<16;b++) {

TEMP = TEMP<<1; }

IO1SET = TEMP; IO1CLR = ~TEMP; IO0CLR = RW; IO0SET = RS; IO0SET = E; DELAY(50); IO0CLR = E;



{ LCMD = LCMD<<1;









} }

void LCD_INIT() {


}

Program

For Serial Port:

/***************************************************************** *************/ /* SERIAL.C: */ /************** ****************************************************************/ /* This file is part of the RhydoLabz development kit. */ /* Copyright (c) 2005-2006 Rhydo Software. All rights reserved. /* written to run with keil uvision 3v3.53 demo software. */

*/

/*********************************************************************** *******/

#include <LPC214x.H>

/* LPC21xx definitions

*/

void init_serial (void) { /* Initialize Serial Interface */

PINSEL0 = PINSEL0 | 0X00000005; /* Enable RxD0 and TxD0 U0LCR = 0X83; /*8 bits, no Parity, 1 Stop bit */ U0DLL = 0Xbb; //c3 U0DLM = 0X00; /* 9600bps

baud rate */ U0LCR = 0X03; /* DLAB = 0 */

*/

}

char sendchar (char SDat)



{ while (!(U0LSR & 0x20)); return (U0THR = SDat);

}

int getchar (void) {

while (!(U0LSR & 0x01)); return (U0RBR);

}

Result:

Thus interfacing RTC and Serial Port are executed.



EXP.NO: 6 Interfacing Key Board and LCD

Aim:

To write a program for Interfacing Key Board and LCD


Matrix Key Board and LCD Card

PC

Software Required:

Keil μVision4

Flash Magic

Interfacing of Matrix Keyboard with LCD

Theory:





Program:


#define O1 0X00E00000 #define O2 0X00D00000 #define O3 0X00B00000 #define O4 0X00700000

#define I1 0x000E0000 #define I2 0x000D0000 #define I3 0x000B0000 #define I4 0x00070000

#define CLR 0x00F00000

void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CD(unsigned int); void LCD_INIT(void); char scan (int); void delay(int);


int main() {

INIT_PLL(); INIT_GPIO(); LCD_INIT();

LCDSTR(0x00000080,"Matrix KeyPad "); LCDSTR(0x000000C0,"Key Pressed: ");

while(1) {

IO0CLR = CLR; IO0SET = O1;

delay(10); if(scan(I1))LCDSTR(0x000000CC,"0"); //S1 if(scan(I2))LCDSTR(0x000000CC,"4"); //S5 if(scan(I3))LCDSTR(0x000000CC,"8"); //S9 if(scan(I4))LCDSTR(0x000000CC,"C"); //S13



IO0CLR = CLR; IO0SET = O2; if(scan(I1))LCDSTR(0x000000CC,"1"); //S2 if(scan(I2))LCDSTR(0x000000CC,"5"); //S6 if(scan(I3))LCDSTR(0x000000CC,"9"); //S10 if(scan(I4))LCDSTR(0x000000CC,"D"); //S14 IO0CLR = CLR; IO0SET = O3; if(scan(I1))LCDSTR(0x000000CC,"2"); //S3 if(scan(I2))LCDSTR(0x000000CC,"6"); //S7 if(scan(I3))LCDSTR(0x000000CC,"A"); //S11 if(scan(I4))LCDSTR(0x000000CC,"E"); //S15 IO0CLR = CLR; IO0SET = O4; if(scan(I1))LCDSTR(0x000000CC,"3"); //S4 if(scan(I2))LCDSTR(0x000000CC,"7"); //S8 if(scan(I3))LCDSTR(0x000000CC,"B"); //S12 if(scan(I4))LCDSTR(0x000000CC,"F"); //S16

} }

char scan(int keystatus) /* scanning a a key */ { while((IO0PIN & 0X000F0000)==keystatus)

{ delay(50); if((IO0PIN & 0X000F0000)== 0X000F0000)return(1);

} return(0) ;

} void delay(int n) /* generates one milisecond delay */ {

int i,j; for (i=1; i<=n; i++) for(j=0; j<=10000; j++);



{ for(j=1;j<1200;j++);

} }

void INIT_GPIO() {

IO0DIR =0x00F00E00; // P0.8 ----- P0.15 LCD DATA



IO1DIR =0X00FF0000;

// P1.21 --- P1.23 LCD CONTROL

} void INIT_PLL() {






// CONNECT PLL


// PCLK=1/2*CCLK



{ TEMP = TEMP<<1;

} IO1SET = TEMP; IO1CLR = ~TEMP; IO0CLR = RW; IO0SET = RS; IO0SET = E; DELAY(50); IO0CLR = E;



{ LCMD = LCMD<<1;









} }

void LCD_INIT() {


}

Result:

Thus interfacing of Key Board and LCD are executed.



EXP.NO: 7 Interfacing Stepper Motor and Temperature Sensor

Aim:

To write a program for Interfacing Stepper motor


Stepper Motor and Matrix Key Board

PC

Software Required:

Keil μVision4

Flash Magic

Interfacing Stepper Motor

Theory:

A stepper motor is a brushless, synchronous electric motor that converts digital pulses

into mechanical rotation in steps. Every revolution of the stepper motor is divided into a discrete

number of steps, and receives the motor rotates through one step.

Figure shows the interface of the stepper motor to ARM7 controller. The stepper motor is

connected to Microcontroller using a ULN2003 driver IC. The ULN driver IC is connected to the

Port 1 pins P0.16 to P0.19 pins. So as the microcontroller gives pulses with a particular

frequency to ULN2003, the motor is rotated either in clockwise or anticlockwise.



This Program first configures the ARM Port0 as a GPIO and also as an port. The sequence code

is sent to the driver IC using these port pins. A suitable delay is incorporated between each step

rotation. By applying the code in the reverse order, the stepper motor can be rotated in the

anticlockwise direction.

Program:

For Stepper Motor:

#include<LPC214X.H>


#define I1 0x0000000E #define I2 0x0000000D #define I3 0x0000000B #define I4 0x00000007


unsigned int CLOCK[4] = {0x00030000,0x00090000,0x000C0000,0x00060000}; unsigned int ANTI_CLOCK[4] = {0x00060000,0x000C0000,0x00090000,0x00030000};

char scan (int); void delay(int);

int main(void){ IO0DIR = 0X000F00F0; while(1){ unsigned char I; IO0CLR = CLR; IO0SET = O1; while(scan(I1)) //S1

{ for(I=0;I<4;I++)

{ IO0SET |= CLOCK[I];

IO0CLR |= ~CLOCK[I]; delay(5);

} }

while(scan(I2)) //S5 { for(I=0;I<4;I++)





} }

IO0CLR = CLR; IO0SET = O2; while(scan(I1)) //S2

{ for(I=0;I<4;I++)

{ IO0SET |= ANTI_CLOCK[I];

IO0CLR |= ~ANTI_CLOCK[I]; delay(5);

} }

while(scan(I2)) //S6 { for(I=0;I<4;I++)



} }

IO0CLR = CLR; IO0SET = O3; while(scan(I2)) //S7

{ for(I=0;I<4;I++)



} }

} } char scan(int keystatus) /* scanning a a key */ { while((IO0PIN & 0X0000000F)==keystatus)

{ return(1);

} return(0);

} void delay(int n) /* generates one milisecond delay */

{



int i,j; for (i=1; i<=n; i++) for(j=0; j<=10000; j++); }

Interfacing Temperature Sensor:

Theory:

The ARM7 LPC21xx processor is interfaced to the 2x16 LCD module in 4-bit mode. The interface diagram is shown. The four data pins are connected with 4 data bits (P1.19 – P1.22 pins to bits D4 -D7), address bit (RS – P0.16), read / write bit (R/W – P0.17) and control signal (E – P0.18) to make LCD display complete. The pins D0, D1, D2, D3 are left free without any connections.


Program:

For Temperature Sensor:


void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CMD(unsigned int); void LCD_INIT(void); int READ_ADC(void); void INIT_ADC(void); void CONVERT_ADC(unsigned int);


unsigned int TEMP=0,ADC=0;

int main() {

INIT_PLL();



INIT_GPIO(); LCD_INIT();

INIT_ADC(); LCDSTR(0x00000080," TEMPERATURE ");

LCDSTR(0x000000C0,"DEGREE C = "); while(1) {

TEMP = READ_ADC(); ADC = (1000*(TEMP*(3.901/1024)))-100; LCD_CMD(0x000000CA);

CONVERT_ADC(ADC); }



{ for(j=1;j<1200;j++);

} }

void INIT_GPIO() {


// P0.8 ----- P0.15 LCD DATA // P1.21 --- P1.23 LCD CONTROL

} void INIT_PLL() {






// CONNECT PLL


// PCLK=1/2*CCLK



{ TEMP = TEMP<<1;






{ LCMD = LCMD<<1;







} }

void LCD_INIT() {


} void INIT_ADC() {

PINSEL1 |= 0x01000000; AD0CR = 0x00200602;

}



int READ_ADC() {

int VAL; AD0CR |= 0x01000000;

/* Start A/D Conversion

*/

do {

VAL = AD0DR1; /* Read A/D Data Register

*/

} while (!(VAL & 0x80000000));

/* Wait for end of A/D Conversion

*/ AD0CR &= ~0x01000000; /* Stop A/D Conversion

*/


} void CONVERT_ADC(unsigned int ADC)

{ unsigned int CNT1,CNT2,CNT3,CNT4;

unsigned char DATA1,DATA2,DATA3,DATA4; CNT1 = ADC % 10000/1000;

CNT2 = ADC % 1000/100; CNT3 = ADC % 100/10; CNT4 = ADC % 10/1; DATA1 = CNT1 | 0x30; DATA2 = CNT2 | 0x30; DATA3 = CNT3 | 0x30; DATA4 = CNT4 | 0x30;

LCD_DATA(DATA1); LCD_DATA(DATA2);

LCD_DATA(DATA3); LCD_DATA('.');

LCD_DATA(DATA4); return;

}

Result: Thus the interfacing of Stepper motor and Temperature Sensor are executed.



EXP.NO: 8 Interfacing EPROM and Interrupt

Aim:

To write a program for Interfacing EPROM and Interrupt


EPROM Card

PC

Software Required:

Keil μVision4

Flash Magic

Interfacing of External EPROM:

Theory:





Program:

For EPROM:

#include <LPC21xx.H> #include <STRING.H>

#define DEV_WR_STAT 0X18 #define DEV_RD_STAT 0X40 #define LOC_WR_STAT 0x28 #define DATA_WR_STAT 0x28 #define DEV_WRITE 0XA0 #define DEV_READ 0XA1




void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CD(unsigned int); void LCD_INIT(void); void delay(unsigned int del); void i2c_init(void); void i2c_start(void); void i2c_write(char dat , char status); void i2c_stop(void); char i2c_read(void); void eeprom_read(char loc,char loc_count , char *ptr); void eeprom_write(char loc , char *ptr); char scan (int); void delay1(int);


unsigned char I2Cdata;



char buf[16]; unsigned char cnt=0;

int main() {


LCDSTR(0x00000080,"Ext EEPROM TEST "); LCDSTR(0x000000C0,"MESSAGE COUNT: 1"); cnt=1; while(1) {

IO0CLR = CLR; IO0SET = O1;

delay(10); if(scan(I1))

{ LCDSTR(0x000000C0,"MESSAGE COUNT: 1"); cnt=1;

} if(scan(I2))

{ if(cnt==1) {

eeprom_write(0 , "Enthu Technology"); LCDSTR(0x000000C0,"Writting ");

delay(120000); }

if(cnt==2) {

eeprom_write(0 , "Coimbatore "); LCDSTR(0x000000C0,"Writting

delay(120000); }

if(cnt==3) {

");

eeprom_write(0 , "SSN Sqaure ");

LCDSTR(0x000000C0,"Writting ");

delay(120000); }

if(cnt==4) {

eeprom_write(0 , "Tamil Nadu ");

LCDSTR(0x000000C0,"Writting ");

delay(120000); }

}



IO0CLR = CLR; IO0SET = O2; if(scan(I1))


} if(scan(I2)) { eeprom_read(0,16, buf); LCDSTR(0x000000C0,"Reading "); DELAY(5000);

LCDSTR(0xC0,buf); }

IO0CLR = CLR; IO0SET = O3; if(scan(I1))


} if(scan(I2)) {

eeprom_write(0 , " "); LCDSTR(0x000000C0,"Erasing ");

delay(120000); cnt=5;

} IO0CLR = CLR; IO0SET = O4; if(scan(I1))


} }



{ for(j=1;j<1200;j++);

} }

void INIT_GPIO()



{ IO0DIR =0x00F00E00; IO1DIR =0X00FF0000;

// P0.8 ----- P0.15 // P1.21 --- P1.23




{ TEMP = TEMP<<1;




{ LCMD = LCMD<<1;







} }

void LCD_INIT()



{ LCD_CMD(0x00000038); LCD_CMD(0x0000000C); LCD_CMD(0x00000001); LCD_CMD(0x00000006);

} void delay(unsigned int del) {

while(del-- > 0); }

void i2c_init(void) {

PINSEL0 = 0X50; I2CONCLR = 0X0000002C;

/* clears AA,I2C interrupt

flag,START flag bit*/

I2SCLL = 0xFFFF;

/* bitrate = 400kHz

*/

// 70,5 I2SCLH = 0xFFFF;;

} void i2c_start() {

I2CONSET |= 0x00000020; while (I2STAT !=

/* Set STA flag */ 0x00000008); /* Wait for Status Set - 0x08 */

} void i2c_write(char dat , char status) {

I2DAT = dat; I2CONSET = 0X00000004; I2CONCLR = 0X00000028; while (I2STAT != status); /* Wait for Status Set */

} void i2c_stop(void) {

I2CONSET |= 0x00000014; I2CONCLR = 0x00000008;

/* Stop I2C and Start Bit */ }

char i2c_read(void) {

I2CONSET = 0X00000004; I2CONCLR = 0X00000028; while (I2STAT != return(I2DAT);

0x00000050); /* Wait for Status Set - 0x50 */

}

void eeprom_read(char loc,char loc_count , char *ptr) {

i2c_init(); i2c_start();



i2c_write(DEV_WRITE ,DEV_WR_STAT); i2c_write(loc , LOC_WR_STAT); i2c_stop(); delay(5000); i2c_start(); i2c_write(DEV_READ ,DEV_RD_STAT); while(loc_count-- > 0) { *ptr = i2c_read(); ptr++;

} i2c_stop();

} void eeprom_write(char loc , char *ptr) {

i2c_init(); i2c_start(); i2c_write(DEV_WRITE ,DEV_WR_STAT); i2c_write(loc , LOC_WR_STAT); while(*ptr != '\0')

{ i2c_write(*ptr , LOC_WR_STAT); ptr++;

} i2c_stop();

} char scan(int keystatus) /* scanning a a key */ { while((IO0PIN & 0X000F0000)==keystatus){

delay1(50); if((IO0PIN & 0X000F0000)== 0X000F0000)return(1); } return(0) ;

} void delay1(int n) /* generates one milisecond delay */ { int i,j; for (i=1; i<=n; i++) for(j=0; j<=10000; j++); }



Interfacing of External Interrupt:

Program:

For Interrupt:

#include<lpc21xx.h> void DELAY(unsigned long VALUE); unsigned int A = 0x00010000;

void ext_interrupt(void)__irq {

EXTINT = 0X02; /* Clear interrupt flag

*/ DELAY(5000000); VICVectAddr = 0x00000000;

/*

Acknowledge Interrupt */ }

void init_ext(void) {

PINSEL0 |= 0X20000000; EXT1 */ EXTMODE = 0X02;

edge sensitive */ EXTPOLAR = 0X02;

edge */ VICVectAddr0 =(unsigned int)ext_interrupt; VICVectCntl0 = 0x0000002F;

EXT1 Interrupt */ VICIntEnable = 0x00008000;

EXT1 INTERRUPT */

/* enable

/*

/* on rising

/* Set Interrupt Vector in 0 */ /* Use it for

/* enable

}

int main(void) {

IO0DIR = 0X00FF0000; init_ext();



while(1) {

IO0SET |= A; /* Port0 00-07 High

*/

DELAY(1000000); IO0CLR |= A;

/* Port0 00-07 High

*/

A <<=1; if(A==0x01000000) A=0x00010000; DELAY(1000000); }

} void DELAY(unsigned long VALUE) {

while(VALUE>0) { VALUE--;

} }

Result:

Thus interfacing EPROM and Interrupt are executed.



EXP.NO: 9 Implementing Zigbee Protocol with ARM

Aim:

To write a program for Implementing Zigbee protocol with ARM


Zigbee

Key Pad

LCD

Stepper Motor

PC

Software Required:

Keil μVision4

Flash Magic

Program:

For Transmitter:





void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_DATA(unsigned char); void LCD_CD(unsigned int);



char sendchar (char SDat); void init_serial (void); void LCD_INIT(void); char scan (int); char scan(int keystatus);


int main() {

init_serial(); INIT_PLL(); INIT_GPIO(); LCD_INIT();

LCDSTR(0x00000080," Zig Bee Based "); LCDSTR(0x000000C0,"Motor Controller"); DELAY(6000);

while(1) {

IO0CLR = CLR; IO0SET = O1; while(scan(I1))

{ LCDSTR(0x000000C0,"Running C-wise "); sendchar('C');

} IO0CLR = CLR; IO0SET = O2; while(scan(I1)) {

LCDSTR(0x000000C0,"Running AC-wise "); sendchar('A');

} LCDSTR(0x000000C0,"Motor Stopped ");

} }



{ for(j=1;j<1200;j++);

} }



void INIT_GPIO() {

IO0DIR =0x00F00E00; IO1DIR =0X00FF0000;

// P0.8 ----- P0.15 // P1.21 --- P1.23


} void INIT_PLL() {

PLL0CFG=0x00000024; // TO GENERATE 60 MHZ CCLK PLL0CON=0x00000001; PLL0FEED=0x000000AA; // UPDATE THE PLL REGISTER PLL0FEED=0x00000055; while(!(PLL0STAT & 0x00000400)); // CHECK WHETHRT THE CCLK

IS GENERATED EXAXT VALUE PLL0CON=0x00000003; // CONNECT PLL PLL0FEED=0x000000AA; // UPDATE THE PLL REGISTER PLL0FEED=0x00000055; VPBDIV=0x00000002; // PCLK=1/2*CCLK


unsigned int b,TEMP; TEMP = VALUE;

for(b=0;b<16;b++) {

TEMP = TEMP<<1; }

IO1SET = TEMP; IO1CLR = ~TEMP; IO0CLR = RW; IO0SET = RS; IO0SET = E; DELAY(50); IO0CLR = E;



{ LCMD = LCMD<<1;

} IO1SET = LCMD; IO1CLR = ~LCMD; IO0CLR = RW; IO0CLR = RS; IO0SET = E; DELAY(50);



IO0CLR = E; }

void LCDSTR(unsigned char ADDRESS,char *MSG) {

unsigned char COUNT,LENGTH; LCD_CMD(ADDRESS);

LENGTH = strlen(MSG); for(COUNT=0;COUNT<LENGTH;COUNT++) {


} }

void LCD_INIT() {


}

void init_serial (void) {

PINSEL0 = PINSEL0 | 0X00000005; U0LCR = 0X83; U0DLL = 0XC3; U0DLM = 0X00; U0LCR = 0X03;

}

char sendchar (char SDat) {

while (!(U0LSR & 0x20)); return (U0THR = SDat);

} char scan(int keystatus) { while((IO0PIN & 0X000F0000)==keystatus)

{ return(1);

} return(0);

}



Program:

For Receiver:

#include <LPC21xx.H> #include "serial.h"

void delay(int n);

unsigned int CLOCK[4] = {0x00330000,0x00990000,0x00CC0000,0x00660000}; unsigned int ANTI_CLOCK[4] = {0x00660000,0x00CC0000,0x00990000,0x00330000}; unsigned char SBUF=0;

int main(void) { init_serial (); IO0DIR = 0X00FF0000; while(1) {

SBUF= getchar(); if(SBUF=='C')

{ IO0SET |= CLOCK[0];

IO0CLR |= ~CLOCK[0]; delay(5);

IO0SET |= CLOCK[1]; IO0CLR |= ~CLOCK[1];

delay(5); IO0SET |= CLOCK[2];

IO0CLR |= ~CLOCK[2]; delay(5); IO0SET |= CLOCK[3];

IO0CLR |= ~CLOCK[3]; delay(5);

} if(SBUF=='A')

{ IO0SET |= ANTI_CLOCK[0];

IO0CLR |= ~ANTI_CLOCK[0]; delay(5);

IO0SET |= ANTI_CLOCK[1]; IO0CLR |= ~ANTI_CLOCK[1];

delay(5); IO0SET |= ANTI_CLOCK[2];

IO0CLR |= ~ANTI_CLOCK[2]; delay(5);

IO0SET |= ANTI_CLOCK[3]; IO0CLR |= ~ANTI_CLOCK[3];

delay(5); }

}}



void delay(int n)

{ int i,j; for (i=1; i<=n; i++) for(j=0; j<=10000; j++); }

///// ----------------

Result:

Thus implementing Zigbee protocol with ARM are executed.



EXP.NO: 10 Interrupt Performance characteristics of ARM and FPGA

Aim:

To write a program for Interrupt Performance characteristics of ARM and FPGA


Wire Connection

Functional Generator

PC

Software Required:

Keil μVision4

Flash Magic

Program:


void DELAY(unsigned int); void INIT_GPIO(void); void INIT_PLL(void); void LCD_DATA(unsigned char); void LCD_CMD(unsigned int); void LCDSTR(unsigned char ADDRESS,char *MSG); void LCD_INIT(void); void CONVERT_DATA(unsigned int); void SEC_DELAY(void);


unsigned int count=0;

void ext_interrupt(void)__irq {

EXTINT = 0X02; /* Clear interrupt flag */

count++;



Interrupt }

VICVectAddr = 0x00000000;

*/

/* Acknowledge

void init_ext(void) {

PINSEL0 |= 0X20000000; /* enable EXT1 */

EXTMODE = 0X02; sensitive */

EXTPOLAR = 0X02; edge */

VICVectAddr0 =(unsigned int)ext_interrupt; VICVectCntl0 = 0x0000002F;

Interrupt */

INTERRUPT */ }

/* edge

/* on rising

/* Set Interrupt Vector in 0 */ /* Use it for EXT1

int main() {

INIT_PLL(); init_ext();


LCDSTR(0x00000080,"Counter: "); while(1) {

SEC_DELAY(); LCD_CMD(0x00000088); CONVERT_DATA(count); count=0;

} }



{ for(j=1;j<1200;j++);

} }



void INIT_GPIO() {


// P0.8 ----- P0.15 // P1.21 --- P1.23


} void INIT_PLL() {





IS GENERATED EXAXT VALUE PLL0CON=0x00000003;

// CONNECT PLL

PLL0FEED=0x00000055; VPBDIV=0x00000002;

// PCLK=1/2*CCLK



{ TEMP = TEMP<<1;




{ LCMD = LCMD<<1;

} IO1SET = LCMD; IO1CLR = ~LCMD; IO0CLR = RW; IO0CLR = RS; IO0SET = E;



DELAY(50); IO0CLR = E;






} }

void LCD_INIT() {


} void CONVERT_DATA(unsigned int DATA)

{ LCD_DATA((DATA % 100000000/10000000) | 0x30); LCD_DATA((DATA % 10000000/1000000) | 0x30); LCD_DATA((DATA % 1000000/100000) | 0x30); LCD_DATA((DATA % 100000/10000) | 0x30); LCD_DATA((DATA % 10000/1000) | 0x30); LCD_DATA((DATA % 1000/100) | 0x30); LCD_DATA((DATA % 100/10) | 0x30); LCD_DATA((DATA % 10/1) | 0x30); return;

}

void SEC_DELAY() {

T0PR = 0x0000270F; T0MR0 = 0x00000BA1 ; T0TCR = 0x01; while(T0TC != T0MR0); T0MCR = 0x00000002; T0TCR = 0x02;

//0x0000270F //0x000004B0

}



Result:

Thus Interrupt Performance characteristics of ARM and FPGA are executed.



EXP.NO: 11 MAIL BOX

Aim:

To write a program for Mailbox

Apparatus Required: PC

Software Required:

Keil μVision4

Flash Magic

Program:

#include <RTL.h> #include <LPC21xx.H> #include <stdio.h>

OS_TID tsk1; OS_TID tsk2;

typedef struct { float voltage; float current; U32 counter;

}T_MEAS;

os_mbx_declare (MsgBox,16); _declare_box (mpool,sizeof(T_MEAS),16);

__task void send_task (void); __task void rec_task (void);

void init_serial () {

PINSEL0 = PINSEL0 | 0X00000005; U0LCR = 0X83; U0DLL = 0Xbb; U0DLM = 0X00; U0LCR = 0X03;



}

__task void send_task (void) {

T_MEAS *mptr; tsk1 = os_tsk_self (); tsk2 = os_tsk_create (rec_task, 0); os_mbx_init (MsgBox, sizeof(MsgBox)); os_dly_wait (5);

mptr = _alloc_box (mpool); mptr->voltage = 223.72; mptr->current = 17.54; mptr->counter = 120786; os_mbx_send (MsgBox, mptr, 0xffff); IOSET0 = 0x00010000; os_dly_wait (100);

mptr = _alloc_box (mpool); mptr->voltage = 227.23; mptr->current = 12.41; mptr->counter = 170823; os_mbx_send (MsgBox, mptr, 0xffff); os_tsk_pass (); IOSET0 = 0x00020000; os_dly_wait (100);

mptr = _alloc_box (mpool); mptr->voltage = 229.44; mptr->current = 11.89; mptr->counter = 237178; os_mbx_send (MsgBox, mptr, 0xffff); IOSET0 = 0x00040000; os_dly_wait (100);

os_tsk_delete_self (); }

__task void rec_task (void) {

T_MEAS *rptr; for (;;)

{ os_mbx_wait (MsgBox, (void **)&rptr, 0xffff); printf ("\nVoltage: %.2f V\n",rptr->voltage); printf ("Current: %.2f A\n",rptr->current);



printf ("Number of cycles: %d\n",rptr->counter); _free_box (mpool, rptr);

} }

int main (void) { IODIR0 = 0x00FF0000; IOCLR0 = 0x00FF0000; init_serial (); _init_box (mpool, sizeof(mpool),sizeof(T_MEAS)); os_sys_init (send_task); }

Result:

Thus mailbox are verified and executed.




Ex. No. 12

INTERFACING BLUETOOTH MODULE

Aim :

To write an embedded C code for interfacing Bluetooth Module with ARM CORTEX M3-LPC2148.

Circuit Diagram Procedure:

Give +3.3V power supply to LPC2148 Primer Board; connect the 5V adapter with Bluetooth module which is connected with the LPC2148 Primer Board. There are two Bluetooth modules are required. One is connected with LPC2148 Primer Board; other one is connected with PC. First connect the serial cable between LPC2148 Primer board & PC. Then open the Hyper Terminal screen, select which port you are using and set the default settings. Now the screen should show some text messages. If the messages are correctly displayed in Hyper Terminal, then only connect the Bluetooth modules in LPC2148 Primer Board UART0 & PC. If you are not reading any data from UART0, then you just check the jumper connections & just check the serial cable is working. Otherwise you just check the code with debugging mode in Keil.



Program:

#define CR 0x0D #include <LPC21xx.H> void init_serial (void); int putchar (int ch); int getchar (void); unsigned char test; int main(void) { char *Ptr = "*** UART0 Demo ***\n\n\rType Characters to be echoed!!\n\n\r"; VPBDIV = 0x02; // Divide Pclk by two init_serial(); while(1) { while (*Ptr) { putchar(*Ptr++); } putchar(getchar()); // Echo terminal } } void init_serial (void) { PINSEL0 = 0x00000005; // Enable RxD0 and

TxD0 U0LCR = 0x00000083; //8 bits, no Parity, 1 Stop bit U0DLL = 0x000000C3; //9600 Baud Rate @ 30MHz VPB Clock U0LCR = 0x00000003; } int putchar (int ch) { if (ch == '\n') { while (!(U0LSR & 0x20)); U0THR = CR; }

while (!(U0LSR & 0x20)); return (U0THR = ch); } int getchar (void) { while (!(U0LSR & 0x01)); return (U0RBR);

}



Result: Thus, interfacing of GSM module with ARM CORTEX M3- LPC2148 using embedded C code was executed and verified successfully.



Ex. No. 13

INTERFACING GPS MODULE

Aim: To write an embedded C code for interfacing GSM Module with ARM

CORTEX M3-LPC2148.

Circuit Diagram:

Procedure:

Give +3.3V power supply to LPC2148 Primer Board; connect the +5V adapter with GSM module which is connected with LPC2148 Primer Board through UART0. Open the Hyper Terminal screen, select which port you are using and set the default settings. Now the screen should show some text messages.

The following Commands and sequence of events performed for sending text message to a mobile phone through GSM Modem interfaced with microcontroller: First select the text mode for SMS by sending the following AT Command to GSM Modem: AT+CMGF = 1 . This command configures the GSM modem in text mode.

Send the following AT Command for sending SMS message in text mode along with mobile number to the GSM Modem : AT+CMGS =+923005281046 . This command sends the mobile number of the recipient mobile to the GSM modem.

Send the text message string ("hello!") to the GSM Modem This is a test message from UART".



If you not reading any text from UART0, then you just check the jumper connections &

just check the serial cable is working. Otherwise you just check the code with debugging

mode in Keil. If you want to see more details about debugging just see the videos in

below link.

If you not reading any text from UART0, then you just check the jumper connections &

just check the serial cable is working. Otherwise you just check the code with debugging

mode in Keil. If you want to see more details about debugging just see the videos in

below link.

Program:

#define CR 0x0D #include <LPC21xx.H> #include <stdio.h> void getstring(unsigned char *);

int getchar (void) /* Read character from Serial Port */ void status_ok(void); void Serial_Init(void); void delay(unsigned int n); void main(void) { unsigned int cnt=0x80,m; char xx; Serial_Init(); delay(50); while(1) { printf("AT\r"); // AT COMMAND FOR INITIALING status_ok(); printf("AT+IPR=9600\r"); // AT COMMAND FOR BAUD RATE status_ok(); printf("AT+CMGR=2\r"); // Reading the message detail // at Index 1 with phone number, data and time status_ok(); delay(250); printf("ATD9790550124;\r");//AT COMMAND FOR CALL DIALING delay(250); status_ok(); delay(500); delay(500);

delay(500); delay(500); delay(500); delay(500); printf("ATH\r"); // AT COMMAND FOR CALL DISCONNECTING delay(250); status_ok(); delay(500); delay(500); printf("ATDL\r"); // AT COMMAND FOR REDIALING delay(250); status_ok(); delay(500); delay(500); printf("ATH\r"); // AT COMMAND FOR ANSWERING THE CALL delay(250); status_ok();



elay(500); delay(500); } } void getstring(unsigned char *array) { unsigned char temp=0, i=0; do { temp = getchar(); *array++ = temp; } while((temp != '\r') && (temp != '\n')) *array = '\0'; } int getchar (void) /* Read character from Serial Port */ { while (!(U0LSR & 0x01)); return (U0RBR);

} void status_ok(void) { getstring(y); while(!(strstr(y,"OK"))) getstring(y);

pointr = strstr(y,"OK"); lcd_cmd(0xc0); lcd_data(*pointr++); lcd_data(*pointr);

delay(500); lcd_cmd(0x01);

} void Serial_Init(void) { PINSEL0 |= 0X00000005; //Enable Txd0 and Rxd0 U0LCR = 0x00000083; //8-bit data, no parity, 1-stop bit U0DLL = 0x00000061; //for Baud rate=9600,DLL=82 U0LCR = 0x00000003; //DLAB = 0; } void delay(unsigned int n) { unsigned int i,j; for(i=0;i<n;i++) { for(j=0;j<12000;j++) {; } }



Result:

Thus interfacing of GSM module with ARM CORTEX M3- LPC2148 using embedded C code was executed and verified successfully

DMI COLLEGE OF ENGINEERINGdmice.ac.in/wp-content/uploads/2017/05/EC6711.pdf · 2018-12-24 · dmi...

Documents

Transcript of DMI COLLEGE OF ENGINEERINGdmice.ac.in/wp-content/uploads/2017/05/EC6711.pdf · 2018-12-24 · dmi...