This project implements an FPGA-based RISC-V microcontroller and accompanying firmware, designed primarily for educational purposes. It targets the Arrow MAX1000 development board, along with a custom peripheral daughterboard.

Jump to the Examples section to explore the capabilities of this platform.

The core of the microcontroller is the PicoRV32 CPU, which supports the RV32IM instruction set. It interfaces with memory and peripherals via the Wishbone interface, with a system clock set to 50 MHz for all components.

Communication between the CPU and the components of the microcontroller occurs through a Wishbone bus arbiter. The slave components include a read-only BROM for bootloader, a multi-purpose read-write BRAM, a memory-mapped peripheral controller, and SDRAM. The following table shows the address mapping:

Peripherals consist of both internal and external components. Internal peripherals include UART0 (via the integrated FT2232H chip), LEDs, and timers, while external peripherals include UART1 (via an external USB-UART dongle) and other GPIO.

The internal UART0 is configured to 115200 Bd, while the external UART1 is set to 2000000 Bd for higher-speed communication.

Timer components include three 64-bit runtime counters (nanosecond, microsecond, millisecond) and four general-purpose 32-bit microsecond looping timers.

The following table contains the memory address offsets of all memory-mapped peripherals (base address is 0xC000):

The PicoRV32 CPU features an interrupt controller with 32 inputs. The first three inputs are reserved for internal sources. The following table lists IRQ inputs connected to the previously mentioned peripherals:

Bootloader is the execution entrypoint upon a microcontroller reset. It is compatible with the STK500 protocol used by Arduino UNO, allowing it to be flashed using avrdude programmer.

The bootloader waits for 250 ms after starting, and if no new firmware is being flashed, it jumps to the firmware located in BRAM. It can also be triggered by a UART1 DTR request, eliminating the need for manual intervention.

The firmware comes bundled with Newlib libc and an extensible hardware abstraction library for peripherals described earlier. Similar to Arduino, the code entrypoint is a setup() function, followed by a loop() function. Available HAL functionality can be found in the headers directory.

Code examples for the most common use cases are available in examples directory:

1. Blink LED
2. Seven-segment display hexadecimal output
3. Seven-segment display individual segment control
4. LED control using buttons and switches
5. Graphics rendering on RGB LED matrix
6. Communication over UART
7. Button state processing using interrupts
8. Wall clock using timers
9. Concurrent thread execution with context switching

To set up development environment on Linux, download Quartus Prime 23.1 (or newer), a native C compiler, GNU Coreutils, Python, and cURL. After that, run the following commands in the repository directory:

cd ./common/tools/
make
cd ../../firmware/lib/
make

These commands will prepare the platform develompent tools and libraries.

Next, compile the bootloader and generate the BROM image:

cd ../../bootloader/
make

After this, compile the FPGA design in Quartus Prime and flash it onto the board. The compiled bootloader image will be read during synthesis.

Finally, to build and upload firmware onto the microcontroller, run:

cd ../firmware/
make
make upload

Ensure that the board's UART0 serial port path matches the one on your system.

Output of printf() statements sent to the UART1 can be accessed via Arduino CLI Serial Monitor or a similar tool:

arduino-cli monitor --timestamp --config baudrate=2000000 -p /dev/ttyUSB1

To edit the firmware source code, add or modify files in firmware's source directory.