Exploring the Netduino #0: Kickin’ the tires

Every tech head with an interest in PICs and Microcontrollers out there knows about the Arduino phenomenon by now. As described by the Arduino folks themselves:

Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.

Except for those of us who spend the bulk of our time in a modern “managed” code environment like Microsoft’s .NET — Sure, we all got started on languages like ASM, BASIC, C and C++, but having graduated to these higher level languages like C# and Java, it’s really nice to have a modern, intelligent IDE (like Visual Studio) to work with and not have to worry about things like malloc() and garbage collection.

Enter: the Netduino

Looks just like an Arduino, right? Well, that was intentional.  The Netduino was designed to build off and utilize the existing base of Arduino “shields” (add-ons) that are currently on the market. But it does not end there. The Netduino is a micro-controller system designed to run Microsoft’s .NET Micro Framework (NETMF) which allows the developer to leverage all the great things that come from Microsoft:  C#, Visual Studio 2010, Intellisense, etc.

But it’s not just about software. Here’s a table of how the Netduino hardware stacks up to various Arduino boards out there:

	Netduino	Arduino Uno	Arduino Mega 2560
CPU	Atmel ATSAM7X	Atmel ATmega328	Atmel ATmega2560
Architecture	32-bit ARM7	8-bit AVR	8-bit AVR
Clock	48 Mhz	16 Mhz	16 Mhz
MIPS / Mhz	0.9	1	1
MIPS	43.2	16	16
Code	128 KB	32 KB	256 KB
RAM	60KB	2 KB	8 KB
Flash	512 KB	32 KB	256 KB
SRAM	128 KB	2 KB	8 KB
EEPROM	–	1 KB	4 KB
Pins	14 Dig. I/O (4 PWM)	14 Dig. I/O (6 PWM)	54 Dig. I/O (14 PWM)
	6 analog-in or digital I/O	6 analog-in	16 analog-in
UARTs	2	1	4
output limits	8 mA / pin & 16 mA / PWM	40 mA per Pin	40 mA per Pin
Cost	$35	$30	$65

The first thing that should jump off the page at you is the Netduino is nearly 3 times faster than the Arduino! Because the Netduino only seems to get ~0.9 MIPS per Mhz (according to Atmel), it is not quite a full 3 times faster, but it is awfully close. The other thing that should be obvious is that the Netduino has ~30x the RAM and uses a full-fledged 32-bit ARM7 processor. Kick-ass!

Comparing the pages of Netduino’s specs vs. Arduino’s specs, it is a little difficult to compare available memory and storage. The Netduino appears to have a good deal more code storage and RAM than the Arduino, but let us not forget that the Netduino has to run the .NET Microframework (NETMF), while the Arduino compiles its source code down to native binaries for the processor. This naturally takes up less space to store and likely has less overhead since it is not running a framework like NETMF.

Wrapping up the comparison, we can see that the Arduino Uno and the Netduino both have similar pin characteristics: 14 digital I/O pins and 6 analog inputs. Subtle variations include:

• Arduino Uno handling 6 PWM outs vs. Netduino’s 4 PWMs.
• Netduino’s 2 UART (serial) comms vs. Arduino Uno’s 1 UART.
• Netduino’s 6 analog-ins can double as Digital I/Os.
• Arduino Uno can output 40 mA per Pin vs. Netduino’s 8mA.

That last one is a somewhat significant drawback for the Netduino. Each pin on the Netduino can only output 8 mA before risking burning out that channel (or potentially the whole chip.) Netduino’s site notes that the 4 pins that can output PWM can output up to 16mA, while the analog-in pins can only take 2mA.

In other words, don’t get any fancy ideas of “experimenting” with your shiny new Netduino by directly driving a standard 5mm red LED (20mA current draw) with one of the Digital I/Os that can perform PWM. The Arduino can probably take it. The Netduino? Not so much.

This is not really a big deal, though. Power switching should not be done directly with the micro controller. That’s what dedicated transistors (like MOSFETs) are for. And you should be putting a current limiting resistor on that LED anyway…

What else? Well, they do not exactly spell it out for you on their website, but the Netduino sacrifices low-latency for higher MIPS and ease-of-use. Although I have not tested this out myself, I am told that Arduinos can handle events in the microsecond range, while the Netduino is more like the millisecond range.

Depending on the demands of the project, this could be a deal-breaker. But for most folks, I suspect the higher latency of the Netduino will not hold them back.

Next time: Taking the Netduino out for a test drive…