In my previous blog I introduced the topic of ‘What’s Next?’ for our programmable future with FPGAs and MCUs (or whatever they morph into). Already there are a few good comments as to where we can take this topic, but while I’m waiting for more comments to show up I thought it would be a good idea to discuss in more detail one of the ‘seed’ topics I highlighted last time.
We have all seen the rapid adoption of MCU technology into FPGA devices. The resulting combination device, sometimes called a System on Chip FPGA (or SoC FPGA), pairs an MCU (usually with an ARM processor and a host of dedicated peripherals) with user configurable FPGA fabric (along with the usual block RAM, DSP blocks and Serial IO). This provides a powerful system building block that combines the power of a sequential processing CPU with the parallel processing capable FPGA fabric. The FPGA can be used to create co-processors, intelligent peripherals, memory mangers, buffers, specialized interfaces, and a host of other specialized functions. More and more designs are finding ways to utilize these powerful devices.
Do we think MCUs are going to follow this same playbook and start adding programmable fabric (on-chip FPGAs)? You might be surprised to find out that the first steps in this direction have already begun. Take for example the Microchip PIC16(L)F1503 MCU. This device includes a small amount of programmable logic on it, using what are called Configurable Logic Cells or CLCs (extra credit for anyone who can add a comment to identify the first common use of this term in programmable devices!). These logic cells can be used to create simple logic functions from device inputs or internal signals which can be applied to device outputs or internal peripherals. A diagram of a CLC is shown in Figure 1 below:
Figure 1: Microchip PIC16(L)F1503 CLC Block Diagram
Up to 16 inputs can be selected and optionally combined (using either an AND or OR gate) then a logic function is applied to create the four generated outputs. The outputs can be enabled, polarity selected, edge detected, or registered depending on what the output is being used for. The eight possible logic functions include AND-OR, OR-XOR, latches and registers. The full set of functions is shown in Figure 2, below. These functions are optimized to allow you to create simple logic functions so you can ‘sweep up’ some simple gates from your board into the MCU. You can also create some simple functions to eliminate some CPU cycles normally used to combine or condition inputs or peripherals. Can you think of other ways to use this capability to improve performance or reduce board space in your designs? Do you know of any other MCUs that have added some programmable logic on-chip?
Figure 2: Possible Logic Functions For PIC16(L)F1503 CLC
Now, granted, this is a fairly simple step toward combining programmable logic onto MCUs. It should be possible to add thousands of logic cells to an MCU, so we have a significant amount of on-chip user customization. Sweeping up on-board random logic, customized intelligent peripherals and co-processing capabilities (user defined instructions implemented in programmable fabric) are just a few possibilities. Do you think adding a significant amount of programmable logic (but much less than there is on current SoC FPGAs) would make sense? Clearly cost would go up, over a non-programmable MCU, but if you can get better performance, more integration and maybe even lower power, would it make sense?
Let me know your thoughts on this possibility. What advantages do you think such a device would need to provide? Can you think of some perfect applications where the advantages outweigh some extra cost? Let me know your thoughts in the comments section below.
Microchip PIC16(L)F1503 Information - http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en553475