Introduction to Speedgoat FPGA Technology
Christoph Hahn, Speedgoat
Speedgoat FPGA I/O modules are used to acquire, process, and generate high-frequency signals in real-time applications. Use pre-configured Simulink^®^ driver blocks, or program the FPGA by using HDL Coder™. Use Speedgoat FPGA Code Modules for standard I/O and protocol needs such as generating or capturing fast PWM or encoder sensor signals. Discover how you can work with code modules and other ready-to-use functionality to get started, even if you are not an FPGA expert. Also, find decision criteria to help you choose the best approach forward.
Hi there. My name is Christoph, and I'm with Speedgoat. In this video, I want to introduce Speedgoat's FPGA solutions. I will modivate why using FPGAs can be beneficial for your work, and show you what Speedgoat FPGAs can do. Most importantly, I will show you how you can make FPGAs part of your workflow. And finally, I will give an introduction about how FPGAs work and what makes them so powerful.
Speedgoat Real-Time target computers are equipped with powerful multi-core CPUs, capable of handling most performance demanding applications. For some applications though, you may need to accelerate your algorithms and offload them to FPGAs. For example, if you want to control high-dynamic systems, you may also want to access and process multiple high-bandwidth signals simultaneously at ultra low latencies.
Also high-fidelity plant models may need to be offloaded to high performance FPGAs. Last, but certainly not least, you may use FPGAs as a cost effective deployment path for your final application such as an Application Specific Integrated Circuit or ASIC for short. Now let's have a look at what Speedgoat FPGAs are capable of. You can target them directly from your Simulink model, either by configuring an FPGA driver block and then simply hitting run on target. Or with a programmable workflow using HDL Coder and HDL Code device.
This is when you're planning to run parts of your Simulink model on the FPGA. You even have a streamlined path for deploying simscape models to FPGAs via the simscape HDL workflow advisor. Sometimes only the I/O of your model needs to run faster. For instance, you may want to generate or capture fast PWM or encoder sensor signals. And even if you are not an FPGA expert, there's no need to worry. Speedgoat offers you ready-to-use FPGA I/O and protocol functionalities, so you can focus on your application. You can connect multiple FPGAs using lowest latency links, operate several of them on a single or on multiple real-time systems. You can also use FPGAs to synchronize multiple real-time machines and data acquisition with other I/O modules.
Now, let's have a look at Speedgoat's FPGA workflows. Speedgoat offers two types of FPGAs, configurable ones and Simulink programmable ones. Configurable FPGAs allow you to use high frequency I/O and lots of protocols without FPGA programming knowledge. There are many code modules represented by Simulink driver blogs. And you can configure your FPGA on the fly and directly from Simulink. Speedgoat provides you different configuration files. So that you can get the best performance out of the I/O module for dedicated applications.
FPGAs can also be used to schedule execution of subsystems, the entire real-time application and a set before individual I/O modules or even to synchronize multiple target computers. Programmable FPGAs allow you to outsource both parts of your algorithm and signal I/O to the FPGA using the HDL Code of workflow from within Simulink. Speedgoat provides you with ready-to-program I/O and protocol driver blocks. So it doesn't necessarily become more complicated because you can leverage and start rapidly using hardware proven examples. Ultimately you have more flexibility for your advanced use cases.
Several FPGA I/O modules allow using both workflows. So it's possible to start simple with a configurable workflow and evolve to the programmable one as you go. Regardless of the workflow, Speedgoat FPGAs work like any other I/O module and can be reconfigured. But how can you tell if your application in real-time system requires an FPGA performance boost? Sample rates are typically a very good measure for
you to decide if FPGAs are required or not. If your application has a simple time larger than 1 millisecond, you have absolutely no problem using solely our CPU technology.
For sample rates let's say higher than 250 microseconds, we suggest to check for fast I/O modules. If you take a shorter sample times, Speedgoat will help you to investigate. Quite often faster I/O modules and configurable FPGAs may already help a lot. If simpler times are below 50 microseconds, it starts to become worthwhile to run parts of the I/O on FPGAs. And even for lower sample times both algorithm and I/O need to run on Simulink programmable FPGAs.
What are FPGAs in effect and why are they so performant? An FPGA is an integrated circuit comprised of configurable logic blocks. These blocks have dedicated functions. For example on tablam called block RAM to efficiently store specific data types, DSP slices that efficiently implement multipliers, or look-up tables and flip-flops to implement logic functions, or IP blocks that are pre-verified building blocks to perform common tasks such as memory access.
An FPGA is a piece of electronic hardware and the term is an acronym for Field-Programmable Gate Array. Field-Programmable, means you can configure the interconnects using Hardware Descriptive Language, HDL. FPGAs are re-configured or re-programmed via synthesized HDL called the bitstream. An FPGA has also input/output interfaces which allows the FPGA to interface with other hardware devices. I/O signals can be digital coming from an ADC or the CPU via the PCI bridge, for example.
Let's summarize the key advantages of FPGAs before showing an example. An FPGA is programmable hardware. By programming it, you actually build a custom processor. In contrast, a CPU executes instructions and is programmed with the software. An FPGA can be tailored for very high throughput such as processing sensor data. Assuming you have enough logic's cells available, all tasks can run in parallel. FPGAs also have ultra low latencies. For example, FPGAs do not require an operating system, also communication does not have to go via generic buses such as USB or PCI Express, because FPGAs have their own I/O interfaces.
Another important factor is, assuming the FPGA is described correctly, deterministic processing behavior can be achieved. Computations are conducted on hardware, independent of background processes or scheduler priorities. Let's go through an example. Let's walk through an example and process a camera output, simplistically speaking a frame or image as a group of pixels. In our example, let's assume one with 8 by 8 pixels in the algorithm conducts some processing steps on pixel level.
Let's compare execution times qualitatively for different computer architectures. On a single core CPU, pixel by pixel will be processed sequentially. We assume that each algorithmic step takes one clock cycle to run on one pixel. Nowadays most CPUs have multiple cores that speed up processing. FPGAs, due to their parallel architecture can run tasks concurrently. Theoretically, all pixels can be processed at the same time. Allow me a quick disclaimer just to state some key assumptions that we are making in these visualizations. We are neglecting that CPUs typically have faster clock cycles than FPGAs. Also we don't consider CPU idle cycles to, for example access memory.
For understanding the example concept, we believe it does matter and for programming FPGAs there are even some more topics to consider. Programming FPGAs is essentially programming hardware. This allows a lot of freedom, such as for streaming and pipelining of instructions. So let's imagine our algorithm is comprised of three steps. CPUs operates sequentially. So the first operation needs to run on the entire image before the second one can start. Now, let's consider the same algorithm running on the FPGA. Streaming data in and pipelining allows parallel execution of programming instructions. So pixel
operations can be done one after another on the same logic cell in just three clock cycles, resulting in a much lower latency.
Additionally on an FPGA, we can execute the operation on available cells concurrently, and obtain a significant increase in throughput. So in summary, FPGAs allow high data throughput by keeping ultra low latency. Thanks for staying until the end of this info-packed video. We hope you got some valuable insights about Speedgoat FPGA technology and we think we gave some helpful answers why it is worth exploring FPGAs. And we highlighted two workflows enabling you to drive innovation no matter whether you focus on the application or need to have full control for deployment. Thanks for watching. And for more information and learning content, I invite you to check out our website speedgoat.com.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
How to Get Best Site Performance
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.
- América Latina (Español)
- Canada (English)
- United States (English)
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- United Kingdom (English)
- Australia (English)
- India (English)
- New Zealand (English)
- 日本Japanese (日本語)
- 한국Korean (한국어)