Scott Hanselman

I'm definitely a software person. I took EE in school and made an LED class, then a small computer like everyone else, and I know my volts and my amps for the most part, but that's about it. The limits of my skills are somewhere around adding an LED and some resistors to leech power off a USB adapter (which I recently did while working on the Hanselcade retro arcade build).

I look at hardware guys like Clint Rutkas in awe. I mean, seriously, who builds a T-shirt cannon from scratch for fun? Amazing.

Clint sent me a "Netduino" board today. It's similar to an Arduino board, except it uses the .NET Micro Framework. Micro you say? That's techie-speak for "tiny ass framework." I spoke to Colin Miller about this earlier in the year on video at Channel 9.

Remember my SPOT watch from 2004? That's Smart Personal Objects Technology, which is marketing-speak for "tiny ass framework." That watch is six years old (and still running nicely, sitting on my desk, in fact) and ran .NET.

Fast forward to today and I find myself plugging in this Netduino board to my computer and following Pete's Hello World Tutorial and I'm looking at this namespace.

using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

It's back!

Ok, putting it all together in context. The Netduino is a board that's mostly Arduino compatible and has a published schematic (PDF here) so you could make one yourself, if you wanted. The .NET Micro Framework (or TinyCLR as some folks have called it) is literally that - it's a tiny CLR that runs .NET byte code. You can write C# and it'll run on tiny CPUs with tiny amounts of memory (like 64k or something similarly smallish.) It's been with us all this time, and there is an enthusiastic community built around it.

The .NET Micro Framework 4.1 source is available, it's Open Source under the Apache 2.0 License. (Ya, the new Microsoft is freaking me out also. There's a lot of source that's quietly making its way out under increasingly liberal licenses.) There's lots of great details at Pete's blog.

Here's what a Netduino looks like:

I'm going to think of some hardware ideas that I can build with this. I also have a more capable and fancy Tahoe II with a touch-screen, accelerometer, buttons and more. If you're looking to prototype something quick, or even build a complete system with an off-the-shelf board, do check it out! Here's what a Tahoe II looks like. Remember, all these boards use C# and .NET. It's amazing writing something for hardware using a language and framework I already know how to use. It literally gets me 80% of the way there from a learning curve perspective.

There's also the GHI Electronics EMX Development system, so there's a lot of choices.

With each of these boards (and others) you just need to get the Micro Framework 4.1, then the SDK for that specific board. It integrates into Visual Studio 2010. If you want to change the product, they are taking proposals in the .NETMF Forums.

Directly from Pete's blog:

Getting Started

What you'll need:

• Netduino (Scott: or some other .NET Micro Framework board)
• USB Cable (early Netduino units come with the USB cable) (Scott: Usually a micro- or mini-USB)
• Visual Studio 2010 and the .NET Micro Framework 4.1 SDK  (you can use C# Express 2010 if you don't have Visual Studio)
• Netduino SDK in 32 bit or 64 bit, depending on your host OS.
• Optional: shields and starter kits to do cool things with netduino. Existing Arduino shields are compatible. A shield is just an add-on card that fits the pins on the board.

The SDK installs a device driver for talking to the Netduino. Make sure you select the one with the appropriate bitness, and that you install it before connecting the Netduino to the PC. I installed the VS2010 bits before the SDK, but it shouldn't matter.

Once you plug in the Netduino, using the USB cable, you should see the device driver get installed, and the power LED on the board light up.

Hello World with Morse Code

Now I just have the Netduino for now, so I haven't got any attachments. If I was a hardware guy, I'm sure I'd go try to take apart a toaster or remote control and declare something like "this toaster just needs a one OHM resister on pin-out 5A so I can invert the voltage and it'll toast bread over Bluetooth" but I have no idea what that means. All I can do with the Netduino out of the box to flash its LED, as Pete points out:

public static void Main() 
{ 
   OutputPort onboardLed = new OutputPort(Pins.ONBOARD_LED, false); 
  
   while (true) 
   { 
      onboardLed.Write(true); 
      Thread.Sleep(500); 

      onboardLed.Write(false); 
      Thread.Sleep(500); 
   } 
}

Let's make it fancier. How about outputting string using Morse Code? Wikipedia says a dot is 100ms long and a dash is 300ms. How hard can it be?

I could go to StackOverflow as they had a contest to see who could make the SMALLEST implementation that would take a string and output Morse Code. They have an extremely optimized (for lines of code) solution. But it's extremely silly. Certainly no more silly than me making an LED blink Morse Code as well, but I'd like to be able to actually read my code. ;)

So, here's a naive 10 minutes solution using this guys' two arrays because I'm too lazy to type up the Morse myself. I could have use a Hashtable also, but two parallel arrays was fine too. The .NET Micro Framework, being micro, doesn't have everything the full framework has. However, being open source, it has taken contributions and version 4.1 includes a Hashtable implementation.

I can even debug directly connected to the board!

Here's my sad little program (it was very easy!)

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
using System.Text;
using System.Collections;

namespace NetduinoApplication1
{
    public class Program
    {
        public static void Main()
        {
            OutputPort onboardLed = new OutputPort(Pins.ONBOARD_LED, false);
            
            while (true)
            {
                onboardLed.Write(false);

                foreach (char c in " hello scott hanselman ")
                {
                    string morse = ConvertTextToMorse(c);
                    Debug.Print(c + " = " + morse);
                    TransmitDotOrDash(onboardLed, morse);
                }
                
            }
        }

        private static Char[] Letters = new Char[] {'a', 'b', 'c', 'd', 'e', 'f', 'g',
          'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
          'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8',
          '9', ' '};

        private static String[] MorseCode = new String[] {".-", "-...", "-.-.",
          "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", 
          "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", 
          "...-", ".--", "-..-", "-.--", "--..", "-----", ".----", "..---", 
          "...--", "....-", ".....", "-....", "--...", "---..", "----.", " "};

        public static String ConvertTextToMorse(char c)
        {
            int index = -1;
            index = Array.IndexOf(Letters, c);
            if (index != -1)
                return MorseCode[index];
            return string.Empty;
        }


        public static void TransmitDotOrDash(OutputPort port, string dotordash)
        {
            foreach (char c in dotordash)
            {
                TransmitDotOrDash(port, c);
            }
            Thread.Sleep(300); //gap between letters
        }

        public static void TransmitDotOrDash(OutputPort port, char dotordash)
        {
            if (dotordash == ' ')
            {
                port.Write(false);
                Thread.Sleep(700); //gap between words
            }
            else //it's something
            {
                port.Write(true);
                if (dotordash == '.')
                    Thread.Sleep(100); //dot
                else
                    Thread.Sleep(300); //dash
                port.Write(false);
            }
        }
    }
}

Here's the debug output as I flash "hello scott hanselman" from the board.

All it all, it really couldn't be much easier. Next I'll try to get the Tahoe II working and maybe make a game for the boys. Perhaps hook up a speaker and a proximity sensor and see if they can sneak up on it.

Related Links

• .NET Micro Framework Community Hub - http://www.netmf.com
• http://netduino.com
• Build Your Own T-Shirt Cannon
• Build Your Own Retro Arcade

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By