HELLO FPGA Kit - Review

Table of contents

RoadTest: HELLO FPGA Kit

Author: dang74

Creation date:

Evaluation Type: Independent Products

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: The Altera NIOS II Embedded Evaluation Kit from Terasic is similar in that an LCD is included. But unlike the Hello FPGA Kit, the FPGA on the Terasic product does not include an embedded ARM processor.

What were the biggest problems encountered?: Initially I had some difficulty setting up the software project. More detailed instructions would have been beneficial.

Detailed Review:



The Hello FPGA Kit is a development platform that includes camera and LCD modules.

Its principal PCB features a SmartFusion2 SoC device which combines an ARM Cortex M3 core with FPGA fabric.


Why I applied for this Road Test


It's been some time since I worked with FPGAs so I applied for the road test as a way to brush up on my skills.

Also the combination of ARM core and FPGA on a single device was really exciting to me.


The Unboxing


Opening the box reveals the LCD.  A  mini USB cable is also included.



The Hello FPGA kit is actually a stack of 3 boards.


On one side you'll find the camera module:



On the reverse side you'll see the LCD module:



Sandwiched in the middle you'll find the FPGA Board.



Running the Demos


Microsemi has prepared 3 demos for the Hello FPGA Kit.

The demos are run through the Hello FPGA GUI.


FIR Demo


I began with the FIR demo.  In this demo the user configures a filter as well as an input signal for testing the filter.

In my case I configured the filter to have a 20MHz lowpass response.  I set up the input to have a 15MHz tone and a 40MHz tone.


The figure that follows shows how the filter allows the 15MHz tone to pass while rejecting the 40MHz tone.




Camera / Display Demo


In this demo the image captured by the camera is displayed on the LCD.

In a sense this demo is more of an intermediate step to set up the next next demo.



Digit Recognition Demo


The third and final demo deals with image recognition and of the three demos this one impressed me the most.

The photo below shows how this demo works.  The camera is pointed to a handwritten number 1.

If you look at the green text on the LCD's lower left hand side, you will see that the number 1 is being correctly recognized.





Libero SoC and the Design Flow Pane


After running the demos I acquainted myself with Microsemi's Libero SoC tool.  The learning curve here was not too bad.

Perhaps my favourite part of the tool was the Design Flow pane which allows the user to easily navigate through the different stages of the design.

Check marks are used in the Design Flow pane to signify when a particular task like synthesis or place and route has been completed.



Smart Design


Smart Design is a graphical design entry method supported by Libero.

IP blocks are dragged into the Smart Design page and wired up to create your system.

The image that follows is a simple Smart Design block I developed for toggling an LED.




The block labelled MSS_C0_0 is the microcontroller subsystem.

If you double click this block the Smart Design for the microcontroller opens. (Refer to the image that follows).


You can use the microcontroller's Smart Design to configure peripherals like I2C, GPIO and Ethernet.




Exporting Hardware Drivers


Once you've created your SoC design you can use Libero to export the software drivers as shown below:




Soft Console IDE


The Soft Console IDE is used to develop the software solution for your design.  The particular version I downloaded was Soft Console 4.0.

This is the stage where I struggled the most.  Microsemi did not provide clear instructions on how to create the software project or how to properly import the drivers.


I spent a number of nights working through a series of linker errors.

I understand that Microsemi is targeting beginners with their Hello FPGA product so the absence of information instructing the user on how to design with the kit was an oversight on their part.


I Wrote a Tutorial


When I finally figured things out I decided to write a tutorial to guide others through the design process.


The tutorial encompasses the steps that need to be carried out in Libero and Soft Console and concludes with the procedure for programming the design onto the Hello FPGA board.


The tutorial is available here: https://github.com/Dan-Grise/Hello-FPGA-Blinking-LED-Tutorial



Experimenting with the LCD


To me the most interesting part of the design kit is the LCD.  Once I had a decent understanding of the toolset I decided to start experimenting with the LCD.

The top level Smart Design for this is pictured below.  Like our previous example MSS_C0_0 is the microcontroller subsystem.


The blocks to the left are standard cores for system reset and clocking.

The core immediately to the right is used to decode and distribute the microcontroller's advanced peripheral bus.


LCD_DISPLAY_0 as its name implies provides the LCD with the image to display.

I did not design the LCD_DISPLAY_0 block.  Instead I imported it from the DSP example design used in the FIR demo.




LCD_DISLAY Smart Design


Double clicking LCD_DISPLAY_0 reveals its Smart Design (see image below).


Initially the microcontroller configures the display's ili9488 controller.

During this stage the MUX is set to output data originating from the advanced peripheral block.


The microcontroller writes the image data to port A of the dual port RAM.

When configuration is complete the MUX will output data from port B of the dual port RAM causing the image to be displayed.




The Software Design


I made like a bandit and lifted much of the LCD code present in the FIR demo code.

I made sure to include the ili9488.h file.  This file and ili9488.c were obtained from the FIR demo design and contain the functions and routines for controlling the LCD.




You might be curious about the clara.h file.  This is a 16-bit bitmap expressed as a C array.


The first few lines look like this:




In all we have a 120 x 80 array of 16-bit words, with each 16-bit word representing a pixel.


The actual LCD is 480 x 320 pixels.  Originally my intent was to use the full resolution of the display so the array was initially 480 x 320.

The compiler was not happy with this so I opted for 1/4 resolution instead.


The main function appears below.


While the ILI9488_init function is executing the MUX directs data from the microcontroller to the LCD.

While show_image is executing the MUX directs data from the dual port RAM to the LCD.



There's one final thing to discuss with regards to the code.  Below you see the nested loops for sending out the pixel data.


At first glance it will appear that we are using the full 480 x 320 resolution.

However, if you look closely at how the index is determined you will see where the low resolution comes from.



Displaying LO RES Clara


So without further ado here is the Hello FPGA kit displaying the image:




Future Goals


I want to continue working with the LCD to see if I can achieve the following:


  • Full 480 x 320 resolution bitmaps
  • Create tile based graphics system
  • Create moving sprites and animations




The Hello FPGA kit is an impressive design platform that includes LCD and camera modules in addition to Arduino compatible connectors.

Its principal board has an SoC device combining an ARM core with FPGA fabric.  The possibilities with this platform are endless.


I had a lot of fun getting to know this product and look forward to exploring it further.

With that said I still think Microsemi needs to do a better job creating tutorials and perhaps instructional videos specifically targeting the Hello FPGA kit.

This will allow them to fully realize their goal in making this product accessible to beginners.


It will be interesting to see what the future has in store for this platform.

I look forward to seeing future developments from Microsemi and the design community.

  • Hello again, have you been able to setup the 1GB DDR3 memory on the board (Micron MT41K1G8RKB-107:N)? I am not sure what all the parameters in the Libero SoC memory configuration are (the datasheet is here):



  • Sorry for not getting back sooner.  If I remember correctly, getting serial coms to work between their GUI and one of my own apps remained elusive to me.  I see that in the last few hours you unlocked some of the secrets for that.  I am typing this from a cell phone.  I'll check out your code later on when I am logged onto my PC.   I agree with you that Microchip would be better served by expanding their documentation and examples to better serve customers of this board.

  • So, after few more hours of experimenting I learned few important things about the programmer PIC32 onboard:

    • It seems the forwarding of UART messages is disabled on startup and to enable it host (PC) has to send 'h' character first. I noticed the ASCII characters ('handshaker') which are exchanged by host and the DSP demo (in the MSS SoftConsole project included) immediately after MSS_UART_init(). I found out that the rest of the string doesn't have to be exchanged, in fact the MSS app only has to wait for 'h' from host.
    • The MSS app must not send anything to the host before receiving 'h', otherwise the forwarding stays disabled.
    • If you close the GUI with the forwarding enabled and then try to reconnect to the COM port, it throws error message "Unable to communicate with the Hello FPGA board !!! ..." and you have to power the board down and up first.

    Just add a while cycle waiting for 'h' before any TX operation, for example like this:

    size_t MSS_UART_polled_rx(mss_uart_instance_t * this_uart, uint8_t * rx_buff, size_t buff_size)
    	size_t rx_size = 0U;
    	volatile int x = 0;
    	while(rx_size < buff_size) {
    		while (((this_uart->hw_reg->LSR) & 0x1) != 0U) {
    			rx_buff[rx_size] = this_uart->hw_reg->RBR;
    	return rx_size;
    // [...]
    uint8_t recv;
    while(!(MSS_UART_polled_rx(uart1, &recv, 1)) || recv != 'h');

    I still don't understand why there is no documentation of the embedded PIC32 programmer or at least firmware source code, there is only firmware hex file (shame on you, Microchip!). So a lot about this board still remain a mistery, eg. it is still unclear how to toggle pin 76 of PIC32 (JTAG_SELECT) to use an external programmer (ULink2 or J-Link) using the JTAG header.

  • Thanks very much for the tutorial, I am finally able to flash the Cortex-M3 program (I am using Keil uVision). But I am struggling to get MSS UART working. I modified your tutorial main.c code this way:

    #include <stdio.h>
    #include <stdint.h>
    #include "drivers/mss_sys_services/mss_sys_services.h"
    #include "drivers/mss_uart/mss_uart.h"
    #include "drivers/mss_gpio/mss_gpio.h"
    #include "drivers/mss_timer/mss_timer.h"
    #define CYCLES_PER_MS (F_CPU / 1000)
    #define RX_BUFF_SIZE 64
    void delay_ms(uint32_t ms){
    	MSS_TIM1_load_immediate(CYCLES_PER_MS * ms);
    	while (MSS_TIM1_get_current_value()); //while counter has not reached 0
    const char* hello_world = "Hello World from Hello FPGA kit!\r\n\0";
    uint8_t rx_buff[RX_BUFF_SIZE];
    void uart_rx_handler(mss_uart_instance_t* handle)
    	MSS_UART_get_rx(handle, rx_buff, sizeof(rx_buff));
    	MSS_UART_irq_tx(handle, rx_buff, sizeof(rx_buff));
    int main(){
    	MSS_UART_set_rx_handler(&g_mss_uart0, uart_rx_handler, MSS_UART_FIFO_SINGLE_BYTE);
    		MSS_GPIO_set_output(MSS_GPIO_0, MSS_GPIO_DRIVE_LOW);
    		MSS_UART_polled_tx_string(&g_mss_uart0, (const unsigned char*) hello_world);
    	return 0;

    It should do a simple echo on UART0 line + send the hello world string every 2 seconds. But in any serial terminal (I tried the embedded one in the Hello FPGA GUI and also HTerm) there are no messages being received or echoed back, I tried multiple different baudrates.  Have you had the same issue or am I doing something wrong?

    Thank you for an answer.

    EDIT: I checked with logic analyzer that the GUI is communicating using UART-USB MCP2221A with PIC32 at baudrate 460800 (measured at RX pin 6 of U5), then PIC32 communicates with M2S (measured at U4TX pin 48 of PIC32) at baudrate 230400. Characters sent using the GUI are sucessfully delivered to M2S (I toggle LED in uart_rx_handler function). The opposite way (to host), when measured at U4RX pin 47 of PIC32, the message is delivered from M2S to PIC32 also successfully, but PIC32 doesn't send anything to the USB-UART bridge. Why? Should I send some command character using UART first to make PIC32 forward the message?

  • When I imported the LCD_DISPLAY_0 block I had to rewire some of the connections.  It is possible I made a mistake or skipped some step which caused the 'wires' to be disconnected.  This is an area I will look further into.

  • Yes, they make is sound easy and you get a free board.


    There is no such thing as free. Everything has a cost and a good road test is hard work.



  • Thanks for your review

    One question. How easy was it for you to reuse/import some of the existing projects blocks (e.g. "LCD_DISPLAY_0") into your own designs?


  • DSP is an important market sector for FPGA vendors so that may have played a role in why the FIR demo was developed.  The other two demos that utilize the camera and display are definitely more representative of the Hello FPGA Kit's capabilities.  

  • Thanks for the explanation, I rather expected that but it seems such a lame demo from Microchip,  I was hoping for better. After all, one could do exactly the same thing without the FPGA.


    I did notice that you manged to get something out of the demo code by using it in your own display interface.


    Thanks again for the review.



  • Thanks.  When I first applied for the Road Test I didn't realize how much work was involved.  So its nice to read your kind words of support.