[MUSIC] Hello, I hope by now you have a general idea about embedded systems, the challenges that lie in this field, and their main characteristics. In this lecture, we will go into details of what components the embedded systems consist of. We are going to start by discussing on processing elements. In the course, we will cover embedded processors and field program level gate arrays, FPGAs. So in the end of the course, you are capable of selecting a proper processing element to implement your own ideas. So here, I would like to start by giving you some ideas on what embedded processors and NetFPGAs are. Well, we discuss embedded processors first. So what is a processor? It is an electronic device that works sequentially. This means that a processor makes computations in a serial manner, one after another. Any computation, no matter how difficult it is, can be split into simpler, let's say sub-computations. Those sub-computations might be split even further. An elementary piece of computation that cannot be split anymore is called an instruction. Any piece of computation, given by let's say by our programmer, in order to be executed on a processor, should be split into a sequence of instructions. Different kinds of processors can have different instruction sets. They are different for example, in the number of instructions or let's say in how complex simple instructions are in the sets. So what is good about this approach? And there should be oboisily something good in it since nowadays processors are widely used. The good thing is it's flexibility. Nearly, any piece of computation can be represented as a sequence of instructions and therefore executed on a processor. That means we change the behavior of an embedded system just by changing the sequence of instructions it's processor executes. In other words, we only change the software. There is no need to change the architecture of the processor. The generality of such approach is the reason why it is used massively nowadays. Let's just think about the huge number of applications that can be run on, let's say, Cortex processors, which are present in smartphones, servers and many other devices. One metric for processors, as mentioned before, is the instruction set, which actually defines the inner structure of a processor. If we compared reduced instruction set computers and complex instruction set computers, we will notice that CISC instruction set is larger. And it has more complex instructions, so how does it influence the complexity of hardware? We are not going to go deeply into the details, but at least we can conclude that the piece of hardware that the codes instructions should be more complex for CISC. One of the most prominent representative of Sisk is Intel's X86 processors. Though in this course, we are not targeting this kind of big general processors. I could not not mention a more kind of embeddable processors are for example RISC micro controllers. If we look at Atmel's AVR family we will find a large variety of options for embedded applications. Advanced RISC, arm processors, as was mentioned before are widely spread nowadays. They've arrived from Cortex M to Cortex A family which are meant for different application domains in terms of competition out performance, energy efficiency and others. In further lectures, we will give more details about processors in general and microcontrollers in particular. So just how instructions are executed, what peripherals are used, what platforms exist, so stay in. Now that you have an insight on what the nature of an embedded processor is we can move to the second representative of processing elements. Field-programmable gate arrays, or FPGAs. Well, it is of course an electronic device, but unlike a processor it is meant for more application specific designs. So what does it mean? First, let's have a quick look at what an FPGA is. FPGA has reconfigured a logic with them. To make a simple example, let's say we have two input and gates. What kind of logic can we implement? We can for example use only one gate and implement a simple logic and function. However, we can implement a more complex circuit if we use both and gates and connected the output of the first gates to one of the inputs of the other gate. So, if a certain application demands the use of two gates, we can use both. This is a simplified way to explain what can be done with an FPGA. An FPGA has many logic blocks in sight, and when needed, these blocks can be connected together to build complex circuits. These connections, the inner structure of the FPGA has to be configured according to the application's requirements before the execution. So, when we deal with an FPGA, we make changes on a hardware level and FPGAs hardware design is meant for certain applications. You can see now that there is no such flexibility for FPGAs as there is for processors. We need to change the hardware design for an FPGA every time there is a new application. There is no flexibility. The reasonable question is why then use an FPGA? Flexibility comes at the cost of performance, and energy consumption. Indeed, in most cases, the same application implemented on an FPGA, executes faster and consumes less energy than if implemented on a processor. There is one more thing which one needs to consider when working with an FPGA. An FPGA design is parallel in a sense that there is no sequence of operations. Things happen in parallel. A good example is a four loop. If the loop is executed on a processor, it will be run one iteration after another. However, if the loop is implemented on FPGA, a separate surrogate for each iteration will be generated. In a sense, iterations exist in parallel. Now you can probably conclude that a FPGA is meant for computationally heavy applications. Such as for example, image processing or big data analytics. It is also interesting that an embedded processor can be implemented on an FPGA. In this case, a processor is the application itself. There are several FPGA vendors available in the market. The living one is Xilinx, which has a wide variety of devices with different characteristics. We will discuss the main ones as well as the inner structure of an FPGA in the following lectures, so there are interesting things ahead. Well, to sum up the video, I would like to emphasize the main differences between a processor and an FPGA. Because these differences will impact the choice when selecting a proper platform to work with. A processor has a sequential nature at its core and provides flexibility. Whereas, an FPGA is more application oriented and provides hydro performance. If the main goal is efficiency, then an FPGA would probably be a good choice. On the other hand, if we need to build a generic platform, and we have either no specific application or many applications in mind, then a processor would be a suitable solution. And also it is worth mentioning that sometimes the optimal solution lies between two limits. So a combination of a processor with an FPGA may be a powerful tool. Thank you for watching, and see you in the next video. [SOUND]
