A Scheme Interpreter for ARM Microcontrollers

ARMPIT SCHEME is an interpreter for the Scheme language (lexically-scoped dialect of Lisp) that runs on RISC microcontrollers with ARM core. It is based mostly on the description of the Revised^5 Report on the Algorithmic Language Scheme (r5rs) and is transitioning towards R7RS-small. It contains some extensions (for I/O) and some omissions (to fit within MCU memory). It is designed to support multitasking and multiprocessing (partially for now). Armpit Scheme is expected to be well suited to educational settings, including student projects in courses on control and instrumentation, or capstone design courses where microcontrollers are needed. It is meant to enrich the spectrum of interpreted languages available for MCUs (eg. BASIC and FORTH) and can be an alternative to MCU-based bytecode interpreters (eg. for Scheme, Java, Lua or Python) and to compiled languages (eg. C).

The name "Armpit" was selected for this project because it includes "ARM" (as in ARM core MCU) and "pit" (as in kernel, noyau, nucleus, the core of an Operating System (OS)). Armpit Scheme, once loaded, governs the operation of the MCU, and is "Scheme to the metal" in the sense of running without any other OS. It may be thought of as turning the MCU into a rudimentary Scheme machine. The screenshot below shows the system running on a NanoPC-T3 Plus, communicating via USB. Minicom is used to communicate with the board which reads, evaluates and prints the result of the entered expressions.

This version of Armpit Scheme supports USB keyboards for various MCU boards. The figure below shows a Logitech wireless USB keyboard used with the NanoPC-T3 Plus (in a metal case; right behind the keyboard).

External display, on LCD or via DVI or HDMI, is also supported for some of the boards. Connecting both a keyboard and an external display provides an environment that is nearly standalone. Still missing are an editor, mouse support (possibly), and the ability of the "boot.scm" startup file to properly instantiate libraries. The code needed to use keyboard and display is given in the example pages (below). Figure 3 shows the result of loading the console.scm file in a running system.

The latest development snapshot of Armpit Scheme is 080. It is distributed under the MIT License and is a beta releases, with both known bugs and unknown bugs. The source code, and pre-assembled (ready-to-use) binary image files, can be downloaded from the armpit project page at SourceForge. You can also view the source code from your web browser.

In version 080, the base characters are from the 16-bit unicode set (rather than 7-bit ASCII). Strings are made up of sequences of these characters, and symbols (eg. function names) are encoded in UTF-8. A memory allocation nursery is used on Cortex-M to help speed-up garbage collection in these slower systems. The code is split-up into a small Live-SD (LSD) bootloader which is MCU- (and board-) specific, and the Scheme interpreter (ArmPit Scheme, aka: APS) which depends on the MCU's Machine Language (Thumb2, Aarch32 or Aarch64) and allows for two Thumb2 memory layouts. The MCUs capable of 64-bit operation (eg. Cortex-A53) are run in 64-bit mode (not 32-bit compatibility mode). To produce a unified code base that successfully assembles and runs across the selected targets, some minimum requirements were set for the boards on which Armpit Scheme 080 runs (relative to previous versions). For 080, the MCU needs to be a Cortex-M4F or above, with a FPU, an MMU or MPU, and the board needs to have an SD-card slot for the LSD bootloader to fetch the APS. Wherever possible, the bootloader is also placed on an SD-card, to be loaded and executed by the MCU's boot ROM, such that the overall operation is as a Live-SD (or Live Disk) whereby the MCU (or board) flash storage is not needed (and not used). In all cases, user files are stored on the SD card.

The system is documented in several web pages: 

• Documentation for Armpit Scheme Version 080 (July 2018 to present):
  • ChangeLog
  • Common Program Examples
  • Display and Keyboard Examples
  • Performance
  • APS Interpreter Implementation Reference
  • LSD Bootloader Implementation Reference


• How To: upload, communicate with and re-assemble Armpit Scheme.


• Documentation for previous versions (ARM7, ARM9, Cortex-M3 and M4, Cortex-A8 and A9):
  • Armpit Scheme 050 to 070 (2012 to 2018).
  • Armpit Scheme 00.0160 to 00.0250 (2009 to 2012)
  • Armpit Scheme 00.0017 to 00.0152 (2006 to 2008)

The lastest release is designed to run on the following boards (see build_all script):

(*) CPU speeds (MHz) are configured speeds and may be lower than the allowable maximum for any of the MCUs in the table. LCDs, DVI displays and USB keyboards are programmed from within user or library space (not in the core -- see mcu-specific program examples).

External links of potential interest include:

• Five recently found links: Spencer Putt's Scheme interpreter for the Z80 (2011), written in assembly. Yesco's esp-lisp (2017), a small fast lisp interpeter for the ESP8266. Jonathan Kraut's Sassy (2009), an x86 assembler written in R5RS Scheme. A very small Scheme bytecode interpreter for PIC18 and ARM, named picobit (2015), developed by St-Amour, with front-end compiler that runs on Racket. The MicroPython project's Pyboard and software (2014-present), for running Python 3 on microcontrollers.
• Discussions on the potential of Scheme/Lisp for Microcontrollers: A brief essay on embedded lisps and schemes by Matt Knox. A colorful project on wearable lisp and unsorted discussions or comments about the potential for Lisp/Scheme to run on MCUs (1), (2), (3), (4), (5), (6) (search for LISP or Scheme in those pages). A Scheme byte-code interpreter that runs on PIC MCUs (named BIT and PICBIT by Danny Dube and Marc Feeley of the University of Montreal. The LegoScheme project at Indiana University. XS LISP for the LEGO RCX by Taiichi Yuasa.
• Implementations of Scheme/Lisp on the metal, in assembly or small: The movitz project that targets Lisp "on the metal" (x86). Dream scheme written in PPC/x86 assembly language by David Joseph Stith. A scheme in forth by Mark Probst. TinyScheme by Dimitrios Souflis and Jonathan S. Shapiro (with versions for ARM processors). pocket scheme (for PDAs) by Ben Goetter. Hedgehog embedded LISP by Lars Wirzenius and Kenneth Oksanen. XMOS BIT Scheme, a Scheme interpreter for XMOS chips produced at the VUB in Belgium. A Scheme interpreter written in C for AT-Mega32 microprocessor, developed as ECE 476 Final Project at Cornell University.
• Other interesting functional language systems running on the metal: The Python-on-a-Chip project where the PyMite VM is implemented on microcontrollers. The eLua project where Lua is implemented on microcontrollers. The lispm project where LISP is implemented in an FPGA.
• Multiprocessing Scheme systems: Termite Scheme, a distributed scheme using Erlang-like communication (paper). Kali Scheme, a distributed implementation based on Scheme48, that is undergoing a revival. The Tube, a system for Flexible Distributed Programming using Mobile Code, in scheme.
• Web Sites Discussing Scheme in Action, Research and Education: The website of schemers.org. A bibliography of scheme research. A list of schools that use Scheme in their curricula (from Schemers Inc.).
• Online Books on Scheme: Teach Yourself Scheme in Fixnum Days by Dorai Sitaram. The Scheme Programming Language by R. Kent Dybvig. Structure and Interpretation of Computer Programs by Harold Abelson, Gerald Jay Sussman and Julie Sussman. How to Design Programs by Matthias Felleisen, Robert B. Findler, Matthew Flatt and Shriram Krishnamurthi.
• A R5RS Scheme quick-reference language card (PDF) by Aaron Lahman.

Acknowledgment and Disclaimer

Last updated July 22, 2018