Lumetta's Links for ECE120 Fall 2016

Remember to check the CLASS WIKI!

ECE120 Notes for Students, Fall 2016 release

Online Exercises

These tools have been designed to help you master some of the skills that we hope to teach you in ECE120. They are written in Javascript and thus can execute in a variety of browsers, including Chrome on Android devices.

Each tool focuses on a particular set of skills, and most of the tools create problems randomly, allow you to solve them, and allow you to check your answers with quick feedback.

A little more detail on testing: The tools have been tested reasonably thoroughly on Chrome on both my laptop and on a Samsung Galaxy S3 (Android). I developed mostly on Firefox, so that's well-tested, too. I did run them all on IE, too. (I also used Chrome on a Samsung Galaxy S5.) They do not work on the default Samsung mobile browser. Apple ... not so well. Feel free to lend me yours for a bit and I'll debug.

Exercises for Part 1

The truth table exercises also have a couple of extra parts for students who want to get ready for part 2 of the class (K-maps and so forth).

• Representations and Logic
• Analysis of C Code
• Truth Tables

Exercises for Part 2

• CMOS Gate Layout Tool
• Karnaugh Maps
• Combinational Logic

Lecture Slides

These are the slides that I plan to use in lecture. I'm still writing them, so I will put them up as I finish doing so. They are organized by topic, not by date. Some topics may be skipped in lecture in the interest of time.

• Part 1: Representations
  • Introduction
  • Abstraction Layers
  • Representations and Bits
  • The Unsigned Representation
  • Modular Arithmetic
  • 2's Complement
  • Boolean Logic
  • Logical Completeness
  • Fixed- and Floating-Point
  • Hexadecimal, Terminology, and Text
  • Extra Slides on Representations (Fall 2016)
• also Part 1: C Programming
  • Introduction to C
  • Expressions and Operators
  • Basic I/O
  • Statements in C
  • Program Execution
  • Program Analysis
  • Testing Programs
  • Bit Manipulation in C
• Part 2: Transistors to Circuits
  • Logic Gates
  • Optimizing Logic Expressions
  • Boolean Terminology
  • Karnaugh Maps (K-Maps)
  • Two-Level Logic
  • Pareto Optimization*
  • Boolean Properties
  • Don't Care Outputs
  • Caring About Don't Cares and Glue Logic
  • The Ripple Carry Adder
  • Bit-Sliced Designs
  • Bit-Sliced Comparator
  • Analyzing and Optimizing the Bit-Sliced Comparator
  • A Comparator for 2's Complement
  • A Power of Two Checker
  • Building with Abstraction and a First Example
  • Checking for Upper-Case Characters
  • Multiplexers
  • Decoders
  • Storing a Bit
  • The Clock Abstractions
  • Static Hazards*
  • Registers
• Part 3: Finite State Machines (FSMs) to the von Neumann Model
  • Serialization
  • Example of Serialization
  • Second Example of Serialization
  • Finite State Machines (FSMs)
  • Binary Counters
  • Machine Models
  • FSM Design Process
  • Color Sequencer
  • Design of the Lab FSM
  • Extending Keyless Entry
  • Vending Machine Implementation
  • Memory
  • From FSM to Computer
  • The von Neumann Model
  • LC-3 as a von Neumann Machine
  • Instruction Formats
  • Instruction Processing
  • Instructions Illustrated
  • The LC-3 ISA
  • Counting to Ten
• Part 4: LC-3, Programming, and Computers
  • Typing in a Number
  • Computers are Dumb
  • Systematic Decomposition
  • Good Design
  • Letter Frequency Planning
  • Letter Frequency Decomposition
  • Letter Frequency Coding
  • Assembly Language
  • Assemblers
  • Example Program: ASCII Screen Art
  • LC-3 Control Signals
  • LC-3 Control Signals for Fetch and Decode
  • LC-3 Control Signals for LDI Execution
  • Hardwired Control Unit Design
  • Microprogrammed Control Unit Design
  • The Patt and Patel Control Unit
  • Error Detection
  • Parity and Hamming Distance
  • Error Correction, Hamming Codes, and SEC-DED Codes
  • Advice

Recorded Lectures

• Part 1: Representations (REVIEW SESSION)
  • Monday 22 August: Introduction, start of Abstraction Layers
  • Wednesday 24 August: Abstraction Layers, Representations and Bits, Unsigned Representation, Modular Arithmetic
  • Friday 26 August: 2's Complement, Boolean Logic -- note that hyperexponential functions (2^(2^N)) are not the same as exponential functions (4^N) despite my agreeability in the video.
  • Monday 29 August: Boolean Logic, Logical Completeness, Fixed- and Floating-Point
  • Wednesday 31 August: Fixed- and Floating-Point, Hexadecimal, Terminology, and Text, Extra Slides on Representations
• also Part 1: C Programming
  • Friday 2 September: Introduction to C, Expressions and Operators
  • Wednesday 7 September: Expressions and Operators, Basic I/O, Statements in C
  • Friday 9 September: Program Execution, Program Analysis, Testing Programs, Bit Manipulation in C; Unfortunately, the mic died a few minutes into the lecture, so you may want to just read the slides (above on this page) and read/download and play with the code (below on this page).
• Part 2: Transistors to Circuits (REVIEW SESSION)
  • Monday 12 September: Logic Gates, Optimizing Logic Expressions
  • Wednesday 14 September: Boolean Terminology, Karnaugh Maps (K-maps)
  • Friday 16 September: Karnaugh Maps (K-Maps), Two-Level Logic, Pareto Optimization
  • Monday 19 September: REVIEW FOR MIDTERM 1
  • Wednesday 21 September: Boolean Properties, Don't Care Outputs, Caring About Don't Cares
  • Friday 23 September: Caring About Don't Cares, The Ripply Carry Adder, Bit-Sliced Designs, Bit-Sliced Comparator
  • Monday 26 September: Bit-Sliced Comparator, Analyzing and Optimizing the Bit-Sliced Comparator
  • Wednesday 28 September: A Comparator for 2's Complement, A Power of Two Checker, Building with Abstraction and a First Example
  • Friday 30 September: Checking for Upper-Case Characters, Multiplexers, Decoders
  • Monday 3 October: Storing a Bit, The Clock Abstraction; sorry, the video feed seems to have had a problem on this day, so the slide view is completely broken; remember that you can get copies of the slides for both of these topics higher up on this page.
  • Wednesday 5 October: Static Hazards, Registers
• Part 3: Finite State Machines (FSMs) to the von Neumann Model (REVIEW SESSION)
  • Friday 7 October: Serialization, Example of Serialization
  • Monday 10 October: Examples of Serialization, Finite State Machines (FSMs)
  • Wednesday 12 October: Binary Counters, Machine Models, FSM Design Process
  • Friday 14 October: Color Sequencer, Design of the Lab FSM
  • Monday 17 October: REVIEW FOR MIDTERM 2
  • Wednesday 19 October: Extending Keyless Entry, Vending Machine Implementation
  • Friday 21 October: Vending Machine Implementation, Memory
  • Monday 24 October: Memory, From FSM to Computer
  • Wednesday 24 October: From FSM to Computer
  • Friday 26 October: The von Neumann Model, LC-3 as a von Neumann Machine, Instruction Formats
  • Monday 31 October: Instruction Formats, Instruction Processing, Instructions Illustrated, The LC-3 ISA
  • Wednesday 2 November: The LC-3 ISA
  • Friday 4 November: Counting to Ten
• Part 4: LC-3, Programming, and Computers (REVIEW SESSION--starts around 11:10)
  • Monday 7 November: Typing in a Number, Computers are Dumb
  • Wednesday 9 November: Systematic Decomposition, Good Design, Letter Frequency Planning
  • Friday 11 November: Letter Frequency Decomposition, Letter Frequency Coding
  • Monday 14 November: REVIEW FOR MIDTERM 3
  • Wednesday 16 November: Letter Frequency Coding, Assembly Language, Assemblers
  • Friday 18 November: an Example of Programming (not from slides)
  • Monday 28 November: LC-3 Control Signals and Examples: Fetch, Decode, and LDI Execution
  • Wednesday 30 November: Hardwired Control Unit Design, Microprogrammed Control Unit Design, The Patt and Patel Control Unit
  • Friday 2 December: Error Detection, Parity and Hamming Distance (skip ICES by going to time 22:00)
  • Monday 5 December: Error Correction, Hamming Codes, SEC-DED Codes, Advice
  • Wednesday 7 December: Advice and REVIEW FOR FINAL EXAM

Examples of C Code

Here are five examples programs that we will examine in class to help you learn how C works. I will have copies of this handout made for you to use in class, but if you want to download and try the programs, they are also here.

For more experience with reading and understanding C code, try the online tool linked at the top of this page. For more experience writing C code ... stay tuned, we'll announce something around Labor Day (5 Sept 2016).

• Fibonacci Printer
• Factorial Calculator
• An Exercise in Reading C Code
• Quadratic Equation Solver
• Riemann Summation
• Truth Table (not in PDF handout, so view it here)

Examples of LC-3 Code

• Example of counting to 10
• "Typing in a Number" from the keyboard example
  • binary version (PDF)
  • assembly subroutine version (PDF)
• Letter frequency histogram example
  • binary version (PDF)
  • assembly version (PDF)
• ASCII screen art example (from Friday 18 November 2016): assemble a solution version and a message, run the command-line simulator on the message, use the file command to load the solution code, then continue to see the message
  • solution version developed in class
  • secret message from Rahul
  • tiny message written in class
  • my prototype solution version

I/O in C*

Since many of you seem to be interested in understanding how to manage I/O more elegantly, I am going to add these old notes to our page. Please be aware that our class will not require this material in any way nor even explain most of the background material necessary to understand it!. That said, here are some Notes on I/O in C

Return to Steve's Home Page