Hi Welcome to Fundamentals Friday Today, we're going to take a look at the Fpga or field programmable Gat array. That's what it stands for. What is an Fpga? Well, an Fpga is a programmable device, a programable chip, which is pretty much the closest thing you can get to actually designing your own chip completely from scratch, just like an Asic you may have heard of or something like that. That's what an Fpga allows you to do.

It allows you to design, and Implement any virtually any digital function you can possibly imagine all within the one universal chip. They're pretty darn flexible. Now, the big difference between an Fpga and virtually every other chip you can buy on the market is that the Fpga doesn't do anything. It has no intended function when you actually buy it.

unlike, say, a microcontroller. it's actually a computer built-in It's all. the logic is all hardwired in there, and it can actually do something useful. All it needs is a program.

Well, an Fpga can't even do that. You apply power to this thing and it's just going to sit there. It's not going to do anything at all. They are completely stupid, but they make up for that with their extreme flexibility allowing you to design anything you can imagine.

In the digital domain. They can't do analog digital only, but in the digital domain, you can program it into one of these Fpga chips. If you want to turn an Fpga into an an AVR microcontroller or a Pck microcontroller, you can do that. If you want to turn it into a digital signal processor, you can do that If you want to turn it into a uh, a th000 LED custom driver, you can do that.

They're incredibly flexible, limited only by your imagination. So how do they do this? Well, Well, they do it by containing thousands, tens of thousands, hundreds of thousands, or even more of individual logic. uh elements. Let's call them cobs or configurable logic blocks.

They go under various names depending on the vendor, and we won't go into that. We'll call them CS configurable logic blocks that can Implement pretty much any basic function you can imagine. And because there's so many of them, thousands, tens of thousands, hundreds of thousands, you can configure them in any way you like to perform any complex or even simple digital function. And those configurable logic blocks sit inside these red lines.

Here this Matrix of interconnecting lines. They're basically exactly that. They're just metal, uh, interconnects inside the chip that you can join up in any configuration possible. So you might want to join this logic block over to this one, over to this one, and then to these IO pins all over the place to implement whatever function you program into this thing.

So they're often called like a sea of gates. For example, because they're just all these, uh, configurable Gates sitting on a sea of interconnecting logic. and, well, um, that's a bit of an old term because these are these: CBS configurable logic blocks or logic elements are more than just individual. Gates They're pretty smart in their own right now.

In theory, the most powerful and flexible Fpgi or configurable logic chip you can imagine would contain millions of n Gates And you know, an infinite network of all these interconnect lines to join them all together. Because if you remember your basic uh, digital logic Theory a nangate, you can if you have enough. Nang Gates You can create anything. You can create a microcontroller, you can create 100 microcontrollers, or any DSP or any function you like to do anything just from.

Nan Gates Unfortunately, um, well, those chips do actually uh, exist. They're called Gat Arays and well, they're not that, um, much used anymore. Similar sort of concept. These Fpgas or fuel programmable Gat Arays with their more complex configurable logic blocks have taken over from that because in theory, um, yeah, you could have all these configurable Nang gates in there, but you just simply run out of room.

It's too complex. You can't have an infinite network of all these uh traces Crossing everywhere, plus an infinite number of gates in there, and have them more configurable in every orientation. You would quickly run into a routing. Just like routing.

A PCB You'd run into a routing nightmare within the Fpga and in the end, it just choke on itself and you wouldn't be able to do anything. So an F a modern Fpga is basically an optimization of more complex configurable logic blocks that do contain individual Gates and elements, but they also contain flip-flops and lookup tables and things like that. Um, a more con, you know, more complex Block in there um, then surrounded by a limited number of interconnecting traces like this. and then it's a balance.

a tradeoff between uh, what you can per what logic function you can perform in one configurable logic block to or your routing resources to be able to get all your signals out to your IO pins around here from your internal logic elements. And we'll take an extremely brief look at what's inside one of these uh, uh, configurable logic blocks. Here this is very generic. Um, in practice, they are much more complicated than this.

But generally what you're going to get inside an Fpga is a lookup table. A basic uh lookup table might be say, four inputs like this. You can get larger ones depending on the Uh Fpga types, and then we've got all the configuration fuses in there as well. Of course, you can actually program that to perform a particular function.

so they basically got gates in there and I won't go into look up table uh, details. But then you'll typically have one or more uh flip flops in here as well. and you can use those uh flip flops in various ways and they'll be uh connected to Dedicated uh, clock lines. or you can or it can come from the fabric and there's more switching stuff in here and the reset line of flip-flop and the Q and not Q outputs they can.

You can select which output you actually want to go out from the Uh configurable logic blocks. so you basically got a bunch of flexible inputs, a bunch of uh, logic gates, and some um, you know, flip-flop latching stuff you can do uh, latched logic with and that clocked logic uh as well. and then you basically got some outputs as well. And if you got thousands or tens of thousands, of these things can become incredibly powerful and flexible.

Now, the other thing I've drawn inside here are these IO blocks around the outside of the chip that actually connect to the individual pins on the chip. And these are, um, fairly complicated little Uh blocks in the of logic in their own right. They're not just a buffer that goes out to the pin, but they can perform, can be programmed to perform all sorts of functions. uh, trate input.

They can be inputs just like a microcontroller. You can program them to be inputs or outputs. You can TR State them. You could have uh, you can turn them into differential pair drivers, so not just single-ended differential pairs.

You can have different Uh log, uh, voltage, um logic standards as well. On the various pins, they can contain uh, flip-flops and latches in them for driving DDR memory and all sorts of complicated things like that contain Within These IO blocks. So they can also be connected to the internal Matrix as well. So you've got lots of these powerful little logic elements in here that you can combine to do any function you want combined with pretty powerful IO as well.

And that all adds up to a very powerful and flexible chip that can do as I said anything you can imagine now and I said before that when you power up an Fpga it's completely stupid. It doesn't know what to do I Wasn't kidding because an Fpga are typically volatile devices. What that means is that they have no ability to store their internal configuration or how you've programmed the device, what you've programmed it to do. they've got no ability to store that.

so as soon as you remove the power, it forgets that Fpga just goes back to be in Factory Fresh. It doesn't know what to do, it's just a huge sea of these Gates sitting there unprogrammed, but the Fpga has built into it a little. Well, actually quite a complex uh conf configuration logic here, which then hooks, which then you have to hook up to an external configuration flash memory. So for any Fpga to be useful, you can't just have the Fpga you've got.

It's mandatory to have an external configuration flash memory, which is basically just a regular, um, you know, four or 8 megabit flash serial flash memory device that can be parallel as well. Um, except that it contains all of the information for all of the these little fuses inside here, which logic block connects to, which and how and the fuses inside these configurable logic blocks. Here, the fuses inside these IO blocks to tell what These IO blocks down here. And you know, hundreds of other Uh fuses for various functions, which we'll talk about.

And uh, that's why you need a quite a large, even for a sort of, you know, a cheap medium, you know, smallish Fpga You really need quite a large flash memory because there's a lot of fuses inside here which have to be programmed. And when I say fuses. They're not fuses like flash fuses. They don't permanently store it.

they're actually just, uh, you know, transistors or latches that just switch on and store the function for that particular bit. But you can think of them as uh fuses. except when you turn off the power, boom, they gone. The Fpga forgets absolutely everything.

So when you turn on an Fpga it doesn't know what to do. But this configuration logic up here when you first switch it on automatically knows. Well, okay, power's just switched on I need to load the data from the external flash memory here and program in all the fuses and that can take you know seconds, uh, sometimes to do so. Fpga are not instant on.

they do take some time to boot up and to configure all of their logic. So what are some of the advantages of Fpga Why would you want to use them? Well, let let's take a look at a few you can. As I said, you can do anything in the digital domain you could possibly imagine. You can turn it into a microcontroller.

You can turn into a say, crazy super computer. You can drive a custom controller to drive a th000 Le Matrix Cube or anything like that. You can do anything. really anything.

It's amazing. They're also super fast. and uh, some of the even the basic Fpga have IO blocks serial functionality which will get into they can go into the Giga you know, the gig bits per second region. they have our transceivers built in that can actually do you know, gig bits per second serial, uh, decode and stuff like that.

Incredibly incredibly quick. Now if you compare that to say a uh, microcontroller, for example, even a really fast modern processor like used like the Arm used on the Raspberry Pi you might be able to toggle the Io pin at you know, 100 MHz or something like that. But really, you know you're you're bottlenecked by the processor. You can't do any serious processing you know on 100 MHz input signal for example.

Well, as with Fpgas that's not a problem at all because you can dedicate the logic in here to just do that and we that'll come down into this massively parallel thing Advantage at the moment to do a specific function on just an IO signal that you want. So if you got an input signal coming in and you want to do some really fast processing of it, uh, in effectively real time and shoot it out another pen where you can dedicate a part of the Fpga to do that. Incredibly flexible from a speed point of view. Now they're as their name suggests, they're field programmable.

They're Fpga How does that differ from a microcontroller which you can reprogram? You can reflash in the field. Well, this is different in that it's not just a fixed processor. In fact, it doesn't contain a processor at all unless you program one in there. But so, you can change anything in your design at all.

So let's say that you design your custom product and you used a microcontroller for example. and then you put it out in the field and you went. oh no, I've got to change something and I can't I don't have enough power or processing capability left in my processor to do it. or it's not flexible enough to do this or that well with Fpga If you ran your processor inside the Fpga and you had enough resources left over when your products gone out in the field, you can go.

oh, look, I needed You know, a a fur filter or something like that to be implemented between this pin and this pin? Well, you can just reconfigure it anything you want if you got enough space left in there. No worries, you put a fur filter in there or a P ID You can tweak P controllers or do whatever you can possibly ibly imagine. so they're more powerful in that respect than a field programmable. uh, microcontroller.

Because they're not just a processor. They're not just a microcontroller. They can do anything. As we said anything at all and we talked about the massively parallel thing.

And this is one of the huge advantages of Fpga In the main: one of the main reasons why you would choose them over a microcontroller for certain projects. because if you take your basic microcontroller, it's effectively a Bottl NE Everything has to run through that processor. call in sequence. You know you got your individual line of code.

You execute each instruction code one by one, and you have to rign I'm doing that fast enough. Even if you got a realtime operating system, it's not really real time. You can't process these 10 pins at the exact instant that you're processing these 10 pins up here and toggling these outputs here. It doesn't happen.

but with Fpgas you can because this all this L logic block. All these logic blocks in here are completely configurable. Completely separate. So you can be processing these pins down here and outputting something over here at the exact instant that you're processing these pins up here and outputting something else over here.

And you can do that If you've got enough IO pins and enough logic blocks. you can do that hundreds and hundreds of times. So you can be processing hundreds of things in parallel. Take for example, an analog to digital converter.

If you had 50 channels of of ADC data coming in, you know you had an external ADC chip. Of course, cuz these are only digital. they can't do anything in the analog domain. Well, if you got all this data coming from 50 analog to digital converters, 50 channels, and you wanted to process that all at once, well, you can.

Yeah, have a 50 channel, uh, sample and hold, and then your processor to do it all well. you know there's a real bottleneck speed bottleneck there. But in an Fpga you can have each one a particular bunch of logic blocks dedicated to that one channel. and then you can just duplicate that 50 times or 100 times or 500 times with inside your Fpj.

Because remember, we've got hundreds, sometimes hundreds of thousands of these logic blocks to play with. Fantastic! So that is the massively parallel advantage of Fpga If you want to do a whole bunch of processing all at once in parallel, then Fpgas of what you want to use use over a micro controller. And that brings us to one of the final advantages: the high IO count. um, Fpgas specialize in high IO count applications.

In fact, the development of Fpgas is really just pushed towards that high pin count capability. And it's actually quite difficult to get a decent Fpga And by decent, when you talk about a decent Fpga you're talking about how many logic blocks effectively it's got. It's hard to get a decent Fpga with a small number of IO pins. You know it's not like you can get an S So6 package or a even a, you know, a 44 pin quad flat pack.

They're actually quite hard to get. That's why most Fpgas are designed for high IO applications. So they contain hundreds of pins up to you know, a th000 plus pins. And because they've got so many pins, they often come in real pain in the ass to use packages like BGA.

So if you want to drive, for example, some huge LED Matrix, you know you had a you know, 100 leads by 100 Le Matrix or something like that. Yeah, you can do it with a microcontroller and a whole bunch of external Um 74 HC 595 latches or something to latch the individual rows and columns and all that sort of thing. That's sort of the traditional way to do it, But then as I said, you come into that real speed bottleneck. The processor has to drive all that incredible incredibly quickly just to get you know 25 times per second.

Updating on your lead. Matrix display. Well, Fpgas can do all of that in parallel because they've got hundreds of IO pins. Or you can choose one with hundreds of IO pins.

You can do it all at once. Bam Straight in there. So that's the huge advantage over microcontrollers. So these Fpga sound fantastic, right? Why doesn't everyone use them? They're so fantastic.

Impr program them to do absolutely anything. Why are they not in every single product and every hobbyist to it? Well, there's lots of disadvantages and I probably haven't even listed them all. Let's go through them. These Fpgas are expensive.

Why are they expensive? Well, they're expensive relative to another chip, Which does that. Could do potentially a similar function. I Mean you can get uh, Fpga as little in you know, as a dollar or two, but they don't contain many configurable logic blocks, so they're quite Limited in what you can actually do with the things. And so they're expensive in a relative sense.

For example, if you wanted to duplicate uh, an AVR microcontroller in an Fpga there is no way that you can get one big enough to put an AVR microcontroller in there. That's going to be cheaper than just buying the AVR microcontroller on its own. So if you just looking to duplicate the functionality of a pre-existing dedicated hardwire chip, you're wasting your time. So that's why they are quite expensive.

And Fpga they're really high-end ones. You can pay many, many, thousands of dollars for just the one chip. Fpga are some of the most incredibly complex and bleeding edge process technology chips on the market. Why? Because they have to contain Mill sometimes millions of these logic elements and routing pars and and and configuration fuses and everything else just to give you that flexibility.

So they are very so. They are relatively expensive, and because they also contain all of this uh flexibility, it means that they're not optimized for power consumption. So if you're after an ultra low power design to do something, there's no way an Fpga or an equivalent Fpga is going to be the same as or lower power or nearly as lower power as a dedicated chip to do the function. It's just not possible due to the process technology and all the complexity.

So they're quite high power devices and they can chew a lot of power when they start up as surge current when they uh, start up and program all these fuses for example. So just got to be very careful, you wouldn't use them in a low power design. They're volatile. As I said, they completely forget everything.

These Fpga are brain dead. You have to have an external configuration flash memory in order to reprogram the Fpga every time you apply power and that can uh lead to boot time issues I mean some Uh systems you want just to work instantly. you can't just uh do that with Fpgas although there are some that do have configuration flash. We'll talk about that maybe.

And as I said, they are high pin count. If you're looking for a hobbyist, friendly or a really production friendly device and Fpga is not the best way to go about it. As I said, you can get low low pin count devices. There are a few out there, but they're generally not in easy to use packages.

Most of them these days come in BGA packages which are not easy to use so often. you have to take that into account. and the other thing is because they're optimized for high pin count. Generally, if you want a lot of configurable logic blocks in here a lot of logic density, then you generally have to go for a higher pin count device.

They sort of go hand inand High logic density High pin count. Why uh, it's annoying. The manufacturers just do it because that's where they think the market is or the Market's being driven by those sort of application. So it's not like you can get a million logic element device in a nice friendly you know, Tqfp.

You know, 44 pin package or something. It's just not going to happen. So they are. And the other thing is, they are complicated.

They are incredibly complicated. Go down, go to the manufacturer's data sheet zyink or altia or one of the others and download a data sheet for an Fpga and you can spend the rest of your life reading that thing. It's not just one data sheet, Then they have all these different data sheets and applications for how these configurable logic blocks work, how the Io Works, how the clock systems work, how the uh, uh, serial interfaces work, and how the DSP cores work in the things and and how to program them the best way. Uh, best and quickest way and safest secure way to program them when they boot up.

And oh, they got you know. Dozens and dozens of data sheets and application notes for just the one device they are. Believe me when I say it. The most incredibly complex chips on the market? Take my word for it or don't go read it for yourself.

Um, and because they are so complicated, they contain many traps for young players. There's lots of things that can go wrong in this thing. Because you are effectively designing the chip yourself. You have to take all the timing into account, all the routing into account, and the complexity of the device.

And how do you configure the Io blocks? and I haven't even scratched the surface of the complexity of this thing. This is incredibly simplistic what we've looked at here so far. so they are many traps in terms of not only just uh, configuring the things, choosing the right clock pins. For example, because some um, in addition to these IO blocks here, they'll have dedicated clock pins which have faster routing paths through here.

And depending on if you want a really fast design, you have to know how to use uh, configure your um, uh logic in the corre correct, uh part of the Fpga It can make a difference where you physically place all your stuff in the Fpga and the tools can sort of take care of some of that or a lot of that for you, but you really have to be aware and there are a lot of traps just in configuring and choosing an Fpga And uh, that's the thing. The tools are incredibly complex. Um, go and download the tools for these Fpgas and it's like many gigabytes of downloads and it. There are so many tools which come with these Fpgas They are incredibly complex.

Yes, you can get uh, nice development kits which you know have example programs and you just install all the tools and even though they got tens of millions of lines of code in there, it all just yeah. You can get these simple, develop Vel kids to just work and you can get a simple uh application running in your Fpga and they look easy but from that aspect when you first use them. but when you want to do your own professional design from scratch boy, you can spend a year just choosing and uh you selecting and programming and configuring and optimizing. a you know, a moderately complex Fpga design.

The tools are necessarily complex because these devices themselves are incredibly complex. And as I said, they're hard to choose and compare. Go to Z just two of the manufacturers the two uh, top ones who own like 80% of the market zyink and Altera and try and figure out and compare two different devices. They'll call these logic blocks different things.

Configur configurable logic blocks. They'll call them logic. one manufacturer will call them logic elements, someone will call them something else. Um, they can contain different number of lookup tables in them.

They might might, uh, use terms like system Gates and all sorts of stuff which confuse the issue and they don't have. The industry does not have common terminology for the architecture Inside these Fpga and manufacturers all have their own architecture terminology. The architecture is entirely different. The terminology is entirely different between manufacturers, and just being able to choose between.

You know you take for, uh, you take uh, advantage of the fact that it's simple to compare microcontrollers. For example, between p and Ill right? Yeah, one contains, you know, X number of adcs of 10 bits, it contains two uarts, it contains X timers, and you know they're all fairly generically, uh, similar. But Fpga is totally different, so good luck trying to choose and compare not only between manufacturers, but choosing the correct size device for your project because when you start your project, you might have an idea of what you want to do and you go Okay, I Need an Fpga because of some of the advantages we talked about. But then you find that well, like how many logic elements do I need because the uh, a device with, you know, 128k uh logic elements might cost you know twice as much as one with 50,000 logic elements or something like that.

How many do you need? You don't know until you actually design your code and then run and then compile it. or synthesize it and try and get an estimate of how many logic elements you're going to use. So sometimes you have to actually do your design first and then choose your design and then choose your chip last. When you know, uh, what, you know how many logic elements you're going to need and things like that.

Maybe you use the power estimating programming the tools. um, they contain. You don't know how much this power this Fpga is going to draw. Don't bother going into the data sheet and going.

oh, how much current does this Fpga draw? It draws nothing when you got nothing in there. or you know, sort of. you know, just aescent current. But when you're running, it depends on how much logic you're running, how many IO blocks, how fast how they're configured, all sorts of stuff.

It's completely Dynamic. So the tools contain power, estimating uh, programs, and uh, so it's just. it's amazingly complex these devices so you don't generally want to use Fpgas unless you're a really experiencing them. or B you absolutely need them for some of the advantages.

We talked about the massively paralleled uh, nature of a project for example, or the really fast IO processing or something like that. Now here's something that we haven't talked about yet and it requires separate videos. In fact, everything I've talked about here and a whole lot more. I could do a one or two hour video on each and every aspect of these Fpga And these Hdls or Hardware definition languages are no different.

Uh, so these are generally how most people program Fpga these days. They don't use the schematic capture anymore, even though you can do that if you really want to. These Hardware definition languages uh, the two major ones Vhdl and Verilog you may have uh, heard of around the traps Now I may get hoed over the calls for this one, but I Generally they are not easy and they're not intuitive like your more sequential programming languages like C and basic that you're familiar with on your PC or your micro controller where you got the processor which executes each instruction line by line by line by line. Fbga don't contain a processor unless you put one in there.

they are just a sea of logic gate. So using code to Define things like multiplexes and counters and and Gates and flipflops and all that sort of thing is not really that intuitive to most people who've learned Electronics a digital electronics the traditional way With Gates and flip-flops and Mxes, it's it's a real different uh world where you have to think that everything's executing in parallel and you have to think about clock domains and all sorts of complicated stuff. So HDL it? yeah, you might be able to load your example program when you get your $100 Fpga demo board, but then trying to really understand it and that comes back to the traps as well. There's not only traps in configuring the Fpgas but there's also many traps in how well you write or how well you uh, can write your Hardware definition language in Vhdl or Verilog.

There's lots of traps there that can cause all sorts of uh, problems inside your Fpga race conditions, and all sorts of stuff that we won't go into. but there's and I've probably left off some other disadvantages, but there's a lot of disadvantages there for Egas, and that's why they're not hugely popular. except for the more Niche applications where the advantages are really so compelling that you want to use an Fpga now. I've been going on for like 30 minutes on just what an Fpga is and quite frankly I haven't even scratched the surface because the simplistic architecture I've sort of uh explained.

here is not how modern Fpga are. Well, they are in a basic operational sense, which is a good introduction of how they actually work. But you know, in practice when you want to implement an Fpga they're incredibly more, much more complex than this. They haven't been sort of this simplistic with just like the cob and just the routing paths and the just the I block and that's pretty much it.

They haven't been that way since the dawn of Fpga many decades ago. All of your modern Fpgas contain a whole slew of functionality in these things. no pun intended because there's things like slew rate control in the Io blocks. Memory is a big thing in Fpgas these days.

Almost all um, decent Fpgas will have various forms of memory in them in terms of uh, distributed, uh memory, which you can utilize in different ways depending on your architecture. Uh, your internal architecture you're trying to design. Or they can have dedicated Ram blocks and you can Implement jeal Port memory. You can do all sorts of stuff because a lot of processing happens inside modern Fpj.

That's what a lot of people use them for. Uh, so they'll even contain. These days, the manufacturers realize, well, people were all implementing what's called these soft processor cores. Which means you might get like a Nios core which is Um, or the manufacturers have their own types of you know, uh, 8, 16, 32bit or more uh processor cores.

You can just drop them in there and they're a soft core soft Because they they can. You can just configure it sort of anywhere within the Fpga you want, as well as a lot of other functionality. but a lot of Manufacturers are going well. A lot of people use use these Calles and they use other functions within the Fpga Basic stuff, like might be an Ethernet controller for example.

So they go okay. Well, let's put hard logic inside these Fpgas as well. so they'll embed like an Arm processor and that's actually not in the Fpga fabric. It's not a soft function, it's a hard function.

So it's you know, might have a little arm processor over here or a couple of them and they might have, you know, Ethernet transceivers, or big uh, serial controllers and all sorts of things implemented as all this hard logic around what traditionally was a soft Fpga fabric. The advantage of having that hard processor and hard logic in there is that, uh, if you know you want to process it in this thing, well, you're better off going for a hard processor with the Fpga fabric around it because it's got to be more optimized. it's lower power. You don't have to worry about designing that aspect of the processor in, you don't have to recompile the processor each time you want to, uh, you know, recompile the design for your Fpga It's all hard in there just like a microcontroller or Micr processor and you know it's guaranteed to, work.

Because the disadvantage of these Fpga is nothing's guaranteed to work because you've designed it all. You've written all the code, you've dropped in all the blocks, Even if you might pull these uh, you know, modules off the internet. How do you know if they work? How do you know how the software has routed it within here? Because that's the other thing with Fpga. Routing is a huge part of this thing and actually fit in all of your design and optimizing.

That's why these tools are incredibly complex and it can actually take sometimes you know a long like days to actually really fit and compile a real huge design and optimize it inside one of these Fpgas and get the correct timing and routing paths. And that's the other thing. Clocks: These things will have dedicated clock pins and dedicated clock routing paths. Uh, I think I said before dedicated clock quadrants.

so you can't just, uh, utilize this logic over here with a clock that you're using on this pin over this side of the Fpga and they'll come with uh DSP blocks. That's another very common thing. You'll see that uh oh, This Fpga contains uh, multipliers, accumulators, and Max and DSP cores all scattered around. A typical Fpga these days might have you know, 50 or 100 DSP little cores all scattered around the place.

and on top of all that complex uh clock routing structure. inside modern Fpga they contain digital clock management uh systems. they go under various names uh PLS and all sorts of things to multiply the external clocks. That's why you might typically find one of these Fpgas working like the external crystals only 20 MHz for example.

But the pro but all the logic inside might be run at a couple hundred mehz because they those Plls and Digital clock managers. You can multiply the external clocks and you can do phase shifting and you can do very complicated timing uh and clocking arrangements with inside your Fpga architecture. But that opens up a whole can of worms in terms of uh, clock timing for your entire system and you can really goof that up if you don't know what you're doing. And I haven't even started on the complexity and the limitations as well of designing or compiling your designs into an Fpga but this is the basic architecture of them.

and well, you don't be afraid because you can get simple development kits start up using the Fpga are an important part of the electronics design toolkit, so they are definitely worth learning. So don't be afraid because there are some powerful advantages to Fpga. So I recommend you actually go to the manufacturer's websites Altera zy links for Stu dats uh for example and check out all the range of Fpgas they got available. There's basically one available for every Niche applications.

Ones are designed for really fast serial processing, others are designed for massive IO others are designed for DSP uh type work and others are designed for a whole combination of those things. Incredibly complex devices and well. I haven't even scratched the surface really. I could do another hundred videos on Fpga will I I Don't know.

Jeez. catch you next time.