Category Archives: Retro Computing

Interfacing assembly with BASIC via DEFUSR, part 1

See also: part 1, part 2, part 3, part 4, part 5, part 6, part 7 and part 8.

This article series will demonstrate how to interface some 6809 assembly code with Microsoft BASIC on a Tandy/Radio Shack TRS-80 Color Computer.

BASIC on the Color Computer is easy, but not fast. 6809 assembly language is fast, but not easy. Fortunately, it’s easy (and fast?) to combine them, allowing you to write a BASIC program that makes use of some assembly language to speed things up.

Assembly code can be loaded (or POKEd) in to memory at a specific address and then invoked by the EXEC command. This is fine for a “go do this” type of routine. But, if you want the assembly code to interact with BASIC by returning values or modifying a variable or string, you can use a special BASIC command designed for this purpose.

The Color Computer’s original 1980 COLOR BASIC had a USR command which could be used to call an assembly language routine via a BASIC interface. From the Wikipedia entry:

USR(num) calls a machine language subroutine whose address is stored in memory locations 275 and 276. num is passed to the routine, and a return value is assigned when the routine is done

This allowed passing a numeric parameter in to the assembly routine, and getting back a status value.

When EXTENDED COLOR BASIC came out, USR was enhanced to allow defining multiple routines. It looks like this:

DEFUSR0=&H3F00
A=USR0(42)

That code would define USR0 to call an assembly routine starting at memory location &H3F00 and pass it the value of 42. That routine could then return a value back to the caller which would end up in the variable A.

There are two ROM routines that enable receiving a value from BASIC, and returning one back:

  1. INTCNV will convert the integer passed in the USRx() call and store it in register D.
  2. GIVABF will take whatever is in register D and return it to the USR0() call.

Here is a very simple assembly routine that would receive a value, add one to it, and return it.

ORGADDR EQU $3f00

GIVABF EQU $B4F4   * 46324
INTCNV EQU $B3ED   * 46061

       org  ORGADDR
start  jsr  INTCNV * get passed in value in D
       tfr  d,x    * transfer D to X so we can manipulate it
       leax 1,x    * add 1 to X
       tfr  x,d    * transfer X back to D
return jmp  GIVABF * return to caller

Using the lwtools 6809 cross compiler, I can compile it in to a .BIN file that is loadable in DISK BASIC:

lwasm --decb -o addone.bin addone.asm

I could then use the toolshed decb command to copy the binary to a .DSK image to run in an amulator such as Xroar. In my case, I have an image called DRIVE0.DSK I want to copy it to:

decb copy -2 -r addone.bin ../Xroar/dsk/DRIVE0.DSK,ADDONE.BIN

Now I can run the Xroar emulator and mount this disk image and test it:

Using DEFUSR to call assembly from BASIC.

It works! Of course, I could have just done…

A=A+1

…so maybe this isn’t the best use of assembly language. ;-)

Up next … a look at doing something actually useful.

Building KenTon/LR-Tech SCSI drivers for NitrOS-9

While the NitrOS-9 project does contain drivers for the KenTon and LR-Tech hard drive interfaces, they are not built or included by default. I wanted to document the steps I took to build and use the KenTon interface under the current NitrOS-9.

Basically, you will be modifying a few makefiles to enable the building of the low level booter, device drivers and device descriptors. If I recall, the changes are the same for each of these makefiles, but you only need to make them for the one you are using. If you are only using the KenTon drivers under NitrOS-9 Level 2 on a CoCo 3, just do that makefile.

  • nitros9/level1/coco1/modules/makefile
  • nitros9/level2/coco3/modules/makefile
  • nitros9/level3/coco3/modules/makefile

Step 1 – Add “KTLRFLAGS”.

These generate the define used inside the generic SCSI source code so it knows which code to build.

TC3FLAGS = $(AFLAGS) -DTC3=1 $(FLAGS)
KTLRFLAGS = $(AFLAGS) -DKTLR=1 $(FLAGS)
IDEFLAGS = $(AFLAGS) -DIDE=1 $(FLAGS)

Step 2 – Add “boot_ktlr” to the BOOTER list.

This makes it a dependency so make will look for it and try to build it. I added it in the middle of the list so when you get updates, it will be easier for the “diff” tool to see what has changed.

BOOTERS = boot_1773_6ms boot_1773_30ms \
 boot_burke boot_rampak boot_wd1002 boot_dw \
 boot_tc3 boot_ide boot_rom boot_dw_becker \
 boot_ktlr \
 boot_dw_arduino boot_dw_38400 boot_sdc

Step 3 – Add the modules to the RBF list.

RBF = rbf.mn \
 rbdw.dr dwio.sb dwio_38400.sb dwio_becker.sb dwio_arduino.sb \
 rb1773.dr rb1773_scii_ff74.dr rb1773_scii_ff58.dr \
 ddd0_35s.dd d0_35s.dd d1_35s.dd d2_35s.dd d3_35s.dd \
 ddd0_40d.dd d0_40d.dd d1_40d.dd d2_40d.dd \
 ddd0_80d.dd d0_80d.dd d1_80d.dd d2_80d.dd \
 ddx0.dd x0.dd x1.dd x2.dd x3.dd \
 rbsuper.dr lltc3.dr llide.dr llcocosdc.dr \
 llktlr.dr \
 dds0_ktlr.dd s0_ktlr.dd s1_ktlr.dd s2_ktlr.dd s3_ktlr.dd s4_ktlr.dd \
     s5_ktlr.dd s6_ktlr.dd sh_ktlr.dd \
 ddi0_ide.dd i0_ide.dd i1_ide.dd ih_ide.dd \
 dds0_tc3.dd s0_tc3.dd s1_tc3.dd s2_tc3.dd s3_tc3.dd s4_tc3.dd \
     s5_tc3.dd s6_tc3.dd sh_tc3.dd \
 ddsd0_cocosdc.dd sd0_cocosdc.dd sd1_cocosdc.dd

Step 4 – Add the dependency to build the driver:

# TC^3 SCSI Booter
boot_tc3: boot_scsi.asm
 $(AS) $(ASOUT)$@ $< $(TC3FLAGS)

# KenTon/LR-Tech SCSI Booter
boot_ktlr: boot_scsi.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS)
 
# SuperIDE/Glenside IDE Booter
boot_ide: boot_ide.asm
 $(AS) $(ASOUT)$@ $< $(IDEFLAGS)

Step 5 – Add the dependencies for building each descriptor. I put mine after the existing TC3 SCSI driver stuff:

sh_tc3.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(TC3FLAGS) $(HDBDOS)

# KenTon/LR-Tech SCSI Descriptors
dds0_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID0) -DDD=1

s0_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID0) $(SCSI_HD)

s1_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID1) $(SCSI_HD)

s2_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID2) $(SCSI_HD)

s3_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID3) $(SCSI_HD)

s4_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID4) $(SCSI_HD)

s5_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID5) $(SCSI_HD)

s6_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(ID6) $(SCSI_HD)

sh_ktlr.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(KTLRFLAGS) $(HDBDOS)

# IDE Descriptors
ddi0_ide.dd: superdesc.asm
 $(AS) $(ASOUT)$@ $< $(IDEFLAGS) $(MASTER) -DDD=1

Now those modules should be built and made available for including in your bootfile. You could do this by editing the bootlist you are using:

  • nitros9/level1/coco1/bootlists/standard.bl
  • nitros9/level2/coco3/bootlists/standard.bl
  • nitros9/level3/coco3/bootlists/standardL3.bl

Or you could use a bootfile editor like ezgen to add them to your current bootfile. Or, if you were just doing something temporary (like I was, to pull data from hard drives), you could just merge the needed modules together and dynamically load them when you need to use the SCSI drive.

Hopefully this will be helpful to someone else.

CoCoSDC SDC-DOS version 1.14 release

In case you missed it, in December 2016, a software update to CoCoSDC and SDC-DOS was released. You can find it under “Latest Firmware” on this page:

http://cocosdc.blogspot.com/

SDC-DOS is now up to version 1.14 and includes the following changes:

  1. AUTOEXEC. If “AUTOEXEC.BAS” if found on a mounted disk image, it will automatically run on startup. Holding down SPACE on startup will bypass this. (I think Kenton’s RGB-DOS did this?)
  2. EXP. A new “EXP” command has been added. It will mount an image called “SDCEXP.DSK” and, if present, run “AUTOEXEC.BAS” from that image.
  3. DEF DW. You can now specify DriveWire baud rates.
  4. WRITE/COPY MEM. These commands can now write to flash pages $FExx on a CoCo 3.
  5. RUN @bank. Code to select and execute one of the virtual ROM banks has been rewritten to make it more compatible with various ROMs.
  6. DSKINI. Fixes a bug where drive motor could remain on when using a CoCoSDC and a real floppy controller at the same time.

The update comes with a .DSK image that you mount and then run a utility which will take care of the upgrade.

Nice! I just started setting my CoCo system back up, and will be trying this out soon.

Commodore Amiga documentary

I just found this Commodore Amiga documentary on HULU and watched it last night. You can find more information on the official website:

https://amigafilm.com

For those too young to remember, the Amiga was the most advanced home computer ever sold. It was incredibly ahead of its time, especially compared to any of the competing systems that were sold when it was released in 1985.

Us old timers recall the early days of home computer with systems like the Apple 2, Commodore PET, Atari 400/800, and TRS-80. There were many other systems, like the Timex Sinclair ZX81, Texas Instruments TI99, VIC-20 and then the massively popular Commodore 64 (and later less successful 128). Thanks to the internet, I have learned about dozens of other competing systems that I never even heard of back then.

The next generation of computers were things like the 1984 Apple Macintosh and the Atari ST. The Commodore Amiga blew everything out of the water. It had multitasking and amazing color graphics (back when a PC produced only 4 awful colors on a “high resolution” screen). It had 4-channel STEREO digital sound. It was just amazing.

I recall seeing an Atari ST in a shop in Houston, and really wanting one, but it was just too expensive. Sure, my CoCo setup ended up costing way more as I added more and more components, but I could do all of that gradually. The entry level cost of an Atari ST (or Amiga) and the required monitor was simply out of my price range.

But I had Commodore 64 friends that moved on to the Amiga, and I remember getting to see one of the first time (probably in late 1987). The bouncing ball demo brought tears to my eye. I had simply never seen anything like that on a home computer screen.

This documentary gives some of the background of the creation of the Amiga, and how it ended up at Commodore (and almost ended up at Atari).

It’s a fascinating look at what was truly an amazing piece of hardware.

The movie is streaming on HULU if you have a subscription, and can be rented or bought on many other services. I recommend it, though I wish it were about 10-15 minutes longer so it could give a more complete timeline of the various models that came out and why they were created (especially things like the CDTV and CD32).

Enjoy…

Creating a RaspberryPi DriveWire server

  • 2016/05/12  This is a work-in-progress article I originally wrote on February 8, 2015, but never completed. The other night I was trying to look up my notes to help Curtis B. with a NitrOS-9 boot disk and I realized I never completed this. I will try to finish it when I have a moment.

Summary

To get DriveWire 4 server running on a Raspberry Pi, you will do the following:

  1. Download the DriveWire server to the Pi and unzip it:
    wget http://sites.google.com/site/drivewire4/download/DriveWire4_4.3.3.zip
    unzip DriveWire4_4.3.3.zip
    cd DriveWire4_4.3.3.zip
  2. Edit the config.xml file to default to your serial port on your Pi in <deviceType> and <serialDevice>. (i.e., “serial” and “/dev/ttyUSB0“)
  3. Run the server with no user interface:
    java -jar DW4UI.jar -noui
  4. On the CoCo, load the needed DriveWire modules from NITROS9/6x08L2/MODULES/RBF:
    dwio.sb, rbdw.dr, x0.dd up to x3.dd
  5. Use the “dw” command to test things by creating a blank disk image:
    dw disk create 0 /home/pi/test.dsk
    format /x0
    dir /x0
  6. Customize your boot disk to include the modules you want and read the documentation to learn how to use all the cool virtual terminals, MIDI and other neat features.

And now, the long version…

Materials Needed

  1. Raspberry Pi B (or B+, or probably the Pi 2 B). I did all these steps on a B.
  2. USB keyboard (a mouse makes things easier, but I do not have one so all of these tips will just use a Pi, keyboard and HDMI TV/monitor).
  3. Compatible* 8GB SD card (or larger).
  4. Ethernet cable to hook the Pi to the Internet. (Required if you plan to do the network install of NOOBS LITE).
  5. WiFi (with a supported USB dongle) or Ethernet is needed later for downloading the DriveWire software and updates, but there are ways to do all of this without any Internet access if you start with the full NOOBs installer.
  6. Compatible* USB serial adapter (or TTL->RS232 converter for use with the built in UART pins of the Pi).

Preparation on Windows/Mac/Linux

  1. Download the “NOOBS” installation for Raspberry Pi (currently 1.3.12). You can get the full NOOBS (780MB, just unzip and copy to the SD card and boot), or the NOOBS LITE (22.8MB) version.
    • NOOBS LITE can also be used. It is a much smaller download, but requires the Pi to be hooked up to the internet via Ethernet to download the rest of the OS files which is about 2355MB.
      http://www.raspberrypi.org/downloads/
  2. Unzip the files, then copy them over to a freshly formatted SD card.

Preparation on the Raspberry Pi

  1. Boot the Pi using this card. You will see a menu of operating systems you can install. Choose “Raspbian [RECOMMENDED]” at the top by using the arrow keys and SPACE to select. You may also wish to hit “l” for Language and set it to “English (US)” or your preference, and “9” for Keyboard and select yours. Once Raspbian is selected, press “I” for install. It will ask if you are sure you wish to overwrite the SD card. Select “Y” for yes.
    • NOOBS LITE: The Pi will then download the Raspbian image (2.3GB), then install.
    • NOOBS: The Pi will then install.
  2. The Pi will (eventually) reboot and after a bit, you get a DOS-like screen for the raspi-config utility. Arrow over to Finish and press ENTER. You will not be at the Pi shell prompt.
    pi@raspberrypi ~ $
  3. At this point, I like to do a full reboot to make sure everything is working properly:
    sudo reboot
  4. On a reboot, you won’t go directly to a shell prompt. You will get a login prompt. The default account is:
    username: pi
    password: rasbperry.
    Log in and you will get back to the shell prompt. You will be in the home directory for user “pi”.
  5. Now we need to download the DriveWire 4 software. Note the filename will change when DriveWire is updated, so check the official site if this does not work.
    wget http://sites.google.com/site/drivewire4/download/DriveWire4_4.3.3.zip
  6. After the zip file is download, you can extract it by typing:
    unzip DriveWire4_4.3.3.zip
  7. DriveWire 4 is set up to run with a nice GUI with mouse control. This requires a keyboard and mouse, and the Pi to be set up with X-Windows running. Since I do not have a mouse, and plan to run the Pi headless with nothing hooked up to it but power and the CoCo, this is not an option for me. Instead, I need to manually edit the configuration file to tell it what Linux serial port I will be using.
    cd DriveWire4_4.3.3
    copy config.xml config.xml.org (always keep a backup!)
    pico config.xml

    The editor will open, and you want to look for a few entries:<instance category=”instance” desc=”Autocreated 2013-03-24 23:57:53.831″ name=”TCP connection via TCP“>

    <DeviceType category=”device” list=”serial,tcp-server,tcp-client,dummy” type=”list”>tcp-server</DeviceType>

    <SerialDevice category=”device” type=”serialdev”>COM14</SerialDevice>The first entry is just the name of the connection. You could change that to “Serial Connection” or whatever. The second “tcp-“server” should be changed to “serial”, and the “COM14” entry should be changed to your serial port device. On my Pi, when I plug in a single USB RS232 adapter, it shows up as /dev/ttyUSB0 so that is what I use.
  8. Save your changes back to the file (Ctrl-X, Y) and now you are ready to run the server without a user interface. (Getting the user interface to run requires installed two more additional packages, and I will make a tutorial for that soon, if anyone wants me to.)
    java -jar DW4UI.jar -noui
  9. After a bit, Java will load and the DriveWire 4 server will start. Java is big, and the Pi is small, so it can be quite sluggish. Now, with the USB cable connected between the Pi and the CoCo, you can start testing.

Preparation on NitrOS-9

This tutorial is being written for someone who already has an active NitrOS-9 system and wants to add DriveWire support to it. If you have no customized

If you are using one of the default NitrOS-9 disk images for you system, it should have a NITROS9 directory, and inside of it will be various device drivers and descriptors, including the ones used by DriveWire. Ultimately, you would want to make a custom boot disk that includes these modules, but here is a simple way to merge them together and just load them when you want to use them. From OS-9:

  1. If you are running a stock CoCo 3 with the standard 6809 processor, go here:
    cd /dd/NITROS9/6809L2/MODULES

    …and if you have upgraded your CPU with a Hitachi 6309, go here:
    cd /dd/NITROS9/6309L2/MODULES
  2. The modules you want depend on what you plan to do. Here is the list:
    • drio.sb – this module handles all communication with the DriveWire server.
    • rbdw.dr – RBF device driver that uses DriveWire for disk access instead of disk hardware
      • ddx0.dd, x0.dd, x1.dd, x2.dd, x3.dd – device descriptors for the DriveWire disk drives (/x0 to /x3, with ddx0.dd being a /dd descriptor for DriveWire).
    • scdwp.dr – printer driver
      • p_scdwp.dd – device descriptor /p for scdwp.dr
    • scdwv.dr – virtual serial port driver
      • n_scdwv.dd, n1_scdwv.dd to n13_scdwv.dd – serial port descriptors. /n is the “next available” descriptor, similar to /w for windows. /n devices may also be used for MIDI.
      • midi_scdwv.dd – this is n14 but named /midi for MIDI programs that are hard coded to look for that name.
      • term_z_scdwv.dt, z1_scdwv.dd to z7_scdwv.dd – (??? not in the doc wiki)
  3. For my example, I am only concerned about the disk drives, so I would merge the following modules together:
    chd RBF
    merge dwio.sb rbdw.dr x0.dd x1.dd x2.dd x3.dd >/dd/dw
    This gives me a single file called “dw” I can load to get DW support instantly. First, I need to set the attributes to allow that:
    attr /dd/dw e
    …then I can just load it when I want to use DriveWire:
    load /dd/dw
  4. If this worked, you should now be able to use the DriveWire command, “dw”, to communicate with the server. Type “dw” and it should report back a list of commands:
    config  disk  log  midi  net  port  server
    …and you can then type “dw config” or “dw disk” to see what all it can do.

Using DriveWire

Here is an example of creating an empty disk image and formatting it:

dw create 0 /home/pi/test.dsk
format /x0
dir /x0

If you look on the Pi, you will see a new file “test.dsk” there. You can now use this disk like any other OS-9 disk. In my test, I copied my NITROS9 directory over to it just for fun:

chd /dd/NITROS9
dsave /x0 ! shell

DriveWire’s performance is not as good as you’d get from a No Halt floppy controller like the Disto Super Controller 2 or a hard drive interface like the Cloud-9 SuperIDE or KenTon SCSI. As disk activity is going on, interrupts are masked while data is blasted out of the bitbanger port. Still, it did a remarkable job keeping up with my typing. Quite impressive for a cheap cable and a $35 computer with a serial port.

TO DO

  1. Make the DriveWire 4 server auto-start.
  2. Update the DriveWire 4 software from the command line (is this even possible?).
  3. Update the Raspberry Pi software.

Problems

One issue I immediately ran in to was a bunch of ERROR #207 (Memory Full) errors. mfree still showed 352K free, and it wasn’t the #237 (RAM Full) that happens when there isn’t enough room left in the main 64K memory map.

Building NitrOS-9 on Mac OS X

Updates:

  • 6-22-2022 – I wrote up the steps on building LWTOOLS under Windows using Cygwin. I found it very simple. But, I was not able to get Toolshed building under Cygwin.
  • 12-7-2022 – A few updates about ‘hg’ on Mac.
  • 2-20-2025 – Updated location of NitrOS9 project, and changing instructions to use “git” instead of Mercurial for that step.

Since I have to relearn all the steps, I thought I would post them as I go through them. The NitrOS-9 website has a tutorial on building it, but here are my steps with some specifically for Mac OS X:

Install the Command Line Tools for Mac OS X.

We need the command line versions of the Mac OS X compiler so we can build the tools that are then used to build NitrOS-9. If you have XCODE installed, you may already have them. An easy way to do this is from aย Terminal prompt:

xcode-select --install

That will launch the Apple Mac App Store installer and get the tools for you. Cool.

Installing the Mac OS X command line tools.
Installing the Mac OS X command line tools.
Screenshot 2016-05-01 17.26.21

Download Mercurial.

The NitrOS-9 repository now uses git as version control. You will need to download a git client, or use the GitHub Desktop app. I just learned about this change today (Feb 2025) so I need to update these steps.

Toolshed and LWTools use Mercurial, so you will need to download that as well. On macOS, you should be able to install it using “brew install mercurial”:

brew install mercurial

Download LWTools.

These are the cross-compiler tools used to build 6809 source code from Mac/Windows/Linux systems. From a Terminal prompt, find a directory you want to download the lwtools to. I chose a poor location — “CoCo” inside my Downloads folder:

pwd
/Users/allenh/Downloads/CoCo

From this directory, use the “hg” command to obtain and build the tools. It will build the directory you specify from the command line (“lwtools”):

hg clone http://lwtools.projects.l-w.ca/hg/ lwtools
cd lwtools
make
sudo make install
cd ..

Build Toolshed.

Next we want to build Toolshed. This is a series of command-line utilities that operate on CoCo/OS-9 disk images (like those used with emulators and the CoCoSDC interface). Once again, I do these steps from my “Downloads/CoCo” directory:

hg clone http://hg.code.sf.net/p/toolshed/code toolshed
cd toolshed
sudo make -C build/unix install
cd ..

(Note: I had to use “sudo make…” here to get it to build on my system.) The different build/make process shows the different styles of the various developers that made these tools. (Note: Mine seems to fail looking for a command “markdown” at the very end. Not sure what this is, but it seems to be building HTML documentation or something.)

Build NitrOS-9.

Now we are ready to download and build NitrOS-9. Once again, I start in my “Downloads/CoCo” directory, and issue the following git commands to download all the NitrOS-9 stuff:

git clone https://github.com/nitros9project/nitros9.git
cd nitros9
make dsk

This will build absolutely everything, including tons of ports and disk images you likely do not want. After this, you will have all the sources, and have built all (or some) of the sample disk images for various types of hardware (CoCo 1/2, CoCo 3, 6809 or 6309, CoCoSDC controller versus floppy or IDE hard drive, etc.).

If you are only interested in a CoCo 3 6809 setup, why build all the CoCo 1/2 and Dragon versions, or any of the 6309 stuff? I always build everything, but you can also specify to build just a specific port. For my CoCo 3/6309 build, I could do this instead:

make dsk PORTS=coco3_6309

For stock 6809 CoCo 3:

make dsk PORTS=coco3

Updating NitrOS-9 and the Tools.

Later, if you want to update your sources, you can use this command from the “nitros9” directory:

git pull
make ask

For updating LWTools and Toolshed, use this:

hg pull
hg update

…then the build steps, shown earlier.

NOTE: David Ladd has pointed out that you may want to clean out old files before rebuilding. For Toolshed, I needed to do this first:

hg pull
hg update
make -C build/unix clean
make -C build/unix

I do this occasionally to get the “latest and greatest.” You can do this for the other tools, too, by changing in to their directory then issuing the “pull” and “update”, then the appropriate make command.

TODO: This next section was from when NitrOS9 was at SourceForge and used Mercurial. I have not had a merge conflict using git yet, so I don’t know what those look like. I will try to update this document later.

If you get a merge conflict because you changed something locally, you might see this:

hg update
abort: outstanding merge conflicts

You can use this command to see what files have been changed on your local repository that conflict with the master files. This happens if, for instance, you tweak a makefile or build list or source code:

hg resolve -l
U 3rdparty/utils/tlindner/sdir.asm

This reminded me that I already Tim’s “sdir” source code (for CoCoSDC) so enable built in help and such. I have to revert those changes if I want to update, or learn how to use the merge too… I forgot!

These steps should get you everything you need to begin playing with NitrOS-9 on a real CoCo with the CoCoSDC interface, or an emulator. If you plan to use real floppies, you can use toolshed utilities to format and then copy disk image .DSK files over to the physical floppy, but I don’t have any way to hook a 360K Floppy drive to my Mac so I have never done this. CoCoSDC is the way to go there.

More to come…

25th annual “Last” Chicago CoCoFEST!

Tandy/Radio Shack TRS-80 Color Computer fans, take note. This weekend (April 23-24, 2016), the Glenside Color Computer Club will be hosting the 25th annual “Last” Chicago CoCoFEST! in Lombard, Illinois (near Chicago).

I attended the first “Last” CoCoFEST! there back in 1992, flying up from Lufkin, Texas with a CoCo friend of mine, Mark. That 1992 event was presented by Dave Myers of CoCoPro, and Glenside was the host club for it. Dave had gotten in to the CoCo convention scene in 1990 when he held his first CoCoFest in Atlanta, Georgia, with the Atlanta Computer Society as the host club there.

These CoCoFests were being started just as the long-running RainbowFests were winding down. Rainbow Magazine was the premier Color Computer publication, starting out as a photocopied newsletter and growing to a 300+ page monthly periodical. Rainbow had years where they held several events across America, but their last event was in Chicago in 1991.

Dave first stepped in to offer an event “down South” in 1990. Rainbow had held only one southern event in Ft. Worth, Texas. When the final RainbowFest was held, Dave decided to continue the tradition with a new event in its place.

Though CoCoPro would exit the convention scene after that 1992 event, the CoCo clubs continued. Atlanta Computer Society kept CoCoFests going there through 1995. The Glenside CoCo Club has continued to host events ever since the original CoCoPro event in 1992 (and they were host club for the RainbowFests before that). But this year is the last one. Again.

Dave chose the “Last” (in quotes) moniker for his first Chicago-area event knowing it could be the final event, and it become the “2nd annual ‘Last'” event the following year when Glenside took over.

Then the 3rd … and 4th … and 5th…

It’s hard to believe that was 25 years ago!

I last got to visit the CoCoFEST! in 2013. I would like to at least day trip to this one. Several long-time CoCo folks from the past are showing up (including our own monk, Brother Jeremy, and our Canadian pal L. Curtis Boyle). I have had several generous offers to provide lodging if I wanted to stay overnight, and even offers to fund my gas. These are some of the people I have called friends longer than just about anyone else I still have in my life.

If you can make it, and I am there, be sure to say hi. If I am not there, be sure to take photos and let me know what I missed.

Find out more: http://glensideccc.com/

Commodore VIC-20: My first computer.

My very first computer was a Commodore VIC-20. At the time, I think I was interested in a new video game system like an Intellivision. My dad suggested that, for about the same money, I could get a computer instead that would do more than just play games. (Second generation game systems like Intellivison or ColecoVision were around $200.)

My desired to get a home computer was also inspired by a guy I met in one of my 7th grade classes. My new friend, Jimmy J., had shared a book on BASIC computer programming with me. We would go down to a local Radio Shack and type in programs on their TRS-80 Model 3s.

My dad began researching options, and I did the same. I ended up choosing something called a VIC-20. I was disappointed when my dad told me he had chosen a different machine – something he called the Commodore. When I realized we were talking about the same machine, it seemed like the perfect choice.

The VIC-20 marketing campaign was “Why buy just a video game?” and “A real computer for the price of a toy.” This may have actually been what got my dad thinking about a home computer in the first place. It was described as “the wonder computer of the 1980s for under $300” and “the first honest-to-goodness full color computer you can buy for only $299.95”, or so claimed launch spokesman William “Captain Kirk” Shatner.

A TV commercial for it parodied the Intellivison and the Atari VCS ads with Shatner “beaming down” between the two saying “move over for my friend VIC”. How could you go wrong with the computer that the Captain of the U.S.S. Enterprise liked?

I received my new VIC-20 sometime in 1982. It was likely for my birthday in August.

I remember hooking it up to a small color TV I had, and staying up all night going through the manual and learning how to program “CBM BASIC V2” which had a whopping 3583 bytes of memory available. Since I had no way to save any programs I typed in, I had to leave the computer on all the time else I would lose all my work. The Commodore Dataset (their expensive and proprietary cassette player)  was about $75 at the time, and that was the first add-on I wanted. I still remember the problems I had with it, and that we had to exchange it at the store a few times (all with the same problem) until we figured out you just couldn’t use it on one side of the TV. There was too much electrical interference apparently.

Custom Programs Limited

My friend Jimmy also got his first computer around this time – a Timex Sinclair. Another friend of ours, whose name I forget, had access to TRS-80s at school. Somehow we got the idea that we could offer to create custom programs for people, and thus the idea of “Custom Programs Limited” was created.

CPU Software - my first "company" in 1982.
CPU Software – my first “company” in 1982.

Jimmy suggested we change it to “Unlimited” so the initials would be C.P.U. At the time, I don’t think I even knew the term “central processing unit.” And thus was born CPU Software.

I remember we came up with an idea for a horse racing game, and each of us created a version of it for our systems: VIC-20, TRS-80 and Timex Sinclair. I do not think we ever did much after that. We probably did not realize how big home computing would become. Had we seriously pursued this venture, maybe we could have all ended up rich and living on a private island somewhere.

I did write a series of games for the VIC-20, including one that was published in a newsletter called the VIC-NIC NEWS. I believe I was in the process of having some of my video games distributed through a cassette magazine called VIXEN (renamed to FOX 20 after their first issue), but I do not recall what happened with that. I know one of the programs they considered (Factory TNT, a graphically updated version of the one VIC-NIC published) they rejected after seeing my first version already published elsewhere.

I have created a special page listing more details about my VIC-20 programs.

Life After VIC

I think I only used the VIC for about a year. I had started frequenting a local Radio Shack store while my grandmother shopped next door. I was learning about their TRS-80 Color Computer. It wasn’t nearly as colorful as the VIC, but it had a better BASIC and much more RAM. I made friends with the workers there and they would let me hang out on Saturdays, writing programs or using their TRS-80 Model III and modem to dial in to local Houston bulletin board systems (BBS). I remember they would sometimes save off programs I wrote to cassette to use to demo the machine to other customers.

The salesman I interacted with most there was a man named Don Burr. He had a CoCo himself, and I remember the time he called me to tell me they had just gotten Extended Color BASIC in. He said I needed to come by and see all the new graphics and sound commands it had. When I did, seeing the ability to easily draw a LINE, CIRCLE or PLAY a musical note was magic. Everything on the VIC was done using POKE commands. (I did have the Super Expander cartridge that added similar commands to the VIC, but they were very slow and no one could run any programs you wrote unless they had the cartridge as well.)

Don was able to hook me up with a “CoCo” (expanded to 64K) for $300, and I moved on from the VIC. As part of the deal of getting me a new computer, I had to give all my old VIC hardware and software to my dad. I don’t know what he did with it after that. After that, until recently, I pretty much never looked back. Only with the discovery of my old VIC-20 games am I starting to understand how much I actually did with that machine.

Good times.

Up next: Dissecting some of my very first programs. Will I even remember how they work?

In search of VIC-NIC News

  • 2020-03-17 Update: I found another reference to The Byte House in a magazine called Micro (about the 6502 and 6809). They listed a VIC-20 game called “Mojave Desert Adventure” by Dennis McCormack. Then, in an earlier search, there was an excerpt from VIC-NIC called “Ask Dennis.” Now I have a second name to try to track down in hopes of finding this old newsletter.
  • 2021-10-13: http://www.vic20listings.freeolamail.com/mag_cpowplay.html
  • 2024-02-02: Someone e-mailed me today saying they had the first issues and that my Eggs program appears in issue #6. I am hopeful they can provide scans of these issues so we can get them uploaded/archived somewhere. Iโ€™ll share details when I have them.
  • 2024-02-012: Article posted! (Also check for follow-ups as I fixed an issue with the joystick code.)

My first computer was a Commodore VIC-20. When I first received it (thanks, dad!), I stayed up all night going through the manual learning how to program it. In my short time with the VIC (I got a Radio Shack CoCo 1 about a year later), I wrote many simple games. Recently, I found a box of old VIC-20 cassettes that have these programs, and I have been trying to import them to run on an emulator.

This makes me want to find another aspect of my first computer. I had a program published in a newsletter called VIC-NIC NEWS. I cannot find my physical copy of it (but may still have it somewhere, since I still have all my old Compute’s Gazette VIC-20 magazines). I’ve done some searching for it over the years (and when I search now, I tend to find myself searching for it or talking about it).

Can anyone help me track down VIC-NIC NEWS? My game was a simple “catch the falling object” game called Eggs. I’d really like to see it again.

Online searches revealed issues of a magazine called Commander. I found this excerpt:

THE VIC-NIC NEWS , bi-monthly, $6 per year from The Byte House.

8 page newsletter consisting of several brief listings, a page of reviews, a crossword puzzle, some ads, a question column, and errata. A decent price from friendly folks, but what is a VIC-NIC?

-Commander Magazine / Also The Midnite June-July 1983 Page 50

As well as a listing under User Groups – New Hampshire:

TBH VICยทNIC CLUB
PO Box 981
Salem, NH 03079
Contact – J. Newman
Publication – VIC-NIC NEWS
Interests – VIC-20 Exclusively

-Commander Magazine (Issue 08, July 1983, Page 121 / Issue 8, Page 89)

I have had no luck tracking down J. Newman. (I also wonder if this might be a female, since I often see women go by an initial in publications and online. Anyone know who J. is?)

Any help?

UPDATE

Tada!

Before Sub-Etha Software…

Updates:

  • 2024-02-12 – Added image of Eggs, my first published program. Replaced Factory TNT screenshot with one that shows the proper graphics. Updated Meteor Clash screenshot.

…it was going to be Custom Programs Limited.

My first computer was a Commodore VIC-20 back around 1981 or 1982 (whenever it first came out for “under $300” – $299.99 is what my father paid for it, I believe).

But my buddy, Jimmy*, suggested “Unlimited” because then it would be C.P.U. (I had not even heard the term CPU yet). And thus, CPU Software  was born.

Screenshot 2016-02-23 21.57.52

The letters appeared to the musical notes of 2001, one at a time, then the title screen would come up:

Screenshot 2016-02-23 21.58.07

That was to be our startup for all our custom programs. It was going to be me writing for the VIC-20, and Jimmy writing for a Timex Sinclair ZX81, and another guy at school writing for a TRS-80 Model III (he didn’t own one, but had access to them at school). We thought we could custom write programs for people.

Our first program was a horse racing game, and it was written for each of these platforms, though I don’t seem to have a copy of it (or it’s on one of the tapes that is bad).

I don’t know why we didn’t pursue this, but I did write a bunch of small games for the VIC-20…

Eggs

I wrote a simple BASIC game called Eggs and it was published in the June/July 1983 issue of VIC-NIC News (issue #6).

It was a very simple “catch the falling object” game that used joystick.

Brick Layer

Bricklayer was a simple game based on the Atari VCS cartridge Surround. I apparently wasn’t date-aware back then, and the comments inside the program only list the title and author. Bummer. I really would like to know when I wrote these.

Bricklayer for the VIC-20
Bricklayer for the VIC-20

The game screen animated as it drew the black walls (with sounds), then the game began. Using a joystick (I think), you started “laying bricks” around the screen, trying to cover as much area as you could without running out of room or crashing.

Screenshot 2016-02-23 20.56.14

If you got over 200, it would congratulate you. If you crashed, it would summarize your accomplishment.

Bricklayer for the VIC-20
Bricklayer for the VIC-20

Yeah. There was a time when this would have been considered a game. Interestingly enough, the movie TRON would come out a year later, taking the “draw lines” concept to a new level with the Light Cycles. The TRON arcade game featured Light Cycles as one of the four games it had, and this became my favorite arcade game of all-time.

I guess I had a thing for drawing lines.

Gold Grabber

Next up was a chase game.

Screenshot 2016-02-23 21.26.39

You moved around the screen (you were the clubs symbol) trying to catch the gold (the diamond) while avoiding the bad guy (the +).

Screenshot 2016-02-23 21.27.05
Screenshot 2016-02-23 21.27.43
Screenshot 2016-02-23 21.29.30

I have no idea what the “+” represented, and the game logic just had it wandering around randomly so I had to actually try to run in to it to see what it did.

Factory TNT

In my mind, this was called Factory TNT, but for some reason, the cassette was just labeled as TNT. This was a “Kaboom” catch the falling objects game. I had previously written a text version of the same type of game and called it Eggs. In it, you were catching falling eggs. This game was printed out in the VIC-NIC NEWS newsletter.

I almost had this program distributed by a company, but due to my very similar Eggs game being printed in a newsletter (which they also subscribed to), they decided to pass on it. (I belive this was the “FOX 20: the magazine for VIC 20 users” cassette-tape newsletter, published out of Pasadena/Deer Park, TX. (I lived in both those towns at one point, and recall going over to the house of the publisher – it was a home run operation – and meeting them once.)

The tape is bad, so the custom graphics are not loading, but it should look like a conveyor belt on the bottom, and pipes on the top. Classic round bombs would fall from the top and you moved your cup along the conveyor to catch them. If they hit the ground, they would turn in to a mushroom cloud. It has decent sound effects.

VIC-20 Factory TNT.

Apparently, it tracked high score (not saved to tape or anything, so it would reset any time you reloaded).

Factory TNT for the VIC-20
Factory TNT for the VIC-20
Factory TNT for the VIC-20
Factory TNT for the VIC-20

Apparently I had different rankings! Cool. I need to check the listing and see what all they were.

Thick Brush

For some reason, I did a blocky drawing program.

Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20
Thick Brush for the VIC-20

What in the world was this good for? There didn’t seem to be a way to save the “artwork” either. I guess I was, yet again, inspired by the Atari VCS Surround cartridge, which had a simple drawing mode (but the Atari version didn’t let you draw in colors – take that, Atari!).

Sky-Ape-Er

In a previous post, I mentioned my Donkey Kong inspired game, Sky-Ape-Er. Actually, it was really inspired by a VIC-20 game I bought that was inspired by Donkey Kong. I remember seeing it at the only VIC-20 store in Houston (I had my grandmother drive me across town to go to it), and they were out of stock, but they made a copy and sold it to me, and said I could get the real tape when they got more (I never did). On the label, they hand wrote “Krazy Kong”, so it might have been this one, or this Super Kong one. They appear to be the same game, but with different colors.

The important breakthrough was that they solved the problem of ladders and such by just making the level wrap around and go up. I had been working on a Donkey Kong style game and planned to use teleporters so you would stand on a spot and it a button and be teleported to the level above (I guess I had no idea how to make the climbing work then). When I saw the Krazy Kong approach, I knew I could do that, and make it better.

I worked on a few versions of this, with some graphics that looked like Donkey Kong girders, and some that looked like bricks. I think the brike

Later versions had instructions!
Unlike one I bought, my version had instructions!
The graphics were more Kong-like here. Sorta.
I think mine looked better than the one I bought.

It turns out to be a very difficult game! I finally cleared the first screen and found out there were multiple levels! I wonder how many are in there??? This is level 2 (using the prototype graphics):

Sky-Ape-Er for the VIC-20
Sky-Ape-Er for the VIC-20

And the “continue” screen was kind of snarky. I seem to have put some work in to these things.

Sky-Ape-Er for the VIC-20
Sky-Ape-Er for the VIC-20

I don’t know what my intentions were with this game, but I expect I was trying to sell it as well. I had no idea that an individual could just make tapes and put ads in newsletters and sell copies back then. I wish I did — I probably could have made some money in those early days.

Maze Gobbler

I was annoyed with Pac-Man games not looking like Pac-Man (I’m looking’ at YOU, Atari VCS), so I started working on my own. I replicated the Pac-Man maze very accurately, but by the time I had done that, I was out of memory on this 3.5K computer. Nothing exists from that maze except a title screen, as far as I have found:

Maze Gobbler for the VIC-20
Maze Gobbler for the VIC-20

Meteor Clash

My attempt at a Defender-style game (maybe – I’m not sure that game even existed yet) was Meteor Clash. You moved a spaceship up and down and dodged endless meteors that headed to you.

Meters Clash for the VIC-20
Meters Clash for the VIC-20

This game had an intro that printed out text letter-by-letter like a typewriter, with beeping sounds! Fancy.

Meteor Clash for the VIC-20
Meteor Clash for the VIC-20

Spell checkers did not exist for the VIC-20, apparently.

Meteor Clash for the VIC-20
Meteor Clash for the VIC-20

I don’t know how to use those cursor control keys on the emulator yet, so I wasn’t able to play it. I was able to fly for a bit until a meteor hit me.

Oops. This screen shot was taken when the meteors were being redrawn, so it’s just the ship. It wasn’t much of a game yet, anyway. It did have sounds, and an explosion, though! Maybe that would have been enough to be a game, but I hadn’t even customized the graphics yet. (Maybe that’s “Meteor Storm” I keep remembering.)

Rover

I seem to recall that this was going to be a Moon Patrol style game, but all I can find is a test of the title screen.

Rover for the VIC-20
Rover for the VIC-20

I found a few other things, too, including stuff written for the Super Expander cartridge which I cannot run on the emulator I am using. I need to figure out if that is possible in another emulator, since I have some games I wrote for it (enhanced graphics commands and such).

I also did a bunch of video titles for a booth at the Houston Boat Show for my father. I remember having an animated fish that swam back and forth on the screen in one of them, and drawing blue water waves. I later did graphics using my TRS-80 CoCo 1, and my dad was never impressed with it since the colors were so much worse than the VIC-20.

Interesting stuff, even if most of the tapes won’t load in 2016.

Man… I was, like, 12 years old when I was doing this. I really should have done more with it, but who knew computers were going to become such a part of life!

To be continued…

*Jimmy J was a kid I met in 7th grade. I had seen a listing in TV guide for “The Hitchhiker’s Guide to the Galaxy” on PBS and had watched it. In English (?) class, I quoted a line from the show, and he turned around and said something like “you watched that to?” We became friends, and I think he’s the one that let me know about Douglas Adams and the book versions of Hitchhikers. He also introduced me to computers. He had a book on programming and we would go down to Radio Shack to type things in on the TRS-80 Model III. He’s likely the one that introduced me to BBSes too (again, we’d go down and get online at Radio Shack before we had our own computers and modems), and he was also the one that introduced me to the concept of hacking and phone phreaking. Fun times! Beyond my parents, I can’t think of any other person that had such an impact on the direction of my life at an early age. Thanks, James!