Retrocomputing with Clash

Haskell for FPGA Hardware Design

Table of contents

  1. Introduction
  2. Into the world of FPGAs
    1. Computers everywhere
    2. Field-programmable Gate Arrays
    3. Retrocomputing
    4. Haskell meets Hardware
  3. Hello, Clash!
    1. Bit
    2. Signal
    3. Our first circuit
    4. Summary
  4. Combinational Circuits are Applicative Functors
    1. Signal is an applicative functor
    2. BitVectors and Vectors
    3. Controlling many LEDs
    4. Seven-segment display
    5. Summary
  5. State, Sequencing and Clocks: The Register Transfer-Level Model
    1. Clocks and registers
    2. The RTL model: register and delayed feedback
    3. Finally blinkenlights!
    4. Passing around Clock, Reset and Enable lines implicitly
    5. Multiple clocks
    6. Pushbutton-toggled LED
    7. Summary
  6. Time-domain Multiplexing
    1. Does this have anything to do with mux?
    2. Seven-segment displays, revisited
    3. Keyboard matrix sweeping
    4. Showing keypad input on a seven-segment output
    5. Summary
  7. Project: Pocket Calculator
    1. A Minimal Viable Calculator
    2. Binary Coded Decimal arithmetic
    3. State and state transitions
    4. An interactive software implementation
    5. Hooking it up to hardware peripherals
    6. Summary
  8. Video Output Using VGA
    1. Basic operation of a CRT display
    2. Video Graphics Array
    3. VGA from Clash
    4. Summary
  9. Generative Graphics
    1. Combinational patterns
    2. Stateful pattern generators
    3. Animation
    4. Coordinate transformations
    5. Animation, differently
    6. High-level simulation with SDL2
    7. Summary
  10. Project: Pong
    1. What is Pong?
    2. Top-level design
    3. What is our state?
    4. Drawing
    5. Summary
  11. Asynchronous Serial Communication
    1. Synchronicity
    2. Universal Asynchronous Serial Communication
    3. Serial Transmitter
    4. Serial Receiver
    5. Applications
    6. Summary
  12. Programmable Machines
    1. RAM machines
    2. Memory
    3. CPU
    4. Summary
  13. Brainfuck
    1. Why Brainfuck
    2. Brainfuck as a programming language
    3. Brainfuck as byte code
    4. Brainfuck with external memory
    5. A complete Brainfuck computer
    6. Brainfuck as machine code
    7. High-level simulation of the CPU
    8. The logic board
    9. Low-level simulation of the logic board
    10. Top-level circuit and peripherals
    11. Summary
  14. CHIP-8
    1. History
    2. The CHIP-8 computer
    3. Instruction set
    4. Video
    5. CPU
    6. Simulation, take 1
    7. The complete machine
    8. Simulation, take 2
    9. Memory contention
    10. Summary
  15. Address decoding and memory maps
    1. Room for improvement
    2. A whirlwind intro to Template Haskell
    3. A memory map DSL
    4. Backpane connections
    5. Access contention
    6. Summary
  16. Intel 8080
    1. History
    2. Veracity
    3. Interface
    4. Instruction set architecture
    5. Instruction decoding
    6. Microcoded implementation
    7. Micro-architecture & micro-instructions
    8. A direct software implementation
    9. The complete CPU
    10. Summary
  17. Project: Tiny BASIC
    1. What is Tiny BASIC?
    2. Asynchronous Communications Interface Adapter
    3. The core logic board
    4. Version 1: serial I/O
    5. PS/2 keyboard interface
    6. Textual video
    7. Screen editing
    8. Version 2: Keyboard and video
    9. Summary
  18. Space Invaders
    1. The design of Space Invaders
    2. How it fits together
    3. Peripherals
    4. Video
    5. Logic board
    6. Simulation
    7. Summary
  19. Compucolor II
    1. Design
    2. A Minimal Viable Compucolor II
    3. Detailed rendering with SDL
    4. Video hardware
    5. TMS 5501
    6. Keyboard
    7. Floppy drive
    8. Cycle-count accuracy
    9. Slowing down the CPU
    10. Our complete computer
    11. Summary
  20. Parting words