Embedded System Lab Manual Final Complete Final

PONNAIYAH RAMAJAYAM COLLEGE OF ENGG & TECH VALLAM, THANJAVUR – 613403

DEPARTMENT OF ECE EMBEDDED SYSTEM LAB MANUAL

EMBEDDED SYSTEMS LAB MANUAL

Prepared BY

T.M.Baskar B.E, M.Tech..,Asst.Prof / ECE

DEPARTMENT OF ECE ©[email protected]



CONTENTSIntroduction to EMBEDDED SYSTEMS EMBEDDED SYSTEMS LAB – SYLLABUS . . . . . . . . . . . . . . . . . . . . . 1

EXPERIMENT NO.1 . . . . . . . . . . . . . . . . . . . . . 2

EXPERIMENT NO.2 . . . . . . . . . . . . . . . . . . . . . 18

EXPERIMENT NO.3 . . . . . . . . . . . . . . . . . . . . . 28

EXPERIMENT NO.4 . . . . . . . . . . . . . . . . . . . . . 39

EXPERIMENT NO.5 . . . . . . . . . . . . . . . . . . . . . 43

EXPERIMENT NO.6 . . . . . . . . . . . . . . . . . . . . . 61

APPENDIX A . . . . . . . . . . . . . . . . . . . . . 65

APPENDIX B . . . . . . . . . . . . . . . . . . . . . 72

APPENDIX C . . . . . . . . . . . . . . . . . . . . . 75




WHAT IS

AN

EMBEDDED

SYSTEM?




EMBEDDED SYSTEM

An Embedded System is a special-purpose computer system designed to

perform one or a few dedicated functions. In contrast, a general-purpose computer, such as a personal computer, can do many different tasks depending on programming. . It is usually embedded as part of a complete device including hardware and mechanical parts. Embedded systems control many of the common devices in use today.

The main difference between an embedded controller and a PC is that the embedded controller is dedicated to one specific task or set of tasks. A PC is designed to run many different types of programs and to connect too many different external devices. An Embedded controller has a single program which includes the computing power and the hardware to perform that dedicated task. An Embedded Controller is reasonably priced compared to that of a PC .A PC has a relatively expensive generalized central processing unit (CPU) at its heart with many other external devices (memory, disk drives, video controllers, network interface circuits, etc.).

An embedded system has a low-cost microcontroller unit (MCU) for its intelligence, with many peripheral circuits on the same chip, and with relatively few external devices. Often, an embedded system is an invisible part, or sub-module of another product, such as a cordless drill, refrigerator or garage door opener. The controller in these products performs a small function in the entire device. The controller adds low-cost intelligence to some of the critical sub-systems in these devices. Embedded systems are not always separate devices. Most often they are physically built-in (Embedded) to the devices they control. It is a combination of both HARDWARE and SOFTWARE.

HARDWARE : Processor associated with peripherals (Interface to the real world) SOFTWARE : Programmed to get specified task (how to deal with inputs)

APPLICATIONS OF EMBEDDED SYSTEMS

DOMAIN EXAMPLEHome Automation Washing Machines, CD-player, and CookerOffice Automation PCs, Laser Printers, Fax Machines, Intelligent TelephonesCommunication Mobile, Data transmissionMachine Control Elevators, ConveyorsOthers Medical, Military, Security system, Robotics




HISTORY OF PROCESSOR

The first microprocessor for example, the Intel 4004, was designed for

calculators and other small systems but it required more of external memory and

support chips. It was a simple calculator which could only add and subtract

numbers, 4 bits (a nibble) at a time. 4040 chip was very successful that it was

soon followed by Intel’s 8-bit 8008 microprocessor. It was a simple

microprocessor with limited resources, poorly implemented interrupt

mechanisms, and multiplexed address and data busses. The first very powerful

8-bit microprocessor appeared in early 1974 as the Intel 8080 chip. This microprocessor had separate address and data busses with 64 Kbyte of address space which was enormous in 1975 standards. 8080 microprocessor was the first microprocessor used in homes as a personal computer named Altair.

Motorola introduced the 8-bit 6800 chip which had a different architecture to that of the 8080 but has

also been very popular. In 1976, Zilog introduced the Z80 microprocessor which was very much

advanced than the 8080. The instruction set of Z80 was downward compatible with the 8080 and this

made Z80 to be one of the most successful microprocessors of that time. Z80 was used in many

microprocessor-based applications, including home computers and games consoles. In 1976,

Motorola created a microprocessor chip called 6801 which replaced a 6800 chip plus some of the

chips required to make a complete computer system. This was a major step in the evolution of the

microcontrollers which are basically computers consisting of only one chip. In later years, we see

many other micro-controller chips in the market, such as Intel 8048, 8049, 8051, Motorola 6809,

Atmel 89C51, etc

MICROCONTROLLERS VERSUS MICROPROCESSORS

Microcontroller differs from a microprocessor in many ways. First and the most important is its

functionality. In order to use a microprocessor, other components such as memory, or components

for receiving and sending data must be added to it. In short it means that the microprocessor is the

heart of a computer. On the other hand, microcontroller is designed to be all of that in one. No other

external components are needed for its application because all necessary peripherals are already

built into it. Thus, we save the time and space needed to construct devices.

A Microcontroller is a single chip computer .Micro suggests that the device is small and controller

suggests that the device can be used in control applications. Another term used for

microcontrollers is embedded controller, since most of the microcontrollers are built into (or

embedded in) the devices they control. A microprocessor differs from a microcontroller in many




ways. The main difference is that a microprocessor requires several other components for its

operation, such as program memory and data memory, I/O devices, and external clock circuit.

A microcontroller on the other hand has the entire support chips incorporated inside the same chip. All microcontrollers operate on a set of instructions (or the user program) stored in their memory. A microcontroller fetches the instructions from its program memory one by one, decodes these instructions, and then carries out the required operations.

MICROPROCESSOR (GENERAL PURPOSE COMPUTER)

CPU for ComputersNo RAM, ROM, I/O on CPU chip itselfExample: Intel’s x86, Motorola’s 680x0

MICROCONTROLLER (COMPUTER ON A CHIP)

A smaller computer On-chip RAM, ROM, I/O ports... Example :Motorola’s 6811, Intel’s 8051, Slog’s Z8 and PIC 16X

RAM ROM

C P U S IN G L E C H IP

TIM ER IO P O R T S

System-On-A-Chip (SOC) refers to integrating all components of a computer or other electronic system into a single integrated circuit (chip). These microcontrollers combine a microprocessor unit (like the CPU in a desk-top PC) with some additional circuits called peripherals, plus some additional circuits on the same chip to create a small control module




requiring few other external devices. This single device can then be embedded into other electronic and mechanical devices for low-cost digital control.

CENTRAL PROCESSING UNIT (CPU)

Central processing unit (CPU) is the brain of a microcontroller. It is responsible for finding and fetching the right instruction which needs to be executed, for decoding that instruction, and finally for its execution.

BY ARCHITECTURE

HARVARDVON-NEUMANNRISC (REDUCED INSTRUCTION SET COMPUTER)CISC (COMPLEX INSTRUCTION SET COMPUTER)

RISC (Reduced Instruction Set Computer) and CISC (Complex Instruction Computer) refer to the instruction set of a microcontroller. Microcontrollers with Harvard architecture are also called "RISC microcontrollers". RISC stands for Reduced Instruction Set Computer. Microcontrollers with von-Neumann's architecture are called 'CISC microcontrollers'. CISC stands for Complex Instruction Set Computer.

In an 8-bit RISC microcontroller, data is 8-bits wide but the instruction words are more than 8-bits wide (usually 12, 14, or 16-bits) and the instructions occupy one word in the program memory. Thus, the instructions are fetched and executed in one cycle, resulting in an improved performance. PIC microcontrollers are RISC-based devices and they have no more than 35 instructions. In a CISC microcontroller both data and instructions are 8-bits wide. CISC microcontrollers usually have over 200 instructions. Data and code are on the same bus and cannot be fetched simultaneously.

Since PIC is a RISC microcontroller, it has a reduced set of instructions, more precisely 35 instructions. (Ex. Intel's and Motorola's microcontrollers have over hundred instructions) All of these instructions are executed in one cycle except for jump and branch instructions.

HARVARD ARCHITECTURE

8 8, 14, 16




VON-NEUMANN ARCHITECTURE

MEMORY C P U(DATA

PROGRAM)

MEMORY UNIT

PROGRAM MEMORY (FLASH)

The Program memory is used to store a written program. Since memory made in FLASH

technology can be programmed and cleared more than once, it makes this microcontroller

suitable for device development. Program memory is the space where your PIC BASIC program

resides. Those sizes— 0.5k, 1k, 2k , 4k, and 8k—are the program memory sizes for the majority

of the PIC devices. Program memory in a PIC is actually 14 bits wide even though PICs are

considered 8-bit microcontrollers. The 8-bit terminology comes from the data memory buss,

which is 8 bits wide. A 14-bit-wide memory is commonly referred as bytes even though a byte by

definition is 8 bits wide. Microchip names the 14-bit-wide addresses as “Words” even though a

word is 16 bits long. On a 0.5k PIC, the memory moves from 0000h to 01ffh (0 to 511 decimal,

14-bit wide words). A 1k part is 0000h to 03ffh, and a 2k part is 0000h to 07ffh.

DATA MEMORY (EEPROM, RAM)

EEPROM

A Data memory needs to be saved when there is no supply. It is usually used for storing important data which is not lost when the power supply goes off. For instance, one such data is an assigned temperature in temperature regulators. During loss of power supply, when all the unsaved data was lost, we would have to make the changes once again. Thus our device looses on self-reliance. The data memory is used to store all of your program variables. EEPROM data memory is provided for long-term storage of data.




RAM

RAM (Random Access Memory) is the Data memory used by programs during execution. RAM

stores all inter-results or temporary data during run-time. Data memory is where all your variables are

stored. The data memory is 8 bits wide, and so the PICs are considered 8-bit microcontrollers.

PROGRAM MEMORY

MEMORY


DATA MEMORY

ix


DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGG

EMBEDDED SYSTEMS LAB

List of Experiments as per syllabus and suggested experiments from HDL SOLUTIONS

1. Open source software such as Linux flavors will be used. Ability to use industry standard tools for Verification and validation.

Using Linux Operating System (VI Editor) developing some set of programs in high level language (C).

2. High level language programming (c, c++ & Java) and porting it on a processor. I/O Porting using the external peripheral devices in ARM9 Processor (LED Display, SEVEN SEGMENT Display, KEYPAD).

3. Create FSM of a typical application and implement on an FPGA. FSM concept of Traffic Light Controller Interface on FPGA

4. Application development, download partition between FPGA and ARM on Performance characteristics.

A simple 4-bit Counter program to show FPGA is faster than ARM

5. Application development & Hardware and Software Partitioning. Partitioning the FPGA using SOC concept and implement a simple 4-bit Counter program with a Embedded Core.

6. Projects (implementation of a wireless communication protocol on an embedded system) File Transfer Application using Zigbee, Bluetooth, RF, RFID, GPS & WiFi Interface Modules

©T.M.Baskar [email protected]



EXPERIMENT 1:Open source software such as Linux flavors will be used. Ability to use industry standard tools for Verification and validation.

AIM: To Port a compressed Embedded Linux kernel image (Linux 2.6 Kernel) to the RAM of ARM9 Processor and network the Linux-bootable ARM9 Single Board Computer to PC through Ethernet to display a message.

TYPE OF PROTOBOARD USED: ―EXPLORER ARM-9 DEVELOPMENT BOARD

HOW TO START WITH TRITON IDE Double click on the icon-Triton on your Desktop

Select the workspace in which you can create all

your projects as shown in the figure below. Click OK.

Selectworkspace

&Click OK

Triton IDE C/C++ Environment opens as shown in below figure in which you can create new project, open existing one etc.




To create new project go to Project menu

Then clickProject New C Project.You will get below figure.




In the Project Name field, type name of the project asdisplay. Do not use spacesor special characters in the project name.

Select the Target as per the board you have. i.e.ARM9

Select the Variant from the variant list. i.e.AT91SAM9260

Select Operating System as per your requirement. Here we should select Linux as the operating system

Select the Port from Port field. i.e.COM1

Select the Baud Rate from dropdown list.i.e.38400




Select the Build options as SDRAM, Download options as ISP Utility, Debug as MONITOR.

You can also change the location of project. For that, uncheck ‗use default location‘ and then browse your location.

Check Create Project Using Template. then click NEXT

Enter the various fields

&Click NEXT

Below screen will appear, Debug and Release configurations would be checked. Select the type of project that you want to build. By default Project Type is

Executable (Gnu)




Uncheck debug mode

& click FINISH

Debug-Project can be debugged on target board using serial JTAG and Ethernet Release-Project is run on Target board without debugging Uncheck the debug and click FINISH The project is created and opened in the IDE. You should see the following components: To create a new file, CLICK FILE > NEW > SOURCE FILE Browse the source folder location & enter source filename –display.c




Select newSource File

The Projects window contains a tree view of the components of the project,source files and file properties.

Enter yourProject

Code here

You can enter the code in the display.c file.




You can double click the display.c tab in the Editor view to expand the view. /**************************************************************

Display.c***************************************************************/#include<stdio.h>int main(){int i = 0; for(;i<5;i++)

{printf("\n%d HDL SOLUTIONS...",i);

}return 0;

}********************************************************************Save thedisplay.cby choosingFile > Save. You will notice an asterisk in front of the file name on the tab in the Editor view (Workspace). The asterisk indicates that the file has changed, but has not been saved. So, save the file for every modification in the program.

To compile project you need to select Release mode. Debug mode: This creates an executable hex file which you, after downloading on the target board, are able to debug. Release mode: This creates an executable hex file which you can download on the target board, but you won‘t be able to debug.

To build project in Release mode----Right click on the DISPLAY project and point to ―Active Build Configuration and select ―Release as shown in the below screenToBuildProject right click on DISPLAY project and selectBuild Project.

Click ―Build Console view to check for any errors as shown in the below figure. If your project has built successful display.hex will be created.

If there are any errors in the project ―Build Console view will display the error messages and from Build Output view you can check the location of errors in your code. When you build the project, the display.hex is generated




Select the Release mode & Build your

Project




SWITCH ON THE POWER SUPPLY OF ARM 9 SINGLE BOARD COMPUTER

Output on HyperTerminal Open Triton IDE; from TOOLS menu, click Hyper terminal and set the Baud

rate as 38400

Set baud rate as 38400 for

HyperTerminal output




Typelsto check the list of files, then pressenter

Typecd /var/lib/tftpboot, then press enter©T.M.Baskar [email protected]



Typels, then press enter




Enter your system IP address. Typeping 192.168.0.12, then press enter

To stop the running process, pressCONTROL+C To Create a new file in Linux, type touch <your filename>. This

command creates an empty file. touch display.out Then press enter

Type ls, then press enter It creates your file name display.out

To change the file permission to read/write & execution operation , Type chmod 777 display.out then press enter & type ls, then press enter.

(To get permission to receive/execute the file from your ARM9 EMB linux OS)It shows the output file name–display.out

Go to Start. Go to Run mode Open the command prompt

TypeOasis\ide\workspace, then press enter

Typec:\windows\system32\ping 192.168.0.240,then press enter

Typecd displaythencd release, then press enter

Typedirto check your output file, then press enter

Type c:\windows\system32\tftp –i 192.168.0.240 put display.out, then press




enter Minimize the run mode and open the HyperTerminal window

Type ./display.out then enter, you will see the output message on hyper terminal window










RESULT:

We create the open source software in C/C++ and implement to the ARM9 Linux Boot Shell with simple printing our message in Linux kernel. We are able to create source codes for Mutex, Semaphore, Fork, Pipes, Message Send & Receiving and Socket Server Programming, etc.,. (Refer: Appendix A)



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGEXPERIMENT 2:High level language programming (C, C++) and porting it on a processor.

Aim: To implement the I/O Porting using the external peripheral devices in ARM7 Processor (UART, STEPPER MOTOR, Graphical LCD Display, LED Display, SEVEN SEGMENT Display, KEYPAD, ADC/DAC, SD/MMC, I2C, SPI, I2S, CAN, LIN, USB, PCI, Ethernet).TYPE OF PROTOBOARD USED: Spirit-II / Voyager II ARM-7 ProtoboardHOW TO START WITH TRITON IDE

Double click on the icon-Triton on your Desktop Select the workspace in which you can create all your projects as shown in the figure below. Click OK.

Triton IDE C/C++ Environment opens as shown in below figure in which you can create new project, open existing one etc.

Selectworkspace

&Click OK

To create new project go to Project menu



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGThen clickProject New C Project.You will get below figure.

SelectNew

C project

In the Project Name field, type name of the project asLED. Do not use spaces orspecial characters in the project name.

Select the Target as per the board you have. i.e.ARM7 Select the Variant from the variant list. i.e.LPC2148

Select Operating System as per your requirement. Here we should select NONE as the operating system

Select the Port from Port field. i.e.COM1 Select the Baud Rate from dropdown list.i.e.38400 Select the Build options as ROM, Download options as ISP Utility, Debug as

MONITOR. You can also change the location of project. For that, uncheck ‗use default location‘ and then browse your location.

Check Create Project Using Template. then click NEXT ©T.M.Baskar [email protected]



Below screen will appear, select Debug and Release configurations. Select the type of project that you want to build. By default Project Type is

Executable (Gnu) Debug-Project can be debugged on target board using serial JTAG and Ethernet Release-Project is run on Target board without debugging Uncheck the debug and click FINISH The project is created and opened in the IDE. You should see the following

components: The Projects window contains a tree view of the components of the project,

source files and file properties. o The Source Editor window with a file called LED_main.c open.

You can enter the code in the LED_main.c file, by replacing the line://TODO: You can write your code at here

You can double click theLED_main.c tabin the Editor view to expand the view.Save the LED_main.c by choosing File > Save. You will notice an asterisk in front of the file name on the tab in the Editor view (Workspace). The asterisk indicates that the file has changed, but has not been saved. So, save the file for every modification in the program.



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGTo compile project you need to select Release mode. Debug mode: This creates an executable hex file which you, after downloading on the target board, is able to step-by-step debugging.

Release mode: This creates an executable hex file which you can download on the target board but you won‘t be able to debug.

Enter thevarious fields &Click NEXT




Uncheckdebug

mode &

Enter yourProject

Code here

To build project in Release mode----Right click on the LED project and point to Active Build Configuration



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGandselect Release as shown in the below screen.

Select the Release mode & Build your

Project

ToBuildProject right click on LED project and selectBuild Project.

Open the build console view to check for any errors as shown in the



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGbelowfigure.

If your project has built successful, LED.hex will be created. If there are any errors in the project, ―Build Console view will display the error messages and from Build Output view you can check the location of errors in your code. When you build the project, the led.hex is generated. You can see where the new file is generated by opening the C/C++ Projects view and expanding the LED project node as shown in the following figure.




Here LED.hex file is created which is to be downloaded on target board and run the program. Right click on the LED.hex file generated and click Download as shown below.




Right click the *.hex file &

click DOWNLOAD

Connect the hardware kit with the serial connector and power supply provided. Switch on the hardware kit. Put the switch in ISP mode for the program to be downloaded. Right click on the LED.hex file and download the executable file on to the board. Once, the program is downloaded, shift the mode from ISP to RUN and reset the board to verify the output.

DETAILS OF ON BOARD INTERFACES

Switch S1- Power ON/OFF the board

Switch S2- Reset switch

Switch S7- To select ISP or RUN mode




NAME OF PIN OUTPUT SETTINGS &INTERFACES CONFIGURATION STATUS DESCRIPTIONS

LED & DIPLED (P0.15 to P0.22)

LED-input 8 LED‘s on bySwitch (P0.2 to P0.6)SWITCH Switch-output DIP switch& (P0.8 to P0.10)BUZZER Buzzer (P0.7) Buzzer-output Connect JP8 to

ON /OFF buzzerConnect CN14 (3

RELAY Relay (P1.26) Relay-output pin connector )toON relay

RESULT:

We create and implement the simple I/O Porting with LEDs using the GPIO ports in ARM7 Processor. We are able to create and I/O porting of the peripherals likes LED & DIP- SWITCH, BUZZER, and RELAY.



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGEXPERIMENT 3:Create FSM of a typical application and implement on an FPGA.

AIM: To create the Finite State Machine for Traffic Light Controller and implement using Xilinx Spartan 3 (XC3S400) FPGA. Traffic Light controller is implemented on FPGA and verified using Traffic Light Interface Module. There are simple rules for traffic lights on one node, and complex ways of regulating a whole infrastructure of them. It is necessary to adjust general algorithms.Spartan-3 - IM includes a TRAFFIC LIGHT Interface Module. This module is interfaced to the Trainer using 60 pin FRC cable.

DESIGN DESCRIPTION:-

Initially all Red Lights will be ―ON (South, West, North, East, Pedestrian) Green Lights will be ―ON , Right, Left & Straight paths are free for Traffic.

Yellow Phase will be ON, respective left & pedestrian paths are free for traffic. Same flow is repeated for all four paths. (South, west, north, east).

Flowchart:-




Algorithm is implemented in VERILOG with a 13 state Finite State Machine. Refer Fig

Fig: State Diagram for Traffic Light ControllerAbbreviation used:

South West

PSG – Pedestrian South Green PWR – Pedestrian West Red

PSR – Pedestrian South Red PWG – Pedestrian West Green

RS – Right South RW – Right West

LS – Left South LW – Left West

SS – Straight South SW – South West

YS – Yellow South YW – Yellow West

REDS – Red South REDW – Red West




North East

PNR- Pedestrian North red PEG – Pedestrian East green

PNG – Pedestrian North green PER – Pedestrian Ease Red

RN – Right North RE – Right East

LN – Left North LE – Left East

SN – Straight North SE – Straight East

YN - Yellow North YE – Yellow East

REDN – Red North REDE – Red East

EXPERIMENTAL SET UP:

Figure shows the Traffic Light Interface to SPARTAN-3 FPGA



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGG Description of above Code:To Start the Traffic light controllerInitially the Red light of all the directions is ON.

Traffic starts from the South Direction; hence the green light of South direction goes ON. The signals that are ON, now are :- TRC_LS (left south) –‗1‘. TRC_RS (right south) –‗1‘. TRC_SS (straight south) –‗1‘. TRC_LE (left east) –‗1‘. TRC_REDW (red west) –‗1‘. TRC_REDN (red north) –‗1‘. TRC_REDE (red east) –‗1‘. TRC_PSG (pedestrian south red) –‗1‘. TRC_PWG (pedestrian west red) –‗1‘. TRC_PNG (pedestrian north red) –‗1‘. TRC_PEG (pedestrian east red) –‗1‘. Similarly when Yellow light of South direction is ON then the signals that are ON now areTRC_LS (left south) –‗1‘. TRC_YS (yellow south) –‗1‘. TRC_LE (left east) –‗1‘. TRC_REDW (red west) –‗1‘. TRC_REDN (red north) –‗1‘. TRC_REDE (red east) –‗1‘. TRC_PSR (pedestrian south red) –‗1‘. TRC_PWR (pedestrian west red) –‗1‘. TRC_PNR (pedestrian north red) –‗1‘. TRC_PER (pedestrian east red) –‗1‘. Similarly when Red light of South direction is ON then the signals that are ON now areTRC_LS (left south) –‗1‘. TRC_REDW (red west) –‗1‘. TRC_REDN (red north) –‗1‘. TRC_REDE (red east) –‗1‘. TRC_PSR (pedestrian south red) –‗1‘. TRC_PWR (pedestrian west red) –‗1‘. TRC_PNR (pedestrian north red) –‗1‘. TRC_PER (pedestrian east red) –‗1‘.

During this time all ways are Blocked for 1 second except left south ( ls -‗1‘ ) and so on. After that it goes clockwise for all Direction (i.e.:- South then West then North then East) similarly.




HOW TO START WITH Xilinx ISE[XILINX ISE 9.1 is preferred for low configuration PCs]

Double click on the icon-Xilinx ISE 9.1ion your

Desktop(or)

Start---All Programs---Xilinx ISE 9.1i---Project Manager




WORKSPACE

SOURCEWINDOW

TRANSCRIPT

PROCESSWINDOW

Create a new ISE project which will target the FPGA device on the Spartan-3 IM demo board.To create a new project:1. Select File > New Project... The New Project Wizard appears. 2. Type tutorial in the Project Name field.3 Enter or browse to a location (directory path) for the new project. A tutorial subdirectory is created automatically.Verify that HDL is selected from the Top-Level Source Type list. Click Next to move to the device properties page.

Enter the Project Name and Location , then click NEXT




6. Fill in the properties in the table as shown

below: ♦Product

Category: All

♦Family: Spartan3

♦Device: XC3S400

♦Package: PQ208

♦Speed Grade: -4

♦Top-Level Source Type: HDL♦Synthesis Tool: XST (VERILOG/Verilog)♦Simulator: ISE Simulator (VERILOG/Verilog)♦Preferred Language: Verilog (or VERILOG)

Verify that ―Enable Enhanced Design Summary is selected. Leave the default values in the remaining fields. Clicknextto proceed to the Create New Source window in the New ProjectWizard. At the end of the next section, your new project will be complete.




Create an HDL SourceIn this section, you will create the top-level HDL file for your design. Determine the language that you wish to use for the tutorial. Then, continue either to the ―Creating a VERILOG Source section below, or skip to the ―Creating a Verilog Source section.Creating a Verilog Source

Create the top-level Verilog source file for the project as follows:Click New Source in the New Project dialog box. Select Verilog Module as the source type in the New Source dialog box. Type in the file name counter. Verify that the Add to Project checkbox is selected. Click Next.



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGDeclare the ports for the counter design by filling in the port information as shown below:

7. Click next, and then Finish in the New Source Information dialog box to complete the new source file template.8. Click Next, then Next, then Finish.Creating a VERILOG SourceCreate a VERILOG source file for the project as follows:Click the New Source button in the New Project Wizard. Select VERILOGModule as the source type. Type in the file name counter. Verify that the Add

to project checkbox is selected. Click Next. Declare the ports for the counter design by filling in the port information as shown below:



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGG7. Click next, and then Finish in the New Source Wizard - Summary dialog box to complete the new source file template.8. Click Next, then Next, then Finish.The source file containing the entity/architecture pair displays the Workspace, and the counter displays in the Source tab, as shown below:Click on the symbol of FPGA device ,then right click to select New source Write the VERILOG code in VERILOG editor



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGTesting the Traffic Controller design on the FPGA board

Once design is synthesized successfully it is ready to be implemented on FPGA.

Step 1: The first step for implementation is to generate constraint file. The constraint file specifies the FPGA pins used for accessing the design.

Step 2: To create new UCF file. Right click on the device name and select NEW SOURCE Select

IMPLEMENTATION CONSTRAINT FILE in NEW SOURCE WIZARD and give suitable name for the Project. Click NEXT for the DEFINE MODULE

Window.Step 3: Click on the UCF File (Traffic_Light.ucf) and Select the Edit Constraints (Text). Write the constraint file as shown in figure below. For implementing your design, from the source window select ―Generate Programming File from the process menu

Step 4: Procedure for downloading using iMPACT Boundary Scan Mode

Right click on ―Configure Device (iMPACT) -> and Say RUN or Double click on ―Configure Device (iMPACT) .

Right click in workspace and select ―Initialize chain .The device is seen.

Right click on the device and select ―Program .

RESULT:

We had done the Finite State Machine for Traffic Light Controller and implement using Xilinx Spartan 3 (XC3S400) FPGA.




EXPERIMENT 4:Application development, download partition between FPGA and ARM on Performance characteristics.

AIM: To create and analyze performance between ARM and FPGA Processor application using a simple 4-bit counter program.TYPE OF PROTOBOARD USED: Herculis ARM-FPGA Fusion BoardPROCEDURE:

1. Create and Generate the Hex file for 4 bit Counter C / C++ program with Triton IDE. /************************************************************

ARM_Counter.c************************************************************/

#define ALL 0x00FF0000 #define ALL 0x00FF0000 #include<LPC21xx.h>void delay (unsigned int); int main(void){

*IODIR0=0x00002000; *IODIR1=0x00FF0000; *IOCLR1=0x00FF0000; *IOSET1=0x00FF0000; *IOCLR0=0x00002000; //*IOSET0=0x00002000;while(1){*IOSET1=0x00010000; //1 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00040000; //2 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00050000; //3 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00020000; //4 delay(400000);*IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00060000; //5 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00030000; //6 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00070000; //7 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00080000; //8 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00090000; //9



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGdelay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000c0000; //10 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000a0000; //11 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000b0000; //12 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000d0000; //13 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000e0000; //14 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x000f0000; //15 delay(400000); *IOCLR1=0x00FF0000; delay(150000); *IOSET1=0x00000000; //16 delay(400000); *IOCLR1=0x00FF0000; delay(150000);

delay(400000);}

return 0;}void delay(unsigned int count){

while(count!=0) count--;

}2. Download the ARM_Counter.Hex file into ARM+FPGA Fusion

Board and RUN the file. 3. In that , ARM7‘s LED outputs are connected with Output LED

LD8 to LD11 4. Create and Generate the Bit file for 4 bit Counter in VHDL program

with Xilinx ISE. /************************************************************

FPGA_Counter.vhd************************************************************/

library IEEE;use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL;use IEEE.STD_LOGIC_UNSIGNED.ALL;entity fpga_counter is

Port ( RESET : in STD_LOGIC; CLK_4M : in STD_LOGIC;COUNTER : out STD_LOGIC_VECTOR (4 downto

0)); end fpga_counter;architecture Behavioral of fpga_counter isSIGNAL CLKDIV : STD_LOGIC_VECTOR(30 DOWNTO 0);SIGNAL CNTR : STD_LOGIC_VECTOR(4 DOWNTO 0);SIGNAL en0,en1,en2,en3 : STD_LOGIC;begin



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGPROCESS(RESET,CLK_4M)BEGINIF(RESET = '1') THENCLKDIV <= (OTHERS =>'0');

ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THENCLKDIV <= CLKDIV + '1';

END IF;END PROCESS; PROCESS(RESET,CLK_4M,clkdiv) BEGIN

IF(RESET = '1') THEN en1 <= '0';

en2 <= '0';

ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THEN en1 <= CLKDIV (20);

en2 <= en1; END IF;END PROCESS;en0 <= en1 and (not en2); PROCESS(RESET,CLK_4M,en0) BEGINIF(RESET = '1') THEN

CNTR <= (OTHERS =>'0');

ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THEN IF(en0 = '1')THENCNTR <= CNTR

+ '1'; END IF;

END IF;END PROCESS;COUNTER <= CNTR;end Behavioral;

--------------------------------------------------------UCF File for ARM+FPGA Fusion Board

--------------------------------------------------------net "CLK_4M" loc = "p79";net "RESET" loc = "p113";net "COUNTER<0>" loc = "p61";net "COUNTER<1>" loc = "p63";net "COUNTER<2>" loc = "p64";net "COUNTER<3>" loc = "p62";

5. Download the FPGA_Counter.bit file in to ARM+FPGA Fusion Board.

6. Now check the FPGA Counter output in LD1 to LD4 and verify the ARM and FPGA Counter delay variations.



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGRESULT:

We create and analyze performance between ARM and FPGA Processor with 4-bit counter application by Xilinx ISE and Triton. Then, verify the speed and performance of Counter on ARM+FPGA Fusion Board. We able to create applications like UART and RTC based application on Fusion Board similarly.



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGEXPERIMENT 5:Application development & Hardware and Software Partitioning.

AIM: To Partition the FPGA using SOC concept and implement a simple 4-bit Counter program with a Embedded CoreTYPE OF PROTOBOARD USED: ―Herculis ARM-FPGA Fusion BoardIntroduction

This lab guides you through the process of using Xilinx Platform Studio (XPS) to create a simple processor system. An MHS file and design netlists will be created.

ObjectivesAfter completing this lab, you will be able to:

Create an XPS project by using Base System Builder (BSB)

Create a Counter hardware design by using Xilinx IPs available in the Embedded Design Kit

ProcedureThe purpose of the lab exercises is to walk you through a complete hardware and software processor system design. Each lab will build upon the previous lab.

In this lab, you will use the BSB of the XPS system to create a processor system consisting of the following processor IP:

Microblaze DCM OPB bus

OPB BRAM controller BRAMGPIO LEDs for displaying results

Figure 1-1. Processor IP

This lab comprises three primary steps: You will create a project using Base System Builder, analyze the project created, and generate the processor system netlists. Below each general instruction for a given procedure, you will find accompanying step-by-step directions and illustrated figures providing more detail for performing the general instruction. If you feel confident about a specific instruction, feel free to



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGskip the step-by-step directions and move on to the next general instruction in the procedure.

Open the Project Step 1

Launch Xilinx Platform Studio (XPS) and create a project file in D:/mb/ by using Base System Builder. Select the Microblaze processor, the processor clock frequency as 32 MHz, the bus clock frequency as 32 MHz, and no debug interface.1. Open XPS by selecting Start Programs Xilinx PlatformStudio 8.1i Xilinx Platform Studio

! Do not select Platform Studio SDK; this opens the Software Development Kit IDE.

2. Select Base System Builder Wizard and Click Ok

Figure 1-2. New Base System Builder-Based Project Creation

This opens the Create New Project Using Base System Builder Wizard dialog box.




Figure 1-3. Create New Project Using Base System Builder Wizard Dialog Box

Specify the Project File as D:/mb/system.xmp and click <OK> Select the ―I would like to create a new design option Click Next to display the Select Board dialog box. Select I would like to

create system for Custom board.

Figure 1-4. Select I would like to create a system for custom board

Click Next to display the Select Processor dialog box Choose the FPGA device configuration




Figure 1-5. Select Processor Dialog Box

Select Microblaze as the processor , spartan3 as a architecture, xc3s400 as device, PQ208 as a package, -4 as a speed grade.

Click Next to display the Configure Microblaze dialog box. Specify settings to match the following: Reference Clock Frequency: 4MHz

This the external clock source on the board you are using. This clock will be used to generate the processor and bus clocks. The values allowed may depend on the FPGA or board you are using because certain on-chip resources (DCMs) may be required to perform clock division or multiplication.

Processor Bus Clock Frequency: 4 MHz Reset polarity – Active High Debug Interface: No debug Local memory (data and instruction) – 8kB Cache setup – No cache




Figure 1-6. Configure Microblaze Dialog Box

Select LEDs as the external device.Click Next to display the Configure IO Interfaces dialog box. Click on add device and select the GPIO option in IO interface type. Select LEDS under Device tab and click OK. Select 4 under GPIO Data width tab and leave the remaining parameters with the default settings. Refer to Figure 1-7. Note that the number of peripherals that appear on each window will depend on the resolution of your monitor.

Figure 1-7. Configure IO Interfaces Dialog Box




Click <Next> to display the Add Internal Peripherals dialog box. At this point you could click Add Peripheral to add additional internal peripherals.

Figure 1-8. Add Internal Peripherals Dialog Box

12. Click <Next> to display the Software Configuration dialog box

Figure 1-9. Software Configuration Dialog Box

13. Click <Next> to view the memory configuration options




Figure 1-10. Configure Memory Test Application

Click Next to display the System Created dialog box which summarizes the system being created. Note that the address map for the peripheral may differ.

Figure 1-11. System Created Dialog Box

15. Click GenerateA congratulations dialog box appears, indicating the files that BSB has created.Click Finish to finish generating the project

Click <OK> when the Next Step dialog appears




Analyze the Created Project Step 2

Under the Project tab, study the created project files and view the project in block diagram view.

Figure 2-1.

Under the XPS Project tab, click on Generate and view Block Diagram to open a block diagram view Observe the various components that are used in the design




Figure 2-2. Block Diagram View of the Generated Project

You will see the Microblaze processor, dlmb_if_cntlr, ilmb_if_cntlr connected to the Microblaze processor side. Notice that the opb_gpio LEDs, opb_gpio LEDs_1 are connected to the opb bus.

1. Right-click the LEDs block in system assembly view and click on configure IP, go through the various fields, and



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGcomplete the following:

Base address:High address:GPIO Data Bus Width:Channel 1 is bidirectional:

Channel 1 is input only:

2. Why do you think that the DCM_module instances do not have connections to any of the other blocks in the design?

________________________________________________

________________________________________________

Notice that you can change the parameters (such as base address, address range, or C_BAUDRATE) here to reflect the design specifications.

Close the block diagram view without saving any changes The block diagram viewer is useful for viewing the overall system and bus connectivity. For more detail, you will utilize other tools.

Generate the Hardware Netlists Step 3

Using PlatGen, generate the hardware netlist.21. Open MHS file and change the following linesPORT fpga_0_LEDS_GPIO_d_out_pin = fpga_0_LEDS_GPIO_d_out, DIR = 0, VEC = [0:3]ToPORT fpga_0_LEDS_GPIO_d_out_pin = fpga_0_LEDS_GPIO_d_out, DIR = 0, VEC = [3:0]And save the changes.22. In XPS, select hardware Generate Netlist or click in the

toolbarObserve the netlist generation in the console window as the generation

progresses

24. Open Windows Explorer by selecting Start ProgramsAccessories Windows Explorer

Browse to the mb project directory

Several directories containing VHDL wrappers and implementation netlists have been created.

3. List the directories that were created.

Generate the Hardware Bitstream Step 4




In project information area, Select Project, open UCF file by double clicking over it given in Project Files. Enter the pin constraints and uncomment them. The dedicated ucf is provided at the end of this document.

27. In XPS, select hardware Generate Bitstream.Observe the bitstream generation in the console window as the

generation progresses

Generate the Software Libraries Step 5

In XPS, select software Generate Libraries and BSPs. Observe the Libraries generation in the console window as the

generation progresses Observe the xparameters.h file created in the testapp_memory under

applications tab

Writing C code Step 6



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGIn XPS, under Application tab, select Project: Testapp_memory

open TestApp_Memory.c. Write the C code application in the workspace. Source code for this project is given at the end of this document.

35.In XPS, select software Build all users applications.36.Observe the elf file generation in the console window as the

generation progresses.37.Create and Generate the Bit file for 4 bit Counter in VHDL program with

Xilinx ISE.

/************************************************************FPGA_Counter.vhd

************************************************************/library IEEE;use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL;use IEEE.STD_LOGIC_UNSIGNED.ALL;entity fpga_counter is

Port ( RESET : in STD_LOGIC; CLK_4M : in STD_LOGIC;COUNTER : out STD_LOGIC_VECTOR (8 downto 0));

end fpga_counter;architecture Behavioral of fpga_counter is

SIGNAL CLKDIV : STD_LOGIC_VECTOR(30 DOWNTO 0);SIGNAL CNTR : STD_LOGIC_VECTOR(4 DOWNTO 0);SIGNAL en0,en1,en2,en3 : STD_LOGIC;



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGbeginPROCESS(RESET,CLK_4M) BEGINIF(RESET = '1') THEN CLKDIV

<= (OTHERS =>'0');ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THEN CLKDIV <= CLKDIV + '1';

END IF;END PROCESS; PROCESS(RESET,CLK_4M,clkdiv) BEGIN

IF(RESET = '1') THEN en1 <= '0';

en2 <= '0';

ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THEN en1 <= CLKDIV (20);

en2 <= en1; END IF;END PROCESS;en0 <= en1 and (not en2); PROCESS(RESET,CLK_4M,en0) BEGIN

IF(RESET = '1') THEN CNTR <= (OTHERS =>'0');

ELSIF(CLK_4M'EVENT AND CLK_4M = '1')THEN IF(en0 = '1')THENCNTR <= CNTR + '1';

END IF;END IF;END PROCESS;COUNTER <= CNTR;end Behavioral;--------------------------------------------------------UCF File for ARM+FPGA Fusion Board--------------------------------------------------------net "CLK_4M" loc = "p79";net "RESET" loc = "p113";net "COUNTER<0>" loc = "p61";net "COUNTER<1>" loc = "p63";net "COUNTER<2>" loc = "p64";net "COUNTER<3>" loc = "p62";net "COUNTER<4>" loc = "p58";net "COUNTER<5>" loc = "p57";net "COUNTER<6>" loc = "p54";net "COUNTER<7>" loc = "p52";

38.In ISE, select Device Configuration update Bitstream to generate thedownload.bit file

Downloading into FPGA Step 7




39.Open Impact software by selecting Start Programs Xilinx ISE9.1i Accessories iMPACT.

40.Impact project dialog box will open. Select create a new project (.ipf) option and click on OK. This will open Welcome to iMPACT dialog box.

41.Keep the default setting Configure devices using Boundary-Scan [JTAG]. Click on Finish. This will identify the device xc3s400.




In the Assign New Configuration File, select the download.bit file from implementation directory of your ISE project. Click on Open. The download.bit file will be assigned to the FPGA. Right click on the device and Click on Program to configure the FPGA with download.bit file. Download the download.bit file in to ARM+FPGA Fusion Board. Now check the FPGA Counter output in LD1 to LD4 for software-hardware partitioned output ie., through embedded core of FPGA and LD5 to LD8 for direct FPGA output.

Base System Builder can be used in XPS to create a project. Several files—including an MHS file representing the processor system and a PBD file representing the schematic view—are created. After the system has been defined, the netlist of the processor system can be created.Answers

Right-click the top LEDS block, configure IP and go through the ©T.M.Baskar [email protected]


DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGvarious fields, and complete the following:

Instance name: LEDSBase address: 0x40020000High address: 0x4002ffffGPIO Data Bus Width: 4Channel 1 is bidirectional: FALSEChannel 1 is Input only: FALSEWhy do you think that the DCM_module instance does not have connections to any of the other blocks in the design? This module generate signals which are area connected to almost every module in the design. For example, the clock signal generated by DCM_module is connected to the processor and opb controller.

3. List the directories that were created. data

etc hdlimplementation pcoresmb_0 synthesis

TestApp_Memory __xps

B Completed MHS File

PARAMETER VERSION = 2.1.0PORT fpga_0_LEDS_GPIO_d_out_pin = fpga_0_LEDS_GPIO_d_out, DIR = O,

VEC = [3:0]PORT sys_clk_pin = dcm_clk_s, DIR = I, SIGIS = DCMCLK PORT sys_rst_pin = sys_rst_s, DIR = IBEGIN microblazePARAMETER INSTANCE = microblaze_0PARAMETER HW_VER = 4.00.aPARAMETER C_USE_FPU = 0BUS_INTERFACE DLMB = dlmbBUS_INTERFACE ILMB = ilmbBUS_INTERFACE DOPB = mb_opbBUS_INTERFACE IOPB = mb_opbPORT CLK = sys_clk_sENDBEGIN lmb_v10PARAMETER INSTANCE = ilmbPARAMETER HW_VER = 1.00.aPARAMETER C_EXT_RESET_HIGH = 1PORT SYS_Rst = sys_rst_sPORT LMB_Clk = sys_clk_sENDBEGIN lmb_v10



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGPARAMETER INSTANCE = dlmbPARAMETER HW_VER = 1.00.aPARAMETER C_EXT_RESET_HIGH = 1PORT SYS_Rst = sys_rst_sPORT LMB_Clk = sys_clk_sENDBEGIN lmb_bram_if_cntlrPARAMETER INSTANCE = dlmb_cntlrPARAMETER HW_VER = 1.00.bPARAMETER C_BASEADDR = 0x00000000PARAMETER C_HIGHADDR = 0x00001fffBUS_INTERFACE SLMB = dlmbBUS_INTERFACE BRAM_PORT = dlmb_portENDBEGIN lmb_bram_if_cntlrPARAMETER INSTANCE = ilmb_cntlrPARAMETER HW_VER = 1.00.bPARAMETER C_BASEADDR = 0x00000000

PARAMETER C_HIGHADDR = 0x00001fffBUS_INTERFACE SLMB = ilmbBUS_INTERFACE BRAM_PORT = ilmb_portENDBEGIN bram_blockPARAMETER INSTANCE = lmb_bramPARAMETER HW_VER = 1.00.aBUS_INTERFACE PORTA = ilmb_portBUS_INTERFACE PORTB = dlmb_portENDBEGIN opb_v20PARAMETER INSTANCE = mb_opbPARAMETER HW_VER = 1.10.cPARAMETER C_EXT_RESET_HIGH = 1PORT SYS_Rst = sys_rst_sPORT OPB_Clk = sys_clk_sENDBEGIN opb_gpioPARAMETER INSTANCE = LEDSPARAMETER HW_VER = 3.01.bPARAMETER C_GPIO_WIDTH = 4PARAMETER C_IS_DUAL = 0PARAMETER C_ALL_INPUTS = 0PARAMETER C_IS_BIDIR = 0PARAMETER C_BASEADDR = 0x40020000PARAMETER C_HIGHADDR = 0x4002ffffBUS_INTERFACE SOPB = mb_opbPORT OPB_Clk = sys_clk_sPORT GPIO_d_out = fpga_0_LEDS_GPIO_d_outENDBEGIN dcm_modulePARAMETER INSTANCE = dcm_0PARAMETER HW_VER = 1.00.aPARAMETER C_CLK0_BUF = TRUE



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGPARAMETER C_CLKIN_PERIOD = 31.250000PARAMETER C_CLK_FEEDBACK = 1XPARAMETER C_DLL_FREQUENCY_MODE = LOWPARAMETER C_EXT_RESET_HIGH = 1PORT CLKIN = dcm_clk_sPORT CLK0 = sys_clk_sPORT CLKFB = sys_clk_sPORT RST = net_gndPORT LOCKED = dcm_0_lockEND

C Completed .ucf File

Net sys_clk_pin LOC=p181; Net sys_rst_pin LOC=p182; ## System level constraintsNet sys_clk_pin TNM_NET = sys_clk_pin;

TIMESPEC TS_sys_clk_pin = PERIOD sys_clk_pin 250000 ps; Net sys_rst_pin TIG;## IO Devices constraints#### Module LEDS constraintsNet fpga_0_LEDS_GPIO_d_out_pin<0> LOC=p58;Net fpga_0_LEDS_GPIO_d_out_pin<1> LOC=p61;Net fpga_0_LEDS_GPIO_d_out_pin<2> LOC=p62;Net fpga_0_LEDS_GPIO_d_out_pin<3> LOC=p63;

D

Completed .c File

#include "xparameters.h" #include "xutil.h" #include "xio.h" #include "xgpio_l.h" main (){long count = 0, i; while(1){XGpio_mSetDataReg(XPAR_LEDS_BASEADDR, 1, count); count = count + 1;for(i=0; i<10000000; i++);}}RESULT:

We create an embedded core through software partitioning of the actual hardware and implement a simple 4-bit counter application by Xilinx EDK Tool. Then verify the speed and performance of Partition on FPGA processor. In these Xilinx EDK, performs many kind of processing in Partitioning.




EXPERIMENT 6:Implementation of a wireless communication protocol on an embedded systemAIM: To implement wireless communication protocol (like. ZigBee / Bluetooth / RF) on an Embedded System.

PROCEDURE FOR ZIGBEEAim: To Interface a ZigBee module with ARM7TYPE OF PROTOBOARD USED:Spirit-II/Voyager-II ARM-7 Protoboard – 2 NosZigbee Transceiver Pair - 1 PairTheory of Operation: Zigbee is a specification for a suite of high level communication protocols using small, low powered digital radios based on IEEE 802.15.4-2003 standard and are used extensively for Wireless Home Area Networks (WHANs), such as wireless light switches with lamps, electrical meters with in-home displays etc. ZigBee is targeted towards at RF applications that require a low data rate, long battery life and secure networking.Procedure and Observation:

1. Open Triton IDE. 2. Select a workspace and create a new Project ZIGBEE_LPC2148 3. Write in the program for ZIGBEE_LPC2148 as provided in the

Documentation CD and ignore step 3 or else click File menu -> Add Project ->Existing Project into Workspace and click next.

4. If importing project browse the Documentation CD and select ―ZIGBEE_LPC2148 and also check option ―Copy projects into workspace and click finish.

5. Save the file, build the Project in Release Mode and generate hex file (ZIGBEE_LPC2148.hex)

6. Download the hex file to ARM7 Board. 7. Disconnect ARM7 UART1 from the PC‘s COM port.

8. Connect the ZigBee module to ARM7 board using the provided male to male serial cable.

9. Attach USB A to B cable between PC‘s USB port and the USB connector on ARM7 Processor add-on board.

10.Repeat steps 6, 7, 8 and 9 for another ARM7 board.Slide RUN/ISP switch into Run mode and press momentarily.Once the initialization is over type anything into one hyper terminal and that will be visible in the other hyper terminal.




RESULT:We interfaced two ZigBee modules to two separate ARM7 protoboards

and established communication between them. These ZigBee modules can be configured in various Network Topologies and are a drop-in replacement wireless application such as Home Automation and Wireless Sensor Networks. (Refer Appendix C)

B) PROCEDURE FOR BLUETOOTH

Aim: To Interface a Bluetooth connected to ARM7 with a ComputerTYPE OF PROTOBOARD USED:Spirit-II/Voyager-II ARM-7 Protoboard – 1 No.Bluetooth Interface Module with dongle - 1 No.Theory of Operation: Conceived by Ericsson in 1994 as a wireless replacement to RS232 bluetooth today is a wireless technology for exchanging data over short distances (using short wavelength radio transmissions) and creating PANs (Personal Area Networks) with high levels of security. Utilizing the frequency hopping spread spectrum the modulation details of which are as under

Basic data rate 1Mbit/s GFSK (Gaussian Frequency ShiftKeying)Extended Rate 2 Mbit/s π/4 DPSK (Differential Phase ShiftKeying)Extended Rate 3 Mbit/s 8 DPSK (Differential Phase Shift Keying)

Procedure and Observation:Open Triton IDE. Select a workspace and create a new Project Bluetooth_LPC2148

1. Write in the program for Bluetooth_LPC2148 as provided in the Documentation CD and ignore step 3 or else click File menu -> Add Project ->Existing Project into Workspace and click next. 2. If importing project browse the Documentation CD and select .Bluetooth_LPC2148 and also check option ―Copy projects into workspace and click finish. Save the file, build the Project in Release Mode and generate hex file (Bluetooth_LPC2148.hex) Download the hex file to ARM7 Board and Disconnect ARM7 UART1 from the PC‘s COM port. 3. Connect the Bluetooth module to ARM7 board using the provided male to male serial cable. Attach USB A to B cable between PC‘s USB port and the USB connector on ARM7 Processor add-on board. Slide RUN/ISP switch into Run mode and press momentarily and Power on the bluetooth addon board.If Computer finds a new device and asks for drivers browse and upload the drivers for this cable provided in the Documentation CD.4. Check the virtual COM port number on device manager.Open a



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGHyper terminal with the found COM port number and select baud rate as 115200.5. Connect the provided USB Bluetooth Dongle to any of the Computer‘s free USB port.Wait for the automatic installation of the bluetooth software.Double click the bluetooth icon visible in the system tray and use the software for searching and connecting to the bluetooth module.6. If asked for a passkey the default passkey is 8888.When connected open the device manager to again see the assigned outgoing COM port number.Open hyper terminal for the COM port and type anything. This will be visible on another HT.

RESULT:File transfer between a PC and ARM7 Protoboard through Bluetooth

Interface is studied.C) PROCEDURE FOR RF MODULE

Aim: To interface a RF Module to ARM7 Processor.TYPE OF PROTOBOARD USED:Spirit-II/Voyager-II ARM-7 Protoboard – 2 NosRF Transceiver Pair - 1 PairTheory of Operation: In this exercise we establish communication between two RF modules from Nordic Semiconductors. These modules work in the ISM band of 2.4 GHz and have a SPI interface through which they are controlled and configured. Being a transceiver they establish full duplex communication. Communication between ARM7 and RF module are also of two types. They are command mode and data mode. In command mode we tell the module that we will be using it as a transmitter or receiver etc. In data mode we either send or receive data depending on the operating mode.Procedure and Observation:

1. Open Triton IDE. 2. Select a workspace and create a new Project

nordic_rf24l01p_LPC2148 3. Write in the program for nordic_rf24l01p_LPC2148 as provided in

the Documentation CD and ignore step 3 or else click File menu -> Add Project ->Existing Project into Workspace and click next.

4. If importing project browse the Documentation CD and select

―nordic_rf24l01p_LPC2148 and also check option ―Copy projects into workspace and click finish.

5. Now open file nordic_rf24l01p_LPC2148_main.c and scroll to line number 16

6. Assign values to NRF24l01_MODE_TX as 1 and to



DEPARTMENT OF ELECTRONICS & COMMUNICATION ENGGNRF24l01_MODE_RX as 0 so that it looks like for Transmitter

Enable. #define NRF24l01_MODE_TX 1#define NRF24l01_MODE_RX0

7. Save the file, build the Project in Release Mode and generate hex file (nordic_rf24l01p_LPC2148.hex)

8. Download the hex file to ARM7 Board. 9. Reverse the assigned values for NRF24l01_MODE so that they look

like for Receiver Enable. #define NRF24l01_MODE_TX 0#define NRF24l01_MODE_RX1

10.Repeat step 7.ownload into another ARM7 board and not the one to which we had downloaded earlier. Connect two separate RF modules to these two ARM7 boards to their appropriate connectors. One ARM7 board will act as a transmitter and the other as a receiver. Connect these two boards to two different computers and open HyperTerminal in each one of them at baud rate 115200.14.Slide RUN/ISP switch into Run mode and press momentarily.15.Both these Hyper Terminals will give some initialization prints and at

the end will tell the operating mode in which they are configured.16.The board that is in Tx mode will ask for characters to send after

initialization as completed. Type in anything and that will be visible on the hyper terminal connected on other board.

RESULT:File transfer between a PC and ARM7 Protoboard through an ISM band 2.4 GHz

RF module pair over SPI is studied. This interface can be used in applications like Remote Monitoring, Wireless data transfer, Wireless Sensor Networks etc.




Appendix ASample Linux Programs for ARM-9 :/*************************************************************** Display.c***************************************************************/#include<stdio.h> int main(){

int i = 0; for(;i<5;i++){

printf("\n%d HDL SOLUTIONS...",i);}return 0; }

/***************************************************************Mutex.c

(Thread malfunctioning in File Sharing)***************************************************************/#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <semaphore.h>void *thread_func(void *arg); pthread_mutex_t mutex;#define WORK_SIZE 1024 char warea[WORK_SIZE]; int time_to_exit=0;int main(){

int res; pthread_t thrd;void *thread_res;

res = pthread_mutex_init(&mutex,NULL); // Initialize the mutex if(res != 0){printf("Mutex not initialised\n"); exit(EXIT_FAILURE);

}

res = pthread_create(&thrd,NULL,thread_func,NULL); if(res != 0){

printf("thread creation failed\n"); exit(EXIT_FAILURE);

}

// Start New thread pthread_mutex_lock(&mutex);

printf("\nInput some text. type 'end' to finish\n"); while(!time_to_exit){

fgets(warea,WORK_SIZE,stdin); pthread_mutex_unlock(&mutex); while(1){

pthread_mutex_lock(&mutex); if(warea[0] != '\0'){




pthread_mutex_unlock(&mutex); sleep(1);

}

else{ break;

} }}

pthread_mutex_unlock(&mutex); printf("waiting for thrd to finish...\n"); res = pthread_join(thrd,&thread_res); if(res != 0){

printf("thread join failed\n"); exit(EXIT_FAILURE);

}

printf("Thread joined\n"); pthread_mutex_destroy(&mutex); exit(EXIT_SUCCESS);

}void *thread_func(void *arg){

sleep(1); pthread_mutex_lock(&mutex); while(strncmp("end",warea,3) != 0){

printf("No. of characters = %d \n",strlen(warea) - 1); warea[0] = '\0';pthread_mutex_unlock(&mutex); sleep(1); pthread_mutex_lock(&mutex); while(warea[0] == '\0') {

pthread_mutex_unlock(&mutex); sleep(1); pthread_mutex_lock(&mutex);

} }

time_to_exit = 1; warea[0] = '\0';

pthread_mutex_unlock(&mutex); pthread_exit(0);

}/***************************************************************

Semaphore.c***************************************************************/

#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <semaphore.h>void *thread_func(void *arg); sem_t sem;#define WORK_SIZE 50 char warea[WORK_SIZE];int main(){

int res; pthread_t thrd;void *thread_res;




res = sem_init(&sem,0,0); if(res != 0){

printf("Semaphore not initialised\n"); exit(EXIT_FAILURE);

}res = pthread_create(&thrd,NULL,thread_func,NULL); if(res != 0){

printf("thread creation failed\n"); exit(EXIT_FAILURE);

}

printf("\nInput text: type 'exit' to finish\n"); while(strncmp("exit",warea,3) != 0){

fgets(warea,WORK_SIZE,stdin); sem_post(&sem);

}

printf("waiting for thrd to finish...\n"); res = pthread_join(thrd,&thread_res); if(res != 0){

printf("thread join failed\n"); exit(EXIT_FAILURE);

}

printf("Thread joined\n"); sem_destroy(&sem); exit(EXIT_SUCCESS);

}

void *thread_func(void *arg){

sem_wait(&sem); while(strncmp("exit",warea,3) != 0){

printf("No. of characters = %d \n",strlen(warea) - 1); sem_wait(&sem);

}pthread_exit(NULL);

}

/***************************************************************Pipes.c

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

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main(){FILE *read_fp;

char buffer[BUFSIZ + 1]; int chars_read;memset(buffer, '\0', sizeof(buffer)); read_fp = popen("uname -a", "r"); if (read_fp != NULL) {

chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp); if (chars_read > 0) {printf("Output was:-\n%s\n", buffer);}pclose(read_fp); exit(EXIT_SUCCESS);




}exit(EXIT_FAILURE);}/***************************************************************

Fork.c***************************************************************/#include <stdlib.h> #include <stdio.h> #include <unistd.h>int main (){

pid_t pid;pid = fork();if(pid == 0){

/* Child process:* When fork() returns 0, we are in * the child process.

* Here we count up to ten, one each second. */ int j;for(j=0; j < 10; j++){

printf("child: %d\n", j); sleep(1);

}_exit(0); /* Note that we do not use exit() */

}else if(pid > 0){

/* Parent process:* Otherwise, we are in the parent process. * Again we count up to ten.

*/ int i;for(i=0; i < 10; i++){

printf("parent: %d\n", i); sleep(1);

}}else{

/* Error handling. */ fprintf(stderr, "couldn't fork"); exit(1);

}return 0;

}




/***************************************************************Message_send.c

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

#include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #define MAX_TEXT 512 struct my_msg_st {long int my_msg_type;

char some_text[MAX_TEXT]; };int main(){int running = 1;

struct my_msg_st some_data; int msgid;char buffer[BUFSIZ];

msgid = msgget((key_t)1234, 0666 | IPC_CREAT); if (msgid == -1) {fprintf(stderr, "msgget failed with error: %d\n", errno); exit(EXIT_FAILURE);}

while(running) { printf("Enter some text: "); fgets(buffer, BUFSIZ, stdin); some_data.my_msg_type = 1;strcpy(some_data.some_text, buffer);if (msgsnd(msgid, (void *)&some_data, MAX_TEXT, 0) == -1) {fprintf(stderr, "msgsnd failed\n"); exit(EXIT_FAILURE);}

if (strncmp(buffer, "end", 3) == 0) { running = 0;}}exit(EXIT_SUCCESS);}/***************************************************************

Message_receive.c***************************************************************/

#include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> struct my_msg_st { long int my_msg_type;

char some_text[BUFSIZ]; };int main()




{

int running = 1; int msgid;struct my_msg_st some_data; long int msg_to_receive = 0;

msgid = msgget((key_t)1234, 0666 | IPC_CREAT); if (msgid == -1) {

fprintf(stderr, "msgget failed with error: %d\n", errno); exit(EXIT_FAILURE);}while(running) {

if (msgrcv(msgid, (void *)&some_data, BUFSIZ, msg_to_receive, 0) == -1) {fprintf(stderr, "msgrcv failed with error: %d\n", errno); exit(EXIT_FAILURE);}printf("You wrote: %s", some_data.some_text);if (strncmp(some_data.some_text, "end", 3) == 0) { running = 0;}}

if (msgctl(msgid, IPC_RMID, 0) == -1) { fprintf(stderr, "msgctl(IPC_RMID) failed\n"); exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);}***************************************************************

Socket_server.c***************************************************************/#include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <unistd.h>#define ADDRESS "server_socket" /* addr to connect */int main(){int server_sockfd, client_sockfd; int server_len, client_len;

struct sockaddr_un server_address; struct sockaddr_un client_address;

//Remove any old sockets and create an unnamed socket for the serve unlink("server_socket");server_sockfd = socket(AF_UNIX, SOCK_STREAM, 0); //Name the

socket

server_address.sun_family = AF_UNIX; strcpy(server_address.sun_path, "server_socket"); server_len = sizeof(server_address);

bind(server_sockfd, (struct sockaddr *)&server_address, server_len); //Create a connetion queue and wait for clients

listen(server_sockfd, 5); while(1) {

char ch;

printf ("server waiting\n"); //Accept a connection

client_len = sizeof(client_address);

client_sockfd = accept(server_sockfd,(struct sockaddrr




*)&client_address, &client_len);//Read and write to client on client_sockfd

read(client_sockfd, &ch, 1);ch++;

write(client_sockfd, &ch, 1); close(client_sockfd);}

}*************************************************************

Socket_client.c***************************************************************/#include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <unistd.h>#define ADDRESS "server_socket" /* addr to connect */ int main(){int sockfd; int len;

struct sockaddr_un address; int result;char ch ='A';

// Create a socket for the client

sockfd = socket (AF_UNIX, SOCK_STREAM, 0); // Name the socket as agreed with the server

address.sun_family = AF_UNIX; strcpy(address.sun_path, "server_socket"); len = sizeof(address);

//Connect our socket to server's socket

result = connect(sockfd, (struct sockaddr *)&address, len); if (result == -1){perror("oops: client1"); exit(1);

}

//You can now read a nd write via sockfd write(sockfd, &ch, 1);read (sockfd, &ch, 1);

printf ("char from server = %c\n", ch); close(sockfd);exit(0);

}




Appendix B

/***************************************************************LED_main.c

***************************************************************/#define ALL 0x007f8000#define ALL 0x007f8000#include<LPC21xx.h>void delay (unsigned int);int main(void){

*IODIR0=ALL;*IOCLR0=ALL;while(1){ *IOSET0= ALL;

delay(150000); *IOCLR0=ALL; delay(150000);

}return 0; }void delay(unsigned int count){ while(count!=0)

count--;}/***********************************************************************

DIP_SWITCH.c************************************************************************/#include <lpc21xx.h>int main(void){

/ *IODIR0=*IODIR0 | 0X000000F7C; / *IOSET0 = 0X000000F7C;

int i; while(1){

*IODIR0 =*IODIR0 | 0x007f8000; //Set Direction of LED *IOCLR0 = 0x007f8000; //Clear all LED's*IOSET0 = ((*IOPIN0 & 0X000000F7C) << 12); for(i=0;i<200000;i++);

/ for(i=0;i<20000;i++); }

/ *IOSET0 = 0X000000F7C; return 0; }




/***********************************************************************Buzzer.c

************************************************************************/#include <lpc21xx.h>#include <BOARD.H>int main(void){ int i;// *IODIR0=*IODIR0 | 0X00040000;

*IODIR0=*IODIR0 | 0X00000080;while(1){*IOSET0 = 0X00000080;

// *IOSET0=0X00040000;for(i=0;i<9000;i++);for(i=0;i<9000;i++);

// *IOCLR0 = 0X00040000;*IOCLR0= 0X00000080;for(i=0;i<9000;i++);for(i=0;i<9000;i++);}return 0;

}/**************************************************************************

ADC.c***************************************************************/#include <LPC22xx.h>#include <board.h>int main(void){unsigned int adcdata;*PINSEL1 = *PINSEL1 & 0XFCFFFFFF; *PINSEL1 = *PINSEL1 | 0X01000000;//*ADCR = 0X01210301; // Channel 0 , Clock 4Mhz, Burst Mode, 11 clocks per 10 bit , //AD conversion is operational, start conversion*ADCR = 0X01210302; // Channel 1 , Clock 4Mhz, Burst Mode, 11 clocks per 10 bit , //AD conversion is operational, start conversionwhile(1){

if(*ADDR&0X80000000){

adcdata = (*ADDR&0X0000FFC0);adcdata = adcdata >> 6;q_printf ("%x \n",adcdata);

}}

return 0;}




/**************************************************************************Relay.c

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

#include <lpc21xx.h> #include <BOARD.H>int main(void){

*IODIR1=*IODIR1 |0X04000000; *IOSET1 = 0X04000000;int i ; while(1){

*IOSET1 = 0X04000000; for(i=0;i<90000;i++); for(i=0;i<90000;i++); *IOCLR1 = 0X04000000; for(i=0;i<90000;i++); for(i=0;i<90000;i++);

}return 0;

}

}return 0;}




Appendix CA) ZIGBEE#include <string.h> // memcpy#include "type.h"#include "target.h"#include "usbdebug.h"#define LPC214x#ifdef LPC214x#include "lpc214x.h"#endif#ifdef LPC23xx#include "lpc23xx.h"#endif#include "armVIC.h"#include "uart.h"#include "usbapi.h"#include "serial_fifo.h"#define MODE_ZIGBEE#if defined(MODE_BLUETOOTH)

#define UART_BAUD_RATE 115200#elif defined(MODE_ZIGBEE) || defined(MODE_WIFI)

#define UART_BAUD_RATE 9600#endif#define INT_IN_EP 0x81#define BULK_OUT_EP 0x05#define BULK_IN_EP 0x82#define MAX_PACKET_SIZE 64#define LE_WORD(x) ((x)&0xFF),((x)>>8)// CDC definitions#define CS_INTERFACE 0x24#define CS_ENDPOINT 0x25#define SET_LINE_CODING 0x20#define GET_LINE_CODING 0x21#define SET_CONTROL_LINE_STATE 0x22#define INT_VECT_NUM 0#define IRQ_MASK 0x00000080// data structure for GET_LINE_CODING / SET_LINE_CODING class requeststypedef struct {

U32 dwDTERate;U8 bCharFormat;U8 bParityType;U8 bDataBits;

} TLineCoding;static TLineCoding LineCoding = {115200, 0, 0, 8};static U8 abBulkBuf[64];




static U8 abClassReqData[8];static volatile BOOL fBulkInBusy;static volatile BOOL fChainDone;static U8 txdata[VCOM_FIFO_SIZE];static U8 rxdata[VCOM_FIFO_SIZE];static fifo_t txfifo;static fifo_t rxfifo;// forward declaration of interrupt handlerstatic void USBIntHandler(void) __attribute__ ((interrupt("IRQ")));static const U8 abDescriptors[] = {// device descriptor

0x12,DESC_DEVICE,LE_WORD(0x0101), // bcdUSB0x02, // bDeviceClass0x00, // bDeviceSubClass0x00, // bDeviceProtocolMAX_PACKET_SIZE0, // bMaxPacketSizeLE_WORD(0xFFFF), // idVendorLE_WORD(0x0005), // idProductLE_WORD(0x0100), // bcdDevice0x01, // iManufacturer0x02, // iProduct0x03, // iSerialNumber0x01, // bNumConfigurations

// configuration descriptor0x09,DESC_CONFIGURATION,LE_WORD(67), // wTotalLength0x02, // bNumInterfaces0x01, // bConfigurationValue0x00, // iConfiguration0xC0, // bmAttributes0x32, // bMaxPower

// control class interface0x09,DESC_INTERFACE,0x00, // bInterfaceNumber0x00, // bAlternateSetting0x01, // bNumEndPoints0x02, // bInterfaceClass0x02, // bInterfaceSubClass0x01, // bInterfaceProtocol, linux requires

value of 1 for the cdc_acm module0x00, // iInterface

// header functional descriptor




0x05,CS_INTERFACE,0x00,LE_WORD(0x0110),

// call management functional descriptor0x05,CS_INTERFACE,0x01,0x01, // bmCapabilities = device handles

call management0x01, // bDataInterface

// ACM functional descriptor0x04,CS_INTERFACE,0x02,0x02, // bmCapabilities

// union functional descriptor0x05,CS_INTERFACE,0x06,0x00, // bMasterInterface0x01, // bSlaveInterface0

// notification EP0x07,DESC_ENDPOINT,INT_IN_EP, // bEndpointAddress0x03, // bmAttributes = intrLE_WORD(8), // wMaxPacketSize0x0A, // bInterval

// data class interface descriptor0x09,DESC_INTERFACE,0x01, // bInterfaceNumber0x00, // bAlternateSetting0x02, // bNumEndPoints0x0A, // bInterfaceClass = data0x00, // bInterfaceSubClass0x00, // bInterfaceProtocol0x00, // iInterface

// data EP OUT0x07,DESC_ENDPOINT,BULK_OUT_EP, // bEndpointAddress0x02, // bmAttributes = bulkLE_WORD(MAX_PACKET_SIZE), // wMaxPacketSize0x00, // bInterval




// data EP in0x07,DESC_ENDPOINT,BULK_IN_EP, // bEndpointAddress0x02, // bmAttributes = bulkLE_WORD(MAX_PACKET_SIZE), // wMaxPacketSize0x00, // bInterval// string descriptors0x04,DESC_STRING,LE_WORD(0x0409),0x0E,DESC_STRING,'L', 0, 'P', 0, 'C', 0, 'U', 0, 'S', 0, 'B', 0,0x14,DESC_STRING,'U', 0, 'S', 0, 'B', 0, 'S', 0, 'e', 0, 'r', 0, 'i', 0, 'a', 0, 'l', 0,0x12,DESC_STRING,'D', 0, 'E', 0, 'A', 0, 'D', 0, 'C', 0, '0', 0, 'D', 0, 'E', 0,

// terminating zero0

};/**

Local function to handle incoming bulk data@param [in] bEP@param [in] bEPStatus

*/static void BulkOut(U8 bEP, U8 bEPStatus){

int i, iLen;if (fifo_free(&rxfifo) < MAX_PACKET_SIZE) {

// may not fit into fiforeturn;

}// get data from USB into intermediate bufferiLen = USBHwEPRead(bEP, abBulkBuf, sizeof(abBulkBuf));for (i = 0; i < iLen; i++) {

// put into FIFOif (!fifo_put(&rxfifo, abBulkBuf[i])) {

// overflow... :(ASSERT(FALSE);break;

} }}




/**Sends the next packet in chain of packets to the host@param [in] bEP@param [in] bEPStatus

*/static void SendNextBulkIn(U8 bEP, BOOL fFirstPacket){ int iLen;

// this transfer is donefBulkInBusy = FALSE;// first packet?if (fFirstPacket) {

fChainDone = FALSE;}// last packet?if (fChainDone) {

return;}// get up to MAX_PACKET_SIZE bytes from transmit FIFO into intermediate

bufferfor (iLen = 0; iLen < MAX_PACKET_SIZE; iLen++) {

if (!fifo_get(&txfifo, &abBulkBuf[iLen])) {break;

} }// send over USBUSBHwEPWrite(bEP, abBulkBuf, iLen);fBulkInBusy = TRUE;// was this a short packet?if (iLen < MAX_PACKET_SIZE) {

fChainDone = TRUE;}}

/**Local function to handle outgoing bulk data@param [in] bEP@param [in] bEPStatus

*/static void BulkIn(U8 bEP, U8 bEPStatus){

SendNextBulkIn(bEP, FALSE);}/**

Local function to handle the USB-CDC class requests@param [in] pSetup@param [out] piLen@param [out] ppbData

*/static BOOL HandleClassRequest(TSetupPacket *pSetup, int *piLen, U8 **ppbData)




{switch (pSetup->bRequest) {// set line codingcase SET_LINE_CODING:

DBG("SET_LINE_CODING\n");memcpy((U8 *)&LineCoding, *ppbData, 7);*piLen = 7;

DBG("dwDTERate=%u, bCharFormat=%u, bParityType=%u, bDataBits=%u\n",LineCoding.dwDTERate,LineCoding.bCharFormat,LineCoding.bParityType,LineCoding.bDataBits);

break;// get line codingcase GET_LINE_CODING:

DBG("GET_LINE_CODING\n");*ppbData = (U8 *)&LineCoding;*piLen = 7;break;

// set control line statecase SET_CONTROL_LINE_STATE:

// bit0 = DTR, bit = RTSDBG("SET_CONTROL_LINE_STATE %X\n", pSetup->wValue);

break;default:

return FALSE;}return TRUE;

}/**

Initialises the VCOM port.Call this function before using VCOM_putchar or VCOM_getchar

*/void VCOM_init(void){

fifo_init(&txfifo, txdata);fifo_init(&rxfifo, rxdata);fBulkInBusy = FALSE;fChainDone = TRUE;

}/**

Writes one character to VCOM port@param [in] c character to write@returns character written, or EOF if character could not be written

*/int VCOM_putchar(int c)




{return fifo_put(&txfifo, c) ? c : EOF;

}void VCOM_putstring(const char *string,int len){

int i;for(i=0;i<len;i++){

VCOM_putchar((int)string[i]);}}

/**Reads one character from VCOM port

@returns character read, or EOF if character could not be read */int VCOM_getchar(void){

U8 c;return fifo_get(&rxfifo, &c) ? c : EOF;

}/**

Interrupt handlerSimply calls the USB ISR, then signals end of interrupt to VIC

*/static void USBIntHandler(void){

USBHwISR();VICVectAddr = 0x00; // dummy write to VIC to signal end of ISR

}/** USB frame interrupt handler

Called every milisecond by the hardware driver.This function is responsible for sending the first of a chain of packetsto the host. A chain is always terminated by a short packet, either apacket shorter than the maximum packet size or a zero-length packet(as required by the windows usbser.sys driver).

*/static void USBFrameHandler(U16 wFrame){

if (!fBulkInBusy && (fifo_avail(&txfifo) != 0)) {// send first packetSendNextBulkIn(BULK_IN_EP, TRUE);

}}/** USB device status handler

Resets state machine when a USB reset is received. */




static void USBDevIntHandler(U8 bDevStatus){

if ((bDevStatus & DEV_STATUS_RESET) != 0) {fBulkInBusy = FALSE;

}}#define MAX_DATA_LENGTH 256typedef struct{

unsigned char data[MAX_DATA_LENGTH];unsigned int data_ptr;

}data_fifo_t;typedef struct{

data_fifo_t rx;data_fifo_t tx;

}uart_buffer_t;uart_buffer_t vcp_buff;/************************************************************************* main

====***********************************************************************/int main(void){

int vcp_ch,uart_ch,i;// PLL and MAM//HalSysInit();target_init();

#if 0#ifdef LPC214x

// init DBGConsoleInit(60000000 / (16 * UART_BAUD_RATE));

#else// init DBGConsoleInit(72000000 / (16 * UART_BAUD_RATE));

#endif#endif

// init DBGuart0_init(UART_BAUD_RATE,8,'N',1);printf("Initialising USB stack\n\r");// initialise stackUSBInit();// register descriptorsUSBRegisterDescriptors(abDescriptors);// register class request handler




USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData);

// register endpoint handlersUSBHwRegisterEPIntHandler(INT_IN_EP, NULL);USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);// register frame handlerUSBHwRegisterFrameHandler(USBFrameHandler);// register device event handlerUSBHwRegisterDevIntHandler(USBDevIntHandler);// initialise VCOMVCOM_init();

#ifdef LPC214x(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority

ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler;

#else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler;#endif

// set up USB interruptVICIntSelect &= ~(1<<22); // select IRQ for USBVICIntEnable |= (1<<22);enableIRQ();// connect to busUSBHwConnect(TRUE);VCOM_putstring("Starting USB Communication",26);#if 0// echo any character received (do USB stuff in interrupt)while (1) {

vcp_ch = VCOM_getchar();if (vcp_ch != EOF) {

// show on consoleif ((vcp_ch == 9) || (vcp_ch == 10) || (vcp_ch == 13) || ((vcp_ch >=

32) && (vcp_ch <= 126))) {

printf("%c", vcp_ch);}else {

printf(".");}VCOM_putstring("We got a character = ",21);VCOM_putchar(ch);




VCOM_putstring("\r\n",2);} }

#elsewhile(1){

// Receive a character from VCP [ Virtual COM Port ]vcp_ch = VCOM_getchar();// show on consoleif( (vcp_ch == 8) || (vcp_ch == 13) || ( (vcp_ch >= 32) && (vcp_ch < 127)

&& (vcp_ch != EOF ) ) ){ switch(vcp_ch)

{case 8: // Back spacevcp_buff.tx.data_ptr--;break;case '\r': // Carriage Return -> send the data to device// Is there any data in bufferif(vcp_buff.tx.data_ptr == 0){

VCOM_putchar('\n');break; // No sense in sending data

}// Adding a '\n' and null terminating the stringif(vcp_buff.tx.data[vcp_buff.tx.data_ptr - 1] != '$' &&

vcp_buff.tx.data[vcp_buff.tx.data_ptr - 1] != '+'){

vcp_buff.tx.data[vcp_buff.tx.data_ptr++] = vcp_ch;}vcp_buff.tx.data[vcp_buff.tx.data_ptr] = 0;// Sending the data to UART0VCOM_putstring("\r\nSending command:[",19);VCOM_putstring(vcp_buff.tx.data,vcp_buff.tx.data_ptr);VCOM_putstring("]\r\n",3);uart0_send((vcp_buff.tx.data),vcp_buff.tx.data_ptr,false);// Null terminate the data because it has been usedvcp_buff.tx.data_ptr = 0;vcp_buff.tx.data[vcp_buff.tx.data_ptr] = 0;break;default:vcp_buff.tx.data[vcp_buff.tx.data_ptr++] = vcp_ch;break;

}VCOM_putchar(vcp_ch);

}// Now lets listen to what UART has say to us




// We will fill the received data into vcp_buff.rx for(i=0;i<6500;i++); // Intercharacter delay on UART typically 1 msif(uart0_getc(&uart_ch,1000) == false){

continue; // Nothing available on UART now }if((uart_ch == 8) || (uart_ch == 13) || ((uart_ch >= 32) && (uart_ch <

127))){

switch(uart_ch){

case 8: // Backspacevcp_buff.rx.data_ptr--;break;case '\n': // new Line

// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = '\r';

vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;VCOM_putstring("\n\rGot response=[",16);VCOM_putstring(vcp_buff.rx.data,vcp_buff.rx.data_ptr);VCOM_putstring("]\r\n",3);// Clearing the buffers vcp_buff.rx.data_ptr = 0;vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;break;case '\r': // Carriage return

// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = '\n';

vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;VCOM_putstring("\n\rGot response=[",16);VCOM_putstring(vcp_buff.rx.data,vcp_buff.rx.data_ptr);VCOM_putstring("]\r\n",3);// Clearing the buffersvcp_buff.rx.data_ptr = 0;vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;break;default:vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;break;

} } } #endifreturn 0;

} /**End of file.*/




B) BLUETOOTH#include <string.h> // memcpy#include "type.h"#include "target.h"#include "usbdebug.h"#define LPC214x#ifdef LPC214x#include "lpc214x.h"#endif#ifdef LPC23xx#include "lpc23xx.h"#endif#include "armVIC.h"#include "uart.h"#include "usbapi.h"#include "serial_fifo.h"#define MODE_ZIGBEE#if defined(MODE_BLUETOOTH)

#define UART_BAUD_RATE 115200#elif defined(MODE_ZIGBEE) || defined(MODE_WIFI)

#define UART_BAUD_RATE 9600#endif#define INT_IN_EP 0x81#define BULK_OUT_EP 0x05#define BULK_IN_EP 0x82#define MAX_PACKET_SIZE 64#define LE_WORD(x) ((x)&0xFF),((x)>>8)// CDC definitions#define CS_INTERFACE 0x24#define CS_ENDPOINT 0x25#define SET_LINE_CODING 0x20#define GET_LINE_CODING 0x21#define SET_CONTROL_LINE_STATE 0x22#define INT_VECT_NUM 0#define IRQ_MASK 0x00000080// data structure for GET_LINE_CODING / SET_LINE_CODING class requeststypedef struct {

U32 dwDTERate;U8 bCharFormat;U8 bParityType;U8 bDataBits;

} TLineCoding;static TLineCoding LineCoding = {115200, 0, 0, 8};static U8 abBulkBuf[64];




static U8 abClassReqData[8];static volatile BOOL fBulkInBusy;static volatile BOOL fChainDone;static U8 txdata[VCOM_FIFO_SIZE];static U8 rxdata[VCOM_FIFO_SIZE];static fifo_t txfifo;static fifo_t rxfifo;// forward declaration of interrupt handlerstatic void USBIntHandler(void) __attribute__ ((interrupt("IRQ")));static const U8 abDescriptors[] = {// device descriptor

0x12,DESC_DEVICE,LE_WORD(0x0101), // bcdUSB0x02, // bDeviceClass0x00, // bDeviceSubClass0x00, // bDeviceProtocolMAX_PACKET_SIZE0, // bMaxPacketSizeLE_WORD(0xFFFF), // idVendorLE_WORD(0x0005), // idProductLE_WORD(0x0100), // bcdDevice0x01, // iManufacturer0x02, // iProduct0x03, // iSerialNumber0x01, // bNumConfigurations

// configuration descriptor0x09,DESC_CONFIGURATION,LE_WORD(67), // wTotalLength0x02, // bNumInterfaces0x01, // bConfigurationValue0x00, // iConfiguration0xC0, // bmAttributes0x32, // bMaxPower

// control class interface0x09,DESC_INTERFACE,0x00, // bInterfaceNumber0x00, // bAlternateSetting0x01, // bNumEndPoints0x02, // bInterfaceClass0x02, // bInterfaceSubClass0x01, // bInterfaceProtocol, linux requires

value of 1 for the cdc_acm module0x00, // iInterface

// header functional descriptor




0x05,CS_INTERFACE,0x00,LE_WORD(0x0110),

// call management functional descriptor0x05,CS_INTERFACE,0x01,0x01, // bmCapabilities = device handles

call management0x01, // bDataInterface

// ACM functional descriptor0x04,CS_INTERFACE,0x02,0x02, // bmCapabilities

// union functional descriptor0x05,CS_INTERFACE,0x06,0x00, // bMasterInterface0x01, // bSlaveInterface0

// notification EP0x07,DESC_ENDPOINT,INT_IN_EP, // bEndpointAddress0x03, // bmAttributes = intrLE_WORD(8), // wMaxPacketSize0x0A, // bInterval

// data class interface descriptor0x09,DESC_INTERFACE,0x01, // bInterfaceNumber0x00, // bAlternateSetting0x02, // bNumEndPoints0x0A, // bInterfaceClass = data0x00, // bInterfaceSubClass0x00, // bInterfaceProtocol0x00, // iInterface

// data EP OUT0x07,DESC_ENDPOINT,BULK_OUT_EP, // bEndpointAddress0x02, // bmAttributes = bulkLE_WORD(MAX_PACKET_SIZE), // wMaxPacketSize0x00, // bInterval




// data EP in0x07,DESC_ENDPOINT,BULK_IN_EP, // bEndpointAddress0x02, // bmAttributes = bulkLE_WORD(MAX_PACKET_SIZE), // wMaxPacketSize0x00, // bInterval

// string descriptors0x04,DESC_STRING,LE_WORD(0x0409),

0x0E,DESC_STRING,'L', 0, 'P', 0, 'C', 0, 'U', 0, 'S', 0, 'B', 0,

0x14,DESC_STRING,'U', 0, 'S', 0, 'B', 0, 'S', 0, 'e', 0, 'r', 0, 'i', 0, 'a', 0, 'l', 0,

0x12,DESC_STRING,'D', 0, 'E', 0, 'A', 0, 'D', 0, 'C', 0, '0', 0, 'D', 0, 'E', 0,

// terminating zero0

};/**

Local function to handle incoming bulk data@param [in] bEP@param [in] bEPStatus

*/static void BulkOut(U8 bEP, U8 bEPStatus){ int i, iLen;

if (fifo_free(&rxfifo) < MAX_PACKET_SIZE) {// may not fit into fiforeturn;

}// get data from USB into intermediate bufferiLen = USBHwEPRead(bEP, abBulkBuf, sizeof(abBulkBuf));for (i = 0; i < iLen; i++) {

// put into FIFOif (!fifo_put(&rxfifo, abBulkBuf[i])) {

// overflow... :(ASSERT(FALSE);break;




} } }/**

Sends the next packet in chain of packets to the host@param [in] bEP@param [in] bEPStatus

*/static void SendNextBulkIn(U8 bEP, BOOL fFirstPacket){ int iLen;

// this transfer is donefBulkInBusy = FALSE;

// first packet?if (fFirstPacket) {

fChainDone = FALSE;}// last packet?if (fChainDone) {

return;}

// get up to MAX_PACKET_SIZE bytes from transmit FIFO into intermediate buffer

for (iLen = 0; iLen < MAX_PACKET_SIZE; iLen++) {if (!fifo_get(&txfifo, &abBulkBuf[iLen])) {

break;}

}// send over USB

USBHwEPWrite(bEP, abBulkBuf, iLen);fBulkInBusy = TRUE;

// was this a short packet?if (iLen < MAX_PACKET_SIZE) {

fChainDone = TRUE;}

}/**

Local function to handle outgoing bulk data

@param [in] bEP@param [in] bEPStatus

*/static void BulkIn(U8 bEP, U8 bEPStatus){

SendNextBulkIn(bEP, FALSE);}/**




Local function to handle the USB-CDC class requests

@param [in] pSetup@param [out] piLen@param [out] ppbData

*/static BOOL HandleClassRequest(TSetupPacket *pSetup, int *piLen, U8 **ppbData){

switch (pSetup->bRequest) {// set line codingcase SET_LINE_CODING:

DBG("SET_LINE_CODING\n");memcpy((U8 *)&LineCoding, *ppbData, 7);*piLen = 7;

DBG("dwDTERate=%u, bCharFormat=%u, bParityType=%u, bDataBits=%u\n",LineCoding.dwDTERate,LineCoding.bCharFormat,LineCoding.bParityType,LineCoding.bDataBits);

break;// get line codingcase GET_LINE_CODING:

DBG("GET_LINE_CODING\n");*ppbData = (U8 *)&LineCoding;*piLen = 7;break;

// set control line statecase SET_CONTROL_LINE_STATE:

// bit0 = DTR, bit = RTSDBG("SET_CONTROL_LINE_STATE %X\n", pSetup->wValue);

break;default:

return FALSE;}return TRUE;

}/**

Initialises the VCOM port.Call this function before using VCOM_putchar or VCOM_getchar

*/void VCOM_init(void){

fifo_init(&txfifo, txdata);fifo_init(&rxfifo, rxdata);fBulkInBusy = FALSE;fChainDone = TRUE;




}/**

Writes one character to VCOM port@param [in] c character to write@returns character written, or EOF if character could not be written

*/int VCOM_putchar(int c){

return fifo_put(&txfifo, c) ? c : EOF;}void VCOM_putstring(const char *string,int len){

int i;for(i=0;i<len;i++){

VCOM_putchar((int)string[i]);}

}/**

Reads one character from VCOM port@returns character read, or EOF if character could not be read

*/int VCOM_getchar(void){

U8 c;return fifo_get(&rxfifo, &c) ? c : EOF;

}/** Interrupt handler

Simply calls the USB ISR, then signals end of interrupt to VIC */static void USBIntHandler(void){

USBHwISR();VICVectAddr = 0x00; // dummy write to VIC to signal end of ISR

}/**

USB frame interrupt handlerCalled every milisecond by the hardware driver.This function is responsible for sending the first of a chain of packetsto the host. A chain is always terminated by a short packet, either apacket shorter than the maximum packet size or a zero-length packet(as required by the windows usbser.sys driver).

*/static void USBFrameHandler(U16 wFrame){




if (!fBulkInBusy && (fifo_avail(&txfifo) != 0)) {// send first packetSendNextBulkIn(BULK_IN_EP, TRUE);

}}/**

USB device status handlerResets state machine when a USB reset is received.

*/static void USBDevIntHandler(U8 bDevStatus){

if ((bDevStatus & DEV_STATUS_RESET) != 0) {fBulkInBusy = FALSE;

}}#define MAX_DATA_LENGTH 256typedef struct{

unsigned char data[MAX_DATA_LENGTH];unsigned int data_ptr;

}data_fifo_t;typedef struct{

data_fifo_t rx;data_fifo_t tx;

}uart_buffer_t;

uart_buffer_t vcp_buff;/************************************************************************* main

====**************************************************************************/int main(void){ int vcp_ch,uart_ch,i;

// PLL and MAM//HalSysInit();target_init();

#if 0#ifdef LPC214x

// init DBGConsoleInit(60000000 / (16 * UART_BAUD_RATE));

#else// init DBGConsoleInit(72000000 / (16 * UART_BAUD_RATE));

#endif#endif




// init DBGuart0_init(UART_BAUD_RATE,8,'N',1);printf("Initialising USB stack\n\r");// initialise stackUSBInit();// register descriptorsUSBRegisterDescriptors(abDescriptors);// register class request handlerUSBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest,

abClassReqData);// register endpoint handlersUSBHwRegisterEPIntHandler(INT_IN_EP, NULL);USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn);USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut);// register frame handlerUSBHwRegisterFrameHandler(USBFrameHandler);// register device event handlerUSBHwRegisterDevIntHandler(USBDevIntHandler);// initialise VCOMVCOM_init();

#ifdef LPC214x(*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority

ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler;

#else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler;#endif // set up USB interrupt

VICIntSelect &= ~(1<<22); // select IRQ for USBVICIntEnable |= (1<<22);enableIRQ();// connect to busUSBHwConnect(TRUE);VCOM_putstring("Starting USB Communication",26);#if 0// echo any character received (do USB stuff in interrupt)while (1) {

vcp_ch = VCOM_getchar();if (vcp_ch != EOF) {

// show on consoleif ((vcp_ch == 9) || (vcp_ch == 10) || (vcp_ch == 13) || ((vcp_ch >=

32) && (vcp_ch <= 126)))




{printf("%c", vcp_ch);

}else {

printf(".");}VCOM_putstring("We got a character = ",21);VCOM_putchar(ch);VCOM_putstring("\r\n",2);

} } #elsewhile(1){

// Receive a character from VCP [ Virtual COM Port ]vcp_ch = VCOM_getchar();

// show on consoleif( (vcp_ch == 8) || (vcp_ch == 13) || ( (vcp_ch >= 32) && (vcp_ch < 127)

&& (vcp_ch != EOF ) ) ){

switch(vcp_ch){

case 8: // Back spacevcp_buff.tx.data_ptr--;break;case '\r': // Carriage Return -> send the data to device// Is there any data in bufferif(vcp_buff.tx.data_ptr == 0){

VCOM_putchar('\n');break; // No sense in sending data

}// Adding a '\n' and null terminating the stringif(vcp_buff.tx.data[vcp_buff.tx.data_ptr - 1] != '$' &&

vcp_buff.tx.data[vcp_buff.tx.data_ptr - 1] != '+'){

vcp_buff.tx.data[vcp_buff.tx.data_ptr++] = vcp_ch;}vcp_buff.tx.data[vcp_buff.tx.data_ptr] = 0;// Sending the data to UART0VCOM_putstring("\r\nSending command:[",19);VCOM_putstring(vcp_buff.tx.data,vcp_buff.tx.data_ptr);VCOM_putstring("]\r\n",3);uart0_send((vcp_buff.tx.data),vcp_buff.tx.data_ptr,false);// Null terminate the data because it has been used




vcp_buff.tx.data_ptr = 0;vcp_buff.tx.data[vcp_buff.tx.data_ptr] = 0;break;default:vcp_buff.tx.data[vcp_buff.tx.data_ptr++] = vcp_ch;break;

}VCOM_putchar(vcp_ch);

}// Now lets listen to what UART has say to us// We will fill the received data into vcp_buff.rx for(i=0;i<6500;i++); // Intercharacter delay on UART typically 1 msif(uart0_getc(&uart_ch,1000) == false){

continue; // Nothing available on UART now }if((uart_ch == 8) || (uart_ch == 13) || ((uart_ch >= 32) && (uart_ch <

127))){

switch(uart_ch){

case 8: // Backspacevcp_buff.rx.data_ptr--;break;case '\n': // new Line

// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = '\r';

vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;VCOM_putstring("\n\rGot response=[",16);VCOM_putstring(vcp_buff.rx.data,vcp_buff.rx.data_ptr);VCOM_putstring("]\r\n",3);// Clearing the buffers vcp_buff.rx.data_ptr = 0;vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;break;case '\r': // Carriage return

// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;// vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = '\n';

vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;VCOM_putstring("\n\rGot response=[",16);VCOM_putstring(vcp_buff.rx.data,vcp_buff.rx.data_ptr);VCOM_putstring("]\r\n",3);

// Clearing the buffersvcp_buff.rx.data_ptr = 0;vcp_buff.rx.data[vcp_buff.rx.data_ptr] = 0;




break;default:vcp_buff.rx.data[vcp_buff.rx.data_ptr++] = uart_ch;break;

}}

}#endif

return 0;}/**End of file.*/

C) RF MODULE

/************************************************************************ nordic_rf24l01p_LPC2148_main.c

************************************************************************/#include "./system/core.h"#include "./spi/spi.h"#include "./tools/print.h"#include "./tools/delays.h"#include "./time/time.h"#include "./time/timer.h"#include "./time/rtc.h"#include "./uart/uart.h"#include "./led/led.h"#include "./tools/debug.h"#include "./nordic/nrf24l01.h"

#define NRF24l01_MODE_TX 0#define NRF24l01_MODE_RX 1

char txData[] = "Oasis Technologies Pvt Ltd.";unsigned int txUserData;unsigned int txUserDataCounter;unsigned int txDataCounter;unsigned char data;unsigned int counter;

void nrf24l01_hardware_init(void);void hardware_init(void);

int main(void){

//TODO: You can write your code at here




hardware_init();printf("Hardware Init complete...\n\r");

nrf24l01_hardware_init();printf("Nordic Init complete...\n\r");

int i=0;unsigned char regData[35];

#if 1// while(1)

{nrf24l01_get_all_registers(&regData[0]);for(i=0;i<35;i++){

printf("nrf24L01+[%d] = [0x%x]\n\r",i,regData[i]);delay_ms(10);

}delay_sec(10);

}#endif

#if (NRF24l01_MODE_TX)

printf("Nordic in Tx Mode...\n\r");while(1){

#if 0

txDataCounter=0;while(txDataCounter<sizeof(txData)){

data = (unsigned char)txData[txDataCounter];

nrf24l01_write_tx_payload(&data, 1, true); //transmit received char over RF

//wait until the packet has been sent or the maximum number of retries has been reached

while(!(nrf24l01_irq_pin_active()));

if(nrf24l01_irq_tx_ds_active()){

nrf24l01_irq_clear_all(); //clear all interrupts in the 24L01

printf(".");txDataCounter++;

}else if(nrf24l01_irq_max_rt_active()){

nrf24l01_flush_tx();nrf24l01_flush_rx();nrf24l01_irq_clear_all();printf("X");

}




}#elseprintf("Type characters to send: ");while(1){

if(uart0_getc(&txUserData,1000)!=true){

delay_ms(10);continue;

}

nrf24l01_write_tx_payload((unsigned char *)&txUserData, 1, true); //transmit received char over RF

while(!(nrf24l01_irq_pin_active()));

if(nrf24l01_irq_tx_ds_active()){

nrf24l01_irq_clear_all(); //clear all interrupts in the 24L01

printf(".");txUserDataCounter++;

}else if(nrf24l01_irq_max_rt_active()){

nrf24l01_flush_tx();nrf24l01_flush_rx();nrf24l01_irq_clear_all();printf("X");

}uart0_putc(txUserData);

}#endifprintf("\n\rTransmitted data [%d]\n\r",counter++);delay_sec(1);

}#elif (NRF24l01_MODE_RX)

printf("Nordic in RX mode ...\n\r");unsigned char status;while(1){

while(!(nrf24l01_irq_pin_active() && nrf24l01_irq_rx_dr_active()));

status = nrf24l01_read_rx_payload(&data,1); // Read the packet into data

if(status == 64){

printf("%c",data);if(data == '.'){

printf("\r\n Read Byte:");}

}




delay_ms(100);}

#endif

while(1);

return 0;}

void nrf24l01_hardware_init(){

// Configure SPI pins on PINSEL

// Configure CSN(P0.20) CE(P0.21) and IRQ(PO.15) pin as fast GPIO as output only// IODIR0 |= (( 1 << 20 ) | ( 1 << 21 )); // Setting up CSN and CE

// IODIR0 &= (~( 1 << 15 ) ); // Setting up IRQ

// Configure CSN(P1.17) CE(P1.16) and IRQ(P1.18) pin as fast GPIO as output only// IODIR1 |= (( 1 << 17 ) | ( 1 << 18 )); // Setting up CSN and CE

// IODIR1 &= (~( 1 << 19 ) ); // Setting up IRQ

// Configure pin as fast GPIO as output only from nrf24l01.hIODIR1 |= ( nrf24l01_CE_PINMASK | nrf24l01_CSN_PINMASK ); //

Setting up CSN and CE

IODIR1 &= (~ nrf24l01_IRQ_PINMASK ); // Setting up IRQ

spi0_open(); //open SPI1

// initialize the 24L01 to the debug configuration as TX, // 1 data byte, and auto-ack disabled

delay_sec(2);

// while(1){

nrf24l01_clear_ce();nrf24l01_set_ce();

nrf24l01_clear_csn();nrf24l01_set_csn();

// if( nrf24l01_IRQ_IOREGISTER & nrf24l01_IRQ_PINMASK )// {// printf("+");// }// else// {




// printf("-");// }

}#if (NRF24l01_MODE_RX)

nrf24l01_initialize_debug(true, 1 , true);#elif (NRF24l01_MODE_TX)

nrf24l01_initialize_debug(false, 1 , true);#endif

}

void hardware_init(){

target_init();irq_vic_init();uart0_init(115200,8,'N',1);

timer_init(SYSTEM_TIMER,Fpclk/1000 -1 );timer_enable(SYSTEM_TIMER);

#ifdef __WRITE_START_RTC__time.seconds = 0;time.minutes = 22;time.hours = 12;time.day_of_month = 21;time.day_of_week = 3;time.day_of_year = 233;time.month = 7;time.year = 2010;rtc_init();rtc_set_time(&time);#elsertc_init();#endif

// initLED();// while(1)// {// circleLED();// }}


Embedded System Lab Manual Final Complete Final

Documents