For some more details, please visit the GitHub page of this project.
Explanation of Front Panel
Some YouTube Videos
Description of the Microtronic, its CPU and Machine Language
I was asked to provide some more details about the Microtronic and its machine language. Here we go:
The Microtronic is a very simple computer. It is programmed in a custom machine language, called 2090 ML in the following. 2090 ML is a virtual machine language, interpreted by the monitor program / operating system of the Microtronic. The original Microtronic uses a TI TMS 1600 Microcontroller, clocked at 500 kHz, and executes 2090 ML at a speed of a couple of 2090 ML instructions per second. This Microtronic Emulator runs on an Arduino Mega 2560, and the interpreter and operating system / monitor program was "reengineered" in C (I don't have the original TMS 1600 machine code of the operating system / monitor program). The emulator achieves a higher speed than the original Microtronic, but it can be throttled down with a pot.
The Microtronic program memory has 256 words of 12 bits. It has two sets of 16 universal 4 bit wide registers, 0 - F. There are instructions to swap / exchange the work and aux register sets. The CPU has Carry and Zero flags, and offers conditional and unconditional branching, as well as subroutines. The original Microtronic disallowed subroutine calls from subroutines due to the lack of a stack for storing the program counter, but my emulator allows nested subroutine calls (and the stack size is adjustable).
The 2090 ML was designed under didactic and pedagogic considerations, offering high-level instructions for otherwise tedious (or impossible) to implement operations, e.g., decimal multiplication and division, hexadecimal to decimal conversion (and vice versa), real time clock, random generator, display output, etc. The program memory is read only; the only write able memory is register memory. In a sense, the Microtronic implements a Harvard Architecture, with the only (write able) data memory being the register memory.
With regard to IO, there are instructions for displaying register content on the 6digit 7segment display. There is 4 bit wide digital input, and a 4 bit wide output port. Also, there is an instruction that waits for input from the hexadecimal keypad and stores it into a register.
A Simple Microtronic Example Program
To give a first example for 2090 ML, a simple digital 4bit counter on the LED 7segment as well as the 4 digital output LEDs looks as follows:
Address Mnemonics OP Comment =========================================================== 00 MOVI 00 100 Load 0 into register 0 01 DISP 10 F10 Display 1 register, starting at 0 02 ADDI 10 510 Add 1 to register 0 03 DOT 0 FE0 Bring register 0 to output port 04 GOTO 02 C01 Goto address 01
The Microtronic Instruction Set
In the following, the 2090 ML instruction set is listed. I use the following notation: s = source register (0-F), d = destination register (0-F), n = 4 bit immediate constant (0 - F), and aa = 8 bit address (00 - FF). reg(d) denotes the content of register d (0 - F). The aux registers are denoted by 0' - F'. Unless indicated otherwise, flags don't change. "... -> d" means copy ... into register d. I am using standard C operators, i.e. "&" is bitwise AND, "|" is bitwise OR, then there are left and right shift operations ">>" and "<<" An "I" suffix to the Mnemonics means "immediate", and "iff" means "if and only if".
Two address instructions:
MOV = 0sd : reg(s) -> d. Zero if reg(d) = 0. MOVI = 1nd : n -> d. Zero if reg(d) = 0. AND = 2sd : reg(s) & reg(d) -> d Carry = false. Zero iff reg(d) = 0. ANDI = 3nd : n & reg(d) -> d. Carry = false. Zero iff reg(d) = 0. ADD = 4sd : reg(s) + reg(d) -> d. Carry iff overflow. Zero iff reg(d) = 0. ADDI = 5nd n + reg(d) -> d. Carry iff overflow. Zero iff reg(d) = 0. SUB = 6sd : reg(d) - reg(s) -> d. Carry iff underflow. Zero iff reg(d) = 0. SUBI = 7nd : reg(d) - n -> d. Carry iff underflow. Zero iff reg(d)...Read more »