EE 472 Lab 1 (Individual)

Introduction to C and the Lab Environment

University of Washington - Department of Electrical Engineering

Introduction:

This lab has two main purposes. The first is to introduce the C language, explore some

of the important aspects of the language including pointers. The second is to introduce

the Atmel AT91SAM7SExxx implementation of the ARM7 microcomputer (Make

Controller), the Eclipse integrated C / Assembler development environment, and the

world of embedded applications. Like a typical embedded system, we have a hardware

piece and a software piece. This quarter, our major focus will be on the software piece.

The best way to become familiar with any new piece of hardware is to take a tour of its

features; the same holds true for learning a new programming language. This is the

approach that we will take.

We will take the same approach as we move to the microprocessor and associated

development environment. For the processor, we’ll begin with the data sheet and

discover some of the key features of this device. This is exactly how we will do it in

future when we start to work with a new microprocessor for our company or in our

graduate research. Then, once again, we will begin with a working application, learn

how to build a project, compile it, download it, and run it on the target platform. We

will then make some simple modifications to the program and verify that the modified

programs work as expected.

Prerequisites:

Familiarity with data types, data structures, as well as standard program design,

development, and debugging techniques.

Background

We will be continuing our work and learning process with a new microprocessor and

development environment this quarter.

Sometimes it can be frustrating when the software or the microprocessor doesn’t behave

the way we want it to, or when, unfortunately, it behaves the way that we have told it to,

or when we can’t immediately find the answer to our questions and problems.

Sometimes your instructor or TA will have the answers and sometimes they won’t. As

we said in the opening, bear in mind that we’re learning the environment and tools too –

this platform and development environment are complex and are new to all of us. If we

all work together to identify and solve problems as they occur, everyone benefits and we

help to build for the next classes. The answers are there somewhere. Let’s all work to

find them.

Regardless of the specific platform/environment used, embedded systems development

requires at least the following:

1. A target platform on which to develop the application.

2. A mechanism for programming the target platform.

Target platform is a term used loosely in industry to mean the actual piece of hardware

that performs the computation and/or control – the place where our application will

ultimately run.

A target platform can be a simple a single chip (i.e. a PIC), or as complicated as a

feature-rich single board computer (build around a multicore high performance

processor and possibly several programmable logic devices). Despite the differences in

physical characteristics, the target platform’s purpose is the same: to execute the

software written by the developer. Here, and for the typical microprocessor based

application, the software will be the C language. On a programmable logic device, it

may be a mixture of C and Verilog, for example.

The term to program here has two meanings. The first is the more traditional sense and

simply means writing software to control a given piece of hardware (in this case the

target platform – see above). In the embedded world, programming the target also

means storing the executable into memory on the target. As the characteristics of the

target platform can vary greatly, so too can the mechanism used to program the target

platform.

Some development environments allow one to develop directly on the target platform

(much like developing code on a PC), while others require that code be developed on

another host computer and then transferred to the target platform. We call this transfer

downloading to the target platform. Apart from the actual technique(s) used, every

embedded system has to provide a mechanism for programming it.

One of the more difficult concepts to learn in C is the notion of pointers. Once you

begin to see what they are, you’ll find that they’re actually rather straightforward. In

reality, pointers are nothing more complicated than a variable type whose value is

interpreted as the address of something in memory. This is exactly the same as

interpreting a collection of bits (they’re just bits) as an integer, a character, a floating

point number, some interesting picture that you downloaded from one of those special

websites on the internet, or all the data on your hard drive as a really big integer.

There is a very good explanation of pointers with accompanying drawings in your text.

Take the time to read through this material.

Laboratory Environment

This laboratory environment is equipped with Make Controller and Application Board

(see class material link on class webpage for more information on Make). As its name

implies, the Make system is a feature-rich single board computer equipped with an

ARM 7 microprocessor.

The ARM 7 is a RISC processor that runs at up to 55 MHz. As a point of interest, we

note that all CPU hertzes are not created equal. Based upon its architecture and the way

that the machine operated, an ARM 7 running at 55 MHz has the potential of being more

powerful than a Pentium running at the same speed.

The ARM 7 architecture supports two instruction sets: a 32-bit implementation (called

ARM) in support of high performance embedded designs and a 16-bit implementation

(called Thumb) that supports a reduced memory footprint for smaller embedded

applications. The ARM 7 utilizes a three-stage pipeline architecture: instruction fetch,

decode, and execute. We’ll talk about what all these mean in class.

Interestingly, the ARM family of microprocessors are actually a design (piece of

intellectual property) licensed by ARM to a variety of different companies to build.

This company grew out of a small company, Acorn Computers, in the UK

From Wikipedia…

Acorn Computers was a British computer company established in Cambridge,

England, in 1978. The company produced a number of computers which were

especially popular in the UK. These included the Acorn Electron, the BBC Micro

and the Acorn Archimedes. Acorn's BBC MicroComputer dominated the UK

educational computer market during the 1980s and early 1990s, drawing many

comparisons with Apple in the U.S.

Though the company was broken up into several independent operations in 1998, its

legacy includes the development of RISC personal computers. A number of Acorn's

former subsidiaries live on today – notably ARM Holdings who are globally

dominant in the mobile phone and PDA microprocessor market. Acorn is sometimes

known as "the British Apple".

The version of the processor on the Make Controller is the Atmel AT91SAM7X256.

Some other features include:

Memory

o 32 KB SRAM

o 256 KB Flash memory

Memory Controller s

o SDRAM

o SRAM

o Error Corrected Code Controller

Interrupt Controller and programmable number of external interrupt inputs

I/O Communication

o Three Parallel Input / Output (PIO) Controllers

o 2 USART serial ports

o SPI and CAN interfaces

o USB port

o Ethernet interface

JTAG Boundary Scan interface

Debug Support

Internal Peripherals

o 3 16-bit timers

o 4 Channel PWM Controller

o 8 Channels 10-bit A/D

o Real-time Timer

o 8 Digital outputs – 4 with high current drive

o 8 Digital inputs

Figure 1: Make Controller

Figure 2: Pinouts

In this class, we will use many of these hardware features as we design and develop the

various laboratory projects; the details regarding each of the components will be given

as needed.

To program the Make Controller target platform, a host PC is required. Using the

Eclipse C Development Environment, code can be developed on a standard PC and then

downloaded into the target platform over a USB serial connection.

Figure 3: Schematic of the EE 472 Accessory Board.

Objectives

Introduce the C language, C programs, and the PC development environment: the basic C/C++ preprocessor, program structure, multiple file programs,

pointers, passing and returning variables by value and by reference to and from

subroutines, designing, compiling, and debugging on a host PC.

Introduce the laboratory environment: the embedded development environment, the target platform, host PC, equipment, etc.

Learn a bit about the Atmel version of the ARM 7 Processor.

Learning the C Language & Working with the Development Environment and Target Platform

We’ll be working with the Eclipse IDE and the Make (ARM 7) Application Board.

First Steps

Our first step is to install the tools that we’ll need and some sample software onto the

machine on which we are working. You can go directly to the Make website

http://www.makingthings.com/resources/downloads then Firmware 1.6.2 source code.

Once you have the package downloaded, unzip it and extract all of the files to your

machine. The following discussion assumes that we are working in the directory….\

firmware-v1.6.2\projects. The prefix of the path is wherever you put the files on your

machine. Note, also, I am working on a PC rather than under Linux.

You can place this directory on your H: drive if you wish.

You are strongly encouraged to work in this directory (….\ firmware-v1.6.2\projects ).

http://www.makingthings.com/resources/downloadshttp://www.makingthings.com/files/firmware/firmware-src-1.6.2.zip

Configuring the Project

We now begin by opening Eclipse and

setting our current workspace. You can

open the “Workspace Launcher” window

from File|Switch Workspace|Other if it

didn’t popup automatically. Using the H:

drive is highly recommended.

Note: The directory names along the workspacepathname cannot

contain any spaces. Also, Figure 4

shows an older version, but you

should be using the newer version

discussed above.

Select

OK

The first splash screen appears.

Select

Workbench

Figure 4

Figure 5

Select

File → New → C Project

Select

Makefile project

WinARM Yagarto

Give your project a name

We’ll use: LEDDriverTinyLab1

Note: The project name cannot contain any spaces – this is why there are no spaces in the name that we have chosen. See we learned earlier when we had a

directory and file name with spaces in them. It didn’t work. The compiler

couldn’t find anything. This is where the frustration in software development

comes in.

Figure 6

Select

Finish

Figure 7

Your environment should now appear as in figure 8.

Next, the application needs the source code and tools to build our application.

Normally, we would write these ourselves. However, for this application, we are

working with existing code. Thus, we must import them into our project.

Download LedDriverTiny.zip from the lab1 page on the class website. Feel free to

download it and unzip it onto your desktop or any other place. We won’t be building this

downloaded copy, so it doesn’t have to be on the H:\ drive.

Next, we need to import the downloaded project into the new project we just created.

Figure 8

10

Select the following in the Project Explorer pane in the Eclipse IDE:

LedDriverTinyLab1

Using the right mouse button to open the selector menu

Select

Import

On the menu that pops up

Select

General → File System

Figure 9

11

Select

Next

In the window that pops up, browse to the directory where you stored the folder

LedDriverTiny.

Select the folder LedDriverTiny and select

Open

Select the checkbox next to LedDriverTiny. This will, in turn, select all of the files in the

right hand window.

Figure 10

12

Select

Finish to copy over all files

Open the directory structure under the heading LEDDriverTinyLab1 and your display should

look something like that in figure 12.

Figure 11

13

Select main.c and double click to open the file in the display window.

Go to the Project menu and select Build All or simply type ctrl + B. This will compile

your program. There should be no errors and your display should look like this…

Figure 12

Figure 13

14

You have just built your first ARM 7 application – Wahoo – that should go on your

resume.

Downloading to the Target

Before we can download our application, we need more tools. Thus, it’s back to the Make

download website. This time, get select and download the file: mchelper 2.5.1

(http://www.makingthings.com/files/mchelper/2.5.0/mchelper-v2.5.1-setup.zip). By

now, you know the routine….download the file, unzip it, extract, and install everything.

Make certain that your Make board is connected to your PC through one of the USB

ports.

Turn power ON to the board

Reset the board – that’s the red button on the system.

Cycle power on the board – don’t even think it. I didn’t make up these rules. I’m just following them.

The McHelper display should now appear something like:

Browse to ……/LEDDriverTinyLab1/output directory.

Select

tiny.bin

Highlight Samba Board

Select upload

Figure 15

15

Your display on McHelper should look like…

…as the file tiny.bin is being downloaded to your ARM 7.

It should start executing automatically.

You should now see LED0 on the Make Application board and the LED on the Make

Controller board flashing.

Your just successfully completed your first ARM 7 project.

Building Your Own Applications

Now that you have successfully run an existing application on the target platform, this next

exercise we will make a series of changes to the program to gain practice in some of the

techniques that we will have to use in our more complex applications.

Application 1

Modify the program LEDDriverTinyLab1.c to flash leds LED-0..LED-3 at approximately

a one-second rate.

Application 2

Modify the program LEDDriverTinyLab1.c to turn each of the leds: LED-0..LED-3 ON

then each of the leds OFF in sequential order (and then circle back) at approximately a

one-second rate.

Figure 16

16

Application 3

Modify the program LEDDriverTinyLab1.c to flash LED-0 and LED-2 at a one-second

rate and LED1 and LED-3 at approximately a two second rate.

Implement the delay as a function with the following prototype:

void delay(int aDelay);

Application 4

Write an application that uses the LCD (call it LCDDriverLab1.c). This new

application should implement the following display function:

void display(char* text, int length, int* delayInSeconds);

This function takes in a pointer to the first element of a character array, which

represents the text, the length of the text (i.e., number of chars), and a pointer to a

delay value. Your function should display and flash the text on the LCD using the

referenced delay amount.

You may use lcd_test (from the example code in the lab1 directory) as a basis for

your application. You should also take a look at the lcd display’s datasheet.

Deliverables

A lab report containing (Lab1 should be done individually)

1. The annotated source code for all four applications (in the appendix).

2. Because there are so few features to this lab, we don’t expect a full lab report that goes into detail about the test cases, results, etc. We just want to know how you

implemented the applications, problems you ran into, and any interesting insights and

tricks you discovered.

Create a single zip file and submit Lab1 using the turn in link provided on the webpage.

Make sure to include your name in the report.

Setup a time to demo your applications to the TA or instructor.