Another interesting small mcu is the nrf51822 which is 3.5x3.8mm , it includes bluetooth low energy transceiver and dc-dc converter + 256K/16K flash/ram and it supports the mbed/arduino. It would be also possible to write/adapt a low energy mesh protocol for it.

Another interesting one: stm32f401, cortex-m4 ,84mhz,512KB flash, 96 KB ram, low power and can run python(micro python) - at only 3X3 mm.

Small enough to be installed in the cables of your device.

Freescale's best trick with these is putting them in business cards (between thin plastic).

Don't forget the battery, wifi and other electronics needed for fully functional system. It would make the entire device 5 times bigger. But its getting there when the entire system is as small as this.

I don't think you'd put a full system in a cable, but you'd make smart cables like Apple's lightning cable or their video adapters that actually convert signals.

With an external base station that talks a different variety of RF, I think you could get an IoT system to "stacks on a coin cell".

Heck, Electric Imp is close to that size. https://electricimp.com/

See arduboy, covered previously: https://news.ycombinator.com/item?id=7325486

http://bateske.com/arduboy/

Thin film batteries + solar cells are already being mass manufactured so thats not a problem. RF chips are shrinking rapidly too and you'd need little more than a CC3000 from TI which is already pretty small (16.3 x 13.5 x 2mm)

Can't you power it briefly via a large enough capacitor/antenna pair?

Notice that they explicitly mention IoT, a week after Atmel announced a similar controller for an IoT module:

http://atmelcorporation.wordpress.com/2014/02/24/atmels-smar...

Freescale seems to mention IoT only because it is the buzzword du jour, there doesn't seem to be anything that makes this new chip particularly IoT oriented. It doesn't even have any built-in internet (or any network for that matter) connectivity, which is kinda important for IoT.

In comparison Atmels use of IoT in that case seems more justified by the fact that they are marketing a solution with network connectivity. And imho the integration of connectivity and microcontroller is far more significant than 15% reduction of already ittybitty package size.

Freescale's IoT angle has been delivering the cheapest MIPS per watt. IoT isn't all about wireless communication in their eyes - you also need a capable data acquisition and processing system that can run on sub-milliamp power for long periods of time.

These recent developments keep reminding me of the "dust" in Vernor Vinge's "A Deepness in the Sky". Powered by microwave pulses.

Granted, that dust as described is more capable. But we know how that curve tends to go.

It seems that the science fiction writers are barely keeping ahead of "reality", these days. Kind of amazing.

What were some of the implications of this dust?

They are sensor nodes and... read the book, it's worth it :)

How does this compare to an AVR (other than being a Von Neumann computer)?

AVR's are 8-bit microcontrollers, Cortex-M's are 32-bit and are generally more powerful and have more features (even the Cortex-M0's) than both AVR's tiny and mega series.

I wonder if it's the beginning of the end 8-bit and 16-bit micro. Prices of 32-bit micros are so low now, they are so small, it just doesn't seem worth the hassle of dealing with an 8/16bit. I'm sure they'll exist in legacy designs for another 20+ years, but new designs? Less and less.

Power budget is still a big deal, and in a lot of applications is a bigger concern than the BOM parts cost.

Related: Atmel's got tiny 8-bit micros that can run off 0.7V, making it feasible to run off a single alkaline cell.

Actually 4-bit MCUs (mostly mask-programmed) are still quite popular at the extreme low end, because they're absolutely tiny (<1mm^2 bare die, in COB packaging) and cheap (<$0.01) and good enough for their application; ultracheap 4-function calculators, electric teethbrush, multifunction flashlights, toys, etc.

8 bit code takes much less space than 32bit code. You can almost pack in 2 to 4 times as much code in the same space as fixed instruction width 32bit code. Perhaps less when compared with ARM thumb but still significant.

You'd think, right? Luckily the ARM dudes came up with Thumb-2, so most (all but 6) of the Cortex-M0+ instructions are actually 16 bit, not 32. (Nice chart at http://en.wikipedia.org/wiki/ARM_Cortex-M .)

But what's even more interesting is to actually compile apps and compare code size. Miro Samek did this for a couple of RTOS-like framesworks and compared across a mix of 8, 16 and 32 bit micro architectures (PIC, 8051, M8C, 68HC08, AVR, MSP430, M16C, ARM7 Thumb, and ARM Cortex-M3 Thumb2). For his test, the MSP430 was the most dense, but Thumb2 wasn't far behind. (http://embeddedgurus.com/state-space/2009/03/insects-of-the-...)

Of course, there are 4 bit micros out there...

> ARM dudes came up with Thumb-2

I guess I'm nitpicking, but Cortex-M0+ and Cortex-M0 are basically Thumb only. The only Thumb-2 instructions implemented by these cores are the ones for barriers and transferring data between general purpose registers and special registers. These are:

1) Without an equivalent Thumb instruction

2) Required on the ARM architecture

3) A tiny, tiny percentage of instructions executed or just not used by typical application code.

Regarding the linked test, the toolchain and optimisation flags are going to make a significant difference. I wonder how GCC (which is free and probably the most popular) and armcc (which generally produces significantly better output) would fit in there.

Here's another interesting comparison of code density, in which x86 (not surprisingly?) came out ahead: http://www.researchgate.net/publication/224114307_Code_densi...

Flash memory used for program storage is much much cheaper than ram. One of the only wins that 8 bit code has over even thumb code is a faster instruction bus, but for a pipelined processor that doesn't matter anymore.

8 bit would be dead if the 32 bit parts included all of the peripherals engineers actually need to build stuff (SPI,analog,timers,etc).

There are lots of 32bit micros with all those peripherals, I think it's just that the embedded industry moves slowly and adopts new products with caution. I think it's only a matter of time before all microcontrollers are ARM and the various 8/16 bit architectures die off.

There are, but the AVR parts for example have an amazing balanced of needed peripherals that still makes those parts attractive. It Atmel replaced their AVR cores with a cortex-m0 but kept all the peripherals in place and the pinouts and the part numbering scheme the same, they would have a huge boost in market share.

AVR is so old school now and has been for years. AVR only lives on because of the hobbyist, like Arduino. Professionals have switched to Cortex M0, because of size, price, and power consumption.

Old school yes, but the hobbyist market it only a drop in the bucket. Around 1,000,000 Ardunios have been sold total. Atmel doesn't give numbers, but the 8-bit MCU market is around 6.7 billion units per year, AVR is a large share of that.

Suggested Price @ 0.75 Per Unit at 100K Batch.

Would Love to get one to play with :D.

You can get a FRDM-KL25Z dev board with a 48Mhz M0+ for $12.95

It even works with the Mbed system, so you don't need to worry about setting up a compiler environment becuase you can do it all online (unless you want to - it works with GCC)

http://mbed.org/handbook/mbed-FRDM-KL25Z

Shameless plug: I've written a program that combines a terminal (for the Freedom board's debugging serial output) with one-click uploading of newly build code. It's called Freemon, is GTK+ and GPLv3, and is available here: https://github.com/unwind/freemon. It's really handy when doing "bare-metal" development on the Freedom board.

Get yourself a discovery board from ST, same architecture (actually: a good range of choice) and no need to solder a 3 mm2 BGA ;)

The discovery boards are absolutely awesome and very cheap. I highly recommend them as well!

There is also a fantastic RTOS called ChibiOS that has a focus on the STM32 chips and has great support.

ChibiOS seems to work OK for me, though I haven't fully tested it yet. I'm running a port on both the M4 and M0 cores of an LPC4357, the 204mHz part. It's pretty quick.

I'd love to have 100 of them! It probably wouldn't be $0.75/ea for only 100, probably closer to $1.00 each, but still. $100 for 100 MCUs to throw into projects would be awesome. 48Mhz is a lot of hertz to throw at a lot of problems.

Hell, at that price, you can afford to do stupid shit with them, like put them in your friends' LED lightbulbs to screw with them, or build a physical neural-network computer, just so you can hook up LEDs between all the interconnects and make a blinklichten display.

The only problem is that they are ball grid array devices. I wouldn't necessarily say that BGA is impossible for a hobbiest, but typically you're just not going to find that kind of equipment at your local hackerspace.

In some ways BGA is even easier, aiming a hot air gun requires less general accuracy than a fine soldering iron tip. The only difficult part is the size of the things.

The listed price is $0.75/ea for 100,000 so at 100 it would probably be around $2-3/chip. Still pretty darn cheap for what it can do!

Though, if the goal is to have a really cheap, programmable chip that doesn't consume a lot of power, then the MSP430 is probably a better bet. 16MHz MCU with admittedly very little memory of its own for about $0.35/ea for a thousand.

Freescale will probably do a Freedom Board with one of these on it, I expect it to sell for ~$13.

Not the chip in the article, but still a Cortex M0+ http://www.nxp.com/products/microcontrollers/cortex_m0_m0/lp... These are about £0.71 at single unit quantities and are very hobbyist friendly in a DIP package. Not sure what I will do with them, but I feel the need to buy 100.

Note that as far as I know MCUs from that series don't have an ADC, which can be a real PITA.

Personally, I've switched to using MCUs in QFP packages a while ago. You get a lot more pins, peripherals, speed, etc for the physical dimensions and price. If you decide to make a custom PCB for a project you don't end up stuck with a huge DIP package or having to evaluate and port the software to a new MCU in an SMD package.

QFPs are perfectly easy to hand solder with the right tools, which are in fact really basic: either a temperature controlled soldering station or a hot air station and solder paste.

I'm now experimenting with QFN packages, which reduce cost and size compared to QFP. Hand soldering seems to work ok, but I have yet to see the yield for small batch manual assembly.

We've worked with an assembly house that does manual assembly for small-quantity (10-20) batches. Usually they ask for extras due to attrition, but so far we've not lost any.

I usually check the quality of their assembly under a 20x microscope. I've only found 1 board that had a bit of stray solder between 2 pins which was easy to clean. So, yes, manual assembly seems to work, but that may depend on the assembler proficiency.

Yep, I keep trying to find an excuse to use then, largely though I end up wanting more IO than you usually find in the DIP ARM packages. With a controller as tiny as those in the article, it should be possible to turn it into a 14/16 pin DIP-like; I'm assuming that you could throw an XTAL on the adapter board, or that you can reduce the pins further since there's likely more than one ground and vcc. It would certainly be a nice toy to play with for projects since I usually don't need more than 10 i/o and if I do, i can get away with shift registers when I need more.

This page: http://www.freescale.com/webapp/sps/site/prod_summary.jsp?co... says "10000 @ US$1.03 each". Not too bad. Not a very hobbyist-friendly form factor, though.

I'm currently playing with a TI Tiva-C development board, and it's great.

http://www.ti.com/ww/en/launchpad/launchpads-tivac-ek-tm4c12...

What os do people run on this?

They don't usually run an OS. But are structured like

  void setup_code() {
    // configure SPI
    // analog to digital converters
    // timers
    // fix internal and external buggy hardware
  }

  void interrupt_handler() {
    TURN_OFF_INTERRUPTS;
    // packet recv
    // time expired
    // etc
    TURN_ON_INTERRUPTS;
  }


  setup_code();
  register_interrupt_handler(interrupt_handler);
  while(1) {
    // application code
  }

Microcontrollers like this only have 2k of working state, the presentable complexity is in the code, not the data.

Freescale provides an RTOS for free called MQX (http://www.freescale.com/webapp/sps/site/homepage.jsp?code=M...) that I have seen used on some projects. Otherwise, bare metal or one of the other standard RTOS options.

There are various FORTHs which run on this and similar chips. Search for M0 FORTH. For example I think this one will run on the Freedom Board:

http://mecrisp.sourceforge.net/

You quite possibly don't run an OS, but there are a number of RTOS stacks available - or some people still brew their own.

an RTOS (uC/OS, Freertos, chibios, ...) or simply a hal such as CMSIS.

Or right on the bare metal.

Bare metal, and preferably Assembly as you need every byte in those 32KB/2KB.

Bare metal: Probably yes, if you don't need the services of an multithreading-OS.

Assembly: probably no. Have a look at what people are doing in C++ on the Arduino platform (the Mega328 has the same Flash/RAM).

Ok, I thought Arduino had more capacity.

For anyone wishing to play with Freescale ARM, a cheap way to get one is the Teensy boards, https://www.pjrc.com/teensy/