Forth Module The Size Of A Stick Of Gum

April 25, 2021 by 27 Comments

Australian engineer [John Catsoulis] developed a small module called the Scamp2 dedicated to running Forth. The focus of his Udamonic project was not only to highlight Forth, but to make a module which was easy to use and doesn’t require any IDE on your computer. According to the website, these modules have found their niche in education as well as rapid prototyping for product development. His site has some good resources, including several Scamp/Forth example applications such as a model train controller or adding a real-time clock module.

The core of the module is a Microchip PIC24F64GB202 MCU with 64K Flash and 8K RAM. Of this, Forth takes up only 20K of Flash and 2K of RAM. [John] is using FlashForth, a version of Forth which came from [Mikael Nordman] at the University of Queensland almost ten years ago. FlashForth has been implemented on a wide variety of PIC and AVR ATmega processors and has apparently developed quite a following in Australia and elsewhere.

We estimate from the photo that the Scamp is about 80 mm long, just slightly longer than a standard piece of MIL-A-A-20175A Type II chewing gum ( 73 mm ). You can use it as-is, or with the header pins installed, the Scamp can be plugged into a breadboard for easy hacking. Regarding the interfacing of Scamp to other equipment, [John] says “Writing software to use other hardware is very easy, and fun.” We like his attitude.

Here is some more information from his Hackaday.io project page, and he also has a Tindie site. If you want a good overview of using Forth in embedded systems, check out Forth: The Hacker’s Language by our own Forth-guru [Elliot Williams]. Thanks to [Stephen Walters] for sending in the tip.

Continue reading “Forth Module The Size Of A Stick Of Gum” →

The Back And Forth Of Windshield Wipers And Patent Lawsuits

April 23, 2020 by 50 Comments

Who among us hasn’t dreamed of having some brainstorm idea, prototyping it, and then have some huge company put it into worldwide production? The problem is, that’s not really as easy as it sounds in most cases. Take the case of Robert Kearns. Never heard of him? You use the result of one of his patents pretty often; Kearns invented the intermittent windshield wiper.

If he had sold the patent to one of the big carmakers, this would be a short article. Not that he didn’t try. But it didn’t go very well and while, in the end, he prevailed, it was a very expensive victory.

Continue reading “The Back And Forth Of Windshield Wipers And Patent Lawsuits” →

Pocket Forth Invades Your TI Calculator

January 25, 2019 by 7 Comments

TI certainly have certainly seen off rivals such as HP or Casio to capture the lion’s share of the calculator market. The TI-84 is a real staple, and with as many units as there are out there, hacking them is a given. However, selecting an operating system for the machine can be a hassle. TI-OS is proprietary and doesn’t really want to let you do everything you’d like to. There are alternatives, but many of them won’t let you easily use your calculator to be — well — a calculator.

[Siraben] has zkeme80 which is essentially ANS Forth (mostly) with extensions for the TI hardware. You can easily extend the system, of course, because it is Forth. You can also use the machine for its intended purpose easily.

Continue reading “Pocket Forth Invades Your TI Calculator” →

Web Pages Via Forth

August 2, 2018 by 16 Comments

Forth. You either love it or you hate it. If you have struggled to work on tiny microcontrollers, you probably are in the first camp. After all, bringing up a minimal Forth system is pretty simple and requires very little resources on the CPU. Once you have such an environment it is then easy to extend Forth in Forth. [Remko] decided he wanted to build a Forth compiler that uses WebAssembly and runs in your browser. Why? We’ve learned not to think about that question too much.

The world has changed a lot since the first introduction of the WorldWideWeb browser in 1990. What started out as a way to show text documents over the network has become — for better or worse — an application platform. JavaScript won the browser scripting language wars and security concerns pretty much killed Java applets and Flash. But JavaScript isn’t always fast. Sure, there are ways to do just in time compiling, such as Google’s V8 engine. But that compile step takes time, too. Enter WebAssembly (or Wasm).

Continue reading “Web Pages Via Forth” →

Forth Version 1 Runs Again

March 27, 2018 by 23 Comments

Some people love Forth and some people hate it. However, you usually think of Forth as something running on a little computer such as an 8-bit microcomputer. When [Chuck Moore] developed the system back in the 1960s though, it ran on an IBM 1130. [Carl Claunch] took a scanned listing of the original code and got it running once again.

There are actually a few blog posts with details. Luckily, Forth is pretty simple — especially the core parts. However, there are a lot of differences from a modern Forth. The most obvious is that the dot keyword starts a definition and does not print the top of stack. However, internal details are different too — the system, for example, stores characters in packed EBCDIC — an ASCII-like code used by IBM computers.

Continue reading “Forth Version 1 Runs Again” →

Forth System-On-Chip Takes Us Back To The 80s

February 22, 2018 by 66 Comments

For anyone who has dealt with the programming language Forth, odds are good that you picked it up back in the 80s. Since the language is still in use for many applications, though, you might not have this sort of nostalgic feeling for the language that some might have. For that, though, you might want to try out [Richard]’s implementation which simulates the microcomputers of the 80s using this unique language.

The system has an FPGA-based CPU written in Verilog. It runs on a Nexys-3 board and features PS/2 Keyboard input, a VGA output with a VHDL VT100 terminal emulation module, access to the Flash and onboard SRAM, and a UART. With all of that put together it’s virtually a Forth-based time machine. It’s also extremely well documented even if you’re just curious how it works and aren’t planning on building your own.

The project also includes a CPU simulator written in C which can model the entire computer if you don’t have the hardware for building the actual computer. [Richard] also released everything that you’d need to roll out your own Forth computer on the GitHub page. There are other ways of heading way back to the 1980s, though, like using the quirky Parralax Propeller.

Take The Blue Pill And Go Forth

August 4, 2017 by 38 Comments

Forth has a long history of being a popular hacker language. It is simple to bootstrap. It is expressive. It can be a very powerful system. [jephthal] took the excellent Mecrisp Forth and put it on the very inexpensive STM32 “blue pill” board to create a development system that cost about $2. You can see the video below.

If you have thirty minutes, you can see just how easy it is to duplicate his feat. The blue pill board has to be programmed once using an STM32 programmer. After that, you can use most standard Forth words and also use some that can manipulate the low-level microcontroller resources.

Continue reading “Take The Blue Pill And Go Forth” →