patricb

Geolocation mit Windows 8

patricb — Thu, 04 Apr 2013 14:52:06 GMT

Als nächstes steht auf meiner Liste der Sensoren der Geolocation Sensor. Um hier nicht mit dem Emulator arbeiten zu müssen, installiere ich auf meinem Surface Tablet den Remote Debugger. Eine Anleitung dafür findet man auf dem Blog meines Kollegen Tim Heuer. Das Thema Geolocation ist ebenfalls in der Dokumentation vorhanden. Wenn auch nicht ganz so ausführlich, dafür aber extrem einfach zum nachbauen.

Dann kann unsere Reise ja auch schon beginnen und wir starten damit ein neues Projekt anzulegen. Wie im Beispiel zuvor lege ich dafür eine C# XAML Applikation an und starte mit dem Blank Solution Template.

Wir setzen einen Button auf die MainPage.xaml über den Designer und geben ihm den Pregnanten namen “btnTracking” und hinterlegen einen entsprechenden Click Handler.

Und das gleiche machen wir ein weiteres mal um das Tracking anzuhalten. Nun brauchen wir noch 2 Elemente. Eine Liste mit dem Status des Gerätes. Und eine weitere Liste mit den Positionen. Also fügen wir zwei ListView Controls unserer BlankPage.xaml hinzu. Das fertige XAML sieht also wie folgt aus:

<Page
    x:Class="GeolocationSimple.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:GeolocationSimple"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
        <Button Name="btnStartTracking" Content="Start Tracking" HorizontalAlignment="Left" Margin="36,32,0,0" 
                VerticalAlignment="Top" Height="81" Width="171" Click="btnTracking_Click"/>
        <Button Name="btnStopTracking" Content="Stop Tracking" HorizontalAlignment="Left" Height="79" 
                Margin="226,34,0,0" VerticalAlignment="Top" Width="171" Click="btnStopTracking_Click"/>
        <ListView Name="listStatus" HorizontalAlignment="Left" Height="554" Margin="78,167,0,0" 
                  VerticalAlignment="Top" Width="532"/>
        <ListView Name="listLocation" HorizontalAlignment="Left" Height="554" Margin="682,167,0,0" 
                  VerticalAlignment="Top" Width="596"/>
    </Grid>
</Page>

Das dazugehörige Codebehind File sollte also nun 2 Eventhandler haben und gut.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238

namespace GeolocationSimple
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {

        }

        private void btnTracking_Click(object sender, RoutedEventArgs e)
        {

        }

        private void btnStopTracking_Click(object sender, RoutedEventArgs e)
        {

        }
    }
}

Als nächstes wollen wir uns dem Geolocator widmen.

Dazu legen wir ein Feld an, das nach dem InitializeComponent Vorgang gesetzt wird.

    …
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private Windows.Devices.Geolocation.Geolocator _location;

        public MainPage()
        {
            this.InitializeComponent();
            _location = new Windows.Devices.Geolocation.Geolocator();
        }
    …

Und schon haben wir den Zugriff auf den Geolocator. Als erstes wollen wir nun den Status des GPS Moduls abfragen. Als erstes setzen wir die beiden Buttons und Ihren entsprechenden State in der OnNavigatedTo Methode die der Einstiegspunkt für unsere App ist.

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            btnStartTracking.IsEnabled = true;
            btnStopTracking.IsEnabled = false;
        }

Als nächstes wollen wir uns dem btnStart zuwenden und die entsprechende Logik hineterlegen.

        private void btnTracking_Click(object sender, RoutedEventArgs e)
        {
            _location.PositionChanged += new TypedEventHandler<Windows.Devices.Geolocation.Geolocator, 
                                         Windows.Devices.Geolocation.PositionChangedEventArgs>(OnPositionChanged);
            _location.StatusChanged += new TypedEventHandler<Windows.Devices.Geolocation.Geolocator, 
                                         Windows.Devices.Geolocation.StatusChangedEventArgs>(OnStatusChanged);

            btnStartTracking.IsEnabled = false;
            btnStopTracking.IsEnabled = true;
        }

Als erstes fügen wir zwei neue Delegaten hinzu. Die setzen wir auf die Events des Geolocators. Die beiden Events an denen wir interessiert sind, ist zum einen die Position und zum anderen den Status des Gerätes. Ich habe auch hier wieder den vollständigen Namespace ausgeschrieben. So dass man Ihn leichter finden kann.

In der OnStatusChanged Methode erstellen holen wir uns den CoreDispatcher der in Windows.UI.Core lebt. Er sorgt dafür, dass wir wann immer sich der Status ändert wir das entsprechend unterscheiden können. Dafür fragen wir den Status der Eventargs e ab. Cool daran ist, dass wir mit dem Switch-Case Snippet und dem args.Status sowie einem Shift+Enter das komplette Statement von Visual Studio automatisch ausgespuckt bekommen.

        private async void OnStatusChanged(Windows.Devices.Geolocation.Geolocator sender, 
                                           Windows.Devices.Geolocation.StatusChangedEventArgs args)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => 
            {
                switch (args.Status)
                {
                    case Windows.Devices.Geolocation.PositionStatus.Disabled:
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.Initializing:
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NoData:
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NotAvailable:
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NotInitialized:
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.Ready:
                        break;
                    default:
                        break;
                }
            });
        }

Die Liste listStatus wollen wir nun mit den entsprechenden Staten befüllen.

        private async void OnStatusChanged(Windows.Devices.Geolocation.Geolocator sender, 
                                           Windows.Devices.Geolocation.StatusChangedEventArgs args)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => 
            {
                switch (args.Status)
                {
                    case Windows.Devices.Geolocation.PositionStatus.Disabled:
                        listStatus.Items.Add("Diabled");
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.Initializing:
                        listStatus.Items.Add("Initializing");
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NoData:
                        listStatus.Items.Add("No data");
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NotAvailable:
                        listStatus.Items.Add("Not available");
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.NotInitialized:
                        listStatus.Items.Add("Not initialized");
                        break;
                    case Windows.Devices.Geolocation.PositionStatus.Ready:
                        listStatus.Items.Add("Ready");
                        break;
                    default:
                        break;
                }
            });
        }

Als nächstes wollen wir nun die eigentlichen Werte abfragen.

…

        private async void OnPositionChanged(Windows.Devices.Geolocation.Geolocator sender, 
                                            Windows.Devices.Geolocation.PositionChangedEventArgs args)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                Windows.Devices.Geolocation.Geoposition pos = args.Position;

                var latitude = pos.Coordinate.Latitude.ToString();
                var longitude = pos.Coordinate.Longitude.ToString();

                listLocation.Items.Add("lat:" + latitude + ", " + "long" + longitude);
            });
        }

…

Auch hier verwenden wir wieder den CoreDispatcher und fragen in diesem Szenario die Position ab, die sich in den args des PostionChangedEvents verbergen. Wir benötigen die Longitude und die Latitude. Die wir der liste hinzufügen.

Noch eben schnell den Button btnStopTracking editiert und dann sind wir auch schon fertig.

…

        private void btnStopTracking_Click(object sender, RoutedEventArgs e)
        {
            _location.PositionChanged -= new TypedEventHandler<Windows.Devices.Geolocation.Geolocator, 
                                             Windows.Devices.Geolocation.PositionChangedEventArgs>(OnPositionChanged);
            _location.StatusChanged -= new TypedEventHandler<Windows.Devices.Geolocation.Geolocator, 
                                           Windows.Devices.Geolocation.StatusChangedEventArgs>(OnStatusChanged);

            btnStartTracking.IsEnabled = true;
            btnStopTracking.IsEnabled = false;
        }

…

Wir lassen die Applikation laufen. Und auch hier kommt das Security Model zum tragen. Deshalb wie schon zu vor in der CameraCaptureApp stellen wir die entsprechende Berechtigung der App im Manifest ein.

Die fertige App sieht nun also wie folgt aus:

Wir wollen das ganze jetzt einmal auf dem Slate testen. Dazu baue ich eine Remote Verbindung auf das Slate auf.

Aus der Liste der Maschinen selektiere ich das Slate.

Beim ersten verbinden, muss eine Developer Lizenz gestartet werden. Und schon sollte Ihre App auf dem Remote Gerät laufen.

Das ist zwar schon ganz nett, aber jetzt wollen wir unsere Position auch auf einer Karte anzeigen. Dazu verwende ich das Bing Maps SDK. Dazu wird ein entsprechender Key benötigt. Dazu fügen wir zu unserem Projekt eine Referenz über Add Referzen hinzu.

Unter Windows Extensions fügt man einfach eine Referenz auf Bing Maps für C# hinzu. Unter umständen muss man nun im Configuration Manager die Target Plattform ändern. In meinem Fall ändere ich das Target auf x86 um.

Als nächstes fügen wir die Bing Maps dem Grid hinzu.

Nun muss nur noch der Key eingetragen werden. Das geht über das Crediantials Attribute. Der Vollständige XAML Code sieht so aus:

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:GeolocationSimple"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:Maps="using:Bing.Maps"
    x:Class="GeolocationSimple.MainPage"
    mc:Ignorable="d">

    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
        <Button x:Name="btnStartTracking" Content="Start Tracking" HorizontalAlignment="Left" Margin="36,32,0,0" 
                VerticalAlignment="Top" Height="81" Width="171" Click="btnTracking_Click"/>
        <Button x:Name="btnStopTracking" Content="Stop Tracking" HorizontalAlignment="Left" Height="79" 
                Margin="226,34,0,0" VerticalAlignment="Top" Width="171" Click="btnStopTracking_Click"/>
        <ListView x:Name="listStatus" HorizontalAlignment="Left" Height="188" Margin="1054,136,0,0" 
                  VerticalAlignment="Top" Width="285"/>
        <ListView x:Name="listLocation" HorizontalAlignment="Left" Height="254" Margin="1059,371,0,0" 
                  VerticalAlignment="Top" Width="280"/>
        <Maps:Map x:Name="bingMap" Credentials="BingMapsKey" HorizontalAlignment="Left" Margin="36,136,0,0" 
                  VerticalAlignment="Top" Height="489" Width="1018"/>
    </Grid>
</Page>

Und nun wollen wir unsere Positionsdaten auf die Map bringen. Dazu gehen wir zurück in das Code Behind File.

Als erstes müssen wir die Geolocation Informationen von Windows 8 auslesen und in Bing Koordinaten konvertieren. Dann einen entsprechenden Pushpin anlegen. Als nächstes können wir die Position des Pushpins bestimmen. Und schließlich zeichnen wir den Pushpin auf die Karte. Als letzter Schritt Zoomen wir in der Karte auf die Richtige Position. Der Code dafür sieht wie folgt aus.

        private async void OnPositionChanged(Windows.Devices.Geolocation.Geolocator sender, 
                                             Windows.Devices.Geolocation.PositionChangedEventArgs args)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                //Retrieve the Geolocation from Geolocator
                Windows.Devices.Geolocation.Geoposition pos = args.Position;

                //Create a new pushpin
                Bing.Maps.Pushpin pin = new Bing.Maps.Pushpin();
                pin.Text = "Meine Position";
                //Get the geolocation from windows 8 and convert to bing maps location
                Bing.Maps.Location location = new Bing.Maps.Location(pos.Coordinate.Latitude, 
                                                                               pos.Coordinate.Longitude);
                //Set the position of the pushpin
                Bing.Maps.MapLayer.SetPosition(pin, location);
                //Add the pushpin
                bingMap.Children.Add(pin);
                //Zoom Bing Maps to location
                bingMap.SetView(location, 18.0f);

                //Convert the postiong for list
                var latitude = pos.Coordinate.Latitude.ToString();
                var longitude = pos.Coordinate.Longitude.ToString();
                //Set the Value in list
                listLocation.Items.Add("lat:" + latitude + ", " + "long" + longitude);
            });
        }
    }

Die fertige App sieht dann wie folgt aus:

Und Fertig! Nun könnte man anfangen richtig Spaß zu haben und eigene Shapes auf die Karte zu zeichnen. In dieser Blog Post von Piotr Walat gibt es eine schöne Beschreibung dazu.

Spaß mit Sensoren - “Internet of Things”

patricb — Tue, 02 Apr 2013 10:50:13 GMT

In der Blog Post Kontext – die rechte Maustaste der NUI – Entwicklung vom 14 März geht Peter Jäger auf die zunehmende Anzahl vernetzter Geräte ein. Seiner Meinung nach ist das ein Konzept das auf bedeutsamer Weise mit zu den natürlichen Steuerungskonzepten der Zukunft zählt. Aber in welchem Kontext stehen nun die zunehmende Anzahl von vernetzten Geräten?

Wenn ich den Facebook Profil meines Kollegen Kai Jäger folge hat dieser ein Talent dafür Prominente an Bahnhöfen und Flughäfen dieser Welt zu treffen. Mir fallen diese zumeist gar nicht auf. Aber was mir hingegen ins Auge springt ist die Tatsache das unglaublich viele Endgeräte an so einem Flughafen present sind. Zum einen sind es Smart Phones und Tablets. Kaum jemand der heute nicht ein gutes dutzend Sensoren in der Tasche versteckt hat.

“Intelligent Systems”

Projekte wie das FALCON-Projekt, also eine App die im Context der Umgebung startet sind naheliegende Szenarien. Der Context in dem sich ein Gerät befindet kann aber mehr bedeuten als nur das automatische bestimmen meiner Position (Geo-Location) und ein Checkin bei Foursquare. Vor ungefähr 3 Jahren haben wir uns in Ingolstadt folgende Fragen gestellt. Bei Elektro Fahrzeugen wie der e-tron Reihe von Audi oder dem i-Konzept von BMW, spielen da Drehzahl und Tankanzeige eine untergeordnete Rolle? Welche Informationen sind wichtig? Die Reichweite des Fahrzeuges, muss ich tanken? Wenn ja, muss ich die Batterie laden oder mal eben kurz zum Erdgasshändler um die Ecke? Eigentlich eine einfache Frage, aber gibt es Einflüsse in der Umgebung des Fahrzeuges die einen Positiven oder Negativen Einfluss auf bspw. die Engergiezellen des Fahrzeuges haben? Und wie visualisiert man diese Faktoren für den Fahrer. Welche Informationen sind Relevant und noch wichtiger auf welche kann der Fahrer Tatsächlich Einfluss nehmen?

(Quelle: http://carsensation.blogspot.de/2012/09/bmw-i8-spyder.html BMW i8 – Spyder Fahrer Informationssystem)

Ein Fahrzeug benötigt also heute 101 Sensor um zu Wissen in welcher Umgebung es sich gerade befindet, und welchen Einfluss die Umwelt auf das Fahrzeug und einen Schritt weiter gedacht, welchen Einfluss das Fahrzeug auf die Umwelt hat. Stichwort Emission etc.
Aber nicht nur Fahrzeuge haben heute gleich eine ganze Reihe von Sensoren. Der Markt der “Intelligent Systems” wird laut IDC auf ca. 649 Billion USD geschätzt und wird bereits 2016 2.6 Billion USD erreicht haben. Segmente wie Medizin, Smart-Home und Smart-Cities um nur einige des wachsenden Marktes zu nennen. Dabei geht es also im Wesentlichen immer folgendes Konzept. Ein Gerät wird mit einer Vielzahl von Sensoren bestückt die Informationen Sammeln. Diese Daten müssen in den richitgen Context gesetzt werden, gespeichert und verarbeitet werden. Und für den Benutzer ausgewertet und Intuitive repräsentiert werden. Dann spricht man von sogenannten “Intelligent Systems”. Der Trend in dem Technologie in unserem Alltag integriert ist und Teil des Alltages selbst ist. Ob das nun das autark fahrende Fahrzeug ist oder die App die unser Zuhause steuert.

Connected

Ein weitere wichtiger Faktor in diesem Zusammenhang ist das Stichwort “Connected”. Ein Fahrzeug oder ein Zuhause das Informationen aufzeichnet und Intelligent in dem Sinne ist, das es seine Umgebung wahr nimmt ist nur ein Teil der Betrachtungsweise. Ein weiterer wichitger Aspekt ist die Speicherung und Verarbeitung der Daten. Zwar sind die Geräte alle mit einem entsprechenden Datenträger versehen, aber der Ansatz das Systeme anderen Systemen Ihre Informationen zur Verfügung Stellen ist die Idee des “Internet of Things”. Der Toaster der aktuelle Wetterkarten auf das Brot brennt ist nun wirklich nichts Neues. Aber Kühlschränke die Automatisch melden wenn Produkte ablaufen und uns das beste Angebot der hiesigen Lieferanten per E-Mail schickt ist schon eine coole Sache. So kann ich bequem von unterwegs bestellen und am Abend die Tüte mit den frisch gelieferten Waren im Kühlschrank verstauen. Der die Lebensmittel in Zukunft nicht nur frisch hält sondern auch Überwacht. Das bedeutet aber auch, dass mein Kühlschrank dazu in der Lage sein muss Angebote über das Internet abzurufen, und mich darüber zu Benachrichtigen. Also bekommt unser Kühlschrank einen entsprechenden Internet Anschluss über W-LAN oder LAN.

Andere Geräte die längst in unserem Alltag sind wie Smart-Phones und Tablets haben längst den dafür Notwendigen Internet Anschluss und sind ein toller Start um sich dieser neuen Welt zu nähern.

Sensoren in Windows 8 und Windows Phone 8

Windows Phone 8 und Windows 8 bietet dank Ihrer APIs einen direkten Zugriff auf vorhandene Hardware Ressourcen. Von der Webcam bis hin zu Accelerometer, Geolocation Sensor und Co.

Da die Demos den Rahmen dieser Blogpost sprengen würden, habe ich mich dazu entschlossen die einzelnen Demos auf andere Blogposts auszulagern.

Windows 8 CameraCapture Sample + MediaCapture API

Geolocation Sample

Accelerometer (cooming soon)

Lightsensor (cooming soon)

NFC (cooming soon)

Anhand der Demos hat man gesehen wie einfach der Zugriff auf die Sensoren tatsächlich ist. Apps wie Foursquare, MyTaxi, … nutzen die unterschiedlichsten Sensoren um den User einen Mehrwert zu bieten. Dieser Mehrwert entscheidet ob ein User sich für oder gegen eine App entscheidet.

Aber Apps stehen für sich alleine. Also ein Endgerät oder ein Benutzer. Die Idee die Werte und die Informationen zu bündeln um dadurch Mehrwerte zu schaffen ist der Gedanke hinter dem Schlagwort Internet of Things.

Merhwerte schaffen durch Hardware? In unserem Alltag begegnen uns im Augenblick schon viele Sensoren die uns helfen wollen. Manchmal muss man aber auch erst einen Prototypen für eine solche Hardware-/Sotfwarelösung bauen.

Rapid Prototyping mit dem .net Gadgeteer

In der Industrie und auch an den Universitäten muss man aber oft ein PoC oder einen kleinen Prototypen also eine Machbarkeitsstudie bauen. gerade wenn es um Hardware geht und die nächste Generation UX spielt Time to Market immer häufiger eine große Rolle. Auch kann man darüber prüfen ob eine Idee tatsächlich Umsetzbar ist. Dank dem .net Microframework 4.2 und dem .net Gadgeteer der Firma GHI Electronics ist genau dieses Szenario komfortabel und einfach geworden.

Los geht es auf der Support Seite von GHI Electronics, nach dem Registrieren/Anmelden erhält man zugriff auf Treiber und aktuelleste Flashes für die Hardware.

Zum starten benötigt man das FEZ Spyder bzw. Hydra Mainbord (siehe Spezifikation) und das rote USB Client Dual Power Module. Dieses wird einfach über USB mit dem Computer verbunden.

In der Konfiguration Port 1 = USBCDP lässt sich das Mainboard flashen. Und man kann im nächsten Schritt beginnen seinen Eigene Hardware zu bauen.

ACHTUNG! Jeweils nur ein rotes Modul (USB Client Dual Power Module) an das Mainboard anschließen!!!

Hallo Welt mit Hardware

Bei den Windows 8 Sensoren Beispielen war als erstes die Kamera aufgeführt. Genau dieses Beispiel will ich jetzt mit dem Gadgeteer nachbauen.

Dazu starte ich Visual Studio 2010 und lege ein neues Gadgeteer Projekt an. Die Toolbox Items und die Projekt Vorlage ist Teil des GHI Software Package.

Dadurch gelangt man zum Designer. Der einem das Mainboard anzeigt und in der Toolbox findet man eine aktuelle Liste der Module und Sensoren.

Unser Versuchsaufbau sieht wie folgt aus:

Port 4 = Button
Port 3 = Camera
Port 1 = USB Client Dual Power Module
Touch Display T35
Port 14 = Display Port R
Port 13 = Display Port G
Port 12 = Display Port B
Port 10 = Display Port T (touch)

Und damit ist unser Setup auch schon fertig. Genau diesen Aufbau bauen wir im Visual Studio im Designer nach. Was dabei heraus kommt ist eine entsprechende Partial Class die folgt definiert ist:

Code Snippet
      
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by the Gadgeteer Designer.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
 
using Gadgeteer;
using GTM = Gadgeteer.Modules;
 
namespace stcHelloWorldGadgeteer
{
    public partial class Program : Gadgeteer.Program
    {
        // GTM.Module definitions
        Gadgeteer.Modules.GHIElectronics.Display_T35 display_T35;
        Gadgeteer.Modules.GHIElectronics.Camera camera;
        Gadgeteer.Modules.GHIElectronics.Button button;
 
        public static void Main()
        {
            //Important to initialize the Mainboard first
            Mainboard = new GHIElectronics.Gadgeteer.FEZSpider();            
 
            Program program = new Program();
            program.InitializeModules();
            program.ProgramStarted();
            program.Run(); // Starts Dispatcher
        }
 
        private void InitializeModules()
        {   
            // Initialize GTM.Modules and event handlers here.        
            camera = new GTM.GHIElectronics.Camera(3);
        
            button = new GTM.GHIElectronics.Button(4);
        
            display_T35 = new GTM.GHIElectronics.Display_T35(14, 13, 12, 10);
 
        }
    }
}
   

Dadurch werden also Ports und Componenten Initialisiert. In der Partial Class Program.cs starten wir nun unsere Applikation.

Sie besteht eigentlich nur aus zwei Delegaten. Der erste um herauszufinden ob der Button gedrückt wurde und der zweite um das geschossene Bild der Kamera auf dem Display darzustellen.

Code Snippet
     using System;
using System.Collections;
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.Modules.GHIElectronics;
 
namespace stcHelloWorldGadgeteer
{
    public partial class Program
    {
        // This method is run when the mainboard is powered up or reset.   
        void ProgramStarted()
        {
            /*******************************************************************************************
            Modules added in the Program.gadgeteer designer view are used by typing 
            their name followed by a period, e.g.  button.  or  camera.
            
            Many modules generate useful events. Type +=<tab><tab> to add a handler to an event, e.g.:
                button.ButtonPressed +=<tab><tab>
            
            If you want to do something periodically, use a GT.Timer and handle its Tick event, e.g.:
                GT.Timer timer = new GT.Timer(1000); // every second (1000ms)
                timer.Tick +=<tab><tab>
                timer.Start();
            *******************************************************************************************/
 
            button.ButtonPressed += new Button.ButtonEventHandler(button_ButtonPressed);
            camera.PictureCaptured += new Camera.PictureCapturedEventHandler(camera_PictureCaptured);
 
            // Use Debug.Print to show messages in Visual Studio's "Output" window during debugging.
            Debug.Print("Program Started");
        }
 
        void camera_PictureCaptured(Camera sender, GT.Picture picture)
        {
            display_T35.SimpleGraphics.DisplayImage(picture, 5, 5);
        }
 
        void button_ButtonPressed(Button sender, Button.ButtonState state)
        {
            camera.TakePicture();
        }
 
 
    }
}
   

Das ganze war schon sehr einfach. So schnell kann man also seine eigene Applikation mit dem .net Gadgeteer bauen.

Ein Beispiel für Home Automation ist das Projekt Heidi. Das Bernd und ich für die CeBit gebaut haben.

Demo Project Heidi (cooming soon)

Fazit

In der Zukunft wird uns Technologie umgeben und Intelligent Systems werden unseren Alltag vereinfachen. Ob es nun Fahrzeuge sind oder Städte wie im Falle von Logica (gehört jetzt zu CGI Gruppe) die sich auf Smart City und Energie Effizienz spezialisert haben. Die zukünftige UX des Users wird also viel von der Umgebung abhängen und den Sensoren die wiederum Apps die sich der Umgebung anpassen, oder die Umgebung steuern.

Die Präsentation von der STC finden Sie hier:

App Developer Day in München

patricb — Thu, 21 Mar 2013 12:17:30 GMT

Aufgrund der großen Nachfrage, meine Slides zum App Developer Day in München:

Windows 8 App Developer Day from Patric Boscolo

Und da ich viele Nachfragen zu den Windows Azure Slides bekommen habe, hier sind Sie.

Erfolgsfaktor app! from Patric Boscolo

Die ausführliche Studie die wir besprochen haben, finden Sie in der Blogpost: Studie zur Mobilen Strategie von Compuware

Studie zur Mobilen Strategie von Compuware

patricb — Tue, 19 Mar 2013 15:58:40 GMT

Compuware hat letzte Woche eine Studie zur Nutzung von Apps auf Mobilen Endgeräten (Smartphone/Tablet) veröffentlicht. Befragt wurden rund 3.500 Nutzer aus unterschiedlichen Regionen (USA, Deutschland, UK, Frankreich, Japan und Indien). Die Befragung wurde im Oktober letzten Jahres durchgeführt weshalb hier weder Windows 8 noch Windows Phone 8 berücksichtigt sind. Das Fazit? Techcrunch schreibt:

Users Have Low Tolerance for Buggy Apps.

Zite für Windows Phone hat mich letzte Woche auf die Studie aufmerksam gemacht. Und ich habe Sie jetzt auch schon in einigen Vorträgen zitiert. Was mich persönlich beeindruckt hat, sind folgende Thesen:

85% der Befragten ziehen eine Mobile App einer Mobilen Internetseite vor.
Die Befragten loben die Schnelligkeit, einfache Handhabung und Komfortabilität der Apps. Im Vergleich zu Mobilen Internetseiten.

Dafür sind Sie aber auch nicht gerade Fehlertolerant. Apps dürfen sich zwar zum Starten 3 Sekunden Zeit lassen, besonders Spiele dürfen auch ein wenig länger brauchen. Aber wenn eine App hängt oder nicht wie gewünscht funktioniert. Selbst wenn die Erwartungshaltung nicht erfüllt wird, ist die liebe zur App ganz schnell vorbei.

Aus eigenem Konsumenten Verhalten kann ich das bestätigen. Erfüllt eine App eine konkrete Aufgabe nicht, gebe ich Ihr natürlich eine zweite Chance, auch eine dritte vielleicht noch. Aber mit mehr Toleranz und Guten Willen darf eine App nicht erwarten.

Die Studie findet man hier: Compuware Whitepapers.

Einige Quellen und Artikel zu diesem Thema:

http://www.thestrategyweb.com/study-consumers-prefer-mobile-apps-to-mobile-Websites

http://www.mobilemarketingwatch.com/study-85-of-consumers-prefer-mobile-apps-to-mobile-websites-30253/

http://techcrunch.com/2013/03/12/users-have-low-tolerance-for-buggy-apps-only-16-will-try-a-failing-app-more-than-twice/

Studie Mobile Apps from Patric Boscolo

A better Command Prompt

patricb — Sun, 19 Aug 2012 23:22:43 GMT

Since I like the CMD Shell per Default to be the Visual Studio Command Prompt I was wondering how to achieve this. Found a way by simply adding the Following Arguments to the System Settings.

%comspec% /k ""C:\Program Files\Microsoft Visual Studio 11.0\VC\vcvarsall.bat"" x86

And here is where you set this.

Press: Windows + Pause and click on Advanced System Settings.

The Full Variable Value should look like this:

%SystemRoot%\system32\cmd.exe %comspec% /k ""C:\Program Files\Microsoft Visual Studio 11.0\VC\vcvarsall.bat"" x86

This is: How to make Visual Studio Command Shell the default command Shell.

Write a WorkItem or Bug to TFS Preview in the Cloud

patricb — Thu, 16 Aug 2012 01:34:03 GMT

Ok, some folks just my search the interweb in how to connect to programmatically via C# to TFS Preview. Here is the how to guide.

So First you need the TFS SDK which you can find here.

Afterwards please make sure you have installed the KB2662296 Fix which is explained here.

That's all you need to get started.

So you start be Making a new Project. In my case I’d like to do a ASP.net MVC Application. So I just wanted to have Controller which is doing all the Magic.

public string SetWorkitems() { }

In order to connect to the TFS in the cloud you have to check out the Endpoint. Here is how this is supposed too look like:

>> https://YOURACCOUNT.tfspreview.com/defaultcollection

Once you figured that out you just need to know how to authenticate against the TFS Preview. Here is the reason why you need to install the KB Fix. Same is true if you want to connect to TFS Preview in the Cloud via Visual Studio 2010 and Team Explorer. Since we use the Identity Service Provider. So that means somewhere behind that is a Resource STS checking if you are allowed to do what you are supposed to do.

The magical Class is ServiceIdentityCredentialsProvider which you should find in the Microsoft.TeamFoundation.Client.dll.

If it is missing you should Install the KB2662296 we discussed earlier.

Well you can now write your own Identity Service Factory to retrieve the Account or you can just use the Tool by Martin Hinshelwood.
Once you authenticated against your TFS Preview instance you get the corresponding User and Password strings.

public string SetWorkitems()
{
    const string serviceUser = "Account Service (generated by Tool)";
    const string servicePassword = "generated by Tool";
    var collection = new Uri("https://YOURACCOUNT.tfspreview.com/defaultcollection");
    const string teamProject = "YOURPROJECT";

var provider = new ServiceIdentityCredentialsProvider(serviceUser, servicePassword);

    var tfs = new TfsTeamProjectCollection(collection, provider);
    // check if authentication works
    tfs.EnsureAuthenticated();

    var workItemStore = tfs.GetService<WorkItemStore>();
    if (workItemStore==null)
    {
        //just for the error handling once more the call
        var tmpTest = new WorkItemStore(tfs);
    }

    if (workItemStore != null)
    {
        WorkItemTypeCollection workItemTypes = workItemStore.Projects[teamProject].WorkItemTypes;

//Define Workitem Type as Bug
WorkItemType workItemType = workItemTypes["Bug"];

//Assign values to each mandatory field
var workItem = new WorkItem(workItemType);

        string workItemTitle = "YOURWORKITEMTITLE";
        string workItemIterationPath = @"YOURAREAPATH\Release 1";
        string workItemAreaPath = "YOURAREAPATH";

        workItem.Title = workItemTitle;
         workItem.AreaPath = workItemAreaPath;
         workItem.IterationPath = workItemIterationPath;

        //Check for Validation errors before saving
        var validationErrors = workItem.Validate();
        if (validationErrors.Count==0)
        {
            workItem.Save();
        }
        else
        {
            return validationErrors.Count.ToString(CultureInfo.InvariantCulture);
        }
    }

return "success";
}

The rest is just API Stuff, which should be easy. Notice in order to Retrieve and work with Workitems there is a bunch of Team Foundation SDK References you will need to add. Here is the List.

That's it happy Extensioning!!!

Mapping SCRUM to Visual Studio 2012

patricb — Tue, 14 Aug 2012 23:59:30 GMT

Come over this nice definitions of Richard Hundhausen about that terminology in SCRUM and TFS. Which I found very useful, so maybe you like to check that out as well?

Scrum Concept	Visual Studio Concept
Team	Team Foundation Server security groups
Definition of Done	Wiki entry or document on the portal
Product	Team Project
Product Backlog	Product Backlog shared query or Backlog page on TWA
Product Backlog Item	PBI or Bug work item
Acceptance Criteria	Acceptance Criteria field and (optionally) associated Test Case work item(s)
Release	Iteration Path (high level)
Release Plan	Backlog page on Team Web Access (w/ Forecast tool)
Sprint	Iteration Path (low level)
Sprint Dates	Iteration start and end dates
Sprint Goal	Wiki entry or document on the portal
Sprint Backlog	Sprint Backlog shared query or Backlog & Board pages on TWA
Task	Task work item
Burndown and Velocity	Release Burndown, Sprint Burndown, and Velocity reports and charts on TWA
Impediment	Impediment work item
Retrospective	Wiki entry or document on the portal

Windows Azure Blob Storage einrichten

patricb — Sun, 10 Jun 2012 19:26:45 GMT

Das neue Portal ist online, und da ich gerade einen Sample Download Ordner für die Dark Side Bakery Samples anlege, dachte ich mir ich mache mal eben kurz ein Tutorial.

Zuerst melde ich mich über das neue Portal https://manage.windowsazure.com an.

Dort angekommen gehe ich in den Bereich Storage. Und lege eine neue Storage an. Über den Punkt +New

Ich fülle die entsprechenden Felder aus.

Jede Blob Storage hat eine eindeutige URL als Endpoint. Ich trage also die URL ein und kann eine Regionsauswahl treffen. Für Europa können nun entweder Affinity Groups definiert und ausgewählt werden, oder man verwendet die Datacenter in Dublin bzw. Amsterdam. Da bei meinem letzten Loadtest eine bessere Performance von Amsterdam gemessen wurde. Lege ich diese Blob Storage auch dort an. Da ich mehrere Accounts auf Azure habe, wähle ich im Menupunkt Subscriptions meinen Internen Account aus.

Insgesamt gibt es derzeit auf Windows Azure 3 Arten von Storages. Die BLOB (Binary Large Object) Storage, die Table Storage (NoSQL) und Queue. Bei letzteren ist der Name Program. Um die BLOB Storage nutzen zu können richtet Windows Azure einen Entsprechenden DNS Eintrag ein. Mehr zu diesem Thema findet man auf der Azure Developer Seite.

Ist das erledigt, ist die BLOB Storage unter der URL http://darksidebakery.blob.core.windows.net/ zu erreichen.

Im nächsten Schritt, erstelle ich ein Monitoring. Dazu gehe ich in der oberen Leiste auf Monitoring und setze die Einstellungen so, dass wir ein präzises Monitoring für Transaktionen auf den BLOB erhalten. Das Portal weißt mich auch darauf hin, dass ich nun höhere Kosten habe und mit Performance einbrüchen rechnen muss.

Damit man auch Daten ablegen kann, benötigt man sogenannte Container. Diese kann man mit einer entsprechenden Berechtigung versehen. Um diese Container anzulegen, kann man entweder das SDK verwenden und einige Zeilen Code Tippen oder CloudBerry verwenden.

Der Zugriff von CloudBerry geschieht über einen sogenannten Access Key. In Cloud Berry kann man unter Source: Add Azure Blob Storage Account Container anlegen.

Dazu wählt man einen beliebigen Display Name aus und hinterlegt den Account was in diesem Beispiel “darksidebakery” ist. Und übernimmt aus dem Portal den Access Key über Manage Keys.

Via Copy und Paste in CloudBerry einfügen und Test Connection verrät ob alles geklappt hat.

Ist der Account angelegt, kann man sich auf die BLOB Storage verbinden und einen neuen Container anlegen. In unserem Fall wollen wir dem Internet einen Full Read Access geben. Und wählen die entsprechende Einstellung aus.

Jetzt kann man via Cloudberry und Drag & Drop Dateien wie man es von einem klassischen FTP Program gewohnt ist uploaden.

Windows 8 RC Installation

patricb — Mon, 04 Jun 2012 13:55:00 GMT

Wie hat Benny so treffend formuliert?

Die Entwicklung für Windows 8 ist einfacher als seine Installation.

Da wir hier in der Dark Side Bakery schon häufiger die Frage gestellt bekommen haben: Wie, Welche Reihenfolge? …
Habe ich mich dazu durchgerungen einen Installationsguide zu schreiben. Alle Angaben sind wie immer ohne Gewähr und zum Thema Haftung Ihr kennt die Antwort. Ich bin nicht Schuld. Wer

>Format c:

macht ist selber Schuld!

Zutaten

Da wir das hinreichend geklärt haben, können wir wie bei jedem guten Kochbuch auf die Zutaten schauen:

3,4 GB Windows 8 RC Build 8400
103 MB Zune Player
290 MB Expression Studio 4
2,6 GB Office 2010 SP1 Professional
686 MB SQL Server 2012 Express with Advanced Services & Management Studio
2,3 GB Visual Studio 2010 Ultimate
1,6 GB Visual Studio 2012 Ultimate
41,8 MB Windows Azure SDK 1.4
41,4 MB Windows Azure SDK 1.6
2,9 MB Windows Azure MMC
33,9 MB Windows Azure Toolkit for Windows 8
559 MB Windows Phone Tools
Über den Webplattform Installer kommen noch weitere Zutaten wie: ASP.net MVC 4 RC, Webmatrix, ISS Developer Express …
Und natürlich noch die Tools der Wahl…

Zubereitung

Nachdem man Windows 8 via des Windows 7 USB Stick Tools auf einen bootbaren USB Stick gebracht hat, beginnt die Installation. … Nach round about 1800 Sekunden sollte die Installation fertig sein. Und ich beginne immer mit Office aber auch die kleinen Helferlein die jeder haben mag, also Tools sind ein willkommener Startpunkt. Nach der Installation von Office folgt die Installation der Add- und Plugins für die Office 2010 Suite. Jetzt noch schnell Zune installiert. Habe kürzlich einige Einstellungen zerschossen, als ich Zune nachinstalliert habe. Deswegen der frühe Zeitpunkt.

Nach der Installation der Tools und Helfer die spätestens jetzt angesagt ist, beginnen wir mit dem SQL Server 2012. Diesen gibt es in Unterschiedlichen Geschmacksrichtungen. Und hier sollte nun wirklich für jeden was dabei sein. Ich habe mich für die Express variante Entschieden und nach der Installation als SQLExpress Instanz kommen die Expression Tools dazu. Dazu zählt auch die Installation der Windows Phone Tools, die gleich nach der Expression Studio Serie installiert wird.

So, jetzt sind Visual Studio 2010 und die damit verbundenen Extensions an die Reihe. Und natürlich nicht zu vergessen, das SP 1 für Visual Studio 2010.
Dann sind auch schon Webmatrix, IIS Express und ASP.net MVC 4 an der Reihe.

Gefolgt von den Windows Azure SDK 1.4. Die Schritte lassen sich hier nachvollziehen. Dann kommen Windows Azure MMC und Windows Azure SDK 1.6 . Dann folgen die Azure Tools wie Cloud Berry und Co. und dann zuletzt die Visual Studio 2012 Version. Der Abschluss der SDKs ist nun das Windows Azure Toolkit für Windows 8. Jetzt noch kurz die Resharper 7 EAP installieren und fertig.

Hier noch eine grafische Anleitung...

Damit ist der Windows 8 Installations HowTo Guide auch schon zu ende. Wenn das ganze fertig ist, sollte es so aussehen.

Happy Coding!!!

Windows Azure Konfiguration / Definition

patricb — Sun, 25 Mar 2012 20:08:54 GMT

Bei Windows Azure handelt es sich um eine Sammlung von Diensten. Dazu gehört unter anderem natürlich die Möglichkeit Virtuelle Maschinen in der Public Cloud zu betreiben. In der Windows Azure Welt nennen wir das Konzept “Hosted Services”. Die entsprechenden SDK für Windows Azure produzieren ein Deployment Package und eine Konfigurationsdatei.

Ein Packet besteht also aus:

In der Service Konfiguration befinden sich Informationen über die Virtuelle Maschine selbst. So können hier größe und Anzahl der Instanzen angegeben werden. Mehr zur Service Konfiguration finden Sie auf MSDN. http://msdn.microsoft.com/en-us/library/windowsazure/ee758710.aspx

In der Service Definition befinden sich Informationen über Endpoints und erweiterte Einstellungen. Mehr zu dieser XML Konfigurations Datei finden Sie ebenfalls auf MSDN. http://msdn.microsoft.com/en-us/library/windowsazure/ee758711.aspx

Die Project Binaries representieren Ihre Lösung. Auf Grund der beiden Konfig Dateien erstellt Windows Azure nach dem Upload in die Cloud eine Virtuelle Maschine aus den vorgefertigten VM Templates erstellt.

Bei den VM Templates handelt es sich um VHD Images mit einer preinstallierten Windows Server 2008 Version.