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!
Hi there FPGA geeks! Power monitoring is a big step when it comes to analysis and subsequent models used for power conservation. The project for today is building an FSM (finite state machine) with a LED as its output and FPGA as its core to measure the power output by the LED when it is active. The IR sensor detects motion and switches on an LED, whose power is measured by the board. This FPGA LED FSM project can be extended to real life scenarios such as measuring the power of fans and other individual electric components in the house to control and conserve power consumption.
The Hardware requirements for this miniaturized model are an IR motion sensor, a LED, a transistor, a FPGA Board and jumper wires. The black box diagram for the project is given in Step3. The wiring instructions are given in Step 8, and the description for the many modules used in this project have been given in the preceding step.
The code has been segregated into modules and has been written using VHDL (.vhd). The VHDL files are available for download from Step 5 along with the XDC master file necessary for the FPGA Board Port Map implementation, you may need to adapt this to your own needs. The code has been written in modules, and can be modified to measure power of any device connected to the board provided its consumption per second is known.
This project can only be used to measure the power consumption of a device for 15 seconds due to circuit limitations. However additional displays and clocks can be used to extend this time frame provided the code has been tweaked on properly.
Hello again FPGA lovers! Today’s project is a challenging one where you build an autonomous search and rescue vehicle with FPGA! The projects involves the use of 2 vehicles, where one searches for the target with the aid of an FPGA, while the other uses minimal sensory aids to follow the search beacon and rescue.
The whole project has been divided into two steps, where the first step contains the hardware requirements. Apart from your FPGA, some of the other materials needed are an LCD screen, infrared thermometer, ultrasonic sensor, Dual DC motor drivers, logic converters, Rotary encoders and even a magnetometer. A detailed list of all used materials, their significance and connections are given in step 1 by the author.
The author has used VHDL (.vhd) for coding, and the code is available here. The zip file has been divided into the binary code and source code. You will find everything you need with detailed modules regarding each hardware part in the source code folder. The code can simply be uploaded onto the board and run for the search vehicle. The rescue vehicle directly follows the search vehicle and needs very little sensory aids.
The project’s documentation, presentation and source code is available here, and you can refer it for a detailed modus operandi of the project. This FPGA work is a combination of a number of interfacing techniques such as LCD with FPGA, DC motor drivers with FPGA and more. It is an apt project to test your mettle in the field of FPGA, and the result is truly worth the effort!
Hi FPGA enthusiasts! Today’s project is a crucial one since it can play a pivotal role in building any major project with FPGAs. The exercise under question is controlling servo motors with FPGA, and this can be of great use on any project that involves servo motors and FPGA. Once you get comfortable with this, you can build anything from claw cranes to terrain rovers using your FPGA.
The hardware you will need is, obviously, your FPGA board, a GWS servo, a PMOD CON3 and a USB A to B micro cable. The FPGA board is incapable of providing the current that will be needed to energize the Servo. This is the reason why the PMOD CON3 is used. While you are free to choose a Servo of your own, you will have to design the code and timing/rotation degrees for it yourself.
The author has done a great job in describing how relevant PWM is in controlling servos. While 10ms refresh periods has been declared a safe bet for most servos, it would be best if you consult the data sheet of the servo you are using. The logic implemented simply consists of a switch to angle converter and a counter which acts as the inputs for a comparator. If the counter value is high, the servo position is held, and if not, the servo switches in 24 degree steps till the condition is met. The interconnections with the FPGA have been shown by the author, and the principle of working has been explained well in step 2 and step 3.
The code for the project has been given in step 4 in a zip file. The code has been implemented in VHDL (.vhd) and broken down to modules. Each module has been implemented with simple logic that will walk you through the entire operation. You can simply generate the bitstream version of the code and upload it to your board once the connections are done as shown in step 6.
Hello FPGA lovers! Today’s project focuses on a key aspect of artificial intelligence and robotics. Robotic Vision is something different from human perception and understanding this and coding for Vision with FPGA can be a great step towards building projects which depend on robotic perception and vision using FPGA.
The materials needed, apart from your FPGA board, are a 2.8” TFT screen, an OV7670 camera board with no FIFO and DuPont cables. The author has added links to all these components in step 1 from where you can buy them directly. Though the interconnections have not been shown in the form of an image by the author, the pin assignments (you may have to adapt this to your FPGA) of the FPGA board in interfacing it with the TFT screen and Camera have been mentioned in step3. The UCF (.ucf) file which contains more detailed interconnections can be obtained from the zip file in step 1.
The code has been broken down into modules and VHDL (.vhd) is the language used. The VHDL files can be found when you open the zip file and each module has a description given on the header. A detailed explanation and working of the code is given in step 4 along with a Top level block diagram.
Once you are done with the interconnections of the camera and TFT with the FPGA, you can upload the BIN file. The code has been designed to detect threshold values of primary Red, Blue and Green colors from an image scanned by the camera. If these threshold values are detected, the screen shows white spots in the corresponding areas and remains black in the other areas. This perspective can help you implementing advanced DSP modules when you build a robot which relies on vision.
Hey FPGA lovers! If you have ever been a fan of arcade games, here is a chance for you to re live the glory days! The LED timer game with FPGA consists of an LED-button interfacing with FPGA. The project is really simple to implement and it is a great first project for FPGA aspirants. The game is similar to the moving light arcade game, where you press a button when a particular color LED glows. As you progress the game gets faster and harder!
The hardware requirements for the project are a FPGA board, Male to Male jumpers, 10 LEDs (9 of which are the same color) and breadboards. The project has been coded by the author for a 10 LED version. The wiring details are given in step 7. However you can extend this to any number of LEDs once you go through the code.
Though any board can be used for this project, the author has shared VHDL codes for Nexys 3. So here you have a good challenge adapting the given code to your FPGA. Another interesting aspect is that you may need to adapt the implementation of the button that is required for the game. So the hardware interfacing not only involves connecting LEDs to FPGA, but thinking a bit outside of the box to get around this minor drawback.
The pieces of software required for this project are Xilinx and Adept. The code has been broken into modules and explained well in step 5. The code consists of a number of modules in VHDL (.vhd) that consists of using the primary button for playing, Display for keeping score and LEDs for driving the game.
The author has done a great job in providing clear instructions and the codes have been written following simple logic. Another major factor is the flexibility in scale of the project where you can implement this game to cover 10 LEDs or even 100s of them. Game on!
Greetings FPGA enthusiasts! Today’s project is a rather exciting one where we will attempt to build a Digitized Version of the popular Tic Tac Toe game with FPGA. This Tic Tac Toe FPGA implementation is pretty simple so this is a great project for a newbie too. So game on!
The Hardware requirements are pretty decent and the cost of this project is quite affordable. The things you will need are breadboards, buttons, LEDs (preferably 3 colors), jumper cables and the your FPGA board.
The entire project is based upon how to build a single LED controller with FPGA, and once you do master this, you can extend it to building your conventional 3×3 array. Once you build a multi LED controller, simply interface them with the FPGA using a XOR network as the author has described. Follow the given steps for interconnections and take care while using the PMOD port since the author did lose a few LEDs to it!
Once the interfacing part is done, you can start programming in VHDL (.vhd) to code the victory conditions. An interesting thing is that these conditions are coded only using 2 “if” loops, but they are substantial in size. An interesting challenge in the project will be to code for “tie” cases. A separate module has been used by the author to reduce the complexity in the code and make it easily decipherable.
If you would like to jump right into the game you can download the zip file in step 10 and implement it using VHDL and the .bit file using Adept. The codes have been well segregated into modules and are pretty easy to understand even if you are new to the FPGA world! Simply wire the components as shown, and download the code into your FPGA board to start gaming.
Hello FPGA lovers! Today’s project is going to be a challenge on mainly 3 fronts. The Project at hand is to build a Hexapod Robot based on FPGA, and the 3 challenges are to get the Hexapod to work with FPGA, design and simulate it with CAD and to carve and glue the parts with plywood. Sounds funny!
The Hexapod Robot basically works on 12 DC servo motors. So if you thought that programming one of those with your FPGA was hard work, then you should definitely try this project to build on experience. The Robot consists of 6 arms, and each arm must have 2 degrees of freedom, the vertical and horizontal axis. For this, 2 motors are used per arm. Other than that, you will need a saw, electric drill, electric grinder, pencil, PU glue, Plywood, screws, nuts, ball bearings and, of course your FPGA board.
But if you are not a fan of all the carpentry work, then you can easily design and print your parts using a 3D printer and then just assemble them.
The Author has sadly not shared the CAD files or VHDL files for this project. However you can leave a request on the comments page to see if you get a response. The different software that you will need for this project is CAD, EDA and VHDL.
Since the VHDL code will be just about controlling 12 DC servo motors with an FPGA, you can use the code here which is the basic module to control one motor. You can simply extend this to 12 motors to get the Hexapod running.
Though the author has not shared the codes, he has been pretty helpful in giving pictures of all the development phases of the Hexapod. You can use these while designing parts in the CAD software.