S/O/S SyMon III --- 6502/65c02 BIOS with monitor and assembler
SyMon's history


SyMon's history | Magnum images | QUILboard images | Roboboard images | Breadboard images | Microboro images | Breadbox images | Multi-I/O card image | EPROM burner card images | Card cage images | SBC Trainer images | send me email | Instructions | Download source file, object file, user guide, quick reference | Credits/KUDOS

The 6502 projects: a brief history

NEWS: New enhanced version (SyMon III) released 5/20/07.
Cleaned-up, new functions added and fully commentated!

From mini to magnum:

My first computer was a Rockwell AIM 65.
A friend "loaned" it to me in 1985.
I still have it, and we're still friends...

It got me started, but I didn't do much
with it because I purchased a used ATARI
130XE from a co-worker about a year or so
later. It was while using the ATARI that I
first became interested in developing my own
system. While it was easy to write nifty
(and colorful) applications for the ATARI,
I became frustrated with the fact that I
had no way of programming an EPROM.

In other words: that was wonderful, but I
wanted to build and program my own 6502

Enter the APPLE ][...
Someone had suggested to me that there
was an EPROM burner available for the
APPLE ][. I got a scrapped(!) APPLE from
my employer, then found an EPROM burner
card at a swap meet.

The first board I built had 4k static RAM,
8k EPROM, PIA (MC6821), 6 digit LED
hexadecimal display (TIL311), 24 key
(4 x 6) cross-point keypad. It was
built enitrely with recycled components
from retired test tools, dud computer
boards and a programmable doorbell...

I used the APPLE ][ and a symbolic
assembler utility (can't recall which)
to write a small monitor program for my
board. It was at this point that two of
my co-workers expressed interest in the
project. That REALLY got me fired-up:
I had BETA TESTERS! Each started his own
board from my drawings. New code revisions
were issued to them almost daily, sometimes
causing them frustration because I kept
"changing stuff". Nonetheless, they both
continued to provide crucial feedback.

I soon became bored with that board; besides
the keypad and display, it had only a few
bits of uncommitted I/O. This was adequate
for code writing practice and minor I/O
interface technique development, but was
obviously somewhat limited. And cumbersome.

What was needed was a serial port. That way,
textual aspects could then be included, and I
could do away with the keypad and LED display.

The original serial port used a MC6850 ACIA,
coupled with a CMOS BAUD rate generator. The
BAUD rate was jumper-selected.

Here began S/O/S. I needed a cool log-on
message which required that I give the program
a 'catchy' name: System Operating Software,
or "SOS". You may have guessed that little time
was lost in that decision. (The "slashes"
were later added after the speech processor
pair was installed: Upon startup, the system
would speak "SOS" as "sauce". The slashes
forced it to speak: "ESS OH ESS")

The monitor program was totally rewritten
to accomodate a dumb terminal. This was the
genesis of SyMon. The original monitor was
similar in structure to those typical of
the SBC variety: input numeric data followed
by a function command. I found that method
somewhat limiting while adding enhanced
function commands to the monitor, so I decided
to reverse the input sequence: command first,
numeric parameters second (similar to the
Rockwell AIM 65 monitor's method).

Once again, I got bored...
There was no room left on the board to add any
more memory nor I/O...time to build another,
bigger board.

By that time I had salvaged a number of IC
components from scrap, and had purchased a
few new, nifty I/O chips. I also bought the
largest piece of perf-board I could afford.

The hardware "core" of board #2 was similar
to board #1 except that it used a Rockwell
(R6551) ACIA for the serial port. Also,
Tri-state buffers were added between the
core and the extra I/O, memory busses (to
allow DMA). Peripheral I/O devices were
added, coded, tested, debugged one at a time.

On a whim, I decided to have a try writing my
own assembler application. I was tired of
having to fire-up the APPLE ][ every time I
wanted to bang out some new code. Thus was
born S/O/S Sub-assembler. That turned out to
be both a blessing and a curse: while it
allowed me to quickly write and debug my
applications, it provided little means of
adequately documenting program listings.
That all had to be done by hand. That did not
often occur, so I don't have a complete,
commented "source" file. I may yet get around
to creating one for the code presented here,
depending upon other's interest and me finding
the time to do so.

***UPDATE: Regenerated source file
(fully commentated) is available for
download. Click "Download Source file,
object file,user guide,quick reference"
link at top of page. (05/12/07)***

Around 1989 I added a floppy disk drive.
I used an early IBM style hardware interface
(MFM, double-sided, 640k total). I found that
I could connect and use a 3.5" drive, so that's
what ended-up installed in the system. Writing
the code for it was relatively easy. It can
format disks, save and load data but there is
no "file system" nor directory/catalog structure:
data are transferred according to entered numeric
parameters (starting address,length,starting
sector). Later I added code that allowed disk
"bootstrapping" upon power-up or reset. I had
intended to write my own "DOS" but got
side-tracked by a new idea...

It occurred to me that S/O/S would be a
complete, stand-alone microcomputer if I
added a full ASCII keyboard and an 80 column
video display. Besides that, my ADM-5 dumb
terminal was well worn and beginning to have
some problems. I salvaged a keyboard from a
scrapped terminal and aquired an old IBM
monochrome TTL video monitor. These were
built into a gutted word processor console
along with my board, power supply, floppy drive,
power entry module and a muffin fan.

The keyboard interface was very easy to build
and code. The video display hardware interface
and driver were another matter: it nearly killed
the "stand-alone" idea. It was, at the time, the
most difficult design I had ever attempted. Both
the hardware and software gave me nightmares.
I mean nightmares literally.

Originally, the 6502 ran at 2 MHz (16MHz/8 - the
floppy drive uses a 16MHz clock). The video
interface required major changes to the system
clock structure. Access to the video RAM/ROM
is interleaved between the 6502 and the 6545-1
(CRT controller) so they had to be properly
synchronized. In addition, other video related
clock signals were required. That put the 6502
clock frequency at 1.777778 MHz (16MHz/9) and
meant that the MPU clock would not be square
(50% duty cycle). The divider is a 9-bit shift
register loaded (upon reset) with the pattern:
000011111. The serial data out is connected
to the serial in, so the pattern constantly
circulates through the S/R. System clock
signals are taken from S/R parallel outputs.

Once the keyboard and video were completed,
one of the "beta testers" added those same
devices to his own system. His board layout was
quite different than mine, so I was worried that
there might be some marginal timing issues with
the video circuit that were sensitive to layout.
I needn't have worried; his worked perfectly, too.

The S/O/S SyMon host system was complete.
My focus could finally shift to applications...

From magnum back to mini:

Circa 1990:
I wanted to fiddle with all those nifty I/O chips I'd
been salvaging and stashing, so I constructed a
"card cage". It is a 7-slot edge-connector circuit
board frame. It connects to the main board via a
50-pin IDC ribbon cable, and carries buffered
address, data, control and chip select signals.
Power is supplied through a separate cable.

The first card I built was a multi-I/O board.
It has the following:

16 channel 8-bit A to D(ADC0816CCN),
8-bit D to A(AD558JD),
24-bit parallel I/O(P8255A-5),
Multi Counter/Timer(AM9513DC),
5-digit LED hex display(TIL311),
MPU wait-state generator,
Piezoelectric horn,
Connector for Hitachi style LCD modules.

The second (and last) card I built was an EPROM
programmer. It can program the 27xxx series
from 2732 to 27513 EPROMs as well as some
NVRAM devices. It uses a high-speed dynamic
programming algorithym, similar to intel's.

It was around that time I began to build some
smaller, scaled-down boards. These usually had
minimal I/O and had specific purposes:
microwave oven controller, robot motor
controller, product lifetest cycling tools, etc.
(I may be the only owner of a microwave oven
that has an RS-232 serial port...)
They all used the same basic hardware, memory
and I/O map, and all used a modified version of
S/O/S SyMon.

By 1992, my interest in things 6502 began to
wane a bit. I had some catching-up to do in other
hobby projects, and spent alot of time playing
with IBM PC-based stuff: CAD programs, games,
word processors, spreadsheets, MIDI, etc.
And then "the internet" got my attention...

Forward to 2004. I was asked to construct a tool
that would "lifetest" a motorized component of
a robotic medical diagnostic instrument. While
there were many options available, it seemed
the most quick-and-dirty option would be to use
a 65c02 board I had previously built for a similar

One day, I noticed a co-worker and fellow
meteorology buff had some interesting Info.
posted on his whiteboard. It had to do with
the National Weather Service (NWS) Specific
Area Message Encoding (SAME) protocol.

click here for NWS/EAS SAME description

He was working on a method of testing the
SAME function of NWS radio receivers that are
currently available. The method used at the
time was to record, on tape or digitally,
an actual EAS/NWS broadcast then play it back
to the receiver under test. This worked for
demonstration purposes but it was not quite
adequate for thorough testing.

6502 to the rescue!

It seemed like a good application for the
6502 MPU. I suggested that we collaborate
to construct a device that could encode and
decode the EAS messages. While he got busy
building his own SyMon 6502 boards, I got
busy designing a suitable modem and
encode/decode software for this project.

To date: I have a working breadboard modem
and EnDec code. Currently I am in the
process of building two complete system
prototype boards.

***EAS modem/EnDec UPDATE*** (11/21/06) :
Completed two identical prototypes.
(no images yet) Both sport salvaged vacuum
fluorescent displays and thermal printers...

During this most recent endeaver, however,
I've also been checking out some stuff that
other folks have created:

Mr. Lee Davison's Enhanced BASIC:
This was the first major application run on
any of my SBC's that I didn't write. It has
been awhile since I wrote a BASIC program,
so it took a bit of time to get re-oriented.
It's obvious to me that Mr. Davison has put
much time and effort into the development
KUDOS to Mr. Davison for a job well done.

click here to visit Lee Davison's site

Mr. Daryl Rictor's 6502 monitor utility:
Mr Rictor has made available a nifty code
package that couples his 6502 monitor utility
with EhBASIC. Porting Mr. Rictor's monitor
into my SBC was very quick and easy, and I've
enjoyed the exploration of his work.
KUDOS to Mr. Rictor for a job well done.

click here to visit Daryl Rictor's site

In the unlikely event that you are reading
this and didn't arrive here via the
6502.org homepage, I highly recommend that
you take a look at the link below...

click here to visit 6502.org


buy levitra