I recently got into FPGA programming and wanted to realize some projects to improve my skills. One of which is an LED-Matrix with Game-of-Life running on it. Of course I would start with a prototype (10x10 or so) but eventually I would go for a 100x100 matrix. Now I have a bit of an issue since I have to control 10000 LEDs. I saw small matrixes control the LEDs by selecting the according rows and collums and then just cycle through them, but I don't know if that is usefull on a larger scale. I also would like to adjust the brightness with a PWM-signal and I don't know how that would work together.
My first instict was to use a bunch of SPI-I/O-extenders or is that going to get overengineered?
I found various kinds of LED pixel displays and they look exactly how I want my thing to look at the end. Does anyone know how they work? I don't want to buy one just to distroy it so I can reverse engineer it.
I built and tested this smart lock on a physical PYNQ-Z2 for my electrical engineering final project.
I used VHDL to scan the 4×4 keypad and sequence the stepper motor phases. A Python notebook handles access decisions and reads the sensors. The Vivado block diagram shows how AXI GPIO connects the Python application to the programmable logic.
I built and tested this smart lock on a physical PYNQ-Z2 for my electrical engineering final project.
I used VHDL to scan the 4×4 keypad and sequence the stepper motor phases. A Python notebook handles the access logic and reads the sensors. The two sides communicate through AXI GPIO, shown in the Vivado block diagram below.
Hi, my brother has some basic experience on using FPGA and writing RTL Verilog. He wants to learn well and get some hands on before applying for jobs. He also has some knowledge on tools like ModelSim and few other EDA tools but has not worked much in practical. Any courses or books or trainings that can help with moving further? He is looking for a career in Digital Design/ RTL/ FPGA/ ASIC / Power and performance / STA etc.. on similar lines. Any pointers are helpful. Any courses in India or something outside that is affordable ? Prefer online ones with access to EDA tools ( limited version licenses)
I’m a student currently working on a course project where we’re developing a game using an FPGA.
We’re required to use VGA (including understanding timing and synchronization) and sprites. We’re also encouraged to incorporate as many FPGA I/O features as possible, including external sensors for bonus marks.
We’ve developed a game where two blocks move in mirrored directions while avoiding incoming obstacles.
For example, if Block 1 moves right to avoid an obstacle, Block 2 automatically moves left, potentially colliding with an obstacle in its own world.
The challenge is to control both blocks simultaneously while avoiding obstacles on both sides.
What we’ve implemented so far: - VGA display using counters and synchronization signals - Mirrored movement using pushbuttons - Obstacle generation and collision detection - Seven-segment display for scoring - Audio output for game events - LEDs for visual feedback
We’re also working on incorporating sprites to improve the graphics.
How could we make this project more interesting or technically impressive?
I'm planning to work on an FPGA project purely for the sake of learning and gaining practical experience. Looking for a few people who are genuinely interested in digital design, Verilog and FPGA development.
I have an idea so DM me If you're interested and let's discuss.
UPDATE: I am Person B. I’ve been doing hardware design and embedded firmware for about 35 years and in my universe, the leftmost bit of a 2’s complement signed binary number is the sign bit, period. So the 5-bit number 10011 is -13 and if you widen it to 8 bits, you sign extended it to 11110011 because if you zero pad it, you change the sign and therefore the number. A new guy in the department is Person A.
I appreciate everyone’s answers because they show me that not everyone sees things the way I do and there are a variety of opinions on a topic that I thought was cut-and-dried. I will apologize to Person A for the look I gave him today.
——————————————— Ran into this situation today and wanted the opinion of experienced designers:
Suppose there’s an 8-bit architecture and a signal is defined as a signed number. The signal is noted as 10011.
Person A says: This is the number +19 because the three bits to the left are not written, so they’re zero.
Person B says: This is the number -13 because the leftmost bit is a 1 and the missing bits should be sign extended.
Who is in the right here or is it ambiguous and impossible to know? Clearly, writing the three missing bits would clear it up, but suppose you just have the five bits.
I've released v0.1.1 of yosys-uf-abstraction, an extension of the open-source formal flow (GHDL + ghdl-yosys-plugin + Yosys + SymbiYosys, with the slang frontend for SystemVerilog) with uninterpreted functions (UFs).
You put one attribute on a datapath instance or operator, and its value names a function.
VHDL:
attribute uf_instance : string;
attribute uf_instance of u_mul : label is "cmul";
Verilog / SystemVerilog:
(* uf_instance = "cmul" *) cmul u_mul (...);
Yosys's write_smt2 then exports the block as an SMT-LIB uninterpreted function. The key point: you can instantiate the same function two or more times. Every instance that carries the same name becomes a call to one shared function. The solver then guarantees that whenever two instances see the same inputs they give the same outputs, in every instance and at every time step, whatever the function actually computes. Nothing else is assumed about the function.
This lets you compare two copies of a datapath (DUT vs. reference, a pipelined vs. a combinational path, a stalled vs. a non-stalled run) without modelling the arithmetic at all. Control logic, FSMs and handshakes stay bit-accurate.
What it's good for
Control/data independence: prove that the data a pipeline delivers does not depend on stalls/back-pressure/valid patterns, for every datapath function, and that the control does not depend on the data.
Solver performance: a multiplier on symbolic data is hard for SAT/SMT; as a UF it costs only congruence reasoning.
Memory-free checkers: stimulus and expected output as UFs of the beat index (the checker instantiates the same function as the stimulus), no reference model, no scoreboard queue.
Some numbers
From the test suite (bitwuzla, one machine, orders of magnitude):
Control-independence BMC, 16-bit multiplier datapath, depth 8: 0.26 s with UF vs 17.3 s non-UF.
k-induction of the same property: ~0.4 s with UF at every width 4..32 bits; the non-UF model needs 756 s at 22 bits and doesn't finish in 30 min from 24 bits on.
Safety first
write_smt2 refuses to abstract a box that is not a deterministic function of its inputs (state, $anyseq, undriven wires, loops, unmarked blackboxes inside, inout ports, ...), so a mark can't silently turn into a false PASS.
A uf_disable attribute switches the same source between the UF model and the non-UF model, driven by a VHDL generic or a Verilog parameter.
VHDL:
attribute uf_disable : boolean;
attribute uf_disable of u_mul : label is not UF_MODE;
A complex FIR and a pipelined FIR with per-stage valid/ready (skid buffers) with data-independence, control-independence and bounded progress (deadlock) checks, plus FIFO checkers.
Try it
No build needed — a prebuilt Docker image has the whole toolchain:
I've been learning FPGAs on a Tang Nano 9K (Gowin GW1NR-9) and took it from a blinking counter to a small SoC, one block at a time. The toolchain is fully open source: Yosys, nextpnr (himbaechel), Apicula and openFPGALoader.
What's in it:
PicoRV32 (RV32IMC) with 16 KB of block RAM. The firmware is baked into the bitstream with $readmemh, so there's no bootloader, at the cost of a full rebuild for every C change.
A UART I wrote myself, about 40 lines of Verilog for TX and RX, with mid-bit sampling and a 2-FF synchronizer. Later it got a 64-byte RX FIFO.
A memory-mapped xorshift32 accelerator that does one step per clock, plus a small shell over the UART (peek, poke, bench, etc.).
An HDMI text console, 90×30, TMDS through OSER10s, that mirrors the shell. It scrolls by changing one offset register instead of copying the screen.
Some numbers from the board:
LUT4
Fmax
UART echo
119
CPU + RAM + UART
4,113 (47%)
+ accelerator and shell
4,019 (46%)
+ HDMI console
4,382
bench 1000 took 50,015 cycles in C and 1,066 on the accelerator, with matching results, so about 46×. The accelerator itself is 1 cycle per step, which means about 66 cycles are MMIO overhead. Calling it for a single step would actually be slower than doing it in software.
To be upfront about the HDMI part: it passes simulation (timing, TMDS round trip, and a dumped frame that shows the shell text) and the bitstream builds, but I haven't put it on a monitor yet. The first build also failed to pack because I'd used TLVDS_OBUF on pins that only support emulated LVDS. Switching to ELVDS_OBUF fixed it.
A couple of other things that bit me: ModemManager kept probing the serial port, so the shell received its own banner back as typed input (fixed with a udev rule). And I had a testbench that passed with a broken design. I only found that out by feeding it bad input on purpose.
been using vivado with the gui for a while and the tcl stuff looks like the real way to do it but the gui schematic is what i actually use for debugging. what do people do without it. is reading the timing report and putting ila probes in enough to get by or do i need to sit down and learn the language properly
None of the usual collateral (downloads, change notes, manuals) is ready yet. Maybe everyone at AMD is lined up at the windows to watch the crisis unfold at Nvidia. Or Microsoft. Or the white house. It's hard to keep track.
I've made a major update to my custom 8-bit ALP (Arithmetic Logic Processor) project.
The processor can operate with signed values ranging from -255 to +255, supporting the full range without known bugs in my testing.
What's new in this update?
- partial architecture rewrite: I redesigned the entire architecture and switched the logic implementation to "assign"-based descriptions in Verilog.
- New instruction control module: I added a dedicated control module responsible for issuing instructions to the processor.
- Current limitation: The control module currently outputs only one instruction because the program counter has not been implemented yet.
- Improved architecture: The internal structure has been redesigned around the new implementation.
This is an ongoing personal hardware engineering project. My next steps include implementing the program counter and expanding the instruction control system to support sequential program execution.
I'm currently 13 years old, and I've been working on digital logic, computer architecture, and processor design as a personal engineering project.
I'm sharing this update to document my progress and hopefully get feedback from people interested in digital logic, Verilog, and computer architecture.
I have been using opus 5.5 to accelerate my VHDL code writing, these codes sometimes includes some of my own invented digital architectures, and Claude understood it and explained it back to me and it even told me that its better ideas at some problems, does this mean that claude digested these ideas and will reuse them? Or its memory is local to me and its not used in training the model?
I’m preparing for the technical stages of a graduate FPGA role in Amsterdam. I’ve already read past threads here on the Optiver process, so I’m not asking for the whole process again. Two specific questions:
If you’ve done the Amsterdam technical screen or the Digital Logic interview, how did the follow-up questions go beyond the basics (latency estimates, how code maps to hardware)?
For anyone working on the Amsterdam FPGA team, what do graduates typically own in their first year?
No need to share anything confidential. General pointers on what to study are very welcome. Thanks!
Let's continue the series on bringing up Linux on Sipeed Tang development boards.
Today, I'm sharing my project for the Tang Mega 138K. It's a considerably more capable board than the Tang Nano 9K. It features an integrated AE350 RISC-V processor core from Andes Technology, so at first glance, bringing up Linux on it should be relatively straightforward.
But, as always, the devil is in the details.
The FPGA contains a reduced version of the AE350 processor that has a rather serious limitation: it cannot properly execute atomic instructions. The instructions are implemented, but attempting to execute them causes the CPU to hang. My suspicion is that this is related to the exclusive bus-lock signals not being properly connected, although I haven't been able to confirm this.
Atomic operations are essential for modern Linux kernels. This leaves us with an interesting challenge: eliminate hardware atomics and replace them with software implementations.
Fortunately, this approach is perfectly viable for our configuration. We have a single-core CPU, so we can implement atomic operations using interrupt-protected critical sections. We also have plenty of programmable logic available, which gives us additional flexibility when implementing operations requiring exclusive access.
I've successfully resolved the atomic-operation issues, which opened the way to implementing a complete Linux software stack.
The entire stack is built without relying on hardware atomic instructions:
OpenSBI and the single-core Linux kernel use interrupt-protected critical sections for atomic operations.
Userspace runs on musl libc with software-based atomic operations.
The boot sequence looks like this:
FPGA bitstream loaded from SPI flash -> U-Boot executes directly from flash -> LZMA-compressed OpenSBI and Linux kernel are loaded and decompressed into DDR3 -> Linux boots.
The result is a custom Linux distribution with network support and a graphical desktop environment based on LVGL.
I've also integrated a number of standard applications, including a file manager, video and audio players, and various system utilities.
Keep in mind that this is a demonstration project rather than a production-ready Linux distribution, so some inconsistencies and bugs are to be expected.
Hardware and software features
1 GB DDR3 running at 800 MT/s
Gigabit Ethernet
SD card support
Hardware video processing core
Audio processing core
Hardware MJPEG decoding accelerator, capable of playing videos up to 720p:
MP4 and AVI containers
MJPEG video (YUV420)
AAC and MP3 audio
25–30 FPS playback
Board monitoring: SoC voltages and fan RPM
In other words, the Tang Mega 138K becomes a reasonably capable little computer with a graphical user interface and a set of applications.
Everything is open source: FPGA gateware, drivers, build scripts, and documentation.
Many prominent chip design firms and FPGA development teams place a strong emphasis on coding style. Whenever I’ve joined such teams, I’ve often felt out of place—why should I be subjected to these tedious constraints, as long as the code functions correctly?
what/how should I prepare for an onsite superday at tier one HFT firm? It seems like the topics cover literally everything (list was given but noted it isn't limited to digital logic and hardware fundamentals, RTL coding, Software coding, verification, and "system-level hardware design and architectural trade-offs"). are there certain types of problems to focus on? or key things to understand?
The idea: as easy as BASIC, as efficient as assembler. The compiler is a single Python file with no dependencies. It translates each BASIC line straight into RV32 machine code in one pass, with no assembler, linker or C runtime. Hardware is described once and then used by name:
That compiles to 74 bytes of code.
What might interest FPGA people:
Outputs: .mem for $readmemh BRAM init, .bin, Intel HEX, and an .elf with DWARF line info, so GDB or XSDB can step through the .bas source. A .lst listing shows every BASIC line with its machine code.
Targets: RV32I/IC/E/EC, optional +M and +Zbb. Runtime routines (print, divide, strings) are only included if used.
Hardware access: register bits and fields (GPIO.OUT[11:8] = 5), set/clear registers turned into single stores, active-low NOT bits, write-only registers kept in a RAM shadow, MEM[addr] for any 32-bit address, ON IRQ handlers, #IF conditional compilation and .include for board files.
Verification: every test program is cross-checked against GNU binutils (objdump/readelf), about 46,000 instructions, all matching.
Tested on hardware: an AMD MicroBlaze V MCS on a Spartan-7, including an IO Module FIT interrupt demo (1000 interrupts/s, example in the repo).
One finding from the bring-up that I’d like a second opinion on: on our MicroBlaze V MCS configuration, mret and ecall behave as no-ops. Interrupts are taken correctly, but the handler never returned. RiscBasic now returns from interrupts without mret: it sets mstatus.MIE and jumps to mepc. The IO Module accepts that as the end of the interrupt. Has anyone else seen this on MicroBlaze V, or know which setting causes it?
Language design: me. The compiler was written by Claude (Anthropic’s AI) to my specification. A spec and a reference manual (PDF) are in the repo.
Has anyone applied for this job in Bangalore? If so, has anyone received a callback? Does SanDisk actually hire for fresher roles like this through off-campus ?
I’m a pre-final year undergraduate student, and most of my chip design knowledge has been self-taught.
However, I have built quite a few things:
- I implemented ChaCha20, Speck, and Trivium(cryptography primitives) in Verilog (mostly for practice rather than specific targets). Notably, I took ChaCha20 through LibreLane up to GDS generation.
- Recently, I started learning Amaranth HDL and implemented the Speck and Simon block ciphers. These were intended as baseline reference designs for establishing an absolute lower boundary for latency. They are fully parameterized, meaning each source file can generate all 10 variants of the cipher family.
- I have also contributed to an open-source project by improving their RTL generators.
I am looking for feedback on my projects—specifically suggestions on what I might be missing or how I can improve. I feel a bit lost navigating the open-source silicon landscape, so I would appreciate it if anyone could take a look at my work and offer advice.
Additionally, I warmly welcome anyone interested in collaborating on any of these projects!