.NET Micro Framework

New NETMF Book out for v4.1 and v4.2

2012-01-09T21:46:07Z

Some of our earliest partners from SJJ Embedded Micro Solutions - Sean Liming and John Malin - have written a book on the latest versions of NETMF. The book is targeted at the professional audience, hence the name - “Professional's Guide To .NET Micro Framework Application Development”,but generic enough for anyone. The book provides a thorough background followed by treatments on the processing loop (threads, priorities, etc), hardware interfaces (Serial, PWM, GPIO, A/D, Ethernet), Graphical...(read more)

Version 4.2 RTM Today!! (Updated)

2011-10-04T21:13:25Z

We are glad to announce today the RTM of the .NET Micro Framework version 4.2. You can download the SDK and PK as well as the all sources from our Codeplex project , client_v4_2 branch, at change number 13620 . (We will be distributing 4.2 solely through the Codeplex site this time and not on downloads.microsoft.com) Version 4.2 of the .NET Micro Framework Porting Kit provides the following new features: Remote Firmware Update: The .NET Micro Framework SDK and PK now support updating...(read more)

So you always wanted to be an angel investor

2011-10-04T20:57:42Z

KickStarter.com was a new one for me. There are dozens of interesting projects out there from movies to technology to children’s books. What all these things have in common is that they need grass roots funding. At Kickstarter.com they define a funding target and set a deadline to get it. Then they put together their case and ask you to commit some money towards that target. The cool thing is that no money is collected unless the target is reached. This means...(read more)

Cortex Support on NETMF in Open Source Project

2011-09-12T21:05:27Z

There is a lot of interest in the Cortex M series platforms these days. One reason that these are interesting for very small devices like .NET Micro Framework is that they use a new instruction set – Thumb2 – that is more compact than the one used in ARM processors like the ARM 7 and ARM 9s that NETMF frequently runs on. We have seen about a 20% reduction in the size of our firmware built with the RVDS tools targeting the Thumb2 instructions. While there have been ports done to the Cortex...(read more)

NETMF Version 4.2 Release Candidate 2

2011-08-30T21:19:43Z

We have just posted the second Release Candidate for .NET Micro Framework version 4.2. We decided to do another release candidate so that we could take a few more features from the community and so that we could get a little more exposure to some fairly esoteric bug fixes. So, in addition to the stuff that was already in 4.2, the new release includes: - support for the STM32 family processors form ST Micro. This port was contributed by Oberon Micro Systems (Cuno Pfister and Beat...(read more)

NETMF 4.2 Contributor and a Cool Product

2011-08-24T15:18:22Z

It is great to be able to highlight a valuable contribution to the 4.2 codebase and a cool application of the platform at the same time. The contribution is from Richard Scott at Pulsecor ( http://www.pulsecor.com/ ). People have asked for examples of the kinds of products built using the Micro Framework and here is one of the devices in the medical segment. Richard is responsible for the technical design of Pulsecor’s Cardiovascular medical products. “The statistics are that 1 in 3 people will die...(read more)

NETMF 4.2 – Regular Expressions

2011-08-18T15:38:20Z

With the 4.2 release just around the corner, I wanted to highlight another contributions from the community – specifically in this case, Regular Expressions. This feature was contributed by Julius Friedman. Regular Expressions This is desktop compatible although some features like Capture have a more limited scope (i.e. not all the methods are there). A typical user scenario might be parsing a stream from a serial port like a wireless modem. This implementation is derived from the Jakarta...(read more)

NETMF Student and Hobbyist projects

2011-08-10T16:34:41Z

The last few blogs have highlighted some of the NETMF uses at the Imagine Cup. These are presumably products that are targeting commercial applications and both of these project teams are exploring the road to bringing their products to market. There are also some really cool things happening in the student and hobbyist space that I want to shine a little light on. The first is a great grassroots robotics competition that is driven by the students of UC Berkeley. I spoke with Amy...(read more)

Imagine Cup and NETMF (Part 2)

2011-08-01T16:35:01Z

The team that won the Software Design category was Team Hermes from Sligo, Ireland. This team created an application that addressed the issue of the high rate of traffic fatalities In Ireland with a classically ‘Internet of Things’ solution. They instrumented the car with a device based on a FEZ Panda that plugs into the car’s data interface (the OBD port) as well as supporting their own set of sensors. With this input, they determine the quality of the operators driving instantaneously and continuously...(read more)

Imagine Cup and NETMF (Part 1)

2011-07-29T15:20:11Z

The Imagine Cup just finished an once again there were some great projects as always. This year, even more than in the past, there were a number of projects that included the .NET Micro Framework platform. I have had the opportunity to talk with several of the teams about their projects and their experiences with NETMF. Here is the first one. Technorati Tags: NETMF , .NET Micro Framework , Imagine Cup , Baby Monitor , Kevin Pfister The first team is an stalwart team of one – Kevin...(read more)

Internet of Things and StreamInsight

2011-07-12T13:43:32Z

The Internet of Things (IoT) is gaining momentum with more and more investment from governments and companies being announced all the time. There is still some complexity to the development of solutions in this segment because the solutions require connecting a wide range of computing devices in new ways, standards are still emerging, and frankly the segment is too diverse for a single set of standards anyway. That said, Microsoft has a number of really great technologies in this space...(read more)

NETMF 4.2 – Other CodePlex NETMF Projects

2011-06-27T14:11:32Z

In this latest release of the .NET Micro Framework we have tried to acknowledge some of the great contributions from the community and we will continue to do that. In addition, there are great contributions happening at our partner’s sites. There is one set of contributions that I want to point out that may go unnoticed. There are a number of people working on extensions to the platform that they have elected to put out as separate CodePlex projects and there is some cool and interesting...(read more)

NETMF 4.2 – Porting Kit Studio

2011-06-20T18:47:26Z

Version 4.2 went to Beta a few days ago with an impressive assortment of contributions from the community. One contribution stands out for its scope and ambition. That contribution is the PKStudio contributed by Alexandr Surkov and Igor Kiselev. As anyone who has tried the NETMF Porting Kit, it is not for the faint of heart. It was built for us to use and we have not gotten back to polishing it up. Alexandr and Igor have tackled that problem by analyzing the porting kit and...(read more)

NETMF Version 4.2 Beta now available

2011-06-07T17:24:00Z

Today, we have posted the Beta bits for the NETMF version 4.2 release to CodePlex.

There are some great additional features beyond what we announced for the 4.2 Alpha release (cryptographic primitives, PWM, FTP,…). These include:

...(read more)

Do You Have a Commercial Product Using NETMF?

2011-06-03T23:22:00Z

I am always being asked for examples of what NETMF is used for. I am also frequently surprised by what people are doing with it. Since going Open Source, there is not an obvious way for me to find out what people are doing with the product and the result is that my list of applications is getting a little stale

...(read more)

NETMF at TechEd 2011

2011-05-23T14:11:00Z

Just got back form TechEd 2011 where Microsoft’s smallest platform had the biggest booth (no kidding). We also had a lot of help manning the booth – thanks to all the volunteers there. The word got out that we had some cool demos as well. Here is what we were showing.

...(read more)

.NET Gadgeteer Live as an Open Source Project

2011-05-02T19:06:00Z

Over the last 7 months, we have shown the .NET Gadgeteer to a number of internal and external parties. The response is almost always the same – where can I get one?

...(read more)

New Kits from GHI Electronics

2011-04-28T15:04:00Z

In case you haven’t been out to the GHI site in the last few days, they just announced a new set of kits. These kits are intended to give you an easy on-ramp to building things.

...(read more)

The Curious Cloud Contest

2011-04-19T15:54:00Z

It has been a busy month getting ready for MIX 2011 in Las Vegas last week. We put together a cool challenge for some of the attendees – a challenge that was maybe a little too challenging but still fun.

...(read more)

NETMF 4.2 Alpha Available

2011-03-24T17:06:00Z

I’m a bit tardy on this announcement since the release has been available for almost 10 days now but things are pretty busy here. On March 15th, we posted an alpha version of the 4.2 release. The features that are available in this early look are security improvements, FTP Support, a PWM Object, and a number of fixes to the issues that you have reported in the issue tracker on the CodePlex project.

...(read more)

Thread Communication and Synchronization

2011-02-01T18:16:00Z

After the last blog on Threads and Thread Priorities, readers asked for a continuation on Thread Communication and Synchronization. Before I jump in, I have to reiterate that concurrency is a complex issue. I won’t try to compete with the technical books on the subject that run to hundreds of pages. I will focus on some basic examples of what is available in NETMF to support the concepts introduced in books like that. That means that you can take what you learn here and still get trouble if you are not careful.

Shared Resources – Locking Critical Sections

The most common interaction between threads is through shared resources. We can define a static resource that several threads can interact with. Here is a simple example where I have the main thread and one additional thread – both of which use a counter (s_IncCounter). The main thread prints it out and the worker thread increments it 5 times and then checks its work.

private static int s_IncCount = 0;

public static void Main()
{
Thread thread1 = new Thread(Thread1);
thread1.Start();

     while (true)
     {
         Thread.Sleep(5000);
         Debug.Print("Thread Execution Count = " + s_IncCount);
     }
}

private static void Thread1()
{
     while (true)
     {
         int j = 0;
         for (int i = 0; i < 5; i++)
         {
             s_IncCount++;
             for (int ii = 0; ii < 1000; ii++)
             {
                 j = s_IncCount % 5;
             }
         }
         if (j != 0)
         {
             Debug.Print("s_IncCount % 5 is: " + j.ToString());
         }
     }
}

The output of the execution of this application shows that we are getting slightly fewer than 700 increments every 5 seconds. We will use this measurement to see what the overhead of the thread synchronization mechanisms are. Also notice that the worker thread checks to see if exactly 5 increments have been done. There are no instances where we see that error message. It doesn’t mean that there is not some interaction between the two threads but since only one is writing to the shared resource (s_IncCounter), the interactions don’t have any side-effects.

Now let’s add a second thread. This one exactly matches the first worker thread.

private static void Thread2()
{
    while (true)
    {
        int j = 0;
        for (int i = 0; i < 5; i++)
        {
            s_IncCount++;
            for (int ii = 0; ii < 1000; ii++)
            {
                j = s_IncCount % 5;
            }
        }
        if (j != 0)
        {
            Debug.Print("s-IncCount % 5 is: " + j.ToString());
        }
    }
}

We start both threads in the main thread.

thread1.Start();
thread2.Start();

When we run these, we immediately see that both threads are reporting problems. Thread 1 is being interrupted in the middle of making its 5 increments and then Thread 2 starts up from there and runs some unknown number of times. The result can be seen below.

Even with three threads competing for time slices, the total throughput (increments/sec) do not change. The thread swapping is very low overhead in NETMF.

So, what we are seeing is just one of the pitfalls of a multithreaded environment that is called a race condition. That means that the results of your program are being determined by two threads racing against each other to complete their tasks. That is clearly not what you want. For our program to function smoothly, we need the portions of each thread that work on the shared resource to complete entirely (ie increment all 5 times then then swap out). Stated another way, those lines of code need to execute ‘atomically’ – as if they were one undisturbed machine instruction. Let’s look at the support NETMF has for this.

First, there is the Interlocked class that you saw in the previous article. The Interlocked class lets you perform a prescribed set of operations on a resource atomically. That set of operations that are supported are the methods to this class. The syntax for this is

Interlocked.Increment(ref s_IncCount);

You might not think you even need this lock – isn’t one line of code an atomic thing in itself? In fact it isn’t. To do the increment, the value is copied from the variable and into a register, incremented there, and then copied back to the variable in three separate instructions and the thread can be swapped out anywhere during that time.

What if you need to do more than the Interlocked class supports (a more complex operation on the resource or operations on several resources) and you need it to all complete before someone else can touch the resources. That is where the Lock mechanism comes in. In our example, we want to execute a number of steps on the counter and test what we did before we let anyone else have access to it. To do this, I first define an object that the will be used by the lock to identify it.

private static object s_IncLock = new object();

Now I add a lock that looks like this in each of our threads:

private static void Thread1()
{
    while (true)
    {
        int j = 0;
        lock (s_IncLock)
        {
            Debug.Print("Lock 1");
            for (int i = 0; i < 5; i++)
            {
                s_IncCount++;
                for (int ii = 0; ii < 1000; ii++)
                {
                    j = s_IncCount % 5;
                }
            }
            if (j != 0)
            {
                Debug.Print("s_IncCount % 5 is: " + j.ToString());
            }
        }
    }
}

With these locks, our output no longer has the race condition and the message reflecting the race condition is no longer showing up.

There is an interesting interaction between the Lock and the thread scheduler. Without the lock, each thread would execute for its 20 mSec before yielding. That would be many iterations of the while loop in each time slice. However, the thread scheduler takes locks into consideration in the following way – when each thread asks for the lock, the scheduler sees if there is anyone waiting for that lock. The priority goes to the thread that has been waiting the longest so the two threads we have defined end up executing the lock one time each and swapping back and forth.

The output looks like this:

Swapping out for each iteration through the while loop still does not change the number of iterations in a measurable way. You can see that locking and thread swapping is REALLY low overhead.

MethodImplOptions Attribute

There is a way to lock a method as opposed to a critical section within a method. That is using the MethodImplOptions attribute. The syntax looks like:

[MethodImpl(MethodImplOption.Synchronized)]
public void MySynchronizedMethod()
{
….
}

This locks the method so that only one thread can access it at a time. If one thread is in the method when it is swapped out and another thread tries to access that method, the second thread blocks.

Monitor Class

Before we leave locks, it is worth mentioning that NETMF supports the Monitor class which does effectively the same thing as the lock mechanism – it defines a critical section and blocks other threads from entering that section while there is a lock on it. Monitors are a little more flexible because they are not limited to using braces to define scope. With Monitors, you can exit your Monitor anywhere– possibly in different paths of execution. This flexibility comes with more risk making it easier to have a path of execution where the Monitor does not Exit(object) or Exit(object) is called more than Enter(object) is called.

The NETMF Monitor class is simpler than the full .NET Monitor implementation in that it lacks event wait handles. For those, you have to use the mechanisms described next.

Thread synchronization - Events

At times, you want to synchronize threads directly – ie run this thread when another thread enters some specific state. There are two ways to do this – one general and one used specifically for UI interactions. First let’s look at Events.

Events are the same mechanism that is available on the full .NET Framework with some minor differences. You can define an event that will control the execution of a thread. In the full .NET Framework, there is a richer semantic that supports waiting for one event, one of several events, or all events to occur. In NETMF, we only support waiting for a single event. First you define an event something like this:

static AutoResetEvent autoEvent = new AutoResetEvent(false);

This sets up the event in an initial state of ‘false’.

Now let’s add a third thread to our sample application that looks like this:

private static void Thread3()
{
    Debug.Print(" Waiting for 10000 iterations");
    autoEvent.WaitOne();
    Debug.Print("Finally got the 10000 iterations");
}

This thread is entered on its Start() call and prints out the message that it is waiting for 10000 iterations and then enters a suspended state until the event triggers (becomes true). In the other threads we add a test after we increment:

if (s_IncCount >= 10000)
{
autoEvent.Set();
}

When the event is Set(), the third thread is unblocked and the scheduler will pick it up quickly since it hasn’t run in some time. Thread3 writes out its second message and then exits and the other threads continue as expected.

The semantics of the AutoResetEvent class are that when set to false (unsignalled) it will block any thread calling the WaitOne() method on that event. Once the event is signaled by someone calling the Set() method on that event the AutoResetEvent unblocks the thread and then returns to the unsignalled state once again blocking. The MaunalResetEvent supports a slightly different set of behaviors. The ManualResetEvent also unblocks threads that have a WaitOne() call when the event is Set(). However, the ManualResetEvent does not automatically go back into an unsignalled state one it unblocks the thread. It stay in a signaled state until its Reset() is called. That means that all calls to WaitOne() return immediately.

Thread Synchronization with the Dispatcher

If you have created a graphical UI for your application using NETMF, then you actually have another thread that is created by the CLR – this is the Dispatcher thread that coordinates the access to all of the UI elements in a thread safe manner. The fact that you now have at least two threads means that you have to manage the access to anything that might be a shared resource. Since your UI logic is sharing the UI elements with the CLR created thread which is actually rendering them and there is no way to define a lock that the Dispatcher thread knows about, there is a different way to safely update the UI resources.

The way to synchronize the two threads is to not execute the code that interacts with the UI Elements on your thread but to execute it on the Dispatcher thread instead. To do this, you define a delegate that the Dispatcher will call back to, you implement the delegate, and you call Dispatcher.BeginInvoke when you want the Dispatcher to invoke your method. (There is also a Dispatcher.Invoke call that is synchronous so you need to define a maximum amount of time you will allow this call the wait for delegate to be called.) There is a previous blog on this topic specifically The Dispatcher and DispatchTimer called Using the Dispatcher.

Summary

This is a rather long blog but this is also a fairly complex subject. We have covered Interlocked, locks, MethodImplOptions, Monitors, Events, and (indirectly) synchronizing with the Dispatcher. Hopefully this is helpful.

Technorati Tags: .NET Micro Framework,NETMF,Threads,Thread Communication,Thread Synchronization,Locks,InterLocked,Monitor Class,Dispatcher,AutoResetEvent,ManualResetEvent

Where to find NETMF this Spring

2011-02-01T00:15:50Z

This is a busy spring for conferences for the platform. Here is a partial list of places that you can look for us. Spread the word about these events so that people can get hands on with the product and get any questions that they have answered in real time. You can see what others are doing with the platform as well. It is a great opportunity to grow the community. Embedded World 2011 If you are not familiar with it, Embedded World is the big embedded event for...(read more)

Threads and Thread Priorities in NETMF

2011-01-17T21:32:23Z

I started this article with the objective of providing a more up to date discussion of thread priorities. I thought first that I should cover a little about threads just in case. If you are already conversant in threads, jump ahead to the Thread Priorities section. Threads are a valuable part of the .NET MF programming model. They are particularly useful in the common scenarios where you are getting input from a sensor or communicating with other devices. If you have a sensor for example, it is common...(read more)

A New Book Experience!!

2010-12-16T16:21:45Z

There is a new book that is not completely out yet but I am really excited about it. The book is ‘Getting Started with the Internet of Things’ by Cuno Pfister. ( http://oreilly.com/catalog/0636920013037 ) There are a number of reasons that I really like this book – listed below in no particular order: The Subject Matter: The Internet of Things (IOT) is defined as everyday objects connected through the internet. These can be appliances, cars, health care devices, whatever you can think...(read more)

Need Help Getting Started with NETMF?

2010-12-06T21:45:43Z

Updated with new location. and new content description and translation ‘challenge’ Are you a .NET programmer who needs some background in embedded interfaces? Not sure how to debounce a button or why you might want to do that? Maybe you even need some help with C#? Maybe you are not sure where to start with getting your devices to talk to each other? The folks at GHI electronics (tinyCLR.com) have invested a significant amount of time in building up a beginner’s guide to C#...(read more)