Implement a complete SoC on FPGA including CPU (RISC-V core), UART, SPI, VGA controller, and custom digital signal processing accelerators.
Implement a complete SoC on FPGA including CPU (RISC-V core), UART, SPI, VGA controller, and custom digital signal processing accelerators. This comprehensive guide covers everything from design through implementation, testing, and deployment.
FPGA (Field-Programmable Gate Array): array of configurable logic blocks (CLBs) interconnected by programmable routing. Each CLB contains: LUTs (Look-Up Tables, implement any Boolean function), flip-flops (sequential storage), and multiplexers. DSP blocks: dedicated hardware multipliers (fast, efficient). BRAM: on-chip block RAM (18Kb or 36Kb blocks). I/O blocks: configurable voltage standards, differential I/O, SERDES. Configuration: SRAM-based (Xilinx/Altera) — contents loaded from flash on power-up. Anti-fuse (Microsemi) — one-time programmable (radiation-hard for space). FPGAs implement any digital circuit up to their resource limits.
10 components required for this project.
| # | Component | Purpose | Qty |
|---|---|---|---|
| 1 | Digilent Basys 3 (Artix-7 FPGA) or Nexys A7 | FPGA development board | x1 |
| 2 | Xilinx Vivado Design Suite (free WebPack) | Synthesis, implementation, bitstream generation | x1 |
| 3 | VGA monitor | FPGA VGA output display | x1 |
| 4 | Logic analyzer (Saleae or FPGA integrated) | Digital signal debugging | x1 |
| 5 | Pmod accessories (UART, SPI, I2C modules) | Peripheral testing | x1 |
| 6 | PicoRV32 RISC-V soft core | Open-source CPU implementation | x1 |
| 7 | ModelSim / Vivado Simulator | RTL simulation before synthesis | x1 |
| 8 | Constraint file (.xdc) for Basys 3 | Pin assignments and timing constraints | x1 |
| 9 | Oscilloscope (for timing verification) | Signal timing measurement | x1 |
| 10 | Git version control | HDL source code management | x1 |
Follow these 4 steps carefully.
FPGA (Field-Programmable Gate Array): array of configurable logic blocks (CLBs) interconnected by programmable routing. Each CLB contains: LUTs (Look-Up Tables, implement any Boolean function), flip-flops (sequential storage), and multiplexers. DSP blocks: dedicated hardware multipliers (fast, efficient). BRAM: on-chip block RAM (18Kb or 36Kb blocks). I/O blocks: configurable voltage standards, differential I/O, SERDES. Configuration: SRAM-based (Xilinx/Altera) — contents loaded from flash on power-up. Anti-fuse (Microsemi) — one-time programmable (radiation-hard for space). FPGAs implement any digital circuit up to their resource limits.
VGA timing: horizontal sync (hsync), vertical sync (vsync), and RGB pixel data. 640×480@60Hz standard: 25.175 MHz pixel clock. Horizontal: 640 visible + 16 front porch + 96 sync + 48 back porch = 800 total pixels/line. Vertical: 480 visible + 10 front + 2 sync + 33 back = 525 total lines. Verilog implementation: two counters (h_count and v_count) driven by 25 MHz clock. Sync signals asserted during sync periods. Pixel data: ROM containing image data, addressed by (v_count × 640 + h_count). Output: 4-bit R, G, B DAC resistor ladder (4 resistors: 2kΩ, 1kΩ, 500Ω, 250Ω) converts digital to analog for VGA connector.
PicoRV32: compact RISC-V implementation in 750 lines of Verilog. Implements RV32IMC (integer, multiply, compressed). Interfaces: AXI4 or simple memory bus. Integrate into FPGA design: connect to BRAM (program memory + data memory), UART peripheral, GPIO. Compile C programs: RISC-V GCC toolchain (riscv32-unknown-elf-gcc -march=rv32imc). Convert ELF to memory init file. Load into FPGA BRAM. Execute: PicoRV32 fetches instructions from BRAM, executes, accesses peripherals through memory-mapped I/O. Benchmark: ~0.8 DMIPS/MHz. At 50MHz on Artix-7: 40 DMIPS — adequate for embedded control.
FPGA timing: paths between flip-flops must meet setup and hold time requirements. Vivado timing analysis: run 'report_timing_summary' after implementation. Critical path: the longest combinational path (determines maximum clock frequency). If timing fails: Vivado reports offending paths. Fix: pipeline (add registers to break long path), reduce logic complexity, use DSP blocks for arithmetic. Write timing constraints (.xdc): create_clock -period 10.000 [get_ports clk] (100 MHz). False paths: between clock domains, async reset recovery. Correctly constrained design is essential for reliable FPGA operation.
Core code for vga_controller.v:
// VGA 640x480 @ 60Hz controller // Pixel clock: 25.175 MHz (use 25 MHz PLL output) module vga_controller ( input wire clk_25MHz, input wire rst, output reg hsync, output reg vsync, output wire display_on, output wire [9:0] pixel_x, // 0-639 output wire [9:0] pixel_y // 0-479 ); // VGA 640x480 timing parameters localparam H_DISPLAY = 640, H_FRONT = 16, H_SYNC = 96, H_BACK = 48; localparam V_DISPLAY = 480, V_FRONT = 10, V_SYNC = 2, V_BACK = 33; localparam H_TOTAL = H_DISPLAY + H_FRONT + H_SYNC + H_BACK; // 800 localparam V_TOTAL = V_DISPLAY + V_FRONT + V_SYNC + V_BACK; // 525 reg [9:0] h_count = 0, v_count = 0; // Horizontal counter always @(posedge clk_25MHz or posedge rst) begin if (rst) h_count <= 0; else if (h_count == H_TOTAL - 1) h_count <= 0; else h_count <= h_count + 1; end // Vertical counter always @(posedge clk_25MHz or posedge rst) begin if (rst) v_count <= 0; else if (h_count == H_TOTAL - 1) begin if (v_count == V_TOTAL - 1) v_count <= 0; else v_count <= v_count + 1; end end // Sync signals (active low for standard VGA) always @(posedge clk_25MHz) begin hsync <= ~(h_count >= H_DISPLAY + H_FRONT && h_count < H_DISPLAY + H_FRONT + H_SYNC); vsync <= ~(v_count >= V_DISPLAY + V_FRONT && v_count < V_DISPLAY + V_FRONT + V_SYNC); end // Pixel coordinates and display enable assign pixel_x = (h_count < H_DISPLAY) ? h_count : 0; assign pixel_y = (v_count < V_DISPLAY) ? v_count : 0; assign display_on = (h_count < H_DISPLAY) && (v_count < V_DISPLAY); endmoduleTest FPGA Digital Design and Implementation by verifying each subsystem individually before full integration.
Verify power voltages, check ground connections, use serial monitor for debug.
An interactive simulator will be available here — simulate circuits and run code in-browser without hardware.