How many microcontrollers can one company make? If you’re Freescale, the answer is, “billions.”
Hot on the heels of its ColdFire+ announcement (see ETJ, June 8, 2010), the big chipmaker from Austin has unleashed Kinetis, an entirely new line of ARM-based microcontrollers. Kinetis is sort of, maybe, kind of, a replacement for ColdFire in the company’s midrange microcontroller lineup… but not really. Like ColdFire, Kinetis chips are 32-bit embedded processors with on-chip flash memory, a useful mix of I/O peripherals, clock speeds in the 100–200 MHz range, and inexpensive single-digit prices. Unlike ColdFire, however, Kinetis is… well, it’s ARM-based. And that makes the chips attractive to a whole new audience.
Freescale isn’t pulling the plug on ColdFire by any means. Quite the contrary. As the ColdFire+ announcement shows, the company is putting a lot of effort into keeping those chips spry and lively in their sunset years. Kinetis is more of a partner to ColdFire than a replacement. A younger sidekick, if you will. Some embedded designers will prefer the familiarity of ColdFire, while others will choose the popular, sexy, ARM-based Kinetis chips instead.
The first Kinetis chips are due to begin sampling later this year, with full production in the first half of 2011. Prices will start at just $1 for the low-end Kinetis K10, “soaring” to maybe $3 or $4 for the relatively high-end Kinetis K70 chips. At these prices, Kinetis should appeal to a lot of embedded developers working on new 32-bit designs.
32 Bits for a Buck
So what’s Kinetis got that ColdFire hasn’t got? An ARM Cortex-M4 processor core, for starters. The M4 is one of ARM’s low-end M-series processors (the M is for “microcontroller”) that has full 32-bit registers and data paths but executes a compressed 16/32-bit instruction set called Thumb-2. Most ARM chips (and most RISC processors in general) execute 32-bit instructions exclusively, which makes designing the chips and writing the compilers easier, but it also wastes memory. That’s a problem when you’re counting bytes in your microcontroller application. So ARM squeezed some of the bubbles out of its normal instructions to produce the variable-length Thumb-2 instruction set. The result is that Kinetis uses less memory than your typical 32-bit RISC processor. The side effect is that Kinetis, like other chips based on Cortex-M4, can’t run “normal” ARM code, although Kinetis code will run on other ARM processors. Got it?
The Cortex-M4 processor isn’t fancy, but it gets the job done. It’s an upgrade from ARM’s Cortex-M3, with enhancements for lightweight DSP applications. That means Kinetis can do some media- and signal-processing, and it’s also good for motor control. Some Kinetis chips will have a floating-point unit (FPU), so they’ll be good for printers and motion-control applications that require that level of precision. All Kinetis chips will have on-chip caches for instructions and data, though the size of the caches will change with each part. They’ll also have anywhere from 32KB to 1MB of on-chip flash memory, which will strongly affect the price of each individual chip.
Freescale is planning seven sub-families of Kinetis chips, labeled K10 through K70. Each tier will have different peripherals: some with LCD controllers, some with FPUs, some with Ethernet, CAN, DRAM controllers, and so on. Over time, the company plans to produce more than 200 variations, so you’ll need a catalog to keep them all straight. About the only things they’ll all have in common are the Cortex-M4 processor core and the Freescale label.
Time Out for TFS
It’s worth noting that Freescale is introducing a new kind of nonvolatile memory with Kinetis, too. Although it’s not getting much press, it’s an interesting twist on embedded memory that is likely to appear in most (and perhaps all) Freescale chips over the years. The company calls it TFS (for thin-film storage), but you’ll see it under the name FlexMemory in the Kinetis data sheets.
The underlying technology behind TFS is pretty cool. It uses tiny silicon nanocrystals that are only 100 angstroms (10nm) across as the storage medium. These crystals are spread over the surface of the chip and then overlaid with normal silicon and metal layers. The crystals can hold a charge indefinitely, so they’re a good basis for nonvolatile memory. At Freescale’s current 90nm process level, there are about 200 crystals per bit. At future 65nm or 45nm levels, there will be fewer than 100 crystals per bit, but that’s still enough to work reliably.
What makes TFS interesting is that it can be reconfigured on the fly to work like either flash memory or EEPROM. Flash is good when you need to update the memory frequently, but EEPROM is usually faster to access. TFS combines the best of both, providing the speed of EEPROM with the durability and byte-addressability of flash. Users can even choose between the two modes themselves; it’s not a factory option. Freescale hopes that TFS will eliminate the need for off-chip EEPROMs in a lot of applications.
New Boss or Old Boss
Kinetis has a lot of similarities to ColdFire. So many, in fact, that Freescale is probably being careful to avoid any direct comparisons. Both are 32-bit chip families; both are in the 100-MHz+ speed range; both are priced at a few dollars per copy; both have lots of on-chip memory and I/O. So how is a poor engineer supposed to choose between them?
Two words: Software and roadmap. The ARM-based Kinetis chips will have more software and they’ll have a clearer roadmap for growth. ColdFire offers backward compatibility with hundreds of other ColdFire (and 68K) chips and legions of happy ColdFire programmers and engineers. It’s a great chip family that has served us long and well. But it’s at the end of its lifespan. ColdFire chips aren’t getting much faster these days, and the old 68K architecture doesn’t have a lot of room for expansion. ColdFire has settled into its comfortable chair and slippers, and it’s preparing for a long, slow retirement. It’s still got plenty of good years ahead of it, but its frisky and adventurous days are over.
Kinetis, on the other hand, is just getting started. Sure, ARM has been around for years and is now one of the most popular processor families on the planet. Freescale is actually a bit late to this party. Nearly every other CPU and MCU maker in the world has signed an ARM license and started producing ARM-based chips. (Even Intel has an ARM license.) But the ARM family tree is blooming and growing, with new offshoots sprouting up every few years. The Cortex-M4 at the heart of every Kinetis is still pretty young, and it’s proving popular. And software support for ARM is unparalleled. You can’t swing a dead cat without hitting a programmer, engineer, or tool vendor with ARM experience.
So the ColdFire-versus-Kinetis decision comes down to software and roadmap. Do you want to keep your old 68K/ColdFire code, or develop (or buy) new ARM code? Do you want to keep your ColdFire development tools or use ARM-based tools? Both chip families are very well supported, both by Freescale and by third-party vendors. Code density is about the same and performance isn’t too far apart. Do you need the upward migration path of an ARM-based chip or are you content with ColdFire’s features and performance? In short, which club do you want to join?
There aren’t many companies that would give you that choice. Freescale offers two similar microcontroller families (not counting PowerPC), hoping you’ll come in the door and flip a coin. As long as you’re in the door, they’ve succeeded. It’s a win-win. Offering two equally good choices isn’t a bad strategy for success.