Project Details

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 the power supply circuitry.
• At 14MHz (highest clock frequency available that allows for the MFP to function), the minimum MFP I/O switch time is 10us (100kHz).  High-speed I/O this is not.

Goals

• Near-term:
  • PCB version 1.1 (bug fixes and minor improvements)
    •  Ideally, I would switch from a 7805 to a more efficient switching regulator of some kind.  No reason to waste power like that if I can avoid it.
    • Lots of signal noise on everything, figure out a way to maybe reduce it a little
  • Blinkenlight daughterboard containing a hex display of the data and address busses, as well as reset and step buttons for debugging
    • This could be hand-soldered, use a CD4026 or something
  • Mounting the board in a plastic enclosure with a battery for portability and coolness
  • Some kind of basic serial monitor program for manipulating contents of memory
    • Maybe a cute little disassembler with a cute little UI as well, would be a great assembly exercise.

• Long-term (in order of difficulty):
  • Data ingestion with a dedicated FIFO chip
    • Could turn this into an oscilloscope or something
  • Sound output
    • Goal is to get tones out of a decently amplified speaker from the MFP
    • Waveform generation from the MFP is possible, but limited to square waves.  Using multiple timer outputs with external hardware would allow for duty cycle adjustment - but there might be a better way to do this.
  • SPI/I2C drivers
    • Could start by bit-banging this over the MFP I/O ports, software-only but slow
    • Eventually use a 74HCT595 for SPI interfacing, which is probably faster
    • Maybe use the FIFO chip listed above... not sure
  • SD card support
    • Loading programs / storing data in a readable format would be helpful for below projects, most notably storing samples for the sound idea below
  • Useful networking using an ESP32 over UART
    • Ideally all the hard stuff would be on the ESP32, not sure where this would go
  • 2D graphics
    • This has to be hardware-accelerated in some way, bit-banging this is going to get slow real fast if I interface to anything bigger than a SSD1306 display
  • Quality sound output
    • Multiple hardware voices
    • Waveform generation
    • Fancy ADSR stuff
  • Forth interpreter
    • Have a little experience with this, but it might take a while
    • Would be really helpful for rapid software prototyping and really not very expensive
  • 3D graphics using an FPGA accelerator card
    • This is probably going to be the hardest project, and the least likely to be completed.

• Shelved:
  • BASIC interpreter - not interested in this since I don't like BASIC and I'm not running any kind of legacy software
  • Multi-tasking operating system - really hard to do well and other projects have great existing solutions already