embs final manual

SRINIVASAN ENGINEERING COLLEGE

DEPT OF ELECTRONICS AND COMMUNICATION ENGINEERING

ANNA UNIVERSITY TRICHY

REGULATION 2008

IV YEAR/ VII SEMESTER

EC1404 – EMBEDDED SYSSTEMS LABORATORY

LAB MANUAL

ISSUE:01 REVISION:00

APPROVED BY PREPARED BY

Prof. B. REVATHI C.SATHISH KUMAR, Assistant Professor.

HOD/ECE R.KEERTHANA, Assistant Professor.

EMBEDDED SYSTEMS LAB MANUAL SRINIVASAN ENGINEERING COLLEGE, PERAMBALUR

IV YEAR

ISSUE: 01 REVISION: 00 2

Preface

This laboratory manual is prepared by the Department of Electronics and communication

engineering for Embedded systems (EC1404). This lab manual can be used as instructional book for

students, staff and instructors to assist in performing and understanding the experiments. This

manual will be available in electronic form from College’s official website, for the betterment of

students.

Acknowledgement

We would like to express our profound gratitude and deep regards to the support offered

by the Chairman Shri. A.Srinivasan. We also take this opportunity to express a deep sense of

gratitude to our Principal Dr.B.Karthikeyan,M.E, Ph.D, for his valuable information and

guidance, which helped us in completing this task through various stages. We extend our hearty

thanks to our head of the department Prof.B.Revathi M.E, (Ph.D), for her constant

encouragement and constructive comments.

Finally the valuable comments from fellow faculty and assistance provided by the

department are highly acknowledged.


IV YEAR


INDEX

S.No TOPIC PAGE

NO

1 Syllabus 4

2 Lab Course Handout 5

3 Experiments

1. Study of ARM evaluation system 7

2. Interfacing ADC and DAC 13

3. Interfacing Keyboard and LCD 15

4. Interfacing EEPROM and Interrupt 22

5. Interfacing Read toggle switch and Relay 27

6. Interfacing LED and PWM 29

7. Interfacing Seven segment LED 33

8. Interfacing Real time clock and Serial port 37

9. Interfacing Stepper motor and Temparature sensor 42

10. Flashing two LEDs 48

11. Reading LM35 and plotting in LCD. 51

12. Two messages on LCD. 54

13. Serial port 57

14. Mail box 61

15. Design and implementation of Traffic light controller in FPGA

65

16. Design and implementation of 4 bit Updown counter in FPGA

72

17. Interrupt processing performance characterstics of ARM& FPGA

77

18. Hardware and software partioning between FPGA and ARM

80

19. Implementation of Zigbee protocol with ARM 7

86


IV YEAR


SYLLABUS

EC 1404 – EMBEDDED SYSTEMS LABORATORY

LIST OF EXPERIMENTS

• Open source software such as linux flavors will be used. Ability to use industry

standard tools for verification and validation

• High level language programming (C, C++) and porting it on a processor

• Create FSM of a typical application and implement on an FPGA

• Application development, download partition between FPGA and ARM on

performance characteristics

• Application development. Hardware and software partitioning

• Projects (implementation of a wireless communication protocol on an embedded

system).

Total: 45

LIST OF EQUIPMENTS

(For a batch of 30 students)

Sl. No. Description of Equipments Quantity

1. Embedded trainer kits with ARM board 3

2. Embedded trainer kits suitable for wireless

communication 3

3. With adequate quantities of Hardware, software and consumables


IV YEAR


LAB COURSE HANDOUT

Subject code : EC 1404

Subject Title : Embedded systems Lab

Staff name : C.Sathish kumar & R.Keerthana

Scope and Objective of the Subject: To write the program and verify the output in ARM & FPGA kit.

Course Plan / Schedule:

S.No Topics to be covered Learning objectives Page No*

No. of hours

1 Study of ARM evaluation system To study of ARM evaluation kit 7 3 hrs

2 Interfacing ADC and DAC To interface ADC & DAC using

ARM evaluation kit 13 3hrs

3 Interfacing Keyboard and LCD To interface Keyboard and LCD

using ARM evaluation kit 15 3hrs

4 Interfacing EEPROM and Interrupt To interface Keyboard and LCD


5 Interfacing Read toggle switch and Relay To interface Keyboard and LCD


6 Interfacing LED and PWM To interface Keyboard and LCD


7 Interfacing Seven segment LED To interface Keyboard and LCD


8 Interfacing Real time clock and Serial port To interface Keyboard and LCD


9 Interfacing Stepper motor and Temparature

sensor

To interface Keyboard and LCD


10 Two Flashing LEDs Flashing Two LEDs in RTOS 48 3hrs

11 Reading LM35 and plotting in LCD. Reading LM35 and observe the

graph in LCD 51 3hrs

12 Two messages on LCD. To observe two messages in LCD

display 54

13 Serial port To connect serial port in ARM

evaluation and transfer the data 57 3hrs

14 Mail box To connect mail box in ARM kit

and transfer data 61 3hrs

15 Design and implementation of Traffic light

controller in FPGA

To write a program for traffic light

controller using FPGA kit 65 3hrs

16 Design and implementation of 4 bit Updown

counter in FPGA

To design and implementation of 4

Bit Updown counter in FPGA kit 72 3hrs

17 Interrupt processing performance characterstics

of ARM& FPGA

To create an interrupt and perform

the characterstics of ARM & FPGA 77 3hrs


IV YEAR


18 Hardware and software partioning between

FPGA and ARM

To make Hardware and software

portioning between ARM & FPGA 80 3hrs

19 Implementation of Zigbee protocol with ARM 7

To Implimentation of Zigbee

protocol with ARM 86

*-As in Lab Manual

Evaluation scheme – Internal Assessment

Timings for chamber consultation: Students should contact the Course Instructor in her/his

chamber during lunch break.

STUDENTS GUIDELINES

There are 3 hours allocated to a laboratory session in Embedded systems Lab. It is a necessary

part of the course at which attendance is compulsory.Here are some guidelines to help you

perform the Programs and to submit the reports:

Read all instructions carefully and proceed according to that.

1. Ask the faculty if you are unsure of any concept.

2. Write the program, and give connections.

3. Get the output from the kit.

4. After completing the experiment complete the observation and get signature from the

staff.

5. Before coming to next lab make sure that you complete the record and get sign from the

faculty.

STAFF SIGNATURE HOD

EC

No.

Evaluation

Components

Duration Weightage

1 Observation Continuous 20%

2 Record Continuous 30%

3 Attendance Continuous 30%

4 Model lab 3hr 20%


IV YEAR


STUDY OF ARM EVALUATION SYSTEM

AIM:

To study ARM evaluation system.

DESCRIPTION:

The top view NXP 2148 ARM evaluation system gives the required hardware platform to study

and apply on-chip peripheral function of the LPC 2148 microcontroller. The hardware is complete to

provide all the required interfacing facilities on board to make the task easy and motivating one.

HARDWARE DESCRIPTION:

The ARM evaluation board has following modules for studying the internal peripherals of the device.

NXP LPC2148 operating at 60 MHz

8 numbers of point LEDs.

8 numbers of toggle switches.

4 digits of seven segment multiplexed display interfaced using IIC bus.

2 lines by 16 characters LCD module.

4 X 4 keyboard matrix

On-board buzzer

IIC RTC with battery backup and IIC EEPROM.

On-board variable voltage source for ADC input.

On-board temperature sensor using LM35.

On-board stepper motor operating at 5v.

Two numbers of on-board 5v relay with LED indicators.

Serial port facility.

USB facility

128 X 64 pixels LCD

5v power supply.

MICROCONTROLLER SECTION:

The microcontroller ARM NXP 2148 operates with external crystal of 10MHz.this section

consists of the controller device, reset circuit, oscillator circuit.LPC2148 ARM controller can be operated

in four different modes namely trace, debug, program and normal mode. On-board jumpers JP1, JP2 and

JP3 are used to select the operating mode for the controller.

NORMAL OPERATION:

Disable all the three jumpers JP1, JP2 and JP3 to select normal mode operation. Controller

executes user application program present in the flash during this mode.


IV YEAR


IN SYSTEM PROGRAMMING OPERATION:

Enable jumperJP3 and disable jumpers JP1 and JP2 to select in-system programming (ISP) mode.

After selecting jumper, press reset button S1 in evaluation board once to activate ISP mode. LED D27

glows to indicate the ISP mode.

TRACE MODE:

Enable jumper JP2and disable jumpers JP1 and JP3 to select the trace mode. After selecting

jumper, press reset button once to activate trace mode.in this mode program debugging can be performed

through trace port line.

DEBUG MODE:

LPC 2148 has facility to debug the program execution through dedicated JTAG debug port.

Enable jumper JP1 and disable JP2 and JP3 jumper to select debug mode. After selecting jumper, press

reset button once to activate debug mode. Connect JTAG emulator through connecter P6 to debug

program execution in real time.

EIGHT NUMBERS OF POINT LEDs:

Eight numbers of point LEDs are interfaced to the microcontroller through the common data bus

linesDB0 toDB7. Since common data bus lines DB0 –DB7 are used for the interface, a eight-bit

latch74HC273 is used to drive the LEDs.

EIGHT NUMBERS OF TOGGLE SWITCHES:

The toggle switches are interfaced to the microcontroller through the common data bus line DB0

toDB7. Since common data bus lines DB0 –DB7 are used for the interface, a eight-bit buffer 74HC244 is

used to interface the switches with data bus.

FOUR DIGITS OF SEVEN SEGMENT MULTIPLEXER DISPLAY:

The display module consists of four number of common anode green colour displays. The

displays are connected to the IIC bus lines of the controller through a four digit LED driver with IIC

interface. IC SAA1064 is a four digit LED driver with IIC interface. The IIC channel0 of the controller is

used here.

TWO LINES BY 16 CHARACTERS LCD MODULE:

A 2 line X 16 characters LCD module is provide on the evaluation board. The data lines are

connected to the data bus DB0-DB7.

4 X 4 KEYBOARD MATRIX:

16 push button switches are provided to get a 4X 4 keyboard n matrix format. The Keyboard has

4 row and 4 colums.The rows are connected to port lines P0.15, P0.16, P0.17 and P0.18. The column


IV YEAR


lines are connected to P0.11, P0.12, P0.13 and P0.14. All the four column lines are pulled up to Vcc using

10K resistors.

BUZZER:

A buzzer is available on board and it driven by a NPN transistor. The base of the transistor is

connected to the port line P0.25. This port line is also the output of the 10 bit DAC, the on chip peripheral

of the controller. Hence the buzzer can be used to test the peripheral, DAC of the controller. A high level

to the base of the transistor switches the buzzer on.

IIC RTC WITH BATTERY BACKUP AND EEPROM:

The IIC devices IIC RAM and IIC EEPROM are provided on board to study the IIC interface.

Both the devices are connected to same two wire bus, where the seven segment LED driver (SAA1064) is

connected. IIC devices are connected to the IIC peripheral of the controller board.

ANALOG VOLTAGE SOURCE TO EXPERIMENT WITH ADC:

A variable analog voltage source is made available on the board to experiment with ADC part of

the microcontroller. The voltage source is connecting to the P0.29, which is the channel 2 of the ADC. A

potentiometer is connected to the voltage to adjust the input voltage to ADC.

TEMPERATURE SENSOR:

The LM35 is precision integrated circuit temperature sensor, whose output voltage is linearly

proportional to the Celsius temperature. Hence LM35 has advantage over other linear temperature sensors

calibrated in degree kelvin, as the user is not required to subtract a large constant voltage from its output

to obtain convenient centigrade reading.

STEPPER MOTOR:

A unipolar stepper motor is connected on-board for experimental purpose. For each winding, 2

Darlington drivers of IC ULN2803 are used as power driver. Each Darlington driver IC is capable of

sinking 500mA current. Hence two Darlington drivers are connected in parallel to increase the current

capacity to 1A

5V RELAY:

Two number of 5v relays are used in the board for experimental purpose. The relays are driven by

the NPN transistors BC547. The port lines used for the driving the relays are P0.30 and P0.10

SERIAL PORT:

The controller has two on chip serial port. The serial port 0 of the controller is used for

programming the flash of the controller. The serial port 1 is terminated separately for user.


IV YEAR


USB:

USB port lines of the microcontroller is terminated in a separate connected marked as USB1. For

programming purpose another USB connector (USB 2) is provided. This can be connected to the USB

port of the PC for programming purpose.

GRAPICS LCD:

A graphics LCD with 128X64 pixels is interfaced on the evaluation board. The data lines are

connect to the data bus DB0-DB7. The control lines RS is connect to the port line P1.25. The R/W line is

connecting to the port line P1.24. The CS line of the LCD is controlled by the decoder IC 74HC138 (U3).

The port lines used by the decoder are set to correct levels to enable the LCD. The port linesP0.19, P0.20

is set to 0 and the port line P0.22 is set to 1 level. The active level of the decoder output line CS4_GLCD

will be 0.since the LCD enable line is at active high level, an inversion of the CS4_GLCD is carried out

using a NAND gate.

RESULT:

Thus the ARM evaluation system is studied.


IV YEAR


PROGRAMMING IN EMBEDDED C AND PORTING IT ON THE PROCESSOR

PROCEDURE

1. Open Embest IDE software

2. Go to file->new workspace. a window will appear. In that window give the project

name & the location to be stored.

3. Copy the support file from the original folder to the created folder

4. Right click on project source files & click on add files to folder->select files & add it.

5. Go to file -> new -> type the program & save the program with the extension .c

6. Click project ->settings

In processor:

CPU mode: ARM 7

CPU family: ARM 7

Member: ARM 7

Build tools: GNC tools for ARM

In remote:

Remote device: SIM ARM 7

In compiler:

Category: target specific option

Click on little endian

Specify the name of the target: ARM 7TDMI

In assembler:



In linker:

Category : general

Linker script file-> browse->select flash.id


IV YEAR


Category : image entry option

Select vector.0

Category : code generation operation

Click->link little endian object

7. Then click ok

8. Click build->rebuild all

9. Click tools->elf to hex

10. Minimize the window

11. Open flash magic.

12. Click browse ->select file name.hex from your project -> open

13. Switch on the kit -> press reset button -> click start in the flash magic window

14. After download finished, switch off the kit-> press reset button.

Output will be executed in the kit.


IV YEAR


INTERFACING ADC AND DAC

AIM:

To write an embedded C program for interfacing ADC and DAC and verify the output in the

ARM kit.

HARDWARE AND SOFTWARE REQUIRED:

PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

ADC:

Step 1: Start the program

Step 2: Initialize the LCD.

Step 3: intialise the ADC.set the port line P0.29 to have the special function ADC input, using the

PINSEL1 register

Step 4: call the routine message_display1 to display message”ADC demo” on line 1 of the LCD.

Call the routine message_display2 to display message”channel2;” on line 2 of the LCD.

Step 5:a)set the control register of the ADC with the following specifications;

Channel number=2;

ADC clock=3 MHz.

Select burst mode,

Conversion clocks required =11 clocks

b) start the ADC conversion

Step 6: wait for EOC signal. Once the EOC signal is obtained read the ADC valve.

Step 7: Display the ADC value on the LCD.

Repeat from step 4.

Step8: Stop the program

DAC:


Step 2: Initialize the DAC.Set the port line P0.25 to have the special function DAC, using the

PINSEL1 register

Step 3: Set the value 0 to DAC

Call a delay

Step 4: Set the value 0xFFC0 to DAC

Call a delay.

Step 5: Repeat from step 2.

Step 6: Stop the program

PROGRAM:

ADC

#include "LPC214x.h" /* LPC21xx definitions */

int ReadADC(char ChannelNumber);

int main(void)

{

int a;

unsigned char Channel = 2;

PINSEL1 = 0x04000000; // Select ADC to pin P0.29

InitializeLCD(); // Initialize LCD

DisplayLCD(0," ADC DEMO "); // Display message

DisplayLCD(1,"Channel 2: "); // Display message

while(1)


IV YEAR


{

a=ReadADC(Channel); // Read ADC channel 2

DisplayLCD2Digit(1,10, (a >> 8)); // Display it on 2nd line of LCD

DisplayLCD2Digit(1,12, (a & 0xff));

LCDDelay1600();

}

} //Read ADC data from given channel number

int ReadADC(char ChannelNumber)

{

int val,ch;

ch = 1<<ChannelNumber;

AD0CR = 0x00210400 | ch; // Setup A/D: 10-bit AIN @ 3MHz

AD0CR |= 0x01000000; // Start A/D Conversion

do

{

val = AD0DR2; // Read A/D Data Register

}

while ((val & 0x80000000) == 0); // Wait for the conversion to

complete

val = ((val >> 6) & 0x03FF); // Extract the A/D result

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

return(val); // Return the Data Read

}

DAC

#include "LPC214X.H"

void InitializeDAC(void);

int main (void)

{ long c;

InitializeDAC(); //Initialize DAC

while(1)

{ DACR = 0x00; // Set DAC = 0

for(c=0;c<0xf0000;c++); // Delay

DACR = 0x0000ffc0; // Set DAC = (0x3ff << 6)

for(c=0;c<0xf0000;c++); // Delay

}

}

void InitializeDAC(void)

{

PINSEL1 = 0x00080000; // Set P0.25 for DAC output

}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for interfacing ADC and DAC is written and executed. The output is

verified in the ARM kit.


IV YEAR


INTERFACING KEYBOARD AND LCD

AIM:

To write an embedded C program for interfacing keyboard and LCD and to verify the output in

the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

KEYBOARD:


Step 2:a)Initialize the IO lines

b) Initialize LCD

Step 3: Display the messages on both lines of LCD

Step 4: Initialize keyboard lines

a) Set P0.11 to P0.14 as input lines

b) Set P0.15 to P0.18 as output lines

Step 5: Initialize timer 0 to generate interrupt for every millisecond

Step 6: Check the keyboard flag for 1 level. Read the key from the keyboard code. Clear the

Keyboard flag variable.

Step 7: Display the pressed key valve on the 2 line of the LCD using display byte routine.

Repeat from step 5

Step 8: Stop the program.

LCD:


Step 2: Initialize the IO port lines

Step 3: a) IntializeP0.19 (A0), P0.20 (A1), P0.22 (A2) as output port.

b) Initialize data lines P.16 (DB0) to P1.23 (DB7) as output lines

c) Initialize the control lines of LCD, P1.24(R/W) and P 1.25(RS) as output lines.

Step 4: initialize LCD

Step 5:a)send command 0x80 to display string on line 1 of LCD.

b) Send character one by one until all 16 characters are displayed.

Step 6:a)send command 0xC0 to display string on line 2 of LCD.

b) Send character one by one until all 16 characters are displayed.

c)halt

Step 7:Stop the program.

PROGRAM:

KEYBOARD

#include "LPC214x.H" // LPC214x definitions

extern void irq_T0(void); // Interrupt process

void T0_Srv(void);

void InitializeTIMER0(void);

void InitializeKeyboard(void);

void ScanKeyboard(void);

unsigned char ReadColumn(void);

void SetRow(unsigned char dat);


IV YEAR


void DisplayLCD(char LineNumber,char *Message);

char KeyboardFlag;

unsigned char KeyboardCode=0;

char Counter=0,ReleaseFlag=0,StatusFlag=0,IdentificationFlag=0;

int main(void)

{

KeyboardFlag =0; //Clear keyboard flag

InitializeLCD();

IODIR0 |= 0x00078000; //Initialize Port lines for keyboard

InitializeTIMER0(); //Initialize TIMER0, Keyboard scan timer

DisplayLCD(0,"Matrix Keyboard ");

DisplayLCD(1,"Key Pressed: ");

while(1)

{

if(KeyboardFlag ==1) //wait for key press

{ DisplayLCD2Digit(1,12,KeyboardCode);

KeyboardFlag=0; //reset keyboard flag

}

}

}

//Scan keyboard

void ScanKeyboard(void)

{

unsigned char a,b,c;

unsigned char f;

if(ReleaseFlag == 1)

{ //debounce time for release

Counter++;

if(Counter ==10)

{ ReleaseFlag = 0;

}

return;

}

if(StatusFlag ==1)

{

if(IdentificationFlag == 1)

{ //Wait for key Release

SetRow(0x00);

if(ReadColumn() == 0x0f) //Check the keyboard status

{ //No key pressed

Counter = 0;

ReleaseFlag = 1;

IdentificationFlag = 0;

StatusFlag = 0;

} return;

}else

{

Counter++;

if(Counter == 10)

{ //Check key press


IV YEAR


KeyboardCode = 0;

SetRow(0x00); //Set all rows to 0

if(ReadColumn() != 0x0f) //Read column levels

{ //any one key pressed

for(a=0;a<4;a++)

{ //Row Setting

f = ~(0x01 << a); //set one row to 0

SetRow(f);

b = ReadColumn(); //read column levels

for(c=0;c<4;c++)

{ //Column checking

f = 0x01 << c;

if(( b & f) == 0)

{ //Pressed Key identified


StatusFlag = 1;

KeyboardFlag=1;

KeyboardCode &= 0x0f;

return;

}

KeyboardCode++;

}

}

}


StatusFlag = 0;

return;

}

else

{

return;

}

}

}

SetRow(0x00);

if(ReadColumn() != 0x0f) //Check for any key press

{ // key press detected

Counter=0;

StatusFlag=1;

IdentificationFlag=0;

}

}

/* Sets the given data to Row */

void SetRow(unsigned char dat)

{

if(dat & 0x01)

IOSET0 = 0x00008000;

else

IOCLR0 = 0x00008000;

if(dat & 0x02)


IV YEAR


IOSET0 = 0x00010000;

else

IOCLR0 = 0x00010000;

if(dat & 0x04)

IOSET0 = 0x00020000;

else

IOCLR0 = 0x00020000;

if(dat & 0x08)

IOSET0 = 0x00040000;

else

IOCLR0 = 0x00040000;

}

/* Reads the Column status and returns the same */

unsigned char ReadColumn(void)

{

unsigned char a=0;

a = (IOPIN0>>11) & 0x0f;

return(a);

}

//Initialise timer0 used in keyboard scanning

void InitializeTIMER0(void)

{ //for 1msec delay

VPBDIV = 0x00000002; //Configure the VPB divider

//CCLK/2 = PCLK = 30MHz

T0PR = 0x0000012B; //Load prescaler = 300, 30MHz/300=100KHz

T0TCR = 0x00000002; //Reset counter and prescaler

T0MCR = 0x00000003; //On match reset the counter and

generate an interrupt

T0MR0 = 0x00000064; //Set the cycle time, 100KHZ/100 = 1KHZ =

1ms

T0TCR = 0x00000001; //enable timer

VICVectAddr4 = (unsigned long)irq_T0;//Set the timer ISR vector address

VICVectCntl4 = 0x00000024; //Set channel

VICIntEnable |= 0x00000010; //Enable the interrupt

}

/* Timer0 interrupt service routine */

void T0_Srv(void)

{

ScanKeyboard(); //Check and update keyboard

status

T0IR |= 0x00000001; //Clear match 0 interrupt

VICVectAddr = 0x00000000; //Dummy write to signal end of interrupt

}

LCD

#include "LPC214x.h" /* LPC214x definitions */

void WriteCommandLCD(unsigned char CommandByte);

void WriteDataLCD(unsigned char DataByte);

void LCDDelay(void);

void LCDDelay1600(void);


IV YEAR


void SendByte(unsigned char Value);

void InitializeLCD();

void DataAddressDirection(void);


void DisplayLCD2Digit(char LineNumber,char CharPosition,char Data);

int main(void)

{

InitializeLCD(); //Initialize graphics LCD

DisplayLCD(0," NXP2148 ARM ");

DisplayLCD(1,"Evaluatin System");

while(1);

}

/* Initializes LCD */

void InitializeLCD()

{

DataAddressDirection();

IOSET0 = 0x00580000; // Set A0, A1, A2

WriteCommandLCD(0x38); //Command to select 8 bit interface

LCDDelay1600();


LCDDelay(); //Small delay


LCDDelay();

WriteCommandLCD(0x0c); //Command to on cursor,blink cursor

LCDDelay();

WriteCommandLCD(0x06); //Command for setting entry mode

LCDDelay();

WriteCommandLCD(0x01); //Clear LCD

LCDDelay1600();

}

/* Writes a command byte to LCD */

void WriteCommandLCD(unsigned char CommandByte)

{

IOCLR1 = 0x03000000; // Clear RS and RW

SendByte(CommandByte);


}

/* Send a byte of data to LCD */

void SendByte(unsigned char Value)

{

IOPIN1 &= 0xff00ffff;

IOPIN1 |= Value << 16; /* Write data to data bus */

IOSET0 = 0x00100000; /* Generate chip enable signal for LCD */

IOCLR0 = 0x00480000;

LCDDelay();

IOSET0 = 0x00580000; /* Set A0, A1 & A2 to disable LCD */

LCDDelay();

}

/* Writes a Data byte to LCD */

void WriteDataLCD(unsigned char DataByte)


IV YEAR


{

IOCLR1 = 0x01000000; /* clear RW */

IOSET1 = 0x02000000; /* Set RS */

SendByte(DataByte);


}

/* Small delay */

void LCDDelay(void)

{

int a;

for(a=0;a<0x1000;a++);

}

/* Big delay */

void LCDDelay1600(void)

{

long a;

for(a=0;a<0x050000;a++);

}

/* Makes cursor visible */

void CursorON(void)

{

WriteCommandLCD(0x0f); //Command to switch on cursor

}

/* Makes cursor invisible */

void CursorOFF(void)

{

WriteCommandLCD(0x0c); //Command to switch off cursor

}

void DisplayLCD2Digit(char LineNumber,char CharPosition,char Data)

{

unsigned char a;

if(LineNumber ==0)

{ //First Line

a = 0x80; //command for first line selection

}

else

{ //Second line

a = 0xc0; //command for second line selection

}

a+=(CharPosition); //Calculate the character position

WriteCommandLCD(a); //Send command to select the given digit

if( (Data & 0xf0) < 0xa0) //Check for less than 0xa0

{

a = ((Data & 0xf0) >> 4) + '0'; //Get the ASCII character

}

else

{

a = ((Data & 0xf0) >> 4) + 'A'- 0x0a;


IV YEAR


//Get the ASCII

character

}

WriteDataLCD(a); //Display the first character

if( (Data & 0x0f) < 0x0a) //Check for less tham 0x0a

{

a = (Data & 0x0f)+'0'; //Get the ASCII character

}

else

{

a = (Data & 0x0f)+'A' - 0x0a; //Get the ASCII character

}

WriteDataLCD(a);

}

/* Displays a message on LCD */

void DisplayLCD(char LineNumber,char *Message)

{

int a;

if(LineNumber ==0)

{ //First Line

WriteCommandLCD(0x80); //Select the first line

}

else

{ //Second line

WriteCommandLCD(0xc0); //Select the second line

}

while(*Message)

{

WriteDataLCD(*Message); //Display a character

Message++; //Increment pointer

}

}

void DataAddressDirection(void)

{

IODIR0 |= 0x00580000; // Set A0, A1, A2 output lines

IODIR1 |= 0x03ff0000;

}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for for interfacing keyboard and LCD is written and executed. The

output is verified in the ARM kit.


IV YEAR


INTERFACING EEPROM AND INTERRUPT

AIM:

To write an embedded C program for interfacing EEPROM and interrupt and to verify the

output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

EEPROM:


Step 2: Initialize the LCD

Step 3: Initialize IIC interface

Step 4:a)Set the address location of EEPROM as 0x00

b) Set the data as 0x12

c) Call routine to write byte to EEPROM.

d) Call the delay

Step 5:a)Set the address as 0x00 for reading from EEPROM

b) Call routine to read from EEPROM

Step 6:a)Display the address

b) Halt


INTERRUPT:


Step 2: a) Initialize the IO lines

b) Initialize an eight bit counter to 0.

Step 3: a) Allocate vector interrupt controller slot 0 for EINT0 by programming VICVectCntIO

Register with 0x2e.

b) Allocate vector interrupt controller slot 1 for EINT2 by programming VICVectCntI1

Register with 0x30.

c) VICVectAddr0 register is initialized with address of the interrupt service routine for

EINT0

d) ) VICVectAddr1 register is initialized with address of the interrupt service routine for

EINT2

e) Slot 1 and slot 0 are enabled by writing VICIntEnable register with valve 0x00014000.



IV YEAR


PROGRAM:

EEPROM

#include "LPC214x.h" // LPC21xx definitions

extern void irq_iic(void); // interrupt process

void Iic_Srv(void);

void InitializeIIC(void);

void I2CTransferByte(unsigned int I2CAddr,unsigned char MemAddr,unsigned char count,unsigned

char *data); //Background call to start master send and receive byte transfers

void WriteByte(int addr,unsigned char *data);

void ReadByte(int addr,unsigned char *data);

void delay2(void);

unsigned char *I2CData,

I2Counter,

I2CAddress,

MemAddress,

lock;

int main(void)

{

unsigned char Data=0, Address;


InitializeIIC(); // Initialize IIC Interface

DisplayLCD(0," EEPROM DEMO "); // Display message

DisplayLCD(1,"ADDR: Data: ");

Data = 0x12;

Address = 0x00;

WriteByte(Address,&Data); // Write Data to EEPROM

Data = 0;

ReadByte(Address,&Data); // Read Data from EEPROM

DisplayLCD2Digit(1,5,Address); // Display

DisplayLCD2Digit(1,14,Data);

while(1);

}

void InitializeIIC(void)

{

lock = 0; //Initilise the lock flag

VICVectCntl1 = 0x00000029; //select a priority slot for a given

interrupt

VICVectAddr1 = (unsigned long)irq_iic; //pass the address of the IRQ into the

VIC slot

VICIntEnable = 0x00000200; //enable interrupt

PINSEL0 |= 0x50; //Switch GPIO to I2C pins

I2C0SCLH = 0x104;

I2C0SCLL = 0x104;

}

//Write given data in EEPROM, address(10bit) specified by addr

void WriteByte(int addr,unsigned char *data)

{

I2CTransferByte(0xAc,addr,1,&data[0]); //write data to the I2C Memory

while(lock==1);

delay2();


IV YEAR


}

//Read data from EEPROM,addr-10bit EEPROM address

void ReadByte(int addr,unsigned char *data)

{

I2CTransferByte(0xAc,addr,0,&data[0]); //set address to addr

I2CTransferByte(0xAd,addr,1,&data[0]); //read data from the I2C Memory

while(lock==1);

}


char *data )

{

while(lock == 1) //Wait for interrupt to signal end of I2C

activity

{

;

}

lock = 1; //Set I2C bus as active

//Place address and data in Globals to be used by the interrupt

I2CAddress = I2CAddr;

I2CData = data;

I2Counter = count;

MemAddress = MemAddr;

I2C0CONCLR = 0x000000FF; //Clear all I2C settings

I2C0CONSET = 0x00000040; //Enable the I2C interface

I2C0CONSET = 0x00000020; //Start condition

}

void Iic_Srv(void) //I2C interrupt routine

{

switch (I2C0STAT) //Read result code and switch to next

action

{

// Start and Send byte conditions

case ( 0x08): //Start bit

I2C0CONCLR = 0x20; //Clear start bit

I2C0DAT = I2CAddress; //Send address and write bit

break;

case (0x18): //Slave address+W, ACK

I2C0DAT = MemAddress; //Write Memory start address to tx register

break;

case (0x20): //Salve address +W, Not ACK

I2C0DAT = I2CAddress; //Resend address and write bi

break;

case (0x28):

if(I2Counter > 0) //Data sent, Ack

{

I2Counter--;

I2C0DAT = *I2CData; //Write data to tx register

I2CData++;

}


IV YEAR


else

{

I2C0CONSET = 0x10; //Stop condition

lock = 0; //Signal end of I2C activity

}

break;

case (0x30) : //Data sent, NOT Ack


break; //Receive byte conditions

case (0x40) : //Slave Address +R, ACK

I2C0CONSET = 0x04; //Enable ACK for data byte

break;

case (0x48) : //Slave Address +R, Not Ack

I2C0CONSET = 0x20; //Resend Start condition

break;

case (0x50) : //Data Received, ACK

if(--I2Counter>0)

{

*I2CData = I2C0DAT;

I2CData++;

}

else

{

*I2CData = I2C0DAT;



}

break;

case (0x58): //Data Received, Not Ack

I2C0CONSET = 0x20; // Resend Start condition

break;

default :

break;

}

I2C0CONCLR = 0x08; //Clear I2C interrupt flag

VICVectAddr = 0x00000000; //Clear interrupt in

} //Small delay

void delay2(void)

{

long int i;

i=0xffff;

while(i)

{

i--;

}

}

INTERRUPT

#include "LPC214x.H" /* LPC214x definitions */

extern void irq_INT0(void); //interrupt process

extern void irq_INT2(void); //interrupt process


IV YEAR


void INT0_Srv(void);


void InitializeInterrupt(void);

unsigned char Counter=0;

int main(void)

{

IODIR0 |= 0x00780000; // Direction setting for Address lines A0, A1 and A2

IODIR1 |= 0x00ff0000; // Direction setting for Data lines D0 to D7

IOCLR0 = 0x00780000; // Clear A0, A1, A2

InitializeInterrupt(); // Initialize interrupts

while(1);

} //Initialize Interrupt

void InitializeInterrupt(void)

{

PINSEL0 = 0x0000C00C;

EXTMODE = 0x05; // edge select enabled for interrupts EINT0 and EINT2

VICVectAddr1 = (unsigned long)irq_INT2; // Set the Interrupt0 ISR vector address


VICVectCntl0 = 0x0000002e; // Set channel 0 to EINT0

VICVectCntl1 = 0x00000030; // Set channel 1 to EINT2

VICIntEnable = 0x00014000; // Enable interrupts EINT0 and EINT2

}

/* Interrupt1 service routine */

void INT0_Srv(void)

{

Counter++; // Increment Counter

IOCLR1 = 0x00ff0000; // Set data lines to 0

IOSET1 = Counter << 16; // Set values for LEDs in data lines D0 to D7

IOCLR0 = 0x00400000; // Clear A3

IOSET0 = 0x00400000; // Set A3

EXTINT |=0x01;


}/* Interrupt2 service routine */

void INT2_Srv(void)

{

Counter--; // Decrement Counter

IOCLR1 = 0x00ff0000; // Set data lines to 0

IOSET1 = Counter << 16; // Set values for LEDs in data lines D0 to D7

IOCLR0 = 0x00400000; // Clear A3

IOSET0 = 0x00400000; // Set A3

EXTINT |=0x04;


}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for interfacing EEPROM and interrupt is written and executed. The



IV YEAR


INTERFACING READ TOGGLE SWITCH AND RELAY

AIM:

To write an embedded C program for interfacing read toggle switch and relay and to verify the

output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

READ TOGGLE SWITHES:


Step 2: Initialize IO port lines.

Step 3: Initialize P0.19 (A0), P0.20 (A1), and P0.22 (A2) as output port. These three lines are the

Control lines to the decoder, used to generate the chip enable signal for the point LEDs in

The toggle switches. These lines are called as address lines.

Step 4:a) Initialize data lines P1.16(DB0)to P1.23(DB7) as input lines.

b) Set the address lines as A1=0,A2=0 and toggle the address line A0 from 0 to1,to enable

The buffer connected to the switches.

c) Read the data from the data bus.

Step 5: a) Initialize the data lines P1.16(DB0) toP1.23(dDB7) as output lines

b) Write the data read from the switches to the data bus for LEDs.

c) Set the addresses lines as A0=0, A1=0 and A2=0 to enable the latch connect to the

LEDs


Step 7: stop the program.

RELAY:


Step 2: initialize IO lines required for the relays

Step 3: Intilize P0.30 (relay 1) and P0.10 (relay20) as output lines.

Step 4: Send 1 level to P0.30 and 0 level to P0.10. Call a small delay.

Step 5: Send 0 level to P0.30 and 1 level to P0.10. Call a small delay.

Repeat from step 3

Step 6:Stop the program.

PROGRAM:

READ TOGGLE SWITCH


void InitializeIO(void);

int main (void)

{

unsigned char b;

InitializeIO(); //Initialize the I/O lines

while(1)

{

IOCLR0 = 0x00580000; // Address Lines A0,A1,A2 set as 0

IOSET0 = 0x00080000; // Set A0 to generate chip enable for toggle switches


IV YEAR


IODIR1 &= 0xFF00FFFF; // Set the data lines to input

b = IOPIN1 >> 16; // Read from toggle switches

IODIR1 |= 0x00FF0000; // Set the data lines to output

IOPIN1 = b << 16; // Display the data on LEDs

IOCLR0 = 0x00580000; // A0 - A2 set as 0

}

}

void InitializeIO(void)

{

IODIR0 = 0x00580000;

IODIR1 = 0x00ff0000;

}

void __gccmain()

{

}

RELAY



int main (void)

{

long a;

IODIR0 = 0X40000400; //Set P0.30 and P0.10 lines as

ouput lines

while(1)

{

IOCLR0 = 0x00000400; // Clear P0.10

IOSET0 = 0x40000000; // Set P0.30 - switch on relay

for(a=0;a<0xF0000;a++); // Delay

IOCLR0 = 0x40000000; // Clear P0.30

IOSET0 = 0x00000400; // Set P0.10 - switch on relay

for(a=0;a<0xF0000;a++); // Delay

}

}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for interfacing read toggle switch and relay is written and executed.

The output is verified in the ARM kit.


IV YEAR


INTERFACING LED AND PWM

AIM:

To write an embedded C program for interfacing LED and PWM and to verify the output in the

ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

LED

Step 1: Start the program.

Step 2: Enable IO port. Initialize timer 0.

Step 3: a) Initialize P0.19 (A0), P0.20 (A1), P0.22 (A2) as output port. These three lines are the

Control lines to the decoder, use to the generate the chip enable signal for the

LEDs.These line are called as address lines

b) Initialize the data lines P1.16 (DB0) toP1.23 (DB7) as output lines.

Step 4:a) Place the data for the LEDs in the data busDB0 to DB7.Set data to switch on one LED

b) Clear all address lines as A0, A1 and A2. Then set all address lines back to 1 to enable

The latch connected to the LEDs

Step 5: Call a delay.

Step 6:a) Rotate the data for a LEDs to switch on next LED.

b) Repeat from step 2


PWM


Step 2: a) Initialize LCD.

b) Display a message on the LCD

Step 3: Initialize PWM. Initialize a variable Var to 900. Set the direction to port lines P0.01 and

P0.07 TO 0in the direction register IODIR0.tjis makes both the port lines as input lines.

Step 4: Check for 0 level in P0.01 lines where a push button switch is connected.

Step 5: Check for 0 level in P0.07 lines where a push button switch is connected.


PROGRAM:

LED FLASHING



void InitializeTIMER0(void);

void T0_Srv(void);

void Delay(void);

extern void irq_T0(void);

unsigned int Count;

int main (void)

{


IV YEAR


long a;

unsigned char b;

InitializeIO(); // Initialize the I/O lines

InitializeTIMER0(); // Initialize Timer 0

while(1)

{

//Sequentially switches from 1st LED to 8th LED with a periodic interval

for(b=0;b<8;b++)

{

IOCLR1 = 0x00ff0000; // Clear all LED lines

IOSET1 = (0x01 << b) << 16; // Switch on any one the line

IOCLR0 = 0x00580000; // Clear A0,A1 and A2

IOSET0 = 0x00580000; // Set A0,A1 and A2

Delay(); // Delay

}

//Sequentially switches from 8th LED to 1st LED with a periodic interval

for(b=0;b<8;b++)

{

IOCLR1 = 0x00ff0000; // Clear all LED lines

IOSET1 = (0x80 >> b) << 16; // Switch on any one the line

IOCLR0 = 0x00580000; // Clear A0,A1 and A2

IOSET0 = 0x00580000; // Set A0,A1 and A2

Delay(); // Delay

}

}

}


{

IODIR0 = 0x00580000;


}

//Initialise timer0 used in LED Flashing

void InitializeTIMER0(void)

{ //for 1msec delay

VPBDIV = 0x00000002; //Configure the VPB divider

//CCLK/2 = PCLK = 30MHz

T0PR = 0x0000012B; //Load prescaler = 300, 30MHz/300=100KHz

T0TCR = 0x00000002; //Reset counter and prescaler

T0MCR = 0x00000003; //On match reset the counter and

generate an interrupt

T0MR0 = 0x00000064; //Set the cycle time, 100KHZ/100 = 1KHZ =

1ms

T0TCR = 0x00000001; //enable timer

VICVectAddr4 = (unsigned long)irq_T0; //Set the timer ISR vector address

VICVectCntl4 = 0x00000024; //Set channel

VICIntEnable |= 0x00000010; //Enable the interrupt

Count =0;

}

/* Timer0 interrupt service routine */

void T0_Srv(void)


IV YEAR


{

Count++; //Counter is incremeted

T0IR |= 0x00000001; //Clear match 0 interrupt


}

void Delay(void)

{

Count = 0;

while(Count < 1000);

}

void __gccmain()

{

}

PWM


#include "string.h"

void InitializePWM(void);

void DisplayPWMData(int dat);


void InitializeLCD();

void ConvertHextoBCD(unsigned int a);

int main (void)

{

int val=900;


DisplayLCD(0," PWM Testing "); // Display Message

DisplayLCD(1,"PWM Data:0900 ");

InitializePWM(); // Initialize PWM

IODIR0 &= 0xffffff7d;

while (1)

{

if((IOPIN0 & 0x02) == 0)

{ // Increment switch pressed

if((IOPIN0 & 0x02) == 0)

{

if(val > 50)

val -= 50; // Decrement PWM value

ConvertHextoBCD(val);

PWMMR4 = val; // Set value to PWM 4 register

PWMMR5 = 950; // Set value for PWM 5 register

PWMLER = 0x30; // Latch the value

PWMTCR = 0x00000002; // Reset counter and prescaler

PWMTCR = 0x00000009; }

while((IOPIN0 & 0x02) == 0);

}

if((IOPIN0 & 0x80) == 0)

{ // Decrement

if((IOPIN0 & 0x80) == 0)


IV YEAR


{

if(val <900)

val += 50;

ConvertHextoBCD(val);

PWMMR4 = val; // Set value to PWM 4 register

PWMMR5 = 950; // Set value for PWM 5 register

PWMLER = 0x30; // Latch the value


PWMTCR = 0x00000009;

}

while((IOPIN0 & 0x80) == 0);

}

}

}

void InitializePWM (void)

{

PINSEL1 = 0x00000400; // Enable P0.21 - PWM5

PWMPR = 0x00000000; // Load prescaler

PWMPCR = 0x00002020; // PWM channel 5 output enabled, double edge control

PWMMCR = 0x00010000; // On match with timer reset the counter

PWMMR0 = 1000; // set cycle rate to sixteen ticks

PWMMR4 = 900;

PWMMR5 = 950;

PWMLER = 0x30; // enable shadow latch for match 5


PWMTCR = 0x00000009; // enable counter and PWM, release counter from reset

}

void ConvertHextoBCD(unsigned int a)

{

unsigned char t[20]="PWM Data:0000";

t[9] = '0';

t[10] = a/100 + '0';

a -= (a/100) * 100;

t[11] = a/10 + '0';

t[12] = a%10 + '0';

DisplayLCD(1,t);

}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for interfacing LED and PWM is written and executed. The output is

verified in the ARM kit.


IV YEAR


INTERFACING SEVEN SEGMENT LED

AIM:

To write an embedded C program for interfacing seven segment LED and verify the output in the

ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

SEVEN SEGMENT LED:


Step 2: Initialize IIC interface

Step 3: Send the instruction byte 0X00 to the IIC device.

Step 4: Send the instruction byte 0X01 to indicate that next byte is segment data for digit 1.





PROGRAM:

7 SEGMENT LED #include "LPC214x.h" // LPC21xx definitions


void Iic_Srv(void);






void delay2(void);


I2Counter,

I2CAddress,

MemAddress,

lock;

int main(void)

{

unsigned char Data=0;


Data = 0x47; // Control byte, adds 12ma to segment current, dynamic mode, digits not blanked

WriteByte(0x00,&Data); // Read Hours from RTC

Data = 0x06; // Segment data for displaying data 1

WriteByte(0x01,&Data); // Display in Digit 1

Data = 0x5b; // Segment data for displaying data 2


IV YEAR



Data = 0x4f; // Segment data for displaying data 3


Data = 0x66; // Segment data for displaying data 4


while(1);

}


{


VICVectCntl1 = 0x00000029; //select a priority slot for a given interrupt

VICVectAddr1 = (unsigned long)irq_iic; //pass the address of the IRQ into the VIC slot



I2C0SCLH = 0x104;

I2C0SCLL = 0x104;

}

//Write given data in EEPROM, address(10bit) specified by addr


{

I2CTransferByte(0x70,addr,1,&data[0]); //write data to the I2C Memory

while(lock==1);

}

//Read data from EEPROM,addr-10bit EEPROM address


{

I2CTransferByte(0x70,addr,0,&data[0]); //set address to addr

I2CTransferByte(0x71,addr,1,&data[0]); //read data from the I2C Memory

while(lock==1);

}


char *data )

{

while(lock == 1) //Wait for interrupt to signal end of I2C

activity

{

;

}




I2CData = data;

I2Counter = count;





}


{


IV YEAR


switch (I2C0STAT) //Read result code and switch to next

action

{





break;



break;



break;

case (0x28):

if(I2Counter > 0) //Data sent, Ack

{

I2Counter--;


I2CData++;

}

else

{



}

break;



break; //Receive byte conditions



break;



break;


if(--I2Counter>0)

{

*I2CData = I2C0DAT;

I2CData++;

}

else

{

*I2CData = I2C0DAT;



}

break;


IV YEAR




break;

default :

break;

}



}

void __gccmain()

{

}

RESULT: Thus the Embedded C program for interfacing seven segment LED is written and executed. The



IV YEAR


INTERFACING REAL TIME CLOCK AND SERIAL PORT

AIM:

To write an embedded C program for interfacing real time clock and serial port and to verify

the output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

REAL TIME CLOCK:

Step 1: Star t the program.

Step 2: Initialize LCD.

Step 3: Initialize IIC interface.

Step 4: Set the address location of RTC as 0X04.



Step 7: Display the read data hours, minutes and seconds on the second line of the LCD.

Repeat from step3.


SERIAL PORT:

Step 1: Star t the program

Step 2:a) Initialize Io lines.

b) Initialize the serial port.

Step 3: Send an initial message through serial port to PC.

Step 4: a) Initialize LCD.

b) Display messages on both lines of LCD.

Step 5: Initialize keyboard lines.

Step 6: Initialize timer 0 to generate interrupt for every millisecond. the keyboard is scanned for

Key press in the timer 0interrupt routine

Step 7: Check for a character from a serial port receiver buffer. Also check for a key press.



PROGRAM:

REAL TIME CLOCK

#include "LPC214x.h" // LPC21xx definitions


void Iic_Srv(void);






extern void delay2(void);


I2Counter,

I2CAddress,


IV YEAR


MemAddress,

lock;

int main(void)

{

int a;

unsigned char Hour=0,Min=0,Sec=0;



DisplayLCD(0," RTC DEMO "); // Display message

DisplayLCD(1," : : ");

while(1)

{

ReadByte(0x04,&Hour); // Read Hours from

RTC

ReadByte(0x03,&Min); // Read Minutes from RTC

ReadByte(0x02,&Sec); // Read Seconds from RTC

DisplayLCD2Digit(1,4,Hour); // Display

DisplayLCD2Digit(1,7,Min);

DisplayLCD2Digit(1,10,Sec);

}

}


{


VICVectCntl1 = 0x00000029; //select a priority slot for a given interrupt

VICVectAddr1 = (unsigned long)irq_iic; //pass the address of the IRQ into the VIC slot



I2C0SCLH = 0x104;

I2C0SCLL = 0x104;

}

//Write given data in RTC


{

I2CTransferByte(0xA0,addr,1,&data[0]); //write data to the I2C Memory

while(lock==1);

}

//Read data from RTC


{

I2CTransferByte(0xA0,addr,0,&data[0]); //set address to addr

I2CTransferByte(0xA1,addr,1,&data[0]); //read data from the I2C Memory

while(lock==1);

}


char *data )

{

while(lock == 1) //Wait for interrupt to signal end of I2C activity

{

;


IV YEAR


}




I2CData = data;

I2Counter = count;





}


{

switch (I2C0STAT) //Read result code and

switch to next action

{





break;



break;



break;

case (0x28):

if(I2Counter-->0) //Data sent, Ack

{


I2CData++;

}

else

{



}

break;



break;

//Receive byte conditions



break;



break;



IV YEAR


if(--I2Counter>0)

{

*I2CData = I2C0DAT;

I2CData++;

}

else

{

*I2CData = I2C0DAT;



}

break;



break;

default :

break;

}



}

SERIAL PORT #include "LPC214x.H" // LPC214x definitions

void InitializeSerialPort(void);

void SendMessage(char *Message);

void SendByteSerially(unsigned char a);

unsigned char ReadByteSerially(void);

extern char KeyboardFlag;

extern unsigned char KeyboardCode;

int main(void)

{

unsigned char a;

InitializeSerialPort(); //Initialize Serial port

SendMessage("NXP LPC 2148 ARM Evaluation System\r\n"); //Send message though serial port

SendMessage("Message at baud 9600.\r\n\r\n");

IODIR0 |= 0x00078000; //Initialize Port lines for keyboard

KeyboardFlag =0; //Clear keyboard flag

InitializeLCD();

DisplayLCD(0,"Serial Port Test ");

DisplayLCD(1,"Received Char: ");

InitializeTIMER0(); //Initialize TIMER0, Keyboard scan timer

while(1)

{

a = ReadByteSerially(); // Read a Serial port

DisplayCharacter(1,14,a); // Display the Character

}

}// Sends Message

void SendMessage(char *Message)

{


IV YEAR


do

{

SendByteSerially(*Message); //Send a byte of data through serial port

Message++; //Increment pointer

}

while(*Message != 0);

} // Sends Byte

void SendByteSerially(unsigned char a)

{

while (!(U1LSR & 0x20));

U1THR = a;

}// Reads Byte

unsigned char ReadByteSerially(void)

{

while (!(U1LSR & 0x01))

{

if(KeyboardFlag ==1) // Wait for key press

{

if(KeyboardCode < 0x0a)

{

KeyboardCode += 0x30;

}

else

{

KeyboardCode += 0x37;

}

SendByteSerially(KeyboardCode);

KeyboardFlag=0; // Reset keyboard flag

}

}

return (U1RBR);

}// Serial Port Initialization

void InitializeSerialPort(void)

{

PINSEL0 = 0x00050000; // P0.8 to P0.9 Pin function select

U1LCR = 0x83; // 8 bits, no Parity, 1 Stop bit

U1DLL = 97; // 9600 Baud Rate @ 15MHz VPB Clock

U1LCR = 0x03; // DLAB = 0

}

void __gccmain()

{

}

RESULT:

Thus the Embedded C program for interfacing Real time clock and serial port is written and

executed. The output is verified in the ARM kit.


IV YEAR


INTERFACING STEPPER MOTOR AND TEMPARATURE SENSOR

AIM:

To write an embedded C program for interfacing stepper motor and temperature sensor and to

verify the output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:

STEPPER MOTOR


Step 2: Initialize IO port lines.

Step 3: Initialize P0.19 (A0), P0.20 (A1), and P0.22 (A2) as output port. These three lines are the

Control lines to the decoder, used to generate the chip enable signal for the stepper motor.

These lines are called as address lines.

b) Initialize data lines P1.16 (DB0) to P1.23 (DB7) as output lines.

c) Set the address lines as A0=1, A1=1 and clear the address line A2.

Step 4: Initialize counter 1 to100.

Step 5:a) Initialize a counter to 4.

b) Place a data 0X6666 in the data bus.

Step 6:a)toggle the address line A0 from 0 to 1,to enable the latch connected to the stepper motor

Driver.

b) Call a delay.

Step7:a)shift left the data 0x6666 once

b) Decrement the counter by 1.

c) Repeat from step 5 until the counter becomes 0.

Step 8:a) Decrement the counter1 by 1.

b) This makes the motor rotate in clockwise direction for few seconds.

c) Repeat from step 4 until the counter1 becomes 0.

Step9: Initialize counter 1 to100.

Step 10:a) Initialize a counter to 4.

b) Place a data 0X6666 in the data bus.

Step 11:a) toggle the address line A0 from 0 to 1,to enable the latch connected to the stepper

Motor Driver.

b) Call a delay.

Step12:a)shift right the data 0x6666 once

b) Decrement the counter by 1.

c) Repeat from step 10 until the counter becomes 0.

Step 13:a) Decrement the counter1 by 1.

b) This makes the motor rotate in counter clockwise direction for few seconds.

c) Repeat from step 9 until the counter1 becomes 0.

Step 14: Repeat from step 3

Step 15: stop the program


IV YEAR


TEMPARATURE SENSOR


Step 2: initialize LCD

Step 3: initialize ADC. Set the port lines AD0.1to has a special function using the PINSEL1

Register.

Step 4: Call the routine message_display 1 to display message “room temperature” on line one of

the LCD.

Step 5: a) Set the control register of the ADC with the following specifications

Channel number=2;

ADC clock=3 MHz

Select burst mode.

Conversion clocks required=11 clocks

b) Start the ADC conversion

Step 6: Wait for EOC signal. Once the EOC signal is obtained, read the ADC value

Step 7: Convert the read valve into BCD and then display the room temperature on the LCD

module..Repeat from step4.


PROGRAM:

STEPPER MOTOR



int main (void)

{

unsigned char a;

unsigned int b;

long c,d;

InitializeIO(); //Initialize the I/O lines

while(1)

{

for(d=0;d<100;d++)

{ // Rotate clock wise

b=0x6666;

for(a=0;a<4;a++)

{

IOPIN1 = (b & 0xff00) << 8 ;

IOCLR0 = 0x00400000; // Clear A3

IOSET0 = 0x00400000; // Set A3

for(c=0;c<0xa000;c++); // Delay

b = b << 1; // Shift left side one

}

}

for(d=0;d<100;d++)

{ // Rotate counter clock wise

b=0x6666;

for(a=0;a<4;a++)

{


IV YEAR


IOPIN1 = (b & 0xff00) << 8 ;

IOCLR0 = 0x00400000; // Clear A3

IOSET0 = 0x00400000; // Set A3

for(c=0;c<0xa000;c++); // Delay

b = b >> 1; // Shift right side one

}

}

}

}


{

IODIR0 = 0x00580000;


IOCLR0 = 0x00580000;

IOSET0 = 0x00180000;

}

void __gccmain()

{

}

TEMPERATURE SENSOR

#include "LPC214x.h" /* LPC21xx definitions */


int main(void)

{

int a;

unsigned char Channel = 1, t[7];

PINSEL1 = 0x01000000; // Select ADC to pin P0.28


DisplayLCD(0,"Room Temperature"); // Display message

while(1)

{

a=ReadADC(Channel); // Read ADC channel 1

t[0] = a/100 + '0';

a -= (a/100) * 100;

t[1] = a/10 + '0';

t[2] = '.';

t[3] = a%10 + '0';

t[4] = 'C';

t[5] = 0;

DisplayLCD(1,t); // Display the room temperature

LCDDelay1600();

}

}//Read ADC data from given channel number


{

int val,ch;





IV YEAR


do

{


}

while ((val & 0x80000000) == 0); // Wait for the conversion to complete




}

RESULT:

Thus the Embedded C program for interfacing stepper motor and temperature sensor is written

and executed. The output is verified in the ARM kit.


IV YEAR


PROGRAMMING IN RTOS & PORTING IT ON THE PROCESSOR

PROCEDURE








In processor:

CPU mode: ARM 7

CPU family: ARM 7

Member: ARM 7


In remote:


In compiler:




In assembler:



In linker:

Category : general



IV YEAR



Select vector.0



category : include objects &library modules

Select new ->type –lc

Select new ->type -lgcc

category :add library searching path

Select new ->browse ->c:->embest IDE->build ->xgcc arm elf->arm elf->lib

Select new ->browse ->c:->embest IDE->build -> xgcc arm elf->lib->gcc lib-> arm elf

->3.0.2

7. Then click ok








15. Output will be executed in the kit.


IV YEAR


FLASHING TWO LEDS

AIM:

To write a program in RTOS for flashing two LEDs and verify the output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:


Step 2: Intialize Handlers

Step 3: Initialize uC/OS-II by calling “OSInit ();”

Step 4: Create main task

Step 5: Initialize timer 0

Step 6: Start multitasking by calling “OSStart ();”


PROGRAM:

FLASHING TWO LEDS

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

* Flashing two LEDs connected to relay contacts.

* Relays are connected to port lines P0.9 and P0.10

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

#include "includes.h"

#include "lpc214x.h"

#define TASK_STK_SIZE 255 // Size of each task's stacks (# of WORDs)

#define TASK_START_ID 0 // Application tasks IDs

#define TASK_1_ID 1

#define TASK_2_ID 2

#define TASK_START_PRIO 0 // Application tasks priorities

#define TASK_1_PRIO 1


OS_STK TaskStartStk[TASK_STK_SIZE]; // Startup task stack

OS_STK Task1Stk[TASK_STK_SIZE]; // Task 1 task stack


static void TaskStartCreateTasks (void);

void Task1 (void *pdata);


void TaskStart (void *pdata)

{

pdata = pdata; // Prevent compiler warning

rIODIR0 = 0X40000400; // Set P0.30 and P0.10 lines as

ouput lines

rIOSET0 = 0X00000400;

TaskStartCreateTasks(); // Create all other tasks

while(1)

{

OSTimeDlyHMSM(0, 0, 1, 0); // Wait one second


IV YEAR


}

}

static void TaskStartCreateTasks (void)

{

OSTaskCreateExt(Task1, // Create Task 1

(void *)0,

&Task1Stk[TASK_STK_SIZE - 1],

TASK_1_PRIO,

TASK_1_ID,

&Task1Stk[0],

TASK_STK_SIZE,

(void *)0,

OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);


(void *)0,


TASK_2_PRIO,

TASK_2_ID,

&Task2Stk[0],

TASK_STK_SIZE,

(void *)0,


}

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

* Task 1 : Switches On/Off Relay 2

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

void Task1 (void *pdata)

{

long a;

pdata = pdata;

while(1)

{

a = rIOPIN0; // Read relay status

if(a & 0x00000400 )

{

rIOCLR0 = 0X00000400; // Switch Off relay 2

}

else

{

rIOSET0 = 0X00000400; // Switch off relay 2

}


}

}

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

* Task 2 : Switches On/Off Relay 1

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

void Task2 (void *pdata )

{

long a;


IV YEAR


pdata = pdata;

while(1)

{

a = rIOPIN0; // Read relay status

if(a & 0x40000000 )

{

rIOCLR0 = 0x40000000; // Switch Off relay 1

}

else

{

rIOSET0 = 0x40000000; // Switch On relay 1

}

OSTimeDlyHMSM(0, 0, 1, 0); // Wait two seconds

}

}

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

* Main Function

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

void C_vMain(void)

{

OS_STK *ptos;

OS_STK *pbos;

INT32U size;

vInitHaltHandlers(); // Initialize Handlers

pISR_IRQ = (U32)UCOS_IRQHandler;

OSInit(); // Initialize uC/OS-II

ptos = &TaskStartStk[TASK_STK_SIZE - 1];

pbos = &TaskStartStk[0];

size = TASK_STK_SIZE;

OSTaskCreateExt(TaskStart,

(void *)0,

ptos,

TASK_START_PRIO,

TASK_START_ID,

pbos,

size,

(void *)0,


FRMWRK_vStartTicker(OS_TICKS_PER_SEC);

OSStart(); // Start multitasking

}

void __gccmain()

{

}

Result:

Thus the Program for flashing two LEDs is written and the output is verified on an ARM

processor board.


IV YEAR


READING LM35 AND PLOTTING IN LCD

AIM:

To write a program in RTOS for reading LM35 and plotting in LCD and verify the output in

the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:


Step 2: Initialize Handlers






PROGRAM:

READING LM35 AND PLOTTING LCD

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

* Reads from Temperature Sensor LM35 and plots the graph on 128 x 64 Graphics Display

* Graph shows the display of temperature (Centrigade) Vs. Time (Seconds)

* The temperature is on the y axix and the Time is on the x axis.

* The display is refreshed for every 2 seconds

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


#include "GLCD.h"

#define TASK_STK_SIZE 256 // Size of each task's stacks


#define TASK_1_ID 1

#define TASK_2_ID 2










unsigned char tempa;


{


Initialise_GraphicsLCD(); // Initialize Graphics LCD

DisplayOneScreenLCD(); // Display parameters on the

display


while(1)

{


IV YEAR


OSTimeDlyHMSM(0, 0, 1, 0); // Wait for one second

}

}


{


(void *)0,


TASK_1_PRIO,

TASK_1_ID,

&Task1Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_2_PRIO,

TASK_2_ID,

&Task2Stk[0],

TASK_STK_SIZE,

(void *)0,


}

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

* Task 1 : Read voltage from channel 1 to which the temperature sensor is connected.

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


{

unsigned int a;

pdata = pdata;

while(1)

{

a=ReadADCChannel1(); // Read ADC channel 1

tempa = 0x3f-8-a; // Calculate temperature for display


}

}

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

* Task 2 : Update the display with the new temperature sensor is connected.

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


{

unsigned int i=0;

pdata = pdata;

while(1)

{

SetPixel(tempa,17+i); // Plot the temperature on the LCD

i++;


IV YEAR


OSTimeDlyHMSM(0, 0, 2, 0); // Wait for two seconds

}

}

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

* Main Function

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

void C_vMain(void)

{

OS_STK *ptos;

OS_STK *pbos;

INT32U size;








(void *)0,

ptos,

TASK_START_PRIO,

TASK_START_ID,

pbos,

size,

(void *)0,




}//Read ADC data from channel 1

int ReadADCChannel1(void)

{

int val;

rAD0CR = 0x00210402; // Setup A/D: 10-bit AIN @

3MHz for channel 1

rAD0CR |= 0x01000000; // Start A/D Conversion

do

{

val = rAD0DR; // Read A/D Data Register

}


val = (((val >> 9)-8) & 0x03FF); // Extract the A/D result

rAD0CR &= ~0x01000000; // Stop A/D Conversion


}

void __gccmain()

{

}

RESULT: Thus the Program for reading LM35 and plotting in LCD is written and the output is

verified on an ARM processor board.


IV YEAR


TWO MESSAGES ON LCD

AIM:

To write a program using RTOS for displaying two messages on LCD and verify the output in

the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:








PROGRAM:

TWO MESSAGES ON LCD

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

* Display Messages on 2 Line X 16 Characters Text LCD

* A Counter increments in Task 1 and it is displayed on Line 1 of LCD

* A Counter decrements in Task 2 and it is displayed on Line 2 of LCD

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


#include "LCD.C"

#define TASK_STK_SIZE 256 // Size of each task's stacks (# of WORDs)


#define TASK_1_ID 1

#define TASK_2_ID 2





OS_STK Task1Stk[TASK_STK_SIZE]; // Task #1 task stack






{

pdata = pdata; // To Prevent compiler warning

InitializeLCD();



IV YEAR


while(1)

{


}

}


{


(void *)0,


TASK_1_PRIO,

TASK_1_ID,

&Task1Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_2_PRIO,

TASK_2_ID,

&Task2Stk[0],

TASK_STK_SIZE,

(void *)0,


}

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

* Task 1 : Displays a counter on Line 1 of LCD (Counter increments)

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


{

pdata = pdata;

unsigned int Count1=0;

DisplayLCD(0,"Mesg Task1 : "); // Display Message

while(1)

{

DisplayLCD2Digit(0,12, (Count1 >>8));

DisplayLCD2Digit(0,14, (Count1 & 0xff));

// Display the count

value

Count1++; // Increment Counter 1

OSTimeDlyHMSM(0, 0, 0,500); // Delay

}

}

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

* Task 2 : Displays a counter on Line 2 of LCD (Counter decrements)

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


{


IV YEAR


pdata = pdata;

unsigned int Count2=0;

DisplayLCD(1,"Mesg Task2 : "); //Display message

while(1)

{

DisplayLCD2Digit(1,12, (Count2 >>8));

DisplayLCD2Digit(1,14, (Count2 & 0xff)); ` // Display the count

value

Count2--; // Decrement Counter 2

OSTimeDlyHMSM(0, 0, 0,500); // Delay

}

}

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

* Main Function

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

void C_vMain(void)

{

OS_STK *ptos;

OS_STK *pbos;

INT32U size;








(void *)0,

ptos,

TASK_START_PRIO,

TASK_START_ID,

pbos,

size,

(void *)0,




}

void __gccmain()

{

}

RESULT:

Thus the Program for displaying two messages on LCD is written and the output is verified on an ARM

processor board.


IV YEAR


SERIAL PORT

AIM:

To write a program in RTOS for using the serial port and verify the output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:








PROGRAM:

SERIAL PORT

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

* Sending Messages through Serial Port by 5 different tasks Using Serial Port 1.

* Connect the serial port cable between the Serial Port (P9) and PC Comm Port.

* Use Hyperterminal utility to receive characters from the serial port.

* Settings for Hyper ternminal - 9600 baud, 8 bits, 1 stop bit, no parity

*- Flow control(none)

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


#include "SerialPortRoutines.c"



#define TASK_1_ID 1

#define TASK_2_ID 2

#define TASK_3_ID 3

#define TASK_4_ID 4

#define TASK_5_ID 5

















IV YEAR






{


InitializeSerialPort(); // Initialize Serial Port


while(1)

{


}

}


{


(void *)0,


TASK_1_PRIO,

TASK_1_ID,

&Task1Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_2_PRIO,

TASK_2_ID,

&Task2Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_3_PRIO,

TASK_3_ID,

&Task3Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_4_PRIO,

TASK_4_ID,

&Task4Stk[0],

TASK_STK_SIZE,

(void *)0,


IV YEAR




(void *)0,


TASK_5_PRIO,

TASK_5_ID,

&Task5Stk[0],

TASK_STK_SIZE,

(void *)0,


}

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

* Task 1 : Send message through serial port

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


{

pdata = pdata;

while(1)

{

SendMessage("\r\nThis message is from TASK 1 with Priority 1\r\n");


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


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


{

pdata = pdata;

while(1)

{

SendMessage("This message is from TASK 2 with Priority 2\r\n");


}

}

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


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


{

pdata = pdata;

while(1)

{



}

}

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


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


{


IV YEAR


pdata = pdata;

while(1)

{



}

}

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


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


{

pdata = pdata;

while(1)

{



}

}

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

* Main Function

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

void C_vMain(void)

{

OS_STK *ptos;

OS_STK *pbos;

INT32U size;








(void *)0,

ptos,

TASK_START_PRIO,

TASK_START_ID,

pbos,

size,

(void *)0,




}

RESULT:

Thus the RTOS Program for Serial port is written and the output is verified on an ARM processor

board.


IV YEAR


MAIL BOX

AIM: To write a program in RTOS for Mail box function and verify the output in the ARM kit.


PC

EMBEST IDE

ARM Evaluation kit

ALGORITHM:








PROGRAM:

MAIL BOX

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

* Mail Box Demo

* A character is posted by Task 1 to Task 2 through Mailbox.

* The task 2 gets the character value from Mailbox and acknowledges it.

* The task 2 then displays the character in line 2 of the text LCD and this process is repeated

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


#include "LCD.c"



#define TASK_1_ID 1

#define TASK_2_ID 2


#define TASK_1_PRIO TASK_START_PRIO+1

#define TASK_2_PRIO TASK_START_PRIO+2




OS_EVENT *AckMbox; // Message mailboxes for Tasks #1 and #2

OS_EVENT *TxMbox;




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

Task 1 :

This task sends a message to Task 2. The message consist of a character that needs to be displayed by

Task 2. This task then waits for an acknowledgement from Task 2 indicating that the message has

been displayed.

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

void Task1 (void *data)

{


IV YEAR


char txmsg;

INT8U err;

data = data;

txmsg = 'A' ;

while(1)

{

OSMboxPost(TxMbox, (void *)&txmsg); // Send message to Task 2

OSMboxPend(AckMbox, 0, &err); // Wait for acknowledgement from Task 2

txmsg++; // Next message to send

if (txmsg == 'Z')

{

txmsg = 'A'; // Start new series of messages

}

OSTimeDlyHMSM(0, 0, 1, 0); // Wait for 1 second

}

}

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

* TASK 2:

** This task displays messages sent by Task 1. When the message is displayed,

* Task 2 acknowledges Task 1.

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

void Task2 (void *data)

{

char *rxmsg;

INT8U err;

data = data;

while(1)

{

rxmsg = (char *)OSMboxPend(TxMbox, 0, &err);// Wait for message from Task 1

DisplayCharacter(1,15,*rxmsg);

OSTimeDlyHMSM(0, 0, 1, 0); // Wait 1 second

OSMboxPost(AckMbox, (void *)1); // Acknowledge reception of message

}

}


{

pdata = pdata; // To Prevent compiler warning

InitializeLCD(); // Initialize text LCD

DisplayLCD(0,"Mail box Demo "); // Display messages on text LCD

DisplayLCD(1,"From Task 1 :");

AckMbox = OSMboxCreate((void *)0); // Create 2 message mailboxes

TxMbox = OSMboxCreate((void *)0);


while(1)

{


}

}


{


IV YEAR



(void *)0,


TASK_1_PRIO,

TASK_1_ID,

&Task1Stk[0],

TASK_STK_SIZE,

(void *)0,



(void *)0,


TASK_2_PRIO,

TASK_2_ID,

&Task2Stk[0],

TASK_STK_SIZE,

(void *)0,


}

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

* Main Function

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

void C_vMain(void)

{

OS_STK *ptos;

OS_STK *pbos;

INT32U size;








(void *)0,

ptos,

TASK_START_PRIO,

TASK_START_ID,

pbos,

size,

(void *)0,




}

void __gccmain()

{

}

RESULT:Thus the RTOS Program for understanding the mail box function is written and the output is

verified on an ARM processor board.


IV YEAR


FSM APPLICATION ON FPGA

PROCEDURE FOR TRAFFIC LIGHT CONTROLLER

1. Open Xilinx ISE 9.2i

2. Go to file-> new project

3. Give project name in the new project wizard- create new project dialog box.

4. Click next.

5. Device properties dialog box appears. In that select the following:

Product category : All

Family : Spartan 3E

Device : XC3S250E

Package : PQ208

Speed : -4

Preferred language : Verilog

6. Click next.

7. Click new source.

8. Select source type dialog box appears.

Select Verilog module and give file name.

9. Click next-> next-> finish

10. Click yes-> next-> next -> finish.

11. Type the program.

12. Go to file -> save.

13. In the synthesize-XST, double click check syntax.

14. Go to project-> new source

15. Select implementation constraints file and give file name.

16. Click next -> finish.

17. Select the newly created ucf file.

18. Double click Assign package pins in the User constraints.

19. Type the corresponding Input/ Output pins and save it.

20. Click ok.

21. Double click synthesize-xst, then double click implement design.

22. Double click Programming File Generation Report in Generate Programming File.

23. Switch ON the kit.

24. Double click Configure Device in Generate Programming File.

25. An iMPACT-welcome to iMPACT dialog box appears.

26. Click finish.

27. Right click the mouse -> select file name.bit -> click open.

28. Click ok.

29. Click on the Xilinx device -> Right click -> select Program

30. Check whether pulse PROG is disabled -> Click ok.



IV YEAR


DESIGN AND IMPLEMENTATION OF TRAFFIC LIGHT CONTROLLER IN FPGA

AIM:

To write a program for implementing traffic light controller and verify the output in FPGA kit.


PC

XILINX ISE 9.2i

Spartan 3E FPGA kit

PROGRAM:

module traffic(clk, rst, dir, p1, p2, p3, p4, pt); //module declaration

// input ports

input clk; // system clock frequency is 20 mhz

input rst; // for reset

// output ports

output [2:0] dir;

output [4:0] p1; // d5,d4,d3,d2,d1

output [4:0] p2; // d10,d9,d8,d7,d6

output [4:0] p3; // d15,d14,d13,d12,d11

output [4:0] p4; // d20,d19,d18,d17,d16

output [3:0] pt; // dl1,dl2,dl3,dl4,dl5,dl6,dl7,dl8 (Pedestrain)

// registered ports

reg [4:0] p1;

reg [4:0] p2;

reg [4:0] p3;

reg [4:0] p4;

reg [3:0] pt;

reg [30:0] sig;

//************ TRAFFIC LIGHT CONTROLLLER BLOCK ***************//

always @ (posedge clk or negedge rst)

begin

if (rst == 1'b0) //when reset switch is zero TLC is reset.

begin

p1 <= 5'b00100; //at reset condition

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b00100;

pt <= 4'b1111;

sig <= 8'h00000000;

end

else

begin

sig <= sig + 1;

case (sig[29:24])

6'b000000 : begin

p1 <= 5'b10011;// d5,d4,d3,d2,d1 (Green)

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b00100;


IV YEAR


pt <= 4'b1111;

end

6'b000100 : begin

p1 <= 5'b01000; //Yellow

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b00100;

pt <= 4'b1111;

end

6'b001000 : begin

p1 <= 5'b00100; // d10,d9,d8,d7,d6

p2 <= 5'b10011; //Green

p3 <= 5'b00100;

p4 <= 5'b00100;

pt <= 4'b1111;

end

6'b001100 : begin

p1 <= 5'b00100;

p2 <= 5'b01000; //Yellow

p3 <= 5'b00100;

p4 <= 5'b00100;

pt <= 4'b1111;

end

6'b010000 : begin

p1 <= 5'b00100; // d15,d14,d13,d12,d11

p2 <= 5'b00100;

p3 <= 5'b10011; //Green

p4 <= 5'b00100;

pt <= 4'b1111;

end

6'b010100 : begin

p1 <= 5'b00100;

p2 <= 5'b00100;

p3 <= 5'b01000; //yellow

p4 <= 5'b00100;

pt <= 4'b1111;

end

6'b011000 : begin

p1 <= 5'b00100; // d20,d19,d18,d17,d16

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b10011; //Green

pt <= 4'b1111;

end

6'b011100 : begin

p1 <= 5'b00100;

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b01000; //Yellow

pt <= 4'b1111;


IV YEAR


end

6'b100000 : begin

p1 <= 5'b00100; //dl1,dl2,dl3,dl4,dl5,dl6,dl7,dl8

p2 <= 5'b00100;

p3 <= 5'b00100;

p4 <= 5'b00100;

pt <= 4'b0000; //Pedestrain

end

6'b100100 : sig <= 8'h00000000;

default : begin

end

endcase

end

end

assign dir = 3'b111;

endmodule

Flowchart:-


IV YEAR


State Diagram for Traffic Light Controller

EXPERIMENTAL SET UP:


IV YEAR


RESULT:

Thus the traffic light controller was implemented and the output is verified in the FPGA kit.


IV YEAR


PROCEDURE FOR 4 BIT UPDOWN COUNTER




4. Click next.



Family : Spartan 3E

Device : XC3S250E

Package : TQ144

Speed : -4

Preferred language : VHDL

6. Click next.



Select VHDL module and give file name.












20. Click ok.






26. Select Enter a boundary-scan chain manually in configure devices using boundary

scan(JTAG) option.

27. Click finish.

28. Right click the mouse, select Add Xilinx device -> select file name.bit -> click open.

29. Click ok.

30. Right click the mouse -> select output file type -> XSVF file -> Create XSVF file.

31. Give file name and save it.


IV YEAR


32. Click ok.


34. Enable pulse PROG.

35. click ok.

36. Program Succeeded will appear.

37. Right click the mouse -> select output file type -> XSVF file -> Stop writing to file.

38. Minimize the window.

39. Open Top view programmer.

40. click browse -> select file.xsvf from your project -> open.

41. Press Power reset button.

42. Clicks configure.



IV YEAR


DESIGN AND IMPLEMENTATION OF 4 BIT UPDOWN COUNTER IN FPGA

AIM:

To write a program for implementing 4 bit up down counter and verify the output in FPGA kit.


PC

XILINX ISE 9.2i

Spartan 3E FPGA kit

PROGRAM: library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity Counter4Bit is

Port ( CLOCK : in STD_LOGIC;

DIRECTION : in STD_LOGIC;

COUNT_OUT : out STD_LOGIC_VECTOR (3 downto 0));

end Counter4Bit;

architecture Behavioral of Counter4Bit is

signal cnt: std_logic_vector(3 downto 0):="0000";

signal cnt1: integer range 0 to 50000000:=0;

signal clk1: std_logic;

begin

process(CLOCK)--Generate low speed clock

begin

if CLOCK='1' and CLOCK'event then--Check CLOCK transition

if cnt1 = 50000000 then --If cnt1 reaches 50,000,000

cnt1 <= 0; --Clear cnt1 and toggle clk1

clk1 <= not clk1;

else

cnt1 <= cnt1+1; --increment cnt1

end if;

end if;

end process;

process(clk1,DIRECTION) --Counter operation

begin

if clk1='1' and clk1'event then--Check clk1 transition

if DIRECTION = '1' then --Direction is '1',up count

cnt <= cnt+1;

else

cnt <= cnt-1; --otherwise down count

end if;

end if;

end process;

COUNT_OUT <= cnt; --assign COUNT_OUT with cnt.

end Behavioral;


IV YEAR


State Diagram:

RESULT:

Thus 4 bit up down counter was implemented and the output is verified in the FPGA kit.


IV YEAR


PERFORMANCE CHARACTERSTICS OF ARM & FPGA AND

HARDWARE AND SOFTWARE PARTITIONING

PROCEDURE FOR

INTERRUPT PROCESSING PERFORMANCE CHARACTERSTICS OF ARM & FPGA AND

HARDWARE AND SOFTWARE PARTIONING BETWEEN FPGA AND ARM




4. Click next.



Family : Spartan 3E

Device : XC3S250E

Package : TQ144

Speed : -4

Preferred language : VHDL

6. Click next.



Select VHDL module and give file name.












20. Click ok.







IV YEAR


26. Select Enter a boundary-scan chain manually in configure devices using boundary

scan(JTAG) option.

27. Click finish.

28. Right click the mouse, select Add Xilinx device -> select file name.bit -> click open.

29. Click ok.

30. Right click the mouse -> select output file type -> XSVF file -> Create XSVF file.

31. Give file name and save it.

32. Click ok.


34. Enable pulse PROG

35. click ok.

36. Program Succeeded will appear.

37. Right click the mouse -> select output file type -> XSVF file -> Stop writing to file.

38. Minimize the window.






43. Right click on project header files & click on add files to folder -> select files & add it.



In processor:

CPU mode: ARM 7

CPU family: ARM 7

Member: ARM 7


In remote:


In compiler:




IV YEAR



In assembler:



In linker:

Category : general



Select vector.0



category : include objects &library modules

Select new ->type –lc

Select new ->type -lgcc

category :add library searching path

Select new ->browse ->c:->embest IDE->build ->xgcc arm elf->arm elf->lib

Select new ->browse ->c:->embest IDE->build -> xgcc arm elf->lib->gcc lib-> arm elf

->3.0.2

46. Then click ok





51. Press Power reset button





IV YEAR


55. Open Top view programmer

56. click browse -> select file.xsvf from your project -> open

57. Clicks configure.


INTERRUPT PROCESSING PERFORMANCE CHARACTERSTICS OF ARM & FPGA

AIM:

To write a program for interrupt processing performance characteristics of ARM& FPGA

and to verify the output in the ARM+FPGA kit.


PC

EMBEST IDE

XILINX ISE 9.2i

ARM+FPGA Evaluation kit

PROGRAM

(i)VLSI PROGRAM library IEEE;




Library UNISIM;

use UNISIM.vcomponents.all;

entity InterruptTest is

Port ( CLOCK : in STD_LOGIC;INTCLK : in STD_LOGIC;

LED : out STD_LOGIC_VECTOR (7 downto 0);

STATUS : out STD_LOGIC;ARMINT : out STD_LOGIC;

ARMSPEED: in STD_LOGIC);

end InterruptTest;

architecture Behavioral of InterruptTest is

signal clk1: std_logic;

signal stat: std_logic:='0';

signal cnt1: std_logic_vector (23 downto 0);

begin

process(CLOCK)

begin --Generate 100MHZ/2 = 50MHZ Clock

if CLOCK='1' and CLOCK'event then

clk1 <= not clk1;

end if;

end process;

process(INTCLK) --Use INTCLK as External interrupt clock

begin

if INTCLK='1' and INTCLK'event then

cnt1 <= cnt1+1; --Interrupt counter


IV YEAR


stat <= not stat; --Generate FPGA status signal, Interrupt process freq/2

end if;

end process;

process(clk1) --Count display process

begin

if clk1='1' and clk1'event then

LED <= cnt1(23 downto 16);--Send scaled counter result to LEDs

end if;

end process;

STATUS <= stat; --FPGA Interrupt processing Speed Indicator

ARMINT <= INTCLK; --Loop INTCLK to Generate ARM Interrupt signal.

end Behavioral;

(ii)EMBEEDED PROGRAM


#include "ARMBoard.h" // ARM FPGA Board I/O Usage Description

extern void irq_INT3(void); // Int0 Interrupt process


void InitializeInterrupt(void);

void Initialize_IO(void);

int Counter=0;

int main (void)

{

Initialize_IO(); // I/O Initialization

APBDIV = 1; // PCLK = CCLK = 50MHz

InitializeInterrupt(); // Initialize Int3 interrupt

while(1){}; // Wait for interrupt

}

void Initialize_IO(void)

{

SCS = 3;

FIO0DIR = ARM_BUS | LED_CS | SW_CS | LCD_CS | LCD_RW | SEG_CS | DG3_EN |

DG4_EN | ROW; // Define Output lines

FIO0DIR |= BUZZER;

FIO1DIR = LCD_RS | FPGA_BUS | FPGA_WR;

FIO0SET = LED_CS | SW_CS | SEG_CS; // Disable all peripherals &

FIO0CLR = ARM_BUS | LCD_CS | BUZZER; // Clear Data Bus lines

FIO0SET |= DG3_EN | DG4_EN; // Disable both DG3 and DG4

FIO1SET = FPGA_WR | LCD_RS;

}

//Initialise Interrupt

void InitializeInterrupt(void)


IV YEAR


{

PINSEL1 = 0x20000000; // Enable EINT3 (P0.30)

EXTMODE = 0x08; // edge select enabled for interrupts EINT3


VICVectCntl0 = 0x00000031; // Set channel 0 to EINT3

VICIntEnable = 0x00020000; // Enable interrupt EINT3

}

/* Interrupt3 service routine */

void INT3_Srv(void)

{ // Response: 350KHz with counter and 480KHz without

counter

int val;

Counter++; // Increment Counter

val = (Counter>>14) & ARM_BUS;

FIO0SET = val; // Latch count on LEDs

FIO0CLR = (~val) & ARM_BUS;

FIO0CLR = LED_CS; // Generate LED CS

FIO0SET = LED_CS; //

FIO1CLR = ARM_STAT; // Arm Execution speed status, TP4

FIO1SET = ARM_STAT;

EXTINT |=0x08; // Clear flag

VICVectAddr = 0x00000000; // Dummy write to signal end of interrupt

}

void __gccmain()

{

}

RESULT:

Thus interrupt processing performance characteristics of ARM& FPGA was implemented and the

output is verified in the ARM+FPGA kit.


IV YEAR


HARDWARE AND SOFTWARE PARTIONING BETWEEN FPGA AND ARM

AIM:

To write a program for Hardware and Software partitioning between FPGA and ARM and to

verify the output in the ARM+FPGA kit.


PC

EMBEST IDE

XILINX ISE 9.2i

ARM+FPGA Evaluation kit

PROGRAM:

ARM TO FPGA

(i)VLSI PROGRAM

library IEEE;




entity ReadARM is

Port ( CLOCK : in STD_LOGIC; LED : out STD_LOGIC_VECTOR (7 downto 0);

ARM_DATA : inout STD_LOGIC_VECTOR (7 downto 0);

ARM_STRB: in STD_LOGIC);

end ReadARM;

architecture Behavioral of ReadARM is

signal buff: std_logic_vector (7 downto 0);

begin

process(ARM_DATA,ARM_STRB) --Get data from ARM Processor

begin

if ARM_STRB='0' and ARM_STRB'event then

buff <= ARM_DATA; --Store result in buffer

end if;

end process;

process(CLOCK) --Result Display process

begin


LED<=buff; --Send result to LED's

end if;

end process;

end Behavioral;





int main (void)

{

int sw;


while(1)


IV YEAR


{

IODIR0 &= ~ARM_BUS; // Configure ARM Bus as input

IOCLR0 = SW_CS; // Generate Toggle Switch CS

sw = IOPIN0 & SW_BUS; // Get Switch status

IOSET0 = SW_CS; // Disable Toggle Switch CS

sw = sw<<14; // Align to FPGA BUS

IOSET1 = sw; // Send result to FPGA

IOCLR1 = (~sw) & FPGA_BUS;

IOCLR1 = FPGA_WR; // Generate FPGA Write signal

IOSET1 = FPGA_WR;

}

}


{

IODIR0 = ARM_BUS | LED_CS | SW_CS | LCD_CS | LCD_RW | SEG_CS | DG3_EN |


IODIR0 |= BUZZER;

IODIR1 = LCD_RS | FPGA_BUS | FPGA_WR;

IOSET0 = LED_CS | SW_CS | SEG_CS | LCD_RS; // Disable all peripherals &

IOCLR0 = ARM_BUS | LCD_CS | BUZZER; // Clear Data Bus lines

IOSET0 |= DG3_EN | DG4_EN; // Disable both DG3 and DG4

IOSET1 = FPGA_WR;

}

void __gccmain()

{

}

FPGA TO ARM

(i)VLSI PROGRAM library IEEE;




entity WriteARM is

Port (CLOCK : in STD_LOGIC; SW_IN: in STD_LOGIC_VECTOR (3 downto 0);

ARM_STRB: in STD_LOGIC;ARM_DATA: inout STD_LOGIC_VECTOR (7 downto 0));

end WriteARM;

architecture Behavioral of WriteARM is

signal buff: std_logic_vector (7 downto 0);

begin

process(CLOCK) --Input Data Processing @ 100Mhz

begin


buff(3 downto 0) <= SW_IN; --Store digital input in buffer

end if;

end process;

process(ARM_STRB,buff) --ARM Data bus handler

begin

if ARM_STRB='0' and ARM_STRB'event then --Check positive edge

ARM_DATA<=buff; --Send result to ARM processor

end if;


IV YEAR


end process;

end Behavioral;





int main (void)

{

int d;


while(1)

{

IODIR1 &= ~FPGA_BUS; // Configure FPGA Bus as input

IOCLR1 = FPGA_WR; // Generate FPGA Strobe Signal

d = IOPIN1 & FPGA_BUS; // Get input data from FPGA

IOSET1 = FPGA_WR; // Disable FPGA Strobe Signal

d = d>>14; // Align data to ARM Bus

IOSET0 = d; // Latch data on ARM Bus

IOCLR0 = (~d) & ARM_BUS;

IOCLR0 = LED_CS; // Generate LED chip select

IOSET0 = LED_CS;

}

}


{

IODIR0 = ARM_BUS | LED_CS | SW_CS | LCD_CS | LCD_RW | SEG_CS | DG3_EN |


IODIR0 |= BUZZER;

IODIR1 = LCD_RS | FPGA_BUS | FPGA_WR;

IOSET0 = LED_CS | SW_CS | SEG_CS | LCD_RS; // Disable all peripherals &

IOCLR0 = ARM_BUS | LCD_CS | BUZZER; // Clear Data Bus lines

IOSET0 |= DG3_EN | DG4_EN; // Disable both DG3 and DG4

IOSET1 = FPGA_WR;

}

void __gccmain()

{

}

RESULT:

Thus Hardware and Software partitioning between FPGA and ARM was implemented and the

output is verified in the ARM+FPGA kit.


IV YEAR


IMPLEMENTATION OF WIRELESS COMMUNICATION PROTOCOL

PROCEDURE

FOR MASTER




3. Copy the support file from the original folder to the created folder.





In processor:

CPU mode: ARM 7

CPU family: ARM 7

Member: ARM 7


In remote:


In compiler:




In assembler:



IV YEAR



In linker:

Category : general



Select vector.0



8. Then click ok






14. Switch on the kit -> press reset button -> click start in the flash magic window.

15. Minimize the window.FOR SLAVE

16. Open another Embest IDE software.



18. Copy the support file from the original folder to the created folder.





In processor:

CPU mode: ARM 7


IV YEAR


CPU family: ARM 7

Member: ARM 7


In remote: Remote device: SIM ARM 7

In compiler:Category: target specific option



In assembler:



In linker:

Category : general



Select vector.0



23. Then click ok




27. Open another flash magic.


29. Switch on the kit -> press reset button -> click start in the flash magic window.


IV YEAR


IMPLEMENTATION OF ZIGBEE PROTOCOL WITH ARM7

AIM:

To write a program for zigbee protocol with arm7 and to verify the output in the ARM wireless

sensor network kit.


PC

EMBEST IDE

ARM wireless sensor network kit.

PROGRAM:

(i)ZIGBEE MASTER


#include "ARMBoard.h" // ARM Wireless Board I/O Usage Description

#include "WirelessCommands.h"


void delay(void);


int main (void)

{

int b;


PINSEL1 = 0x05000000; // Enable ADC input pins P0.28 & P0.29

IOCLR0 = XBEE_RST; // Reset XBEE Module


DisplayLCD(0," WireLess Study "); // Display message

DisplayLCD(1," "); // Display message

InitializeSerialPort(); // Initialize Serial port

IOSET0 = XBEE_RST; // Reset=1, enable XBEE Module

EnterCommandMode(); // Select command mode

SetSelfID("NODE0"); // Self Node name

ExitCommandMode();

SendByteSer(SYNC); // Send sync byte to slave


while(1)

{

if(Connect("NODE1")=='O') break; // Connect Destination Node2

}

while(1)

{

b=ReadADC(2); // Read ADC channel 2

SendByteSer(LED_DATA); // Send LED control command to destination node

SendByteSer(b); // Transmit ADC Result to destination node

SendByteSer(ADC); // Send ADC process command to destination node

b=ReadByte()<<16; // Receive ADC Result of Kit2

IOSET1 = b; // Display the data on LEDs

IOCLR1 = (~b) & ARM_BUS;


IV YEAR


IOCLR0 = LED_CS; // Generate LED CS

IOSET0 = LED_CS;

SendByteSer(PROX); // Send Object sense command to destination node

if(ReadByte()==0) IOSET0 = BUZZER; / When object found, Turn on Buzzer

else IOCLR0 = BUZZER;

}

}

// Initializes I/O Lines


{

IODIR0 = LED_CS | SW_CS | LCD_CS | LCD_RW | LCD_RS | BUZZER;

IOCLR0 = LCD_CS | LCD_RW | LCD_RS | BUZZER;

IOSET0 = LED_CS | SW_CS; // Disable all peripherals

IODIR1 = ARM_BUS; // Define ARM BUS lines as output

IOCLR1 = ARM_BUS; // Clear Data Bus lines

IODIR0 |= XBEE_TXD1 | XBEE_RST | XBEE_RTS; // XBEE interface lines

IOSET0 = XBEE_TXD1 | XBEE_RST | XBEE_RTS;

}

void delay(void)

{

int i,j,k;

{

for(k=0;k<50;k++)

{

for(i=0;i<500;i++)

{

j++;

}

}

}

}

//Read ADC data from given channel number


{

int val,ch;




do

{


}




return(val>>2); // Return upper 8-bits

}

void __gccmain()

{

}


IV YEAR


(ii)ZIGBEE SLAVE


#include "ARMBoard.h" // ARM Wireless Board I/O Usage Description

#include "WirelessCommands.h"


void delay(void);


int main (void)

{

int b,cmd;

char N0,N1,N2;


PINSEL1 = 0x05000000; // Enable ADC input pins P0.28 & P0.29

IOCLR0 = XBEE_RST; // Reset XBEE Module


DisplayLCD(0," WireLess Study "); // Display message

DisplayLCD(1," "); // Display message

InitializeSerialPort(); // Initialize Serial port

IOSET0 = XBEE_RST; // Reset=1, enable XBEE Module


SetSelfID("NODE1"); // Self Node name

ExitCommandMode(); // Exit command mode

ReadByte(); // Get Sync from Node0


Connect("NODE0"); // Connect with Node0

while(1)

{

cmd = ReadByte();

if(cmd==LED_DATA) // Check LED control command?

{

b=ReadByte()<<16; // Receive ADC Result of Kit2

IOSET1 = b; // Display the data on LEDs

IOCLR1 = (~b) & ARM_BUS;

IOCLR0 = LED_CS; // Generate LED CS

IOSET0 = LED_CS;

}

if(cmd==ADC) // Check ADC?

{

b=ReadADC(2); // Read ADC channel 2

SendByteSer(b); // Transmit ADC Result to master node

}

if(cmd==PROX)

{

b = ((IOPIN1 & PROX_IN)>>25)&1;

SendByteSer(b); // Transmit Result to master node

}

}

}

// Initializes I/O Lines


IV YEAR



{

IODIR0 = LED_CS | SW_CS | LCD_CS | LCD_RW | LCD_RS | BUZZER; IOCLR0 =

LCD_CS | LCD_RW | LCD_RS | BUZZER;

IOSET0 = LED_CS | SW_CS; // Disable all peripherals

IODIR1 = ARM_BUS; // Define ARM BUS lines as output

IOCLR1 = ARM_BUS; // Clear Data Bus lines

IODIR0 |= XBEE_TXD1 | XBEE_RST | XBEE_RTS; // XBEE interface lines

IOSET0 = XBEE_TXD1 | XBEE_RST | XBEE_RTS;

}

void delay(void)

{

int i,j,k;

{

for(k=0;k<50;k++)

{

for(i=0;i<500;i++)

{

j++;

}

}

}

}


{

int val,ch;




do

{


}




return(val>>2); // Return upper 8-bits

}

void __gccmain()

{

}

RESULT:

Thus zigbee protocol with arm7 was implemented and the output is verified in the ARM wireless

sensor network kit.

embs final manual

Documents

laboratory manual

interfacing led

embedded systems ec1404

interfacing adc

interfacing eeprom

interfacing keyboard

year issue

fpga application development