CS/ECE 5785/6785: Lab 1

(back to: main 5785 page, 5785 lab page)

Before You Start

Read the lab web page completely. That page contains important information.

Objectives

The purpose of this lab is to become familiar with our development boards and with the CodeWarrior development tools, and to develop basic skills that subsequent labs will build on. Please read the entire lab assignment before starting to work on it.

Tasks

Create a "hello world" project and download it to your board.
Create a ColdFire application that blinks the 4 programmable LEDs on your board as a counter.
Show that you can measure the execution frequency of your processor.

Powering up the Board

Put the M52233DEMO board in front of you with the largest-font text facing so you can read it.
Ensure that the board's jumpers are as follows:
- PWR_SEL set to VB
- VX_EN, BDM_EN, and POT_EN are closed
- LED_EN, CTS, RTS, RXD, TXD are closed
Turn the board ON
Connect the board to the USB port on your lab machine. The board takes power from USB. The D301 and D302 LEDs on either side of the USB port should turn on, as should the VDD LED. If these aren't on, something's wrong -- make sure you've followed all instructions and then talk to an instructor.

Running a Hello World

Start "CodeWarrior for ColdFire" on your machine.
Click File -> New -> Bareboard Project
Give your project a name and uncheck "use default location" so you can specify a location on your USB drive
Under "ColdFire Evaluation Boards" / "ColdFire V2" select M52233DEMO, then click "next". If you pick the wrong board type here, nothing else will work.
For "connection to be used" select the top option "P&E USB BDM Multilink"
Click "next" a few more times and finish creating the project.
Make sure you are in the "C/C++ perspective" using some buttons at the top-right
Use a button at the left side of the screen to bring up the "CodeWarrior Projects" window, select the project you just created, and under Sources find its main.c.
Under "project" select "build all" -- this should build your application. There should be no compile errors.
Under "Run" select "debug" -- this runs your application under a debugger.
Now you can either single-step through the code or else click "Resume" to run the program. A "ColdFire Console I/O" window should appear with the text printed by your application.
Change your application to print something different. Make sure it works.

Blinking LEDs

Create another new application, as above.
Delete the printf code.
Add this code to the begingging of main():
```
MCF_GPIO_PTCPAR = MCF_GPIO_PTCPAR_DTIN0_GPIO;
MCF_GPIO_DDRTC = MCF_GPIO_DDRTC_DDRTC0;
MCF_GPIO_PORTTC = 0x00;
```
These lines respectively configure a pin as general-purpose I/O, enable the signal as a digital output, and turn the signal off. This pin happens to be connected to LED0 on your board.

NOTE: It is natural that at first all these definitions will seem confusing. There are many ways to start learning what is going on. First, right-clicking on an identifier such as MCF_GPIO_PORTTC will bring up a sub-menu including an option to see its definition in whatever header file it comes from. Also, you should connect these definitions with information about Port TC from the processor reference manual and the schematic for your demo board. After a bit of experience, you'll find it fairly easy to start putting the pieces together.
To turn on the LED set bit 0 of MCF_GPIO_PORTTC; to turn it off clear this bit.
Make sure you can blink this LED at a visible speed.
Change the "0" in the code above to access the I/O ports corresponding to LEDs 1, 2, and 3. These constants should be orred together, so for example to enable all four LEDs as general-purpose I/O you type:
```
MCF_GPIO_PTCPAR = 0
        | MCF_GPIO_PTCPAR_DTIN3_GPIO
        | MCF_GPIO_PTCPAR_DTIN2_GPIO
        | MCF_GPIO_PTCPAR_DTIN1_GPIO
        | MCF_GPIO_PTCPAR_DTIN0_GPIO;
```
Write a program that blinks LEDs 0-3 as a 4-bit counter, at a visible speed. This is what you should turn in.

Estimating CPU Frequency

NOTE: Your CodeWarrior project supports three build/run options: internal flash, internal RAM, and internal RAM with console support. For this part of the lab, DO NOT use the one with console support as this causes the processor to run at a slower speed. Rather, use one of the other two options. It shouldn't matter which.
Using the ColdFire programmer's reference and the CodeWarrior build tools reference manual (see the "links" part of the main lab web page), create a block of code whose execution requires a number of cycles that you can count. This may involve inline assembly (the manual covers this). I suggest using a large block of nop-type instructions.
Once you have a block of code that takes a known number of cycles to run, put it into a loop and run it enough times that it takes very close to 1s to execute. Flip the sense of an LED every time this loop completes.
Multiply the number of loop iterations by the number of cycles taken by your block of code. This is the number of cycles per second that your processor executes. Include this number in your lab report.

Lab report

Include printouts of your two (commented!) programs.

This page is maintained by John Regehr, mail me if you find a mistake or if any content is unclear.