Roadmap to the EECS 373 Resources

EECS 373 has no book but volumes of reading materials and web resources. This document is an annotated roadmap for navigating through those materials and resources in a structure that roughly follows the class syllabus.
  1. Motivation. Embedded systems are everywhere and they're only becoming more common as processors, memory, sensors, wireless, and power source become smaller and less expensive. Going forward, lots of embedded systems that marry hardware and software are going to be emerging in the home, office, car, train, power grid, and so on. If you're curious about the pedagogical history of this class, check out Steve Reinhard's paper on an earlier version of this class (the details have changed, but not the course goals). If you like building and hacking around with embedded systems, check out SparkFun for lots of cool stuff. If you might like to start a company selling a hardware/software product, you might want to check out the following blogs and websites to get an idea what just one, two, or a few people can pull off these days: FitBit, Saleae, PlantSense, WakeMate, WattVision, LIFX, and SensorDrone.

  2. SmartFusion Hardware. We're using the SmartFusion Evaluation Boards in lab. The SmartFusion Kit (User Guide) provides a modern, mixed-signal FPGA/MCU system. The full schematics are also available. The SmartFusion includes an ARM Cortex-M3 as part of the Microcontroller Subsytem (User Guide). SmartFusion also include an Analog Subsystem (User Guide) with ADCs, DACs, comparators, and lots of other interesting things.

  3. Architecture. In this class, we focus on the ARM Architecture in general and the ARM Cortex-M3 in particular. The ARM Cortex-M3 Technical Reference Manual provides a functional description, programmers model, and an overview of the NVIC. An instruction set cheat sheet that lists the instructions in short form is available. If you're looking for all the gory details, check out the ARM Architecture Reference Manual (aka ARM ARM). This 716-page tome covers the ARMv7 M profile, app level programmers model, memory model, ARMv7-M instruction set, Thumb instruction set encoding, Thumb instruction details, system level programmers model, system memory model, system address map, system instructions, and debug architecture. The ARM Architecture Procedure Call Standard specifies how to write code that complies with the ARM Embedded Application Binary Interface (EABI). Different tools that comply with this standard generate compatible object files. The ARM family of processors use the AMBA bus to communicate with non-CPU on-chip peripherals. A historical perspective on the genesis of AMBA is available too. In this class, we focus on two subparts of the AMBA architecture including the AHB-Lite for connecting high-performance peripherals and APB for connecting peripherals to the core.

  4. Memory. Most external parallel devices are either memory or they look like memory and are memory-mapped into the processor's system address space. So, it's useful to know how to interface various memory technologies. Most of the traditional memory interfaces are standardized. For example, the Open NAND Flash Interface specifies the electrical and mechanical specs of the Flash memory interface that Flash chips like the Spansion S29GL512P and others conform to. Another memory datasheet worth taking a look at is GS78108 asynchronous RAM. To learn more about how memory is implemented on chip, you might consider reading about ROMs, EPROMs, and EEPROMs or SRAMs.

  5. Tools. This course uses the GNU GCC tools to develop assembly and C code for the ARM Cortex-M3. We could also have used Keil (from ARM) or other tools but chose GCC since the tools can be freely downloaded. We're using the CodeSourcery toolchain for labs (Getting Started). This toolchain provides/improves the following tools: GNU Assembler (which assembles ARM assembly into object code), GNU Compiler (which compiles C and C++ code into object code), GNU Preprocessor (which processes all those defines and inclues), GNU Linker (which takes one or more object code fragments along with a linker script and turns it into a binary image), GNU Debugger (which allows you to add debugging code to your programs, step through execution, watch variables, etc.), and GNU Binary Utilities (which include objcopy and objdump for changing binary formats, disassmbling object files, etc.).