FPGA-based XLR8 (think “Arduino on steroids”) to appear at ESC Minneapolis

Well, as usual, I'm bouncing off the walls with excitement because ESC Minneapolis, Wednesday-Thursday 4-5 November 2015, is almost upon us.

I just spent this past weekend working furiously on my entry to the Capriciously Cunning Chronograph Competition — I'm going to be showing this little beauty off at the Awesome Arduino Show & Tell session (Wednesday from 1:30 p.m. to 2:15 p.m.). If you are planning on attending this presentation, may I suggest you start practicing your “Oohs” and “Aahs” and gasps of astonishment and delight, just so you don’t feel left out.

Max's Cunning Chronograph in music mode
(Source: Max Maxfield/Embedded.com)

The reason I'm waffling on about this here is that the folks from Alorium Technology are also going to be at ESC Minneapolis. And the reason that's of interest is that these little scamps have created an FPGA-based board called the XL8R (“Accelerate” — get it?) that has the same footprint and behaves just like an Arduino Uno on steroids.

The FPGA-based XLR8
(Source: Alorium Technology)

Now, I have to be careful here, because I don’t want to confuse the issue. The regular Arduino Uno has a 16 MHz clock and does things in a certain way. The last thing a user wants to do is swap this out with something that runs much faster, for example, but that doesn't work with any of that user's existing shields. Thus, the XLR8's FPGA has been configured to look exactly like the microcontroller (MCU) powering the Arduino Uno, down to the fact that it also employs a 16 MHz clock.

At this point you may be saying to yourself “But if it walks exactly like an Arduino Uno, and if it talks exactly like an Arduino Uno, then why don’t I just use an Arduino Uno and have done with it?” Ah, but there's more… there's so much more…

Let's start with floating-point math, for example. The Arduino Uno's MCU doesn’t have a dedicated floating-point unit. This doesn't actually stop it from performing floating-point math operations, but it does mean that it has to clunk along using lots and lots of simple instructions, which means it executes these operations verrryyy sslllooowwwlllyyy. By comparison, the XLR8 has dedicated floating-point hardware programmed directly into the FPGA's fabric.

And there's more. One of the things a lot of Arduino users want to do is create robots and control servos. One of the problems is that servicing interrupts can result in “twitching” on the servos. By comparison, the XLR8 has dedicated servo functions that allow the processor to service interrupts without any such “twitching.” Check out this video to see what I'm talking about.

Here we see a regular Arduino clone versus an XLR8, both performing the same task, but one's performing it better than the other (can you guess which one?). The great thing from the user's point of view is that both of these boards are running exactly the same sketch (program) — the only difference being that the original servo library call #include has been replaced with a new #include equivalent.

This has so many implications that the mind boggles. For example, one of the tortuous timing problems I ran into recently was the fact that Adafruit's NeoPixel library disables the Arduino's interrupts whenever it's in the process of streaming data out to the NeoPixels. In turn, this messes up all of the Arduino's timers, which then causes things like the millis() and micros() functions to return erroneous results.

Well, I just got off the phone with Jason Pecor from Alorium Technology. Jason tells me that they are planning on tackling a variety of issues people have with the regular Arduino. And for each of these solutions, the user's programs will remain unchanged apart from swapping out an existing library call with its XLR8 counterpart. For example, since so many people are using WS2812-based LEDs — like Adafruit's NeoPixels — this is a target that's firmly in Alorium's sights, which explains why I'm currently performing my happy dance (avert your eyes; it's not a sight for the young or faint-of-heart).

Jason and his colleagues will be bringing some XLR8s to demonstrate at the Programmable Logic Meet-up (Wednesday from 9:00 a.m. to 10:00 a.m.) and also the Arduino/DIY Meet-up (Wednesday from 2:30 p.m. to 3:30 p.m.), where the latter starts just after the Awesome Arduino Show & Tell. I'm going to be attending all of these sessions — I'm actually hosting the Programmable Logic Meet-up — so hopefully I'll see you there.

Have you registered yet? If not, why not? All I can say is that you'd better sign up quickly before all the good seats are taken!

5 thoughts on “FPGA-based XLR8 (think “Arduino on steroids”) to appear at ESC Minneapolis

  1. “Max, how can you write about FPGAs and Arduinos, and not compare and contrast with the Papilio Duo, which can do many of the same things in a slightly different way?”

    Log in to Reply
  2. “Hi Tony — I love the Papilio and the Papilio Duo as a training tool — and maybe I should have mentioned it — but I see the XLR8 as being in a slightly different space and doing things in a slightly different way.”

    Log in to Reply
  3. “As a arduino newb I have a question. Would moving to a more powerful ARM board correct those jitter problems? Something like a Teensy 3.1/3.2 or a Particle Photon? The teensy is a 72mhz Cortex M4 and the Photon is a 120mhz Cortex M3. “

    Log in to Reply
  4. “Good question — I don't know the answer — I do know that the Teensy 3.1 is brilliant when it comes to dealing with NeoPixels because you drive the NeoPixel strings from the DMA (direct memory access) port and thsi can be happening while the main process

    Log in to Reply
  5. “Max, you're right that one of the benefits of XLR8 is the Uno functionality and form factor, so existing shields and sketches will just work. As far as the servo control, I don't know enough about Teensy or Photon to do a specific, detailed comparison, b

    Log in to Reply

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.