Design News is part of the Informa Markets Division of Informa PLC

This site is operated by a business or businesses owned by Informa PLC and all copyright resides with them. Informa PLC's registered office is 5 Howick Place, London SW1P 1WG. Registered in England and Wales. Number 8860726.

A Solution to Fight MCU Complexity: Hardware Programmable Logic

A Solution to Fight MCU Complexity: Hardware Programmable Logic

I have previously remarked (some might say complained) about the unnecessary complexity microcontroller manufacturers have added to their devices. In particular, peripheral blocks seem to have mushroomed in new features and capabilities, making them difficult to completely understand (at least for me). One possible solution to this mess that I mentioned involved allowing software to hide the underlying complexity; the software could provide the key functions needed in 90% of the cases, and the extra 10% would only be "visible" if you really need it. Well, now there is a potential hardware version of this solution.

Flex Logix recently announced an extension to the capabilities of its programmable logic fabric that SoC and MCU manufacturers can use to create programmable hardware on their chips. Hardware users can configure to add a variety of functions. In fact, the fabric is flexible enough to provide those extra functions we find in complex peripherals.

By using programmable logic, however, you only use logic when you need the extra features, which don't sit idle if you don't use them, as they do on a traditional MCU. Intelligent software could decide what hardware you require based on your driver calls and allocate the needed programmable fabric (maybe this will be called "stitching" instead of the "linking" done in the software world). The figure below shows the structure of the programmable fabric with programmable logic, embedded memory, and I/Os. The new DSP capability is illustrated at the bottom of the figure.

The advantages of programmable fabric don't stop with just flexible peripheral implementations. Programmable logic can even provide hardware glue to connect peripherals and create autonomous functional units. A timer could trigger an ADC, which would do a conversion and store the data into a programmable fabric block memory.

Programmable fabric could process the data (perhaps using DSP blocks to implement a low-pass filter) and put the result in another buffer. The programmable fabric could notify the USN controller that a block is ready to transfer off chip to a data aggregator for data logging.

This could be done without the processor being involved. The processor could focus on the various system-level control and coordination functions, but all the low-level data movement, buffering, and processing could be done by the programmable fabric. Even your GPIOs get new capabilities, as programmable fabric can sweep up any random logic outside the MCU to reduce board space.

It could be possible that this combination of programmable hardware and intelligent software will be the approach to cutting the MCU complexity Gordian Knot. If so we will end up with just the right hardware needed to implement the peripherals (both simple and complex) we will require on next-generation MCU-based designs. Let's hope we get a solution before our next big design (or maybe at least before the one after that)...



Warren Miller has more than 30 years of experience in electronics and has held a variety of positions in engineering, applications, strategic marketing, and product planning with large electronics companies like Advanced Micro Devices, Actel, and Avnet, as well as with a variety of smaller startups. He has in-depth experience of programmable devices (PLDs, FPGAs, MCUs, and ASICs) in industrial, networking, and consumer applications and holds several device patents.

Hide comments
account-default-image

Comments

  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.
Publish