CSE467: Advanced Logic Design

Carl Ebeling, Winter 1999

Final Project Description

Due Dates

Distributed Feb 22
Initial Design Specification: March 1
Initial Schematics/Verilog: March 5
Completed Circuit Due: March 12

Overall Project Description

The device you will be implementing is a simple electronic Rolodex which stores information from cards' magnetic stripes. Each time you swipe a card, the information from the magnetic stripe will be stored in memory and also displayed on the LCD display. The memory will have space for many card records; each new card swiped will be stored in the next memory location. It will be convenient to think of the card records being numbered starting at 1. Record 0 is always empty, and this is what is displayed at reset. The first card will be read into record 1 and also displayed. The second card read will go into record 2 and displayed.

Two push buttons will allow the user to "scroll" through this memory. The "back" button goes to the previous record in memory and displays the card stored there. The "forward" button goes to the next record in memory and displays that card; the "back" button can be used to go back all the way to record 0. In addition, there will be a reset button that will go back "home" to record 0. The next card read is always stored at the next location after the card shown on the display. That is, if we have scrolled back to record 3, then the next card will be stored as record 4.

Project Specification

The first thing you must do is decide on a complete specification of your project. For example, what happens if a button is pushed in the middle of a card swipe? What kind of cards will you handle? What if the card swipe did not work properly? How many and which characters will you display? How about characters on the second line of the magnetic stripe? Will you keep track of the number of cards read?

This specification will evolve over time as you think of more things. Your "spec" will be an online document that you add to. By the time you have completed the design, your specification should be complete.

Partitioning the project

The project can be partitioned into four main pieces: the magnetic stripe reader, the memory controller, the LCD display and the central controller. This partitioning is shown below:

After you have finished an initial specification of the overall project, your next design task will be to define the interfaces of each module. We have already defined the interface to the LCD module and designed its implementation, so you have an idea of what an interface should be. You have also designed an interface for the magnetic card stripe reader and connected it to the LCD interface. You will now need to design a similar interface for the memory. You will want to make this interface as simple and as abstract as possible, hiding all the ugly details inside the module. Think of each module as a procedure call. With good interfaces, you will be able to divide your design up and have different group members work on different parts.

The central controller is the "main program" and will co-ordinate the other three modules. Data should be allowed to pass directly between the other modules, but the control module will control the operation of these modules via control signals. Your module interface design may evolve as you do your design and you think of more issues. But any changes will have to be reflected in the implementation of the modules. So thinking hard about the interfaces and how the central controller will control the show before you start will save you time later on.

The interface specification will consist of two parts. First, there is the description of the signals that pass between two components. Second, there is the operation of the interface, i.e. the interface protocol. You can describe the signals by redrawing the above system block diagram in more detail, showing exactly what signals pass between the different modules. The second part will have to be text, supplemented with timing diagrams which show how the interface signals interact.

You should hand in an initial design and interface specification on Monday, March 1.

Card Memory

The XESS board has a 32Kx8 SRAM chip which we will use to store the card data. I will give you a data sheet describing this SRAM and we will spend time in class talking about how to use a simple SRAM like this. The Central Controller should not read and write this memory directly. Instead, the memory module should be designed with a higher-level protocol which allows the Central Controller to read and write entire records in the memory. By isolating complexity in the memory controller, the central controller can be made simpler.

Central Controller

The brains of the whole project will be in the central controller. It keeps track of data coming from the mag stripe reader and directs it to the memory and the LCD display. It also keeps track of the scroll buttons, executing the "forward" and "back" commands. If you design the interfaces correctly, the design of this module will be a relatively straightforward state machine.

Design Process

You should proceed as follows:
  1. Write as much of the specification as you can to start with, updating it as you go along.
  2. Define the interfaces for the mag stripe reader and the memory module. Think through how the modules will interact and how data will get moved around. Remember that the main controller has little control over the mag stripe reader and will have to keep up with whatever it does.
  3. At this point, turn in an initial design specification so that we can conduct a design review of your project. This will be due March 1.
  4. Design and test the memory module and the main controller.
  5. Simulate the entire project. We will tell you how to simulate this memory.
  6. Implement, test and debug the project.

Extensions to the Project (Extra Credit)

If you are worried that the project is too easy, here are some ways the project can be extended. You could figure out how to display more data on the card using a more complicated scrolling interface. For example, an extra module could be added that implements an RS-232 serial interface through which the data in the card memory could be sent to a PC or a Pilot. Or you may have ideas of your own; if so, feel free to discuss them with us.

Hand In:

  1. March 1: A complete design specification, including details on exactly what your device will do (as well as you know), a detailed interface specification for all modules, and a written specification of how each module operates. For example, this should indicate how data is stored in memory and how addressing is done. We will do a design review and give you feedback.
  2. March 5: Initial design (schematics and Verilog). These should be complete, if not completely working.
  3. March 12: Demonstrate completed circuit. Hand in complete design: specification and documentation, schematics, Verilog.
ebeling@cs.washington.edu