by Bill Giovino, Mouser Electronics
It seems that every semiconductor company has a microcontroller solution for the Internet of Things (IoT) today. We are seeing specs for low power, high performance, and high integration microcontrollers from the usual core suppliers. But when Intel announced that it was re-entering the microcontroller business with a 32-bit x86 MCU for the Internet of Things, it was like Thor picking up his hammer to take on the competition again.
Intel’s new IoT microcontroller product line is the Intel Quark microcontroller family, and it emulates the small yet highly powerful subatomic particle it is named after. With the Intel Quark microcontroller, Intel has rolled out its groundbreaking 32-bit i486 architecture – that’s right, the same CPU architecture used to run desktop PCs is now powering little embedded IoT applications.
The x86-based Intel Quark microcontroller D2000
The latest Intel Quark brand in the product line is the Intel Quark microcontroller D2000. It starts with a single-threaded i486 register-based core, then adds the six Intel Pentium™ optimization instructions, resulting in a 32-bit Pentium-compatible instruction set architecture (ISA) without the SIMD or x87 floating point support. The Pentium instruction set actually has some surprising features that make it applicable to embedded code, such as a single-cycle 32×32 multiply as well as some bit test instructions. There are also some unusually complex logic instructions such as a “Bit-wise Logical AND and NOT“.
The instruction set has a flexible opcode size, some instructions are 32-bits long, while stack instructions need just a single byte. This flexibility helps compilers generate more compact code.
The Pentium’s mature ecosystem
By choosing a Pentium-compatible instruction set, Intel has made the Intel Quark processor core compatible with the large number of Pentium compilers out there, giving it additional optimizations from a code development ecosystem even more mature than ARM. This also allows access to a vast library of Pentium-ISA compatible code which can be easily ported to the Intel Quark microcontroller. Thread-X and Zephyr are two popular small footprint x86 RTOS packages that can fit easily in the Intel Quark microcontroller. There are a number of legacy RTOSs available that were tested, verified, and made solid 30 years ago that can run flawlessly.
The Intel Quark processor core includes memory block protection, an internal AHB bus interface, a JTAG port, a wakeup controller, and an interrupt control unit (ICU).
When looking at the low power figures of the Intel Quark microcontroller D2000, the numbers are surprising. Running the device at 32MHz at 3.3V, the draw is only 8mA. This results in a 32-bit Pentium-ISA core with the power draw of some 8-bit microcontrollers. HALT current, with only the core and the Real Time Clock (RTC) running, results in a current draw of just 697nA. These are impressively low numbers for what is, let me remind you again, an Intel 32-bit embedded Pentium microcontroller.
It is tied to 32KBytes of Flash program memory and 8KBytes of SRAM. An additional 8KBytes of Flash, divided into two 4KB banks, is available for data storage. It can be treated like EPROM; alternately, it can be set to be one-time programmable (OTP) in one or both 4KB banks. For fault-tolerant IoT applications this allows for local storage of critical sensor data if, for example, the Intel Quark microcontroller determines that the wireless connection to the sensor hub has been lost and data needs to be saved locally.
The Intel Quark microcontroller D2000 sports the usual range of communication peripherals which includes a real-time clock (RTC), two 16550-compatible 2Mbaud UARTs, a master/slave I2C, and two SPIs. The analog to digital converter (ADC) on the Intel Quark microcontroller D2000 has 19 channels and can be configured to convert 12, 10, 8, or 6-bits, with speeds from 3.3Msps (6-bits) to 2.4Msps (12-bits). This is quick enough to grab plenty of atmospheric sensor data in a fast-changing environment.
The Intel Quark brand D2000 Development Board (figure 2) provides a wide variety of powerful features in a cost-effective environment. It includes a 6-axis accelerometer with 12-bit resolution, a 3-axis geomagnetic sensor, and a temperature sensor. It includes connectors for Arduino Uno-compatible shields for expanded functionality, and has a battery holder for a CR2032 coin cell capable of powering the board in low-power event driven applications for a couple of months. Application code for the Intel Quark microcontroller family is built using the Intel System Studio for Microcontrollers (Figure 3). With this code development package, developers can quickly build IoT sensor node applications including remote positional sensing, free fall detection, tilt-compensated compass, or dead reckoning applications.
While Intel supports various versions of their System Studio, the version for microcontrollers is free. It is based on the popular Eclipse Integrated Development Environment (IDE) and comes with two C compilers. The first is a GNU C Compiler, and the second is from Intel. Both compilers benefit from Intel Pentium architecture-specific optimizations. Besides these, there are a wide variety of 3rd party Pentium C/C++ compilers that can be easily integrated with the Eclipse IDE. RTOS-aware debugging, flash programming support, and power efficiency profiling are all features that help to optimize application code for small sensor-aware embedded applications that are typical of low power IoT sensor applications. Full hardware debugging is supported through a JTAG interface. Linux and Windows development environments are presently supported.
The Intel Quark MCU SE – taking intelligent sensor nodes to the next level
The Intel Quark Microcontroller SE takes the concept of a smart sensor node to a new level. It takes the D2000 and makes it faster by adding 8KBytes of 2-way associative L1 instruction cache. The x86 core also now has 192KBytes of Flash and 80KBytes of RAM. A flexible 8-channel DMA supports memory to memory, peripheral to memory, memory to peripheral and peripheral to peripheral transfers. Peripherals include an RTC, analog comparators, timers, PWM, UARTs, SPI, I2C, and USB ports. But the real value of the Intel Quark microcontroller SE is the new sensor subsystem and pattern-matching accelerator, each boasting impressive processing power.
The Intel Quark microcontroller SE and intelligent sensor processing
The sensor subsystem of the Intel Quark microcontroller SE contains a standalone 32-bit ARC EM DSP core with 192KBytes of Flash. The DSP is capable of first order digital signal processing, and is meant to offload sensor processing from the x86 core. It directly interfaces a variety of peripheral resources including SPI, I2C, ADC, GPIOs, and timers that can interface to external sensors. The ARC DSP core supports fractional arithmetic, floating point, divide, square root, and more complex processing including trigonometric functions. The ARC DSP has 8KBytes of dedicated SRAM and also has a shared SRAM memory area with the x86 Pentium core for inter-processor communication.
The sensor subsystem’s ARC DSP supports intelligent data acquisition for low power applications. The DSP can be placed in a sleep state until a peripheral wakes it up to send data to be processed. The DSP wakes up, processes the data, and sends the results to the main x86 Pentium processor. For intelligent IoT sensor node applications, the sensor subsystem is a valuable feature that provides fast and accurate processing of sensor data supporting sensor fusion, data averaging, filtering, artifact rejection, and error correction.
Intelligent pattern recognition with the Intel Quark MCU SE
The new Pattern Matching Recognition Engine in the Intel Quark microcontroller SE provides machine identification of previously learned digital objects. The engine is composed of a network of parallel arithmetic units, called Neurons, which perform two types of pattern recognition. The first is called K-nearest neighbor (KNN) and the second is call radial basis function (RBF). Both allow the Intel Quark microcontroller to do some pretty impressive edge processing by performing simple pattern detection on sensor data. Upon processing a pattern, the engine returns one of three states: identification, uncertain, or unknown. Up to 32,768 identification categories can be programmed.
The pattern matching engine features 128 arithmetic units operating in parallel. In this configuration, each arithmetic unit is referred to as a neuron. The recognition time is constant, providing the added advantage in embedded systems applications of making the engine deterministic.
While this pattern matching engine can seem complicated at first glance, in reality, it supports four main operations:
- Load a vector knowledge base to the engine
- Read the vector knowledge base from the engine
- Load a pattern to be recognized into the engine
- Read the results of pattern recognition from the engine
Now, if the Pattern Matching Engine is tied into the Sensor Subsystem, the Sensor Subsystem can pass a series of vectors representing, for example, vibration, temperature, current, and audio data, to the Pattern Matching Engine which can match it against a stored dataset. If the dataset finds a hit of a pattern it has been looking for, it can trigger a wakeup event to the main x86 processor. The x86 can then make a decision to, for example, turn a switch on or off, or send an alert of the match to the main sensor hub.
This level of processing in an inexpensive chip is uncommon in microcontrollers found today, and adds significant cost-effective value to simple IoT sensor nodes. Complex processing that would normally be sent wirelessly from the node to the main sensor hub or a cloud server can be performed locally at the sensor node itself. This not only saves processing power at the sensor hub, but it also saves the node’s battery power. In an IoT node, the power draw of the node must be worth the value of the data. The more processing that can be performed at the node level, the less data needs to be transmitted wirelessly, saving power.
Intel has taken a big step by re-introducing their familiar x86 32-bit Pentium architecture into the microcontroller arena, but this makes sense in the IoT application field. The x86 Pentium architecture leverages a development ecosystem of compilers, debuggers, and evaluation tools that spans 30 years. While the Intel Quark microcontroller D2000 introduces an entry-level 32-bit microcontroller architecture into the marketplace, the Intel Quark microcontroller SE brings new intelligence into small cost-effective nodes, rivaling existing solutions and introducing a new era of innovation in the Internet of Things.