Tiny Arduino + FPGA = Sno

Alorium rolled out a new product late last year that caught our attention. The Sno (pronounced like “snow”) board is a tiny footprint Arduino board that you can see in the video below. By itself that isn’t that interesting, but the Sno also has an Altera/Intel Max 10 FPGA onboard. If you aren’t an FPGA user, don’t tune out yet, though, because while you can customize the FPGA in several ways, you don’t have to.

Like Alorium’s XLR8 product, the FPGA comes with preprogrammed functions and a matching Arduino API to use them. In particular, there are modules to do analog to digital conversion, servo control, operate NeoPixels, and do floating point math.

However, you can reprogram the FPGA to have other functions — known as XBs or Xcelerator Blocks — if you like. The only problem we see is that, so far, there aren’t many of them. In addition to the stock XBs, there is one that will do quadrature decoding for dealing with things like shaft encoders. There are a few others you can find on their GitHub page. You can get an idea for the workflow by looking at this tutorial for the XLR8 board.

Of course, you can write your own FPGA configurations as you see fit, but they also provide a standard workflow — OpenXLR8 — that lets you build your own blocks that operate just like their blocks. It would be easy to imagine an “app store” concept where people develop custom blocks and make them available.

We really like the idea of this device and it is certainly inexpensive. You can prototype on the XLR8 which looks like a UNO or you can put headers in the Sno. They also sell a breakout board that will make the Sno physically more like an UNO. We are surprised, though, that there are not more XBs created over the last two years.

The FPGA onboard is similar to the one on the Arrow board we looked at earlier this year, although that has some additional components like SDRAM. If you are looking for a project, it might be interesting to convert our PWM code into an XB.

Thanks to [K5STV] for showing us one of these.

33 thoughts on “Tiny Arduino + FPGA = Sno

    1. No thanks.

      I’ve worked quite a bit with the PSoC4 and 5LP devices. While they do have decent analog peripherals and the ability to route any signal to (almost) any pin is awesome, the programmable logic is just too little to do anything truly useful with. 8-bit data paths to the UDBs is a real head-scratcher of a decision on Cypress’ part as well, but truly, having to use that godforsaken IDE is just the final nail in the coffin as far as I’m concerned.

      Now if you were to take the SiFive core, tack some good peripherals on to it and combine that into this Sno board… That may be something worth pursuing!

  1. An iCE40UltraPlus 5K seems like it would be a better fit for this sort of thing. It has 128KB of on-board SRAM which would be very nice on a small soft-core micro – in addition to 15KB of EBR. The rest of the soft-core program flash could be stored on the same config flash the programmable logic uses. Only comes in one hobby-friendly package though – QFN48. Integrated hard IP (2x I2C, 2x SPI, PWM, timers, etc) and constant current LED drivers are icing. Icestorm has basic support now as well.

      1. I know it is OTP. The config flash I was referencing is external. You only need 100KB or so for the device config at the start of SPI flash. Add a bootloader ROM in EBR to pull in the rest of the soft-core app code from SPI flash beyond that into SRAM. 143KB of total SRAM (15 EBR, 128 single-port) is quite a lot for a small programmable device. MAX10 goes up to 182 KBytes (EBR) on their largest device and only 21 KBytes (EBR) on an equivalent sized device.

  2. The MAX10 is an awesome part, if you need programmable logic.

    However, it’s pricey, compared to a microcontroller. The part on that board comes up at $33 on Digi-Key, qty=1.

    If you’re not making extensive use of the custom logic functions, it’s an expensive way to implement an embedded controller.

      1. The lower end MAX10 parts have loads of restrictions that are not immediately apparent. I’m using a 10M08SCE144C8G and you can’t use the onboard memory as a pre-programed ROM. It also lacks the ADCs and DDR memory interface.

      1. Hi BeagleBoy – which part seems misleading? We have tried very hard to be sure we are clear in the descriptions of what is on our boards. The fact that it’s still a bit confusing is good information. Any details you can share will help us clarify things better. Thanks!

        1. The main product page says “EMBEDDED 8-bit AVR instruction set compatible microcontroller”, and then mentions FPGA-based Xcelerator Blocks, which makes it sound like there is a dedicated microcontroller and separate FPGA extensions. It is clarified on the Xcelerator Blocks page that the microcontroller itself is realized on the FPGA, but I think it’s worth mentioning it on the product page as well. It’s really no big deal though.

  3. From the part number / data sheet – single supply, 169 pins in 11mm x 11mm UBGA package (0.8mm pitch).
    16K logic elements (LE). 12-bit, 1Msps ADC
    External memory: only on devices with dual power supplies (Sorry, no DDR3 SDRAM support on this chip).
    DSP: 45 18×18-bit multipliers

    By using the single supply chip, they don’t need to support high speed SDRAM – or any other high speed interface. That simplifies their design significantly, but is something to consider if high speed is your big reason for switching from microcontrollers to FPGAs.

    1. Years ago I felt like that too. But let’s try a thought experiment. I have a 4 bit number coming in and I want to drive a LED display with 0-9 based on that input. I can draw the schematic out. Might make a mistake or two but it wouldn’t take long. Decode each digit and drive the segments.

      There here’s the code in Verilog:

      reg [7:0] Disp;
      assign {segA, segB, segC, segD, segE, segF, segG, segDP} = Disp;

      always @(*)
      case(BCD)
      4’h0: Disp = 8’b11111100;
      4’h1: Disp= 8’b01100000;
      4’h2: Disp= 8’b11011010;
      4’h3: Disp= 8’b11110010;
      4’h4: Disp= 8’b01100110;
      4’h5: Disp = 8’b10110110;
      4’h6: Disp= 8’b10111110;
      4’h7: Disp = 8’b11100000;
      4’h8: Disp= 8’b11111110;
      4’h9: Disp = 8’b11110110;
      default: Disp = 8’b00000000;
      endcase

      That took no time at all and is easy for almost anyone to look at, understand, and correct. Now imagine doing a 32-bit CPU in schematics (I used to have access to the 68000 family schematics; they covered giant tables and were multiple sheets). Much better to describe using Verilog/VHDL/etc.

    1. real time signal processing/control for one. You can create the VHDL/Verilog for the heavy lifting of some DSP algorithms then write super sloppy code to deal with the results.

        1. Yes. There are a few pre defined functions available. All mentioned in the article. All are available in the arduino ide. You simply choose the block you want to use and burn that bootloader. Once configured you upload your code just like any other sketch with the exception of using the custom libraries instead of the standard ones.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

w

Connecting to %s