All Hail the Evo Compute Module
The Evo Compute Module (small board) mounted on an EvoTray (larger board) (Image source: Alorium Technology)
I was just chatting with my chum Jason Pecor at Alorium Technology. We bounced around from topic to topic with the agility of much younger men. At some stage in our conversation, Jason mentioned a forthcoming product called the Evo Compute Module, which really grabbed my attention.
I'll tell you all I know in a minute (it won’t take long), but first I need to ensure that we are all tapdancing to the same drum beat and that you understand exactly what it is that the folks at Alorium are famous for.
The XLR8
This all started a few years ago when the guys and gals at Alorium announced their XLR8, which is pronounced "X-ell-erate," which leads us to "Accelerate" (and they say engineers don’t have a sense of humor).
The XLR8 has the same footprint as an Arduino Uno and, in its default configuration, it behaves exactly like an Arduino Uno. However, instead of the Arduino's 8-bit processor, the XLR8 boasts one of Intel's flash-based MAX 10 FPGAs, in which the processor is implemented as a soft core.
The FPGA-based XLR8 has the same footprint as an Arduino Uno (Image source: Alorium Technology)
The Arduino Uno's ATmega328P 8-bit processor has a 16 MHz clock, 32 KB flash, 2 KB SRAM, 14 digital I/O pins (of which 6 provide PWM output), and 6 analog I/O pins. In its default configuration, the XLR8 matches all of these specs (you can boost the XLR8's clock speed to 32 MHz officially, and to 64 MHz unofficially, but that's a story for another day).
"So, what's the point?" I hear you cry. As our hero famously said in Dirk Gently's Holistic Detective Agency by the late, great Douglas Adams: "If it looks like a duck, and quacks like a duck, we have at least to consider the possibility that we have a small aquatic bird of the family Anatidæ on our hands.”
Well, the idea is that you can start by taking an existing Arduino Uno sketch and running it on an XLR8 and not be able to tell the difference. Once you are satisfied that all is as it should be, you can begin to unveil the power the resides in the programmable fabric of the XLR8's FPGA.
The chaps and chappesses at Alorium have created a library of XBs ("Accelerator Blocks") that you can use to boost the capabilities and performance of the XLR8. Take servos, for example. One of the problems with a standard Arduino Uno is that when it's servicing its interrupts (the ones it uses to keep track of time), this can result in slight "twitching" on the servos. By comparison, the XLR8 has a dedicated servo XB that allows it to service interrupts without any nasty servo twitches. Take a look at this video to see what I'm talking about.
This shows a regular Arduino Uno and an XLR8, both controlling servos. In turn, the servos are attached to laser pointers that are projecting onto a wall. As we see, the Arduino-controlled servo-laser combo exhibits jitter, whilst the XLR8's servo-laser combo is as steady as a rock.
And how do we access this power? Well, the original Arduino sketch will have a #include command to include the default servo library, <Servo.h>. All we have to do is modify this statement to include the <XLR8Serrvo.h> library; all of the function calls inside the program can remain exactly the same. (The reason I used the "can" qualifier in the previous sentence is that -- as seen in this video -- you can actually add an extra parameter to the function calls to control the speed of the servo's response.)
There's so much more we could talk about here, such as the fact that the regular Arduino Uno doesn’t natively support floating-point operations. This means that if you use floating-point values and perform floating-point calculations, things will really slow down. By comparison, the XLR8 has dedicated floating-point hardware programmed directly into the FPGA's fabric.
Even better, users can create their own XBs to accelerate all sorts of things. All of this means that the XLR8 is not only of interest to hobbyists and makers, but also to the creators of commercial and industrial products and systems. For example, an embedded developer may be looking to enjoy the benefits of hardware acceleration, while an FPGA developer may wish to take advantage of easy access to the vast Arduino ecosystem of libraries and accessories.
The Snō and SnōMākr
Following the success of the XLR8, the folks at Alorium introduced the Snō, which is similar in size to an Arduino Nano. Once again, the Snō is based on one of Intel's flash-based MAX 10 FPGAs; once again, in its default configuration, it acts like an Arduino Nano (you can increase the clock speed from 16 MHz to 32 MHz and even (unofficially) to 64 MHz is you wish); and, once again, you can use Alorium's library of XBs and/or create your own.
The FPGA-based Snō (Image source: Alorium Technology)
Just to increase the fun and frivolity, while many users enjoy the ability to embed Snō modules in their final products, they also like the wide range of shield boards that are available with an Arduino Uno form factor. To address this audience, Alorium created the SnōMākr breakout board.
The SnōMākr breakout board (Image source: Alorium Technology)
You can see the footprint in the middle of SnōMākr breakout board where you would attach a Snō module. Also observe the extra header on the rear of the SnōMākr board. This provides access to the extra 18 I/O pins that are provided on the Snō module.
The Hinj
I don’t know about you, but I'm always interested to hear the origin stories of product names. In the case of the Snō, for example, Jason told me that when it came time to decide on a name for this module, he happened to glance out of the window and noticed that it was snowing outside. You can't argue with logic like this.
Similarly, the Hinj (pronounced "hinge") provides a "gateway" into the development of products for the Internet of Things (IoT). Personally, I think this is a brilliant name. The MAX 10 FPGA in the XLR8 boasts 8K programmable logic elements (LEs); the MAX 10 in the Snō flourishes 16K LEs; and the MAX 10 in the Hinj flaunts 50K LEs.
The FPGA-based Hinj (Image source: Alorium Technology)
The Hinj boasts Integrated Ethernet and WiFi modules with built-in driver support to provide quick and easy connectivity to cloud servers and IoT frameworks. As for the XLR8 and Snō, the Hinj can be programmed using the Arduino's integrated development environment (IDE). It also allows you to take full advantage of Alorium's library of XBs -- and/or develop your own -- to boost IoT sensor data processing and enhance industrial motion control solutions.
The Evo
All of the above brings me to my hot news -- Alorium's forthcoming Evo Compute Module -- which can, of course, take full advantage of Alorium's XB library. At the time of this writing, you won’t find this little scamp on Alorium's main product page, but there is a hidden Evo page.
A tempting taster image for the Evo (Image source: Alorium Technology)
There are several things to note about this image, not the least that this is the first of Alorium's boards that doesn’t implement the processor as a soft core in the MAX 10 FPGA's programmable fabric. Instead, the processor is a standalone Atmel SAMD51 32-bit ARM Cortex-M4 Microcontroller.
Next, the Evo has the same footprint as Adafruit's Feather, which is a rising star in hobbyist and maker space, and which will give the Evo access to the emerging Feather ecosystem.
In addition to programming the Evo with the Arduino IDE, you can also program it with CircuitPython. Also, in addition to the main I/O vias, observe the castellated I/O in the form of the tiny half-vias presented around the outer edge of the board. These provide access to an additional 32 I/O pins, which puts the Evo in a class of its own.
Although using castellated I/O is no big deal when you go into production, I was wondering how one might go about accessing this I/O while prototyping with an Evo. Happily, it turns out that the folks at Alorium have us covered, because they are also planning on providing an EvoTray.
The Evo Compute Module (small board) mounted on an EvoTray (larger board) (Image source: Alorium Technology)
Personally, I think the Evo is going to be of interest to a lot of my designer friends. In addition to having the raw power of a SAMD51 32-bit ARM Cortex-M4 Microcontroller at your fingertips, the fact you can dramatically boost this processor's performance with hardware acceleration in the form of XBs implemented in the Max 10 FPGA is really, really exciting. I look forward to hearing what my designer friends think. I also look forward to hearing what you think, which is why the nice folks at Altium have kindly provided the comment area below (hint, hint).
