Pre-Lab 1: An A-maze-ing Programming Problem

Note: This pre-lab should be completed before starting the first laboratory assignment for this course.

The problem we will be trying to solve for the semester was originally taken from a puzzle book. Here is the problem as defined by the puzzle book.

“In the forest, you will find beehives and more importantly honeycombs. Along the path are bees. The number of bees at any given location is indicated by a number. There are a few ways your bear can travel to the forest. Your aim is to teach your bear how to make his way to the forest while encountering as few bees as possible.”

Take a few minutes and see if you can solve the puzzle. While the problem may seem trivial, we will be using this as an example to show how various programming methods can be used to develop a solution that can be implemented with the assembly language that you learned in lecture. Hopefully, later on in your engineering careers, this sequence of labs will help you realize how there are many ways to resolve a problem and that creating a program may simplify the solution.

Now let’s see if you can translate your path through the maze into a flowchart. We will need to break it down into the individual actions that the bear can take and make sure that it can be executed by the program. This leads to the following assumptions.

1. Assume the hungry Bear is initially facing north with his knapsack. In the knapsack is a blank notepad with a pencil and eraser. (This is our explanation for how the bear keeps track of various values) The length of each step is exactly one square.
2. There are certain things that the bear can do or check in the attempt to exit the maze. The bear could take a step into the next room, check to see what type of room is encountered, or decide on which way to go next.

The entire list of instructions that the bear can take are listed below. Compare it with your own list of instructions that you thought to see how close you were.

Actuators and corresponding unconditional instructions

1. Take a step
2. Turn left
3. Turn right
4. Turn around
5. Count and record the number of bees in your notepad

Sensors and corresponding conditional instructions

1. Did you hit a wall?
2. Can your left paw touch a wall?
3. Can your right paw touch a wall?
4. Are you in the forest?
5. Do you see any bees?
6. Are you thinking of a number {not equal, less than, greater than, or equal} to 0?
7. Is the number on page N of the notepad {not equal, less than, greater than, or equal} to some constant?

Notepad operations

The bear can remember 8-bit unsigned and 1-bit (binary) numbers. The bear records a number in his notepad. He can only save one number per page. You may assign a descriptive name to a page (ex. bees), simply use the page number (page1), or think of it as a variable (X). In the following example X = 0.

Nodes

1. Start
2. Stop

Tips and Tricks

• You may not need all the instructions provided.
• Although not required, you can use subroutines.

Take a few minutes to see if you can sketch-out your flowchart. If you don’t know where to start; don’t worry, in the next few sections I will step you through how to write your own flowchart.

The path through the maze can be modeled as follows. Figure 2 provides an overview of the process we will be implementing in our labs. Each block can be considered a collection of the various actions described above and will be expanded on in future labs to describe exactly what our assembly program will be doing. For example, this pre-lab will focus on defining the “Which Way” block, which determines the direction the bear should face while going through the maze.

First, we need to clarify what the WhichWay block will be doing. From Figure 2, we know that the bear has just entered a room in the maze and now needs to determine which direction to go. The bear will be taking another step after the Which Way block, so we only need to make sure that the bear is in the correct orientation. There are two ways the bear can decide which way to turn when entering a room. You can count how many rooms the bear has passed or identify what type of room the bear is in. We will be doing the latter for our lab. Based on this information, these are the only instructions needed for this flowchart.

1. Turn left
2. Turn right
3. Turn around
4. Did you hit a wall?
5. Can your left paw touch a wall?
6. Can your right paw touch a wall?
7. Increment the number on a page
8. Is the number on page N of the notepad {not equal, less than, greater than, or equal} to some constant?

With that in mind, we need to define a way to identify the rooms the bear enters.

Here is a standardized naming convention to help you define the decision points in any maze. In order to provide a design example, the following maze identifies the squares (i.e., intersections) where the bear needs to make a decision for the shortest path solution.

Squares are numbered by concatenating the binary values (yes = 1, no = 0) for the answers to the following three questions (sensor inputs).

Can your left paw touch a wall? – Did you hit a wall? – Can your right paw touch a wall?

The answers to these three questions provide all the information that our bear can know about any given square. Let’s look at a few examples to see how this works. After taking the first step the bear can touch a wall with his left paw (1), has not hit a wall (0), and cannot touch a wall with its right paw (0). For our convention, this would correspond to input condition 4 = 100_2. As seen in the illustration, those types of squares are labeled number 4. Assuming the bear turns right; after taking another step the bear finds himself in a hallway where his left and right paws touch a wall and he does not hit a wall. This corresponds to square  5 (101₂). Although you could write a 5 in this square, for the sake of brevity, the square is left blank (your bear walks down a lot of hallways). Notice that the numbers are based on the direction the bear is facing and not a universal reference point, like facing north. This corresponds to the fact that within the maze our bear has no idea where north, or any direction for that matter, is (our bear forgot his compass). So, let’s continue to the next intersection. Here the bear’s left paw cannot touch a wall (0), he does not hit a wall (0), and his right paw can touch a wall (1). We therefore would write a 1 (001₂) in this square. Continuing in this fashion all intersections are identified for our minimum solution.

Using the naming convention and the shortest path through the maze presented in the last section, let’s design a solution for the shortest path.

Build a Truth Table

Here are all the possible squares our bear could encounter and a short description of the situation he is facing.

For your minimum solution your bear should encounter squares 1, 3, 4, 5, and 6. Once again we did not include in our illustration situations where the bear has no choice (3 = left corner, 6 = right corner, and 5 = hallway).

Draw your Flowchart – Solution for a Fully “Deterministic” Maze

A fully deterministic maze is one where for any given intersection the bear will always (it is predetermined) take the same action. For example, for your puzzle solution, whenever the bear encounters intersection 4 he will always turn right. Fora a non-deterministic maze he may turn right one time and turn left another. If you look at our shortest solution to the maze you will discover that it is fully deterministic, and so it lends itself to this simple solution.

It is always a good idea to check your answer (or the given one) to see if it actually teaches the bear how to count bees and find the shortest path out of the maze. Once you have your flowchart, implementation in the C programming language or Assembly is fairly straightforward.

In subsequent labs, we will be working with the same bear in the same maze; however you will all be mapping out and trying to teach your bear how to follow a different path. To help everyone plot a unique path, you will need to locate your target square.

Please use the maze included at the start of this lab and “theMaze.bmp” that is linked in the Page 2 section under Deliverable for Prelab 1.

Write down the last four digits of your student ID as two 2-digit decimal numbers. These digits will provide the coordinates (row and column) of your target square. For example, if the last four digits of your student ID were 7386, your two 2-digit numbers would be 73 and 86. Divide by 20 using long division on each number and write the remainder down. Those remainders are now your row and column numbers. In our example, 20 dives into 73 three times with a remainder of 13 and into 86 four times with a remainder of 6. Next convert both numbers into a hexadecimal number. For our example, 13 = 0x0D (where the prefix 0x signifies a number in hexadecimal) and 6 = 0x06. Your target square would therefore be in row 0x0D and column 0x06.

Find a path through the maze such that:

1. The bear goes through the target square.
2. The bear must get lost at least once. Specifically, he must at some point turn-around. This is typically, but does not need to be, at a dead end.
3. There are any number of paths that can take your bear through the target square, get lost, and into the forest, you now want to find the one that results in the numbers of bees encountered being closest to but not exceeding 15 (inclusive).
4. Finally, the maze must be non-deterministic. This means that at some intersection along the path the bear will need to take a different action. For example, the first time he encounters a T-intersection he turns left and the second time he turns right. The good news is that, if your path meets the first three criteria, the odds are extremely high that it will be non-deterministic.

Let’s look at how you can develop a flowchart for your unique path.

As previously mentioned, most maze solutions are non-deterministic. The phrase “not fully deterministic” means, while one set of input conditions in one part of the maze will determine one action (go straight), in another part of the maze the exact same conditions will require a different action (turn right). By looking at your truth-table you can recognize a “non-deterministic” path as having two or more 1’s in the same row. A quick inspection of my truth table reveals that, for the shortest path solution (Figure 4), the bear follows a fully deterministic path. Specifically, for any given intersection the bear will always take the same action. For example, if the bear’s left paw is touching a wall (1), he does not hit a wall (0), and his right right paw is not touching a wall (0), then the bear will always turn right. Following is one path example that illustrates how to solve a non-deterministic maze.

Let’s begin by looking at the sequential actions that must be taken as we encounter each intersection.

The good news is that with the exception of square number 1 all other actions are deterministic. The bad news is that only when we encounter room 1 after the second time do we start turning left. To solve this more difficult problem, we will create a binary tree that allows us to resolve all 8 squares, allowing us to then take any action needed. This binary tree can now be easily translated into C++ or Assembly.

A more modular solution separates the identification of the square (referred to as a room) from the action to be taken. Identification of the room is placed into a C++ or Assembly subroutine which returns the room number. The calling program must then determine the action to be taken based on the room number returned. The flowchart for the room subroutine is provided here and once again easily implemented in C++ using if or switch conditional instructions as discussed in the next lab.

Here are step-by-step instructions for solving your maze.

Begin by making a copy (electronic or paper) of the maze and drawing your bear’s path through the maze. When you are happy with your new path, follow the methodology previously discussed to build your truth table. Verify that your path meets the design criteria (passes through the target square while encountering the minimum number of bees and getting lost once). Remember, your target square may not be along the original solution path.

It is now time to teach your bear how to navigate the new path by writing a flow chart. To accomplish your goal you will need to apply everything you have learned so far plus add a few Notepad operations. The notepad pages (i.e., variables) are used to determine which path your bear should take when he enters an intersection in which more than one action is possible. For example, the first time he enters intersection 1 you may want the bear to go straight, while the second time he encounters intersection 1 you want him to turn left. To resolve this conflict you would record in your notepad how many times intersections 1 had been encountered and then check your notepad before taking any action.

In addition to previously stated conditions, your solution must also meet the following negative criteria.

1. Your solution may not use a variable (notepad) to simply count how many steps the bear has taken in order to make a decision.
2. Your solution should use a variable(s) and not the number of bees encountered to help it make a decision.

Turn in the following material on the following pages (i.e., no more, no less). All work must be typed or neatly done in ink.

All labs should represent your own work – DO NOT COPY.

Title Page (Page 0)

The title page (Page 0) includes your picture (one that will allow me to match a name with a face), the lab number, your name, today’s date, and the day your lab meets.

Page 1

At the top of the page provide the last four digits of your student ID and describe how you calculated your target square. Include in your discussion how the resulting path met the design requirements defined in the pre-lab. For example how many paths did you consider before choosing your final path – how close did you come to 15.

Page 2

Next, using your favorite illustration (Visio, Illustrator, or Photoshop) program or the drawing tools included with your favorite Office program (PowerPoint, Excel, and Word) mark your target square with an X and illustrate your bear’s path through the maze). Also include on this page a table of “Sensor input combinations and actions” similar to Table 2. If you do not have access to any of those programs, there is a free online website called draw.io that works just fine.

Many drawing programs allow you to import a bitmap file, in this case the maze. You can find a bitmap and vector formatted picture of the Maze here. Once imported, draw your path, typically using the line tool. Next, number your intersections (but not corners or hallways) as illustrated in Figure 5 “Nondeterministic path example.”

Page 3

Again using your favorite drawing program, draw the flowchart for programming problem.

Your flowchart should resemble the one included with the lab and only use the provided instructions. Artwork of the sample flowchart is included here.

Page 4

Answer the following questions and complete the following table of binary, decimal, and hexadecimal numbers. You must show your work:

Shown below is a diagram of the CSULB Shield that you will be working with in the labs. As the semester goes on, you will be learning more about the different parts and how they interact with each other. For now, we will be focusing on the eight switches, the 7 segment display, and the eight discrete LEDs that are used in Lab 1.

Each of the switches is connected to an input pin of the Arduino Uno and the state of the switch (on or off) is represented by a value of 0 or 1. Those values are placed into register r6 by the code we will be suing in Lab 1. This way, we could figure out the state of the switches by looking at the values that are in r6. For example, if switch 7 was on, but 7 of r6 would have a value of 1.

The goal of Lab 1 is to connect the eight switches with both the 7 segment display and the eight discrete LEDs. This means that the values that are in r6 will also be copied or transferred to registers r7 and r8 respectively. If a value of 1 is copied over, that corresponding segment or LED will turn on. Answer the following questions using that knowledge.

Question 1: If switches 3 (SW.3) and 1 (SW.1) were moved to the ON position (value of 1 in r6), which segments on the 7 segment display will light up?

Question 2: Which switches need to be turned ON in order to display the number 2 on the seven segment display? Do not include the decimal point segment in your answer.

1. Your pre-lab report includes a title page (Page 0) with your picture (one that will allow the professor to match a name with a face). Title information includes lab number, your name, today’s date, and the day your lab meets (Monday or Tuesday)
2. Pages are in the order specified (see Deliverable)
   
3. You do not have any extra pages
4. You describe how you arrived at your path
5. Maze is not copied from another student (zero points)
6. Path is computer drawn.
7. Maze Path meets specified requirements
8. Intersections ar not drawn by hand and appear as shown in the example
9. Intersections are numbered
10. Intersections are numbered correctly
11. Truth table
12. Truth table is on the same page as the maze
13. Truth table is typed
14. Truth table matches the maze
15. Flowchart
16. Flowchart matches your truth table
17. Flowchart is correct
18. Questions are answered with all work shown

Lab 1: An Introduction to Assembly

This lab is designed to introduce you to the Arduino Microcontroller Board, Atmel (part of MicroChip) Integrated Development Environment (IDE) and AVR Assembly Language programming. Plus, you will learn about the power of library files. Library files are simply files that you instruct AVR Studio to include in your program. In this lab you are going to include two library files. One named m328pdef and the other spi_shield.

Note: Please do the step-by-step simulation tutorial at the end of this lab. At the end of this tutorial you should be able to set switches to a given value by toggling Ports D and C pins. For example, after the tutorial you should be able to show how you would simulate an input of 0xAA.

What is New?

The following instructions and assembly directives are used in Labs 1. If you have any questions on any instructions or assembly directives a nice source of information, in addition to your textbook, is the Atmel AVR Assembler User Guide

AVR Assembly Instructions

Data Transfer
in r6, PINC    // Input port C pins (0x09) into register R6
out PORTB, r7  // Output to Port B from register R7
mov r8, r7     // Move data from register R7 into register R8
Arithmetic and Logic
clr r16       // Clear  register R16
ser r17       // Set register R17
Control Transfer
call WriteDisplay //Subroutine Call
rjmp loop     // Jump to the label named loop

AVR Studio Assembly

Directives
.INCLUDE      // < > means the file is in the AVR Studio folder
.INCLUDE “spi_shield.inc”     //” ” means the file is in the project folder
.CSEG         // Code Segment
.ORG 0x0000   // Code Origin
Labels
loop:
Comments
; // /* */

Introduction to AVR Studio

In lab you will be spending most of your time working within an IDE. For our labs we will be working in the AVR Studio IDE. As shown in the figure and discussed in the next few sections the IDE lets us write our program in a human readable form, known as assembly, and then translate it into a machine readable form understood by the ATmega328P.

Create a New Project

The best way to learn about the AVR Studio IDE is to start playing with it. So let’s get things started by launching AVR Studio and Opening a New Project.

Select Atmel AVR Assembler and check both check boxes(Create initial file and Create folder). Name your project (Lab1) and browse to location where you want it saved. Click Next >>.

In the next window select AVR Simulator 2. For the Device, select ATmega328P. Click the Finish button.

Congratulations, you are ready to start programming within the AVR Studio IDE!

Assembly Directives

All assembly programs contain assembly directives and assembly instructions. Assembly directives are instructions to be read by the assembler. In our lab, the assembler is included with AVR Studio IDE. As you have seen, AVR Studio is a program that runs on your computer and is responsible for translating your human readable assembly program into the machine language of the microcontroller.

We begin our program with an Assembly Directive. First, locate the program window within the IDE. This is the blank window in the center of your AVR Studio application. The title bar should include the location of your program and end with the name of your program and the “.asm” extension. Enter the following lines into the program window.

You can probably guess that here we are telling the assembler that we would simply like to include some comments for the individual reading our code. To include comments, you can use the C language notation // comment line and /* block comment */ or unique to assembly a semicolon ; character.

Now let’s add some code which intended strictly for the assembler, not the reader or the microcontroller. The difference is important.

.INCLUDE 
.CSEG
.ORG 0x0000

The “dots” tell the assembler that these lines are talking to the assembler and not to be turned into machine instructions.

Without overly complicating our first program, I will just note that the INCLUDE assembly directive tells the assembler to copy into our program all the text contained in a file named m328pdef.inc. For now, we do not need to know what is in this file, other than to note it will help us in writing a more human readable program.

The CSEG statement tells the AVR Studio Assembler to place the following material in the Code SEGment of memory. For the ATmega328P, this means Flash Program Memory. The ORG statement tells the assembler to start placing code at this address in Flash Program memory.

Programming Convention Because it is so important to remember when a line is intended for the Assembler (Assembly Directive) and when a line is to be converted to a machine instruction intended for ATMega328P microcontroller (Assembly Instruction), I always capitalize Assembly Directives and place in lower case letters Assembly Instructions. AVR Studio is not case sensitive, so this convention is not required for your assembly program to assemble correctly – it is however required by the instructor.

Now let’s add our first label. Enter the following line after the .ORG 0x0000 assembly directive:
RST_VECT:

The label RST_VECT stands for ReSeT VECTor and is only there as a point of programming style (i.e., it helps the reader know that the code to be executed on reset follows). What the assembler does is quite a different story. Whenever the assembly sees a label, it places the label name and its corresponding address, in this case we know it is 0x0000, into a look-up table.

Now if you ever want to reference this location in your program, you can use the name and let the assembler worry about the address.

Congratulations, you have for now completed your initial conversation with the assembler. You have asked it to include some comments, include more assembly directives located in another file, setup to write some code at address at 0x0000 in program memory, and finally to associate this address with the name RST_VECT. What you haven’t done is write anything that the AVR microcontroller will ever read. Once again it is important to know when you are talking to the assembler and when your code will be used to generate machine instructions to be run by the microcontroller. So let’s start generating assembly instructions intended for the microcontroller.

Assembly Instructions

Just as you are reading the step-by-step instructions on this page so you can write your first program, the microcontroller in Figure 5 reads the step-by-step instructions contained in the program to learn what is intended by the programmer. This is the “Machine Language” of the computer. This language is comprised of only ones and zeros. For example, this binary sequence 0010011100000000 tells the AVR computer (aka microcontroller) to set all the bits in register 16 to zero. All these 0’s and 1’s are not very easy for us humans to understand. So instead we humans have created a human like language comprised of abbreviations (known as mnemonics). This is known as Assembly Language. By definition then, there is a one-to-one correspondence between a machine instruction and an assembly instruction. For our machine code example, the equivalent assembly instruction is clr r16.

Registers Our microcontroller contains 32 general purpose registers labeled R0 to R31. For now you can think of registers like variables which can hold up to 8-bits of information (00000000₂ = 0₁₀ to 11111111₂ = 255₁₀). To learn more about number system read Chapter 1 “Introduction” in your textbook or Appendix A – Number Systems in my Lecture 1 notes.

It is finally time to write our first assembly instruction. Add the following assembly instructions to your program.

rjmp reset     // jump over the IVT, tables and include file(s)

The assembly instruction rjmp Reset instructs the microcontroller to jump to the yet to be defined label named Reset. You will also see I have included a comment. The meaning of this comment will become more clear over the remainder of the semester.

The Anatomy of an Assembly Instruction

Each assembly instruction is defined by an operator and one or two operand fields. For our clr r16 example, the clear instruction’s operator is clr and it has one operand r16. Our first program line also contains a single operand instruction. In this case, the operator is rjmp and the operand is reset.

Introduction to the Arduino Proto-shield

A schematic of our Arduino Proto-shield is shown in Figure 6. It includes 8 switches, 1 push button, 10 discrete LEDs, 1 seven segment display, and 2 D flip-flops. If you were to add up all the inputs and outputs required to support this proto-shield you would come up with 29. The Arduino Uno board, designed with the ATmega328P microcontroller, only has 23 general purpose digital I/O pins. So how do we solve the problem? Luck for us the ATmega328P includes a Serial Peripheral Interface (SPI) subsystem which allows us to send 8-bits of data as a serial string of 1’s and 0’s. By adding two 74HC595 8-bit Serial-to-Parallel shift registers to our Proto-shield as shown in Figure 6, and using the SPI subsystem, we are able to generate 16 new outputs. We will use these outputs to drive 8 discrete LEDs and our 7-segment display.

The ATmega328P Serial Peripheral Interface

Additional information can be found in Chapter 10 of the textbook or Section 18.2 of the ATmega328 Datasheet.

A conceptual representation of how the ATmega SPI subsystem works with our Arduino Proto-shield is shown in Figure 7 “SPI Master-slave Interconnection.” You can find the original of this picture in Section 18 “SPI – Serial Peripheral Interface” in the ATMEL doc8161.pdf document. On the left is the SPI subsystem, it includes the 8-bit Shift Register and the SPI Clock Generator. To send 8 bits of data to the Arduino proto-shield you simply need to write to this register. The SPI subsystem takes care of the reset including generating the serial data stream and clock signal. On the right is an 8-bit shift register used to convert the serial data stream back to 8 discrete bits of data. For our proto-shield this 8-bit shift register is physically realized as a single 74HC595 Serial-to-Parallel shift register. Two generate the 16 output bits used on the proto-shield we daisy chain two 74HC595s and write to the SPI’s 8-bit shift register twice.

The SPI_Shield.inc Include File

To simplify your life – it is after all the first lab – I have already written all the assembly code you need to work with the Proto-shield. This code is contained in a separate file named spi_shield.inc. We will add this file to our program in the same way we included the m328pdef.inc “include” document an earlier part of this lab. Let’s begin.

• Download and add to your Lab1 project folder my spi_shield.inc file.
• Unlike, the m328pdef.inc file which contains equate statements, the spi_shield.inc file includes subroutines which need to be run by the                  microcontroller.
• Add the following lines of code to your Lab1 project file. Original code that you should have already added is shown in gray.

Quick Review and New Instructions for the Assembler

1. Can you Identify the comments?
2. Can you tell which lines contain Assembly Directives and which contain Assembly Instructions? Remember assembly directives typically, but not always start with a period and use upper case letters; while assembly instructions use lower case letters.

Do you remember the first INCLUDE assembly directive from earlier in the lab? The m328pdef.inc library is written by Atmel and allows you to use names in place of numbers. For example PINC which was introduced in lab 1 is equated to the number 0x06 in the library. Here is the actual equate statement from the library.

.EQU   PINC    = 0x06

So when you press the reset button, the AVR processor will first run the rjmp reset instruction. The rjmp instruction tells the processor to jump to the code starting at the reset label. This means the program will jump over (bypass) a table known as the IVT (to be covered later in the semester) and all the code included in spi_shield.inc. Which is a good thing; because we do not want to run any of the included programs until we are ready.

I wrote the spi_shield library. This library includes subroutines InitShield, ReadSwitches, WriteDisplay which allow you to work with the Arduino Proto-shield without knowing the details of how it works.

Why are the two include files placed at different locations in the program?

The m328pdef.inc library is written by Atmel and allows us to use mnemonics (abbreviations like PINC) in place of numbers (like hexadecimal 6). To allow us to use these mnemonic names as quickly as possible we insert this library at the beginning of the program. The spi_shield library is written by the instructor and contains instructions. This code must not be executed at reset so the library is inserted after the first jump instruction (rjmp reset) and above the label reset.

If you have played around with the Arduino IDE, you know that all Arduino programs have an initialization section named setup() and a looping section named loop(). Our assembly program written within the AVR Studio IDE will be configured in a similar fashion. In our case, the initialization section is labeled reset: and the looping section is again named loop:. In the next section you will write the initialization section to be used throughout the semester.

Initialization Section

How to Initialize the Stack

To accomplish almost anything useful in assembly you write a subroutine. To allow us to work with the Proto-shield I have written a number of ready-made subroutines for you to use. When you call a subroutine you need to save your current location on a stack. All computers have built-in hardware stack support. However, before we can save our return address on the stack we need to initialize our stack pointer (SP) register. You will learn more about stacks as the semester progresses. Add the following lines of code to your program right after the reset label.

ldi    r16,high(RAMEND)    // SP = 0x08FF
out    SPH,r16
ldi    r16,low(RAMEND)
out    SPL,r16

How to Use the InitShield Subroutine

We are now ready to call our first subroutine. Add the following line to your program.

call  InitShield

The InitShield subroutine takes care of all the initialization required to use the Arduino Proto-shield. You only need to call it once at the beginning of your program, just after stack initialization. That is it, you are now ready to use the ATmega328 GPIO Ports and SPI subsystem to work the Arduino Proto-shield – allowing you to read the 8 switches and whenever you want to update the 7 segment display and/or 8 discrete LEDs. To make your life even simpler the spi_shield file also includes the subroutines ReadSwitches and WriteDisplay.

Looping Section

To programmatically connect our switches to the 7 Segment display we will (1) read the 8 switches into register r6, (2) move register r6 into r7, and (3) then write r7 to the 7 Segment display. We will maintain the connection by looping the program around these three instructions using the Relative Jump (rjmp) instruction. To accomplish steps 1 and 3 you will use two subroutines that I have already written for you named ReadSwitches and WriteDisplay. In the next two sections we will take a closer look at both.

You can find out more about these and other instructions in AVR Studio by clicking Help in the menu bar and selecting Assembler Help. Let’s take a little closer look at our program and how it works.

How to Use the ReadSwitches Subroutine

In Figure 6, on the left hand side, you see bits in Register 6 (in purple) assigned to each of the 8 switches. Register 6 is not hardwired to the switches. Instead, we will use the ReadSwitches subroutine to read the GPIO ports and perform all the logical operations needed to map these switches to Register 6.

Remember, changing the switches does not automatically change the value in register r6 – you must call ReadSwitches.

How to Use the WriteDisplay Subroutine

In Figure 6, on the right hand side, you see bits in Register 7 and Register 8 (in purple) assigned to each of the lines controlling the input pins of the 7 segment display and 8 discrete LEDs. To change the 7 segment display or any one of the discrete LEDs, you make the change to bit(s) within the associated register and call the WriteDisplay subroutine. The WriteDisplay subroutine will take care of all of the housekeeping required to map these bits within the registers to their corresponding pins. Please, do not get confused. These registers are not hardwired to the 7 segment display and discrete LEDs. Instead they are used as arguments to the WriteDisplay subroutine which sends them to the SPI Serial Register, which in turn sends them as a serial stream of data to the 74HC595 ICs on the Arduino Proto-shield (see Figure 7).

If you are asking yourself “What is a 7 segment display?” and “What is a 74HC595?” among probably many other questions, you can find many of your questions answered in Appendix B   “How the Parts of the Arduino Proto-Shield Work.”

Remember, changing bits within these registers does not automatically change the pins on the 7 segment display or discrete LEDs – you must call WriteDisplay.

In the next section we will see how the ReadSwitches and WriteDisplay subroutines can be used to create software wires between the 8 switches and 7 Segment display.

Making SPI Software Wires

Because the switches are not physically connected to the 7 segment display, we must create software wires to transfer the data. In this section, we want to connect all 8 switches to their corresponding segments of the 7 Segment display (the numeric display on the top right in Figure 8) using our two new subroutines and a new assembly instruction. Once you have completed this section, the CSULB shield should work as discussed in the questions from Prelab 1.

Let’s review what you have accomplished to date. In “The SPI_Shield.inc Include File” section you initialized the stack pointer and included SPI subroutines InitShield, ReadSwitches, and WriteDisplay. You ended by calling InitShield to setup the SPI Subsystem of the ATmega328P microcontroller.

In the “How to Use the ReadSwitches Subroutine” section you learned how to connect the 8 switches on the Proto-board to Register 6 (in purple) as illustrated on the left hand side of Figure 8. In the “How to Use the WriteDisplay Subroutine” section you learned how Register 7 and Register 8 (in purple) can control the input pins of the 7 segment display and 8 discrete LEDs. To make our software wires we simply need to move the contents of Register 6 into Register 7. To do that, we will use the assembly mov instruction.  Add the following lines to your program.

The rjmp instruction loops back so that future changes made to the switches are sent to the 7 segment display.

On Your Own

Apply what you have learned by connecting the 8 switches to the eight discrete LEDs. Add the appropriate instruction to do this to the main loop. Like the 7 segment display which is mapped to register r7, the eight discrete LEDs are mapped to register r8. Your code should now update both the 8 discrete LEDs and 7 segment display. You only need to call the WriteDisplay subroutine once.

Debug Workshop 1 — Simulate Your Program

Important The following section summarizes what you learned in Debug Workshop 1 covered in Lab 1 Part A and introduces the step over button  to skip over subroutine calls. You must complete this section before starting lab 2. You may/will be tested (ex. Quiz 1) on the information contained in both Debug Workshops (1 and 2) plus you will need to demonstrate proficiency with the simulator (i.e., debugger) as part of the sign-off for lab 1.

PLEASE REFER TO THE SIMULATION TUTORIAL FOR ADDITIONAL INFORMATION AND TO UNDERSTAND WHAT YOU ARE DOING.

Assemble your program by pressing the Assemble F7  icon. If there are no syntax errors you should see the following line in the Build window pane (usually located at the bottom of the screen).

Assembly complete, 0 errors. 0 warnings

Important – Reading and Remembering can SAVE HOURS OF TIME!

• One very common misconception is that when the assembler says there are 0 errors and 0 warnings that your program will work. That is almost always not the case! This message only tells you that the assembler understood everything you entered. Technically speaking, it is saying that your syntax is correct. Unfortunately, ninety-nine times out of a hundred your program still contains “programming” or logical errors. You have to find these errors all by yourself. Luckily, AVR Studio includes a Simulator to help you.
• Students try to make their broken programs work by making random changes and downloading them to their Arduino boards to see if they “now” work. This process is repeated for hours upon hours until more errors are introduced than corrected. I typically receive an email after 4 to 8 hours of frustration, asking why the program doesn’t work. The first thing I ask is if they have simulated the program. The typical answer is NO. One of the reasons I am including this lab at this early stage in the course, is so you cannot download to your Arduino board and so make this common mistake. ALWAYS SIMULATE YOUR PROGRAM.

Once your program has assembled successfully enter AVR Studio’s debug mode by pressing the Assemble and Run  icon.

If closed, expand the Registers folder in the Processor pane and PORTC and PORTD in the I/O View pane within AVR Studio. Select PORTD. In the window below the I/O View, you will notice that PORTD has three rows of eight bits, represented by square boxes.

Each box corresponds to a flip-flop or pin as defined in Table 1 “Port Pin Configurations.”

Table 1: Port Pin Configurations

Inputs		Outputs
DDRXn	PORTXn	I/O	Pull-up	Comments
0	0	Input	No	Read “Synchronized” PINXn
0	1	Input	Yes
1	X	Output	N/A	Write bit to PORTXn

Looking at Figure 9, lets start with the first row and the Port D Data Direction Register (DDRD). Each box in this row corresponds to flip-flop. As defined in Table 1, if this box is filled in (Flip-Flop DDRXn = 1) then this port pin will be an output. Conversely, if the box is not selected then the port pin will be an input.

The second row of Figure 9 may be visualized as a physical Port D pin (PIND). If you want to simulate a change on an input pin, say from a switch being toggled, this is the box you would set (input = 1) or clear (input = 0).

The third row contains the Port D register (PORTD). Each box in this row corresponds to flip-flop PORTxn. As described in Table 1, these flip-flops are interpreted differently based on if the port pin is defined as an input (DDRXn = 0) or an output (DDRXn = 1). If DDRXn = 0 (input), then the corresponding PORTXn flip-flop adds (PORTXn = 1) or removes (PORTXn = 0) a Pull-up resistor (see fourth column in Table 1). If DDRXn = 1 (output), then the corresponding PORTXn flip-flop defines the output state of the pin. For example, if PORTXn = 1, the pin is driven high. If you want to see how your program modifies a pin defined as an output, PORTXn is the box you would look at.

As an example, lets assume all Port D pins are to be inputs with pull-up resistors assigned to the two most significant inputs. In this case all the boxes in the DDRD (second row) would be empty (logic 0) and the two most significant boxes of the last row would be filled in (logic 1). This is the case depicted in Figure 9.

The above example corresponds to switches 7 and 6. To simulate turning a switch ON simply check the box corresponding to the desired input pin (PIND).

By clicking on the Step Over (F10)  button, single step the program to the last line of your program.

Now, open the PORTC window by selecting PORTC in the I/O View window.

Let’s simulate switch SW0 in the up/ON position (logic 1) by checking the first box in the PINC Register.

With respect to Table 1 “Port Pin Configurations” and the above image (Figure 10), note that PORT C bit 0 has been configured as an input with a pull-up resistor and the input is currently at logic 1. If it is not already open, expand the Register entry in the Processor window pane (normally located in the upper-left window pane). Notice that register R06 is cleared (0x00)

Single step (using Step Over) through your program so the input instruction is executed:
call ReadSwitches // read switches into r6

In the Processor window you should now see r06 now set to 1 (0x01).

Single step your program so the output instruction is executed:
call WriteDisplay // write r7 to the 7 segment display

If you have followed the lab instructions exactly and correctly written your one line of code, you should now see the following in the processor window:

Lab Sign-off

At signoff, you will be given an arbitrary hexadecimal number.  You should be able to convert this number to binary and simulate the corresponding switch configuration using the PINC and PIND registers in AVR Studio.  You should also be able to use the processor window to demonstrate that your program does, in fact, programmatically “wire” the switches to the 7-segment display (r7) and discrete LEDs (r8).

For example: given 0xA2, input 0b10100010 into PINC and PIND registers.

How to Create and Print-out a List (.lst) File

At the end of each lab, you will turn in a List file version of your program. A list file contains both your assembly program and the machine program generated by the assembler. First let’s verify that AVR Studio is set to generate a List file. In the menu bar select Project and then Assembler Options

Now whenever you assemble your program, a file with a .lst extension will be created in your project folder. Assemble your program  and then open the generated list file.

You will see that along with your program the list file includes a lot of other stuff. Most of this is the text from the included m328pdef.inc document. This is the document that includes all the equate Assemble Directives which allow us to use mnemonics for all our registers in place of their actual addresses. If you have not done so already browse this material to see how AVR Studio does it. You should see something like the following.

AVRASM ver. 2.2.7 c:\users\Documents\Lab1\Lab1.asm Tue Aug 21 13:05:53 2018

[builtin](2): Including file 'C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATmega_DFP\1.2.209\avrasm\inc\m328pdef.inc'
c:\users\Documents\Lab1\Lab1.asm(10): Including file 'C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATmega_DFP\1.2.209\avrasm\inc\m328pdef.inc'
c:\users\Documents\Lab1\Lab1.asm(16): Including file 'c:\users\Documents\Lab1\spi_shield.inc'

/* Lab 1 - An Introduction to Assembly

* Version x.0 <- update the version each time to print your program
* Written By : Your name here
* ID # : Your CSULB student ID number
* Date : Date the lab report was turned in, NOT THE DATE DUE
* Lab Section : Your day and time
*/

;***** Created: 2011-02-09 12:03 ******* Source: ATmega328P.xml **********
;*************************************************************************
;* A P P L I C A T I O N N O T E F O R T H E A V R F A M I L Y
;*
;* Number : AVR000
;* File Name : "m328Pdef.inc"
;* Title : Register/Bit Definitions for the ATmega328P
;* Date : 2011-02-09

There is a lot of extra material that is not useful, so there are several things to remove. Everything that comes from any include file must be removed since it is not a part of the main code. Delete material from this line…

;***** Created: 2009-12-11 15:36 ******* Source: ATmega328P.xml **********
;*************************************************************************

up to and including this line.

; ***** END OF FILE ******************************************************

Your list file must include the AVR Studio Assembler version and time stamp!

AVRASM ver. 2.1.42                         Tue Aug 23 16:57:15 2011

The “Resource Use Information” should also be deleted before you print out your list file.

Delete material from this line…

RESOURCE USE INFORMATION
------------------------

up to, but not including this line.

Assembly complete, 0 errors, 0 warnings

You can clean up and format the final version of your file in AVR Studio or your favorite text editor. Regardless of the text editor your final document should be formatted as follows.

Font: Courier or Courier New
Size:  9 or 10 point
Paragraph Spacing: 0 pt before and after
Line Spacing: Single
Page Layout: Landscape

Next, clean up unwanted spaces so your code is aligned and easy to read. DO NOT FORGET THIS STEP. Your touched up list file should now look something like this template.

AVRASM ver. 2.1.42                              Tue Jan 10 11:24:47 2013

/* Lab 1 - An Introduction to Assembly
 * Version x.0 <- update the version each time to print your program
 * Written By  : Your name here
 * ID #        : Your CSULB student ID number
 * Date        : Date the lab report was turned in, NOT THE DATE DUE
 * Lab Section : Your day and time
 */

.CSEG
.INCLUDE 
.ORG 0x0000

RST_VECT:

000000 c131          rjmp reset               // jump over IVT, tables, and include files

.ORG 0x0100              // place all the code that follows starting at the address 0x0100.

.INCLUDE "spi_shield.inc"

reset:

// Initialize the stack pointer

000132 e008        ldi r16, HIGH(RAMEND)   // IO[0x3e] = 0x08

000133 bf0e        out SPH, r16

000134 ef0f        ldi r16, LOW(RAMEND)    // IO[0x3d] = 0xFF

000135 bf0d        out SPL, r16

000136 940e 0100   call InitShield

loop:

000138 940e 0116       call ReadSwitches   // read switches into r6

00013a 2c76            mov r7,r6           // wire switches to the 7 segment display

00013b 940e 0121 call WriteDisplay         // write r7 to the 7 segment display

00013c cffb rjmp loop

Assembly complete, 0 errors, 0 warnings

NOTE: THIS IS JUST AN EXAMPLE. YOUR LIST FILE SHOULD CONTAIN THE CODE FOR THE LAB YOU ARE SUBMITTING.

Finally, if you have not done so already, set your printer page layout to landscape mode.  Preview your printout before you actually print it out to save paper. Double check your document to make sure there is no word wrap. Your printout should never include word-wrap. If you do see a line wrapping in the print-out, go back and correct the line and re-print your list file. Print your list file.

Now single step  your program noting how the change input modify the registers. Use the step over button  to skip over the subroutine call instructions. This button tells the simulator to run the code in the subroutine without showing you.

Follow the instructions in Lab 1 “Debug Workshop 1” to simulate your program and verify your program reads the switches and moves them to register r7. Until you actually build your own proto-shield you will have to assume that my WriteDisplay subroutine works.

Design Challenge (2 Points)

You can skip this section if you are happy receiving a passing or even a good grade on the lab. If you want to receive an excellent grade you will need to accept the challenge. Specifically, the maximum grade you can receive on this lab if you do not accept the challenge is 18 points.

The purpose of this design challenge is to help you better understand how the I/O ports work and to how the subroutines ReadSwitches and WriteDisplay are written.

The SPI Shield which you will be assembling soon has two green status LEDs.  They are connected to the two least significant bits of PORTB, as shown in Figure 15.  The design challenge for Lab 1 is to create software “wires” between switches 6 and 3, connected to PIND6 and PINC3, and these two green LEDs. Make sure that switch 6 connects to PORTB1 and switch 3 goes to PORTB0.

This can be accomplished by implementing something similar to the ReadSwitches subroutine, where the inputs are read from the desired I/O port and then written to the output I/O port. Refer to Appendix A for an explanation of how the InitShield and ReadSwitches subroutines work. Note that if you are correctly calling the InitShield subroutine, you do not need to modify any of the Data Direction Registers (DDRx). PORTB should look like this if both LEDs are turned on after correct execution of this challenge:

Lab 1 Deliverable(s) / Checklist

STOP Read the Lab READ ME document contained in the Labs Folder.  Be absolutely sure you have followed all instruction in the “Lab Formatting” section of this document. Points will be deducted if you do not follow these instructions. You have been warned.

If you have not done so already, please purchase a Lab Notebook. Follow the guidelines provided in the “Lab Notebook” section of the Lab READ ME document.

Make sure you have read and understand the “Plagiarism” section of the Lab READ ME document, especially if you are repeating the class.

All labs should represent your own work – DO NOT COPY.

Remember before you turn in your lab…

1. Does your software program “wire” the switches to the 8 discrete LEDs and the 7 segment display?
2. Your lab report includes a title page with your picture (one that will allow me to match a name with a face), lab number, your name, today’s date, and the day your lab meets
3. The above information is duplicated in the title block of your assembly program as described in the lab. Do not forget to include the first line of your program containing the title of the lab. If you are not careful this line may be deleted and points deducted.
4. Your list file should include the AVR Studio Assembler version and time stamp.
5. Your list file should not include material from the m328pdef.inc or spi_shield libraries or Resource Use Information.
6. Include the Assembly line indicating that your Assembly program contains no errors or warning in syntax.
7. Your list file should be formatted as defined here.
   Font: Courier or Courier New
   Size: 9 to 10.5 point
   Paragraph Spacing: 0 pt before and after
   Line Spacing: Single
8. All fields within the program area (address, machine instruction, label, operand, destination operand, source operand, comment) must be aligned.
9. Your list file printout should be in landscape and not have any lines wrap from one line to the next.
10. Never turn in a program that is not debugged (i.e., contains logical errors).

Appendix

Pre-Lab 2: Room Builder and Direction Finder

Introduction

The Wake-up Machine
Plus Arduino Uno Version

In this prelab you will (1) learn more about the assembler, (2) learn how a 7-segment display works, (3) apply what you learned to display rooms within the maze on the 7-segment display and finally apply what you learned in EE201 “Digital Logic Design” and CECS100 to display the direction the bear is facing using (4) Boolean Expressions and (5) A flowchart.

The Assembler

Seven Segment Display

In this section, you will learn how a 7-segment display works. A 7-segment display is comprised of 7 LEDs labeled a-to-g plus the decimal point (dp).

Each LED segment can be represented as a single LED as shown schematically here with one of the in-line resistors.

When the input (anode) of the LED is connected to a 5v source through a limiting resistor and the output (cathode) is connected to ground, the LED is said to be forward biased. The LED emits light when operating in this mode (ON). If instead we wire the anode of the LED to ground, then no current can flow in the circuit and the LED is said to be reverse biased (OFF).

Traditionally, a 7-segment display is used to form all 10 digits (0-9) by turning on or off the LEDs in different combinations. For example to create the number 1 you would turn on segments b and c.

Part A – Room Builder

In the first half of the lab, instead of numbers we will be using our 4 switches and the 7-segment display to draw the 24 = 16 different rooms that our bear may encounter in any maze. As an example, let’s use our four switches to draw a room with a north and west facing wall. For this room we would turn on (up position) switches 6 and 4, leaving switches 7 and 5 in the off position (down). The resulting room configuration is shown in Figure 2.

Here are the sixteen possible situations or “rooms” our bear may find as he explores the maze. The decimal point dp and segments c, d, and e are always “off.” Segments a, b, g, and f are turned “on” and “off” to show the room configuration. Working from Figure 2, complete the drawing below by filling in the LED pin values and coloring in the LEDs that are turned “on” for each switch SW[7:4] combination. I have included a file named Room_Combination.JPG here for you to use.

After completing the drawing above you may have noticed that the following relationships exist between our switches SW[7:4], returned in register r6 by ReadSwitches, and the 7-segment LEDs, sent in register r7 as an argument to WriteDisplay. Figures 4 “MazeRoom” graphically shows how your program will work.

In the previous lab you connected your eight (8) switches to the 7-segment display by using the mov instruction. In essence you created a “software” wire between register 6 bit 0 and register 7 bit 0, register 6 bit 1 and register 7 bit 1, etc. As seen from a quick look at the crossing lines in Figure 4, this solution will unfortunately not work for your room builder code. Instead you will use two new bit instructions. The “Bit Store from Bit in Register to T Flag in SREG” (bst Rd, b) and the Bit Load from T Flag in SREG to Bit in Register” (bld Rd, b) instructions. Here is how these two bit instructions would be used to create the blue “software wire” between register 6 bit 7 and register 7 bit 6 (seven segment display segment G).

call ReadSwitches
bst r6,7 // wire switch 7 to segment g (south wall)
bld r7,6
call WriteDisplay

As shown in Figure 4, the call to ReadSwitches places the state of the eight (8) switches on the proto-shield into register r6 and the call to WriteDisplay copies the bits in register 7 to the 74HC595 8-bit Shift Register IC wired to the 7-segment display (see proto-shield schematic). The two lines bst and bld therefore functionally wire switch 7 to segment g. Let’s take a closer look.

Turn to “Appendix C ATMEGA328P Assembly Instructions” in your textbook and specifically Table C.4: “Bit and Bit-Test Instructions” or the free 8-bit AVR Instruction Set document 0856 available from Atmel, you can find it here.

The bst “Bit Store from Register to T” instruction copies bit 7 from register 6 into the T flag bit located in the status register (SREG) of the AVR processor. You can think of T as our general purpose 1-bit register. As most 8-bit data uses one of our 32 general purpose, single bits of data use the T bit. The bld “Bit load from T to Register” completes our “software” wire by sending the contents of the T bit to register 8 bit 6.

Working from the above example you should be able to write the next six assembly instructions to wire switches 6, 5 and 4 to 7-segment LEDs f (west wall), b (east wall) and a (north wall) respectively.

call readSwitches
bst r6,7 // wire switch 7 to segment g (south wall)
bld r7,6

… your code goes here

call writeDisplay

Part B – Direction Finder

In the second half of the lab you will be using two (2) more switches and the same 7-segment display to show the direction you want your bear to walk. For example, if your bear is heading north, and enters a room requiring a right-hand turn (see Figure 5), then you would turn on segment b indicating that the bear should go East.

For this lab, we will use Switches 1 and 0 on the development board to input the direction we want the bear to go. These switches correspond to port pins PINC.1 and PINC.0 respectively. As before, we will assume that these port pins have been input to register r6 as illustrated in the arduino-proto-shield schematic. The logic value corresponding to each switch position is defined by variables dir.1 and dir.0. The following table translates these two switch positions into their corresponding dir input values and outputs signals to LED segments f, a, b, and g of the 7-segment display.

Table 1: Direction to Segment Conversion

			Inputs		Outputs
Direction	SW1	SW0	dir.1	dir.0	Direction Segment ON = 1, OFF = 0
					LDg	LDb	LDf	LDa
South	DWN	DWN	0	0	1	0	0	0
East	DWN	UP	0	1	0	1	0	0
West	UP	DWN	1	0	0	0	1	0
North	UP	UP	1	1	0	0	0	1

Continuing with our initial example; we have a bear in a room with north and west facing walls (SW[7:4] = 0101), we want the bear to go east (SW[1:0] = 01). For this situation the switches would be set as shown in the illustration below.

Now that we know what we want we will look at two different ways to implement it using our microcontroller.

Boolean Logic

Applying what you learned in your Digital Logic Design class, construct a sum-of-products (SOP) expression for each direction segment. For our example, we would want to light the direction segment pointing east. All work should be included in your lab notebook.

To draw the Boolean equations in Microsoft Word select Insert – Equation …

Flowchart

In the last section, you applied what you learned in EE201 “Digital Logic Design” to create your Boolean equations to calculate the segment to be turned ON. In this section, you will apply what you learned in your programming class and in pre-lab 1, to construct a flowchart to determine which segment to turn on based on dir bit 1 and bit 0. Specifically, you will translate the flowchart into a series of conditional statements. For example, if dir bit 1 is equal to 0 and dir bit 0 is equal to 1 then turn on bit 1 of register r8. From the introduction to this section (Direction Finder) we know this will turn on segment b (i.e., spi7SEG = 0b00000010).

Draw your flowchart using your favorite drawing program (Visio, Illustrator, etc.).

Part C – Questions

1. A student flips the switches on their proto-shield, such that, switches 7, 2, and 0 are up, and the rest are down, as represented by the following blocks:
   
   The student then runs ReadSwitches and executes the following assembly code:
   clr r7
   bst r6, 2
   bld r7, 5
   bld r7, 3
   bst r6, 4
   bld r7, 7
   a. What is the binary value of register 6 (r6)?
   b. What is the binary value of register 7 (r7)?
   c. What is the value of the T bit in SREG?
2. The eighth bit of register 17 (bit # 7) needs to be moved into the fourth bit of register 18 (bit # 3).
   a. Write two lines of code to achieve this task using bst and bld.
   b. If the starting hexadecimal value of r17 is 0x7A, and the starting hexadecimal value of r18 is 0xEC, what will be the final hexadecimal value of r18 after performing your code?
3. A student is debugging their code for the proto-shield, and has tried to simulate a switch input as in problem 1. She has checked the following pins in the AVR simulator:
   
   
   When she runs ReadSwitches, register 6 (R06) and the watch window for “switch” contain a hex value of 0x80.
   a. Why does register 6 contain 0x80 and not 0x85?
   b. Show how the student should have clicked the pins in AVR simulator:
   
   

What Should I Turn In?

Turn in the following material. The page numbers may change if you need more room for certain parts but the order must be followed. Points will be deducted if this instruction is not followed. Make sure all your original work is in your Lab Notebook. All written material must be typed or neatly done in ink. Once again please do not copy.

Page

1. Title page with the pre-lab number, your name and picture, today’s date, and the day your lab meets.
2. A completed version of the Figure 3 “Room Combinations” picture.
3. Your assembly code from “Part 1 – Room Builder” Your code must be typed, but does not need to be assembled.
4. Four (4) Boolean Expressions for the four direction segments
5. A Flowchart of Direction Builder
6. Questions and answers to all questions.

Lab 2A: Build a Test Bench Room Builder

Introduction

As you hopefully remember from the previous lab, our long term objective is to help guide a bear through the following maze.

Towards that goal, in this lab you be writing code to create a software test-bench that can generate all the rooms by reading the left-most 4-switches, and turn on and off direction indicator LEDs based on the right-most 2-switches. To help you remember how everything should operate by the end of this lab, I have generated the following reference card.

PRINT OUT THE MAZE (FIGURE 1) AND THIS REFERENCE CARD (FIGURE 2) AND ALWAYS KEEP THEM WITH YOUR BOARD.

What is a Test Bench?

Over the semester, you will be writing assembly code subroutines to help our bear find his way out of the maze. But how do you know that a subroutine works unless you have built the whole thing? Testing subsystem elements has been a challenge since before computers were even invented. For electrical components, it was traditionally done on a “test bench” which was equipped with power supplies and signal generators to provide the input to the Device Under Test (DUT), also referred to as a Unit Under Test (UUT), and Volt Ohm Meters (VOM) and oscilloscopes to measure the output of the DUT. We have carried this nomenclature forward into the world of computer engineering.

To help us test our future software modules (DUTs), we will build a simple test bench comprised of switches to provide our inputs and the 7-segment display to let us view the output. As our design matures, we will no longer need our test bench and in fact in the latter labs you will not even use the switches. Specifically, in this lab, you will use the switches and seven-segment display to draw the different rooms that our bear may encounter in any maze and to provide him with directional information.

Ironically, one of the most difficult parts of any project is understanding what you (or the customer) want. Applying this principle to the task at hand, one of the most difficult parts of any lab is trying to understand what the instructor wants. To help you understand the overall objectives of a lab, I will from time-to-time include an “Owner’s Manual.” In these sections I will talk about how your program should operate when completed.

What is New?

Here are some of the new concepts you will be exploring in this lab.

• Working with Bits
• More on Simulation and Debugging
• Uploading to the Arduino

The following instructions and assembly directives are used in Labs 1 and 2. New items are underlined.

AVR Assembly Instructions

Data Transfer
mov r8, r7 // Move data from register r7 into register r8
in r7, PINC // Input port C pins (0x09) into register R7
out PORTB, r7 // Output to Port B from register R7
Arithmetic and Logic
clr r16 // Clear register r16
ser r17 // Set register r17
Control Transfer
call WriteDisplay // Subroutine Call
rjmp loop
Bit and Bit-Test
bst r7,7 // Bit store from register r7 bit 7 to SREG T bit
bld r8,6 // Bit load from SREG T bit to register r8 bit 6

AVR Studio Assembly

Directives
.DEF spiLEDS = r9 // Replace spiLEDS with the text r9
.EQU seg_a = 0 // Replace seg_a with the number 0
.CSEG // Code Segment
.ORG 0x0000 // Code Origin
.INCLUDE “spi_shield.inc” // “ “ means the file is in the project folder
.INCLUDE  // < > means the file is in the AVR Studio folder
Labels
loop:
Comments
; // /* */

Working with the Arduino Shield

You will be using your Lab 1 spi_shield file for the remainder of the semester. Before we begin, let’s review how to use the subroutines included in spi_shield.inc.

To read the switches on the Arduino Shield, you call an assembly function named ReadSwitches which will return the state of the switches in register r6. To turn ON and OFF the 8 discrete LEDs on the shield, you write to register r8. To turn ON and OFF each segment of the 7-segment display, you write to register r7. To send the r8:r7 register pair to the Arduino Proto-shield, you call the WriteDisplay subroutine. The switches, LEDs, and 7-segment display on our Arduino Proto-shield implement positive logic, which means that for the switches UP = 1 and DOWN = 0, and for the lights ON = 1 and OFF = 0. Remember: changes made in the r8:r7 register pair (see Note 1) will not be displayed until you call WriteDisplay.

Note 1: The colon “:” means concatenate (i.e., combine) these two 8 bit registers to create a 16-bit register.

Create the Lab2 Project

If you are using a lab computer I would recommend erasing everything in Drive D and using this area for your project. Do not forget to save often. At the end of the lab do not forget to save to your Flash drive.

1. Open AVR Studio and create a new Project named Lab2 (see Lab 1 for detailed instructions)
2. Copy over your spi_shield.inc written in Lab 1.
3. Copy the text in Lab1.asm into Lab2.asm
4. Update the title block
   
5. Build your project and verify you are starting with zero errors and zero warnings.

Add Software Wires to Make a Room

First delete the line wiring the switches to the seven segment display.
mov r7, r6 // wire to 7-segment display
This should leave only the line wiring the switches to the discrete LEDs.
mov r8, r6 // wire to discrete LEDs
Next make the changes to the code after the label loop as shown here.

You should now be able to create all the rooms in the maze by toggling the 4 most significant switches. Let’s make sure by simulating your program.

Debug Workshop 3 – Simulate Your Program

You must complete this section before starting lab 3. You may/will be tested on the information contained in any Debug Workshop plus you will need to demonstrate proficiency with the simulator (i.e., debugger) as part of the sign-off for this lab sequence (both Parts A and B).

Once your program has assembled successfully enter AVR Studio’s debug mode by pressing the Assemble and Run  icon.

If closed, expand the Registers folder in the Processor pane and PORTC and PORTD in the I/O View pane within AVR Studio. Select PORTD. In the window below the I/O View, and shown in Figure 1, you will notice that PORTD has three rows of eight bits, represented by square boxes.

Each box corresponds to a flip-flop or pin as defined in the table “Port Pin Configurations.”

Table 1: Port Pin Configurations

DDRXn	PORTXn	I/O	Pull-up	Comments
0	0	Input	No	Read “Synchronized” PINXn
0	1	Input	Yes
1	X	Output	N/A	Write bit to PORTXn

Looking at Figure 1, let’s start with the top row and the Port D Data Direction Register (DDRD). Each box in this row corresponds to flip-flop. As defined in Table 1, if this box is filled in (Flip-Flop DDRXn = 1) then this port pin will be an output. Conversely, if the box is not selected then the port pin will be an input. The second row of Figure 1 may be visualized as a physical Port D pin (PIND). If you want to simulate a change on an input pin, say from a switch being toggled, this is the box you would set (input = 1) or clear (input = 0). The third row contains the Port D register (PORTD). Each box in this row corresponds to flip-flop PORTxn. As described in Table 1, these flip-flops are interpreted differently based on if the port pin is defined as an input (DDRXn = 0) or an output (DDRXn = 1). If DDRXn = 0, then the corresponding PORTXn flip-flop adds (PORTXn = 1) or removes (PORTXn = 0) a Pull-up resistor (see fourth column in Table 1). If DDRXn = 1, then the corresponding PORTXn flip-flop defines the output state of the pin. If you want to see how your program modifies a pin defined as an output, PORTXn is the box you would look at.

For our application, all Port D pins are to be inputs with pull-up resistors assigned to the two most significant inputs wired to the two most significant (left-most) switches. In this case all the boxes in the DDRC (top row) would be empty (logic 0) and the two most significant boxes of the last row would be filled in (logic 1) as shown in Figure 1. Set a break-point at the line that calls our readSwitches subroutine.

Run to this line  and verify that the PORTD registers have been initialized in Figure 1. Next simulate turning on the switch on the left by selecting the left most check-box in PIND. Now step over the call to readSwitches . The subroutine still runs, AVR Studio simply does not show you the step-by-step details. Verify that register R06 = 0x80. This means ReadSwitches read PIND pin 7 and moved it into register r6.

Single step  your program to the line…

bld r7,6

Verify that the most significant bit of register r6 has been copied to the SREG T bit. Based on your program the other SREG bits may be different from the ones shown below. At this time we are only concerned with the T bit.

Now execute the line we are on and verify that the T-bit has been moved to bit 6 of register r7.

From our prelab we know that this corresponds to Segment g on our 7 segment display – a south facing wall

In a similar fashion, verify that the code you wrote in your pre-lab is wiring the other switches to their respective segments as defined in Figure 2.

Making Your Code More Readable

Open the spi_shield.inc file (double-click in Project window) in AVR Studio.

As touched on in Lab 1 and covered in more detail here in Appendix A, the m328pdef.inc include file makes our code more readable by the use of equates (.EQU) and define (.DEF) assembly directives. The equate assembly directive performs a numeric substitution. Simply put, whenever the assembler encounters text which has an equate assigned to it, it replaces the text with the numeric value defined in the equate statement. For example, in m328pdef, the text PORTD is equated to the number 0x0b.

.EQU PORTD = 0x0b

Consequently, whenever the assembler encounters the text PORTD it substitutes the number 0x0b.

The define (.DEF) assembly directive works in a similar fashion performing a textual substitution. Simply put, whenever the assembler encounters text which has a define statement assigned to it, it replaces the text with the text value in the define statement. For example, in m328pdef, the text XH is defined as meaning the text r27.

.DEF XH = r27

Consequently, whenever the assembler encounters the text XH it substitutes the text r27. Following the lead of m328pdef, I have added a few definition and equates of my own in spi_shield.inc to make working with the proto-shield a little easier.

; SPI interface registers
.DEF spiLEDS=r8
.DEF spi7SEG=r7

; Switches
.DEF switch=r6

; 7-segment display
.EQU seg_a=0
.EQU seg_b=1
.EQU seg_c=2
.EQU seg_d=3
.EQU seq_e=4
.EQU seg_f=5
.EQU seg_g=6
.EQU seg_dp=7

To read the switches on the Arduino Shield you call readSwitches which returns the state of the switches in register r6. Now, instead of writing r6 to look at the switches you can use the more descriptive word switch, which means the same thing (.DEF switch=r6). To turn ON and OFF the 8 discrete LEDs on the shield you used to write to register r8. Now you can use the more descriptive mnemonic spiLEDs (.DEF spiLEDS=r8).

For example here is the instruction wiring the switches to the discrete LEDs.

mov r8, r6 // wire to discrete LEDs

By replacing the register numbers with the more descriptive mnemonics the instruction becomes much more understandable.

mov spiLEDS, switch // wire to discrete LEDs

Now lets make your code more readable. When specifying a single discrete LED bit, the number of the bit was clear enough (7, 6, 5,… 0). For the 7-segment display knowing which segment is which is a little more confusing. The final series of equates lets you specify the segment (bit) you want to work with by name (seg_dp, seg_g, seg_f, …seg_a) as defined in Figure 3 7 Segment display.

Now let’s use our newly created define assembly directives to make our code more readable. For example the two lines wiring the leftmost switch with its corresponding south wall segment…

bst r6,7 // wire switch 7 to segment g (south wall)
bld r7,6
now becomes much more readable..
bst switch,7 // wire switch 7 to segment g (south wall)
bld spi7SEG,seg_g

Following my example rewrite your code to make it more understandable.

This completes Lab 2A. You will be continuing with this code in Lab 2B. The submission for Lab 2 is the combination of both Lab 2A and 2B.

You are finally ready to upload and test your program on your Arduino.

How to Upload your Hex file using AVR Dude

If you have not done so already, download and install AVR Studio, WinAVR, and Arduino IDE from http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725, http://sourceforge.net/projects/winavr/, and http://arduino.cc/en/Main/Software

If you are running Windows 7 and have an Arduino Duemilanove (not an Arduino Uno) you may need to download the Virtual COM Port Drivers from Future Technology Devices, used by the winAVR software to upload programs to your board.

At this time you should have verified that your Arduino works by uploading and running blink from the Arduino IDE (Integrated Development Environment) and that the Protoshield works by running sketch_shiftOut_16-bit. Instructions are provided in “How to Build the Arduino Proto-Shield.”

Open notepad from your computer and type in the following two commands:

avrdude -p m328p -c arduino -P \\.\COM4 -b 115200 -U flash:w:Lab2.hex
pause

You will need to confirm which com port the Arduino UNO is using, so you may have to change it from COM4 to the correct number. Additionally, the file name has to match exactly. If you named your project lab_2, the file name to use will be lab_2.hex .

In order to save the file as a batch file in the same folder as the project, make sure to add .bat to the end of the name and make sure that the Save as type option is set to all files instead of text document. You can name the batch file whatever you like but it is suggested to be upload328P.bat . You can copy this file and make modifications to the contents in order to upload future labs.

Here is a short description the options and how you will need to modify them. For a complete list of avrdude command line options go to http://www.nongnu.org/avrdude/user-manual/avrdude_4.html#SEC4 her

-p partno Use -p ? option in the command window (Windows - R Open:cmd) to get a list of part numbers 
-c programmer-id You can also use stk500v1
-P port Set to your port number. The \\.\ provides support for com port numbers greater then 7.
-b baudrate For the Arduino Uno keep the baud rate at 115200. For the Arduino Duemilanove change the baud rate to 57600 
-U memtype:op:filename[:format] Enter the name of your file (ex. Blink.hex)
memtype flash The flash ROM of the device.
op w Read the specified file and write it to the specified device memory.

In the future if you need to create a new batch file or if you modified this one; be sure to save the file with a .bat extension (not .txt) in the folder containing your hex file (look in the folder named ‘default’).
To find your port number, in the control panel open the Device Manager, expand Ports (COM & LPT). Look for the Arduino, it should say something like USB Serial Port (COM4).

Using Notepad change the port setting in the upload.bat file to this port number.

To upload your program run the batch file (right-click open or double-click). For the Arduino Duemilanove you may to simultaneously press the reset button. The order is not important; but both must be done within less than a second of each other. Don’t panic if you get it wrong. You will simply see the message including the text “not in sync.” Wait until you see the line “Press any key to continue . . .” press any key and then try again.

Appendix A The m328pdef Include File

Open the m328pdef.inc file (double-click in Project window) in AVR Studio.

Each port register (DDRXn, PORTXn, and PINXn) has its own unique address within both the Data Memory and I/O area of the ATmega microcontroller as defined in Table A.1. For this lab we will use the I/O address of each of our ports.

Table A.1 General Purpose Digital I/O Port Register Definitions

You can find the original version of this table in the ATmega328P doc8161.pdf document in Section 30 “Register Summary.” A similar version is in Appendix B ATmega328P Registers and specifically, Section B.1 Register Summary of your textbook. The I/O address of each register is shown on the left (see Table above). The Data Memory address is shown in parenthesis. For example, you can input register PINC from the address 0x06. Where the 0x simple means this is a hexadecimal number (0x06 = 06₁₆).

While we could use the actual address in our assembly instruction; our code is more readable if we use its mnemonic (i.e., PINC = 06₁₆). The “equating” of these mnemonics with their corresponding values is done in the m328pdef.inc “include” document. This is a text document so you can open it in AVRStudio or even Notepad at any time and take a look at what is going on under the hood. Here is the relevant section for our ports…

.EQU PORTD = 0x0b
.EQU DDRD = 0x0a
.EQU PIND = 0x09
.EQU PORTC = 0x08
.EQU DDRC = 0x07
.EQU PINC = 0x06
.EQU PORTB = 0x05
.EQU DDRB = 0x04
.EQU PINB = 0x03

The “dot” tell the assembler that this line is talking to the assembler and not to be turned into a machine instruction. The mnemonic equ tells the assembler to make the following equate. For example, the first line would tell the assembler to replace PORTD with the value 0B16 whenever it comes across it in the assembly code portion of the program.

To have the assembler read (include) the m328pdef.inc text file we use the include assembly directive. One again an “assembly directive” is an instruction to the Assembler; in contrast with an Assembly instruction which the assembler turns into an ATmega328P machine instruction.

.INCLUDE 

Because it is so important to remember when a line is intended for the Assembler (Assembly Directive) and when a line is to be converted to a machine instruction intended for the ATMega328P microcontroller (Assembly Instruction), I always capitalize Assembly Directives and place in lower case letters Assembly Instructions. AVR Studio is not case sensitive, so this convention is not required for your assembly program to assemble correctly – it is however required by the instructor.

Lab 2B — Build a Test Bench Direction Finder

Please quickly scan the lab before starting. This is a new class of lab that you can tailor to your own learning and academic goals. Specifically, you can follow a step-by-step or do-it-yourself approach – you decide. You can also decide how simple or difficult you would like to make the lab, based on the grade you would be happy receiving.

Introduction

In the first part of this lab (Lab 02A) you designed a circuit with four (4) switches wired to four (4) LEDs of the 7-segment display. Using the four switches you were then able to draw all 16 rooms that the bear might encounter in his journey through the maze. This was the beginning of building your test bench to be used to verify the code you will write in future labs.

In the second part of the lab (Lab 02B) your goal is to design a digital circuit with two (2) switches that will turn on one of the rooms 4 LED segments indicating the direction you want your bear to walk. Like the previous lab, this code will become an important component of your test bench.

 What is New?

Here are some of the new concepts you will be exploring in this lab.

• More Working with Bits
• Logical Instructions
• Conditional Branch Instructions

The following instructions and assembly directives are used in Labs 1 to 2. New items are underlined.

AVR Assembly Instructions

Data Transfer
ldi r16, 0x03 // Load immediate the number 3 into register r16
lds r16, dir // Load data from SRAM variable room into register r16
sts dir, r16 // Store data from register r16 into SRAM variable room
mov r8, r7 // Move data from register r7 into register r8
in r7, PINC // Input port C pins (0x09) into register R7
out PORTB, r7 // Output to Port B from register R7
Arithmetic and Logic
cpi a, 0x03 // compare immediate a with 0x03
cbr r16, 0xF0 // Logical and of r16 with complement of constant 0xF0
or r16, r17 // logical bit-wise or of r16 and r17, result placed in r16
com r16 // complement (not) of register r16
clr r16 // Clear register r16
ser r17 // Set register r17
Control Transfer
brne next_test // branch is not equal to label next_test
call WriteDisplay // Subroutine Call
rjmp loop
Bit and Bit-Test
brts next_test // Branch if T set
swap r5 // Swap high and low nibbles in register r5
bst r7, 7 // Bit store from register r7 bit 7 to SREG T bit
bld r8, 6 // Bit load from SREG T bit to register r8 bit 6

AVR Studio Assembly

Directives
.DSEG // Data Segment
.BYTE 1 // reserve 1 byte in SRAM
.DEF spiLEDS = r9 // Replace spiLEDS with the text r9
.EQU seg_a = 0 // Replace seg_a with the number 0
.CSEG // Code Segment
.ORG 0x0000 // Code Origin
.INCLUDE “spi_shield.inc” // “ “ means the file is in the project folder
.INCLUDE  // < > means the file is in the AVR Studio folder
Labels
loop:
Comments
; // /* */

Review and a few new pieces of the puzzle

Configuration

Here is how the top-level configuration section of your program should look.

;
 /* Lab2.asm - Show a Room
 * Version 1.0 <- update this number each time you print your program
 * Created: 1/27/2013 11:01:03 AM
 * Author: Your Name Here
 * Lab: Tu 7:00pm - 9:45pm
 */

.INCLUDE  

.CSEG
.ORG 0x0000

RST_VECT:

rjmp reset // jump over IVT, tables, and include file(s)

.ORG 0x0100 // bypass IVT

.INCLUDE "spi_shield"

Lets take a look at this code, with an eye to reviewing what we have learned to date, while adding a few more pieces to the puzzle.

Title Block

The title block provides a top-level description of the program and information about who wrote it.

INCLUDE

The include assembly directive (.INCLUDE) tells the assembler to load the text file m328pdef.inc at this point in the code. This is a simple block copy-paste operation. If it is not already open, open the m328pdef.inc file located in the Included Files folder in the Project window pane (left side of window). If you do not see it you may need to expand the folder (click the + box) or build the project (click the  Assemble icon). If all else fails you can open the file directly. From the menu bar select Project and Open File. Navigate to and select C:\Program Files\Atmel\AVR Tools\AvrAssembler2\Appnotes\m328Pdef.inc. This file is unique to your AVR microcontroller and provides useful mnemonics for mapping AVR standardized mnemonics with their respective locations in the data and i/o address space.

CSEG and ORG

The code segment assembly directive (.CSEG) tells the assembler we are about to start writing assembly instructions to be translated into machine code and placed into program memory.

The origin assembly directive (.ORG) immediately following, tells the assembler that we want it to start placing this code at location 0x0000 in code memory.

When you press the reset button on the Arduino the reset pin on the AVR microcontroller is placed at logic 0 and the Program Counter (PC) begins executing the first instruction at program address 0x0000 (RST_VECT) .

For us the first instruction executed is a jump instruction to the code identified by the label reset (rjmp reset).

Notice that another origin assembly directive (.ORG 0x0100) places this code after location 0x0100. This is done to place our program code after the AVR’s Interrupt Vector Table (IVT) which we will learn about in the future. Between the .ORG 0x0100 directive and the start of your code is another .INCLUDE directive. Which was first introduced in Lab 2. If you have already forgotten Lab 2, here is a quick review.

.INCLUDE “spi_shield”

While the Arduino Duemilanove board is a great low priced microcontroller board it is i/o pin poor. Specifically, it does not include enough general purpose i/o pins to support our 8 switches, 8 discrete LEDs, the 8 pins needed for the 7-segment display, and the other miscellaneous components that make up our Proto-Shield. To solve this problem the shield uses the Serial Peripheral Interface (SPI) of the AVR microcontroller. You will learn about this peripheral device in the future but to minimize your confusion I have hidden it inside the spi_shield.inc file. As before, the assembler simply does a block copy of the material in this file and pastes it at this point in the program.

If you open the spi_shield include file, you will see it includes some definitions (.DEF) and equates (.EQU). Unlike definition (.DEF) assembly directives, equate (.EQU) directives do a numeric substitution. For example, in our program anywhere the assembler sees “seg_a” it will replace it with the number 0. Like the define directive the equate directive is used to add clarity to our assembly program. Looking around you will also see three subroutines (InitShield, ReadSwitches, and WriteDisplay and SpiTxWait). In the language of C++ you can think of InitShield, WriteDisplay, and ReadSwitches as public and SpiTxWait as private. Which means we will call InitShield, WriteDisplay, and ReadSwitches from our main program.

SRAM Variable Definition

Now might be a good time to let AVR Studio know about an SRAM variable named dir. Add the following two lines just after the first .INCLUDE assembly directive.

.INCLUDE 

.DSEG
 dir: .BYTE 1

.CSEG
.ORG 0x0000

RST_VECT:

rjmp reset

.ORG 0x0100 // bypass IVT

.INCLUDE "spi_shield.inc"

DSEG and BYTE

This is the first time we have placed anything into SRAM, so lets take a closer look at what is happening. The .DSEG assembly directive tells the AVRStudio assembler that we are going to be talking about the Data Segment (DSEG). This is just another way of saying SRAM Data Memory. The .BYTE assembly directive tells the AVRStudio assembler that we want to reserve N bytes of RAM whose starting address should be associated with the specified name. In this example the variable named dir and the number of bytes to be associated with this name is 1.

Initialization

Here is how the initialization (reset) section of your program should look.

reset:

 ldi r16, low(RAMEND) // RAMEND address 0x08ff
 out SPL, r16
 ldi r16, high(RAMEND)
 out SPH, r16

; Initialize Stack, and GPIO Ports, and SPI communications
 call InitShield

The reset section initializes our stack (see Lab 2 “Stack Pointer Initialization”), and configures our SPI peripheral device by calling the InitShield subroutine included with spi_shield.inc.

Variable Initializations

A good programming practice is to initialize all variables on reset. Within the reset section of your program lets set variable dir equal to the number 3 (hex 0x03).

ldi r17, 0x03 // your descriptive comments here
sts dir, r17

Highlight in yellow your descriptive comments. Please do not simply repeat the name of the mnemonic instruction. For example, for the mnemonic instruction ldi r6, 0x03 do not write the comment “load imediate register r16. In this example, the load immediate (ldi) instruction is paired with the store in sram (sts) instruction on the next line. The purpose of this pair of instructions is to initialize the direction variable so the bear is facing north (0x03). Therefore, a good comment would be something like “the bear enters the maze facing north”

It would be nice if we could simply set variable dir directly equal to the number 3. However, this is not how a load-store architecture works. The idea behind our RISC architecture is that instructions operate on registers not variables in memory. If you want to therefore perform some operation with a variable you need to…

1. Load the data (e.g., lds, ldi, in),
2. Do something (typically an arithmetic or logical instruction), and then…
3. Store (sts, out) the result.

We are initializing variable dir so we do not care what their current value is and can therefore skip the load (lds) step. The selection of register r16 is somewhat arbitrary. For example in place of register r16, I could have chosen any register between r16 and r31.

Loop

We finish our review with the main loop.

loop:
 ; SPI Software Wires

call ReadSwitches
mov spiLEDS, switch // wire to discrete LEDs

clr spi7SEG // start with all 7-segments OFF

bst switch, 7 // wire switch 7 to segment g (south wall)
bld spi7SEG, seg_g
...
call WriteDisplay
rjmp loop

The main loop section of our program clears the 7-segment display and discrete LEDs, reads the switches, implements the “software wires” used to manually build a room. The program ends with an rjmp, which repeats the process.

Direction Finder

In this section you are going to write the code to turn on the 7 segment LED corresponding to the direction the bear is currently facing.

Some Electrical Engineers are more comfortable working with truth tables and Boolean logic, others prefer writing programs using conditional expressions, while a few like programming challenges. In this lab you can choose which path you take. Specifically, you may choose to program your direction finder using one of three different approaches.

1. Your Boolean expressions from the pre-lab.
2. Your flowchart from the pre-lab.
3. Model the Arduino C++ solution by creating a one-dimensional array and using the indirect addressing mode to translate the direction. (design challenge)

The maximum number of points you can receive on a lab is governed by which approach you select. These points are estimates only and may be adjusted by the instructor.

Design	Basic Lab (points)	Design Challenge	Total Possible
Boolean Logic	16	4	20
If-Then Flowchart	17	N/A	17
If-Then-Else	17	N/A	17
Indirect Addressing	20	N/A	20

Regardless of which option you choose, the first thing that needs to be added to your code is updating the newly created direction variable with the value from the direction switches in the main loop. Place the following lines of code after the clr spi7SEG.

mov r16, switch // move switch (r7) to temporary register r16
cbr r16, 0xFC // mask-out most significant 6 bits
sts dir, r16 // save formatted value to SRAM variable dir.

These three lines of code are taking the input from the switches, clearing out the unused bits and saving it to the dir variable. By doing this, the user can quickly get the direction value from the dir variable instead of taking it from the switches and clearing out the unused bits every time.

Programming Option 1: Convert your Digital Logic Expressions into Subroutines

For this solution you will be translating the Boolean expressions from your pre-lab into assembly code. To translate each Boolean expression into assembly code you will use AVR 8-bit logical instructions com, and. Because you are implementing only one gate at a time, you will only need 1 of the 8 bits. For my example I have arbitrarily picked bit 0. To help you get started here is the the code needed to decode 7-segment LED segment b.

loop:
 ; SPI Software Wires

 call ReadSwitches
 mov spiLEDS, switch // wire to discrete LEDs

 mov r16, switch // move switch (r7) to temporary register r16
 cbr r16, 0xFC // mask-out most significant 6 bits
 sts dir, r16 // save formatted value to SRAM variable dir.
 ...
 call WriteDisplay

 ; Lab 2 Direction Finder

 lds r16, dir // load direction into temporary register r16
 clr spi7SEG // start with all 7-segments OFF

 ; facing east (segment b)

 mov r18, r16 // your comments here
 bst r16, 1
 bld r17, 0

 // B = /A * B
 com r17 // your comments here
 and r18, r17

 bst r18, 0 // store answer into T
 bld spi7SEG, seg_b // load answer from T into segment

Bits versus Bytes

For this lab I want to implement a series of logical expressions, working with one bit at a time. The AVR processor logical instructions work with bytes and not bits. If you think about it, this is not really a problem. For example, in the above code, I work with bit 0 and simply do not worry about the other bits.

We begin by loading the direction the bear is currently facing (SRAM variable dir) into scratch pad register r16 and making sure all our 7-segment display elements (LEDs) are off (at logic zero).

Our initial objective is to move bit 0 into register variable B bit 0. This one is easy, Direction bit 0 is already in bit 0 of register r16 so I can simply move it to register r18. Direction 1 is a little trickier. In this case I move bit 1 into bit 0 through the T bit in the status register sreg. This is the technique you first learned about in Lab 3. I then use the 8-bit logic instructions to implement my Boolean expression – again I am only interested in bit 0. It is important to note that the left hand operand (in this case r18) of any arithmetic and logic instruction acts as both a source and a destination. Consequently, the original source bit(s) are destroyed.

Once you understand how my “digital logic gate” works, write the missing parts of the program for the remaining 3 segments (g, f, and a). If you need to, refer to the Arduino Proto-Shield schematic for switch and 7-segment LED assignments.

 ; facing south (segment g)
 mov r18,r16
 bst r16,1
 bld r17,0

Write your direction code (translating your circuit schematics from the prelab) for segments g here along with your comments.

 bst r18,0 // store answer into T
 bld spi7SEG,seg_g // load answer from T into segment

 ; facing west (segment f)
 mov r18,r16 // your comments here
 bst r16,1
 bld r17,0

Write your direction code (translating your circuit schematics from the prelab) for segment f here along with your comments.

 bst r18,0 // store answer into T
 bld spi7SEG,seg_f // load answer from T into segment

; facing north (segment a)
 mov r18,r16 // your comments here
 bst r16,1
 bld r17,0

Write your direction code (translating your circuit schematics from the prelab) for segments a here along with your comments.

 bst r18,0 // store answer into T
 bld spi7SEG,seg_a // load answer from T into segment

 call WriteDisplay
 rjmp loop

Verify the basic operation of the program using AVR Studio. For detailed step-by-step instructions see Debug Workshops 1, 2, and 3. Remember, before you debug/run any program you should know what values will be contained in the affected registers.

Design Challenge for Option 1 – Byte Implementation

Some of you find the material difficult enough and appreciate step-by-step instructions, while others like to figure things out for themselves. This section is designed for the later group. If you are happy with your basic solution please proceed to the next section and decide if you want to accept the design challenge.

The code provided in this and future labs is designed for instructional purposes and may not be as optimized for size and speed as possible. This optimization of code is the primary reason that engineers program in assembly versus a high level language like C++. It is also one of the things that makes assembly programming so much fun for many engineers. If you like a challenge, then see if you can rewrite the above code to make it smaller and faster.

The code provided in lab requires 28 instructions to implement. My “optimized” solution to this coding problem only takes 16 instructions to do the same thing. I limited my optimized solution to only use instructions you already know, including bst (4), mov (1), com (1), bld (8), and (1), cbr (1). The number in parenthesis is the number of times my minimum solution used the instruction.

I was able to optimize the code by observing that I was always working with bit 0 and forgetting about the other 7 bits in the register. But what if I aligned the bits to be operated on based on the segment to be turned on or off. If I were to rewrite my code in this fashion I would only need a single and instruction, thus greatly simplifying my program, while also adding clarity.

If you like challenges, see if you can implement my parallel solution, or come up with an even better solution.

Programming Option 2: Implement your Flowcharts using an “If-Then” Binary Tree Structure

In the last section you applied what you learned in EE201 “Digital Logic Design” to create your Boolean equations to calculate the segment to be turned ON. In this programming based solution you will apply what you learned in your programming class, to construct a flowchart to determine which segment to turn on based on dir bit 1 and bit 0. Specifically, you will translate the flowchart you built in the pre-lab into a series of conditional If-Then statements. For example, if dir bit 1 is equal to 0 and dir bit 0 is equal to 1 then turn on bit 1 of register r8. From the introduction to this section (Direction Finder) we know this will turn on segment b (i.e., spi7SEG = 0b00000010).

Begin by replacing each decision diamond with a compare bit store (bst) instruction and a brts conditional branch if T flag set instruction. The bst instruction saves the bit to be tested to the T bit in SREG. We then test this bit using the brts instruction. As a general rule use the complementary form of the conditional branch in your decision diamond. For example, if you want to branch if dir bit 1 (dir.1) is clear you would use the brts instruction as shown here.

 lds r16, dir // move direction bit 1 (dir.1)
 bst r16, 1 // into SREG T bit
 brts case1X // your comment here
 bst r16, 0
 brts case01
 ; code to be executed if bit 1 and 0 are zero (case00)
 ; 7 segments gfedcba
 ldi r16, 0b01000000 // spi7SEG = r8, seg_g = 1
 rjmp found

 case01:
 ; code to be executed if bit 1 and 0 = 01
 ; 7 segments gfedcba
 ldi r16, 0b00000010 // spi7SEG = r8, seg_b = 1
 rjmp found

case1X:
; more code and comments...

found:
mov spi7SEG, r16

Programming Option 3: Implement your Truth Table using an Optimized “If-Then-Else” Structure

Compare Immediate (cpi) Instruction

For this solution you will be using the compare immediate instruction to implement the conditional expression in the Table 1.

Table 1: Direction to Segment Conversion

			Inputs		Outputs
Direction	SW1	SW0	dir.1	dir.0	Direction Segment ON = 1, OFF = 0
					LDg	LDb	LDf	LDa
South	DWN	DWN	0	0	1	0	0	0
East	DWN	UP	0	1	0	1	0	0
West	UP	DWN	1	0	0	0	1	0
North	UP	UP	1	1	0	0	0	1

For this solution each line of the truth table becomes a guess, followed by a compare immediate cpi instruction, and finally a conditional branch instruction.

The Guess

In assembly, it’s all about code optimization. One technique assembly programmers use with conditional expressions to optimize code is to guess an answer and then test for the condition. If the guess was correct then no additional work is required. This typically results in simpler and less confusing code which runs as fast or faster (if the guess was correct) than the more traditional approaches. Here is how our flowchart for seg_b would look applying this technique.

Notice that the code is more linear than the if-then binary tree solution. Here I guess that the return value will be 0b00000010. Specifically, segment seg_b is on with all other segments off. For this to be true, the bear would need to be facing East (dir = 0b01). If my guess is correct then I can jump to my found label. Now lets look at the assembly code needed to implement this flowchart.

Code Example

The code provided here implements the direction finder flowchart defined above. Note: 0b01 assumes that the leading bits are zero and therefore 0b01 = 0b00000001.

 lds r16, dir ; load direction bear is facing into r16
 ; 7 segments gfedcba
 ldi r17, 0b00000010 ; guess bear is facing east (seg_b = 1)
 cpi r16, 0b01 ; if bear is facing east then we are done
 breq found
 ; 7 segments gfedcba
 ldi r17, 0b01000000 ; guess bear is facing south (seg g = 1)
 cpi r16, 0b00 ; if bear is facing south then we are done
 breq found
 ; more code and comments...

found:

mov spi7SEG, r17 ; transfer correct guess to 7 segment register

When comparing the above code with the flowchart one difference you will immediately notice is that the ldi instruction only works with registers r16 to r31 and spi7SEG is in r8, which means we can not directly place our “guess” in r8. Instead I will temporarily place my guess in r17 and only when I reach the found label move r17 (the correct guess) into r8 (spi7SEG).

Programming Option 4: Implement the Arduino C++ Solution in Assembly

This is a design challenge solution, which simply means less instructional information is provided and the solution requires the use of assembly instructions not yet covered in class. Design challenges were created as a response to students who requested more open-ended problem definitions.

Open the Lab02B.ino file within the Arduino IDE. Here the direction segment is chosen by first creating a one-dimensional array of segments (g, b, f, and a). The location of each segment within the array corresponds to the direction the bear is facing. For example, looking at Table 1 above if you are currently facing South (dir = 00), then you want to turn on segment g. Therefore, in the lookup table, the first entry is segment g. Here is the C++ code.

static const byte truth_table[] = {_BV(seg_g), _BV(seg_b),_BV(seg_f),_BV(seg_a)};
 seg7_val |= truth_table[dir_val];

The macro _BV(bit) is defined as 1<<bit.The symbol << being the C left shift operator. In words, the compiler is directed to shift the number 0x01 to the left bit tiresulting a Byte Value (BV) with a 1 in the bit position. For example, _BV(6) would equal 0b01000000. Our assembler does not support the Byte Value (_BV) macro, so we will substitute its definition (1<<bit)

Create the array in assembly using the Define Byte (.DB) assembly directive. Access the array using the indirect addressing mode instruction lpm.

RST_VECT:
 rjmp reset // jump over IVT, tables, and plus INCLUDE code
 .ORG 0x0050 // bypass IVT
 dir_table: .DB 1<<seg_g, 1<<seg_b,="" 1<<seg_f,="" 1<<seg_a<="" em=""></seg_g,>

 .ORG 0x0100 // bypass IVT
 .INCLUDE "spi_shield.inc"

Lab 2 Deliverable(s)

STOP Read the Lab READ ME document contained in the Labs Folder. Be absolutely sure you have followed all instruction in the “Lab Formatting” section of this document. Points will be deducted if you do not follow these instructions. You have been warned.

Make sure your lab notebook is up to date. Follow the guidelines provided in the “Lab Notebook” section of the Lab READ ME document.

Make sure you have read and understand the “Plagiarism” section of the Lab READ ME document, especially if you are repeating the class.

All labs should represent your own work – DO NOT COPY.

Pre-Lab 3: Subroutines

Before you begin I recommend reviewing the Introduction to Lab 02

In this Lab you will begin by writing four (4) subroutines. TurnLeft, TurnRight, TurnAround, and HitWall. These four subroutines are the subject of this pre-lab. After you have completed these four subroutines you will write two new subroutines named RightPaw and LeftPaw. These two subroutines will illustrate the power of subroutines by simply using the previously written subroutines to answer the questions “Did the bear’s right paw touch a wall?” and “Did the bear’s left paw touch a wall?”

Teaching the Bear to Turn Left, Turn Right, and Turn Around

In the first part of this Lab you are going to teach the bear how to change directions – turn left, turn right, and to turn around. Let’s first consider the TurnLeft subroutine (i.e, pseudo-instruction).

Table 1: Truth Table for TurnLeft Pseudo-instruction

Facing Direction			Direction after turning Left
	dir.1	dir.0		dir.1	dir.0
	x	y
South	0	0	East	0	1
East	0	1	North	1	1
West	1	0	South	0	0
North	1	1	West	1	0

Note: The syntax dir.1 is a shorthand way of saying variable dir bit 1.

As an example, if the bear is facing north (dir = 11) and you tell him to turn left, then after calling the TurnLeft subroutine, he should be facing west (dir = 10).

As you did in the previous lab, the above table can be viewed as a truth table with inputs dir and outputs dir.

Having variable dir for both input and output can be a little confusing so I have added x as a pseudonym for inputs dir.1 and y for dir.0 and broken the problem into two blocks as shown above and represented as two truth tables. Again inputs dir bit 1 (dir.1) and dir bit 0 are now renamed x and y respectively.

Table 2: Truth Table for dir.0 Input Output x y dir bit 0 0 0 1 0 1 1 1 0 0 1 1 0

Table 3: Truth Table for dir.1 Input Output x y dir bit 1 0 0 0 0 1 1 1 0 0 1 1 1

Boolean Logic

Applying what you learned in your Digital Logic Design class construct a sum-of-product (SOP) expression for each table entry (min term). To review, begin by writing a product expression for each one (1) in the output . These are the input conditions where you want to produce an output of 1. In other words, if the first condition OR the second input condition are true (1) you want to output a 1. This reasoning leads directly to our first SOP expression for Table 1.

Now write the SOP expression for dir.1 shown in Table 2.
dir.1 = ?

Simplify your two expressions (dir.1 and dir.0) by observation or using Boolean algebra. You may find it helpful to refer to this Basic Laws and Theorems of Boolean Algebra document. Please, do not draw a 2 variable Karnaugh map. Include all your work in your lab notebook.

     Distributive Law
      Law of Complements
              Dual of Identity Law

After all that work you can, by simple observation, see that our solution is correct. To draw the Boolean equations in Microsoft Word select Insert – Equation …

Flowchart

Applying what you learned in your programming class construct a flowchart for subroutines TurnLeft, TurnRight, and TurnAround. Each flowchart should show how to determine a new value for variable dir based on the current value of dir. For example, if I am writing the flowchart for TurnLeft I will start by testing if dir is equal to 0x00. If it is the bear is facing south and because I want the bear to turn left I will set variable dir equal to 0x01.

Did the Bear Hit a Wall?

Reading: Before you begin this part of the pre-lab, you may want to review Chapter 1 of your textbook on logical operators. For this pre-lab you will need to understand AVR Logical Instructions COM, AND, OR, and EOR by reading about each in AVR Studio’s Assembler Help document.

1. Complete the following truth table.
   

   Table 4: Switch to LED0 Truth Table

   Input	Output
   Logic Gate Selected	SW1	SW0	LED0
   AND	0	0
   	0	1
   	1	0
   	1	1
   OR	0	0
   	0	1
   	1	0
   	1	1
   EOR (Exclusive OR)	0	0
   	0	1
   	1	0
   	1	1
   COM(Inverter)		0
   		1

   To give you a little practice using the Assembler Help window in AVR Studio (Help – Assembler Help), look-up the CBR and SBR instructions. Use the information from the help provided for these two instructions to answer the following two questions.

2. The Clear Bit(s) in Register (CBR) instruction performs what logical operation to clear individual bits in a register?
3. The Set Bit(s) in Register (SBR) instruction performs what logical operation to set individual bits in a register?
4. What byte-wide logical instruction can be used to test if a bit or bits are set? You only need to indicate the appropriate operator. Do not worry about the entire instruction. (IE the focus is on MOV from MOV R7, R6) To help you answer this question, consider the following drawing depicting 8 2-input gates.
   
   The type is unknown at this time so I have simply drawn 8 boxes. I then named one of the inputs to each of the gates “test.” To test if a bit or bits are set (bn = 1), you set the corresponding “test” bit to 1. If any of the bit or bits being tested is 1 the corresponding output will be a non-zero value.
   In the following example I want to see if bit 1 in register r24 is set. Consequently, I would set bit 1 in my “test” byte (register r16) to 1. The answer is no so the contents of output register r24 is zero.
   
5. Write the single logical instruction that would be used to test the bits, using inputs R19 and R24. R19 and R24 are two of the AVR’s 32 8-bit general purpose registers. Assume r24 initially contains the byte you want to test, and register r19 contains the test sequence (in our example 00000010₂). The output of the test should be into R24.
6. What would the contents of R26 be after the instruction COM R26 is executed if it originally has the value 0b11001010?

What Should I Turn In?

Turn in the following material. Make sure all your original work is in your Lab Notebook. All written material must be typed or neatly done in ink. Once again please do not copy.
Page

1. Title page with the pre-lab number, your name and picture, today’s date, and the day your lab meets.
2. Truth tables and simplified Boolean expressions for TurnLeft, TurnRight, and TurnAround
3. Flowcharts for TurnLeft, TurnRight, and TurnAround You may use more than one page to show your flowcharts
4. The problem statements (remove explanatory text) and solutions to the five (5) pre-lab questions in Part B of the pre-lab. Circle and/or highlight your answers. Make sure all your original work is located in your lab notebook. This part of your pre-lab must be typed. You may use more than one page to write the question and answer these five questions.

Lab 3A: Pseudo-instructions TurnLeft, TurnRight, and TurnAround

Ironically, one of the most difficult parts of any project is understanding what you (or the customer) want. Applying this principle to the task at hand, one of the most difficult parts of any lab is trying to understand what the instructor wants. To help you understand the overall objectives of a lab, I will from time-to-time include an “Owner’s Manual.” In these sections I will talk about how your program should operate when completed.

Owner’s Manual

As you hopefully remember from the previous labs, our long term objective is to help guide a bear through the following maze.

Towards that goal, you have already written test-bench code that can generate all the rooms by reading the left-most 4-switches, and turn on and off direction indicator LEDs based on the right-most 2-switches. To help you remember how everything should operate up to this point I have generated the following reference card.

If you have not done so already (Lab 2), print out the maze and reference card above. I highly recommend keeping these open and on your desktop when doing any of the labs.

You may have already noticed that I have included two new switches on the reference card named “turn.” The purpose of the switches is to test pseudo-instructions TurnLeft, TurnRight, and TurnAround which you worked on in the pre-lab and will now implement in lab. To test these three new pseudo-instructions you will write a subroutine named WhichWay which will call the three new pseudo-instructions based on the position of the turn switches as shown in the reference card. For example, let’s say the direction switches are both in the up position (11). By the compass on the card we see that this means the bear is facing North (n), If you completed Lab 2 correctly, then segment-a should be ON. For our example, we want to see if pseudo-instruction TurnLeft is working. By looking at the card we see that, to simulate turning left we need to set the switches to UP = 1 and DOWN = 0. If pseudo-instruction TurnLeft is working then the bear should now be facing west and consequently segment-a should be OFF and segment-f should now be ON. To completely verify the functionality of the TurnLeft pseudo-instruction you will need to test it for all four (4) directional cases (initially facing North, South, West, and finally East). Do not get confused. Turns are always made relative to the direction the bear is facing. That means if the bear is facing south and you are testing the TurnRight pseudo-instruction then segment-d should turn OFF and segment-f should turn ON.

What is New?

Lab 03 represents a reset of the lab sequence. Specifically, I am providing subroutine versions of the in-line code you wrote in Labs 01 and Lab 02. These subroutines named DrawRoom and DrawDirection are located in a new include file named testbench. Like almost all the subroutines you will be writing in this and future labs, they are C++ compliant by using register r24 for sending arguments and returning function values.

To work with my two new subroutines, I am providing a new Lab03 assembly file and the testbench.inc file. While functionally equivalent to your Lab 2 program, Lab03 calls both of my new subroutines.

You do not need any code from previous labs.

AVR Assembly Instructions

Here are some of the new instructions you will be learning in this lab.

Data Transfer
push r16 // place register r16 onto the stack
pop r16  // remove register r16 from the stack

Control Transfer
brts cond_01   // branch if T is set
rcall WhichWay // relative subroutine call

Bit and Bit-Test
lsr r24 // shift contents of r24 right by 1 bit

Lab03.asm code

; ----------------------------------------
; Lab 3 - Pseudo-instructions
; Version 1.1
; Date: February 10, 2017
; Written By : Your Name
; Lab Hours : Tuesday 7:00pm - 9:45pm
; For questions regarding this code, contact your email address
; ----------------------------------------

.INCLUDE 

.DSEG
room: .BYTE 1    // Defines the SRAM variable called room
dir:  .BYTE 1    // Defines the SRAM variable called dir

.CSEG
.ORG 0x0000
RST_VECT:
rjmp reset               // jump over IVT, plus INCLUDE code
.ORG 0x0100              // bypass IVT
.INCLUDE "spi_shield.inc"
.INCLUDE "testbench.inc" // DrawRoom and DrawDirection

reset:
ldi r17,HIGH(RAMEND) // Initializes Stack Pointer to RAMEND address 0x08ff
out SPH,r17          // Outputs 0x08 to SPH
ldi r16,LOW(RAMEND)
out SPL,r16          // Outputs 0xFF to SPL

call InitShield      // initialize GPIO Ports and SPI communications
clr spiLEDS          // clear discrete LEDs
clr spi7SEG          // clear 7-segment display

;Initialize SRAM Variables 
clr r17              // initializes r17 to 0 and then stores data from r17 into variable room
sts room, r17
ldi r17, 0x03        // loads the hex number 3 into r17 and then stores that value into variable dir
sts dir, r17

loop:
call ReadSwitches    // read switches into r6

// dir = switch & 0x03;
mov r17, switch      // move switch (r6) to temporary register r17
cbr r17, 0xFC        // mask-out most significant 6 bits
sts dir, r17         // save formatted value to SRAM variable dir.

/* Read Switches and update room and direction */
// room = switch >> 4; 
mov r17, switch      // move switch (r6) to temp register r17
cbr r17, 0x0F        // mask-out least significant nibble 
swap r17             // swap nibbles
sts room, r17        // save formatted value to SRAM variable room.

/* Draw Direction */
lds r24, dir        // calling argument dir is placed in r24.
rcall DrawDirection // translate direction to 7 segment bit
mov spi7SEG, r24    // Displays DrawDirection on the 7 segment display.
call WriteDisplay

/* Room Builder */
lds r24, room       // calling argument room is placed in r24.
rcall DrawRoom      // translate room to 7-seg bits
mov spi7SEG, r24    // return value, the room, is saved to 7 segment display register
call WriteDisplay   // display the room
rjmp loop

testbench.inc code

; ----------------------------------------
; Testbench Utility
; Version 1.1
; ----------------------------------------

;directions (most significant 6 bits zero) 
.EQU south=0b00
.EQU east=0b01
.EQU west=0b10
.EQU north=0b11

; --------------------------
; --- Draw the Room ---
; input argument in r24 is the room
; return value in r24 is the room formatted
; for a 7-segment display
; No general purpose registers are modified,
; while SREG is modified by this subroutine.

DrawRoom:
	
	push   reg_F 	        // moving this register onto the stack so
	in     reg_F,SREG       // it can be used to save the value in SREG
	push   r17

        mov    r17, r24         // move input to temporary register
	cbr    r24, 0b11111100  // room bits 1 and 0 are already aligned to segments b and a
        cbr    r17, 0b11110011
	swap   r17
        lsr    r17              // room bits 3 and 2 are now aligned to segments g and f
	or     r24, r17         // SW7:SW4 now mapped to 7 segment display
		
	pop    r17 		// restore original contents of r17
	out    SREG,reg_F
	pop    reg_F
	ret

; --------------------------
; --- Set Direction Bit ---
; The input argument in r24 is the direction
; and return value in r24 is the 7-segment display
; no registers are modified by this subroutine

DrawDirection:
	push  reg_F
	in    reg_F,SREG
	push  r16

        mov   r16, r24          ; move direction bear is facing into r16
        ldi   r24, 1<
        cpi   r16,south         ; if bear is facing south then we are done             
        breq  found
        ldi   r24, 1<
        cpi   r16,west          ; if bear is facing west then we are done             
        breq  found
	ldi   r24, 1<
        cpi   r16,east          ; if bear is facing east then we are done             
        breq  found
        ldi   r24, 1<

found:
	pop    r16
	out    SREG,reg_F
	pop    reg_F
	ret

Create the Lab3 Project

If you are using a lab computer I would recommend erasing everything in Drive D and using this area for your project. Do not forget to save often. At the end of the lab do not forget to save to your Flash drive.

1. Open AVR Studio and create a new Project named Lab03.
2. Copy over the code for Lab03.asm that was provided above.
3. Create a new file and copy over the code for testbench.inc. Make sure to save it with that exact name.
4. Within windows, copy over your version of spi_shield.inc from Lab02.
5. Within windows, copy over your upload.bat from Lab02. Open the text file in notepad (right-click edit) and change the file name from Lab02.hex to Lab03.hex
6. Update the information in the title block.
7. Build your project and verify you are starting with zero errors and zero warnings.

Subroutines TurnLeft, TurnRight, and TurnAround

SRAM Variable turn

Before we write our first three subroutines, let’s define and initialize a new variable in SRAM named turn.

1. Applying what you learned in Lab 02B “SRAM Variable Definition,” define a new variable named turn.
2. Applying what you learned in Lab 02B “Variable Initialization,” initialize your new SRAM variable too.

Now that the assembler knows what the word turn means and the AVR processor has initialized it, we can use it in our code.

The least significant two bits of SRAM variable turn will hold the values in switches SW3 and SW2.

In the following code taken from Lab03, each block of code is preceded by its C++ equivalent. You may want to open the Lab04A.ino sketch within the Arduino IDE to see these C++ statements in context. To help you write the code to extract the variable turn from the switch input, I have again included the C++ code equivalent.

Comparing the preceding lines of code you can see we have pretty much done the same thing for SRAM variables room, and dir. Specifically, we moved the switch values into a temporary register (r16), masked out the bits we will not be using (cbr), and then we used different bit manipulation instructions to right justified the remaining bits. For the turn variable you will again follows these steps. For the bit manipulation you will need to right justified switches SW3 and SW2 by using the logical shift right instruction twice. In C++ this is double shift is accomplished with the shift operator (>> 2). In assembly this is done by using the logical shift right instruction (lsr) twice. As the name implies, this instruction shifts the contents of the source/destination register by 1 bit, while shifting 0 into the most significant bit.

loop:

; Test Bench

call ReadSwitches // read switches into r7

/* Read Switches and update room, direction, and turn */

// dir = switch & 0x03;
 mov r17, switch // move switch (r6) to temporary register r16
 cbr r17, 0xFC // mask-out most significant 6 bits
 sts dir, r17 // save formatted value to SRAM variable dir.

// room = switch >> 4;
 mov r17, switch // move switch (r7) to temporary register r16
 swap r17 // swap nibbles
 cbr r17, 0xF0 // mask-out most significant nibble
 sts room, r17 // save formatted value to SRAM variable room.

// turn = (switch >> 2) & 0x03;
 … write your assembly code with comments here.
 ...
 rjmp loop

Write Subroutines TurnLeft, TurnRight, and TurnAround

In this section you are going to write subroutines TurnLeft, TurnRight, and TurnAround.

You may now choose to write each subroutine using one of three different approaches.

1. Your Boolean expressions from the pre-lab.
2. Your flowcharts from the pre-lab
3. Model the Arduino C++ solution by creating a one-dimensional array and using the indirect addressing mode to translate the direction. (design challenge)

The maximum number of points you can receive on a lab is governed by which approach you select. These points are estimates only and may be adjusted by the instructor.

Design	Basic Lab (points)	Design Challenge	Total Possible
Boolean Logic	15	2	17
Flowchart	15	2	17
Indirect Addressing	20	N/A	20

As you work through your own solutions do not forget to show all your work in your lab notebook.

Rules for Working with Subroutines

Please read Appendix A “Rules for Working with Subroutines” at the end of this lab for rules you must always follow when writing subroutines. I have included this material as an Appendix so you may more quickly review it in subsequent labs.

Place the following empty subroutines TurnLeft, TurnRight, and TurnAround just after the main section of your code.

 ; -------------------------------------
 ; -------- Pseudo Instructions --------
 ; --------------------------
 ; ------- Turn Left --------
 ; Called from WhichWay subroutine (see Table 5.1)
 ; The input and output is register r24
 ; register SREG is modified by this subroutine
 TurnLeft:

Your AVR Instructions and comments here
 ret

; --------------------------
 ; ------- Turn Right -------
 ; Called from WhichWay subroutine (see Table 5.1)
 ; The input and output is register r24
 ; register SREG is modified by this subroutine
 TurnRight:

Your AVR Instructions and comments here
 ret

; --------------------------
 ; ------- Turn Around -------
 ; Called from WhichWay subroutine (see Table 5.1)
 ; The input and output is register r24
 ; register SREG is modified by this subroutine
 TurnAround:

Your AVR instructions and comments here
 ret

Highlight in yellow your descriptive comments. Please do not simply repeat the name of the mnemonic instructions as I have done in the TurnLeft sample code (next section). I did this to help you learn the instructions. In practice I would have written the comment differently. For example, for the mnemonic instruction mov r16, r24 I would have written something like,
/* Register r24 is used as both an input and an output. The remaining code works with r24 as an output. Consequently, I am moving the input to scratch pad register r16. */

It is good programming rule, not to mention making your subroutine much more portable, to protect registers modified by your subroutine. In the spirit, of simplifying the course/lab I have not enforced this rule – up to this point. Subroutine TurnLeft uses register r16 as a temporary register. Following our new rule I have saved the value in r16 onto the stack before my subroutine modifies it. I then restore the original value before I exit the subroutine. You should not save/restore registers used to return values.

It is now time to decide which path you wish to follow in implementing your pseudo-instructions. You may want to quickly read over the next three sections before deciding which path you want to take.

Programming Option 1: Convert your Digital Logic Expressions into Subroutines

In this section I will show you how to translate each simplified SOP expression, generated in the pre-lab, into assembly code. As you hopefully discovered, this can be done with a little bit manipulation and the complement (com) instruction. I have included my TurnLeft subroutine to help you get started. As you can see, each result is accomplished by moving bits through our 1-bit T flag in the Status Register (SREG).

Programming Option 2: Convert your Flowcharts into Subroutines

Translate your flowcharts, generated in the pre-lab, into assembly code. Begin by replacing each decision diamond with a compare immediate cpi and a conditional branch instruction. As a general rule use the complementary form of the conditional branch in your decision diamond. Here is my TurnLeft subroutine to help you get started.

To help make the code more readable I introduced the following equate statements in the testbench include file provided with this lab. Do not add these to your assembly file.

;directions (most significant 6 bits zero)
 .EQU south=0b00
 .EQU east=0b01
 .EQU west=0b10
 .EQU north=0b11

Programming Option 3: Implement the Arduino C++ Solution in Assembly

This is a design challenge solution, which simply means less instructional information is provided and the solution requires the use of assembly instructions not yet covered in class. Design challenges were created as a response to students who requested more open-ended problem definitions.

Open the Lab03A.ino file within the Arduino IDE. Here the turn left and right subroutines are implemented by first creating a one-dimensional array of directions. The location of each direction within the array corresponds to the turn to be made. Once created to make a turn you only need to use the direction, a number from 0 to 3, as an index into the array. For example, looking at Table 1 from the pre-lab if you are currently facing South (dir = 00), and you turn left you will end up looking East (dir = 01). Therefore, in the turn left array, you want the first entry to be East.

Table 1: Truth Table for TurnLeft Pseudo-instruction

Facing Direction			Direction after turning Left
	dir.1	dir.0		dir.1	dir.0
	x	y
South	0	0	East	0	1
East	0	1	North	1	1
West	1	0	South	0	0
North	1	1	West	1	0

Create the array in assembly using the Define Byte (.DB) assembly directive. Access the array using the indirect addressing mode instruction lpm.

WhichWay – Testing the T flag

To find out if your pseudo-instructions work, you are going to write a new subroutine named WhichWay. Call WhichWay from the main program just after moving the SRAM variables dir and turn into temporary registers r24 and r22 respectively. Unlike your in-line code written in Labs 1 and 2, our subroutines do not work directly with variables dir and turn. Instead these variables are loaded into registers r24 and r22 and then sent as arguments to WhichWay. Subroutine WhichWay also does not change the variable dir directly. Instead, it returns the new direction value in register r24, which we then store in variable dir. We are doing this for two reasons. First, it makes our subroutines more general purpose, allowing them to possibly be used in other parts of our program and second it allow our assembly programs to be called from a top level C++ program. Add the following code to the main loop right after the section that updates the SRAM variables.

// turn = (switch >> 2) & 0x03;
… write your assembly code with comments here.
...

; Direction Finder

 lds r24, dir   // load direction bear is facing into r24
 lds r22, turn  // load direction bear is to turn into r22
 rcall WhichWay // change direction based on variable turn
 sts dir, r24   // save formatted value to SRAM variable dir.

; Draw Direction

   lds r24, dir        // calling argument dir is placed in r24.
   rcall DrawDirection // translate direction to 7 segment bit
   mov spi7SEG, r24    // Displays DrawDirection on the 7 segment display.
   call WriteDisplay

We will be using switches 3 and 2, now right justified and located in register r22 bits 1 and 0 respectively to input which action we want the bear to take as defined by the following table.

Table 2: Truth Table of Turn Indicators

r22 bit 1	r22 bit 0	action
0	0	do not turn
0	1	turn right
1	0	turn left
1	1	turn around

Step-by-Step Instructions for writing WhichWay

1.  Let’s begin with the header block so we will know how to use our subroutines. Although you may place this subroutine anywhere after the rjmp loop instructions, I would recommend placing it right at this point.
   
   Like all subroutines the last instruction is always return (ret).
2. The basic objective of our WhichWay subroutine is to translate two switch bits into four subroutine calls. One way to accomplish this is by testing each bit at a time as shown in the following flow chart. This is the same technique used in Pre-lab 02 to determine the room number the bear had entered.

I began by testing bit 1, if it is one (1) then I know that I am looking at condition (cond) 11₂ or 10₂. At this point I do not know which so I will label this point cond 1X, where the X could be 1 or 0. Following this path I next test bit 0. If it is 1 then I know I have condition 11₂ and I need to turn around. If it is 0 then I have condition 10₂ and I need to turn left. The 0X condition follows a similar train of logic.

Now we have to turn our flowchart into assembly code. The key is the use of the branch if T set (brts) instruction. Here is the start of my version of WhichWay. I use my handy bst instruction to sequentially copy each switch value into the T flag and branch based on its value (1 or 0) using the brts instruction.

Repeat the above strategy to implement the cond_1X one bit test and then branch to conditions 10 and 11 (cond_10 and cond_11) accordingly.

Design Challenge – Dueling Subroutines (2 points)

You can skip this section if you are happy receiving a passing or even a good grade on the lab. If you want to receive an excellent grade you will need to accept the challenge. If you implemented the third solution (one-dimensional array with indirect addressing mode) then you should skip this design challenge.

Create a new Project named Lab03C. Copy the contents of your Lab03.asm file into your new Lab03C.asm file. Place a copy of your spi_shield.inc and testbench.inc files along with the upload.bat file into your new project folder. Update the file name in the upload.bat file. Build your project and verify you are starting with zero errors and zero warnings.

Using the Programmer’s Reference Card (Figure 2) and the following switch assignments, we would know that the bear was going North when he entered a room with North and West facing walls. Given no choice, the bear is instructed to turn right. Run the program on your Arduino and verify that this is in fact what happens.

What if we had not told the bear to turn right, but instead had taken no action and let the bear continue north.

Enter these switch settings and see what happens. At first you will probably not see any difference; however, if you look a little closer you will see that segment a is a little brighter than the others. What is going on? The part of your code which builds the room is interfering with the code which generates the direction. Both program elements modify the same bits in spi7SEG register r8 before calling WriteDisplay, so one may turn a segment on while the other turns it off.

Your challenge is to solve this problem. For my solution I defined a byte in SRAM named room7segment.

.BYTE room7segment 1

Variable room7segment is different from variable room. The latter holds a 4-bit value corresponding to the room number, while the former contains the actual LEDs to be turned on or off. Do not get confused.

I then replaced spi7segment with an instruction to save the room to be displayed in variable room7segment in my room builder program. Next I deleted the first call to WriteDisplay. Next I wrote a new subroutine named Display; replacing my last call to WriteDisplay with this new subroutine. In my new Display subroutine I combined room7segment and spi7SEG using a logical or instruction.

lds r24, room7segment
 or spi7SEG, r24

Now if a room or direction LED is on it stays ON. Now all I needed to do was call WriteDisplay before returning to the calling program.

This is a design challenge so you may run into problems. If you do, don’t forget to use the simulator to help you figure out what is going wrong.

Appendix A Rules for Working with Subroutines

In the last lab I introduced three steps for writing a program for a load-store RISC based architecture.

1. Load the data (lds),
2. Do something (typically an arithmetic or logical instruction), and then…
3. Store (sts) the result.

When working with subroutines an analogous set of steps applies.

1. Load argument(s) into input registers (parameters) specified in the header of the subroutine. Following the gcc C++ calling convention, this would be register r24 if only one calling argument is specified (lds r24, myData).
2. Call the Subroutine
3. Do something with the return value(s) stored in the output register(s) specified in the header of the subroutine. Following the gcc C++ calling convention, this would be register r24 if a single byte value is returned. In most cases you will storing this return value(s) into SRAM data memory (sts myData, r24).

You call a subroutine using the rcall or call assembly instruction and return using the ret instruction. Here are a few rules to remember when writing your main program and subroutines.

• Your subroutine should always include a header block. As a minimum, the header must define the input arguments to the subroutine, the values returned, and what if any registers are modified by the subroutine.
• Always initialize variables and registers at the beginning of your program. Do not re-initialize variables or registers within a loop or a subroutine. For example, you only need to configure the port pins assigned to the switches once.
• Never jump into a subroutine. Use a call instruction to start executing code at the beginning of the subroutine.
• Never jump out of a subroutine. Your subroutine should contain a single return (ret) instruction as the last instruction.
• You do not need an ORG assembly directive. As long as the previous code segment ends correctly (rjmp loop, ret, reti) your subroutine can start at the next address.
• Subroutine names start with a capital letter.
• Your subroutine should contain only one return instruction (ret, reti) located at the end of the subroutine (last instruction). All blocks of code within the subroutine should exit the subroutine through this return (ret).
• Push (push r7) any registers modified by the subroutine at the beginning of the subroutine and pop (pop r7) in reverse order the registers at the end of the subroutine. This rule does not apply if you are using one of the registers or SREG flags to return a value to the calling program. Comments should clearly identify which registers are modified by the subroutine.
• You cannot save the Status Register SREG directly onto the stack. Instead, first push one of the 32 registers on the stack and then save SREG in this register. Reverse the sequence at the end of the subroutine.

push r15
 in r15, SREG
 :
 out SREG, r15
 pop r15

• Once again, never jump into or out of a subroutine from the main program or any other subroutine. However, subroutines may call other subroutines.

Lab 3B: Pseudo-instruction HitWall, LeftPaw, and RightPaw

Pre-Lab 4A: Polling

• The ATmega328P is equipped with two 8-bit timer/counters and one 16-bit counter. These Timer/Counters let you…
• Turn on or turn off an external device at a programmed time.
• Generate a precision output signal (period, duty cycle, frequency). For example, generate a complex digital waveform with varying pulse width to control the speed of a DC motor
• Measure the characteristics (period, duty cycle, frequency) of an incoming digital signal
• Count external events

Nomenclature

Frequency

The number of times a particular event repeats within a 1-s period. The unit of frequency is Hertz, or cycles per second. For example, a sinusoidal signal with a 60-Hz frequency means that a full cycle of a sinusoidal signal repeats itself 60 times each second, or every 16.67 ms. For the digital waveform shown, the frequency is 2 Hz.

Period

The flip side of a frequency is a period. If an event occurs with a rate of 2 Hz, the period of that event is 500 ms. To find a period, given a frequency, or vice versa, we simply need to remember their inverse relationship, where F and T represent a frequency and the corresponding period, respectively.

Duty Cycle

In many applications, periodic pulses are used as control signals. A good example is the use of a periodic pulse to control a servo motor. To control the direction and sometimes the speed of a motor, a periodic pulse signal with a changing duty cycle over time is used.

Duty cycle is defined as the percentage of one period a signal is ON. The periodic pulse signal shown in the Figure 1 is ON for 50% of the signal period and off for the rest of the period. Therefore, we call the signal in a periodic pulse signal with a 50% duty cycle. This special case is also called a square wave.

Timer 1 – Normal Mode Operation (default)

In lab you will be using the timer subsystems of the ATmega328P to generate a square wave with a frequency of 2 Hz.

We will be working with 16-bit Timer/Counter 1 due to the large delays (250 msec) needed to generate our 2 Hz frequency square wave. To keep things as simple as possible we will be operating Timer 1 in its default Normal mode. In this mode the counting direction is always up (incrementing). The counter overruns when it passes its maximum 16-bit value (MAX = 0xFFFF) and then restarts from the BOTTOM (0x0000). In normal operation the Timer/Counter Overflow Flag (TOV1) will be set in the same timer clock cycle as the TCNT1 becomes zero.

The TOV1 Flag in this case behaves like a 17th bit, except that it is only set, not cleared.

Maximum Delay

So can TCNT1 generate the 250 ms delay required to generate our 2 Hz square wave? To answer that question we will need to determine the maximum delay possible. Assuming a system clock frequency of 16.000 MHz and a prescale divisor of 64, the largest time delay possible is achieved by setting both TCNT1H and TCNT1L to zero, which results in the overflow flag TOV1 flag being set after 2¹⁶ = 65,536 tics of the Timer/Counter1 clock.

f_T1 = f_{Tclk_I/O}/64, given f_{Tclk_I/O} = f_clk then f_T1 = 16.000 MHz / 64 = 250 KHz

and therefore T1max = 65,536 tics / 250 KHz = 262.14 msec

Clearly, Timer 1 can generate a delay of 250 msec. Our next step is to calculate the TCNT1 load value needed to generate a 250 ms delay.

Step to Calculate Timer Load Value (Normal Mode)

To generate a 250 msec delay assuming a clock frequency of 16 MHz and a prescale divisor of 64.

Variables

t_{clk_T1 –} Period of clock input to Timer/Counter1
f_{clk –} AVR system clock frequency

Solution

1. Divide desired time delay by t_{clk_T1} where t_{clk_T1} = 64/fclk = 64 / 16.000 MHz = 4 µsec
   250msec / 4 µs = 62,500
2. Subtract 65,536 – step 1
   65,536 – 62,500 = 3,036
3. Convert step 2 to hex.
   3,036 = 0x0BDC

For our example TCNT1H = 0x0B and TCNT1L = 0xDC

Question 1 What values would need to be loaded into TCNT1H and TCNT1L to generate a 38 ms delay with a system clock frequency of 10.000 MHz and a prescale divisor of 8 (show your work)?

Initialization

Applying what we learned lets setup our timer to set overflow flag TOV1 after 250 ms.

ldi r16,0x0B // load value high byte (Sect 15.2-15.3)
sts TCNT1H,r16
ldi r16,0xDC // load value low byte
sts TCNT1L,r16

In the next step we simultaneously turn on the clock to Timer 1, and apply a prescaler of 64, as defined in Table 7.10: Timer1 Clock Select Bit Description in your textbook.

; Initialize Timer/Counter1
ldi r16,(1<<cs11)|(1<<cs10)  // prescale of 64 Sect 15.11.2
sts TCCR1B,r16 // Table 15-5 Clock Select Bit Description

The C++ bit-wise left shift operator

The C++ bit-wise left shift operator << is used to move a one (1) into a specified bit location within a byte. In the first half of the expression an 8-bit value is built with the CS1 bit 1 set to 1 ( 0b00000010). In the second half of the expression an 8-bit value is built with the CS1 bit 0 set to 1 ( 0b00000001). The C++ bit-wise or operator | is used to combine these two bytes to form the byte to be stored in register r16 (0b00000011).

Question 2 The first two lines of code set both CS11 and CS10 bits to 1 in Timer 1 register TCCR1B, while setting all other bits to zero. What hexadecimal value is saved in TCCR1B? Register TCCR1B is shown in Figure 9-18 TCCR1B (Timer 1 Control) Register of your textbook. If you do not have the textbook you can also find this register in Section 15.11.2 TCCR1B – Timer/Counter1 Control Register B in the ATmega328P_doc8161 pdf file found in the reference folder on my website. Once you find register TCCR1B locate bits CS11 and CS10 and set these to one (1), set all other bits to zero (0). Convert this binary number to hexadecimal and you have the answer.

Polling

At this point the timer has been initialized so it will set the overflow flag TOV1 in the TIFR1 register after 250 ms, and the timer’s clock has been started.

Polling the overflow flag TOV1 is a very simple way to keep track of time. Specifically, with a polling routine we loop until the overflow flag bits is set (TOV1 = 1), once this event occurs, we know the desired time has elapsed.

Question 3 Write a small assembly subroutine named delay to poll the TOVF1 flag. When the flag is set (TOV1 = 1), clear theTOV1 flag by writing a 1 (sbi TIFR1, TOV1), and reset the timer value (TCNT1H:TCNT1L = 0x0BDC). You may think I just made a mistake by saying write a 1 to the TOV1 flag to clear it – but this is in fact how you clear a flag within the ATmega architecture. Do not ask me why.

Question 4 You have now written a subroutine to generate a delay of 250 ms, now let’s use that delay to toggle a byte in SRAM at a frequency of 2 Hz. I am going to do this by introducing a new variable named next_state whose value toggles between all 0s and all 1s. Complete my code to accomplish this goal. You may assume that next_state is initially equal to zero.

; — 250 msec —-

rcall Delay

; — next_state —

lds r20, next_state // toggle next_state

ldi r16, 0x     
___ r20, r16
sts next_state, r20

Question 5 In this lab you will be generating a 2-state FSM. You have now written a subroutine to generate a delay of 250 ms and can toggle variable next_state at a frequency of 2 Hz, but how will you know it really works?

Over the next few labs you will be upgrading your FSM from 2 to 3 states and finally to 4 states. At the present time the LEDs are no longer required, so we are going to use the most significant 2 LEDs to display the current state of the FSM (the value in register r20).

Write a short program 4 to 5 line program to move bits 1 and 0 in register r20, to discrete LEDs (spiLEDS) bits 7 and 6.

What Should I Turn In?

Turn in the following material three pages. Make sure all your original work is in your Lab Notebook. All written material must be typed or neatly done in ink. Once again please do not copy.

Page

1. Title page with the pre-lab number, your name and picture, today’s date, and the day your lab meets.
2. The problem statements (remove explanatory text) and solutions to all pre-lab questions. Circle and/or highlight your answers. Make sure all your original work is located in your lab notebook.
3. Your delay subroutine. This should be done in AVR Studio and assemble without errors.