But what if you don't have a Kinect? Or use of your hands? Or have limited movement or space?

You all know I have this thing for Emotiv. So lets put all this together.

What if you could...

Use your brain as mouse control (with EPOC by Emotiv)

Can you imagine that there is an easier way to control the mouse, than with your head? The answer could be: With your mind.

Electroencephalography (EEG) was already established in 1924. In the past it was used mainly for medical reasons. But now you can also use this technology, to control your computer.

Emotiv EPOC

Emotiv has developed a Neuroheadset called EPOC. It reads your brainwaves and on this ground it is able to detect your current feelings like boredom, frustration, meditation and excitement. Your mind sends also certain signal patterns when your face is showing facial expressions. So EPOC can detect facial expressions like smiling, lowering and raising your eyebrows, clenching your teeths or blinking your eyes. This is quite similar to the facial expression detection, which is provided by Kinect for Windows SDK. Furthermore EPOC has a Gyroscope, which recognizes your head movement very accurate. So we developed a version of FaceMouse especially for EPOC.

FaceMouse for EPOC

You can replace your mouse with Emotiv EPOC, the revolutionary brain computer interface. Within Emotiv Control Panel there is already a Mouse Emulator which uses the EPOC Gyroscope to control the cursor of your mouse. EmoKey, an app developed by Emotiv, provides basic functionality for clicking by using EPOC, but this method has several disadvantages:

• In EmoKey clicks are sometimes not executed correctly in special kinds of application windows.
• It is not possible to send a scroll command with EmoKey.

FaceMouse for EPOC sends mouseclicks directly to the operating system, independent from the currently active application window. Also it is possible to scroll or drag & drop, which is not possible with EmoKey.

Just activate the Mouse Emulator in Emotiv Control Panel and use this simple App. It is the easiest way to replace your mouse with EPOC.

FaceMouse

This is a small Windows application, which enhances the possibilities to use EPOC as mouse control. Within Emotiv Control Panel you find a Mouse Emulator which uses the EPOC Gyroskop to control the cursor of your mouse. EmoKey provides basic functionality for clicking by using EPOC, but this method has several disadvantages:

In EmoKey clicks are sometimes not executed correctly in special kinds of application windows. Also it is not possible to send a scroll command with EmoKey.

This application sends mouseclicks directly to the operating system, independent from the currently active application window. Also it is possible to scroll or point & click. FaceMouse uses data from Expressiv Suite.

Just activate the Mouse Emulator in Emotiv Control Panel and use this simple App. It is the easiest way to replace your mouse with EPOC.

Mouse control with your face, head and mind... That's just cool

What?

NUIverse

NUIverse is an application, written to give me a sandbox for exploring “Natural User Interaction” with a large, multi-dimensional dataset. This build for the Samsung SUR40 with Microsoft PixelSense demonstrates multi-touch gestures, multi-user and multi-directional UI, and object-interaction with transparent Byte Tags. This site provides brief instructions for installing, using, and configuring NUIverse.

NUIverse is not intented as an accurate simulation of the solar system and surrounding universe, since it was written in my spare time and the focus was on interaction rather than accuracy. There are many existing applications available for this purpose, such as Microsoft WorldWide Telescope, Celestia, Space Engine etc.

The following video shows the application demonstrated on a Samsung SUR40 with Microsoft PixelSense at WPC 2012.

NUIverse for Windows

As previously discussed, my manipulation processor now supports WM_TOUCH messages, which means that I can do native multitouch on both Windows 7 and Windows 8. I have therefore updated NUIverse for a Windows-release, as shown below in Figure 1.

There are some key differences to the PixelSense-release, as follows:

• No support for tagged objects, since it does not use the Surface 2.0 runtime, nor require PixelSense hardware (though it will run on the latter outside of the Surface Shell).
• Since horizontal form-factor multitouch hardware is generally less-common than vertical form-factors, I have added a single-orientation configuration setting. This is true by default, since even if mounted horizontally, many touchscreens will not deliver the multitouch performance required for simultaneous multi-user interaction.
• Since the Surface Shell added chrome to close the application and by default the application runs full-screen, either drag in a menu control (see note below) and use the exit menu, or press ESC if a keyboard is present.

One of the current issues when running a full-screen desktop app on Windows 8 is that the operating system captures initial touches used for edge-swipes. If touch is maintained after an initial edge-swipe, further edge-swipes are not captured and therefore will add NUIverse controls to the screen. An alternative is to touch the screen and simultaneously edge-swipe, or to use two fingers when edge-swiping.

Several key configuration settings (in NUIverse.exe.config) are worth mentioning. Note that there is no graphical interface for these settings, and that the configuration file needs to be edited by hand (I would recommend saving a copy first):

• PixelWidth and PixelHeight control the resolution used for both windowed and full-screen mode.
• FullScreen controls whether the application runs full-screen (true) or windowed (false).
• For the configuration settings specified in mm to work correctly, set PixelsPerMm to the appropriate value, taking account physical screen size and either PixelWidth or PixelHeight (square pixels are assumed).

To install NUIverse for Windows, proceed as folows:

1. Install the XNA 4.0 runtime.
2. Download and extract NUIverse for Windows (2.75Mb) to a suitable location.
3. Low-resolution textures for several planets and moons are included, but extras can be created or downloaded from http://nuiverse.com.

Here's a snap of the app running on my Windows 8 notebook;

I said there was extensibility?

Extensibility Model Part 2

I previously mentioned that I had implemented an extensibility model, and thought it useful to discuss an example of adding a simple model to earth orbit, as shown below in Figure 1 (further images of which are in the gallery).

Figure 1. Model added to earth orbit. Colonial Raptor model (based on new TV series) by Coxxon.

The "extra" is defined as a folder containing the following items:

• A model in XNB format. XNA has built-in content importers for .x and .fbx (2009.1) formats.
• An optional pair of textures for both diffuse and emissive textures. These are standard image files.
• An XML file defining the "extra", in this case as shown below in Listing 1.

This configuration file specifies that the model should be added to the planetoid "earth" in the "solar" system, both of which are defined in system.xml configuration file.

In order to scale the model correctly, a scale factor is applied to normalize the model to unit length. This can either be applied in the XML scale attribute, or specified in the XNA content processor scale attribute, in which case the XML attribute can be set to 1. A size attribute then defines the maximum length of the model in km. The Colonial Raptor shown in Figure 1 was defined with a size of 8.6m.

The textures are defined in sub-folders "texture" and "emissive". If an emissive texture is not available, an all-black image (e.g. JPEG file) can be used.

The rotation period defines how long it takes for the model to rotate while orbiting the planetoid. If this is the same as the P orbital element, then the same face of the model is presented to the planetoid throughout the orbit. The remaining standard orbital elements specify that the model is in a circular equatorial orbit at an altitude of 500km (the earth has a radius of 6,371km).

Make sure you read through the rest of his NUIverse, and other, articles as they are very interesting and informative... (like his holographic Princes Leia recording post... that's just cool!)

Windows 8 Platformer Game Starter Kit

Platformer Game Starter Kit(includes 2 HTML5-based examples)

Don't start from scratch. Our Platformer Game Starter Kit for Windows 8 will get you going with full code & free game art.

How

---

Feel free to take the examples, mix them up and build your own great game for the Windows Store following these steps:

1. Download your free Visual Studio for Windows 8 for all the tools you will need.
2. Download the Platformer Game Starter Kit.
3. Mix it up and build your own epic game.
4. Open a Windows Store Developer Account.
5. Let us know about it and we can even give you free advice on making it great and help pass store certification.
6. Publish it to the Windows Store.

We know everyone is not a game artist, so we have provided you with some free game art and other places you can find royalty-free art for your game.

Ludus Game Starter Kit

An HTML5 Platformer Game Starter Kit for Windows8 Store

by Christer (McFunkypants) Kaitila http://mcfunkypants.com

Source: https://github.com/mcfunkypants/ludus

Demos: http://www.mcfunkypants.com/ludus

Welcome to Ludus, brave adventurer!

Ludus is a dirt-simple game engine that uses html5 canvas. It was designed specifically for mario/sonic style platformer games but could be used for any genre with minimal changes. It boasts great performance, and requires only free tools.

The word Ludus means PLAY/GAME/TRAINING in latin. The Ludus engine is designed to be a great way to learn to make games.

Sure, there are bigger and more complex game engines.

This one is designed to be easy to play around with.

Why? It was created to run real-world games that have a beginning, middle, and end. It was optimized to run on less powerful systems and touch-screen tablets. It is simple, but goes beyond the level of a "tech demo" to encapsulate all the required functionality you might need to make a polished game, such as GUI and sound.

...

IT'S POSSIBLE TO MAKE A GAME USING LUDUS IN A WEEKEND.

You could make your own game just by changing the artwork: it is possible to make a new game without ever touching a line of code. All you would need to do is modify the .png and .mp3 art assets as well as the level#.js level data files.

The best tool to create in-game worlds is TILED (http://www.mapeditor.org) which exports data in .json format.

Check out the example .tmx source files and see if you can make your own game! Once you've made a level, export as .json and then run the _buildlevels.bat file to convert JSON to JSONP data to a new level#.js file.

The one important thing to remember is that each layer is important. The order matters. The bottom-most layer is for regular world tiles that the player will collide with. The rest are for pickups, bouncy platforms, dangerous spikes, and so on.

Additionally, you should modify the game settings in the MAP MENU -> MAP PROPERTIES dialog. Gravity, speed and the player's starting position are all stored there.

HACKING THE SOURCE CODE

The only source code file you will want to modify, if you choose to start coding, is ludus.js. Inside, you'll notice all sorts of variables at the top which you can modify to your heart's content. Note that some of these variables are overwritten by whatever is defined inside the level data.

With regard to the structure of the code, the most important thing to know is that the game is controlled by STATE objects.

Each state (title screen, in-game, and between level transitions) is a class object that has a .setup(), .update() and .draw() function. You could add new states for things like boss battles, inventory screens or a high score table.

See these class constructors: function TitleScreenState() function LevelTransitionScreenState() function PlayState()

HAVE FUN!

...

Let's take a peek at the two included example games (In Visual Studio of course!)...

Both games ran for me the first time with no issues and were fun (in a platformer kind of way). Sure there's only 3 levels, but hey, if there was too much done it would take all the coding fun away!

So either start from scratch or copy off of these, this kit and the provided free artwork, framework and code will have you building your next great Windows 8 game...

Okay, maybe this isn't "hacking" nor all the hardcore [at all] but for a non-circuit guy like me, it is...

Arduino Fun – Door Entry Alarm

Physical computing and “internet of things” is a super exciting area that is unfolding right now. Even decades back one could hook up sensors and remotely get those data and process it. What is special now is that powerful micro-controllers are dirt cheap and most of us have in our pockets a really powerful computing device. Connecting everything wirelessly is also very easy now and almost every home has a wireless network.

All of these put together can create some really compelling and cool stuff where data travels from sensor over wireless networks into the cloud and finally into the cell phone we carry everywhere. I finally want to create a smart door so that I can get an notification while at work when someone knocks at our home door. Maybe I can remotely open the door. The possibilities are endless, but time is not, so lets see how far I get in some reasonable amount of time.

...

The Project

I decided to start out with making a simple entry alarm and see how much time it takes to get everything done. In college I built something similar, but without a microcontroller (based on 555 IC and IR photo-transistors) and it took decent amount of time to hook up all the components. Basically the idea is that across the door there will be some source of light and a sensor will be on the other side. When someone passes in between the light on the sensor will be obstructed and this will sound an alarm.

When I last did it in college I really made it robust by using pulsating (at fixed frequency) IR LED as source and IR sensors. Now for this project I relied on visible light and the photo-resistor that came with the kit.

...

Now, get building!

Building Portable Libraries?

Wonder what all the weird and wild code paths your code might have, but it hurts your brain to try to write every possible path in your unit tests?

Want a free extension that throws everything at your code, but the kitchen sink? (though I think that's an option too...

Introducing: Code Digger, an extension for VS2012

Today, the Pex team at Microsoft Research (Nikolai Tillmann and Peli de Halleux) is happy to announce that Code Digger, an extension for Visual Studio 2012, has shipped to the Visual Studio Gallery. After shipping the Moles framework as Fakes in Visual Studio 2012, this is the next step of bringing our research projects to the latest and greatest development environment

...

What is Code Digger?

Code Digger generates interesting values that show different behaviors of your .NET code. The result is a table showing for which inputs your code produces which outputs.

What is the relation between Pex and Code Digger?

Under the hood, Code Digger uses the Pex engine and Microsoft Research’s Z3 constraint solver to systematically analyze all branches in the code, trying to generate a test suite that achieves high code coverage. Working together with Peter Provost from the Visual Studio product group, we tried to create a really simple user interface. We want to bring the idea of code exploration to every programmer’s fingertips. This is different from the Pex Power Tools where we gave you many options to configure, and you had to embrace the idea of (Parameterized) Unit Testing to get all benefits. Code Digger is not a full replacement of Pex, it is merely the first extension that the Pex team ships for Visual Studio 2012 – stay tuned for more.

Limitations

Code Digger only works on public .NET code that resides in Portable Class Libraries.

By restricting the code exploration to Portable Class Libraries, we avoid problems with code that has dependencies on a particular platform which the Pex engine does not understand.

...

Microsoft Code Digger

Overview

Code Digger analyzes possible execution paths through your .NET code. The result is a table where each row shows a unique behavior of your code. The table helps you understand the behavior of the code, and it may also uncover hidden bugs.

Through the new context menu item "Generate Inputs / Outputs Table" in the Visual Studio editor, you can invoke Code Digger to analyze your code. Code Digger computes and displays input-output pairs. Code Digger systematically hunts for bugs, exceptions, and assertion failures.

Code Digger only works on public .NET code that resides in Portable Class Libraries.

Under the hood, Code Digger uses the Pex engine and Microsoft Research’s Z3 constraint solver to systematically analyze all branches in the code, trying to generate a test suite that achieves high code coverage.

Code Digger is the first extension from the Pex team at Microsoft Research for Visual Studio 2012. Stay tuned for future extensions that bring more aspects of the rich experience of the Pex Visual Studio 2010 Power Tools to the latest version of Visual Studio. If you have feedback for us, or bug reports, feel free to write an email to the Pex team at Microsoft Research. If you have used Pex before, let us know if you are missing a particular feature.

To stay up-to-date, like Pex and Moles on Facebook.

...

Walkthrough

After you have installed the Code Digger extension for Visual Studio 2012, create a “Portable Class Library” project.

...

Write some public code, right-click on it, and select “Generate Inputs / Outputs Table”.

Wait a moment, and you will see a table, listing interesting parameter values which cover all the corner cases in your code.

...

TouchDevelop has been highlighted before, Develop for Windows Phone, with Windows Phone... TouchDevelop, yet this time, David's hours of videos and pages of curriculum will take you from getting started to creating your first series of games...

TouchDevelop Curriculum Video Tutorials

Video Tutorials on Microsoft's new development platform TouchDevelop which allows anyone to create games or apps for mobile devices using a mobile device.

Yes that means program and playtest apps on your WP or Surface, Android Phone or Tablet and even on any iOS Tablet or Phone. All you need is a device with an HTML5 compatible browser.

Curriculum

Here's three examples of the games David helps you create...

If you are trying to pickup TouchDevelop, or looking to get someone in your life excited about development, this is your ticket to Ninja-dom (well, ticket to get you stared at least...)

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();
     }
}

Visual Studio has these cool things to help you in your debugging, called Visualizers. They help you see beyond the code and into the data, using a custom dialog or interface. And while there's a number in the box, they can't build one for everything.

But Visual Studio being what it is, you can create your own...

Visual Studio Visualizer: Part 1

Add a Visual Studio Visualizer to look data from: 

• Dataset; 
• DataTable; 
• DataRow; 
• DataView; 
• DataRowView; 
• DataRowCollection.

Using the code

Visit the project home page, download your flavor (2010 or 2012), unzip, and place the DLLs in the right folder, Documents\Visual Studio xxxx\Visualizers. 

When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow, and DataView objects. 

Points of Interest

For some reason arrays are not allowed for visualizing within visual studio debug, but when using the VisualizerDevelopmentHost class to test the visualizer, an array is allowed.

This project shows a work around to make a non-serializable object available to our custom visualizer. 

Create a visualizer

This project was created using visual studio express, any edition can be used.

First create a class library project then add a reference to the Visual Studio Visualizer API, the DLL can be found on: (Visual Studio installation folder)\Common7\IDE\ReferenceAssemblies\v2.0 Microsoft.VisualStudio.DebuggerVisualizers.dll. 

Add references to the types of objects, the visualizer will receive:

[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DSVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataSet), Description = "My DataSet Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DTVisualizer), typeof(VisualizerObjectSource), Target = typeof(DataTable), 
    Description = "My DataTable Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRow), Description = "My DataRow Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataView), Description = "My DataView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRVVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowView), Description = "My DataRowView Visualizer")]
[assembly: System.Diagnostics.DebuggerVisualizer(
    typeof(DRCollectionVisualizer), typeof(DataRowVisualizerObjectSource), 
    Target = typeof(DataRowCollection), Description = "My DataRowCollection Visualizer")]

This can be inside any cs file of the project, but it must be outside any namespace declaration. As you can see, some types use VisualizerObjectSource and others use DataRowVisualizerObjectSource, this is because the DataRow type needs some massage before we can use it, this is covered later.  

The class that will get the object to visualize must inherits from DialogDebuggerVisualizer. 

This will allow to override the Show method: 

...

Visual Studio Watchers

This project contains some visualizers to work with Visual Studio.

Currently this project has visualizers for:

• DataSet
• DataTable
• DataRow
• DataView
• DataRowView
• DataRowCollection

There next visualizers will be for entity framework objects (trying to do a visualizer for all custom objects), StringBuilder, string and XDocument.

Introduction

Place the dll's in the right folder, Documents\Visual Studio xxxx\Visualizers.
When debugging with VS there is a extra option for visualizer, for the DataSet, DataTable, DataRow and DataView objects.

DataSet

The dataset visualizer mainpage, show a tree and a datagrid. In the tree all of the datatables are available:

...

And as you expect the source for all this is available too...

Game Starterkit for Windows 8 with leaderboard in Windows Azure

This Game Starter Kit for Windows 8 contains what you need to get started with game programming for Windows 8, including online high score in Windows Azure. The game kit is written in HTML and JavaScript.

Download now – follow instructions below to make it work.

Before we start, let me show you what you get with this solution.

Example game
The kit comes with an example game that you can modify and play with. The code is all in one file so it’s easy to play with for beginners. Feel free to use it however you like.

The kit will get updated with cooler and more advanced game that you can use as a basis when developing your own. Follow this blog to get the updates!

...

If you want to learn how to create this game that comes with this starter kit, you can read the guide here (slightly different graphics):

Part I:
http://digitalerr0r.wordpress.com/2012/09/19/html5-game-development-for-windows-8-1-getting-started/

Part II:
http://digitalerr0r.wordpress.com/2012/09/20/html5-game-development-for-windows-8-2-adding-a-player/

Part III:
http://digitalerr0r.wordpress.com/2012/09/20/html5-game-development-for-windows-8-3-finishing-your-first-game/

• Implementation of high score in Windows Azure
  The kit also enables support for Windows Azure and handles the connection, and got functions to check if you are having a internet connection. You need to have your own Windows Azure account, and set up the service/datatable yourself.
• Snap view
• Tiles
• Settings charm implementation

Let’s get you up and running!

Follow this guide to get everything up and running with the starter kit.

1) Install the tools

2) Get an account on Windows Azure

3) Create your Mobile Service and Database

4) Configure

5) Build your solution and make sure it works

Go back to the solution, make sure you have the correct URL and Application Key in your solution, and then Build and run the project.

The game starts up, and when you die, your score will be uploaded to this table. Check that the column Score is created, and that it contains the correct score value you wanted.

Go to the Data tab and the table to see your scores:

Now, be creative. There are a lot of funny little games you can create by just modifying this simple template.

...

Download now

Here's a snap of the Solution;

And a snip, once you've set everything up, on how easy it is to talk to Windows Azure Mobile Services

If you're creating a Windows 8 or Windows Phone 8 app (or iOS or Android) Windows Azure can really ease your cross platform data needs (Yeah, I know the irony in that, but it's true).

So anyway.. you've got your starter kit, you've got your cloud storage, now just add some "You"...

.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;

So why am I highlighting it here? But it looks like a awesome resource that you can code against, build awesome app's using it's data, and it's all open, as in open, open, open...

Digital Public Library of America (dp.la)

The Digital Public Library of America brings together the riches of America’s libraries, archives, and museums, and makes them freely available to the world. It strives to contain the full breadth of human expression, from the written word, to works of art and culture, to records of America’s heritage, to the efforts and data of science. The DPLA aims to expand this crucial realm of openly available materials, and make those riches more easily discovered and more widely usable and used, through its three main elements:

1. A portal that delivers students, teachers, scholars, and the public to incredible resources, wherever they may be in America. Far more than a search engine, the portal provides innovative ways to search and scan through the united collection of millions of items, including by timeline, map, format, and topic.

2. A platform that enables new and transformative uses of our digitized cultural heritage. With an application programming interface (API) and maximally open data, the DPLA can be used by software developers, researchers, and others to create novel environments for learning, tools for discovery, and engaging apps.

3. An advocate for a strong public option in the twenty-first century. For most of American history, the ability to access materials for free through public libraries has been a central part of our culture, producing generations of avid readers and a knowledgeable, engaged citizenry. The DPLA will work, along with like-minded organizations and individuals, to ensure that this critical, open intellectual landscape remains vibrant and broad in the face of increasingly restrictive digital options. The DPLA will seek to multiply openly accessible materials to strengthen the public option that libraries represent in their communities.

Open platform, open data and open API...

The platform (so you can see how the built it all, which is kind of cool)

The data;

The API...

Welcome!

Welcome to the DPLA API Codex! This is where you can find authoritative documentation for the DPLA API and resources you can use to make the most of it. We’re happy to have you. (Wondering why we built an API in the first place?  Check out our philosophy.)

What now?

• If you’ve never played (or worked) with an API before, head on over to API Basics.  We’ll get you started accessing some of our data.
• If you’re already familiar with APIs in general and you just want to know how to get at our data, skip the basics and dive right into requests (Make sure you get an API key first.)
• Once you’ve got some shiny new JSON-LD, how can you tell what it all means?  In responses, we explore the structure of objects and define the fields within those objects that the API will return.
• Ready to start building something against our API, but want to know how we operate? We’ve got you. Check out our policies.
• Uh oh.  You’re lost. We’re lost. Everything’s broken. I’m confused.  Time to check out our troubleshooting and FAQ page!
• Confused by the terminology we’re using? Check out the glossary of terms.
• Did we miss/break/overlook/forget something? Tell us.

The essentials

Need to start right now? Here’s a cheat sheet.

• http://api.dp.la/v2 is the base URL of the DPLA API.
• items and collections are the two resource types you can request.
• In order to pass requests to the API, you’ll need to request an API key first. You also need to append &api_key=$YOUR_KEY (where $YOUR_KEY is your 32-character key) to any requests you make.
• All records are returned as structured, wonderful, JSON-LD objects.   And we have reasons for that.
• We’ve got a boatload of fields you can query, and a whole bunch of ways you can query them.
• Dive head first into a bucket full of kitten metadata: http://api.dp.la/v2/items?q=kittens&api_key=. (Copy and paste the URL into your browser and add your API key on the end.)

...

API Basics

...

A request is a URL sent to the web server over HTTP with the expectation of getting resource items back in the form of human-readable text or data. The URL supplies the web server with everything it needs to create and return a correct response. This is called a RESTful approach to API design and is employed by the DPLA API.

Who should use this?

This API is intended for use by large organizations and lone individuals alike, and our audience’s level of technical sophistication is deliberately quite varied.

How do I use it?

All you need to do to use the DPLA API is:

1. Request an API key from DPLA.
2. Fire up your web browser and enter your request into the URL bar.
3. Read the response.

The DPLA API offers metadata (and meta-metadata) on two types of resources: items and collections. In short, items represent single physical objects indexed by a DPLA data provider, and collections are logical groupings of items. For simplicity’s sake, let’s try a simple search for items—i.e., a full-text search of all of the fields associated with items for a single term.

Let’s say you really want to know more about weasels. Compose your search query by taking the URL of the API and append your request to it like so:

http://api.dp.la/v2/items?q=weasels&api_key=

http://api.dp.la/v2 specifies the API and the correct version; items indicates the type of resource you’re requesting; ?q= begins your request, and the unadorned, unqualified search term weasels will be interpreted as a request for a full-text search.

Remember: You must enter your 32-character API key after the &api_key= parameter in included in every example request, and in general.

Now let’s look at typical results (to simplify things, we’re only reproducing the first result here):

...

Open, open, open... Now it's up to you to build some cool apps (hopefully Windows apps . If you do, let us know...

DrumkitX

A Windows Phone 8 port of the ​Drumkit XNA example using Direct3D and XAudio for fast graphics and low latency sample playback. This demo app lets you play percussion sounds by tapping the screen. You can record your beats, play them back later and also play drums on top of your latest recording.

---

This example has been implemented for various platforms; ​With Qt for Symbian, MeeGo Harmattan and ​JavaME for Series 40. The XNA version supporting Windows Phone 7.x can be found ​here.

Compatibility

• Compatible with Windows Phone 8 phones
• Tested with Nokia Lumia 920 and Nokia Lumia 820
• Developed with Visual Studio 2012 Express for Windows Phone 8

Here's a snip from the technical documentation

The basic structure of DrumkitX was generated with the ​Windows Phone XAML and Direct3D App wizard in Visual Studio. The following diagram is a high-level overview of the architecture:

DrumkitX is the managed component part of the solution. It is structured like a regular XAML app with pages and C# code-behind classes. In the XAML and Direct3D App template, the Direct3D content is rendered onto a DrawingSurface control that is laid out in regular XAML like any other interface element.

DrumkitXComp is the native C++ component that takes care of graphics and audio using Direct3D and XAudio2. It knows nothing of the managed component, it is only provided with a surface to draw onto.

The native component uses the ​DirectX Toolkit to simplify resource handling and drawing, specifically loading textures with DDSTextureLoader and drawing them with SpriteBatch.

...

And a snip from the solution;

Finally the app itself, which compiled and ran for me with no problems...

On the outside it's simple, but shows off a number of interesting things you can do...

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...

Space Invaders

Project Description
The classic Space Invaders game written in C#.

**Space Invaders The Game **
The project represents entertaining console game. The idea in the game is stopping alien invasion. There are different types of alien ships that must be destroyed by the player’s ship. Both the player and the aliens can fire to destroyed the enemy and have number of lifes. For every destroyed alien ship player receives points. Also there can be bonuses for killing the aliens – Gifts (points or additional life).

Deceptively simple? Check out the included Diagram;

And a snap of the Solution;

Yeah, all that for a console space invaders. How cool is that...

Yeah, I know it feels like I've been doing allot frameworks recently, but in my weird world, playing with new frameworks and seeing how they work is "fun". Why? They let you focus on building your apps, and not worrying about the goo. Or they let you see how the library author dealt with the goo. Or you LIKE goo and want to create your own goo buster. So many opportunities for fun.

Anyway...

Cimbalino Windows Phone Toolkit

Cimbalino Windows Phone Toolkit is a set of useful and powerful items that will help you build your Silverlight applications for Windows Phone.

The Toolkit is divided in projects, regarding different Windows Phone application required capabilities:

• Cimbalino.Phone.Toolkit - the base project of the toolkit, containing base MVVM services, some very useful converters, helper classes and extension methods, and the bindable Application Bar behavior
• Cimbalino.Phone.Toolkit.Camera - MVVM compatible services for camera access
• Cimbalino.Phone.Toolkit.Controls - Controls library (requires Silverlight for Windows Phone Toolkit)
• Cimbalino.Phone.Toolkit.DeviceInfo - MVVM compatible services for device information access
• Cimbalino.Phone.Toolkit.Location - MVVM compatible services for location access
• Cimbalino.Phone.Toolkit.PhoneDialer - MVVM compatible services for phone dialer access
• Cimbalino.Phone.Toolkit.UserInfo - MVVM compatible services for user information access

Note: this toolkit is only compatible with the Windows Phone SDK 7.1.x and Windows Phone 8.0!

Nuget

The packages are available thru NuGet here, with the same handles as the project names (e.g., the main package is "Cimbalino.Phone.Toolkit")

Download

Please visit the download section on GitHub to download the latest release of the toolkit.

I thought one of the cool things was that it supports both Windows Phone 7.1 and 8...

While you can easily grab the binaries from NuGut, since source is part of the fun, I grabbed the latest drop. Which compiled with no problems or errors.

How do you use it? There's a couple samples in the repository... Here's the Location sample.

So okay, what else is there of interest? Just check out snaps of the main library;

That enough to wet your appetite?

Cimbalino, you ask? Here's Pedro's answer.

"Cimbalino" is the word people from Porto (my home town!) use for expresso coffee!

The name Cimbalino is a reference to La Cimbali, a popular brand for expresso machines a few years ago in Portugal.

If you'd like you can hear how it is correctly read in Portuguese.

Here's a few of the past posts;

• Controlling a .NET Gadgeteer Device with your mind...
• Mind Control with C# (and the Emotiv and Emotiv Engine Client Library)
• It's as if it can read your mind...

Today we show off Antonio Blescia's work in his ThinkUino project.

ThinkUino Project

ThinkUino (Thinking Arduino) is an open source project that allows to connect the Arduino board with Mindwave headset. The cognitive application opens new frontiers for control the electronic circuits through  the reading of brainwaves. With this article I explain how to make a cognitive application for control a single LED light.

Mindwave... what is it?

Mindwave is an innovative headset produced by Neurosky. Mindwave converts the brainwaves into digital electronic signals. There are two version of this device:   

• Mindwave Headset: is the basic configuration of Mindwave. It can be connected only to pc for reading data only with Neurosky applications. Its color is white. You can buy it from this link: http://store-eu.neurosky.com/collections/hardware/products/mindwave-1
• Mindwave Mobile Headset: this version allow to connect with mobile device through bluetooth SPP communication. This device retrieves the brainwaves with more precision. This device, than, can be connected to Android and iOS operating system. Its color is black. You can buy it form this link: http://store-eu.neurosky.com/collections/hardware/products/mindwave-mobile

Mindwave... two versions, but which i should choose?

For the scope of this project the Mindwave Mobile is indispensable. That device supports the bluetooth connection, through the bluetooth connection it send the data in RAW mode to the connected devices. With the retrieved data we can parse the various frequency reading by the headset. 

What do I need to implement this project?

The fundamental elements to create this project are:  

1. Mindwave Mobile Headset 
2. Arduino 2009 or higher 
3. Led  

 

...

Best of all is the code is all C# and looks pretty simple (as must code does in hindsight

The device's price seems reasonable, the Brainwave Starter Kit is currently $99, it's developer tools are free and this project shows just a glimpse of how you can start turning it into the "Internet of [Mind] Things"...

Developing an app with the Visual Studio 3D Starter Kit, part 1 of 3

As we promised a few weeks ago, welcome to the first post in a series where we’ll explore a full end-to-end app developed with the Visual Studio 3D Starter Kit. During this series we’ll develop a 3D dice roller that allows you to roll a 6-sided die by tapping or clicking it. In the process of rolling a number, the die will jump and flip in the air. This app will also work on Windows 8’s snap view, so that users can still roll dice while working on other apps. Finally, we’ll show you how to make this app compatible with Windows RT devices and port it to Windows Phone.

This first post will cover the basics of creating the app to the point where we can render the die to the screen and apply a texture.  We’ll also review the Visual Studio Graphics tools, which are included in Visual Studio Professional or greater.  If you only have Visual Studio Express 2012 for Windows 8, don’t worry, you’ll still be able to use this walkthrough.

The hardest part about learning Direct3D development is the need to learn many new concepts, such as coding HLSL shaders and how to convert meshes into runtime formats. There are many Visual Studio tools make this process much easier, letting you focus on your app logic instead of dealing with all those new concepts. And whenever you’re ready you can add more advanced features to your app without having to start over. Throughout this series, we’ve provided a number of links to additional documentation about DirectX features that we use, so you may want to follow these links to explore more about DirectX and graphics programming.

Let’s stop talking and start designing our app!

The demo app: a dice roller

Dice are used for a variety of board games and gambling. Making a simple dice roller app is an easy task in any programming language - a random number generator is only one line of code in many languages. But how can we make this app more interesting?

Starting with a clean slate

The first step to use the Visual Studio 3D Starter Kit is to download and open it. You can get the full Starter Kit from http://aka.ms/vs3dkit. We have also prepared a special version of the Starter Kit (Windows Store only) for this tutorial that starts with a completely blank screen with no 3D models, so we can explore how to create our own assets. You can get that version on CodePlex (direct download link on the tile below). This changeset also shows what has to be changed to remove all the content from the Starter Kit.

Note for Visual Studio Express users: You can download the assets used in this project by clicking the tile below. Just add them to your project at the appropriate points in the walkthrough below.

If you run this app, you’ll see the Starter Kit’s teapot splash screen, followed by an empty gray screen. Don’t worry, we’ll fill it up soon…

...

Developing an app with the Visual Studio 3D Starter Kit, part 2 of 3

...

Let it roll, baby, roll

In order to make anything move in a graphics application, the steps are always the same:

1. Set some state (e.g. a Boolean flag) to indicate that an animation should be running. This is also a good time to save the starting position and time of the animation if needed.
2. In the Update method (called on every frame before rendering), calculate the object’s position/rotation/scaling (in 3D speak, transforms) using the time between the beginning of the animation and the current frame time. You must also make sure that when the animation ends the state is correctly updated to stop the animation.
3. In the Render method, make sure that the transforms are correctly applied to each object.

In our case we will add a new method called RollDie() that will set the state and save the starting time. We will use this method to calculate each die roll result, but for now let’s just execute an animation that rotates the die from 1 to 6.

To create this animation we will need a set of variables to keep track of the cube’s transforms, as well as the animation time. We will create one Boolean value to signal that animation is running, one float to store the animation time, and three vectors to store the initial, final and current rotations of the cube. These vectors should be of type XMFLOAT3, to store the Yaw, Pitch and Roll rotations (see figure below).

...

So this completes our app functionality. It’s definitely a more useful and interesting version of the classic random number generator. You can download this version on CodePlex (direct download link on the tile below).

We only have a few more steps to finish in order to make this app run on Windows RT and Windows Phone as well!  We’ll cover these steps in our third and last blog post. Stay tuned!

Keep an eye on the Visual C++ Team Blog for the final part...

What you need is a NFC emulator/simulator (and wouldn't it be cool if the source for that emulator/simulator's source were available?)

How to use emulators to develop NFC features on WP8

One of the more interesting features of Windows Phone 8 is its Proximity Framework for Near-field communications (NFC). Both Nokia and Microsoft have heavily invested in this area. The Proximity API provides you the controls needed to innovate on NFC technology, but at the moment Windows Phone SDK default emulator does not simulate NFC. That means you have to use real WP8 devices to test and debug NFC-related features. If you’re developing a feature to be used between NFC-enabled devices, you’ll need to have at least two devices in hand. In addition, there are often physical movements required to perform NFC interactions while debugging.

The good news is that there is an open source project called “Proximity Tapper” (http://proximitytapper.codeplex.com/) which offers NFC simulation on top of the emulators WP8 SDK provides. The project is generously Apache 2.0 licensed. Proximity Tapper can simulate a wide variety of NFC scenarios, such as tapping one WP8 device with another, tapping a WP8 device with a tag, and tapping a WP8 device with Windows 8 device. The use cases that Proximity Tapper cannot perform include tag writing, “Tap+Send” system integration (due to lack of Bluetooth capability), and Wallet integration. Also, it currently does not support tapping between a real WP8 device and an emulator. According to discussion on project webpage, mixing real WP8 device with emulator seems to be too much work.

From the Proximity Tapper UI, you first add devices. WP8 Emulators can be automatically discovered. Also other devices such as Windows 8 devices can be added manually using IP, hostname, or MAC addresses

...

Proximity Tapper can be a pretty handy tool for NFC development on Windows Phone 8. It allows you to focus more on the content of messages to be published/subscribed. Using the emulator to test NFC is not only cost-efficient but also saves you the hassle of moving between real devices and keyboard while developing NFC features. It’s also perfect for demonstrating your app during presentations.

Proximity Tapper

Project Description
Proximity Tapper is a developer tool for working with NFC on both Windows Phone and Windows, and allows you to build NFC apps in the Windows Phone emulator.

The Windows Phone 8 emulator does not currently have any built-in official support for emulator NFC (Near Field Communication), but the Proximity Tapper tool plugs into the Windows Phone 8 emulator to simulate NFC and make it possible to test and develop NFC/Proximity-enabled Windows Phone 8 apps without phone hardware. The tapper tool supports "tapping" a pair of Windows Phone 8 emulators together as if they had physically been tapped, injecting NDEF messages into the connection (and allowing for "tapping" just a single emulator), as well as displaying all message traffic for diagnostic purposes.

Note that the Proximity Tapper tool is not officially supported, and it does not always accurately simulate the behavior of true NFC hardware.

Quick Start

VERY IMPORTANT: When first launching the tapper tool you will get a Windows Firewall prompt, you MUST select ALL 3 checkboxes and allow the tool through the firewall otherwise it will silently not work

• After launching the quick start installer, make sure you follow the above instruction to select all 3 checkboxes on the firewall prompt. Also, the tapper tool must be installed and used on the same physical host machine as the Windows Phone emulators.
• The tapper tool has 3 sections:
  • The top left lists the devices available. Any running Windows Phone emulators (must be running on the same physical host machine) should automatically show up in the list, for Windows machines running the simulator driver you may type the IP address or hostname in the textbox and click "add" to manually add them to the list.
  • The bottom left lists the active connections (taps). When you tap a pair of devices together (or a single device) the connection representing that tap is listed, but when you untap (equivalent of pulling the devices apart and breaking the NFC connection) the connection will disappear.
  • The right half of the screen is the message log and will show the transcript of all messages sent or received over the currently selected connection (select it in the list on the bottom left).
• Tap a Pair of Phone Emulators Together
• Tap a Phone Emulator to a Simulated NFC "tag"
• Tap With a Windows 8 Device

...

Getting Started Writing Proximity/NFC Apps

• The APIs for Proximity/NFC are mostly identical between Windows 8 and Windows Phone 8. They're Windows RT-based which means you can use them from either C# or native C++ (and WWA on Windows 8)

• Getting started guide to Proximity/NFC APIs: http://msdn.microsoft.com/en-us/library/windows/apps/xaml/Hh465221(v=win.10).aspx

• Proximity code sample: http://code.msdn.microsoft.com/windowsapps/Proximity-Sample-88129731

• Windows 8 NFC Driver Spec (contains useful information about message types and formats): http://msdn.microsoft.com/en-us/library/windows/hardware/hh770524.aspx

Source? Yep!

Here's a snap of the Solution, based on the latest source check-in (Dec 11, 2012);

You'll not he Warning icons... As you download it, it won't compile, complaining about not being able to find the certificate in the Cert Store. Don't sweat it. To the Project Properties, Signing tab and uncheck the Sign the ClickOnce manifests (or click on the Create Test Certificate)

Now the program should compile and run (at least it did on my machine).

So if you're interested in building and testing WP8/W8 NFC app's or just checking out some interesting code... Proximity Tapper.

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)

dx.h - A modern C++ library for DirectX programming

dx.h is a modern C++ library that aims to simplify DirectX-related development in C++.

It focuses on Direct2D but also includes support for Direct3D, DXGI, DirectWrite, the Windows Imaging Component (WIC), and the Windows Animation Manager (WAM).
dx.h is compatible with Windows 7, Windows 8 (both desktop and Windows Store projects), and Windows Phone 8. The Direct2D 1.0 subset should even work on Windows Vista.

For in-depth Direct2D training, please check out Direct2D Fundamentals. For a crash course in DirectX programming, and even more Direct2D training, check out Direct2D Fundamentals – Part 2.

dx.h was created by Kenny Kerr.

There's no carebear here, no doc's beyond the code, no diagrams, no Solutions, no help files, no compiled downloads, just code, code, code (and in the end, that's all you really need, right?)

Source

If you're a C++ DirectX'er you're probably not even gotten this far down the post have you? You're already check out the code, aren't you? 

Today's Mobile Monday project is one that's kind of cool, in a weird "track your health stat's via a Windows Phone 8 Health Vault enabled app" kind of way.

Like many do as they get older, I've been tracking some of my health stats, like blood pressure recently. And being a dev, where did I track them? No, not there (in a custom dev'd app), but Excel. Yeah, I know... I'd have to remember to write them down, and when I got home update my Xlsx.

Well now that there's the SkyDrive, Web Excel and Excel on my Windows Phone 8 (and Surface RT) I could be a little less lame and do it right there in the Dr's office.

But still, Excel? (cough... lame... cough)

Isn't there a much broader heath bases system and infrastructure? One that can be a repository for all your health data? One where there's app's, devices, etc?

Yep, there's Microsoft's HealthVault. And there's an API too! (You were wondering when we'd get to the coding stuff, weren't you?)

So wouldn't it be cool to be able to easily, securely, from your phone add or update your data?

Today's project by Ranjan.D does just that...

Blood Pressure Tracker, Win 8 Phone Based HealthVault App

This application interacts with HealthVault. One has to create a HealthVault application and makes use of the Application Id in Blood Pressure Tracker App.

For now you can run the sample application without creating a new application in HealthVault. However it can be used only for testing and not for production. In reality all your blood pressure information will be stored in HealthVault. You are responsible for your own data. Please make sure to keep them secret and not to disclose to unauthorized persons.

Please note : This article does not deal with how to move test HealthVault application to production.  Also no part of the concept , code is related to my current or previous organizations.

Introduction 

This article is all about blood pressure and it's tracking. Blood Pressure Tracker, A Windows 8 Phone application developed for tracking the day to day blood pressure states. Before jumping into the technical details about the
application , we will try to understand about blood pressure and related terminologies.  

Domain knowledge is very important for a technical person so that one can understand and contribute better. Many a times programmers don't understand what they do, they just try to complete their work items. They don't bother to understand the business. Things may work fine for few , however it's very important for us to understand the domain so that one can meet the expectations of business analyst or product managers and deliver the right product to customer. 

The blood pressure tracker application stores all the information in Microsoft HealthVault. The same is being fetched. We will not go in detail about the HealthVault integration but to an extent we will see how to communicate with it.  

Let us now start with the basic understanding of blood pressure.

...

After explaining what and how's of blood pressure, the article goes into detail on how you can create a new HealthVault Application

Creating a New HealthVault Application

For now we will work on development environment of HealthVault. First of all we need a HealthVault Application Id in order for our application to communicate with the HealthVault. Below is the link for creating a new HealthVault Application. You need a windows live Id, click on the below link and log into the site.

...

Then it's code, code, code

Using the code

The Blood Pressure Tracker App uses some of the HealthVault libraries to integrate with HealthVault for authenticating the user and then storing and fetching of blood pressure information.

...

The sample code ran for me fine the first time, which is always nice. Here's a snap of the Solution

As the author states clearly (and the app makes very apparent) this is just the starting point, connecting to a test/dev HealthVault server.

There's more steps involved in rolling into production (which makes sense, do we really want it easy for any app/systems/etc to access our health data? Without some kind of controls and processes in place?) but this does get you started down the road and building your next Health App.

They say Health/Medical is the next big "thing," maybe this is your chance to catch that next wave (or at least code something different...

• 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!

It's got some "standard" features but also some pretty cutting edge and pretty cool ones too.

And besides binaries (GNU or LGPLv2), the source for everything is available too!

Sasa

Description

Sasa is a collection of extensions to the .NET framework organized in logical, often standalone assemblies.

Sasa: no deps
* tuples
* IEnumerable extensions
* thread-safe + null-safe events
* numeric extensions
* Option type
* lazy type

Sasa.Binary: -
* low-level bit-twiddling functions
* portable BinaryReader/Writer

Sasa.Collections: Sasa, Sasa.Binary
* purely functional collections, ie. list, dictionary, queue, set, etc.

Sasa.Mime: -
* media types and file extensions

Sasa.Numerics: -
* statistical and numerical functions

Sasa.Net: Sasa, Sasa.Collections
* full MIME message parsing
* POP3 client
* Rfc822 header parsing

Sasa.Contracts: Sasa
* Code Contracts impl.

Sasa.Concurrency: Sasa
* software transactional memory
* Concurrent Revisions fork-join framework

Sasa.Parsing: Sasa
* extensible Pratt parser

Sasa.Dynamics: Sasa
* type-safe reflection

Sasa.Linq: -
* LINQ expression visitors and query providers

...and much more!

To get a real feel for everything that's in this cool collection, check out the doc's, http://higherlogics.net/sasa/docs-v0.9.4/

Source? Yep! (and you can see that it's under active development too

Here's a snap of the binary drop (to highlight the "standalone assemblies" statement):

Want to see more? Check out Sandro's blog posts on Sasa, http://higherlogics.blogspot.com/search/label/Sasa

What kind of Sasa stuff has he written recently?

• Sasa.Strings - General String Extensions
• Sasa.Parsing - type-safe, extensible lexing and parsing framework
• Sasa.Dynamics - type-safe polytypic/reflective programming
• Sasa.Func - Type-Safe Delegate Combinators
• Sasa.Option - Handling Optional Values
• Sasa.Result - Handling Exceptional Values
• Sasa.Numbers - Generic Number Extensions

Hopefully that has wet your appetite a little. Now it's up to you to grab it and start Sasa'ing! (I just like saying, "Sasa..." can you tell?

Aviary Launches Windows 8 SDK with 6 Partners

We’re proud to launch Aviary’s Photo Editor SDK for Windows 8, specifically designed for apps on Windows 8 tablets and PCs. This new SDK joins our existing SDKs for iOS, Android, HTML5 & Windows Phone 7, collectively used by our 3,500+ partners.

We worked closely with AMD and Microsoft to build this SDK from the ground up, optimizing our photo-editing technology by leveraging unique AMD APU architectural advantages.

...

Windows 8 developers – you can download and use Aviary’s SDK, available immediately here: http://aviary.com/w8

If you’d like to try out the features and functionality first, download Aviary’s Photo Editor app for Windows 8 from Microsoft’s app store.

Contact us if you have any questions at partners@aviary.com – we would love to help you integrate Aviary

...

If you're new to Aviary, first you create an account (about 2 seconds of work), you get a key (by "creating an app" again about 2 seconds), you download the SDK and sample code (about 4 seconds), install the SDK (4.73 seconds), fire up the sample code and start playing.

It's taken me longer to write about it that it took for me to get to the point of running the sample code...

BTW, there was one issue I ran into with the sample code provided with the SDK.

When I first fired up the Project, it was set to Any CPU, which Aviary didn't seem to like.

Quickly switching it to x64 (x86 and ARM worked too, anything but Any CPU) fixed it all up

Here's it running on my notebook;

Looks like allot of stuff there right? How hard to get this into your app? About 6'ish lines of code...

And I said something about free?

If you need photo editing features for your app, this looks like a great place to start looking at...

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.