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)

Wi-Fi Gadgeteer Robot controlled by Windows Phone with image streaming

I have upgraded the .NET Gadgeteer Robot I described in the post Constructing a Bluetooth controlled Robot, replacing the Bluetooth Module with Wi-Fi and adding a camera to stream images. The result is a Robot that can be controlled by a Windows Phone application, with which it is also possible to show captured images.

Let’s start seeing the new Gadgeteer application, that uses the following modules connected 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;
• Motor Driver L298 to control rover movements;
• Camera, to capture images.

You can see the result in following screenshot.

From hardware to the phone app, it's all covered, including the challenges he faced.

Getting and showing image streaming, instead, require a bit more work. First, we use RestSharp, a library that simplifies the process of making requests via HTTP and processing responses in an asynchronous way. But then, we have a problem: Windows Phone doesn’t support BMP format, that is used by .NET Gadgeteer camera module. So, we need a way to load images in this format and convert them in a format that Windows Phone can handle (i.e., in PNG or JPEG). For this task, we’ll use ImageTools, that is available on http://imagetools.codeplex.com.

But there is another problem: if we try to read images that come from .NET Gadgeteer camera module with ImageTools, the height property is always negative. So, the read operation causes an exception. To solve this issue, I have downloaded the source code of ImageTools and applied a little hack to the library, in order to take the positive value of height. Doing so, the image is read correctly, but it appears flipped. This is the reason for which I have applied a ScaleTransform tranformation on image object in XAML, so that it is shown in the right direction. Of course, a better approach is to modify the code that reads the bitmap, but for the moment this solution is acceptable. As always, you can find the modified version of ImageTools library in the ZIP file that comes with this article.

And of course the source is available, both used inline to explain how he built it;

As well as a the complete Visual Studio Solutions (click through for the download, at the bottom of the post).

If you're ready to create your own Wi-Fi networked and Windows Phone controlled robot head on over to the post, grab the projects and get building!

A Smart Thermostat on the Service Bus

Here’s a bold prediction: Connected devices are going to be big business, and understanding these devices will be really important for developers not too far down the road. “Obviously,” you say. But I don’t mean the devices on which you might read this article. I mean the ones that will keep you cool this summer, that help you wash your clothes and dishes, that brew your morning coffee or put together other devices on a factory floor.

In the June issue of MSDN Magazine (msdn.microsoft.com/magazine/jj133825), I explained a set of considerations and outlined an architecture for how to manage event and command flows from and to embedded (and mobile) devices using Windows Azure Service Bus. In this article, I’ll take things a step further and look at code that creates and secures those event and command flows. And because a real understanding of embedded devices does require looking at one, I’ll build one and then wire it up to Windows Azure Service Bus so it can send events related to its current state and be remotely controlled by messages via the Windows Azure cloud.

Until just a few years ago, building a small device with a power supply, a microcontroller, and a set of sensors required quite a bit of skill in electronics hardware design as well as in putting it all together, not to mention good command of the soldering iron. I’ll happily admit that I’ve personally been fairly challenged in the hardware department—so much so that a friend of mine once declared if the world were attacked by alien robots he’d send me to the frontline and my mere presence would cause the assault to collapse in a grand firework of electrical shorts. But due to the rise of prototyping platforms such as Arduino/Netduino or .NET Gadgeteer, even folks who might do harm to man and machine swinging a soldering iron can now put together a fully functional small device, leveraging existing programming skills.

To stick with the scenario established in the last issue, I’ll build an “air conditioner” in the form of a thermostat-controlled fan, where the fan is the least interesting part from a wiring perspective. The components for the project are based on the .NET Gadgeteer model, involving a mainboard with a microcontroller, memory and a variety of pluggable modules. The mainboard for the project is a GHI Electronics FEZ Spider board with the following extension modules:

• From GHI Electronics
  • Ethernet J11D Module to provide wired networking (a Wi-Fi module exists)
  • USB Client DP Module as power supply and USB port for deployment
  • Joystick for direct control of the device
• From Seeed Studio
  • Temperature and humidity sensor
  • Relays to switch the fan on or off
  • OLED display to show the current status

Together, these parts cost around $230. That’s obviously more than soldering equivalent components onto a board, but did I mention that would require soldering? Also, this is a market that’s just starting to get going, so expect prices to go down as the base broadens.

...

Thermostat Functionality

Implementing local thermostat functionality for this sample is pretty straightforward. I’ll check temperature and humidity on a schedule using the sensor and switch the fan connected via one of the relay ports off or on when the temperature drops below or rises above a certain threshold. The current status is displayed on the OLED screen and the joystick allows adjusting the target temperature manually.

...

Provisioning

In the beginning, the device is in “factory new” state—the device code has been deployed but the device hasn’t yet been initialized and therefore doesn’t have any current settings. You can see this state reflected in the GetSettings method when the settings object is still null and is therefore initialized with default settings.

Because I want to let the device communicate with and through an Internet infrastructure—Windows Azure Service Bus—I need to equip the device with a set of credentials to talk to that infrastructure and also tell it which resources to talk to. That first step of setting up a factory new device with the required network configuration and setting up the matching resources on the server side is known as provisioning; I discussed the basic architectural model for it in the previous article.

...

Sending Events and Receiving Commands

With provisioning completed, the device is now ready to send events to the Windows Azure Service Bus events Topic and to receive commands from its subscription to the devices Topic. But before I go there, I have to discuss a sensitive issue: security.

As I mentioned earlier, SSL/TLS is an expensive protocol suite for small devices. That is to say, some devices won’t ever be able to support SSL/TLS, or they might support it only in a limited fashion because of compute capacity or memory constraints. As a matter of fact, though at the time of this writing the GHI Electronics FEZ Spider mainboard based on the .NET Micro Framework 4.1 I’m using here can nominally speak SSL/TLS and therefore HTTPS, its SSL/TLS firmware apparently can’t deal with the certificate chain presented to it by Windows Azure Service Bus or the Access Control service. As the firmware for these devices gets updated to the new 4.2 version of the .NET Micro Framework, these limitations will go away for this particular device, but the issue that some devices are simply too constrained to deal with SSL/TLS remains true in principle, and there’s active discussion in the embedded device community on appropriate protocol choices that aren’t quite as heavyweight.

...

Wrapping Up

The goal of this series on the Internet of Things is to provide some insight into the kinds of technologies we’re working on here at Microsoft to enable connected-device prototyping and development. We also want to show how cloud technologies such as Windows Azure Service Bus and analytics technologies such as StreamInsight can help you manage the data flow from and to connected devices; how you can create large-scale cloud architectures for handling a great many devices; and how to aggregate and digest information from them.

On the way, I built an embedded device that you can place on any home network and control remotely from any other network, which is pretty cool if you ask me.

I believe we’re in the very early stages of this journey. In talking to Microsoft customers from all over, I’ve seen that a huge wave of connected and custom-built devices is on the way, and this is a great opportunity for .NET developers and innovative companies looking to build cloud offerings to connect to these devices and to combine them with other connected assets in inventive ways. Let’s see what you can do.

As you would expect, the source for the project is available here. Here's a snap of the Solution.

What's the story behind all these Projects? RTFR (Reading The Fine Readme

Code Artifacts:

The solution contains several directories and sub-projects:

/AzureBackend – This is the Windows Azure deployment project for the cloud backend service.

/BackendRoleTest – This is a very simple one-shot command line test to talk to the provisioning endpoint, configured to talk to the local dev-fabric.

/BackendWebRole – This is the backend web role hosting the Provisioning.svc endpoint as well as the Passthrough.svc custom-gateway endpoint implementing a simple hash-based model as a replacement for SSL to be used alternatively to talking directly to Service Bus.
 
In the web.config file you will find the following <appSettings>
*  sharedSignature – replace the value with a base64 encoded 256-bt (16 byte) random binary key or with the same value as ‘managementKey’ below. This is the shared signing key used for the non-SSL scenario.
* serviceBusNamespace – replace the value with the name of a Service Bus namespace you provisioned. Just use the prefix (i.e. myownnamespace) and not the .servicebus.windows.net suffix. As you create the namespace in the Windows Azure Portal, you should create two Topics, named ‘devices’ and ‘events in that namespace.
* managementKey – replace the value with the ‘owner’ key of the Service Bus namespace, which you can also obtain from the portal.

/Microsoft.ServiceBus.AccessControlExtensions – This is a set of utility classes for managing Service Bus Access Control taken from the Windows Azure Service Bus SDK ‘Authorization’ scenario sample

/Microsoft.ServiceBus.Micro – This is a .NET Micro Framework client for Service Bus implementing Send and Receive operations and token acquisition from ACS over HTTPS and the alternative non-SSL model that’s using the Passthrough.svc gateway included in this sample. It also includes a SHA-256 implementation by Elze Kool (http://www.microframework.nl/2009/09/05/shahmac-digest-class/) and an NTP client written by Michael Schwarz from https://mschwarztoolkit.svn.codeplex.com/ which is included under its own license as expressed in the file.

/ServiceBusApp – is the actual Air Conditioner code for .NET Gadgeteer requitring the setup explained in the article. The ‘serverAddress’ in Program.cs must be set to the deployment location of the backend web role. This application will only function when run on the actual hardware.

/ServiceBusMicroTest – is small test app to run in the .NET Micro Framework emulator to call the provisioning logic and send/receive messages.

Also in the readme are additional URL's if you don't have the .NET Gadgeteer SDK installed or need an Azure account.

If you're been wondering what it would take to create a "smart, internet of things" kind of device, are interested in see how a .NET Gadgeteer can talk to Azure, or interested in building interconnected devices and service using the power of the Service Bus, this article and source is just a quick click away...

.Net Gadgeteer Powered Object Tracking Robot

This is a .Net Gadgeteer powered robot based on the rover 5 platform, and using an ir compound eye for object tracking.

It's the first robot i've ever build and also my first real project with the Gadgeteer platform.

I started off with some code based on the arduino sample code for Mr General from the dagu code sample site which i converted into c#. I then refactored it to make it more object oriented and tweaked stuff to make it work better with the .Net Gadgeteer platform

Details and example code can be found on my blog ...

.Net Gadgeteer Powered Object Tracking Robot

This is my first real project using the awesome .Net gadgeteer platform. My initial aim for this project was to build a Gadgeteer version of the robot shown in this video.

The robot can track objects at short (around 20-30cm) distances and will try to stay a set distance away from the object it is tracking.

For tracking the robot uses an ir compound eye, which is a sensor that gives an analog output depending on the level of reflected infrared light.

This is a video of the working prototype of my gadgeteer powered version. (apologies for the crappy quality, i'll get a better version uploaded soon)

This is the first of a series of posts detailing how i went about building it and the stupid expensive mistakes i made along the way.

Parts and materials

The base of the robot is a Rover 5 chassis, made by Dagu electronics.

I had a couple of different options for the motor controller. GHI electronics make a Gadgeteer motor driver module, which i could have used and would probably have worked perfectly well.

However i chose the Dagu explorer pcb as it was designed to fit the chassis i was using and has lots of other nice features such as infrared corner tracking and multiple power sources.

• Dagu ir compound eye for object tracking
• Pan and tilt kit
• Fez Spider mainboard (you can probably use most other gadgeteer mainboards)
• Gadgeteer Power Module
• 4 Gadgeteer Extender Modules

Future posts will detail how i went about putting it together.

• Driving the motors
• Object Tracking

As you can see above, Rik dives into the project breaking it into manageable and understandable pieces. He's also using this project as a basis for others, like...

.Net Gadgeteer Robot with PS Vita as controller

This post is about a modification of my .Net Gadgeteer object tracking robot.

The aim of the project was to add a robotic arm to the robot and allow control over wifi using my Playstation Vita.

I had picked up a Playstation Vita a few months back and was really excited when I heard about the Playstation Mobile Developer Program because it would allow me to write code for the vita in c#

After building my object tracking robot, i thought it would be an interesting challenge to try and control it using the vita.

The robot uses the same Rover 5 chassis and explorer pcb motor controller as the original robot.

Here's a couple of videos of him in action.

The parts i used to build this robot were as follows.

• Fez Spider Mainboard
• 2 Gadgeteer Extender Modules
• Gadgeteer Ethernet Module
• Gadgeteer Client DP Module
• Dagu 2dof Robotic Arm
• Dagu Rover 5 Chassis
• Dagu Explorer PCB
• Edimax Portable Router

I'm using a Playstation Vita as the controller for this robot, however you could really use any wifi capable device that you can write a socket client for.

...

...

Where's the code? Most of his posts include all the code required, including this one...

Code, parts, concepts and ideas. All there waiting for you to use and extend in your own projects...

Prototyping a connected object using the .NET Gadgeteer: the example of a steampunk meteo station

For years I’ve had this very old voltmeter I wanted to do something with: I liked the beautiful wooden case, the leather strap, but honestly, I had better tools for my day to day electronics experiments. I found a purpose for it when I started experimenting with the .NET Gadgeteer kit, and one of my first prototype of connected object: a simple meteo station that would measure temperature, humidity and pressure and upload data to a feed in Cosm, formerly known as Pachube, which is a connected objects web platform used to publish and consume realtime data. I had two goals with this project: have fun with the .NET Gadgeteer kits, and experiment on a complete connected object prototyping cycle (I’m not going to talk about industrialization or mass production here).

Here’s the plan:

1. Discovering the .NET Gadgeteer tooling, and interfacing with sensors
2. Connecting to Cosm (Pachube)
3. Creating the steampunk GUI
4. Making the meteo station user-configurable using a small webserver
5. Prototyping the finished design using 3D modeling tools

While this article reads fine on the web, it's also available as a Word Document here. 

The article delves into each of the above areas, providing a number of code snips and related resources. Frist the hardware is covered.

Discovering the .NET Gadgeteer tooling, and interfacing with sensors

The .NET Gadgeteer is a rapid prototyping environment for connected objects. Kits are manufactured by Microsoft partners, like GHI Electronics (http://www.ghielectronics.com), Seed Studio (http://www.seeedstudio.com/depot/), or the Mountaineer Group (http://www.mountaineer.org/). The core libraries (based on the .NET Micro Framework: (http://www.netmf.com)) are maintained by Microsoft and the community, while the hardware specific drivers and updaters are maintained by the different partner.

Therefore, there are 3 different packages to install on top of Visual Studio 2010 (any version, Express will do) to install the .NET Gadgeteer tools: the .NET Micro Framework base, the Gadgeteer Core, and the hardware specific SDK. In our case, we are going to use a FEZ Spider Kit from GHI Electronics as well as a couple of sensors and a Wifi module.

Then each code section;

Connecting to Cosm

Before connecting to Cosm, we need to connect to a network. GHI Electronics offer different modules, we’ll talk about the Wifi Module, and the Ethernet (J11D) module .When purchasing anyone of them, pay attention that there are different references depending on the motherboard you’re using. Read the docs!

The Ethernet module is the easier to program: here’s the code to connect to a network using DHCP:

ethernet.NetworkSettings.EnableDhcp();

The static equivalent:

ethernet.NetworkSettings.EnableStaticIP("192.168.0.10", "255.255.255.0", "192.168.0.1");string[] dnsServers = { "192.168.0.1", "192.168.0.2" };ethernet.NetworkSettings.EnableStaticDns(dnsServers); 

There are a couple of events you can subscribe to be notified about Network changes:

ethernet.NetworkDown += new GTM.Module.NetworkModule.NetworkEventHandler(ethernet_NetworkDown);ethernet.NetworkUp += new GTM.Module.NetworkModule.NetworkEventHandler(ethernet_NetworkUp);

The Wifi module is also very straightforward to configure: you are going to use the same code, only you need to join a network first:

WiFi_RS21.WiFiNetworkInfo wifiInfo = wifi.Search("<SSID>");wifi.Join(wifiInfo, "<KEY>");

The second step is to set the system time. Since there’s no “backup” battery that saves the clock time, one has to set it everytime the system is powered. This is done with a small NTP library called MicroNTP extracted from the Micro Framework Toolkit: http://mftoolkit.codeplex.com/

DateTime UtcTime = NtpClient.GetNetworkTime("0.fr.pool.ntp.org");Microsoft.SPOT.Hardware.Utility.SetLocalTime(UtcTime + new TimeSpan(TimeSpan.TicksPerHour * 2));

The NTP server returns the Coordinated Universal Time (UTC) therefore I add the timezone difference (+2H, hardcoded here for readability reasons, it would have to be a system parameter, we’ll see later how to create a settings system.

Creating the Steampunk GUI : reading and displaying images from the SD Card, and charting data.

There are two ways to create a user interface using the .NET Micro Framework. Either using the very small subset of WPF, or, a bit like a game, create a display loop and use graphical elements and fonts, just like a game. In my case, I really want my interface to have a steampunk feeling so I’m going to use a lot of images. Since it will be sealed in a box, I have no need for touch interactions, so I’m going to go for the game-like approach. I’ll have a timer that will regularly draw all images, in the right order and at the right place, depending on the various data I have. The only “non-image” data that I’m going to display is a graph, and for that all I need is a SetPixel() method. It’s very easy.

Building a webserver and configuration interface within the meteo station

There’s a sample project for .NET Micro Framework that works great, but the .NET gadgeteer makes it even simpler: there’s a WebServer class already included, with basic routing functionalities. We’re going to use it. We will store the HTML files on the SD Card, as well as a configuration file.

Starting a WebServer is as simple as one line of code:

WebServer.StartLocalServer(ethernet.NetworkSettings.IPAddress, 80);

To configure routing (i.e. associate code execution with specific URLs), use the WebEvent class:

WebEvent webevt = WebServer.SetupWebEvent("Settings.htm");webevt.WebEventReceived += new WebEvent.ReceivedWebEventHandler(webevt_WebEventReceived);

Once the webevent is configured, calling “http://ip:port/Settings.htm” will automatically trigger the execution of the handler associated with the string “Settings.htm”. What we need to do in the handler, is therefore to return, as an HTTP response, the content of the Settings.htm file.

Conclusion

In this article, we’ve gone through the process of prototyping every function of a connected object, from the sensors, to the network, and configuration. Hopefully you now understand:

• How to use the .NET Gadgeteer tooling
• How to connect sensors, and get data from them
• How to work with different kind of files on the SD Card
• How to build a simple user interface
• How to post them on the network
• How to interface with Cosm
• How to buld a webserver in your object
• How to build a configuration mechanism

We also made use of a few toolkits (mftoolkit, HttpUtility, Pachube DAL, etc) that will hopefully help you, and concluded on the possibility to use CAD tools to physically design the object around the 3D models of the gadgeteer components. Now it’s your turn to build something!

In the end, there's a cool little steampunk weather station...

Making Mayhem with .NET Gadgeteer

Mayhem is an open source application that supports triggers, events, and reactions. The core Mayhem application runs on a PC, but the events and reactions it uses are interoperable with just about any platform or device. The guys making Mayhem say that non-programmers can use it to automate anything! This seems an invitation to try Mayhem with .NET Gadgeteer.

Creating events and reactions that run with Mayhem is not difficult after a look at the API Reference, which explains methods to override. The example implemented in this article requires a static class in order to use a single instance of Paul Mineau’s XBeeClient. The XBeeClient is a driver for XBee radios. It provides a serial interface that services two events. Mayhem persists state information when the events are turned off or Mayhem is shut down.

As you might expect, the post not only provides a short introduction to Mayhem but how to integrate it with a .NET Gadgeteer project.

.NET Gadgeteer Devices Automated by Mayhem Events and Reactions

Embedded microcontroller devices often run without an operating system, and they communicate with PCs in various ways. Mayhem EventBase and ReactionBase classes can automate .NET Gadgeteer devices as in the example we’re building, which uses XBee radio communication to and from a device. The device uses .NET Gadgeteer compatible GHI Electronics Light Sensor and Seeed Relay modules and the .NET Gadgeteer XBee adapter for XBee radio communication.

The relay module in this device can control AC electrical circuits that use power up to 15 Amps/120 Volts or 7 Amps/250 Volts. The light sensor is an analog device. Mayhem automation of this device includes events that originate on the device and events that originate on the PC. Paul Mineau wrote the XBeeClient open-source driver , available on CodePlex, that runs the XBees.

The code behind this hardware sets up the device so Mayhem can automate its modules. The code runs the XBeeClient to communicate with the PC hosting Mayhem. It runs a timer that reads the Light Sensor at 10 second intervals and sends notifications when the sensor detects light greater than 92.00 percent of maximum. It toggles the Relay that reacts to Mayhem automation events.

The post includes Mike's entire module as well;

Complete code for both Mayhem modules

We’ve discussed all the elements of a Mayhem/ .NET Gadgeteer implementation. This is a basic example, but adaptable in many ways. The Mayhem vision is to connect everything to everything else.

Here’s a few more links you might find interesting:

• To XBee or not XBee...
• Kinect to Mayhem
• Project Mayhem - an overview
• Project Mayhem - Creating a module
• Making Mayhem with Volume Control
• TWC9: CodePlex Facelift, a little Mayhem, Targeting Async, GUIDs and more
• Make Mayhem! The open source, event driven, add-on enabled, graphical service connection utility

In this video, I am using a helper class I wrote to display "HELLO WORLD". The driver for the module exposes a single API, DrawBitmap, which takes as an argument a byte array representing the on/off pattern for the LEDs. To make working with the module simpler, I wrote a class with a series of static properties that return the byte array for the uppercase English letters A-Z and numbers 0-9.

To generate the byte arrays required for each letter, I wrote up a quick and dirty HTML and JavaScript utility that displays an 8x8 array of checkboxes, which you can use to create the desired glyph, and which automatically provides the correctly-formatted byte array for use with the LED Matrix module.

With my helper class, I simply create an ArrayList of the letters I want to display, then loop through the ArrayList, displaying each letter in turn. I've named the letters using the NATO phonetic alphabet to make the API intuitive without using single letter property names.

Links:

• GHI's LED Matrix Module
• Alphabet Helper Class code on TinyCLR Codeshare
• Helper Class discussion thread
• HTML/JavaScript 8x8 glyph generator for LED Matrix Module

So you're a .Net Gadgeteer builder. Your project is coming together and now you want to build a case, cover, fitting or something. To build it just right you need the given hardware pieces, the buttons, boards, etc, so you can measure and fit it. But you don't want to use the actual hardware for that (since it's already assembled and all that)... What you need is something that is just like the hardware, same size and all, a real life model of the hardware pieces. Maybe even something you could 3D print yourself?

3D-Print a Custom Gadget: Open-Source 3D Models of .NET Gadgeteer Hardware

Today we are contributing a large number of 3D models of .NET Gadgeteer-compatible hardware modules to the Gadgeteer Codeplex project.

The files make it easy to design custom enclosures for Gadgeteer devices – we call these shells. You can import these files into the 3D design tool of your choice (such as 123D, SolidWorks, Inventor or Alibre) and use the models as reference in your shell design. This saves you the trouble of having to measure each module individually, and improves the likelihood that everything will fit nicely inside your shell once it is actually manufactured.

Once you have designed a shell you can 3D-print it. If you don’t have direct access to a 3D printer, you can upload it to one of several online 3D printing services (such as Ponoko, Shapeways or iMaterialise). Today we are contributing models of many of the currently available Gadgeteer modules. Not every module is included - new modules are being released faster than we can model them! Over the coming months we will continue to add new models, and will be publishing some guidelines for others to contribute their own. We are also planning to release some ready-to-print shell designs. Below is a preview of the first one – a design for a Gadgeteer plant-moisture sensor.

Here's a snap of the current 44 designs; 

I grabbed 123D and it's able to open most of these with no problems.

Controlling a Gadgeteer device using Bluetooth Module and 32feet.NET library

In this post, I’ll show how to send messages to a GHI Bluetooth module from a PC application using the 32feet .NET library.

First of all, let’s create the Gadgeteer application. Connect an USB ClientDP and an OLED Display to a FEZ Spider Mainboard, as in the following screenshot.

...

Let's quickly jump over to a snip about 32feet.Net.

32feet.NET - Personal Area Networking for .NET

32feet.NET is a shared-source project to make personal area networking technologies such as Bluetooth, Infrared (IrDA) and more, easily accessible from .NET code. Supports desktop, mobile or embedded systems. 32feet.NET is free for commercial or non-commercial use. If you use the binaries you can just use the library as-is, if you make modifications to the source you need to include the 32feet.NET License.txt document and ensure the file headers are not modified/removed. The project currently consists of the following libraries:-

• Bluetooth
• IrDA
• Object Exchange

Bluetooth support requires a device with either the Microsoft, Widcomm, BlueSoleil, or Stonestreet One Bluetopia Bluetooth stack. Requires .NET Compact Framework v2.0 or above and Windows CE.NET 4.2 or above, or .NET Framework v2.0 for desktop Windows XP, Windows Vista and Windows 7.

Now back to the project post where it continues discussing adding Bluetooth to the device.

We don’t add the Bluetooth module to the Designer because we use the beta driver implemented by Eduardo Velloso. Download the driver from CodePlex and add the Bluetooth.cs file to your project. Connect the module to socket 9. We initialize the driver in the ProgramStarted method:

bluetooth = new Bluetooth(9); 

client = bluetooth.ClientMode; 

bluetooth.SetDeviceName("Gadgeteer"); 

bluetooth.SetPinCode("1234"); 

bluetooth.DataReceived += new Bluetooth.DataReceivedHandler(bluetooth_DataReceived); 

client.EnterPairingMode();

In this code, we set Gadgeteer as device name and we configure a PIN code. Then, in the bluetooth_DataReceived event handler, we print the received text on display:

private void bluetooth_DataReceived(Bluetooth sender, string data) { 

oledDisplay.SimpleGraphics.ClearNoRedraw(); 

oledDisplay.SimpleGraphics.DisplayText(data, Resources.GetFont(Resources.FontResources.NinaB), 

GT.Color.Yellow, 0, 60); 

}

Now that the Gadgeteer application is up and running, and the Bluetooth module is correctly configured, we can write a PC program to control it.

The last piece is to write the WPF app that is used to send the commands to the device.

Create a new WPF Application with name BluetoothControl. Write the following XAML in the MainPage.xaml file:

...

...

In the btnSendMessage_Click event handler, if the connection has been correcly established, we can send messages over the stream:

private void btnSendMessage_Click(object sender, RoutedEventArgs e) { 

if (bluetooth.Connected && bluetoothStream != null) 

{ 

var buffer = System.Text.Encoding.UTF8.GetBytes(txtMessage.Text); 

bluetoothStream.Write(buffer, 0, buffer.Length); 

txtMessage.Text = string.Empty; 

} 

}

We simply get the bytes that compose the message and then we call the Write method on the stream object: the Bluetooth module on Gadgeteer device will receive the data and show it on the diplay.

If you're thought adding Bluetooth communication to your devices might be hard then you really need to read this post and download the code...

Come on, how you can you not get excited about the possibilities in something like this?

Mind Control of .NET Gadgeteer Device via Neurosky EEG Sensor

This experiment leaves much to the imagination, but it does demonstrate how wave forms of the human brain can determine events on a device with an embedded microcontroller. This code scenario is submitted for use in the Open Health and Fitness Data Aggregator project headed by Ira Laefsky. The Neurosky Mind Wave sensor is an economical electroencephalograph designed for extensibility with other applications. For less than $100 the device includes the Think Gear Connector, which runs on the Windows or Mac operating systems and supports an API. With two lines of code you can initialize the Think Gear Connector to access the output of the Neurosky electroencephalograph (C# requires the interop thinkgear.dll in the folder with the executable).

int connectId = ThinkGear.TG_GetNewConnectionId();

int succeeded = ThinkGear.TG_Connect(0, "COM7",

ThinkGear.BAUD_57600, ThinkGear.STREAM_PACKETS);

Console.WriteLine("Any key to continue... .");

Console.ReadKey();

The connector sorts the data into the following wave-form categories - from the developer’s guide:

eSense: A container for the eSense™ attributes, which are integer values between 0 and 100. Zero is perceived as a lack of that attribute and 100 is an excess of that attribute.

• attention. The eSense Attention value.
• meditation. The eSense Meditation value.

eegPower: A container for the EEG powers. These may be either integer or foating-point values.

• delta. The “delta” band of EEG.
• theta. The “theta” band of EEG.
• lowAlpha. The “low alpha” band of EEG.
• highAlpha. The “high alpha” band of EEG.
• lowBeta. The “low beta” band of EEG.
• highBeta. The “high beta” band of EEG.
• lowGamma. The “low gamma” band of EEG.
• highGamma. The “high gamma” band of EEG.

rawEeg: The raw data reading off the forehead sensor. This may be either an integer or a foating-point value.

blinkStrength: The strength of a detected blink. This is an integer in the range of 0-255.

Control the .NET Gadgeteer Device with Brain Waves

The sorted wave-form data from the Mind Gear Connector could be sent to a .NET Gadgeteer device in several ways. This example sends data as an http request to a Web service running on a .NET Gadgeteer device. A WiFi connection enables the connection by using the WiFi RS21 Module available from GHI Electronics.

The following illustration shows the WiFi RS21 module, the GHI Electronics FEZ Spider mainboard, and four Smart Multicolor LED Modules connected by the daisy-link method, as described in the .NET Gadgeteer Module Builder’s Guide version 1.8.

...

The user wearing the Neurosky EEG sensor starts sending data. The command window prompts the user and waits for connection to the Mind Gear Connector to initialize. When it continues, it will read packets of data from the connection according to the defined wave-forms. When various wave-forms reach an arbitrary value, the wave-form are assigned an integer value that is sent to the .NET Gadgeteer device . Sending all of the data is unnecessary for this experiment, so the threshold is set high enough to limit the amount of data sent to the Web service. Probably the middle range of each wave-form values could be disregarded and the low and high ranges sent.

...

There's a great deal more information in the post, so please click through for all the details...

Have the starts of a game running on the FEZ Spider

Just a quick post to show what I’ve been doing with the new toy

Of course I started to write the same game as I have going on the Windows Phone and Azure.

The below picture shows the components used in the project:

Added a generator tool (Windows) in VB.net for TyranntMicro

Added a new generator tool. So far it can just generate items:

This tool will store the items in “|” delimited text files which can easily be turned into objects using the split(“|”c) or split(‘|’) string function.

An example of the above “Arrows” item is:

1.0|Arrows||A Quiver of arrows. Holds a maximum of 10 arrows|arrowico.gif|arrow.gif|ammo|10|0|False|False|False

I was planning to do this on the Spider but it just makes more sense to do this on a desktop machine.

So Character Generator is almost finished. (Starting items are all that is required)
Item generator done.

Next when I get spare time I’ll start working on the Maze Generator in the generator tool and a “Play Game” screen system on the Spider.

Tyrannt Micro

This is an RPG game which runs on the .net Micro Framework Gadgeteer platform. It uses the FEZ Spider hardware

This is an RPG game that uses the .net Micro Framework Gadgeteer platform. I basically wanted a project to learn how to use different components so thought Game was a good idea. The hardware required for this project is:

• FEZ Spider
• T35 Display Module
• SD Card Module

...

Here's a snap of from the latest check-in;

And a snip from the Character Generation Window routine (UI shown in the video);

void InitCharacterGenWindow()
  {
      // get the current character
      Character currChar = characters[currentCharacter];

      // Get the name Text Box
      TextBox nameTextBox = (TextBox)characterGenWindow.GetChildByName("nameTextBox");
      // Get the races
      RadioButton humanRadio = (RadioButton)characterGenWindow.GetChildByName("humanRadioButton");
      RadioButton dwarfRadio = (RadioButton)characterGenWindow.GetChildByName("dwarfRadioButton");
      RadioButton elfRadio = (RadioButton)characterGenWindow.GetChildByName("elfRadioButton");
      RadioButton gnomeRadio = (RadioButton)characterGenWindow.GetChildByName("gnomeRadioButton");
      // Get the sexs
      RadioButton maleRadio = (RadioButton)characterGenWindow.GetChildByName("maleRadioButton");
      RadioButton femaleRadio = (RadioButton)characterGenWindow.GetChildByName("femaleRadioButton");
      // Get the stats
      TextBlock strTextBlock = (TextBlock)characterGenWindow.GetChildByName("strValue");
      TextBlock intTextBlock = (TextBlock)characterGenWindow.GetChildByName("intValue");
      TextBlock dexTextBlock = (TextBlock)characterGenWindow.GetChildByName("dexValue");

      // Set the Race
      switch (currChar.race.ToLower())
      {
          case "human":
              humanRadio.Checked = true;
              dwarfRadio.Checked = false;
              elfRadio.Checked = false;
              gnomeRadio.Checked = false;
              break;
          case "dwarf":
              humanRadio.Checked = false;
              dwarfRadio.Checked = true;
              elfRadio.Checked = false;
              gnomeRadio.Checked = false;
              break;
          case "elf":
              humanRadio.Checked = false;
              dwarfRadio.Checked = false;
              elfRadio.Checked = true;
              gnomeRadio.Checked = false;
              break;
          case "gnome":
              humanRadio.Checked = false;
              dwarfRadio.Checked = false;
              elfRadio.Checked = false;
              gnomeRadio.Checked = true;
              break;
          default:
              FatalError(currChar.race.ToLower() + " is unknown race");
              break;
      }

      // Set the Sex
      switch (currChar.sex.ToLower())
      {
          case "male":
              maleRadio.Checked = true;
              femaleRadio.Checked = false;
              break;
          case "female":
              maleRadio.Checked = false;
              femaleRadio.Checked = true;
              break;
          default:
              FatalError(currChar.sex.ToLower() + " is unknown sex");
              break;
      }

      // Set the name
      nameTextBox.Text = currChar.name;

      // Set the stats
      strTextBlock.Text = currChar.strength.Current.ToString();
      intTextBlock.Text = currChar.intelligence.Current.ToString();
      dexTextBlock.Text = currChar.dexterity.Current.ToString();

      // Refresh the portrait image
      reloadPortrait();

      // Display the character generator page
      Glide.MainWindow = characterGenWindow;
  }

If you've thought that creating a portable game device with your own RPG on it would be cool, this project might be a place for you to start...

Posture Regulator using .NET Gadgeteer Accelerometer from Seeed Studio

People who work in technology often spend many hours at the computer, which can make it difficult to maintain good posture. I’ve been advised by a physical therapist to keep my chest high with my head and neck upright. The problem is that fatigue tends to make me slouch. Then my neck is out of alignment, leading to some unpleasant grinding of vertibrae and tension in the shoulders.

The .NET Gadgeteer device in this example uses the Seeed accelerometer module, which can be calibrated with a single function to set the base position that should be maintained. I use a relay module, also from Seeed Studio, to activate a beeper when the Z axis of my posture varies too far from the calibrated normal.

The accelerometer is similar to the sensor in a cell phone that detects whether the phone is in the horizontal or vertical orientation. The methods that the Seeed module supports are more than adequate for this application. There is a method to calibrate the position from which variation is measured. Monitoring the Z axis of the variation is sufficient to detect the kind of slouching I’m trying to avoid. For this prototype I simply attached the accelerometer to my sweater with a safety pin, as shown in the following photo.

Posture Regulator with LED Alert – Silent

This is a second iteration on the device using a Seeed accelerometer as posture sensor that sends alerts when the user’s posture lapses from the position desirable for working extended periods in the seated position. The previous version used a buzzer on a relay circuit as an alert. It produced a sound that could drive one to distraction. This version uses a LED that simply turns red when the user wearing the accelerometer slouches or leans too far from the desirable vertical position.

The modules used in this application are shown in the following screen shot from the .NET Gadgeteer Designer.

Posture Accelerometer Sensor LED Alert

This implementation of the posture sensor is different from the previous version in that it doesn’t require a relay circuit to turn on a buzzer. It uses the GHI Electronics multicolored LED module. It also uses the Seeed OLED Display module instead of the larger and more expensive Display T35 from GHI Electronics.

The application logic is similar in this version to the previous except that it omits the relay circuit and turns on the LED instead of the buzzer. The following illustration shows the working components.

...

One surprising discovery in this version is that the Accelerometer.StartContinuousMeasurements method has to be set at a lower frequency than the previous version. Having the relay running on the board changed the configuration so that the button could interupt the continuous measurements and turn off the measurements. In this version I found that pushing the on/ off button had no effect until I slowed the rate of continuous measurements.

Come on, what hardware hacker wouldn't want to wear something like that? Now to make it portable, and report posture results to a web site (and tweet them?), maybe some Bluetooth integration to an app, and... and... and...

Using a Servo in a .NET Gadgeteer Camera Device

The Gadgeteer.Interfaces.PWMOutput interface can support the use of a servo to move mechanical parts of a device as needed by applications. This example uses the Gadgeteer.Interfaces.PWMOutput interface and a servomechanism to turn a camera through an arc of about 140 degrees. The Pulse Width Modulation (PWM) input for this servo is obtained from a WCF REST Web service running on a remote IIS Server. The user can direct the camera to take pictures over its range of motion from any device that can send a Web request to the service. After the camera takes a picture, the device generates a POST request to upload the picture to the Web service so it is accessible remotely. The post: Controlling the Servo using a Windows Phone Application describes a client application for the device and Web service.

...

The core of this application is the code that polls the Web Service to get the PWM number that controls the servo. The number is a percentage of the delta between the top and bottom PWM settings, an unsigned integer that indicates a percentage of the range: 1% - 100%. The Web service returns the number to the application to be used in the SetPulse method of the Gadgeteer.Interfaces.PWMOutput interface.

Wiring the servo requires connecting the input wire to a pin on a P socket that supports pulse width modulation. The external power for the servo motor has to come from an external battery or transformer that supplies about 5 volts DC. The socket connections can be wired using the GHI Electronics Extender Module.

uint pulse = low + (delta * percent / 100);

servo.SetPulse(20000000, pulse);

Here is a schematic of the servo-control circuit from the GHI Electronics Extender module. Following the schematic, a photo shows the wiring. Only pin 9 and the ground on pin 10 are needed for the PWM circuit.

Implementing a REST Web service can be done with the WCF REST Web Service Template 4.0. For more information on using the template project, see REST Web Service to Record Data from a .NET Gadgeteer Sensor Device and Remote Control of .NET Gadgeteer Device via REST Web Service.

...

The Web service code that receives the picture from the camera module is shown in the following blocks. Implementing the Web service to manage state information was easy, but getting the bitmap data into a format that works on this service took some discussion. Marco Minerva is skilled in this area and provided some of this code in a discussion that you can follow on an MSDN WCF forum thread.

First the classes to store data and maintain state:

...

The WCF REST Web service template 4.0 works fine for the GET and for the POST methods.

The Web.config file for the Web service follows.

<?xml version="1.0"?>

<configuration>
<system.web>
<compilation debug="true" targetFramework="4.0" />
</system.web>
<system.webServer>
<modules runAllManagedModulesForAllRequests="true">
<add name="UrlRoutingModule" type="System.Web.Routing.UrlRoutingModule, System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
</modules>
</system.webServer>
<system.serviceModel>
<serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true"/>
<standardEndpoints>
<webHttpEndpoint>

<!--
Configure the WCF REST service base address via the global.asax.cs file and the default endpoint via the attributes on the <standardEndpoint> element below
-->

<standardEndpoint name="" helpEnabled="true"
automaticFormatSelectionEnabled="true" maxReceivedMessageSize="4194304"
transferMode="Buffered" />
</webHttpEndpoint>
</standardEndpoints>
</system.serviceModel>
</configuration>

For more information about the WCF Web services, see the forum discussion:

...

Controlling the Servo using a Windows Phone application

In the post Using a Servo in a .NET Gadgeteer Camera Device we saw how to create a .NET Gadgeteer application that uses a Servo to change the direction of the Camera, takes a photo and uploads it to a Web Service. Now, we’ll realize a Windows Phone application to remotely control the camera and show the pictures.

Let’s create a standard Windows Phone Application, named CameraControl, targeting OS version 7.1 (Mango). We use too Silverlight for Windows Phone Toolkit, that can be downloaded from CodePlex site. The user interface is very simple and consists of an area where the last taken photo is shown and a slider with which we can control the direction of the camera:

...

The application is developed using the MVVM pattern. We have only one ViewModel, called MainViewModel. It uses the REST Web Service already described in the post Using a Servo in a .NET Gadgeteer Camera Device: in particular, the method to set the state of the servo and the one to get the last taken picture. Note that, to set the servo state, we need to send to the service a number that is a percentage of the delta between the top and bottom PWM settings. It’s an unsigned integer that indicates a percentage of the range: 1% – 100%. Communications are realized using RestSharp, a library that simplifies the process of making requests and processing REST responses in an asynchronous way.

And of course the source is available for download...

So when I saw this, while there's no Solutions or direct code to download, I still thought this a great Hardware Friday post...

.NET Gadgeteer School Lesson Plans

.NET Gadgeteer can be used in schools to help students make gadgets and learn C# programming along the way. These lesson plans give teachers all the material you will need to run 8 1-hour sessions using .NET Gadgeteer. You will also need the hardware, details of which are given at http://netmf.com/gadgeteer.

The material consists of 8 sessions:

• Session 1: A basic digital camera
• Session 2: Extending the camera (part 1)
• Session 3: Extending the camera (part 2)
• Session 4: Creating a stop watch
• Session 5: Extending the stop watch
• Session 6: Create a simple game (part 1)
• Session 7: Create a simple game (part 2)
• Session 8: Create a simple game (part 3)

Session 1: A basic digital camera

Aim of session

The aim of the first session is to

- put together the hardware components needed to make a basic digital camera

- write the code needed to create a basic digital camera

Learning Outcomes

At the end of this session, pupils will be able to:

- Identify input, output and storage devices on everyday devices

- Identify and put together the hardware components for a digital camera

- Understand that in C# the execution of programming code is triggered by events

- Be able to write simple lines of code to enable the camera to work.

Starter task: input, output and storage devices (10 minutes)

Show students some pictures of devices such as phones, cameras, music players etc ask them to brainstorm what input, output and storage devices these everyday devices might use.

Main session

The structure of the session is as follows

1. Identify hardware components

2. Assemble digital camera

3. Use Gadgeteer Designer to drag and drop components on screen

4. Write the programming code for the camera

Session 2: Extending the camera

Aim of session

The aim of this session is to

- Extend the digital camera to use the LED to indicate when the camera can take a picture

- Further extend the digital camera to save pictures to an SD Card.

Learning Outcomes

At the end of this session, pupils will be able to:

- Be able to add new modules to the digital camera

- Be able to explore and select appropriate methods for the multi-coloured LED and SD Card.

- Be able to write to the SD Card

- Be able to write code to create a new field (data attribute) and increment it in C#

- Be able to concatenate a string, including converting an unsigned integer to a string.

Starter task: functions of a digital camera

Look at a “proper” digital camera and brainstorm what its functions are. Students could discuss in groups what else their Gadgeteer camera could do, considering the modules available in the kit.

Main session

The structure of the session is as follows

1. Add an LED to the hardware and to the Designer software

2. Implement the functionality to have the LED turn green when the program starts then momentarily turn red when the camera is busy.

3. Add an SD Card to the hardware and to the Designer Software

4. Implement the functionality to save the pictures to an SD Card

5. Implement the functionality to save pictures with unique names

Through to session 8...

Session 8: Creating a simple game controlled by a joystick (final part)

Aim of session

The aim of this session is to

- Complete the joystick ball-in-a-box game, consolidating previous skills

- Encourage students to explore how they could implement their own ideas for a gadget

Learning outcomes

- Students should be consolidate everything they have learned in the previous sessions

Session Plan

Starter

Ask students to recap what they have learned so far. For example, you could ask if they can tell you:

- How to put a new component on to the mainboard and replicate it in the designer

- How to write an if statement in C#

- How to add a new font to Gadgeteer

- How the timer works

- How to declare a whole number

- How to add one to a whole number

Main session

The activities which the students can do to finish the game are:

1. Create a new timer to count down from 60 to 0 and display on the screen

2. Start the game by touching the screen

3. Display a Game Over message with the final score when the time is up!

If you're looking to learn or teach hardware/software development this looks like a great resource that's very approachable ...

Here’s a few more links you might find interesting:

1. Gadgeteer 
2. For Educators
3. Getting Started
4. Featured Projects

Page image courtesy of Teaching Programming with Microsoft .NET Gadgeteer – A Case Study

.NET Gadgeteer Arcade Console

Relive the days of classic arcade games with this gorgeous do-it-yourself miniature arcade console. It’s equipped with a touch screen, joystick and Ethernet port for fun multiplayer action! Pay tribute to your favorite classic game or invent your own!

The Arcade console is an implementation of the Snake video game. There are many versions of this game. In this version the .NET Gadgeteer Display T35 module and .NET Gadgeteer Timer are used to display the snake and a pellet of food and to move them around the display window. A joystick sends user input that controls the movement of the snake. The object of the game is to move the snake into a collision with the food pellet, which makes the snake grow longer.

The code for the Arcade console demonstrates many features of the Display T35 module, the .NET Gadgeteer WPF Window class, and .NET Micro Framework Canvas class. The implementation of the GameEngine, GameCanvas, and Sprite classes illustrates the use of bitmap resources and drawing on the canvas. Two timers are running while the game is in progress. One timer randomly advances the food pellet and another moves the snake as directed by the user from the joystick. Math classes are used in the positioning of the sprites.

The C# program runs on a GHI Electronics Fez Spider mainboard powered by the Dual Power module, which can be used with a battery or USB power. The USB connection must be connected initially to deploy assemblies to the mainboard. An Ethernet module is included to support extensibility for multiple players.

Code for MicroSnake game: MicroSnake.zip

Laser cut enclosure (Ponoko-ready): Arcade_Cabinet_Enclosure.zip

http://www.youtube.com/watch?v=pscenYHbOJ8&feature=player_detailpage

Here's a snip of the hardware design;

And a code snip;

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Controls;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Touch;

using Gadgeteer.Networking;
using GT = Gadgeteer;
using GTM = Gadgeteer.Modules;

using Gadgeteer.GameEngine;
using Gadgeteer.Modules.GHIElectronics;

namespace MicroSnake
{
    public partial class Program
    {
        const int GAME_GRID_SIZE = 20;

        Window mainWindow;
        GameEngine gameEngine;
        Gadgeteer.Timer drawTimer;
        Gadgeteer.Timer inputTimer;

        Sprite food = new Sprite(Resources.GetBitmap(Resources.BitmapResources.Food_20x20), 160, 200, true);
        SpriteCollection snake = new SpriteCollection();
        Bitmap snakeBitmap = Resources.GetBitmap(Resources.BitmapResources.SnakeBlueBody_20x20);

        void ProgramStarted()
        {
            // Initialize event handlers here.
            // e.g. button.ButtonPressed += new GTM.MSRC.Button.ButtonEventHandler(button_ButtonPressed);
            mainWindow = display.WPFWindow;

            gameEngine = new GameEngine(mainWindow);

            drawTimer = new GT.Timer(new TimeSpan(0, 0, 0, 0, 400));
            drawTimer.Tick += new GT.Timer.TickEventHandler(drawTimer_Tick);

            inputTimer = new GT.Timer(new TimeSpan(0, 0, 0, 0, 100));
            inputTimer.Tick += new GT.Timer.TickEventHandler(inputTimer_Tick);

            CurrentDirection = Direction.Right;
            SetupGame();

            inputTimer.Start();
            drawTimer.Start();

            // Do one-time tasks here
            Debug.Print("Program Started");
        }

        void inputTimer_Tick(GT.Timer timer)
        {
            GTM.GHIElectronics.Joystick.Position jPos = joystick.GetJoystickPostion();

            if (0.3 < jPos.Y && jPos.Y < 0.7)
            {
                if (jPos.X > 0.8)
                {
                    if (CurrentDirection != Direction.Left)
                    {
                        CurrentDirection = Direction.Right;
                    }
                }
                else if (jPos.X < 0.2)
                {
                    if (CurrentDirection != Direction.Right)
                    {
                        CurrentDirection = Direction.Left;
                    }
                }
            }

            if (0.3 < jPos.X && jPos.X < 0.7)
            {
                if (jPos.Y > 0.8)
                {
                    if (CurrentDirection != Direction.Down)
                    {
                        CurrentDirection = Direction.Up;
                    }
                }
                else if (jPos.Y < 0.2)
                {
                    if (CurrentDirection != Direction.Up)
                    {
                        CurrentDirection = Direction.Down;
                    }
                }
            }
        }

This is just another example that building hardware you can code to, or code that you can build hardware for, is probably easier, faster and more fun than you think.

How to Build a Flipbook Maker: Part 1, Part 2, Part 3 (Complete Project Source)

Build your own stop-motion animation tool using .NET Gadgeteer! The Flipbook Maker combines Gadgeteer's intuitive hardware and software construction with a useful enclosure to create a project that will appeal to your inner cartoonist.

What You'll Need

This walkthrough uses modules from GHI Electronics' Fez Spider Starter Kit. Other mainboards and modules can be substituted - just check that your modules will work with the sockets on your mainboard. You can quickly determine whether a module will work with a mainboard by matching the module's socket type letter with the socket type letters on each mainboard socket.

Hardware Modules Used:

• Mainboard
• Camera Module
• Potentiometer Module
• Button Module
• SD Card Module (plus an SD card - check your module to determine its card size and capacity requirements)
• USBClient power module

You'll also need a Gadgeteer development environment. Check out this guide which describes how to set that up.

Finally, if you want to assemble your Flipbook Maker as pictured here, you'll need to create an enclosure for it. We'll talk about fabrication options in a later post - including stuff you can do yourself and services you can use to have the case constructed for you.

• Step 1: Connect the Modules
• Step 2: Starting the Software

Part 2

In Part 1, we assembled the hardware and created the event handlers for the Flipbook Maker. Now let's flesh out the software foundation and create a state machine to manage the Flipbook Maker's behavior.

• Storing Images
• Flipbook Maker Playback States
• Implementing the Playback Timer
• Taking Pictures
• Implementing the Potentiometer Timer
• The Flipbook Maker to So Far and What's Next

Part 3

Happy New Year! The Gadgeteer team is back from the holidays and we'll conclude the Flipbook Maker series this week. In Part 1 and Part 2 we assembled the hardware and built the basic software architecture. This post covers using WPF to create a menuing system for the touchscreen display. This will provide the remaining user controls - saving the movie to the SD card, deleting a frame, etc. It will also provide visual cues like frame number and playback status.

• Adding Resource Images and Fonts to the Project
• Setting Up the Display
• A Note on Implementing Lightweight Touch Buttons in Gadgeteer
• The Touch Event Handlers
• The Home Stretch: Saving the Movie

I think one of the cooler things about .Net Gadgeteer is the development environment. Even if you don't have the hardware (which I don't) you can still install the SDK's (see this guide) and check out the hardware design and associated code. There's no .Net Gadgeteer emulator that I am aware of, so to run the code you'll need the hardware, but still...

Here's the Solution open on my system;

Some snips of code, though I recommend you check out the three different posts as there's more snips there, with assoicated context...

// This method is run when the mainboard is powered up or reset.   
  void ProgramStarted()
  {
      // Set up event handlers for modules
      button.ButtonPressed += new GTM.GHIElectronics.Button.ButtonEventHandler(button_ButtonPressed);
      camera.BitmapStreamed += new GTM.GHIElectronics.Camera.BitmapStreamedEventHandler(camera_BitmapStreamed);

      sdCard.SDCardMounted += new SDCard.SDCardMountedEventHandler(sdCard_SDCardMounted);
      sdCard.SDCardUnmounted += new GTM.GHIElectronics.SDCard.SDCardUnmountedEventHandler(sdCard_SDCardUnmounted);

      SetupDisplay();

      // Set up event handlers for timers, and start timers running
      playbackTimer.Tick += new GT.Timer.TickEventHandler(playbackTimer_Tick);
      playbackTimer.Start();

      potentiometerCheckTimer.Tick += new Gadgeteer.Timer.TickEventHandler(potentiometerCheckTimer_Tick);
      potentiometerCheckTimer.Start();

      // Use Debug.Print to show messages in Visual Studio's "Output" window during debugging.
      Debug.Print("Program Started");
  }

void button_ButtonPressed(GTM.GHIElectronics.Button sender, GTM.GHIElectronics.Button.ButtonState state)
   {
       if (!camera.CameraReady) return;

       if (frames.Count <= MAXIMUM_FRAMES)
       {
           if (playbackTimer.IsRunning) playbackTimer.Stop();
           if (potentiometerCheckTimer.IsRunning) potentiometerCheckTimer.Stop();
           currentFrame++;
           currentMode = PlaybackMode.Recording;
           cameraImage.Bitmap = new Bitmap((int)display.Width, (int)display.Height); // Give the camera and screen a new bitmap to stream to.
           camera.StartStreamingBitmaps(cameraImage.Bitmap);
       }

   }

   Image icon;
   Text frameNumber;
   Canvas canvas;
   Window mainWindow;

   ArrayList buttons = new ArrayList();
   Image deleteThisButton = new Image(Resources.GetBitmap(Resources.BitmapResources.DeleteThisButton));
   Image deleteAllButton = new Image(Resources.GetBitmap(Resources.BitmapResources.DeleteAllButton));
   Image saveButton = new Image(Resources.GetBitmap(Resources.BitmapResources.SaveButton));
   Image cancelButton = new Image(Resources.GetBitmap(Resources.BitmapResources.CancelButton));

   bool buttonsVisible = false;

   void SetupDisplay()
   {
       mainWindow = display.WPFWindow;
       canvas = new Canvas();
       cameraImage = new Image(Resources.GetBitmap(Resources.BitmapResources.StartScreen));
       frames.Add(cameraImage.Bitmap);
       icon = new Image(Resources.GetBitmap(Resources.BitmapResources.CALIBRATE));
       frameNumber = new Text(Resources.GetFont(Resources.FontResources.SegoeUI_20), "");
       frameNumber.ForeColor = GT.Color.FromRGB(0, 200, 0);

       canvas.Children.Add(cameraImage);
       canvas.Children.Add(icon);
       canvas.Children.Add(frameNumber);

       canvas.Width = (int)display.Width;
       canvas.Height = (int)display.Height;

       Canvas.SetLeft(cameraImage, 0);
       Canvas.SetTop(cameraImage, 0);

       Canvas.SetRight(frameNumber, 5);
       Canvas.SetTop(frameNumber, 0);

       Canvas.SetLeft(icon, 5);
       Canvas.SetTop(icon, 10);

       // Add and position menu buttons
       canvas.Children.Add(deleteAllButton);
       canvas.Children.Add(deleteThisButton);
       canvas.Children.Add(cancelButton);
       canvas.Children.Add(saveButton);

       Canvas.SetLeft(deleteAllButton, 40);
       Canvas.SetTop(deleteAllButton, 5);
       Canvas.SetLeft(deleteThisButton, 180);
       Canvas.SetTop(deleteThisButton, 5);
       Canvas.SetLeft(saveButton, 40);
       Canvas.SetTop(saveButton, 125);
       Canvas.SetLeft(cancelButton, 180);
       Canvas.SetTop(cancelButton, 125);

       buttons.Add(deleteThisButton);
       buttons.Add(deleteAllButton);
       buttons.Add(saveButton);
       buttons.Add(cancelButton);

       foreach (Image button in buttons)
       {
           button.Visibility = Visibility.Hidden;
       }

       buttonsVisible = false;
       mainWindow.Child = canvas;
   }

The .Net Gadgeteer really has made building custom hardware devices and programs almost as simple as building just software only solutions. If you can code but have thought "hardware is hard" you really should check out the .Net Gadgeteer. It's likely easier than you think...

Here’s a few more links you might find interesting:

• Looking for API reference docs for the core Gadgeteer libraries?
• .NET Gadgeteer Useful Resources & Links
• .Net Micro Framework Showcase: Featured Projects
• TinyCLR/.Net Micro Framework Support (Downloads, Resources, free eBooks, Tutorials, etc)