Dispositivos conectados se va a ser un gran negocio, y la comprensión de estos dispositivos va a ser muy importante para los desarrolladores .
 En la edición de junio de MSDN Magazine ( msdn.microsoft.com/magazine/jj133825 ), se explicó una serie de consideraciones y esbozó una arquitectura para la forma de gestionar los flujos de eventos y comandos desde y hacia  los dispositivos que usan Windows Azure Servicio Bus.
En este artículo,se va  a tomar las cosas un paso más allá  mostrando  el código que crea y asegura los flujos de eventos y mando.
Dado que  una comprensión real de los dispositivos integrados requiere mirar uno,  se va a construir uno y después la conexion  que hasta el bus  de servicio de Windows Azure para que pueda enviar eventos relacionados con su estado actual y controlar de forma remota a través de mensajes a través de la nube de Windows Azure.
 Hasta hace sólo unos pocos años atrás, para la construcción de un pequeño dispositivo con una fuente de alimentación, un microcontrolador y un conjunto de sensores  era  necesario un poco de habilidad en el diseño de hardware electrónico, así como para poner todo junto, por no hablar de buen dominio de la soldador. 

Pero debido a la aparición de plataformas de prototipado como Arduino / o Netduino. Gadgeteer NET, se puede poner ahora juntos en un pequeño dispositivo completamente funcional, aprovechando las habilidades existentes de programación.

 En este articulo se trata de diseñar un «acondicionador de aire» en la forma de un ventilador controlado por termostato, donde el ventilador es la parte menos interesante desde el punto de vista eléctrico.

 Los componentes del proyecto se basan en el modelo Gadgeteer NET, implicando una placa base con un microcontrolador, una memoria y una variedad de módulos conectables .


La placa base para el proyecto es un tablero de GHI Electronics Araña FEZ con los módulos de ampliación siguientes:

•  De GHI Electronics Ethernet J11D módulo para proporcionar una red cableada (un módulo Wi-Fi existe) DP
•  Módulo USB Client como fuente de alimentación y puerto USB para la implementación Joystick para el control directo del dispositivo 
• Desde Studio Seeed Sensor de temperatura y humedad Relés para cambiar el ventilador encendido o apagado
•  Pantalla OLED para mostrar el estado actual 

En conjunto, estas piezas cuestan alrededor de $ 230. Eso es obviamente más que soldar componentes equivalentes sobre un tablero,
 Además, este es un mercado que está empezando a ponerse en marcha, por lo que esperan que los precios bajan como la base amplía.
 Para hacer que los componentes cobren vida se necesitara  Visual C # 2010 Express (versión gratuita completamente funcional de VStudio  c#), el. NET Micro Framework SDK y el SDK Gadgeteer de GHI Electronics o Seeed.

 La figura 1 muestra la vista de diseño del programa Gadgeteer. NET en Visual Studio.   El archivo con la extensión. Gadgeteer contiene un modelo XML que es visualizado en el editor. Desde ese archivo XML, la herramienta Gadgeteer genera automáticamente una clase del Programa parcial con contenedores para cada uno de los módulos conectados a la placa base.
Su código se encuentra en el programa. cs celebrar otra parte de la clase de programas, al igual que el modelo de código subyacente que está familiarizado con entre sí. API NET.

 Se utiliza el. NET Micro Framework con estos dispositivos. Es una versión de código totalmente abierto de la plataforma Microsoft. NET Framework que se ha creado específicamente para dispositivos pequeños con limitado poder de cómputo y memoria no mucho.

Debido a que el marco es una capa sobre el hardware nativo del dispositivo y el dispositivo no es un ordenador de propósito general con un sistema operativo que maneja toda la abstracción de hardware (en realidad no hay OS aquí), la versión del marco se puede utilizar con un dispositivo depende del fabricante de la placa de soporte de los requisitos previos, lo cual es, obviamente, muy diferente de la experiencia de una PC regular, donde particularidades de hardware están muy lejos de las cosas como de alto nivel como el Marco. NET.

 Hay varias otras diferencias en comparación con el normal. NET, y la plataforma PC en general, que son-procedente de un PC de fondo inicialmente sorprendente. Por ejemplo, el dispositivo aquí no tiene una batería de a bordo.

 Como no hay batería para el buffer de reloj,  el dispositivo no tiene idea de la hora real  cuando se despierte.

 A falta de un sistema operativo, y con una pantalla de extensión de otro fabricante, el dispositivo también no tiene fuentes a bordo que puede utilizar para dibujar cadenas para mostrar. Si desea mostrar una cadena, usted tendrá que agregar una fuente a hacerlo.

 Del mismo modo, el dispositivo no tiene predefinido, Windows Update mantenido almacén de certificados. Si desea validar los certificados SSL / TLS, que tendrá que desplegar al menos los certificados de CA raíz en el transcurso del dispositivo y de que va a también tiene que tener la hora actual para comprobar la validez del certificado.

 Como ya has adivinado podría, el manejo de los certificados representa un poco de un obstáculo para estos dispositivos, así como los requisitos para la criptografía SSL / TLS son tan importantes en términos de cálculo esfuerzo, el consumo de memoria y huella de código que no todos los dispositivos pueden apoyarlos. Sin embargo, porque la seguridad es claramente cada vez más importante, incluso en este espacio como los dispositivos deben comunicarse a través de Internet, la versión 4.2 del Framework. NET Micro aporta mejoras significativas para SSL / TLS para dispositivos que tienen recursos suficientes para manejar la situación.


. Termostato Funciones Implementar la funcionalidad termostato local para esta muestra es bastante sencillo. Voy a comprobar la temperatura y la humedad en una programación con el sensor y cambiar el ventilador conectado a través de uno de los puertos de relé apagado o encendido cuando la temperatura cae por debajo o por encima de un determinado umbral. El estado actual se visualiza en la pantalla OLED y la palanca de mando permite ajustar la temperatura objetivo manualmente. Mientras comienzo del dispositivo, voy a cablear eventos a un temporizador para activar las lecturas de temperatura y para leer los eventos de la palanca de mando.

Cuando se presiona la palanca de mando, voy a suspender el temporizador, comprobar la temperatura objetivo de acuerdo con la posición del joystick , solicite inmediatamente una nueva lectura de temperatura del sensor y reanudar el temporizador. cuando finaliza la lectura de temperatura, el evento se TemperatureHumidityMeasurementComplete planteada por el sensor. entonces a almacenar las lecturas actuales y ajustar el estado del relé para conmutar el ventilador si necesario. Esa es la medida de la lógica de termostato, que se muestra en parte en la Figura 2.

 Figura 2 Lectura de Temperatura y Humedad

1.  
2.           void WireEvents()
3. {
4.   this.InitializeTemperatureSensor();
5.   this.InitializeJoystick();
6. }
7. void InitializeTemperatureSensor()
8. {
9.   this.temperatureCheckTimer = new Timer(5000);
10.   this.temperatureCheckTimer.Tick += (t) =>
11.     this.temperatureHumidity.RequestMeasurement();
12.   this.temperatureCheckTimer.Start();
13.     this.temperatureHumidity.MeasurementComplete 
14.     += this.TemperatureHumidityMeasurementComplete;
15. }
16. void InitializeJoystick()
17. {
18.   this.joystick.JoystickPressed += this.JoystickPressed;
19. }
20. void JoystickPressed(Joystick sender, Joystick.JoystickState state)
21. {
22.   this.temperatureCheckTimer.Stop();
23.   var jStick = this.joystick.GetJoystickPostion();
24.   if (jStick.Y < .3 || jStick.X < .3)
25.   {
26.     settings.TargetTemperature -= .5;
27.     StoreSettings(settings);
28.   }
29.   else if (jStick.Y > .7 || jStick.X > .7)
30.   {
31.     settings.TargetTemperature += .5;
32.     StoreSettings(settings);
33.   }
34.   this.RedrawDisplay();
35.   this.temperatureHumidity.RequestMeasurement();
36.   this.temperatureCheckTimer.Start();
37. }
38. void TemperatureHumidityMeasurementComplete(TemperatureHumidity sender, 
39.   double temperature, double relativeHumidity)
40. {
41.   var targetTemp = settings.TargetTemperature;
42.   this.lastTemperatureReading = temperature;
43.   this.lastHumidityReading = relativeHumidity;
44.   this.relays.Relay1 = (lastTemperatureReading > targetTemp);
45.   this.RedrawDisplay();
46. }
47.       

 Cada vez que ajuste la temperatura deseada en el método JoystickPressed, se guarda el valor nuevo en el campo de la clase Program ‘ajustes y llamar StoreSettings. El campo de configuración es de tipo applicationSettings, una clase serializable en el código de dispositivo que mantiene todo el equipo necesario recordar a través de las renovaciones y los ciclos de potencia.

Para almacenar persistentemente los datos, el Marco. NET Micro se reserva algunas páginas de almacenamiento en la memoria no volátil del dispositivo y permite el acceso a este almacenamiento a través de la clase ExtendedWeakReference
. No creo que sea intuitivo hasta que reconozcas que es ante todo un mecanismo para intercambiar datos de la memoria principal a presión, y convenientemente se dobla como una función de almacenamiento. La clase contiene referencias débiles a objetos, tal como el WeakReference regular lo hace en el marco. NET, sino que intercambiar los datos para el almacenamiento no volátil en lugar de descartarlo una vez que el recolector de basura, vuelve.

Dado que los datos se intercambian fuera de la memoria principal, tiene que ser serializado para el almacenamiento, lo que explica por qué la clase applicationSettings (que veremos más tarde se utiliza cuando hablamos de aprovisionamiento) necesita ser serializable. Recuperación de un objeto a partir de su lugar de almacenamiento o la creación de una ranura de almacenamiento nuevo con el método RecoverOrCreate requiere especificar un identificador único. Sólo tengo un objeto de almacenar, así que voy a usar un identificador fijo (cero).
 Después de que el objeto se ha almacenado y una vez recuperado, las actualizaciones deben ser obligados a regresar a almacenamiento mediante el método PushBackIntoRecoveryList en la instancia ExtendedWeakReference, así que eso es lo que hago en StoreSettings para eliminar los cambios, como se muestra en la figura 3.

1.           static ApplicationSettings GetSettings()
2. {
3.   var data = ExtendedWeakReference.RecoverOrCreate(
4.     typeof(ApplicationSettings),
5.     0,
6.     ExtendedWeakReference.c_SurviveBoot | 
7.     ExtendedWeakReference.c_SurvivePowerdown);
8.   var settings = data.Target as ApplicationSettings;
9.   if (settings == null)
10.   {
11.     data.Target = settings = ApplicationSettings.Defaults;
12.   }
13.   return settings;
14. }
15. static void StoreSettings(ApplicationSettings settings)
16. {
17.   var data = ExtendedWeakReference.RecoverOrCreate(
18.     typeof(ApplicationSettings),
19.     0,
20.     ExtendedWeakReference.c_SurviveBoot | 
21.     ExtendedWeakReference.c_SurvivePowerdown);
22.   data.Target = settings;
23.   data.PushBackIntoRecoverList();
24. }
25.         

 Figura 3 Actualización de los datos almacenados Poner en funcionamiento


 En el principio, el dispositivo está en «nueva de fábrica» ​​estado del código de dispositivo se ha desplegado el dispositivo, pero todavía no se ha inicializado y por lo tanto no tiene ninguna configuración actual.
 Se puede ver este estado se refleja en el método GetSettings cuando el objeto de configuración sigue siendo nula y por tanto se inicializa con la configuración predeterminada.

 Porque quiero dejar que el aparato se comunican con Internet ya través de una infraestructura de Windows Azure Service Bus-Necesito equipar el dispositivo con un conjunto de credenciales para hablar con esa infraestructura y también decir que los recursos con quien hablar.

 Ese primer paso de la creación de un dispositivo de nueva fábrica con la configuración de red necesaria y la creación de los recursos correspondientes en el lado del servidor se conoce como el aprovisionamiento, me referí a la modelo arquitectónico básico para ello en el artículo anterior.
 En el código de dispositivo Voy a ser bastante estricto acerca de cómo obtener el dispositivo aprovisionado correctamente e iniciará los pasos de aprovisionamiento cada vez que el dispositivo se conecta a la red y no tiene una configuración válida.
 Por eso, mantener una bandera booleana en los valores que me diga si he tenido éxito anterior. Si el indicador no está definido, expido la llamada al servicio de aprovisionamiento alojado en Windows Azure. El servicio de aprovisionamiento es responsable de verificar la identidad del dispositivo utilizando su identificador de dispositivo único, el cual fue registrado en un per-lista mantenida por el servicio cuando se haya producido.
 Una vez que el dispositivo está activado, se elimina de la per-lista. Para mantener las cosas simples razonable para este artículo, sin embargo, voy a omitir la aplicación de la gestión permitir-lista. Una vez que el dispositivo se considera legítimo, la asigna provisión de servicios, siguiendo el modelo establecido en el artículo anterior, el dispositivo a una determinada unidad de escala y en particular, fan-out tema dentro de esa unidad de escala
. Por ejemplo, yo Voy a mantenerlo simple y crear una suscripción para un solo tema fijo llamado dispositivos que sirve como canal de comando de la nube en el dispositivo, y por un tema llamado eventos para recabar información de los dispositivos.
 Además de crear la suscripción y asociar el dispositivo con el tema, yo también voy a crear un servicio de identidad para el dispositivo en el Servicio de Control de Acceso (una característica de Windows Azure Active Directory) y concede que la identidad de los derechos necesarios para enviar mensajes al tema Eventos y recibir los mensajes de la suscripción de nueva creación para el Tema dispositivos. El dispositivo puede realizar exactamente esas dos operaciones en Windows Azure Servicio de Bus-nada más. La figura 4 muestra el núcleo del servicio de aprovisionamiento.
Este servicio depende del Windows Azure Service Bus API de administración (el NamespaceManager) encontrada en el conjunto del núcleo Microsoft.ServiceBus.dll que se incluye como parte del SDK de Windows Azure o vía Nuget. También se basa en una biblioteca de ayuda para la gestión de las cuentas de control de acceso y permisos disponibles como parte de la muestra Autorización para bus de servicios y, por supuesto, también se incluyen en el código descargable de este artículo

namespace BackendWebRole



{



  using System;



  using System.Configuration;



  using System.Linq;



  using System.Net;



  using System.ServiceModel;



  using System.ServiceModel.Web;



  using Microsoft.ServiceBus;



  using Microsoft.ServiceBus.AccessControlExtensions;



  using Microsoft.ServiceBus.Messaging;



  [ServiceContract(Namespace = "")]



  public class ProvisioningService



  {



    const string DevicesTopicPath = "devices";



    const string EventsTopicPath = "events";



    static readonly AccessControlSettings AccessControlSettings;



    static readonly string ManagementKey;



    static readonly string NamespaceName;



    static Random rnd = new Random();



      static ProvisioningService()



      {



        NamespaceName = ConfigurationManager.AppSettings["serviceBusNamespace"];



        ManagementKey = ConfigurationManager.AppSettings["managementKey"];



        AccessControlSettings = new AccessControlSettings(



          NamespaceName, ManagementKey);



      }



      [OperationContract, WebInvoke(Method = "POST", UriTemplate = "/setup")]



      public void SetupDevice()



      {



        var rcx = WebOperationContext.Current.OutgoingResponse;



        var qcx = WebOperationContext.Current.IncomingRequest;



        var id = qcx.Headers["P-DeviceId"];



        if (this.CheckAllowList(id))



        {



          try



          {



            var deviceConfig = new DeviceConfig();



            CreateServiceIdentity(ref deviceConfig);



            CreateAndSecureEntities(ref deviceConfig);



            rcx.Headers["P-DeviceAccount"] = deviceConfig.DeviceAccount;



            rcx.Headers["P-DeviceKey"] = deviceConfig.DeviceKey;



            rcx.Headers["P-DeviceSubscriptionUri"] =



              deviceConfig.DeviceSubscriptionUri;



            rcx.Headers["P-EventSubmissionUri"] = deviceConfig.EventSubmissionUri;



            rcx.StatusCode = HttpStatusCode.OK;



            rcx.SuppressEntityBody = true;



          }



          catch (Exception)



          {



            rcx.StatusCode = HttpStatusCode.InternalServerError;



            rcx.SuppressEntityBody = true;



          }



        }



        else



        {



          rcx.StatusCode = HttpStatusCode.Forbidden;



          rcx.SuppressEntityBody = true;



        }



      }



      static void CreateAndSecureEntities(ref DeviceConfig deviceConfig)



      {



        var namespaceUri = ServiceBusEnvironment.CreateServiceUri(



          Uri.UriSchemeHttps, NamespaceName, string.Empty);



        var nsMgr = new NamespaceManager(namespaceUri,



          TokenProvider.CreateSharedSecretTokenProvider("owner", ManagementKey));



        var ruleDescription = new SqlFilter(



          string.Format("DeviceId='{0}' OR Broadcast=true",



            deviceConfig.DeviceAccount));



        var subscription = nsMgr.CreateSubscription(



          DevicesTopicPath, deviceConfig.DeviceAccount, ruleDescription);



        deviceConfig.EventSubmissionUri = new Uri(



          namespaceUri, EventsTopicPath).AbsoluteUri;



        deviceConfig.DeviceSubscriptionUri =



          new Uri(namespaceUri,



            SubscriptionClient.FormatSubscriptionPath(



              subscription.TopicPath,



              subscription.Name)).AbsoluteUri;



        GrantSendOnEventTopic(deviceConfig);



        GrantListenOnDeviceSubscription(deviceConfig);



      }



      static void GrantSendOnEventTopic(DeviceConfig deviceConfig)



      {



        var settings = new AccessControlSettings(NamespaceName, ManagementKey);



        var topicUri = ServiceBusEnvironment.CreateServiceUri(



          Uri.UriSchemeHttp, NamespaceName, EventsTopicPath);



        var list = NamespaceAccessControl.GetAccessControlList(topicUri, settings);



        var identityReference =



          IdentityReference.CreateServiceIdentityReference(



            deviceConfig.DeviceAccount);



        var existing = list.FirstOrDefault((r) =>



          r.Condition.Equals(identityReference) &&



          r.Right.Equals(ServiceBusRight.Send));



        if (existing == null)



        {



          list.AddRule(identityReference, ServiceBusRight.Send);



          list.SaveChanges();



        }



      }



      static void GrantListenOnDeviceSubscription(DeviceConfig deviceConfig)



      {



        var settings = new AccessControlSettings(NamespaceName, ManagementKey);



        var subscriptionUri = ServiceBusEnvironment.CreateServiceUri(



          Uri.UriSchemeHttp,



          NamespaceName,



          SubscriptionClient.FormatSubscriptionPath(



            DevicesTopicPath, deviceConfig.DeviceAccount));



        var list = NamespaceAccessControl.GetAccessControlList(



          subscriptionUri, settings);



        var identityReference = IdentityReference.CreateServiceIdentityReference(



          deviceConfig.DeviceAccount);



        var existing = list.FirstOrDefault((r) =>



          r.Condition.Equals(identityReference) &&



          r.Right.Equals(ServiceBusRight.Listen));



        if (existing == null)



        {



          list.AddRule(identityReference, ServiceBusRight.Listen);



          list.SaveChanges();



        }



      }



      static void CreateServiceIdentity(ref DeviceConfig deviceConfig)



      {



        var name = Guid.NewGuid().ToString("N");



        var identity =



          AccessControlServiceIdentity.Create(AccessControlSettings, name);



        identity.Save();



        deviceConfig.DeviceAccount = identity.Name;



        deviceConfig.DeviceKey = identity.GetKeyAsBase64();



      }



        bool CheckAllowList(string id)



      {



        return true;



      }



  }



}








El servicio consta de un único recurso HTTP, llamado /setup, implementado mediante la Web de Windows Communication Foundation (WCF) operación SetupDevice, que acepta solicitudes POST. Usted notará que el método es sin parámetros y también no vuelve a la carga de una entidad. No es casualidad. En lugar de utilizar un cuerpo de entidad HTTP en XML, JSON o forma de codificación para transportar información de solicitud y respuesta, estoy haciéndolo muy simple para el dispositivo y colocar las cargas en los encabezados HTTP personalizados. Esto elimina la necesidad de un analizador específico analizar la carga y mantiene la huella de código pequeño. El cliente HTTP ya sabe cómo analizar encabezados, y para lo que quiero hacer aquí, es abundante.Se muestra el código de dispositivo correspondiente llamando el recurso HTTP en figura 5, y es difícil imaginar hacer que llame a todo más sencillo que esto. El identificador del dispositivo se envía en un encabezado y la configuración post-provisioning igualmente se devuelve a través de cabezales. No hay malabarismo de arroyos, no analizar, cliente HTTP de pares clave-valor simple fácilmente entiende.

 



          bool PerformProvisioning()



{



  [ ...



          display status ...



          ]



  try



  {



    var wr = WebRequest.Create(



      "http://cvdevices.cloudapp.



          net/Provisioning.svc/setup");



    wr.Method = "POST";



    wr.ContentLength = 0;



    wr.Headers.Add("P-DeviceId", this.deviceId);



    using (var wq = (HttpWebResponse)wr.GetResponse())



    {



      if (wq.StatusCode == HttpStatusCode.OK)



      {



        settings.DeviceAccount = wq.Headers["P-DeviceAccount"];



        settings.DeviceKey = wq.Headers["P-DeviceKey"];



        settings.DeviceSubscriptionUri = new Uri(



          wq.Headers["P-DeviceSubscriptionUri"]);



        settings.EventSubmissionUri = new Uri(



          wq.Headers["P-EventSubmissionUri"]);



        settings.NetworkProvisioningCompleted = true;



        StoreSettings(settings);



        return true;



      }



    }



  }



  catch (Exception e)



  {



    return false;



  }



  return false;



}



void NetworkAvailable(Module.NetworkModule sender,



  Module.NetworkModule.NetworkState state)



{



  ConvertBase64.ToBase64String(ethernet.NetworkSettings.PhysicalAddress);



  if (state == Module.NetworkModule.NetworkState.Up)



  {



    try



    {



      Utility.SetLocalTime(NtpClient.GetNetworkTime());



    }



    catch



    {



      // Swallow any timer exceptions



    }



    if (!settings.NetworkProvisioningCompleted)



    {



      if (!this.PerformProvisioning())



      {



        return;



      }



    }



    if (settings.NetworkProvisioningCompleted)



    {



      this.tokenProvider = new TokenProvider(



        settings.DeviceAccount, settings.DeviceKey);



      this.messagingClient = new MessagingClient(



        settings.EventSubmissionUri, tokenProvider);



    }



  }



}



        

Enviar eventos y recibir comandos

 

          void TemperatureHumidityMeasurementComplete(TemperatureHumidity sender,

  double temperature, double relativeHumidity)

{

  [...] (see Figure 2)

  if (settings.NetworkProvisioningCompleted &&

    DateTime.UtcNow - settings.LastServerUpdate >

      TimeSpan.FromTicks(TimeSpan.TicksPerMinute))

  {

    settings.LastServerUpdate = DateTime.UtcNow;

    SendEvent(this.lastTemperatureReading, this.lastHumidityReading);

    ProcessCommands();

  }

}

void SendEvent(double d, double lastHumidityReading1)

{

  try

  {

    messagingClient.Send(new SimpleMessage()

      {

        Properties = {

          {"Temperature",d},

          {"Humidity", lastHumidityReading1},

          {"DeviceId", settings.DeviceAccount}

        }

      });

  }

  catch (Exception e)

  {

    Debug.Print(ethernet.ToString());

  }

}

void ProcessCommands()

{

  SimpleMessage cmd = null;

  try

  {

    do

    {

      cmd = messagingClient.Receive(TimeSpan.Zero, ReceiveMode.ReceiveAndDelete);

      if (cmd != null && cmd.Properties.Contains("Command"))

      {

        var commandType = (string)cmd.Properties["Command"];

        switch (commandType)

        {

          case "SetTemperature":

            if (cmd.Properties.Contains("Parameter"))

            {

              this.settings.TargetTemperature =

                double.Parse((string)cmd.Properties["Parameter"]);

              this.RedrawDisplay();

              this.temperatureHumidity.RequestMeasurement();

              StoreSettings(this.settings);

            }

            break;

        }

      }

    }

    while (cmd != null);

  }

  catch (Exception e)

  {

    Debug.Print(e.ToString());

  }

}

        

.

 Fuente Original aquí

solo-electronicos por Carlos Rodriguez Navarro se encuentra bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 Unported.