Overview
  The Nomad board is a 68000/68010 compatible microcomputer with 128K of SRAM and 128K of EEPROM memory, with the EEPROM being in a convenient PLCC socket for repeated removal.  The Nomad board includes a MK68901 peripheral chip to enable microcontroller-like functionality, including 4 timers, a buffered 115200 baud 8N1 UART interface, and an 8-bit I/O port, all with processor interrupt capabilities.  The board can be clocked anywhere from 8MHz (the minimum speed of the processor) to somewhere around 14MHz (max speed of the MK peripheral)

  The bootloader is currently not capable of self-updating, although this will be available in the future.  Due to the 68000 architecture, this means that the interrupt vector table is not modifiable without re-flashing the bootloader.  This can also be fixed by using a 68010, which can move the vector table into RAM if modification is required.

  On the software side, a couple programs have been developed in order to speed assembly development:

• The makefile itself, which assembles source code using binutils.  Note that there is a makefile for compiling C and C++ programs, but support for this is incomplete.
• eeprom_interface, an Arduino program that takes in commands and data over the serial port and flashes the EEPROM chip connected with the appropriate data.  This program can also verify the EEPROM identification information and read code from the EEPROM into a binary on the host computer for later use.
• split, a tool that splits the final binary into and even and odd binaries, suitable for upload onto the two EEPROM chips in the Nomad board
• eeprom_config, a host tool that interfaces with the Arduino program listed above, allowing the user to specify only an action, a binary, and the Arduino's location and have the code be automatically uploaded to the EEPROM chip connected.
• flash, a (broken) bash script that tries to automate the whole thing
• upload, a Python program that interfaces with the Nomad bootloader directly.  Script is likely to change as the bootloader gets written.

Design goals
    1. Fast.  Or at least as fast as the hardware will reliably support.
    2. Simple.  Easy to program for, but still capable of doing something interesting.
    3. Extensible.  The board should contain enough to do something fun out of the box, but not enough that it hinders future expansion.

    4. Compact.  I really don't like massive 2-layer boards, so this board is compact.

Bugs (version 1.0) (no, I didn't breadboard this beforehand)

1. RX buffering is backwards
2. All of the TX and RX signals are inverted
3. RC values for reset are wrong
4. 10uF caps have the wrong footprint
5. Mounting holes were too small for decent-size standoffs
6. The byte select signals for the SRAM and EEPROM are inverted, which was a pain to figure out because the 68000 still fetches instructions on word boundaries, so writing words or anything encoded in an instruction literal still worked.
7. I think the 7805 is getting extra hot because I ran out of 0.1uF caps and had to use 0.33uF ones?

Known Issues

1. Some of the silkscreens for the expansion IO connector are off a little
2. Software Data Protection on the EEPROMs needs to be turned off for
   self-update functionality to work, but that isn't a huge concern and writing to EEPROM pairs with SDP enabled is extremely difficult to do with the current architecture.
3. MFP DTACK signal is grounded all the time, but MFP still accepts reads
   and writes.  Doesn't cause any issues, but out of spec with the datasheet

Things that worked

1. CPU executed code in a loop, RAM word access works well
2. MFP can echo incoming strings over UART, and manipulate I/O ports
3. Bootloader almost definitely works, but I haven't tested it yet.

Measurements

• Board draws ~270mA when executing instructions, and ~230mA when in reset, but these values might be wrong because of the above bug with...