Mike and Jonathan of ValentF(x) hope to create useful blog posts that serve the purpose of helping electronics generalists to better understand FPGA technology. We hope to create some elementary blogs which walk through basics and then move to working through fun and interesting applications that use common CPU platforms including the Raspberry Pi and BeagleBone while working in conjunction with FPGAs. We hope that this blog serves as a starting point of working from the basics of FPGAs and moving to more complex topics and applications that users are most interested in. Please give us feedback on what you would like to see in the fpga group at http://www.element14.com/community/groups/fpga-group
Here are some thoughts of topics and discussion that might work well for future blog posts, but we hope you ultimately drive where we end up going with this, so let us know!
How do FPGAs fit within the wide world of electronics around us
Understanding the complementary nature of FPGAs technology to widely used CPU technology
Learn how to implement the LOGI Stack of software and drivers to make implementing FPGAs easier for the end user
Walk through examples and applications implementing FPGA technology in order for users to become comfortable delving into their own projects
Implement and walk through LOGI projects such as machine vision, autonomous vehicle control, robotics and more.
Implement and walk through user requested projects.
Field programmable gate array (FPGA) technology is highly contrasting to the more well known and widely used CPU technology. There a key differences between the two which make them very complimentary for use with each other. At the low level, FPGAs are made of transistor configurations which implement logic gates that combine to make combinational logic or flip flops that can then combine to make up register transfer logic (RTL) and the hierarchy and abstractions keeps going up from there. These combinations and abstractions are put together to create CPUs, custom hardware processing modules that are found in application specific integrated circuits (ASICs) and/or the combination of the multitude of digital integrated circuits found on the market today. With the difference between ASICs and FPGAs being that the FPGA can be reprogrammed or configured an unlimited number of times with user defined applications where the ASIC has a single fixed configuration of functionality.
FPGAs are similar to CPUs in that they are able to process data. If a CPU needs to handle tasks A, B and C, it would typically start with task A and move through task B and C in a linear fashion to finish the tasks. As the CPU is given new tasks, the tasks are added sequentially and are processed until they are all finished. The CPU may become loaded with too many tasks that take a large number of instructions to complete, slowing down the processing which may make the CPU unviable for the specific application and tasks at hand. This often happens, for example, in real-time systems where the timing of tasks are critical . The solution would be to either remove some of the tasks or use a faster processor if the users chose to continue using a sole CPU.
If an FPGA had the same tasks, A,B,C, the tasks could be constructed so that each task was being processed at the same time or in parallel within the FPGA fabric. Any new tasks are also processed in parallel so that no additional time is required for the additional processing. Tasks can continue to be added as long as there is enough logic within the FPGA. The parallel tasks can vary from simplistic digital gate logic to more complex configuration that make up high speed digital processing such as image processing and digital signal processing, all being added in parallel without affecting any of the original A,B,C, processes that are running concurrently on the FPGA.
FPGAs are widely used in the electronics industry because of their unrivaled ability to be fully reconfigured to support any number of contrasting applications while not requiring any modification to the PCB hardware or design. FPGAs are commonly referred to as “logic fabric”. This term implies that the logic fabric can be modified, cut, pieced and applied in many different configurations to create customized applications that otherwise might require the design and fabrication of an ASIC (very expensive) or by using a mixture of different discrete logic and/or processing solutions. Many times FPGAs are used in designs knowing that the design requirements will change and the FPGAs would need to be updated to meet the changes without modifying the existing board hardware. The only change that would be required would be for new HDL code to be written and loaded into the FPGA, assuming the inputs and outputs have not changed. In this way, FPGAs are like a chameleon, taking on new colors or disguises to adapt to changing environments.
These examples are not intended to imply that FPGAs are superior to CPUs, but to show that the two technologies operate very differently from each other. Both technologies are very good at doing what they do in their respective processing paradigms. The FPGAs ability to have new functionality added to it without affecting the performance of existing functionality makes it great for applications that require flexibility and expandability. When used together, the qualities of the CPUs and FPGAs complement each other and deliver outstanding results.
The LOGI Boards were designed with key attributes in mind
Overcome the sharp learning curve of working with FPGAs by enabling multiple levels of entry to using FPGAs
Enable users to easily create CPU/FPGA systems using open source drivers, software and HDL for communication between the CPU and FPGA
Create an educational pathway for beginners to understand and proficiently work with FPGAs
Maximum plug and play interfacing with existing hardware using Pmod and Arduino modules
Enable access to fully functional high performance open source projects
The LOGI Apps give FPGA beginners an easy way begin working working with advanced applications very quickly with no need to write any code. The LOGi Apps can run developed highly functional applications by simply typing “sudo make_demo.sh” to run a shell script from the linux command line. The user only needs to plug in any needed hardware modules and then run the script, which builds the source code, configures any drivers and loads the FPGA with an appropriate bitfile to the FPGA. The user then has a fully functional and running application that can be used as is, modified to suit special needs or simply used a reference to understand the underlying source code and drivers. Current LOGI Apps include machine vision, bitcoin mining algorithms, virtual components, logic analyzer, wishbone interfacing and more, See the LOGI Apps wiki page for documentation and a guide to using the LOGI Apps.
For users who want to create their own customized HDL without needing to write a line of code, meet the LOGI Skeleton Editor. Skeleton Editor is a web based graphical HDL composer that can be used to customize and configure projects using graphical components. ValentF(x) has created an array of graphical components that the users can configure graphically within the web based editor to fit their needs. The configured Skeleton project can then be shared, saved or produce the HDL that the user can then synthesize and implement within their LOGI products with support and communication for the CPU platforms. See the LOGI skeleton Editor wiki page for more documentation and a guide to using the graphical editor.
Underlying the LOGI Ecosystem is the LOGI Stack. The LOGI stack consists of software, drivers, firmware and HDL that allows users a seamless interface between the FPGA and the host CPU when using the LOGI development boards. The key to successfully using a mixed CPU and FPGA co-processing system is allowing them to transparently and efficiently read and write data between the CPU and FPGA. The LOGI Stack allows users to quickly create their own CPU/FPGA applications by giving the user easy read and write access, software and drivers to efficiently communicate between the Raspberry PI or BeagleBone and the LOGI FPGA Boards. See the LOGI Stack wiki page for more information. Below is an image of the layers contained within the LOGI Stack.
The most important aspect of working with FPGAs is understanding digital logic, HDL, FPGAs and the concepts of making them work together. In order to create a successful FPGA system from custom HDL requires that the user have a base knowledge of these components. ValentF(x) has created an Educational pathway to working with FPGAs with the LOGI EDU Package.
The LOGi-EDU package is an expansion board board for the LOGi Pi FPGA board. The LOGi-EDU serves as an educational pathway to allow FPGA beginners to easily learn and implement an HDL design within FPGAs. The educational pathway walks beginners through the basic steps of FPGA and HDL design by using examples from the book “FPGA Prototyping By Verilog Examples” or “FPGA Prototyping By VHDL Examples”. The examples can be run by using the add-on EDU expansion module that supports the book examples and applications. Using these examples allows the user to quickly get up to speed with the basics of FPGA design and allows the user to migrate to designing and working on and designing greater complexity FPGA applications.
No matter your experience level, there are fun applications to delve into that use the wide array of available electronics available on the market today. Let the LOGI Boards be your gateway into exploring the latest technologies and in creating fun, high performance, easy to use applications.
The LOGi Boards were designed to allow implementation of many high performance applications in a straightforward manner. Many popular applications are best served by the processing capabilities of an FPGA, including SDR (Software defined Radio), quad-copter control, computer vision, and bitcoin mining, robotics and more. Applications have been created for the LOGI Boards that implement machine vision, bitcoin mining, autonomous vehicle robotic controller using GPS, 9-axis IMU, WIFI, and machine vision to run blob detection and color detection algorithms. These applications are representative of a few of the applications that can be developed by using off-the-shelf components and integrating high performance CPU and FPGA technology.
The LOGI Boards seek to allow as much plug-and-play expansion to existing available hardware as possible by using widely available and low-cost, off-the-shelf hardware. Pmod and Arduino Shields were chosen to be used as standard interface on the LOGI Boards, based on their wide market usage, availability, and cost. There are currently multiple hundreds of Pmod and Arduino Shields available for purchase. Additionally, high bandwidth LVDS interconnects implementing impedance controlled LVDS lines can be interfaced. By using LVDS, such applications as HDMI, SDR, LVDS camera interfaces, and other high bandwidth applications can easily be developed on the LOGi Boards.
ValentF(x) hopes that by bringing together popular CPU platforms with FPGAs, giving users the LOGI Ecosystem of drivers, software and widely available hardware modules will allow for new and innovative applications to be developed by electronics enthusiasts and professionals alike. The LOGI Team looks forward to continuing to create new and in demand CPU/FPGA projects and applications that users can learn from and use to create their own applications.
For more information about the LOGI Boards visit element14 LOGI page or drop by and open a discussion regarding your FPGA thoughts and interests on the element14 FPGA group.