Schedule

Readings:

• A fun read on how the Raspberry Pi came to be for a taste of the adventure to come.
• For background, review our guides on electricity, binary/hexadecimal numbers, and the unix command line.
• Bookmark this collection of unix video tutorials that were prepared for CS107 students. These videos cover basic concepts, common utilities, development tools, and productivity features.
• I also recommend Steven Wolfram's blog post Untangling the Tale of Ada Lovelace for a nice description of Charles Babbage's and Lady Ada Lovelace's roles in developing the concept of a general-purpose computer.

• Read Baking Pi ( intro, lesson1, lesson2 ) and skim Carl Burch's Intro to ARM assembly.
• Here is a link to the VisUAL simulator demoed in lecture.

• Before lecture, read/skim sections A3.1-A3.4 and A3.11 from the ARM Instruction Set Architecture manual.
• Our one-page guide to ARM.
• An interactive demo of ARM immediate value encoding. A tribute to how much can be done with just an 8-bit value and barrel shifter!
• Enjoy Danny Cohen's article Holy Wars and a Plea for Peace on the history of little-endian vs. big-endian.

• Review sections A3.2 and A3.3 on conditional execution and branch instructions from the ARM Instruction Set manual
• Our one-page guide to ARM.
• Brush up on C basics (syntax, data types, operators, control structures) via your favorite C reference; sections 1-2 of Nick Parlante's EssentialC; or chapters 1, 2, and 3 of K&R. Skip content on I/O and standard libraries (we are bare metal!)
• Read Dennis Ritchie's account of the history of C
• Try out the Compiler Explorer demoed in lecture
• Read our guides on make and gcc

• Before lecture, read EssentialC chapters 3 (skip material on structures) and 6 (skip material on the heap and memory management) or K&R 5.1-5.4. C-strings are primitive compared to Java/C++ strings; take note of the manual effort required to use and pitfalls to avoid.
• Poul-Henning Kamp's essay on The Most Expensive One-byte Mistake. Did Ken, Dennis, and Brian choose wrong with NUL-terminated text strings?
• C volatile can be subtle and tricky. See GeeksForGeeks advice on correct use and John Regehr's blog on what NOT to do with volatile

• Read up on C functions (Chapter 4 in K&R, or Section 4 in Essential C).
• Read Thinking Geek's explanation of the mechanics of local variables and stack frames.
• Here is the ARM reference on implementing stacks with ldm and stm and this nice explanation of LDM https://keleshev.com/ldm-my-favorite-arm-instruction/

• Read about characters and strings, IO functions (putc,puts,printf), and structures (Sections 1.5, 1.6, 1.9, 5.5, 6, 7 in K&R; or Section 3 in EssentialC).
• Read Sparkfun's tutorial on serial communication.

• Read David Welch's articles on baremetal programming and bss data.

• Read our overview of ARM stack frames
• Review dynamic memory allocation (malloc/free in C) and the operation of the heap (K&R 5.6-5.9 or Essential C Section 6). Consider the comparison/contrast between stack and heap allocation and use cases for each.

We've crossed the halfway point! We will use this lecture to catch-up/expand on lecture content covered lightly on first pass, and discuss how to further your mastery of C.

Readings:

• Google style guide for C/C++ code: https://google.github.io/styleguide/cppguide.html
• Read code! Our code, your code, other published code,… Some selected projects to browse:
  • https://github.com/dwelch67/raspberrypi, David Welch baremetal examples
  • https://opensource.apple.com, Apple OpenSource
  • https://directory.fsf.org/wiki/GNU, Free Software Foundation (GNU)
  • https://musl.libc.org, Musl C library
• The masters share their best practices in the book "Beautiful Code: Leading Programmers Explain How They Think" https://www.amazon.com/dp/0596510047

• Read Adam Chapweske's overview of the PS/2 protocol for keyboards and mice.

• Read about the framebuffer in these Baking Pi lessons: Screen 1, Screen 2, Screen 3, Screen 4.

In this first lecture on interrupts, we'll focus on the low-level mechanics and what needs to happen at the assembly level to enable and process an interrupt.

• Selected code from interrupts module.
• Interrupts chapter of ARM manual, annotated by Dawson Engler for CS140E

Now we move up to the higher-level abstractions for interrupts, including library support for managing interrupt handlers and reviewing best practices for interrupt-safe code.

• Peruse our list of available sensors for possible use in your project.
• Wikipedia entries on analog-to-digital conversion and pulse width modulation.

Tips and tricks from Anna and Maria on making your code fly! Also, some quick tips for final projects.

Matt's "whirlwind tour" of important topics including Trust and Safety, the Memory Hierarchy and Caching, Memory Safety, and Recommended Future Classes. Also includes some fun intermissions.

Representation of signed and unsigned numbers, types and type conversion.