Posts Tagged ‘step-by-step’

9 Easy Steps to Build a Photosensitive Synth Machine with FPGA

Tuesday, September 27th, 2016

Hello FPGA lovers! Engineering traditional synth machines using development platforms like Arduino and FPGAs is becoming quite the trend now. Today’s post however takes a twist from the traditional synth machines where sounds are produced by either flicking switches or pressing buttons. The synth machine under discussion is a photosensitive synth machine which uses LDRs interfaced with FPGA in place of button switches and this gives an almost touch screen like feel to the device.

The Hardware required is a FPGA board (adaption may be required), 16 LDRs, 16 high value resistors, a speaker, adequate jumpers and 2 breadboards. The entire project has only 2 sets of hardware implementation off the FPGA board. A speaker is directly wired to the FPGA board besides 16 LDRs which function as the photosensitive keyboard. These LDRs work as a 16 bit Keyboard that inputs signals to the FPGA board to convert to sound signals. The connection diagrams and screen shots are given here.

The coding used for the project has been done in VHDL and the author has given the codes in different modules. The note decoder module on Step 2 is one of the most crucial modules in the whole code as it assigns a particular frequency for the 16 bit value from the LDR keyboard. The sound generator module on Step 4 is the next crucial module as it sends the respective frequency (pitch) values to the speaker interfaced with the FPGA.

Through this link you will find the ucf files for the project. This can be modified according to your convenience in case you would like to add more functionality like sustain buttons and other effects.

By Evan_Ashley_Lauren

7-Step Tutorial to Create a Nine Shine LED Timer Game with FPGA

Thursday, September 22nd, 2016

Picture of Nine-Shine-Line: The LED Timing Game

Hello FPGA lovers! FPGAs are versatile tools that can be used for research, analysis, engineering applications and entertainment. Today’s project falls into the last category! The nine shine LED game is an interactive game that tests your sense of timing. It consists of an array of LEDs that are turned on sequentially, and you need to press a button exactly when the central LED lights up to progress in the game. The game has been organised into 10 levels by the author with increasing difficulty based on speed to make it fun and challenging.

The project uses an FPGA along with an array of LEDs. The Hardware required for the project is an FPGA Board, USB-to-Micro cable, Eight LEDs, 8 resistors and a Big Dome Pushbutton. To fabricate the setup board for LEDs, the materials required are a wooden board rubber feet, soldering iron and solder, heat shrink, drill, drill bit, hole saw, hot glue gun and insulated electrical wire.

The coding has been done in VHDL and is available in modules in step 2. The author has explained what each module does and its significance in the FPGA system in this step. Right from the FSMs to the main module, the author has gone to great lengths in explaining the code even in fine aspects such as button debouncing issues.

Read it in full and enjoy!

By Zack Eldredge

Visualize Music with a Muscled FPGA

Tuesday, September 13th, 2016

Picture of LED Music Visualizer with Zybo Board

The Zybo Board is one of the most powerful tools in FPGA and this is because it is FPGA combined with an ARM processor that widens the spectrum of possibilities with FPGA. Today’s post is yet another dive into Zybo’s possibilities and in this project a visualization of audio signals or music will be accomplished. The author has been very detailed about this project and has explained every aspect of it in 18 steps.

The Hardware needed for carrying out this project are the Zybo Zynq 7000 FPGA board, a neo pixel LED matrix, a 5V 10 A power supply, a female DC power adapter, 3 pin male to male header, a 1mF capacitor, an audio splitter and some jumper wires. The connection diagram is provided by the author in step 17.

The code basically uses the principle of FFTs to detect frequency components in the audio file. Depending upon the magnitude of frequencies received, the LED display has been programmed to light up. 16 steps starting from opening Vivado to run the code to generating a bit file for the FPGA has been provided by the author. You can download a zip file which contains all modules relevant to the project. The author has used a combination of C, custom Verilog and HDL to code the project. This gives an ease in defining GPIO ports and makes the circuit a lot simpler.

Another interesting aspect is that the FPGA has been so coded that with the help of switches, your LED matrix can either act as a spectrogram or as a visualizer seen in media players.

Let me challenge you to achieve similar results adapting your own FPGA!

By jtdykstra

Build Your Own Globe of Persistence with FPGA

Thursday, September 8th, 2016

Hey there FPGA lovers! The human eye is far from being perfect, and this imperfection helps us in coming up with a lot of ideas and products (take the television for example!). Today’s post exploits the Human eye’s persistence of vision to build a globe of persistence using FPGA. These globes can be used to build circular LED displays using just 1 column of LEDs which make them highly cost effective and fun to build with FPGA.

The trick when it comes to the globe of persistence is to balance the RPM of the globe and the timing of the LEDs switching colour. The author has shared details regarding the hardware needed for the project in the introduction. An FPGA board (you may need to adapt yours for this project), a neopixel 12 LED strip, a 12 wire slip ring, a photo interrupter and a photo interrupter breakout board, a 12V DC motor, a micro SD card and a cross compiler for ARM processors.

The project also needs an interfacing board for the FPGA and globe which has been explained in step 2. Building the globe’s mechanical structure with the DC motor has been explained in detail in step 5, and soldering the wires in the right way has been shared by the author too.

The author has gone to great lengths to explain how to execute the project. Step 1 gives complete details about generating an FSBL file and a PDF in case you have doubts. The coding for the project has been done in Linux. But even if you are unfamiliar with Linux, the author has explained Linux for FPGA in detail in steps 3 and 4. The code has been broken down to modules, and there are clear instructions available on how to program the FPGA. Step 7 is the final step that explains how to get your globe working, and also gives details regarding building custom applications using the globe of persistence and FPGA.

 Have fun!

By NicolasD3

How to Build an Arcade Obstacle Avoidance Game Using FPGA

Tuesday, September 6th, 2016

Image result for obstacle avoidance game

Hello FPGA innovators! Remember the arcade obstacle avoidance game where blocks of pixels fall on you and you steer clear of them moving left or right? Today’s project attempts to re engineer the same game using a VGA and FPGA. Here, a pseudo random code is used to generate obstacles that fall down and buttons on the FPGA are used to move the cursor so that none of the obstacles hit it.

The only hardware required to execute this project is an FPGA board (you might need to adapt yours if different from the author’s), a computer monitor and connection cables. This is because the FPGA board has inbuilt push buttons that can be used to move the cursor of the game, and also has the necessary DACs and VGA interfaces required to run the game.

The coding done by the author is in VHDL and everything starting from a functional flowchart to running the bit file for FPGA has been described from steps 1 to 9. Since the buttons on the FPGA has a bouncing issue, a separate debouncer code needs to be run which is available on step 2. Details regarding the VGA, coding for random obstacles and checking for collisions and updating the game are given from steps 3 to 7.

Though the authors put in 50+ hours of effort and made a great attempt, the game still could be done in a lot more simpler ways. The main code is available in the introduction to spare other followers from putting in more additional effort, but starting from choosing a different FPGA board to running through basics of other games implemented using VGA and FPGA can end up delivering something better with a lot less effort.

Give it a try and have fun!

How to Create a Visual Audio Spectrum with a FPGA in 5 Steps

Tuesday, August 30th, 2016



Hello FPGA lovers! Today’s post is an interesting one which helps us visualize the audio spectrum with the help of your FPGA and an LED strip. Using a VGA cable, the spectrum can be visualised in a computer monitor as well. The microphone on the FPGA used (you may need to adapt this to your own board) captures the surrounding sounds and uses the FPGA to convert it into a perceivable visual output. The author has explained the principle of working in step 2. The input audio signal is stored in 2 block RAMs. The 1st RAM consists of the time domain representation which is used for display in the VGA. The 2nd RAM consists of the Frequency domain representation using FFT which is displayed both in the VGA and the LED strip.

The Hardware required for this project is a FPGA board, USB A to B micro cable, VGA cable, 30 LED Strip, VGA display (PC monitor) and 3 male to male jumper wires. The author has used the PC monitor as the VGA display for this project. However you can use a dedicated LCD screen or any other VGA display if you choose to. The hardware connections are explained in step 3.

The code is available as a zip file in step 4. The author has dedicated steps 4 and 5 towards installing and generating the program for the board. The language used is VHDL and the code has been broken down into modules. The zip file consists of the source files, a readme file explaining the code, a .tcl file to automatically build the project and the .bit and .bin files for programming the FPGA.


By Mirceadabacan

[DIY] How to Make a FPGA-based Electric Composer

Tuesday, June 28th, 2016


Hello FPGA enthusiasts! Today’s project takes sound production using FPGA to another level. The project under focus is building an electric keyboard/composer using FPGA. The keyboard acts as a song tune composer where a network of switches on the FPGA board is connected in precedence such that while a switch is on, the corresponding note plays.

The major hardware components needed are just a FPGA board (you may need  to adapt this project to your own board), a speaker capable of playing a wide range of frequencies, and not just a monotone, and an auxiliary cable or suitable wires for connecting the speaker to the FPGA board.

The coding has been done using Xilinx ISE in the VHDL (.vhd). The author has given a detailed pin assignment as well as a basic VHDL background explanation. The code has been shared from step 5 to 9 and each module has been well explained by the author. The modules basically consist of a frequency division for playing different frequencies of sound and process statements for fixing parameters like precedence and sensitivity.

Setting the port map and executing the program has been explained in steps 10 and 11. By switching different switches you get different tones, though combinational tones cannot be made since precedence is followed.

The show must go on!

By krosenfeld7

How to Build an Automated Intelligent Room Lighting System with FPGA

Thursday, June 9th, 2016

Hello FPGA lovers! The project in focus today is aimed at creating an Intelligent Room Lighting System with FPGA, where you can bid adieu to the use of switches! The system is powered by an FPGA board connected to a set of LEDs that turn on depending on the number of people in the room. This project has been designed for 8 LEDs, hence 8 people, and when there is no one in the room, the LEDs switch off themselves in 60 seconds.

The materials used for the project are a FPGA Board, 7 LEDs, 7 Resistors, Jumper wires, a micro USB cable and a breadboard. This implementation is a miniaturized model of the actual project, and the things you will need for that are relays, bulbs instead of LEDs, and sensors to detect the number of people in the room.

The author has divided the entire project into 5 modules, whose significance and role have been explained thoroughly from Step 3 to Step 8. This implementation uses the 7 segment display on the FPGA Board used by the author for the 60 second countdown. This saves the cost on buying and interfacing an additional 7 segment display on other FPGA boards, so you may need it. The project uses switches on the FPGA for determining the number of people in the room. This can be replaced with sensors for real scenario cases.

The author has attached a zip file containing the code for the project in Step 9. The code is written in VHDL (.vhd) and has been broken down into modules just like the steps in the project. The code logic is relatively simple to follow and can be easily modified to incorporate sensors and increase or decrease the number of lights in the room.

With the successful implementation of this project in reality, you can light up your room depending on the number of people in it, and completely forget about turning the lights on and off!

By RichardNLe