Arduissimo is a MultiCore Arduino project. It is optimized for Virtual Peripherals and is based on a Low Cost FPGA Arduino Board, which is the central element of this project:
The following picture gives an overview of how to use it:
An Arduino board usually has a chip with one processor, program and data memory and a set of peripherals. You can program it using the Arduino IDE or other IDEs like the Atmel Studio and you can use the Arduino language or other languages like C++. You download the program through the USB interface for example.
This is also true for this project. You can use the enhanced Arduino IDE - called the Arduissimo IDE - or alternatives like the Atmel Studio and languages like the Arduino language or C++ as well. The difference is, that you now have 16 processors available and more program and data memory to run your code. You have to run a minimum of 4 processors. The system has a maximum system performance of 140MHz, which means that when you use 4 processors, that each one of them is running at 35MHz. The system boots from the SD-card when applied.
But the performance increase and the
multicore solution are not the only new aspects here. The cool thing
is, that the system is optimized to execute virtual peripherals.
Virtual peripherals provide the functionality of common peripherals
like PWMs, serial interfaces etc, or any other freely user defined peripheral, but they only exist as software
If you want to use the Arduino IDE – instead of Atmel Studio – then don't worry. You can assign individual loops to individual processors or leave the multicore handling to the compiler. It is as simple as using the original Arduino IDE.
An additional frame lets you setup the project directory and structure. You can also define a set of sketch files for your project.
Virtual Peripherals replace fixed hardware peripherals with their functional counterparts in software using software code and standard GPIOs (General Purpose Inputs and Outputs). The concept of Virtual Peripherals is best explained with an example:
The picture shows how signals of a simple serial interface (cs (chip select), clk, data) change over time to transmit data. It becomes clear, that most of the time the signals remain constant. Only at specific time-points they alternate their value. This is indicated with the little vertical arrows at the timeline arrow. These actions can be handled by little software threads which modify the right signals at the right GPIOs at the right time.
This method can become very timing critical when you need multiple (many) peripherals, but you only have one processor for it (and for all the rest). This is where the MultiCore solution of this project is perfect. I has many processors available which quickly execute a thread when needed and then fall into waiting/reset mode again. There is no fixed relation between a series of threads for one Virtual Peripheral and one processor. Threads are executed on the next available processors at a given time-point.The Arduissimo project fully supports Virtual Peripherals, it allows you to use an almost unlimited number of PWMs, I2Cs, SPIs etc. on any of the 124 General Purpose IOs. You can still use the standard Arduino Peripherals (for code compatibility for instance) and you can also use common predefined Virtual Peripherals as easy as writing Arduino code in the Arduissimo IDE. It is also possible to modify existing Virtual Peripherals or define new Virtual Peripherals. You can also use a more professional IDE like the Atmel Studio and other languages like C++ for it, as shown in this picture:
Maybe this MultiCore project optimized for the embedded world, enabling Virtual Peripherals and using standard languages and programming flows is one way how the future might look like. So be one of the very first to support it.
Emulator and Virtual Prototyping
The Arduissimo project provides an emulator. An overview of the GUI gives the next picture.
With this emulator you can debug your Arduissimo code. It lets you set breakpoints and lets you step through the code. You can check out special function register values and display port waveforms. Also a stimulie pattern can be defined. The emulator is open source java code, so anybody can modify and improve :-) it.
Sometimes emulators are limited. This is why this project supports the idea of virtual prototyping. The emulator is based on a cycle accurate C model which is automatically derived from the MultiCore Arduissimo design. This cycle accurate C model can now be embedded in your simulation model of your robot or environment model. This includes the processor and memory model of the Arduissimo processor design as well as the compiled program code. A demo project shows you how.
Low Cost FPGA Arduino (LCFA) Board
Finally, here is the specification of the magic LCFA board we were talking about all the time.
98.5 mm x 60 mm
- Power supply: DC 3.3V - 15V
- Xilinx Spartan-6 LX16 CSG326 -2
- EEprom for configuration file
- High Speed USB, FTDI HS2232HL (13 pins for “245 fifo sync” connected to the FPGA)
- SDRAM Interface 1: 1x 256MBit, 4x 64MBit, 166MHz
- SDRAM Interface 2: 1x 64MBit, 166MHz
- microSD-Card holder (4 pins connected to FPGA)
- 124 IOs:
- 4 IOs: 2,54mm header (e.g. Raspberry Pi)
- 72 IOs: Arduino Mega footprint (44 IOs shared with uPlug)
- 92 IOs: 8 uPlug connector slots (44 IOs shared with Arduino Mega)
- 50MHz oscillator
- Reset switch
- One magic yellow LED
- Power jack connector 2.1mm/5.5mm
- 4 nice bumpers
Raspberry Pi Bridge
There are mounting holes to place the Low Cost FPGA Arduino Board on top of your Raspberry Pi. With the right connectors you can use one of the serial interfaces or the USB interface. There is also an Arduissimo library available so that they can nicely talk to each other via SPI or USB.
In other words, your Raspberry Pi now has a flexible and large number of peripherals, something you might have already dreamed of.
uPlug (an outlook)
You might have wondered what these extra headers and screws are for. They are part of a Plug and Play system called uPlug, which is outside the scope of this campaign, but maybe subject to the next one. To explain the usage of the uPlug slots on the LCFA, the following pictures are shown.
Various modules can be plugged into these slots. This picture shows an example which you could use in your next drone project. It has a video-in, Xbee, a temperature and humidity sensor, a navigation switch, drivers for servos and motors, a GPS module, a Wifi module, LEDs and keys, an SD Card holder for your flight and video data for instance and a 3-axis accelerometer and a 3-axis gyro.
With this example you can control your little robotic car. It has a bluetooth module, two USB master interfaces to control other devices, a DAC, control modules for a stepper motors, DC motors and servos. It also shows loudspeaker, a LCD display, PMOD, Poti, LEDs and Key modules. And everything on top of a Raspberry Pi.
If you want to use uPlug as a prototyping tool, then you can automatically generate the schematic of your system after having prototyped and tested it with uPlug.
The LCFA for FPGA Nerds
The low cost FPGA Arduino board can also be used as a nice FPGA evaluation board. The user can download his own FPGA configuration file through the USB interface. With an additional adapter board, the JTAG pins can also be accessed when a Xilinx download cable should be used.
The 576 MBit (@166MHz) SDRAM memory combined with the HS-USB interface makes this board ideal to be used as a logic analyzer.
Some SoCs from opencores.org – like the MSP430, ARMs or the OpenRisc1200 - are remapped on this board and will be released as open source.
The System Configurator helps you to download a user's bitfile to the LCFA. It also lets you define your SoC to be mapped on the LCFA. This also includes customer peripherals. It does the complete compiling and tool handling for you. Since there is still space available in the MultiCore Arduino design, it allows you to add customer logic to the Arduissimo project.
The LCFA as a "subwoofer":
Last but not least, an FPGA nerd can also combine the LCFA with a standard Arduino (Due, Yun, etc.) and associated modules. This can be easily done by soldering some connection pins and using some screws. This picture shows a possible video frame grabber solution. The video input stream is decoded into digital signals using a uPlug module, the FPGA handles the video bitstream and might use the memories for data storage. The communication to the Arduino Due can be based on any of the serial interfaces for instance. Still there are plenty of IOs available on the LCFA and on the Arduino Due. I'm sure you can imagine the endless possibilities of having the LCFA as a "subwoofer" beneath any of the existing Arduino boards.
This is the official website CloudX.cc, where all the activity around the LCFA board is organized. It covers the Arduissimo related information, uPlug as well as pure FPGA based projects from me and hopefully from others as well. Feel invited.
The motivation for this project is the realization of an idea I had as a student. This idea multiplies the functionality of a design – like the one of a Multi-Processor for example – BUT on a very much reduced area. I was certainly not the only one having this idea, but I had a lot of fun to continue working on this technique and I think it can be very useful in today's embedded world.
I call this now further developed technique System Hyper Pipelining (SHP). This project is all about SHP, and instead of defining yet another evaluation board and compiler flow etc., I made everything Arduino compatible and created an Arduino board with an FPGA on it.
I programmed the FPGA that it provides now 16 Arduino processors using SHP technology.
Although I think that it is really cool to run more than one processor on a very small device like the Spartan-6 LX16, and I'm very proud of demonstrating it, I thought I needed something even more useful to convince you guys. So I developed the concept of virtual peripherals on top of it. Almost all “embedded” programmer emulated any kind of interface already on a CPU and the concept of virtual peripherals is certainly not new, but when you combine it with System Hyper Pipelining, it can be very efficient.
So this project is all about some ideas and about the right mix of various technologies. With this project I want do demonstrate, that you can have a very efficient SHP-based MultiCore solution already on an FPGA and that you as a user can really benefit from it. So once the system is field proven then we can think about making an ASIC out of it. Then it will be faster and even more cost efficient.
The motivation is not “how can I make the Arduino better”, it is more or less “I would like to demonstrate a promising system architecture and I use the Arduino environment for it”.
This project is not as fast as you might expect when you hear the word “MultiCore”. This is because the project is using an FPGA, the third smallest one of a low-cost FPGA family.
It is still a very cool achievement to get 140 MIPS out of this FPGA. Additionally the system architecture (based on System Hyper Pipelining) improves the overall system performance (e.g. less stack handling) to be more efficient than standard bus oriented SoCs.
If this system already proves (almost)
cost efficient on an FPGA, then an ASIC version will certainly be very, very cost efficient.
An FPGA is used, but no synthesis is needed for Arduissimo:
For the Arduissimo solution a “frozen” design is used, means that it is not changed by the Arduissimo user and it will only be changed when a bug is found. Still the nerdy Arduissimo user can add customer designs to use the FPGA entirely for a new design. Only then synthesis is needed.
It is not true that one processor executes one peripheral, so that the number of virtual peripherals is limited. The algorithm of a Virtual Peripheral is sliced into individual threads. A thread is then executed on the next available processor. A Virtual Peripheral does not occupy processor resources when nothing needs to be done.
The LCFA has no Analog to Digital Converter (ADC) implemented. But there are ADC uPlug modules as an alternative.
The Virtual Peripherals do not support high speed peripherals like gigabit Ethernet etc. It is fast enough to drive servos, motors, I2Cs, SPIs and related protocols below the range of 1MHz.
Why Crowdfunding ?
Low Cost FPGA Arduino Board can only be sold if the price is right.
This can only be achieved when a minimum of 400 pieces is
manufactured. To place an order of 400 pieces, I need your help by
supporting this crowdfunding project.
The price of the board is fair:
It is 65 € (~90 $) for the Indiegogo campaign (including German VAT tax).
It will be 69,90 € (~95$) in the shop after the campaign (including German VAT tax).
The Raspberry Pi bridge will be 4,90 € (including German VAT tax).
International and national shipping will be 7€.
hardware can be compared to the “Spartan 6 LX9
Microboard, MicroBlaze” from Xilinx,
which costs me 91,90 € when I buy it at RS-online today (including
German VAT tax and free shipping).
All boards come in a nice and reusable Soft-Pac.
The prototypes have been manufactured so far by a company (X), which I use when only a few pieces are needed. The LCFA will be ordered from a different manufacturer (Y), which is cheaper for higher number of pieces. I already have received boards from them (Y) and the boards were great. Still I would like to order prototypes first from (Y), also because there are still some very minor changes to do for the Low Cost FPGA Arduino board.
This schedule is based on worst case estimations. Due to the relative high investment I planned 2 rounds of prototypes and a relatively long time for assembly and shipping.
2nd Jul '14: Order prototypes A from manufacturer (assembly and shipping time: 35 days).
6th Aug '14: Test prototypes A (7 days).
13rd Aug '14: Order prototypes B from manufacturer (assembly and shipping time: 35 days).
17th Sep '14: Test prototypes B (7 days).
24th Sep '14: Order final product from manufacturer (assembly and shipping time: 42 days).
5th Nov '14: Test and post-assemble final product (7 days).
12th Nov '14: Start shipping final product and release of the Arduissimo IDE.
If everything goes well and only one
round of prototyping is needed, boards can theoretically be shipped
as early as 13th September 2014.
The Low Cost FPGA Arduino Board did go through several versions throughout the last years. The board will go through further testing during the crowdfunding phase. The crowdfunding goal and schedule covers 2 prototype and testing phases. I consider the risk that the boards don't work as low.
The electronic parts of the LCFA are very common standard parts. I don't think that any of these will be discontinued by the manufacturer in the near future.
The Arduissimo FPGA design and the
Arduissimo IDE work. Bugs can be cleared by modifying the source
Thank you for reading the story of this
crowdfunding campaign. If you think that MultiCore Programing and
Virtual Peripherals can be a lot of fun, then please become a
supporter and help us that this project can be realized. Thanks you
so much, again.