Solar Tracker

Project Description
This project is deployed to a netduino, it uses a Arduino Compatible Mega Motor Shield, a linear actuator and a photocell out of a garden light to move a set of solar panel so that they face the sun throughout the day.

Required components
Netduino version 4.2 .NetMF

Motor shield http://www.robotshop.com/ca/arduino-compatible-mega-motor-shield-1a-5-28v-2.html

12V DC 12 in. Stroke Linear Actuator

Completed unit

And of course the source is available (which is the real cool part of this project)

Here's the Program.cs. It gives you a real nice feel for all the features to play with and code to check out...

public class Program
{
     private const int IterationTimeout = 5000;
     private static LinearActuator _linearActuator;
     private static LightSensor _lightSensor;
     private static readonly LcdText _lcdText = new LcdText();
     private static Thread _workerThread;
     private static long _lastTime;
     private static bool _setup;
     public static void Main()
     {
         _workerThread = new Thread(UpdateLCD);
         _workerThread.Start();
         InitializeActuator();
         InitializeLightSensor();

         var button = new InterruptPort(Pins.GPIO_PIN_A3, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
         button.OnInterrupt += button_OnInterrupt;

         Thread.Sleep(Timeout.Infinite);

     }


     static void button_OnInterrupt(uint data1, uint data2, DateTime time)
     {
         var currentTime = time.Ticks;
         var delta = currentTime - _lastTime;
         if (delta > 500)
         {
             _lastTime = currentTime;
             if (_setup == false)
             {
                 _setup = true;
                 if (_linearActuator.IsTracking == false)
                 {
                     _linearActuator.SetupDaylength(_lightSensor.LenghtOfDaylight.Ticks / TimeSpan.TicksPerMillisecond);
                 }
             }
             _linearActuator.Step(null);
             _lcdText.DebugLine2 = "Force step, Pos:" + _linearActuator.CurrentPosition;
         }
     }


     private static void UpdateLCD()
     {
         var lcd = new Lcd { Visible = true };
         lcd.Clear();
         lcd.ShowCursor = true;
         // set up the LCD's number of columns and rows: 
         lcd.Begin(24, 2);
         bool toggleDebug = false;
         while (true)
         {
             lcd.Clear();
             if (toggleDebug)
             {
                 lcd.SetCursorPosition(0, 0);
                 lcd.Write(_lcdText.DebugLine1);
                 lcd.SetCursorPosition(0, 1);
                 lcd.Write(_lcdText.DebugLine2);
             }
             else
             {
                 lcd.SetCursorPosition(0, 0);
                 lcd.Write(_lcdText.ActuatorText);
                 lcd.SetCursorPosition(0, 1);
                 lcd.Write(_lcdText.SensorText);
             }
             toggleDebug = _lcdText.HasDebug ? !toggleDebug : false;
             Thread.Sleep(IterationTimeout);
         }
     }

     private static void InitializeActuator()
     {
         _linearActuator = new LinearActuator(_lcdText);
         return;
     }

     private static void InitializeLightSensor()
     {
         _lightSensor = new LightSensor(_lcdText);
         _lightSensor.Dusk += LightSensorDusk;
         _lightSensor.Dawn += LightSensorDawn;
     }

     static void LightSensorDawn(object sender, EventArgs e)
     {
         _linearActuator.GoEast();
         // start tracking
         _linearActuator.StartTracking(_lightSensor.LenghtOfDaylight.Ticks / TimeSpan.TicksPerMillisecond);
     }

     static void LightSensorDusk(object sender, EventArgs e)
     {
         // stop tracking and return to east
         _lcdText.ActuatorText = "Waiting for morning";
         _linearActuator.GoEast();
     }
}

.NET Gadgeteer Core 2.42.700

The .NET Gadgeteer Core installer includes the core libraries and end user project templates for Microsoft .NET Gadgeteer. This is a prerequisite for end users to build and deploy .NET Gadgeteer projects. It includes a project template wizard in the New Project dialog in Visual Studio 2012 or 2010 (or express versions) under the Gadgeteer tab - ".NET Gadgeteer Application". This template uses a graphical designer built for Visual Studio which allows end users to visually configure .NET Gadgeteer hardware builds and then write the software logic for that hardware in C# or Visual Basic.

The .NET Gadgeteer Builder Templates installer is for hardware vendors who are building modules, mainboards or kits comprising multiple modules/mainboards. This adds additional project templates for modules, mainboards and kits. Each template includes instructions on how to use it, and automatically builds an MSI installer which can be distributed to end users.

If you are a prospective module or mainboard builder you should also look at the Module Builder's Guide and Mainboard Builder's Guide, which includes the full specifications for what it means to be ".NET Gadgeteer compatible" and other helpful examples and guidelines.

Neither installer includes libraries for specific hardware modules/mainboards, so by themselves these installers do not enable users to use .NET Gadgeteer hardware. Hardware manufacturers should release installers (based on the templates above) for their hardware.

================================================================
Microsoft .NET Gadgeteer Core
RELEASE NOTES
Version 2.42.700 19 April 2013
...

================================================================
Change Log
================================================================
Version 2.42.700, 19 April 2013
MAJOR CHANGES

• VS 2012 support (if using NETMF 4.3 SDK) added alongside VS 2010 support (using NETMF 4.2 or earlier) (When using VS 2012 you can target NETMF 4.2 or 4.1 devices too)
• Visual Studio Express 2012 for Windows Desktop support (and older 2010 Express version support maintained)
• Application template wizard which checks for compatibility between VS, NETMF SDK and mainboard
• Power consumption data is specifiable in GadgeteerHardware.xml schema and shown in VS designer

MINOR CHANGES

• Socket type D and H compatibility check fixed
• Managed software I2C (used by DaisyLink) uses repeated start condition when appropriate
• Added StorageDevice.DeleteDirectory method and fixed StorageDevice.Delete to delete files
• Text templates no longer used by designer, avoiding permissions warning
• License updated to clarify that VS extensions are binary-only

**** ALPHA SUPPORT *****
This release also includes alpha support for the following. This is for evaluation purposes only, and features may change.

• NETMF 4.3, with feature changes:
• AnalogOutput uses NETMF native support

...

And remember, the source for all of this, and even some 3D models, are available;

Laurent Ellerbach has been building some pretty cool .Net Micro Framework projects for a while now. Here's just a few;

• Lighting my Lego city using .NET Microframework
• Using XMLHttpRequest to pilot a Lego train dynamically in HTML 5
• Also see: Display overlay images in HTML and javascript with .NET Microframework
• Some hard to pilot a Sprinkler with .NET Microframework
• A low cost humidity sensor for my sprinkler system
• A soil low cost humidity sensor (moisture) and .NET Micro Framework (NETMF)

Web Server and CSS files in NETMF (.NET Microframework)

But I will start with the modification of my Web Server to support CSS file. I did couple of demonstration of my development and each time I show the interface people were telling to me I need to work with a designer. And that’s what I finally did  I worked with Michel Rousseau who is designer at Microsoft in the French team. And I gave him a challenge: “Design this simple web page without changing the code too much and keep it less than couple of K without any image”. Michel is used to design Windows 8 and Windows Phone apps but not very very simple page like the one I had.

And he has done an excellent job! Here is the view before and after:

Now I had to implement this in my code. As the brief was to have minimal effect on the code, I was expecting to implement this quickly. Reality was a bit different. It took me a bit more time than expected for the following reasons:

• I had to implement in my basic web server a function to be able to download a file (the CSS one)
• To read and download a file from an SD, you have to do it by chunk as the buffer size is limited (in the case of my Netduino 1024 bit)
• Modify the main code to care about downloaded file and also add the lines of code to support CSS
• But the main issue was that I’ve discovered that to be able to have a CSS file, you need to have the specific type “text/css”. This is to avoid cross domain fishing and other hacking

So let see how to implement this step by step. So let start with the reading part of the file and how to send it. As explained in the last point, a CSS file has to have the correct mime type in the header. In fact, Internet Explorer and most of the other browsers such as Chrome and Firefox does not need the mime type to determine what kind of fire you are downloading. They do it with the mime type and/or with the extension. Most of the time, it’s just with the extension and reading the header of the file. But for security reason, it’s better if you have to determine correctly the type matching with the extension and the header of the file. And for CSS, it is forced like this to reinforce the security in Internet Explorer 8, 9 and 10.

So as I had to implement this feature for CSS, I made a simple function to support some types I’ll use in other creation:

...

Want to just jump to the source?

.NET Microframework (NETMF) Web Server source code available

So as I got lots of asks to get the code of my Web Server, I’ve decided to create a Codeplex project. You’ll find the source here: https://netmfwebserver.codeplex.com/

It does include the following features:

• Start, stop, Pause the Web Server
• Creation of a Web Server on any port
• Fully functional multithread Web Server supporting GET only
• Downloading any file present on a SD (or any other physical storage)
• A full function to get all the parameters of a URL

Now your next .Net Micro Framework and be an web providing for the Internet of Things...

NetDuino Solar Monitor

The Netduino Solar Monitor accesses data from a Midnite Solar Classic charge controller using the Modbus protocol or the Outback Flexmax controller using the serial interface. The solar monitor can also monitor information from a Outback FX inverter using the serial interface. The Netduino Solar hosts an embedded web server that displays the pages below which can be viewed on a smart phone or tablet.

Installing/Running/Building? Check the Documentation page;

If you simply want to install this application onto a netduino plus 2, please follow these steps;
1. Download the NetduinoSolar.zip file from the 'Downloads' area.
2. Unzip to a temporary location on your PC.
3. ...

If you want to use the emulator, please follow these steps

1. Follow the instructions at http://netduino.com/downloads/ to install the required .Net Micro Framework SDK.
2. Once you have the SDK installed, you can use Visual Studio (Express) to deploy the application to the netduino or you can run the application within the emulator when you select the 'Debug' target.
3. ...

The Netduino and the charge controller should be connected to a wireless router. The charge controller must be setup with a static IP address, this address must then be entered in the settings tab of the NetduinoSolar application.

The status page viewed by browsing to the configured deviceIp address which can be configured along with the subnet mask and gateway address by editing the SolarConfig.ini file.

If you are going to be monitoring an Outback controller or inverter, you will need an RS232 interface for your Netduino. Pins 4 (DTR) will need to be driven high and pin 7 (RTS) will need to be driven low in order to power the Outback Mate serial interface. An interface card such as the Pololu 23201a Serial Adapter can be used.

...

...

Netduino Solar parts list
Required components;
1. Netduino Plus 2, firmware rev 4.2.2 (https://www.sparkfun.com/products/11608)
2. 2 Gig micro SD card, netduino does not support more than 2 Gigs (http://www.tigerdirect.com/applications/SearchTools/item-details.asp?EdpNo=2882538&CatId=3610)
3. 9 volt AC adapter (https://www.sparkfun.com/products/298)

Optional components for access to Outback Mate;
- RS 232 serial adapter (http://www.pololu.com/catalog/product/126)
Optional LCD display;
- 24x2 Line LCD Module HD44780 (ebay)
Optional power supply to run netduino and router directly off the (24V) battery bank
- LM2596 DC 3A Step-Down Adjustable Breadboard Module Power Supply Converter (ebay)

• Hardware? Check.
• .Net Micro Framework? Check
• The new Windows Azure Mobile Services? Check
• Azure Web Site? Check
• Quick project to bring this all together for the fun of it? Check!

Here's a summary that says it all...

This is a little demo pulled together over the weekend to demonstrate that we can do some really cool things using Mobile Services and embedded devices! - the dataflow is basically the following:

• Temperature and Humidity data captured on using .NET Micro Framework 4.2 on Gadgeteer GHI FEZ Spider
• Data is then inserted into mobile services using a thin slice of the Mobile Services SDK that i ported to .NET MF. It was slow going as in the .NET MF there is no support for generics, json serialization, no linq and limited reflection capabilities sort of like coding back in .NET 1.1
• Mobile Service Insert Script sends collected data to this browser via Pusher - one of our store partners
• Windows Azure Web Site Web client subscribed with Pusher and shows update live data on graph in near real time

Devices + Services: Near Realtime Sensor Data with Windows Azure Mobile Services, .NET MicroFramework, Pusher and ASP .NET MVC

It’s no surprise to people around me that I have a strong desire to code more, so I did just that on a Saturday several weeks back and here is what I built – a new devices + services scenario using a Gadgeteer, the .NET MicroFramework, Windows Azure Mobile Services and Pusher and Windows Azure Web Sites.

...

Capturing Sensor Data

For this scenario I am using the GHI Gadgeteer FEZ Spider and I have already installed all the pre-req software from GHI   An embedded device that runs the .NET MicroFramework and has a bunch of plug and play sensors for rapid prototyping.  To collect the sensor data is quite straight forward

...

Storing the Sensor Data in Mobile Services Ok the first thing that you will need to do is Create a Mobile Service. Within the Windows Azure Portal Click New+

...

Sending the sensor data to listening clients using Pusher

This is where things get pretty sweet. I wanted to visualize my sensor data in a graph as it arrived in my Mobile Service. Recently we announced a new Windows Azure Store partner – Pusher a  WebSocket Powered Realtime Messaging Service.  Within the Windows Azure Store you can quickly provision a Pusher account and utilize it from Mobile Services within minutes as follows.

...

Graphing the data received via Pusher in a web client running on Windows Azure Web Sites

So now we had our sensor data collected, inserted and stored in Mobile Services and then pushed using pusher to any listening clients.  What I wanted was a web client to visualize the data in a graph as it arrived. You can learn how to create a free Windows Azure Website using ASP.NET MVC and deploy it to Windows Azure here – http://www.windowsazure.com/en-us/develop/net/tutorials/get-started/

...

If you read through the code you will see pretty clearly that the Pusher implementation is 3 lines of code only – to me this is extremely cool. Itty bitty amount of code, phenomenal cosmic power!

So that’s it now we have live graphs on our website, you can checkout a running version of this code and it live graphs that I deployed to a Windows Azure Web Site here – http://microframework.azurewebsites.net

How much does it cost

Everything that I did here can be done for free with Windows Azure Windows Azure Free Trial and/or the great free tier offerings for Windows Azure Web Sites, Windows Azure Mobile Services and Pusher.

Where’s teh codez?

This is unofficial, is not supported – I did it in my free time and it Works on my machine!   disclaimers all being said I really hope that this does open up a lot of doors for you for building out a whole new range of devices + services scenarios using Windows Azure and our Store Partners You can download the .NET MF lib and sample code from this github repo

Summary

I hope this has opened the door to great new devices+services scenarios you can build out for your .NET MicroFramework solutions. With few lines of code and powerful services like Windows Azure Web Sites, Windows Azure Mobile Services and Pusher you can make working in the emerging embedded devices + services space a lot easier then it has been in the past. Please do let me know if you have built something awesome in this space on the Twitterz @cloudnick

Check, check, check! Got to love that you can do all this cloud stuff for free!

So what are you waiting for? Get building your cloud connected projects!

The best part of all is that it's not really a project as much as it is a "teach you to fish all the while creating an awesome thing" kind of... well... thing.

Demo connecting 11 Netduinos to Windows Azure Service

I put together a talk that includes a lab on building a security/home automation system using 11 netduinos communicating over MQTT with a broker located in Windows Azure.  The attendees of this talk will walk through the lab and build out various components of a security system.

Here is a video demonstrating the various components of the system.  

...

My Security

Overview

This project was created to show off some fun things you can do to get started in the Internet of Things craze. This project was never intended to be an actual working Home Security system so don’t try and use it for that unless you really think about addressing some of the internet security issues that need to be tackled with a project like this. Please use this code as an example only!

Each device that is connected to the system's central hub will perform a specific function in the security platform. In a real security system you wouldn’t have mission critical devices dependent on external connectivity to the cloud. The connectivity to such an external system could be easily disrupted. Again this is just a fun example to get you thinking about connecting many devices to a cloud service.

The hardware used for this project is the Netduino Plus 2 from Secret Labs LLC. All code samples you see on this sight will target the Netduino Plus 2 device. However, the protocol to communicate with the cloud service is not platform specific so any device can be used to communicate with the Home Security service. So feel free to use a different .Net Micro Framework device. You could even use one of the very popular Arduino devices.

Of course the cloud service part of this project is running on the Windows Azure Platform. There are so many options available to you with the Azure platform. I decided to use a small subset of the features available just to prove that it doesn't take a lot to get something going on the Azure platform.

Where to start

As a participant in this project you will be building the devices that complete the Home Security system. Some basic code will already be written for you but for the most part it will be your job to complete the code and make the device functional. The cloud service that connects the devices is already completed and deployed to Windows Azure for you to use, so you wont need to do any of that coding. However the code for the cloud service is available in source control for you to look at.

• Documentation - This is where you will spend most of your time because it contains all the documentation to complete the lab exercises.
• Getting Ready For the Meeting - All the information you need to come prepared for the event.
• Azure Source Code Repository - All the source for the Azure components of the security system.
• Netduino Source Code Repository - All the source for the Netduino components of the security system
• Dashboard - This is the Home Security Dashboard where you can see the status of a device and interact with it
• Slide Deck - The slides for the presentation

Documentation

What do I need

Before you attend this event you need to get a few things in order. We don't have a lot of time during the event to spend it setting up your development environment so make sure you check out Getting Ready For the Meeting.

What will I be doing

You will be building one of the following devices in the home security system:

• External Door Entry- This device handles all the I/O for any External Door
• Door Bell- This device handles the I/O for letting the user know a door bell was pushed
• Alarm- This device handles the I/O for letting the user know the alarm was tripped
• Alarm Control Panel- This device handles the I/O for the control panels placed in each room of the house
• Master Control Panel- This isn't really a device (but it could be) and it is already built for you. I am calling it out here because without it the entire system would be a bunch of devices that are independent of one another with no real central control managing the whole security system logic.

Determine which one of the devices that you want to attempt to build. Some of the devices are harder to complete than others. If you want to start out easy then you can do the doorbell device. If you want a tougher challenge then go ahead and try the Alarm Control Panel.

There will be some code that is already written for you so that you don't have to worry about the communication protocols needed to publish and subscribe to the MQTT message bus. Since the protocol is abstracted away from you all you need to know is that the MQTT messages are basically made up of two parts: a Topic and a Message. There is a lot more to the MQTT standard that you can read up on your own but you won't need it for this project. Basically, topics are a series of words separated by a / topic separator. The message is simply any string. The devices on the bus are expected to understand the topics and message formats, but like all pub/sub designs the devices don't know

...

What is running in the cloud

There are two main components that already exist in Azure that the devices will interact with: MQTT Message Broker and Master Control Panel. The message broker runs under an Azure Worker Role. The Master Control Panel runs in Windows Azure Web Role. The broker simply routes MQTT messages and has no real home security specific business logic on it. The Master Control Panel manages the state of the security system as well as the business rules around how the security system functions as a whole. SignalR is used to update the client browsers when the state of the security system changes. Take a look at the Master Control Panel for more details on how it functions.

...

As you can see, pretty awesome. If you're in his area, make sure you see him, and build this project with him... Scroll to the bottom of http://www.cloudhomesecurity.com/ to see where and when.

Just kidding... but with all the cool work Matt, aka RogueCode, has been doing, and which we've been highlighting, it kinds of feels that way doesn't it? Now if only the stuff he was doing wasn't just so darn cool.

We have just about everything in this project. Hardware, electronics, development, mobile even 3D printing!

Netduino + WP8 real-life maze game

When I was young my parents bought me a wooden maze game. I loved that thing. I don’t think I ever cared much for the actual maze element – but the mechanism to tilt the stage was intriguing, and very simple.

When I remembered it the other day I managed to both find it online, and actually find my original one in an old cupboard from storage.

Moving on a decade or two, we now have hundreds of these ball games on smartphones using their accelerometers (like this one – a random one from the WP store), but their graphics leave a lot to be desired. Which is why I’ve made a photorealistic one

The objective was to make a maze game that was a merge between the old-school and new-school ones. So the phone is used as a tilt controller to control the physical maze via Bluetooth with a Netduino. The maze is a simple model printed on my 3D printer and is tilted by using two servos. Bonus points for adding a switch mechanism to report back to the phone when the player gets to the end.

What you need:

• 2 fairly strong servos. I used Turnigy metal-gear ones from HobbyKing.
• Bluetooth module
• Netduino
• Small square maze-like object
• 10K ohm resistor
• 4.8V battery pack
• Conductive ball-bearing/marble

The maze:

This probably took longer than all the other parts combined because my 3D printer’s extruder nozzle jammed up rather solidly. And even when I did eventually get it to print, the result was pretty terrible. However, the actual maze model at the end of this post is perfect and will print fine on your printer if you have one. I printed it 9CM x 9CM because that is about the biggest my Makerbot Thing-O-Matic can print.

To make the model, I first went to http://www.mazegenerator.net/ and generated a 9X9 maze. Then imported the result into SketchUp, traced out the lines, and extruded the walls up. I only made the walls high enough to steer the ball – not encase it.

And of course, Matt's made everything that can be downloaded, downloadable...

Rock-Paper-Scissors with Netduino and Arduino

Been constantly persuaded by my 6 years old daughter to play Rock-Paper-Scissors I decided that we can make it a bit more interesting, so I’ve put following schematics on the prototyping shield:

Netduino and Arduino are pin compatible, but the output voltages are different: 3.3V for Netduino and 5V for Arduino. For current limiting, I’ve selected 150Ohm resistor to avoid changing the elements, when change the platform. The 10K pull-down resistors assure false state on the digital inputs until button is pressed.

What the code is doing and how to play:
After MCU initialise, RGB LED becomes steady GREEN thus indicating first player’s move. In secret from the other player, press the chosen button (from left to right in order: ROCK, PAPER, SCISSORS). RGB LED becomes steady RED and now this is the second player’s turn (at that stage of the game, the player may not press the button in secret any more). After the second player’s choice, the RGB LED will flash with the winners colour: GREEN (first player), RED (second player) and BLUE for TIE. Few seconds later, game restarts and you can play again.

BTW, while your there, make sure you check out his Netduino for beginners tutorial! (Yes, it's a two for one kind of day...

C9'ers, this is Mario Vernari. Mario Vernari, this is C9'ers...

A simple yet versatile GDI library for Netduino.

This is my second attempt of making an hardware abstraction against a limited UI which can be connected to a Netduino. Most of the times, you can drive a character LCD module or something like that, but no complex displays unless some native library or hardware helper will come in rescue. That's because they require a lot of resources, such as RAM as well as CPU speed. However, until you write apps in managed C# on a Netduino, both of them are very limited.

That's the way I considered only very simple displays, and -why not?- the nice led matrix presented in my previous article.

I don't think to have discovered anything new: I took "inspiration" by the old Windows GDI (Win 98 and earlier), mixed with some elegancy of the newer GDI+ (XP). By the way, GDI+ is the one exposed by the .Net Winforms APIs. Instead, the challenge was to create the very minimum to be able to (literally) play with, without forgetting a decent performance.

Step-by-step usage of library with the Sure Electronics led-matrix.

The library usage should be pretty straightforward. However, a basic knowledge of the Windows GDI/GDI+ and/or Winforms Graphics will help a lot. I don’t teach here anything about it, because it is very well explained in many places, and there are thousands of good examples.

Instead, here I just want to show you how to proceed, step-by-step, for a very basic app. As a minimal example, this app won’t have any animation, but creates only static images on the display. Animations aren’t particularly different, but it require a bit of ability on manage the graphics at best, due the limited performance.

Here we go!

...

Animation with the GDI library for Netduino.

As promised, here is a tutorial on how create a basic animation with the GDI library for Netduino and the Sure Electronics HT1632 led-matrix module.

There's nothing special behind it: the process is exactly the same as drawing a static composition, but the sequence of frames is performed many times in a second. The deal is managing the drawing composition on every frame in the quickest way, that require a pretty good knowledge of the library and the framework itself.

Frame rendering: choosing an approach.

There are two approaches on how manage the animation.

The first way is running all the rendering in a tight endless-loop, so that the frame rendering sequence will be as fast as possible. The actual frame rate is not known a priori, but it varies upon the amount of work to be done for the graphics composition. Thus, when a frame is relatively simple, the frame rate will be high. Instead, when the composition is rather complex, you'll experience a poor, jerky animation.

Another way is constraining the frame rate at a certain value (e.g. 20 frames per second). This should ensure the same animation quality in any context, but requires a much more careful development of the composition. In fact, you must be sure that, in any case, no composition will take longer than the maximum allowed (in the example of 20 fps, no longer than 50ms).

I'd prefer the latter, but there are pros and cons in both of them. 

Although you may choose the best approach you'll like, you have to deal with short timings of composition in any case. This is the only real task to deal with.

To measure the framing time, I used a simple trick. An OutputPort is taken high on the very beginning of the composition, then pulled low at the end. The high-level duration is measured with the scope (or any logic analyzer), and gives an approximate time of the task.

The bouncing-balls example.

This tutorial will cover an example on how to animate one or more "balls", each one actually drawn as a framed rectangle, and bouncing against the virtual bounds of the display viewport.

The program is structured to animate an array of "Ball" instances, thus you can experience how long takes animating just one or a series of them. A similar project is also interesting for inspecting what and where can be optimized.

Let's start back from a generic application, as seen in this article.

...

The GDI library for Netduino targets a LCD module.

In this post I will show how the GDI library for Netduino can be used for a generic LCD character module (typically HD44780 driven).

The library abstracts the physical layer pretty well, although it’s rather hard to ignore the huge differences between a colored led-matrix and a back-and-white display.

First off, as said, the colors are just two: black and white. Better: blank and shaded, because there are LCDs which displays dark dots on a bright background, but also other models which displays bright dots on a dark background. To mimic the blending as in the led-matrix case, I considered the “Black” as blank (inactive) and the “White” as shaded (active).

Secondly, this kind of LCD module is structured as a character-matrix, so it has an intrinsic ability to display a character. For the led-matrix there’s a font-oriented character generator, which compose the character pattern using the display’s dots.

Thirdly, in a character-oriented LCD module, you cannot target a single “pixel” (meant as a single dot of a character). The “pixels” are something inaccessible from the outside interface, which understands the “character-entity” only, instead.

The hardware and the “old” LCD Boost library.

This project actually replaces the old LcdBoost library, but just for the software side. The hardware is still the same, because it works fine and it’s very fast compared to other solutions.

So, before dealing with the step-by-step tutorial, you should wire up the hardware. Here follows the Fritzing board-view of the circuit.

...

A playable Invaders-like game with a Netduino Plus 2.

This is not the very first time an Invaders game has been developed for the .Net Micro Framework (check here), but it should be the very first developed for a Netduino-sized board.

The goal of this post is not give you a game, rather demonstrating how is simple create a pretty complex application using the GDI library for Netduino. Moreover, the good performance of the library as well as the physical layer (driver and hardware) yields the ability to control both a led-matrix and a LCD module at same time.

Of course, for the game to be playable, we also need a minimal controller. A simple sound generation is also provided.

How it's made?

I won't go deeper in the details of the app, because any good programmer can put his/hers hands on it. Instead, I'll go to describe the circuit structure, which is far form being complex.

All the hardware is composed of the following "components":

• a Netduino (Plus) 2;
• a Sure Electronics led-matrix module (introduced here);
• any common LCD character-module (I used a 4x20 one);
• three pushbuttons as the game-controller;
• some parts for the sound generation (optional);
• a good 5VDC power supply (I used a LM7805).

...

Hardware, code and some space-invaders... Looks like you've got some fun stuff to play with this weekend, don't you?

I mean how can you not dig a Windows Phone 8, Netduino, Sonar and the Star Wars Imperial March all in one project!?

But first...

More Netduino + WP8 + Bluetooth fun- 3D reconstruction

Following my previous post on Bluetooth with the Netduino, I thought I would extend it a bit.

The goal for this project is the following: Have a Netduino sending it’s orientation data (XYZ) over Bluetooth to WP8 which displays a 3D representation of it (at the right angle of course), and for bonus points attach a potentiometer to control the zoom.

In the video above, as with the last one, the Netduino is only plugged in because I don’t have a 9v battery lying around. And you might notice a few MS of lag – that’s due to the smoothing filters. It’s possible to get the movement to just about real-time (Bluetooth is impressively fast) but then you also get all the fluctuations of the accelerometer.

...

For the phone app I’ve copied pretty much the entire code from the last post. Some is commented out because it referenced UI stuff that isn’t in this project. Because the previous post covered all this, I’m not going to go into any of that code.

So how do we show a 3D model? Well, in my opinion the easiest way is XNA. However, Microsoft killed XNA on WP8 (and W8) leaving native code as the only way. Enter: MonoGame. MonoGame is a framework that enables XNA developers to write one code base and have it run on many different platforms. So even though XNA isn’t officially supported on WP8, we can still use MonoGame – which is pretty much identical (at least for anything we’re going to be doing). Here is their explanation of it:

...

Okay, okay.. I know, "Star Wars!...", here you go...

Netduino + Sonar + WP8 + Bluetooth - Controlling sound with your mind

OK, maybe not with your mind, but at the very least, your hand.

The objective here was to add a sonar (ultrasonic) sensor to the Netduino, work out how close my hand was, and then send that info over Bluetooth to Windows Phone 8 and display it. Bonus points for doing something useful with the data (yes, controlling the volume of the Imperial March is totally useful!).

What you need for this is:

• Netduino or variant
• Sonic/sonar sensor
• Bluetooth Module
• Windows Phone 8

...

few months ago I bought this Sonar sensor: HC-SR04 (http://lightake.com/detail.do/sku.UltrasonicSensorHCSR04DistanceMeasuringModuleBlueSilver-58594). I got it from a random little online Chinese shop for $4. I literally just bought it to see if they would actually deliver (free worldwide) because they have quite a big range of Arduino/Netduino sensors and it’s hard to get things locally. Surprisingly it actually came.

So last night I opened it, tweeted, and plugged it into the Netduino:

VCC   -  5v
Trig   -  D6
Echo  - D7
GND  - GND

This site has a great explanation about how these work: http://arduino-info.wikispaces.com/UltraSonicDistance

They have two transducers, basically a speaker and a microphone.
Ultrasound is a high frequency sound (typically 40 KHz is used). A short burst of sound waves (often only 8 cycles) is sent out the "Transmit" transducer (left, above). Then the "Receive" transducer listens for an echo. Thus, the principle of ultrasonic distance measurement is the same as with Radio-based radar.

After understanding it I started coding a little helper to do the math for me, and realized that someone would have done this before – and proceeded to find this perfect little class by J Wilson on the Netduino forums: http://forums.netduino.com/index.php?/topic/3256-library-for-hc-sr04-ultrasonic-rangefinder/

Download that class and add it to your Netduino project.

...

Create a new WP8 project just like before and add the Bluetooth stuff like in the first post.

Then I have a very simple UI. It’s got a ProgressBar to visualize the volume, a MediaElement to play the song, and some TextBlocks to show the current value.

 

This would have probably been a good time to show a very basic use of MVVM, but I will leave that for another day.

Besides the Bluetooth code, there is really only one method that does all the work here, and it’s really simple. This method is called when a message is received over BT. The message in this case will be the CM distance value from the sonar sensor:

...

And yes, of course the source is available for both projects...

• [0:56] CTP for Visual Studio 2012 Update 2 (VS 2012.2) is available (Brian Harry), February CTP for Visual Studio Update 2 (Charles Sterling)
• [1:47] Embracing Semantic Logging, Introducing Semantic Logging (Grigori Melnik), Codeplex site.
• [2:51] [Sample Of Feb 13rd] Project SaveAs VS extension (Philip Fu), http://code.msdn.microsoft.com/VBVSXSaveProject-65a4f335
• [4:01] Introducing Simple.OData.Client: a portable OData client library for .NET4.x, Windows Store, Silverlight 5 and Windows Phone 8 (Vagif Abilov)
• [5:32] Simple golden rules for async / await (Nigel Sampson)
• [6:22] Windows 8: Working with Semantic Zoom using C# and XAML (Mahesh Sabnis)
• [7:34] Make your app more attractive to customers in the Windows Phone Store (Kami LeMonds)
• [8:36] Create a blog reader Windows Store app using JavaScript and HTML
• [9:42] XAML Introduction (Shahid Aziz )
• [10:54] Visual Studio 3D Starter Kit (Windows Store only), Visual Studio 3D Starter Kit (Windows Phone only) (Roberto Sonnino)
• [11:55] Game Design [Storyboard] Shapes

Picks of the Week

• Nisha's Pick of the Week:[12:55] BLINK
• Brian's Pick of the Week:[13:42] Windows Phone 8 Bluetooth -- Fun with Gyros, Windows Phone 8 Bluetooth – Sonar and Imperial March (Matt aka @RogueCode ) [Found Via: Chris Walker]

To give credit where credit is due, I found via Hack A Day's, Gas sensor suite built with Gadgeteer modules post.

Gadgeteer Gas Sensor with ThingSpeak

Gadgeteer Gas Sensor demo using ThingSpeak. The ThingSpeak site for this project is available to the public at https://thingspeak.com/channels/3512 while I test different gas sensors. I'd like to thank Paolo for his excellent ThingSpeak libraries which I got from his CodePlex 'μPLibrary - Net Micro Framework Helper Library' which is available at http://uplibrary.codeplex.com/ Source code for this project is now available at http://www.tinyclr.com/codeshare/entry/607 The Gadgeteer Framework site: http://gadgeteer.codeplex.com

Gadgeteer Gas Sensors and ThingSpeak

A demo of how to use ThingSpeak (an IOT web site) with a Gadgeteer Gas Sensor Device. Data from the sensors are displayed in real time on ThingSpeak and using some of ThingSpeak's cool features the Gas Sensor device can send out Tweets for Alert and Alarm conditions. A very special thanks to Paolo for his ThingSpeak libraries which I got from his CodePlex 'μPLibrary - Net Micro Framework Helper Library' project at http://uplibrary.codeplex.com You can visit the ThingSpeak channel for this projects at https://thingspeak.com/channels/3512 while I'm testing different gas modules.

https://thingspeak.com/channels/3512

And as mentioned the source for the project is available too!

With the .Net Gadgeteer, a few components, a few libraries, plug and play and your creativity and you've got your own cool thing...

Controlling a Netduino over Bluetooth with WP8

The last time I touched my Netduino was about 5 months ago (due to work-load), around the time of my wedding to make the wedding tank. So this weekend I decided to dust it off and introduce it to my Lumia 920.

Disclosure: I didn’t actually dust it off.

They are now lovers.

Here is a video of what this post aims to explain how to make. It’s hard to see the actual color of things in the video – so let’s just trust me that it works

I’m going to start by explaining the entire Netduino side of things then move to WP8. Also, I’ve pretty much explained it as simply as possible incase there is anyone on earth worse than me at electronic stuff...

First he covers the hardware...

First was to get the Netduino updated. Surprisingly, the Netduino didn’t update itself sitting in the cupboard. I’m running Windows 8 – but besides mistakenly flashing it with the Netduino Plus rom the drivers all work fine and there's nothing special you need to do.

Next I picked up this awesome little Bluetooth module from Pro-tecc:

...

 

... next Windows Phone 8

Onto Windows Phone 8.

Create a new WP8 application in VS2012. Yes, this is only possible in WP8, not 7.

I’ve made a simple UI which has 3 sliders, one for each color. By default, the color of the sliders on the left of the handle will be the phone’s accent color, so I overrode the style and changed that. Below that is a Rectangle that shows the color. Then there are 3 radio buttons: Still, Strobe, and Ambient. Still will just send the slider values and strobe will randomize the sliders every 100MS (essentially flickering the LED). Ambient is a bit more complicated. I am using the [back] camera on the device to get the average color of what the phone is looking at, and then it sends that color through to the Netduino. To force the camera to initialize I needed to put a hidden rectangle on the UI and bind it’s Brush to the camera.

Above all of that is a Grid with a ProgressBar to show that it’s connecting. If the connection fails (or the first time it connects), it will display this overlay until it’s successfully reconnected and has sent and received a test ping.

...

Source? Yes, he's made the source for both sides available, just Click through to the post, and scroll down to the bottom of the post.

This should help you get started and keep your WP8 from feeling blue...

How to get our Netduino running faster

Before going on on my graphic library for led matrix, I think it’s time to optimize a bit the code in order to get the Netduino running faster.

My job is programming application using .Net for desktop, but a PC is very rich of resources such as RAM and processor speed. Instead, the Micro Framework offers a very small environment where every byte more might have an impact on the final result.

Here is a brief bunch of tests for showing a comparison on different approaches against a same task. Sometime you don’t care about the best way to write the code, but the interesting thing is actually knowing how the things are working. You will be surprised, as I was.

The test bench.

The base program for the tests is very simple: it is an endless loop where the code under test runs interleaved by a short pause of 100ms. The comparison is mostly against different yet commonly-used types, such as Int32, Single, Double and Byte.

The timings are taken by using a scope, then watching at two output ports when they change their state.

Except for the very first, each test cycles 50 times over a 20-operations set: that for minimize the overhead due to the “for-loop”. By the way, the first test is targeted just for get the “for-loop” heaviness.

It follows the test program template:

...

The basic for-loop.

Since every test will use the “for-loop”, we should measure how much overhead that introduces.

Here is the snippet…

...

Roughly speaking, we could say that every for-loop cycle takes about 7 microseconds.

How does look the IL-opcodes generated by the compiler (restricted to the only for-loop)?

Well, it is pretty interesting digging a bit behind (or under?) the scenes. I will take advantage by the awesome ILSpy, which is a free, open-source decompiler, disassembler and much more provided by the SharpDevelop teams.

...

If you're not afraid of a little IL and want to see what's happening behind the scenes of the code you're writing, check out his post...

.Net Micro Framework Weather Station

This project helps you to build a weather station based on .Net Micro Framework. The data come from some sensors (temperature, humidity, luminosity and wind speed) and you can read them, in real time, using a Web page on the integrated Web Server. Enabling data logging, you can save your data into a microSD.

The project is built for Netduino Plus board and based on .Net Micro Framework 4.2 but you can use a different board changing only the pin for the sensors connections.

It uses Metro UI CSS (http://metroui.org.ua/) for Metro style Web page.

The main components are :

• Netduino Plus board;
• Wind Speed Anemometer;
• SHT1X Temperature and Humidity sensor;
• Photoresistor for luminosity;
• DS1307 RTC;
• microSD for data logging;

Here's a snap of the Solution,

Did you catch how it's built-in Web Server feeds up a Tile Web UI by using http://metroui.org.ua/? That's kind of cool, isn't it?

.NET Micro Framework Toolbox

Project Description
This project is a sub-framework for the .NET Micro Framework that gives support for several electrical components in the form of drivers NETMF-devices.

What's in the project?
In this project is support for multiple devices by adding several drivers in the form of classes. See the documentation for more details about them.

How to download the source code
All source code is available on Codeplex. To download the latest release, follow these two simple steps:
1. Browse through the latest build using this direct link: http://netmftoolbox.codeplex.com/SourceControl/BrowseLatest
2. Click on the big download-button

If you need support
The developers and maintainer of this library are all active at http://forums.netduino.com/

If you encounter any problems with Netduino hardware, it's best to post a thread on those forums.

Also, there's the Discussions tab.

Note about Visual Basic support
Although the framework code is completely written in C#, all samples are available for both C# and Visual Basic. This requires .NET Micro Framework 4.2 or higher.

Here's an example if one of the classes/devices in action;

Netduino HD44780 Snake

I [Stefan Thoolen] just updated the .NETMF Toolbox with some additional samples for both Visual C# and VB.NET. One of them is this awesome game which demonstrates custom character support for the HD44780 text LCDs:

So what kind of devices are supported?

Supported devices

And it's not just all about hardware devices. Check out these classes

And the source for all of this is available too!

VB Gadgeteer Webserver, SDK 4.2 QFE2 and Spider Premium Library's

This is an small sample code to show how to build our basic gadgeteer web server using VB with Spider and the 4.2 RTM Premium library's.

Start Visual Studio with a new gadgeteer project and copy/paste...That's all! (remember add library's references)

...

Here's a hint from Chris Walker...

Summary

2x the RAM, 4x the speed, and 6x the flash of GEN1   Many users have run out of flash/RAM on gen1, so the huge upgrade is going to be pretty big news.

Most Vital Specs

• 168 MHz
• 384KB code space (1MB total flash)
• 100KB+ available RAM (192KB total RAM)

New Features

• OneWire support
• Four serial ports (vs. 2 serial ports on gen1)
• Compatibility with even more Arduino shields
  • Higher current
  • All six core PWMs
  • Compatible with new extended Arduino shield form factor
• MiniJTAG – for debugging of native code (side-by-side with C#/VB debugging via USB)

Figured it out yet?

netduino plus 2

system requirements

Windows

• Windows XP, Vista, or 7 (32 or 64 bit)
  Recommended: Windows 7 or 8
• 1.6 GHz or faster processor
• 1 GB RAM
• Up to 3 GB of available hard drive space for Visual Studio Express 2010

design files and source code

design files (open source)

• netduino plus 2 schematics
• netduino plus 2 board layout

source code (open source)

• .NET Micro Framework v4.2 source
• netduino firmware v4.2.1 source
  coming soon
• netduino sdk v4.2.1 source
  coming soon

Also remember if you want something a bit easier, try the Netduino Go! Or the Gadgeteer boards over at GHI. We love all our hardware vendors providing .Net Microsoft Framework compatible systems. There's hardware for every skill level (even one for a dev like me!... cough... Gadgeteer... cough...  Now that's saying something)

Remember when you build something awesome with one of these systems, drop us a line. Thanks and most importantly, have fun!

Led-matrix controller driven via SPI

Time ago, Stanislav -a Netduino community user- posted a problem on how to drive a 6-by-4 led-matrix using its Netduino. After some experiment, he got stuck with the circuit, because a matrix must be multiplexed, and that’s not easy to solve.

Here is the link to the forum thread.

If you read the message exchange on the thread, then you’ll collect easily a list of constraints. Here they are:

• the leds have been already assembled (i.e. only the multiplex driver is needed)
• the overall price should fall within 10 Euro
• must be handcrafted, thus no use of small parts (e.g. SMDs)
• the multiplex should not stop its cycling as the Netduino stops (avoid leds burnout)
• the circuit should avoid complicate wiring, so that the PCB can get pretty easy
• reliable enough
• finally, Stanislav asked to learn how to design such a circuit

It was clear that Netduino only wasn’t enough to drive a 6×4 led-matrix. First off, for the inability to give enough current for the leds, and secondly for the relative slowness of the managed code running into.

The problem in depth.

Light up a led is very simple. Starting from the power supply, as parameter you have the current flowing through the led, then calculating the resistor to put in series. A led needs from few mA (SMDs), to several hundreds of mA (or even more) for the high-power class.
Let’s face the multiplex problem thinking to a normal discrete-led which needs 10 mA for a normal brightness.

So, what is a multiplex?
The multiplexing is a technique for driving many loads (e.g. leds), using a relatively low number of wires. Thinking to a 6×4 led-matrix, instead having 24 wires (one for each led), the multiplex-way needs only 6+4 = 10 wires at all. The trick is enabling one column at once, and issuing the related row pattern. If this process is fast enough, our eyes can’t perceive the scanning.

Now, let’s focus on a single column of four leds: the scan process cycles over, but each column is enabled only at 25% (i.e. 1/4) of the total cycle-time. It means that to yield the same brightness as the led was lit with 10 mA, we should raise it of a factor of 4, thus 40 mA. This current is off the upper limit achievable by a normal logic chip.

By the way 40 mA is probably above the led’s limit. However, the current is flowing only for a quarter of the cycle, so there’s no warm up in the *average*. We only should take care to *avoid* any cycle break, otherwise the 40 mA will flow for a too long time, and the led blows.

That’s not all. When a column is enabled, there are 6 leds composing it, and they might be all on (worst case). So, the total current flowing is 40 mA x 6 = 240 mA.
How much is the current of each row, instead? A row drives only the led at where the column is enabled, but at 25% duty, of course. It means the 40 mA seen above.

My solution.

To solve this problem, I see three ways:

...

I mentioned holidays? Well don't you see yourself coding something up to display some kind of holiday stuff with this? Come on, you know you want to code this to display some kind of little animated Christmas Tree...

Talking to an Electric IMP with Windows 8

Ok – your first question is “What the hell is an Electric IMP?”  My lazy answer is - check out their web site for the best answer: http://electricimp.com.  

But in a nut shell, it’s a small little electronics module with the primary focus of connecting to the internet and controlling hardware.  This hardware can be something as simple as a relay to control a light or as complicated as a sensor that uses I2C, SPI or serial communications (UART).  You have six I/O lines that can be configured for your needs, so you aren’t going to control a small factory with only one of these, but configure a 100 or so of these and it might get interesting.  At this point, this “tech” is in a very early stage, the concept is very cool, but I don’t think I’d propose doing anything commercial or for a client, well at least just yet.

So let’s start where it all begins, here is my little Electric IMP that I purchased from Spark Fun. 

...

In my picture above, you can see the green glow of some internal LED’s.  This is because I’ve already registered my IMP with Electric IMP’s server.  Everything you do with this IMP goes through their server.  Ok, you are probably now thinking what I was/still am thinking….”hmmm…actually I don’t know what to think about that…and…I’m still at the jury is still out point on this having long term legs…but it is sooooo cool, I’m going to give it the benefit of the doubt”.

Ok back to the content, my IMP is green, if you plug a new one in, yours won’t be.  To get your IMP green, and thus have it registered so you can use it with the Electric IMP server, you need to signup for an account at http://electricimp.com, download an iPhone or Android (what no Windows Phone?!??) app.  Then, do something that I think is very cool, turn the lights down in your room, no seriously do this it works better in a darker room, run the app, follow the instructions and hold the screen of your non-Windows Phone device, next to the front edge of your IMP as pictured below and press the “Send BlinkUp” button on your “other type of phone”.

Programming

So, next you’ll go to their web site with Chrome (another editorial note, they don’t support IE, but they say they are “working on it”, yyyyyeeeaaaahhh, I’m sure that’s towards the top of their priority list) and if you click on the “impees” you’ll see that your Imp has been registered.

My Imp

...

Planner

Now we need to “program” the IMP.  Go to the “Planner” tab, find your IMP’s node and select the program you just created, in our case “MyFirstApp”.

...

Now you've got a starting point. Take it and drive on!

Gadgeteer Home Automation System

In this post I want to describe how to create a Home Automation System that puts together many of the modules and source code we talked about on this blog during the past months. In particular,  we’ll create a Gadgeteer device that uses touch screen capabilities of Display T35 to provide access to all the functionalities of the system.

So, let’s start. Connect the following modules to a FEZ Spider Mainboard:

• USB ClientDP;
• WiFi RS21, to retrieve current time from the Internet;
• Display T35, to manage the system using touch;
• SD Card, to store the configuration file of the application;
• Temp & Humidity, to show an example of information that can be acquired using sensors;
• Relays, to control eletrical devices;
• Camera, with which we can show, for example, people that ring our bell.

You can see the result in following screenshot.

Almost all the FEZ Spider sockets are filled. As said before, we’ll use source code from some articles that have been published on this blog. In particular:

• XML Configuration Files for .NET Micro Framework
• Synchronize the Clock with a Reference Server on the Internet
• Windows-like Interface for the .NET Gadgeteer Display

Moreover, we need to create some custom fonts for the application. .NET Micro Framework SDK provides a command line tool that allows to do this. Alternatively, you can use the Tiny Font Tool GUI to make things simpler. In the ZIP file attached to this article you can find all the fonts we’ll use.

...

This project goes into all the details, from build the hardware, coding it and constructing the UI

Our application has three sections: Temperature & Humidity, Relays and Camera. So, we need to create three menu items:

 

 

The result is shown in the following screenshot.

Here's a video of it in action.

And as you would expect, the source available for download (click through and it's at the bottom of the page)

Introducing MicroWorkflow for Netduino

MicroWorkflow – create your own automation on Netduino in a visual way.

MicroWorkflow is a framework layer for creating simple automation on the top of a host .Net application. It currently supports both the standard .Net framework, and the .Net MF.

It’s not meant as a replacement of the underlying programming language, but rather a simple and effective way for creating small tasks, which aid the main hosting application. A dedicate engine provide one or more tasks to run, by interpreting runtime the complied workflow designed by the user.

The language structure is procedural, similar to Pascal. Several functions are available at the moment of writing, but many more will be added, as well as general improvements.

---

At a glance…

Structural features:

• Deeply inspired by the Windows Workflow Foundation: meant to be a very light, yet flexible platform for small/embedded devices.
• The tasks run on the top of the .Net framework, so that their implementation code can be loaded/unloaded anytime, with absolutely no assembly-gluing.
• No special firmwares are required.
• The tasks run in a “sandbox”, which share a custom interface with the hosting application. This is perfect for keeping the application protected, while the custom tasks can be modified by the user.
• The engine is structured in a functional-fashion: that yields to an easier thread-safe concurrency, for running many tasks simultaneously.
• A compiled task is very compact and easy to transfer, as a simple string is.
• Total independence from the communication channel: the data can be sent via TCP/IP, UART, SPI, etc. Any feasible way for exchanging a string can be used.
• The compiled tasks may be stored in any non-volatile medium, such as SD or EEProm. Afterward, the hosting app could load the right task on-demand.

Interop features:

• No skilled programming required, nor complicated IDEs. Even Visual Studio is not required. A full-visual approach has been chosen for creating your own tasks.
• ...

And best of all? It's open source! Cet MicroWorkflow

I DID find this post from the .Net Micro Framework team, On-going VS Express Support, which notes the VS 2012 support for the .Net Micro Framework is coming...

...

We are in the final stages of version 4.3 of NETMF with release in the near future.   This release will work with Visual Studio Express 2012 for Windows Desktop.  In addition, we are in the planning stages for .NET Gadgeteer version 4.3 and this version will also support that Express edition.  We don’t have a firm release target for that at this time.

In the meantime,  VS 2010 and VS2012 co-exist nicely and the language specific Express editions are still available.

... but I couldn't leave today's post at that. So since the Visual Studio Launch was pretty focused on Windows 8, how about we highlight a Windows 8 hardware related project from the one and only Pete Brown? 

 Controlling a NETMF Gadgeteer Robot from a Windows 8 App

At several recent events (VSLive Redmond, thatConference, the Heartland Developer Conference and more), I've had a neat little .NET Micro Framework robot with me. The remote control for the robot is a Windows 8 tablet running a simple Modern UI/Windows Store app I wrote in C#/XAML. The example shows both how you can use C# skills to build robots, and also how flexible the new Windows Store app model is when it comes to communicating with remote devices.

Pete covers the complete project in his post, from the parts, with links to where you can purchase them;

Parts

Although they're out there, it's rare to find a robot as a complete kit. Typically you need to assemble one from a number of different parts. Here are the parts I used.

• The body

• The brain

• Wireless

• Motor controller

• Motor power

• Optional LCD Character display

• Optional sensor

• Wireless Hub / Router

Hooking everything together;

Robot Connections

Assemble the chassis. I did the chassis assembly with my two kids; it's pretty easy, although some parts do get a little fiddly (the motor mounts in-particular). Leave the top off for now so you can get to the bottom deck.

Then, connect both motors to the positive and negative motor connections on the motor module. I kept the motor module on the bottom deck to make that easier. Because I didn't reverse the wires on the two motor connections, but the motors are on opposite sides, they have to be reversed in code. Positive voltage in one goes forward, while on the other goes backwards.

Attach the 9v battery connector (without battery) to the motor modules power input...

Coding the robot;

Robot Code

Now, let's get to the code.

The onboard robot code is a .net Gadgeteer project, created in Visual Studio 2010. NETMF doesn't currently support Visual Studio 2012, but you can install VS2010 side by side with VS2012.

First, I used the WiFly module source code from Stefan Thoolen's great .NET Micro Framework Toolbox project on CodePlex. This project currently doesn't have support for being a socket server, only a client. For that reason, I had to make the Windows 8 app the server. The downside to this is the IP address for the Windows 8 device is hard-coded into the robot, which is opposite of what you would normally do.

The code is simple, all contained in the Program.cs file. Explanation after the listing.

To building the Windows 8 Windows Store app;

Windows 8 App

When I first saw the networking support available to Windows 8 apps, I was pretty psyched. I did a lot of networking work in Silverlight, including some sockets (shudder). What we have in Windows 8 is not only a lot simpler, but it also does not have the port and protocol restrictions Silverlight has because WinRT apps weren't designed to be run in a web browser on the public Internet.

Here's the UI. It's very simple: just four boxes sized and positioned for touch.

As Pete notes, the Windows Store App is... um... minimal... at this point.

But the key to this isn't the UI, it's the code and the connection.

Can a Windows 8 Windows Store app .NET Gadgeteer? Oh yeah, and Pete makes it look easy (as these things do in hindsight now that he's done all the work...

Controlling a Light Switch using Windows Phone

In this post, I’ll show how to control a Relay module using a Windows Phone app that is able to remotely turn on or off a light.

Let’s start creating a new Gadgeteer application. Connect the following modules to a FEZ Spider Mainboard:

• USB ClientDP;
• WiFi RS21, to allow connections to the device;
• Multicolor LED, to indicate device status;
• OLED Display, to show the IP Address of the device;
• Relay (the most important), that allows to create a switch controlled by .NET Gadgeteer.

The resulting system is shown in the following screenshot.

...

From the hardware;

To the .Net Micro Framework code...

To the Windows Phone 7 code and app...

It's all there. If you click through and scroll to the bottom there's a download link for both projects too.

Okay, okay, this might be overkill, but it's a pretty cool overkill, you've got to admit!

Playing with .NET Micro Framework and Gadgeteer

I am sure most people have heard about the .NET Micro Framework and more recently Gadgeteer. While I have had a keen interest for sometime, I never got around to purchasing any of the hardware until about 3 weeks ago.

Here are a few things I have done in my endeavor to learn more about the framework and the embedded devices.

The first application I developed was a little Pac man clone, I made the source for this available on codeplex just follow this link http://chrismcstuff.codeplex.com/

Mini-Pacman on Miniature Arcade Console

I recently blogged about some of the stuff I am playing with on the .NET Micro Framework Gadgeteer platform. Kenny Spade from the TinyCLR community forums has kindly built a miniature arcade and put up a video of Mini-Pacman running on the arcade.

BTW, this is related to the Min Arcade Console project we highlighted here,Snake away with a .NET Gadgeteer arcade console and Snake game

Code? Oh yeah, Chris posted all the code, which made this all possible, here, Chris' Micro Controller Stuff

Here's a snap of the hardware;

And the Solution;

Now you too can build your own little Pacman arcade console too!