I had long wanted to share my lifelong experiences as a professor, professional engineer and programmer with the community beyond the boutique educational environment of Stanford and in a friendly, open way. I planned to start with my Stanford coursenotes and my textbook on MEMS, and branch out into design notes and “how-to” examples for engineers and students of moderate (not beginner) experience levels. Reading below, you might think VoidLoop is yet another Arduino web site, but it is not. It is really about circuits (analog and digital), but somehow these seem to often include an Arduino alternative called a Teensy, as described below.
Having retired from Stanford in 2016 and moved on to an executive role, I found less time to work on this sharing, but as a relief from stress, more time to develop the content. This has been going on for a while, and there are many demos built and notes written, few yet in final, shareable form. (Some of the videos of projects can be seen here: https://vimeo.com/user45644770).
Before diving into all of that, here is a bit about the history. Long before my retirement from Stanford, a former student, awesome person and gifted engineer by the name of Chris Countryman (https://countryman.com) came to visit our family when we were living in Arlington, VA (I can’t remember exact date, but in the 2008 – 2010 range). He gave me a board he had been playing with, an Arduino Uno, and after letting it sit for a long time, I started to play with it. That led to a long relationship with the concept, the IDE, the community and my use of such boards in my Stanford classes.
It was all good, including Maker Faires and such, until the obvious limitations of the 8-bit AVR processor became apparent, while the higher-power but OS-bogged Raspberry Pi boards grew their own community (2000 lines of code to blink an LED, and the timing will not be stable because the processor is running Linux). Ugh! The processors were both molding and limiting their audiences and neither class of board was designed by engineers representing my community. Meanwhile, tons and tons of other boards came out (BeagleBone, LaunchPad, etc., etc.) but none – by orders of magnitude, it seems, achieved the scale of the Arduino, largely due to the IDE being approachable and pre-loaded with hackable examples.
Enter Paul Stoffregen in Portland, OR, and his company PJRC (https://www.pjrc.com). Paul is the developer of the Teensy series of Arduino-compatible boards. They seemed to me to have another backwater set of products in the vast Arduino space until he built the first boards around ARM processors, which blew away performance barriers while maintaining (with pros and cons) compatibility with the vast bulk of Arduino libraries and hardware. I want to give maximum possible credit to Paul (and his wife, Robin) for the meticulous work building on a fairly unplanned community evolution. Those boards got me back in the game with renewed vigor. The Teensy 3.1, 3.2, 3.5, 3.6 and in 2020 the 4.0 and 4.1 brought stunning performance with, in various combinations, performance up to 1 GIPS, on-board analog inputs up to (realistically) 12-bits, tons of memory, hardware floating-point math, etc., etc.
Being a visual person, most of my projects end up producing something you can see (or, hear, but I’ll get to that later). So meanwhile, in the sleepy coastal town of Pescadero, CA, graphics genius James Bowman, a charming Englishman, had been developing graphics devices (“shields” in Arduino parlance) to bring real performance to the Arduino world (https://excamera.com/sphinx/gameduino3/). Well, he succeeded. The Gameduino 3, which is a GPU- and touchscreen-equipped, 480 X 272 pixel color LCD sreen, blew my mind when I demonstrated it with the Teensy 3.6 (256 MIPS, single-precision hardware floating point). More recently with the Teensy 4.0 (1 GIPS, double-precision floating point), the performance is incredible. It is worth seeing the demos for the Gamduino 3 with just a plain-vanilla Arduino UNO (the GPU on the Gamduino 3 is doing the work!), such as: https://www.youtube.com/watch?v=tSzgSJ3qlpE
This inspired me to pursue other ways of getting information (waveforms, spectra, user interface controls) displayed on various devices. You know, the kind of things EE nerds want to see (other web sites cover cat photos and porn, which may have more general appeal).
This led me to experiment with VGA output (allowing tons of leftover computer monitors to be used) via a clever library written by Eric Prevoteau (https://github.com/qix67/uVGA) and only a few external resistors, and with this approach it is possible to generate 800 X 600 pixel video at 60 Hz. (It is worth noting that there is a very nice library for the Arduino Due (https://stimmer.github.io/DueVGA/), but that processor is both expensive and somewhat obscure, so I focused on approaches using the Teensy 3.X and 4.X.)
For retro composite (NTSC) video, Wolfgang Friedrich (Pier 42 on Tindie) designed a nice shield using the VLSI VS23S010D-L chip, which produces 320 X 200 pixel video (a home-brew board with this chip is in the works at VoidLoop). This approach works very well, although some who prefer the more basic Arduino boards can use the well-known TVout library: https://github.com/Avamander/arduino-tvout.
Inspired by the Arduino and later Teensy vector graphics (think Vectrex) demos by Edward Andrews (https://www.nutsvolts.com/magazine/article/tgi-the-teensy-graphics-interface), I also developed several vector graphics output circuits and code for the Teensy family. This is really cool looking if you have a suitable X-Y analog display or oscilloscope.
Finally (this is getting long), I asked James Bowman if it might be possible to generate HDMI output at a low cost, and at this time, his Dazzler (which does just that, at 720P resolution, or 1280 X 720 pixels) is almost ready to launch.
In parallel, the Processing language (Casey Reas and Ben Fry originally at MIT, see: https://processing.org continued to evolve. This language, based on a main loop executing screen updates, is oriented toward development of rich, audiovisual I/O with minimal learning curve and a familiar-looking IDE. Processing provides a way to link Arduino IDE devices to big screens, keyboards, and “real” computers.
All of these diverse graphical output approaches, with their pros and cons, were investigated and over time will be shared on VoidLoop with examples. We have combined Teeny boards, graphics outputs, and mixed-signal circuits from basic through advanced, to create a number of examples that are fun and educational.
It is both the backlog of coursenotes and circuit ideas to share, and convergence of these high-performance embedded technologies that pushed the VoidLoop idea over the top and motivates its development today. The domain name VoidLoop is meant both as an homage to the Arduino and to evoke the notion of creative engineering operating as an infinite loop. Our aim is to evoke the notion that the endless loop of engineering and computer science is the sharing and building upon of clever and useful memes, powered by human effort and kindness. To do so, we plan to provide ideas, educational materials, code and, eventually unique, cost-effective hardware.
Overall, the goal is to lower the barriers for learning while not becoming a tutoring services for newcomers. We want to focus on individuals who have the basics of circuits and programming down, and want something more. With a growing and enthusiastic team, we hope to deliver a growing and well-curated set of resources.
Greg Kovacs
Palo Alto, California, July 2020