About this project
What is XLR8?
XLR8 is a drop-in replacement for an Arduino Uno, but with a twist. It is an Arduino-compatible board that uses a Field-Programmable Gate Array (FPGA) as the main processing chip.
The FPGA provides a reconfigurable hardware platform that hosts a clone of an ATmega328 microcontroller. The FPGA also provides the ability to implement custom logic that accelerates specific functionality known to be slow or otherwise problematic for the standard 8-bit ATmega328 microcontroller.
The FPGA-based hardware acceleration and offload provided by XLR8 results in significantly improved performance in the same physical footprint and using the same tool chain as standard Arduino Uno boards.
If you have a project that's using an Uno, you can swap in an XLR8 board right out of the box, and it will just work. You won't even know you're actually running your sketch on an FPGA, at least not until you fire up one of the accelerated functions…and then the magic happens.
Bottom line: XLR8 provides a solution to accelerate your Arduino-based applications and projects.
Why XLR8?
Our team has a lot of experience developing custom processor chips, but we also like to tinker, experiment and build things. Arduino is well known in our ranks as a great platform for Makers.
So, we started thinking about how to take the expertise we have in chip design (ASIC and FPGA) and apply it to the Arduino space. Initially, we were talking about building an FPGA Arduino shield, but quickly decided that the FPGA was "too far away" from the processor to really be interesting. It would take too long to get information back and forth between the two.
We realized that what we really wanted, what would really be unique, what would add the most value, was to have the microcontroller ON the FPGA rather than sitting next to it or attached to it through the standard headers.
And XLR8 was born.
Xcelerator Blocks
An Xcelerator Block is an optimized hardware implementation of a unique processor-intensive function. Since everything needs a cool acronym, we simply refer to one of these blocks as an “XB”.
Basically, an XB is a custom piece of hardware, implemented on the same FPGA fabric as the ATmega328 and tightly integrated with the microcontroller. XBs can access the same register space and even integrate with the instructions of the microcontroller.
The first XB we developed targets floating-point math. So, instead of 100 or more clock cycles to do a floating point add, our custom hardware can do it in 6 clocks. Multiply and subtract see similar improvement, and divide is even better.
And if you've ever been frustrated by that annoying servo jitter when you just want it to be still, our hardware-based servo controller XB provides a rock-steady PWM signal that is more than 15 times more stable than the standard Arduino library.
XLR8 ships with pre-installed XBs that target application-specific behavior, and the board can be field-updated to change the XBs implemented on the FPGA.
We currently have XBs for:
- Floating Point Math
- Servo Control
- NeoPixel Control (in development)
Early feedback from developers indicates interest in XBs targeting functions such as:
- Proportional-Integral-Derivative (PID) control
- Event Counters and Timers
- Quadrature Encoders/Decoders
- Pulse Width Modulation (PWM)
- Multiple UARTS
- Fast Fourier Transforms (FFT)
- Enhanced Analog-to-Digital Functionality
Alorium Technology has plans to add additional XBs and will be developing those and rolling them out soon.
User-Created XBs
Out of the gate, Alorium Technology’s primary goal was to create an FPGA-based board that is a drop-in replacement for the Arduino Uno. It supports FPGA image updates via the USB port, and there is also a JTAG footprint on the board so that more advanced FPGA users could use a JTAG programmer to talk to the FPGA directly.
The ATmega328 core that we have developed has been designed to be easily extendable, and initially, Alorium Technology will provide limited support for users who want to create their own XBs and interface to the on-chip microcontroller. Down the road, we do plan to provide access to enough source code and documentation to make it possible for someone proficient with Verilog or VHDL, and with Quartus II, to create their own XBs. The sky’s the limit on what can be done, and the XBs created this way can be shared with the rest of the XLR8 community.
XLR8 Advantages
Technical Specifications
XLR8 is based on the popular Arduino Uno board, and matches the Uno’s physical footprint, so any mounting brackets or shields that fit Uno will also fit XLR8.
Because we’ve used a 3.3V FPGA as the main chip on the board, the final design will include circuitry for handling level shifting on the I/Os. Electrically, we’ve gone out of our way to be sure that XLR8 is compatible with the 5V environment that Arduino Uno users are accustomed to.
Out of the box, the board has 5V tolerant inputs, and 3.3V outputs. On the digital I/O, the board has pads for pull-up resistors which, when populated, can create true 5V drive capability on these pins.
On the analog pins, we have used an op-amp circuit to emulate the zero-to-5V behavior of the ADCs on the Atmel chips. However, unlike an Arduino board, XLR8 will give correct ADC results regardless of whether it’s powered from USB or from the barrel connector. When a standard Arduino board is powered from USB, it will give incorrect ADC readings due to a reduced 5v supply. Additionally, XLR8’s ADC is higher performing in both speed (1MHz) and resolution (12 bit) than the ATmega ADC, so watch for future XBs that will help users take advantage of this increased ADC performance.
The ATmega core will be running at 16MHz on the initial production boards, the same as on the Uno. However, our timing analysis has shown that the XLR8 hardware should be able to run at least twice that frequency, though there will be some library updates needed to make it seamless for the user. We plan to release updated FPGA images soon to take advantage of the additional performance on the FPGA, which will translate directly to increased application performance.
For the USB-to-serial interface, we use an FTDI chip. The pre-production boards use an FT232RQ, and the production boards will have an FT230XQ on them. Paired with a mini-USB connector, the board has a very similar feel to it as Sparkfun’s Redboard.
Application Examples
This demo shows our XLR8 board connected to a color TFT LCD display via SPI, a 3-axis accelerometer via I2C, and a Neopixel array from Adafruit. Note that this was one of the early demos that we did with XLR8, mostly to show that it can speak SPI, I2C, and can run the timing-critical assembly code routines that the Neopixel library uses. There are no XBs used for this demo, but we are “moments” away from a Neopixel XB that will free up the processor and memory of the Arduino so that you can drive Neopixels, and still do other things with your Arduino. How cool is that?!?
This demo shows the enhanced stability that XLR8’s hardware-based servo control logic achieves compared to the standard software-based library typically used on an Arduino board. The left servo/laser pointer is connected to a Redboard running the software-based servo library, while the right servo/laser point is being controlled by an XLR8 board with hardware-based servo control. The XLR8 solution provides rock-solid servo control compared with the software-based control.
This demo shows how much faster XLR8 can do floating point math than a standard Arduino-compatible board. The fans at the bottom of the tubes run continuously until each board (an XLR8 on the left, and a Redboard on the right) gets a pulse which simultaneously turns off the fans and begins a sequence of floating point math calculations. When the calculations are done, the fans are turned back on. You’ll notice that, with the Readboard, the ball falls nearly to the bottom of the tube before the fan is able to propel it back to the top. With XLR8, the ball only falls a few inches before the fan is able to return it to the top of the tube.
Budget and Goals
Our goal is to be able to do a large enough production run of XLR8 boards that will allow us to offer them for sale at a price that is competitive with other high-end Arduino boards. We believe that we need to be in the $70-$80 retail price range to achieve this, and to make XLR8 attractive to high-end users.We have invested nearly 2 person-years of engineering effort into the development of XLR8 so far. We are continuing to invest, and with your help, we will reach our goal of $50,000 which will enable us to start our initial production run of 1,000 XLR8 boards, and begin to change the world, one XLR8 board at a time!
Risks and challenges
Every engineering development has risks. Some are small, some are big, and some are show-stoppers. We’ve had prototype hardware in our lab since mid-July, and we’re confident that there are no show-stopper bugs. We have found and fixed a number of big and small bugs, and given the level of both simulation and hardware-based testing we’ve done to date, we are confident that we are in the home stretch regarding finding and fixing any remaining bugs.
We have built a couple rounds of protos through one supplier, but we are in the process of evaluating our supply chain for the production builds. We want to be sure we do our diligence and have a good solution lined up. We plan to do a proto run with the new board rev in November to be sure we’re ready for the production run soon after that.
Learn about accountability on KickstarterFAQ
-
We want to make it as easy as possible for all of our supporters to find answers to their questions, so we will keep the website and Kickstarter FAQs in sync.
-
Currently we have a limited number of pre-production boards on-hand, and we will be building a few more of those later in the fall. While our Kickstarter is active, the best way to get a board is to choose one of the rewards that includes shipment of a board.
We are currently talking with partners to provide the easiest and most reliable access to XLR8 boards as soon as we begin our production build, so check back often for the latest on that!
-
It's an Altera MAX10.
-
It’s an FTDI chip. On the pre-production boards, it’s an FT232RQ. On the production boards, it will be an FT230XQ.
-
The short answer is Yes. The long answer is, well, longer…
Out of the gate, AloriumTech’s primary goal was to create an FPGA-based board that is a drop-in replacement for the Arduino Uno, meaning that it is the same footprint, runs the same sketches, uses the same libraries, and is programmed with the standard Arduino IDE. When released, the XLR8 board will come pre-loaded with a few different XBs, and will support FPGA image updates via the USB port, which will enable users to upload images with new XBs supplied by AloriumTech. There is also a JTAG footprint on the board (which will not be populated on the production boards), so that more advanced FPGA users can use a JTAG programmer (the Altera USB Blaster, specifically) to talk to the FPGA directly.
Initially, AloriumTech will provide limited support for users who want to create their own XBs and interface to the on-chip microcontroller. Down the road, we do plan to provide access to enough source code and documentation to make it possible for someone proficient with Verilog or VHDL, and with Quartus, to create their own XBs.
-
The final pricing is still TBD, but expect to see a price in the $70-$80 range for a single board (competitive with other high-end Arduino boards), and volume discounts for larger quantities.
-
XLR8 uses the standard Arduino IDE for programming. You simply select Uno as your board type, then compile and upload your sketch over USB.
-
In order to access XLR8’s floating point hardware, we provide a library that you include in your sketch, but there are some changes required to the floating point arithmetic operations in your sketch, as well. Our library defines functions that directly access the general purpose registers within the processor core, such that the hardware-based floating point operations can be performed extremely fast.
Any floating point operation that you want to accelerate in your sketch (or in any libraries you’re using) needs to be converted into the XLR8-specific function call. For example:
c = a + b;
becomes
c = xlr8FloatAdd(a,b);
Because I’m a lazy typist, I typically do this:
#define xA xlr8FloatAdd
so the line of code I end up with looks like:
c = xA(a,b);
There are similar functions for subtract, multiply, and divide, too. We debated a few different approaches for this, and landed on this one for the time being.
-
8. Which MAX10 device does XLR8 use? What about larger (or smaller) devices as additional offerings?
XLR8 uses a 10M08 device. The smaller MAX10s don’t have enough flash to properly emulate the 328p microcontroller. Larger MAX10 devices could be used, and we may consider those for future boards based on user demand for a larger FPGA.
-
The microcontroller uses about half of the available space on the 10M08 MAX10, so about half is available for XBs.
-
Yes, based on all of our testing to-date, our implementation of the ATmega-compatible microcontroller is cycle accurate with the standard ATmega micro. If we (or someone else) finds a case where that isn’t true, we are treating that as a bug.
-
We don’t have specific plans for that. Right now, our focus is predictable, easy-to-use performance enhancements to the standard ATmega by providing intelligently-designed hardware acceleration that users can access within a well-known development environment. Of course, we are still building our roadmap for future enhancements, so please keep the ideas coming!
-
That’s something that is on our roadmap. Keep in mind that the MAX10 we use is a 0.8mm pitch BGA, so there are definitely some skills required to put it down on a board! But, for those of you with the skills (and the equipment), check back with us soon to learn more about what else we have planned!
-
C/C++ programs can be directly compiled with avr-gcc, makefiles, etc., and uploaded using avrdude over the USB/UART interface. It’s not a path that we use every day, but we do it occasionally. It’s a great way to avoid some of the overhead of Arduino’s built in libraries.
Programming the chip via the ICSP header instead of through USB/UART is not in our short term plans. It would take us some verilog design work to enable that path, but it could be done if there’s enough demand for that capability.
Since we only have the USB/UART path for program upload, the Arduino optiboot bootloader is currently hardcoded into the design. It’s a pretty good bootloader, taking just 256 locations (512bytes) from the instruction memory.
The ATmega’s “fuses” don’t really exist in our design, and the options they control are set to the Arduino defaults.
-
Yes, it should be. Timing analysis of our implementation of the ATmega core shows that it should run at more than double the standard Arduino Uno clock speed. We plan to provide a path for users to access higher clock speeds in future FPGA image updates.
-
The user will see the same program/flash and data/sram memory space as the ATmega328 (32Kbytes and 2Kbytes respectively). Beyond that there is some extra sram on the FPGA that the XBs can use, but that the AVR doesn’t directly see. We don’t have any on-chip EEPROM memory, but the production board design has a spot where an external EEPROM could be added.
-
The Arduino ecosystem supports a number of different processor architectures. Because the AVR core seems to be the most prevalent core, and specifically because of its limitations, we wanted to offer an upgrade path to help Arduino users with a large base of AVR code to dramatically improve performance. Down the road, user demand will help us decide on additional upgrades for XLR8.
-
XLR8 has built-in ADC functionality just like the Uno, but a few of the specifics are different. We don’t have the option for an internal bandgap reference, nor do we have the ATmega’s analog compare function. On the plus side, XLR8 will give correct ADC results regardless of whether it’s powered from USB or from the barrel connector, unlike an Arduino board which, when powered from USB, will give incorrect ADC readings due to a reduced 5v supply. Additionally, the MAX10 ADC is higher performing in both speed (1MHz) and resolution (12 bit) than the ATmega ADC, so look for future enhancements to XLR8 that will make these additional capabilities readily available to users!
Support this project
Funding period
- (28 days)