The Harris RTX2000 Stack CPU was released in the late 1980's. This CPU is a direct descendent of the Novix N4000 designed by Charles Moore as a hardware implementation for his Forth computer language. The RTX2010 version is radiation hardened for space applications, of which there have been many.

https://books.forth2020.org/home/forth- ... plications

These processors are rare, difficult to source and expensive! My interest in the RTX2000 relates to the stacks, a feature found in my homebrew LALU computer design. About 5 years ago I was fortunate to source some of these CPU's on Ebay, and now I am working on a development board to experiment with the devices. I've attached a photo of some of the hardware, and the first page of the datasheet.

Here is a link to the complete datasheet.

https://rocelec.widen.net/view/pdf/wezk ... e&u=5oefqw

It has been very challenging to find design information for these devices. I have spent about 1 month collecting information on these CPUs. I plan to document the development process on this project thread...

Michael

Looking forward to hearing more on this project thread. I remember reading about the RTX2000 a while ago. I was tempted to try and come up with a Verilog version by modifying something like the J1. Finding good documentation for older devices is a challenge. Especially important if one wants to develop compatible hardware and software.

Well ebay has them. Remember they are 16 bits data. I like a 20 bit forth engine, with 4 5 bit micro ops per word
and 20 bit? data.

Great starting point for experiments Michael!

A outdated web page.
https://www.ultratechnology.com/chips.htm
The wayback machine is back online, so check there for broken links,

Thanks for the information and the support! I've spent alot of time researching Forth for the RTX2000. Chuck Moore wrote cmForth for the Novix CPU (Predecessor to the RTX family). The cmForth was eventually adapted to the RTX2000 and included in a product development package offered by Indelko in 1989. Here is a screenshot of the product offering from Forth Dimensions. Sure would like to have that DOS 360K diskettes! (Can't find that version of cmForth anywhere) Michael

Here are a few useful links related to the RTX2000 project.

Dr. Tom Hand was an employee of Harris Semiconductor when he wrote this paper describing the RTX series. His paper is an excellent summary of the CPU and the 16 bit instruction format.

https://vfxforth.com/flag/jfar/vol6/no1/article1.pdf

Commercial development IDEs are available for the RTX series. If money is no object, you have the SwiftX offering here for $2995.

https://www.forth.com/product/forth-rad-hard/

Another offering is from MPE, which is offered in a subscription model.

https://www.mpeforth.com/software/rtx20 ... 0rh-tools/

As previosly mentioned, Chuck Moore wrote cmForth for the Novix series. Moving cmForth to the RTX was quite a task, as described here by Dr. Ting in a supplement to "Footsteps in an Empty Valley."



The trail turns cold trying to find this version of cmForth for the RTX series. The best I could find was this link to a source code listing.

https://eforth.com.tw/academy-n/chips/H ... 2000_5.htm

I believe my development work will start by doing some simple hand assembly using machine opcodes. Next week I am expecting some PCB's to arrive and the hardware phase will begin. Michael

The development PCBs finally arrived and I have assembled the first prototype...

Since the ZIF sockets for the CPU are difficult to find (and expensive) I designed a carrier card for the RTX2000. I expect multiple iterations of the motherboard will be required, and with the carrier card I can simply move the CPU plug-and-play style.

The motherboard is quite barebones at this point. I have 32K of ROM and 32K of SRAM memory. The glue logic for the memory is made of 74F00 NAND gates. I'm starting with a slow clock at 1 MHZ, but the oscillator is socketed for experiments at higher speeds. The motherboard also has an RS-232 circuit based on a MAX232 Serial I/O. (I'm a long ways from that!)

So far, my only testing has been the smoke test. Which I am happy to report was negative. Right now I have the CPU in an infinite loop, but my next step will be to write an assembly code loop to flash the LED (lower left) connected to the Boot pin on the RTX2000.

Some photos are attached. Michael

I like using EEPROM's for ROM, this way you can patch the ROM with out removing them.

What design rules are you using for the PCB's? I have gone to 10 mills trace and 10 mills space
with a 10/20 mill via. This lets me use a 25 mill grid for routing and cuts my board size by half,
over the normal 50 mill grid.

Hi, I'm using 10 mil traces, but with an 0.031/0.014 via (smallest available in ExpressPCB). I purposely have kept everything large and spaced-out, starting with the breakout board in a 0.100" pitch. I also use throughhole components to keep things easier to assemble. I purchase my boards from PCBWAY. Previously this has been a great solution, although I've recently had a few issues with shipping by DHL related to tariffs. Michael

The RTX2000 Development Board is now responding to machine code instructions. I am able to toggle the High/Low level of the Boot pin, which is connected to an LED indicator. I found a simple mistake (intersecting traces) in the PCB routing which was fixed with a wired patch. The coding consists of hand-assembled opcodes burned into a pair of ROMS (8 low bits + 8 high bits = 16 bit instruction).

I was not able to find a cheat sheet for opcodes, and had to determine them from the documentation. Here are the best resouces I have identified for determing opcodes.

1. Best place to start. General overview:

Koopman's "Stack Computers: The New Wave
Section 4.5 Architecture of the Harris RTX 2000

https://users.ece.cmu.edu/~koopman/stac ... index.html

2. Another good place to find opcode information is Dr. Hands' paper

"The Harris RTX 2000 Microcontroller"

https://vfxforth.com/flag/jfar/vol6/no1/article1.pdf

3. The Programmers Reference Manual from Harris Semiconductor

I have yet to find a good, clean PDF of this document. I have found a marked-up draft copy here.

https://users.ece.cmu.edu/~koopman/fort ... Manual.pdf

I have attached a draft list of opcodes for Forth primitives that I have determined from first principles. Most of these codes have not been tested (yet).

Michael

My first experiments with the RTX2000 CPU will be with hand-assembled machine code. I built a simple assembler using EXCEL, similar to what was done for the TTL-Retro and LALU computers.

First I created a list of 3 character mnemonics representing some Forth primitives. From there I used the available documentation to determine the corresponding 16 bit opcodes. Then I created 2 substitution formulas. The substitution formulas recognize the mnemonics and translate to the high and low bytes for my ROMs, in separate columns. The codes can then be cut-and-pasted into a ROM file for burning, using a hex editor.

I've attached a screenshot of the worksheet (with some notes) and an overview of what the substitution formulas look like. The formulas are maintained as a text document, which makes it easy to change and update going forward.

I have found that many good resources related to cmForth are scattered around the internet. Here are some especially useful links related to this project...

Here is a nice, clean copy of Dr. Ting's book "Footsteps in an Empty Valley". This books spends alot of time on the Novix, predecessor to the RTX series. (FWIW: A printed copy is available on Amazon for less than $20)

https://www.forth.org/OffeteStore/4001- ... sFinal.pdf

I previously posted a link to a cmForth listing for RTX. Here is a link to some nice cleaned-up copies for the Novix and RTX.

https://github.com/tendai22/cmForth

Finally, I found this link to Pygmy Forth for DOS Version 1.7, from Frank Sergeant. Pygmy Forth was largely based on cmForth. This version runs on a DOS machine and has excellent documentation. This distribution makes it easy to get into the cmForth development enviroment to learn your way around!

https://pygmy.utoh.org/pygmyforth.html

FIG FORTH is the only TRUE Forth.
https://www.forth.org/OffeteStore/1010_ ... gForth.pdf

One thing I liked about fig forth, is that you had a version (6502) of the FORTH compiler
written in FORTH.

Regardless of what forth you run, DISK routines are rather primitive and assume a floppy sized
disk. There is no files, just raw blocks. If have no OS that is a good thing, if you have a OS
like DOS that is PTA.

IIRC I ported FIG FORTH 6502 to the 6809 a couple of years ago. Fairly straightforward to do so.