Hi, I discovered a few mistakes in my opcode list and have made an update. Main difference is how the unconditional jump instruction is used. Thanks! Michael

Microprocessor Engineering (MPE) provides a modern Forth for the RTX2000 CPU's. They graciously provide a link to a legacy cross compiler, officially "MPE Forth Cross Compiler v5.1 for RTX2000/1/10". Here is a link to the zip file:

https://vfxforth.com/downloads/VfxCommunity/xrtx.zip

The documentation of the cross compiler is excellent, see the PDF in the Manual directory. Included in the manual is a convenient list of opcodes. I have taken a few screenshots of the opcode information, and share it here.

The legacy cross compiler has some challenges regards implementation. An installation key for the software is required, which was graciously provided by MPE upon request. The software has a windows installer, but the software itself runs in a DOS enviroment. I installed the software on a Windows 95 machine, and drop down to DOS in a window to run.

The software has an integrated development environment of sorts, based upon a DOS shell called Xs3. The shell is invoked from different directories, with each directory containing a separate configuration file for the current shell, depending upon the intended activity. The software can cross compile to create either a Tether Forth, ROM forth or RAM forth. The manual is excellent. I'm experimenting with the cross compiler presently.

Here are a few miscellaneous points...

Attached is a screenshot of the MPE Forth Cross Compiler in action on a Windows 95 computer. The software seems OK with simply operating inside a MS-DOS window prompt. Notice the extensive menu.

The memory for the RTX is paged. Each page is 64 KB (32K Words). Special opcode invocations are required to work across page boundaries. I decided to avoid that issue by changing the memory layout on my development board. The board was rewired to provide a contiguous 16K of ROM words, and 16K of RAM words. My board is starting to get pretty messy, and I need to do another spin. See photo.

Finally, something simple. For months I was trying to use the large RTX Programmers Manual in PDF format. I finally had the PDF printed and bound. What a difference in convenience!

Howdy. I have spent a lot of time researching opcodes for the RTX2000 CPU series from Harris. In the process I have found there are many forth words that are not defined. I just wanted to mention that it is very easy to work around that issue. The RTX instruction opcodes are 16 bit words. If the first bit of any word is a zero, the instruction is treated as a jump to a subroutine. This makes it very easy to define your own Forth words programmed in assembly.

Attached are some examples of words that I have defined. The code snippets are placed in ROM at the address of the subroutine. That address can thereafter be treated by the excel assembler as a valid opcode, so long as the routines are present in the ROM.

At some point I will program the mnemonics into the substitution formulas of the assembler. It is a great convenience to simply type the mnemonics and have the split codes assembled for you. The only really tedious part at this point is fixing up the addresses of the jumps. Other than that, it's almost like coding in Forth! Michael

It might be nice to process the assembly using a macro processor.
FORTH directory format might be simplified permitting different versions
of FORTH to compile using the same core routines.

Just a quick update on the RTX2000 Development Board Project. I have been writing snippets of code in Assembly using my Excel Assembler Tool. I created a cheat sheet for logical control structures using the opcodes provided by hardware, which is attached.

Presently I am working on a native operating system, of sorts, which will allow me to more easily exercise and experiment with the RTX architecture. Considering my approach to serial terminal control, an editor and file transfer. Also updated the PCBs. Michael

Here is a quick update. I wrote a small application for the RTX2000 development board using assembly code. The application allows me to create, list, edit and execute machine code on the RTX2000. This is a great convenience for exploring the CPU architecture and opcodes. I have attached a screenshot of a brief editing session.

The total size of all the code I have written is 992 bytes. This includes Initializing the Serial Port UART, a NEXT Engine for the menu, Definition of an additional 27 words (bulk of code) and the Monitor Application (Type, Edit, List, Run). I have made no attempt to economize or streamline the code.

It occurred to me that this would be a good point to archive my project materials to date. I've zipped up the most important things and uploaded it to my website. Folders Include: PCB Files, Excel Assembler, Photos, Documentation and Binaries. There is a readme.txt in each folder describing what's there. Here is a link:

http://www.mtmscientific.com/rtx_mtm.zip

Michael

A milestone! Thanks for sharing.

Hi, My work on the RTX2000 Development Board continues. I did new spins on the Carrier Board PCB and also the Motherboard PCB. I'm hoping to build up several of these systems, considering I have managed to collect multiple working RTX CPUs

One item that might be helpful to others: There is a listing on EBAY for used RTX2001 chips from Harris. An excerpt from the listing is attached. The listing clearly states the devices are being sold as-is. However, I took a chance and bought one of them for testing. Unfortunately the CPU does not work. So you might want to factor that in, if you are tempted to try your luck with a low ball offer to the seller. Michael

It's been hard to find specific design information about using the RTX2000. In the process of researching the CPU I have identified several different methods for serial communication...

In the 1980's Harris published an application note on the topic titled "Description of a software UART for the RTX2000". This method uses the boot pin as the TX output, programmed for bit banging. An interrupt line is used for the input. The software automatically determines the baud rate by analyzing the first character sent from the Host. This method was used by Chuck Moore, who wrote cmForth, which uses this method of serial communication. Here is a link to the App Note:

http://www.mtmscientific.com/Harris89_R ... ote117.pdf

A development board for the RTX2000 was offered by MPE. There is a recent YouTube presentation about it here:

https://www.youtube.com/watch?v=TYgsCbTw1kY

The MPE board uses the Zilog Z8530 UART. There are some binaries floating around GitHub for the MPE board which expect this specific UART configuration. I was able to obtain a low resolution circuit diagram and parts list of the setup. Both are attached here for reference. (Contact me if you have any hardware, software or documentation for this board!)

The serial UART used on my development board is the P8251A. This vintage UART had been previously used by me for some other projects, so I was familiar with it and had parts on hand. I am using the ASIC bus to communicate with the UART, which is overkill. I would be inclined to switch to memory mapped I/O in a future design.

Finally, I wanted to mention that there is a good potential source for the RTX CPU if you want to experiment. A fellow in Australia is offering the CPU with a compatible socket for a reasonable price. Here is a photo excerpt of the listing. The seller used the RTX for a fruit sorting machine, a few photos of which are in the Ebay listing. Interesting! Thanks, Michael