Entries posted in June 2023

Recently I was looking around the internet and looking for something to do with some ESP8266 devices, which I've been neglecting over recent years.

When I was on paternity-leave, five years ago, I decided I wanted a new hobby for my "down" time. I had two obvious choices a) developing applications for mobiles, or b) working with "hardware". I chose the latter.

By accident I came across a couple of simple scripting languages, FORTH-esque. Sample usage looks something like this (which obviously sends the command over a serial-device to the connected-board):

$ echo '5{ 6d 1o 100m 0o 100m }' >/dev/cu.usbmodem12341

That's a little terse, but briefly:

• 5{ ... }
  • Execute the block five times.
• 6d
  • Set the output pin, in the example "D6".
• 1o
  • Output "1" to the pin we've selected, D6 in this example.
• 100m
  • Delay for 100 milliseconds.
• 0o
  • Output "0" to the pin we've selected, D6 in this example.

The end result is a blinking LED, for five iterations anyway. The code for this interpreter is described in the following link, with the code in the linked gist:

• http://sustburbia.blogspot.com/2016/02/a-review-of-tiny-languages-part-3.html
  • https://gist.github.com/anonymous/a5bf920f42da5d2c44cc

This is derived from an older, and simpler, project which has a similar focus but slightly different built-in operations (and which lacks loops/conditionals):

• https://github.com/WardCunningham/Txtzyme

Both of these implementations are very similar, I guess due to the shared history and obvious FORTH-inspiration. Each allows port I/O, delays, and simple math opertions. We can pretend they're stack-based, though there are some differences and some niggles.

I'm kinda tempted to port one of them to Z80 assembly, and see if I can get it running under CP/M. I guess I could add a REPL for interactive use, though without actual hardware connected to my single-board computer it might all feel a little pointless. Then again I have Turbo Pascal, and even a tiny C-compiler, so I guess with those in mind any toy-language is pointless in a completely different regard.

Tags: simple, txtzyme | No comments

So my previous post documented a couple of simple "scripting languages" for small computers, allowing basic operations in a compact/terse fashion.

I mentioned that I might be tempted to write something similar for CP/M, in Z80 assembly, and the result is here:

• https://github.com/skx/z80-cpm-scripting-interpreter

To sum up it allows running programs like this:

0m 16k{rP _ _}
C3 03 EA 00 00 C3 06 DC 00 00 00 00 00 00 00 00

Numbers automatically get saved to the A-register, the accumulator. In addition to that there are three dedicated registers:

• M-register is used to specify which RAM address to read/write from.
  • The instruction m copies the value of accumulator to the M-register.
  • The instruction M copies the value of the M-register to the accumulator.
• K-register is used to execute loops.
  • The instruction k copies the value of accumulator to the K-register.
  • The instruction K copies the value of the K-register to the accumulator.
• U-register is used to specify which port to run I/O input and output from.
  • The instruction u copies the value of accumulator to the U-register.
  • The instruction U copies the value of the U-register to the accumulator.

So the program above:

• 0m
  • 0 is stored in the accumulator.
  • m copies the value of the accumulator to the M-register.
• 16k
  • 16 is stored in the accumulator.
  • k copies the value of the accumulator (16) to the K-register, which is used for looping.
• { - Starts a loop.
  • The K-register is decremented by one.
  • If the K-register is greater than zero the body is executed, up to the closing brace.
• Loop body:
  • r Read a byte to the accumulator from the address stored in the M-register, incrementing that register in the process.
  • P: Print the contents of the accumulator.
  • _ _ Print a space.
• } End of the loop, and end of the program.

TLDR: Dump the first sixteen bytes of RAM, at address 0x0000, to the console.

Though this program allows delays, RAM read/write, I/O port input and output, as well as loops it's both kinda fun, and kinda pointless. I guess you could spend hours flashing lights and having other similar fun. But only if you're like me!

All told the code compiles down to about 800 bytes and uses less than ten bytes of RAM to store register-state. It could be smaller with some effort, but it was written a bit adhoc and I think I'm probably done now.

Tags: assembly, cpm, github, z80 | No comments