Display inteligente para Netduino


La biblioteca TextDisplayMenu  es un marco extensible para rápidamente crear menús jerárquicos, editables que pueden mostrar en un display lcd de caracteres de verias lineas (típicamente compatible con hd44780)    controlándose mediante un IRotaryEncoder o una intrface  IButton . Los drivers para pantallas LCD Serie comparten una interfaz común que lo hacen fácil de conectar e integrar con el  TextDisplayMenu

Por tanto gracias a esta biblioteca podemos movernos en menús mostrados en displays lcd de varias lineas con un solo botón giratorio de un modo muy potente  y eficiente.

En este vídeo podemos ver un ejemplo de funcionamiento:

El menú se puede crear mediante programación o cargadolos desde un fichero en formato JSON y tiene un número de tipos de elementos de menú integrado de pantalla y edición entrada como tiempo, temperatura y otros.

Además se pueden crear fácilmente menús personalizados contipos de elementos que permiten a los usuarios editar su valor a través de las entradas

Utilización

Para utilizar el menú, necesitará un LCD compatible con ITextDisplay u otro display, así como alguna combinación de botones y codificador rotatorio que permita la funcionalidad de avanzar a siguiente, anterior y seleccionar . Por ejemplo, puedes usar; tres entradas IButton discretas para la siguiente / previa / selección, un codificador rotatorio para siguiente / anterior y un IButton para selección, o un RotaryEncoderWithPushButton para manejar las tres entradas.
El esquema siguiente muestra una configuración típica de integral para manejar el menú e incluye una pantalla de cuatro líneas LCD común controlado directamente por pernos GPIO digitales de Netduino, así como un encoder rotativo con pulsador:

Como se puede apreciar se usa un display copatible con hd44780  usando interfaz de 4 bits  con dos señales de control  y luego aparte el encoder que usa tres señales de control

El display  ademas de alimentación de 5v DC , tomada directamente de la placa ,usa pues   6 conexiones binarias de Netduino :d8,d9,d10,d11,d12 y d24 , forzando algunas lineas del diplay a  vcc o gnd y el encoder las tres anteriores :d7,d5 y d5;

Resumiendo estas son las conexiones del display lcd:

  1. VSS – Ground
  2. VCC – (+5V)
  3. VE – Contrast adjustment –>a gnd
  4. RS – Register Select–>pind13
  5. RW – Read/Write– >a gnd
  6. EN – Clock (Enable)–>pind12
  7. D0 – Data Bit 0–>pin d11
  8. D1 – Data Bit 1–>pin d10
  9. D2 – Data Bit 2–>pin d9
  10. D3 – Data Bit 3–>pin d8
  11. D4 – Data Bit 4
  12. D5 – Data Bit 5
  13. D6 – Data Bit 6
  14. D7 – Data Bit 7
  15. BLA – Backlight Anode (+)–>gnd
  16. BLK – Backlight Cathode (-)–>a 5v (ojo algunos dislplay necesitan una resistencia  limitadora no alimentándose directamente a 5v dc)

La caja para contener el encoder  y el display  los del Wilderness Labs han  diseñado específicamente en 3D  conun acabado fantastico:

Código de ejemplo

El código siguiente ilustra cómo crear una nueva, por eso carga su contenido de JSON:TextDisplayMenuRotaryEncoderWithButton

using System;
using System.Collections;
using System.Threading;
using Microsoft.SPOT;
using H = Microsoft.SPOT.Hardware;
using N = SecretLabs.NETMF.Hardware.Netduino;
using Netduino.Foundation.Sensors.Rotary;
using Netduino.Foundation.Displays;
using System.IO;
using TextDisplayMenu_Sample.Properties;
using Netduino.Foundation.Displays.TextDisplayMenu;

namespace TextDisplayMenu_Sample
{
    public class Program
    {
        public static void Main()
        {
            RotaryEncoderWithButton encoder = new RotaryEncoderWithButton(
                N.Pins.GPIO_PIN_D2, N.Pins.GPIO_PIN_D3, N.Pins.GPIO_PIN_D4,
                Netduino.Foundation.CircuitTerminationType.CommonGround);
                
            ITextDisplay display = new SerialLCD(new TextDisplayConfig() { 
                Height = 4, 
                Width = 20 }) as ITextDisplay;

            display.SetBrightness();

            Menu menu = new Menu(_display, _encoder, Resources.GetBytes(Resources.BinaryResources.menu), true);
            menu.Enable();

            Thread.Sleep(Timeout.Infinite);
        }
    }
}

El código  completo se puede encontrar aquí.

Para crear un menú con otras entradas, como botones o un codificador giratorio opcional, puede usar los otros constructores:

// Rotary encoder and select button
public Menu(ITextDisplay display, IRotaryEncoder encoder, IButton buttonSelect, byte[] menuResource, bool showBackOnRoot = false)

// Buttons for next, previous, and select
public Menu(ITextDisplay display, IButton buttonNext, IButton buttonPrevious, IButton buttonSelect, byte[] menuResource, bool showBackOnRoot = false)

Carga un menú desde JSON

Para crear el menú de JSON, en primer lugar definir el contenido del menú en un archivo JSON y luego agregarlo como un recurso.
Definición de muestra
El nodo raíz debe ser una matriz de elementos de menú. La tabla siguiente enumera las propiedades y uso asociado:

Property Usage
text Mostrar texto en el renderizado. Incluye {value} para mostrar el valor actual del tipo
command Nombre del comando para distinguir los eventos de selección de menú. Si se establece el comando, tiene prioridad sobre el elemento de menú editable.
id Identificador único para el tipo. Necesario para un elemento de menú editable..
type Tipo de entrada, por ejemplo: Edad, Tiempo. Necesario para un elemento de menú editable.
sub Array de items de sumenus .

Por ejemplo, el siguiente código json define un menú jerárquico dispuesto en los artículos y páginas de menú.

{
  "menu": [
    {
      "text": "My Age: {value}",
      "id": "age",
      "type": "Age",
      "value": 12
    },
    {
      "text": "My Command",
      "command": "DoSomething"
    },
    {
      "text": "Parent",
      "sub": [
        {
          "text": "Sub Item A"
        },
        {
          "text": "Sub Item B"
        },
        {
          "text": "Sub Item C",
          "sub": [
            {
              "text": "Sub Item D"
            },
            {
              "text": "Sub Item E"
            },
            {
              "text": "Sub Item F"
            }
          ]
        }
      ]
    }
  ]
}

Agregar el menú JSON como un recurso

Para agregar el archivo JSON al proyecto como un recurso:

  1. Haga clic derecho en el proyecto y seleccione Propiedades
  2. Haga clic en el panel izquierdo Recursos
  3. Haga clic y elija el archivo apropiado. Agregar recurso

Ahora, se puede acceder a este recurso por Resources.GetBytes(Resources.BinaryResources.[ResourceName]).

Soporte de eventos

El menú genera eventos cuando se selecciona un comando, se edita el elemento del menú y se sale del menú.

En cuanto a la selección de eventos ,para recibir una notificación cuando se selecciona un elemento de menú con un comando asignado, asigne un controlador al evento Seleccionado:

menu.Selected += (s, e) =>
{
    Debug.Print("menu selected: " + e.Command);
};

Respecto a la salida de eventos si el menú no es la pantalla de inicio de la aplicación deseada, entonces el menú puede ser cargado o descargado programáticamente usando Enable () o Disable (), respectivamente. Además, hay un parámetro opcional al crear un nuevo menú, showBackOnRoot, y cuando se establece en verdadero, ”

menu.Exited += (s, e) =>
{
    Debug.Print("menu exited");
    menu.Disable();
};

Para editar eventos para obtener una notificación cuando cambia un valor de elemento de menú Editar, asignar a un controlador al evento:ValueChanged

menu.ValueChanged += (s, e) =>
{
    Debug.Print(e.ItemID + " changed with value: " + e.Value);
}

Construcción de  tipos

La siguiente tabla enumera los tipos de elementos de menú integrados y sus usos y valores asociados:

Type Description
Boolean Un tipo de lista como true y false.
Age Un integer entre 0 y 100.
Temperature Un valor entre -10 y 100 con una escala de 2.
Time 24 hora militar con HH:MM
TimeDetailed 24 hora militar con HH:MM:SS
TimeShort 24 hora militar con MM:SS

Creación de tipos de elementos de menú personalizado

Hay dos formas de crear elementos de menú personalizado. El más fácil y más común es heredar de y modificar, los tipos de base integrados. Sin embargo, también puede crear menús totalmente personalizada tipos de elementos.
Personalización de tipos Base incorporados
TextDisplayMenu incluye una serie de tipos base integrados que manejan tipos comunes y puede ser modificado para requisitos particulares para adaptarse:

Base Type Description
NumericBase Proporciona una pantalla y entrada numérica genérica. El mínimo / máximo y el número de decimales se pueden modificar.
TimeBase Proporciona una máscara de entrada de XX: XX: XX o XX: XX según el modo.
ListBase Proporciona una lista seleccionable de elementos.

Ejemplo de NumericBase personalizado

El siguiente código se extrae del tipo de menú Edad, e ilustra cómo heredar de NumericBase y especificar el piso, el techo y la escala de la entrada deseada.

using System;
using Microsoft.SPOT;

namespace Netduino.Foundation.Displays.TextDisplayMenu.InputTypes
{
    public class Age : NumericBase
    {
        public Age(): base(0, 100, 0) { }
    }
}

En resumen como vemos el equipo de Wilderness Labs a través de la fundación de Netduino ha hecho un trabajo fantástico que espero podemos usar en nuestros futuros proyectos

Mas información en http://netduino.foundation/Library/Displays/TextDisplayMenu/

Anuncios

Nuevos aires para Netduino


Sin duda corren nuevos aires para la plataforma Netduino tras la retirada de Secrets Labs por parte de su creador Chris Walker y ahora wilderness labb es la plataforma que oficialmente  esta soportando Netduino tanto es así que el sitio oficial anterior se ha redirigido a la plataforma wildernesslabs.co

 Wildeerness Lab  es una comunidad de desarrolladores .NET dispuesta a construir experiencias de hardware de próxima generación. Se  consideran  los “pastores” de Netduino; una plataforma de desarrollo de hardware abierto de código abierto y los creadores de Netduino.Foundation  un marco que simplifica enormemente la construcción de cosas conectadas con Netduino.

Tras unos años reestructurando el nuevo sitio se ha asociado con Hackster.io y desafió a cualquier entusiasta de Netduino para poner en marcha la revolución de hardware mediante la creación de soluciones innovadoras que utilicen IO Netduino y .NET Micro Framework

 

 

 

 

Hoy en dia   los teléfonos móviles   superan  a los dispositivos conectados móviles  en relacion 4 a 1 pero en apenas unos años, los dispositivos conectadas a Internet superaran a los teléfonos móviles en una proporcion de 10 a 1 lo que supondra  75 billones dispositivos conectados  predichos en 2025 gracias al uso de   microcontroladores y  los avances de hardware , lo cual  desembocaran con la revolucion del mundo va móvil, en pocos años, a conectar casi todos los nuevos productos.

Esta progreso del hardware es toda una revolución , y Wildeerness Lab lo sabe  permitiendo a los desarrolladores de hoy ser parte de él, pues ellos son conscientes de hecho que la revolución depende de piratas informáticos, creadores y manitas para crear  con la tecnología de las experiencias del mañana

Veamos en primer lugar las placas disponibles  pra luego meternos mas en detalle del concurso

Plataforma Netduino plus

Netduino es una plataforma abierta  basada en  Microsoft.NET Micro Framework. La versión  Plus ademas  es un poderoso Netduino junto con Ethernet integrado, así como el apoyo de una ranura para microSD en la misma tarjeta  . Ademas existe una version avanzada con adaptador wifi integrado

Cuenta con un  potente microcontrolador de 32 bits integrado con un entorno de desarrollo estándar que está disponible gratuitamente a través de Microsoft (Visual Studio 2010).

La familia Netduino se basa en el Microprocesador Cortex-M que ejecuta .NET Micro Framework (NETMF) v4.3.

El desarrollo se puede hacer tanto en Windows, con Visual Studio, o con Xamarin Studio en Mac OS X.

 

La plataforma permite una fácil interconexión con switches, sensores, LEDs, dispositivos de serie, y mucho más. El Netduino combina 20 GPIO con SPI, I2C, UART 2 (1 RTS / CTS), 4 y 6canales de PWM ADC.

Microsoft. NET Micro Framework combina la facilidad de un lenguaje de programación de alto nivel (C #) con las características de los microcontroladores permitiendo la depuración de programación basada en eventos, multi-threading, línea por línea,puntos de interrupción y mucho más.   Ademas ..,se pueden añadir  mas accesorios ofreciendo funcionalidades extra ( por ejemplo la ubicación GPS, el control de servos ,displays  de todo tipo).

También son compatibles con pin / puerto con los escudos Arduino, abriendo posibilidades en el mundo.

Características de la placa original , mantenida en las siguientes versiones Netduino 2 y Netduino 3 (esta ultima  con interfaz wifi) :

● all 20 digital and analog pins: GPIO
● digital pins 0-1: UART 1 RX, TX
● digital pins 2-3: UART 2 RX, TX
● digital pins 5-6: PWM, PWM
● digital pins 7-8: UART 2 RTS, CTS
● digital pins 9-10: PWM, PWM
● digital pins 11-13: SPI MOSI, MISO, SPCK
● analog pins 4-5: I2C SDA, SCL

● ethernet: 100 mbps (solo versiones con ethernet en v1, v2, v3) con  network stack via  lwIP

● micro sd (up to 2 GB)
● auto card detect

Netduino 3

Es la ultima evolución de esta placa. Cuenta con procesador  168Mhz Cortex-M4 (STM32F4) con o 1,408 KB of almacenamiento para código  y  164 KB de RAM.

Existe comercialmente en tres variantes:

N3

384 KB Code Flash Storage

SIn ethenert  ni wif

N3 Ethernet

1,408 KB Code Flash Storage
10/100 Mbps Ethernet
Micro SD Slot (up to 2GB)

Con ethernet

N3 WiFi

1,408 KB Code Flash Storage
802.11b/g/n WiFi
Micro SD Slot (up to 2GB)

Con adaptador WiFI

Netduino 2

Es la version mas antigua basada en Cortez M2   y M4. Existen unicaemnte dos  versiones

N2

Cortex-M3 @ 120Mhz
192 KB Code Flash Storage
60KB Ram

SIn ethenert  ni wif

N2 Plus

Cortex-M4 @ 168Mhz
384 KB Code Flash Storage
100 KB RAM
10 Mbps Ethernet
Micro SD Slot (up to 2GB)

Con intrefaz Ethernet

 

 

Netduino Foundation

Wildeerness Lab    ha creado  Netduino.Foundation,, una plataforma que toma gran parte de la complejidad del desarrollo de hardware y permite una experiencia de desarrollo lista donde se pueden crear soluciones de hardware sofisticado utilizando C#. Usando  Xamarin,se pueden crear aplicaciones móviles que hablan y controlan cosas conectadas aso como escribir soluciones de extremo a extremo en. net,

 

IoT real va a ser construido por los desarrolladores reales de hacking de IoT  como nunca  nunca podríamos imaginar:es ahi  donde usted entramos los entusiastas de netduino por lo nos proponen  unirnos a ellos  en la construcción de soluciones creativas con Netduino y el .NET Microframework.

Por cierto si no tiene un Netduino no hay problema, pues  estan regalando un total de 40 Netduino 3 WiFi o Ethernet de 3 Netduino  personas que están pensado proyectar aplicaciones( asi qeu  desee prisa, si usted necesita un tablero,pues  el plazo de propuesta de proyecto patrocinado es el 1 de julio.)
Y para endulzar el acuerdo, todos los ganadores del concurso recibirán acceso temprano de beta a Prado; el sucesor de Netduino que ejecuta .net completo estándar 2 aplicaciones en un microcontrolador.

Si no recibe un Netduino  o quieren conseguir uno  cuanto antes, use HCONTEST para recibir una 15% de descuento en cualquiera de nuestros productos de Netduino vendidos en Amazon. Este código es válido hasta el 30 de julio de 2018..

 

Hackster_Contest_Description_Banner.png

Concurso Netduino

 

Presentaciones del proyecto

Presentación debe incluir:

  • Descripción detallada de su proyecto. ¿Qué es, ¿qué hacer, cómo funciona?
  • Imágenes de calidad y videos
  • Historia con instrucciones claras
  • BOM (Bill del material)
  • Código fuente y esquemas si está disponible
  • Compruebe hacia fuera estos proyectos Netduino Hackster ejemplos de buenas presentaciones:

Línea de tiempo

  • Presentación proyecto abre -13 de junio de 2018
  • Fecha límite para aplicar gratis Netduino -01 de julio de 2018
  • Presentación de proyecto cerrado -31 de julio de 2018
  • Anunciados los ganadores del -03 de agosto de 2018

 

 

Estos serán los premios a este concurso;

  • Mejor presentación general – 1er lugar

El mejor autor de presentación general de proyectos recibirán un kit de hack de prototipos de hardware que incluye una impresora 3D, osciloscopio y acceso beta temprano a Prado; Plataforma de hardware de vNext desierto Labs que trae .net completo estándar a un microcontrolador.
También recibirá un paquete de cuidado secreto artesanal del desierto Labs Director Ejecutivo y cofundador, Bryan Costanich.

  • Presentacion honorable

Hasta diez otros envíos grandes, también recibirá un paquete de atención secreta y acceso temprano al Prado.

  • Acceso de la Beta Meadow

Meadow  es el sucesor a Netduino. Ejecuta aplicaciones .net estándar 2 completo en un microcontrolador a través de Mono. Es seguro desde el hardware hacia arriba y es manejable a través de la nube. Esperan ofrecer acceso beta privada al final de ganadores del verano.

 

  • ¿Listo para comenzar?

Crear una cuenta en wildernesslabs.co si no lo has hecho ya.

Registro para el concurso en esta página https://www.hackster.io/contests/netduino

Presentar su idea de proyecto el 1 de julio para tener la oportunidad de ganar un Netduino gratis para su proyecto.

Diseñar, construir y presentar su proyecto antes de 31 de julio.

 

 

Mas informacion en https://www.hackster.io/contests/netduino

 

 

 

Como leer el pulso cardiaco


La esencia de estos circuitos es un sensor integrado de circuito de amplificación óptica y con un circuito de eliminación de ruido de la frecuencia cardíaca  todo ello alimentado  con una tensión de alimentación: 3.3V ~ 5 V

Lo ideal  para medir el pulso  es  poner  el sensor de pulso en el dedo o lóbulo de la oreja, directamente  o bien  mediante algún sistema mecánico que lo deje fijo como por ejemplo   alguno de los sistemas que mostramos a continuación:

 

soportes sensores.PNG

 

Estos sensores cuentan con una salida analógica   que se puede conectar por ejemplo a una entrada analógica de un  Arduino, para probar la frecuencia cardíaca

Estudiantes, artistas, deportistas, creadores, desarrolladore3s de juegos, o terminales móviles puedan desarrollar software o interactivos relacionado con el ritmo cardíaco, pero no obstante también existe  una aplicación de código abierto para la visualización en tiempo real de la gráfica de la frecuencia cardíaca en https://github.com/WorldFamousElectronics/PulseSensor_Amped_Arduino/.

 

 

El sensor de pulso cardiaco es esencialmente un fotopletismógrafo, que es un dispositivo médico conocido que se usa para controlar la frecuencia cardíaca de forma no invasiva. Asimismo  los fotopletismógrafos miden los niveles de oxígeno en la sangre (SpO2) pero no siempre lo soportan.

La señal de pulso cardíaco que sale de un fotopletismograma es una fluctuación analógica de voltaje, y tiene una forma de onda predecible, tal como estamos acostumbrados a ver ( la representación de la onda de pulso se denomina fotopletismograma o PPG).

El Sensor de pulso  amplifica la señal bruta del Sensor de pulso anterior y normaliza la onda de pulso alrededor de V / 2 (punto medio en voltaje) respondiendo a los cambios relativos en la intensidad de la luz

Tal y como esta construido ,veremos que  la luz  interna del LED verde del sensor  se refleja de nuevo en el sensor cambiando durante cada impulso, ocurriendo las siguintes casuiticas:.

  • Si la cantidad de luz incidente en el sensor permanece constante, el valor de la señal permanecerá en (o cerca de) 512 (punto medio del rango de ADC).
  •  Más luz y la señal aumentará.
  • Menos luz, todo lo contrario: el valor de la señal analógica dismuniira

El objetivo es encontrar momentos sucesivos de latido instantáneo del corazón y medir el tiempo transcurrido entre ellos, llamado intervalo Inter Beat (IBI)  pues al seguir la forma y el patrón predecibles de la onda PPG, podemos hacer exactamente eso.

Cuando el corazón bombea sangre por el cuerpo, con cada latido hay una onda de pulso (una especie de onda de choque) que viaja a lo largo de todas las arterias hasta las mismas extremidades del tejido capilar donde está conectado el sensor de pulso. La sangre real circula en el cuerpo mucho más lentamente de lo que viaja la onda de pulso.

 

Figura 1

 

Sigamos los eventos a medida que progresan desde el punto ‘T’ en el PPG a continuación. Se produce un aumento rápido en el valor de la señal a medida que la onda de pulso pasa por debajo del sensor, luego la señal vuelve a descender hacia el punto normal. A veces, la muesca dicroica (pico descendente) es más pronunciada que otras, pero, en general, la señal se establece en el ruido de fondo antes de que la siguiente onda de pulso se filtre. 

Como la onda se repite y es predecible, podríamos elegir casi cualquier característica reconocible como punto de referencia, por ejemplo, el pico, y medir la frecuencia cardíaca haciendo cálculos matemáticos sobre el tiempo entre cada pico,pero sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

Existen otras buenas razones para no basar el algoritmo de detección de latidos en fenómenos de onda arbitrarios. Idealmente, queremos encontrar el momento instantáneo del latido del corazón. Esto es importante para el cálculo preciso de BPM, la variabilidad del ritmo cardíaco ( y mida la frecuencia cardíaca haciendo cálculos en el tiempo entre cada pico.

Sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

.

 

Algunos investigadores del corazón dicen que es cuando la señal alcanza el 25% de la amplitud, algunos dicen que es el 50% de la amplitud, y algunos dicen que es el momento en que la pendiente es más pronunciada durante el evento ascendente.

 

El circuito que vamos  a ver es muy simple pues solo se precisa conectar  un buzzer y el sensor de pulsos cardíacos  .

Como podemos ver en el video  , el sensor de pulsos cardíacos  se conecta a la alimentación de +5V  entre el hilo rojo(+5v)   y el naranja (GND)   y del  hilo marrón obtenemos la salida analógica que conectaremos a la primera entrada analogica (A0) de cualquier placa que  soporte entradas analogicas como pueden ser Arduino o Netduino

 

arduino.PNG

Para complementar el circuito puede ser interesante reflejar el punto maximo de nivel qeu reproduciremos mediante un buzzer  conectado al pin 11 de salida binaria

 

A continuación  en este breve  ejemplo  para Arduino se puede mostrar un pulso de latido del corazón humano en directo ayudándonos por medio de “Serial Plotter” de arduino o  por ejemplo con una aplicacion móvil usando   un modulo bluetooth coenctado a nuestro arduino

 

En este pequeño programa para Arduino qeu vamos a ver , sonará un buzzer con cada latido de tu corazón al mismo tiempo que se envia el valor de la señal de forma serie (esta es la señal directa del sensor de pulso) el cual podemos visualizar en un ordenador  o si tenemos conectado un modulo bluettoth a nuestro arduino mediante un smarptphone usando una app .

 

//Programa para capturar el pulso cardiaco

// Variable para fijar el puerto donde conectaremos el buzzer 

int buzzer = 11;

// la variable pulso contiene los datos brutos entrantes pudiendo  variar entre 0-1024

int pulso;

 

// Determina qué señal “se contará como un latido” y qué señal ignorar.

int limite = 550;

 

void setup() {

//definimos donde conectamos el buzzer , que  sonará al ritmo de su corazón

pinMode(buzzer,OUTPUT);

 

// Configura la comunicación serial a 9600 dependiendo de su adaptador bluetooth como esté configurado

Serial.begin(9600);
}

void loop() {

// Lee el valor del pin analógico 0, y Asigna este valor a la variable “pulso”.
pulso = analogRead(A0);

 

//Este caracter lo filtra la aplicación en APP inventor

Serial.print(“*”);

// Envíe el valor de pulso al Plotter serial. Comentar si queremos visualizar en “serial ploter”
Serial.println(pulso);
if(pulso > limite){

// Si la señal es superior a “550”, entonces suena el buzzer.
digitalWrite(buzzer,HIGH);

}

else

{

// De lo contrario, deja de sonar el buzzer.
digitalWrite(buzzer,LOW);
}

//Retardo de 35ms
delay(35);
}

 

 

IoT con Netduino


Pachube  fue pionera en desarrollo de aplicaciones y servicios web para conectar personas y dispositivos en lo que se considera “el Internet de las Cosas” o IoT(Internet of things) , un concepto global en el que todo está conectado (casas, móviles, coches, lámparas, pcs…) nacido en 2008 y que en el momento actual es imparable.

Para quien no lo conozca, Pachube era un servicio web donde se  podía transmitir la información que generaban nuestros dispositivos mediante una conexión a Internet  (Wifi, ethernet, GPRS,etcC). Una ventaja que tenia es que mediante nuestro ordenador/móvil/tablet podiamos consultar los datos que nuestro dispositivo envíaba mediante la propia  web de Pachube de una forma gráfica, pudiendo  hacer que nuestros feeds fuesen públicos o privados, consultar el historial de datos  así como enviar alarmas y notificaciones a nuestros dispositivos.

Tenia limitaciones  en su version gratuita , como que no se podían hacer más de 100 peticiones por minuto, pero en la mayoría de los casos eran suficientes para cualquier aficionado.

 

El servicio de Pachube   fue adquirido hace varios años por una compañía llamada LogMeIn  de modo que incluso cambiaron el nombre del servicio a COSM.
Con ésta adquisición LogMeIn  entraba en un comercio en auge que se supone llegará a conectar más de 50.000 millones de dispositivos (muy variados entre si, como hemos comentado) en un futuro muy próximo pudiendo ayudar a mejorar la calidad de vida actual así como dar el último impulso a proyectos tan famosos como las viviendas inteligentes o ciudades “tecnológicas” enteras.

Al poco tiempo después, lo renombraron  como Xively, el cual solía existir en dos formas: Xively (Comercial) y Xively Personal.

Lamentablemente en enero de 2018 cerraron Xively Personal , de  modo que  es necesario “pasar por caja” si se quiere usar sus servicios, los mismo servicios  que antaño eran gratuitos.

Perfilándose como   alternativa de servicio de IoT  , hemos visto crecer  la plataforma gratuita Adafruit IO. Su API  es muy limpia y elegante  , y  permite ejecutar interaccionar correctamente en un Netduino 3 WiFi , pero muchos usuarios tienen problemas con  Netduino 2 Plus, lo cual no lo hace recomendable por el momento si se disponen de placas “antiguas”.

Muchas personas que han probado el Api de Adfruit   frente a  Xively Personal  afirman  que Adafruit IO.  es mucho más sencillo de usar  Xively   con la ventaja añadida  que es gratuita y tiene una gran comunidad de usuarios  entusiastas por detrás

 

 

Algunas alternativas posibles en ningún orden en particular (esta lista puede crecer) de plataformas de IoT para experimentar con una placa Netduino:

  • ThingSpeak – la plataforma abierta de IoT con analytics MATLAB, la cual sigue estando disponible para uso no comercial para aficionados  usando cualquier versión  de Netduino con conectividad ( Netduino+,Netduino2+ y Netduino 3)
  • AdaFruit.IO – el internet de las cosas para todos
  • Microsoft IoT Central – grado empresarial IoT SaaS
  • Blynk – democratización de la Internet de las cosas
  • Cayenne – simplificar el mundo conectado  y del que hemos hablado numerosas veces en este blog
  • Plataforma thinger.IO
  • SenseIoT – Internet de cosas datos Hosting plataforma
  • Temboo – herramientas para la transformación Digital
  • Carriots por Altair
  • Nearbus -un proyecto abierto de la IoT
  • ubidots – una aplicación Builder de Internet de las cosas
  • Microsoft IoT Central – empresa grado IoT SaaS
  • Nube de Kii
  • Artika – plataforma End-to-end IoT
  • goplusplatform – conectar tus cosas con ir +
  • ¿?

 

 

Espero que podamos compartir  ejemplos de uso de algunas de estas plataforma  en este humilde blog   como alternativas reales  al antiguo Pachube,   democratizando el uso de Iot  incluso para nuestra placa Netduino , la cual e resiste   a ser reemplazada por otras placas  destinadas a otros usos  y que poco están  quitándole el protagonismo que tubo antaño

Desbloquear un Netduino inaccesible


La palabra “ladrillo” (bricked) ,se utiliza en referencia a la electrónica de consumo, describiendo como  un dispositivo electrónico tal omo un smartphone, videoconsola, router,tablet, o placa de desarrollo  debido a un severo daño físico, un grave error de configuración, corrupto firmware  o un problema de hardware , ya no funciona, por lo tanto, sólo puede ser útil  tecnológicamente como un ladrillo (y de ahí la sugerencia humoristica  de que el dispositivo  ya sólo puede funcionar como un objeto sin vida, tal como  un pisapapeles o tope de puerta).

Este término es comúnmente usado como verbo. Por ejemplo,  “bricked” mi reproductor de MP3 cuando trató de modificar su firmware y no le funciono. También puede ser utilizado como un sustantivo, por ejemplo, si queda corrupto y se aplica usando fastboot, el dispositivo es un “brick”(ladrillo).

En el uso común del término, “bricking” sugiere que el daño es tan grave que se inutilizó el dispositivo permanentemente.

Antiguamente para desbriquear placas Netduino teníamos la herramienta .NET Micro Framework Deploy Tool (MFDeploy) , herramienta que se instala con  el Framework .NET . Por  ejemplo, para la version 4.3    normalmente el ejecutable estará en  la ruta “C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.3\Tools\MFDeploy.exe”. Esta antigua herramienta nos puede resolver el problema , pero adolece de un  serio inconveniente: no incluye el  firmware disponible ( que como sabemos dependiente de la placa  y  version ) , pero ademas, no siempre logra su objetivo sobra una placa bloqueada.

Asegurar que su Netduino tenga el firmware más reciente significa que será actualizado con la actual ejecución de Netduino específica de  .NET Micro Framework   .Además, a menos que su Netduino tenga el firmware más reciente, pueden tener problemas implementando su aplicación  en ese contexto, de modo   que merece la pena intentar cargar el ultimo firmware oficial.

Las instrucciones para  cargar el ultimo firmware  son diferentes  para el SO donde conectaremos nuestra placa Netduino ( Windows y  tambien Mac).

Desgraciadamente, por consideraciones tecnológicas, las placas soportadas  por esta nueva herramienta son sólo aquellas versiones superiores   a la version 2  ( es decir a partir de Netduino 2 en adelante).

Windows

  1. Descargue la aplicación Netduino Updater .
  2. Descomprimir  la aplicación Netduino Updater_4.3.2.3 en una ubicacion del disco de su ordenador .
  3. Ejecutar la aplicación Netduino Updater.exe .
  4. Incluso conectado su Netduino a su PC no debería aperecer nada   :                                              
  5. Mientras su Netduino está desenchufado de su pc mediante un cable USB, mantenga pulsado el pulsador interno de la placa y luego  al conectarlo suéltelo, para ponerlo en Modo Bootloader de DFU:                                                                                          
  6. Su Netduino debería aparecer en la lista de dispositivos de la lista. Si no apareciese, puede que el driver no este actualizado,  o simplemente que Windows tiene problemas para cargar el driver para ese puerto , por lo que recomendamos probar  conectando el cable a otro puerto USB disponible.
  7. Una vez aparezca su placa en la pantalla de Netduino Adapter, haga clic en la casilla de verificación junto a él y haga clic en el botón Upgrade (Actualizar)netduino.png
  8. Netduino updater instalará automáticamente la última versión de firmware:
  9. Cuando termine, se reiniciará el Netduino y así que debe ya no se mostrar nada en la lista de dispositivos.                              
  10. Existen tres opciones disponible en esta herramienta ademas de poder actualizar el firmware:
  • Cambiar el nombre de la placa desde la pestaña “General” . Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)general.png
  • Cambiar la dirección MAC  de su placa Netduino  desde la pestaña “Network” .Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)                                          mac.png
  • Borrar la ultima aplicación que haya desplegado en su placa Netduino desde la pestaña “Tools”                                                                         borrar.png

 

Mac

  1. Mientras su Netduino está desenchufado, mantenga pulsado el botón y luego conectarlo, para ponerlo en Modo Bootloader de DFU:
  2. Iniciar el Netduino Mac desplegar (disponible en la página de descargas ):
  3. Haga clic en el botón, debe instalar el firmware: Install Firmware

Instalación de Firmware de los archivos .hex o .s19

La herramienta de Mac Firmware también permite la implementación de firmware manual:

  1. Siga los pasos 1 y 2 anteriores.
  2. Haga clic en el botón y seleccionar la o y archivos: Choose.hex.s19ER_CONFIGER_FLASH
  3. Haga clic en y se deben desplegar el firmware: Deploy

Fuente   http://developer.wildernesslabs.co

Servidor para Netduino+


NeonMika.Webserver es un servidor web preconfigurado  para Netduino+  yNetduino 2+   fácil de extender de modo que con un código mínimo (o incluso nulo), puede obtener excelentes resultados controlando todos  los puertos de  su Netduino +, accediendo y cargando archivos, creando servicios web ¡y algunas cosas  más!

El código  fuente esta disponible aun en codeplex en  :https://neonmikawebserver.codeplex.com/documentation  aunque hay  una version para Netduino 3+ en  Github .  A pesar de que el foro  de Netduino se ha mudado al sitio widernesslab.co  se mantiene  información  de NeonMika.Webserver  en el antiguo  foro de Netduino ( http://forums.netduino.com/index.php?/topic/2889-neonmikawebserver/)  asi que tiene más preguntas o desea  mas explicaciones  sobre el código le recomiendo que se dirija a ese sitio.

Si usa el esquema de la cafetera conectada  del que hablábamos  en un post anterior     únicamente puede   usar el pin digital  D2  como salida  y al que  conectaremos  una economica placa de un relé   compatible  con Arduino (5V)

 

Como se puede apreciar en el esquema del circuito , este no puede ser mas simple pues solo hay que alimentar el circuito del rele con la tensión  de 5V procedente de la placa Netduino, conectar el pin de datos  D2 a la entrada IN de la placa del  relé  y finalmente conectar la carga ( en este caso un cafetera)  a los contactos de salida del relé

 

Gracias  a neomikaserver podremos controlar fácilmente la cafetera   de una manera muy facil  y rapida pero ademas este servidor destaca por la siguientes  funcionalidades:

  • Acceso a la tarjeta microSD
  • Control de todos  lso puertos GPIO
  • Lectura de todos los puertos GPIO
  • Control   de  su Netduino+  usando métodos existentes como setPWM o setDigitalPinState
  • Permite agregar sus propios métodos similares al servicio web para que pueda expandir NeonMika.Webserver a sus propias necesidades para cada proyecto.

Hay dos directorios de interés para usted:

  • Framework :contiene el código de la biblioteca para un nuevo proyecto usando NeonMika.Webserver. Consulte esta carpeta si desea agregar NeonMika.Webserver a un proyecto existente.
  • Executeable:  contiene un pequeño proyecto creado usando NeonMika.Webserver. Consulte este si desea obtener una primera experiencia con el servidor. ¡Puede ejecutarlo sin escribir ninguna línea de código!

Para probar NeonMika.Webserver y tener algún código de muestra, simplemente siga estos pasos:

  • Simplemente descargue el código y vaya a “Executeables”.
  • Implemente el proyecto en su Netduino Plus. Debería comenzar a funcionar.
  • Este proyecto de ejemplo que utiliza NeonMika.Webserver tiene el siguiente método xml agregado al servidor web en tiempo de ejecución: netduinoplus / wave … Conecte los LEDs al Pin 0,1,4,5,8,9 y verá que su LED se enciende uno después el otro.

 

Setup

Como puede ver, solo necesita llamar al constructor para iniciar NeonMika.Webserver.

Server WebServer = new Server(PinManagement.OnboardLED, 80, false, "192.168.0.200", "255.255.255.0", "192.168.0.1", "NETDUINOPLUS");

Los parámetros necesarios son  autoexplicativos:

  • El puerto 
  • DHCP encendido / apagado
  • Dirección IP
  • Máscara de subred
  • Gateway
  • Nombre de red

¡No necesita nada más para ejecutarlo!

Métodos sopurtados?

Aquí hay una lista con todos los métodos web precodificados que puede usar en su navegador o en cualquier otra aplicación para comunicarse con su Netduino:

  • echo (devuelve el valor enviado) ,    ejemplo   netduinoplus / echo? value = [a-Z] , por ejemplo http://192.168.0.2/echo?value=markus devolveria “markus”
  • switchDigitalPin (Cambia el pin seleccionado de verdadero a falso y vis-a-vis) ,ejemplo : -> netduinoplus / switchDigitalPin? pin = [0-13]  es decir  por ejemplo para encender la cafetera seria http://192.168.0.2/setDigitalPin?pin=2&state=true y para apagarla http://192.168.0.2/setDigitalPin?pin=2&state=flase
  • setDigitalPin (Establece el pin digital seleccionado al estado seleccionado), ejemplo -> netduinoplus / setDigitalPin? pin = [0-13] & estado = [verdadero | falso]
  • pwm (establece el PWM del pin para el período y duración enviados, ejemplo -> netduinoplus / pwm? pin = [5 | 6 | 9 | 10] & period = [int] & duration = [int]
  • getAnalogPinValue (Devuelve el valor del pin analógico seleccionado),ejemplo-> netduinoplus / getAnalogPinValue? pin = [0-5]
  • getDigitalPinState (Devuelve el estado de su pin seleccionado (on / off)),ejemplo -> netduinoplus / getDigitalPinState? pin = [0-13]
  • getAllAnalogPinValues ​​(Devuelve el valor de cada pin analógico), ejemplo-> netduinoplus / getAllAnalogPinValues
  • getDigitalPinState (Devuelve el estado de cada pin digital).ejemplo-> netduinoplus / getAllDigitalPinStates
  • getAllPWMValues ​​(Devuelve los valores para todos los puertos PWM), ejemplo-> netduinoplus / getAllPWMValues
  • fileUpload (Carga un archivo en la ruta de la tarjeta SD mediante POST. Debe escribir los datos de archivo (bytes) en el cuerpo POST),ejemplo  -> netduinoplus / upload? path = [a-Z]
  • Respuesta de archivo y directorio: Simplemente escriba netduinoplus / [pathtomyfile] y podrá ver / descargar su archivo. Si la ruta dada es un directorio, se devolverá una vista de directorio

 

Más para fines de prueba, pero también como parte de NeonMika.Webserver:

  • xmlResponselist (le da una lista de todos los métodos XML) , ejemplo -> netduinoplus / xmlResponselist
  • jsonResponselist (Te da una lista de todos los métodos JSON),ejemplo -> netduinoplus / jsonResponselist
  • multipleXML (Ejemplo sobre cómo usar XML anidado), ejemplo -> netduinoplus / multixml

Algunos  ejemplos de uso

Como expandirlo con servicios XML

WebServer.AddResponse(new XMLResponse("wave", new XMLResponseMethod(WebserverXMLMethods.Wave)));

No se ve tan complicado? Eso porque no es complicado.

Este es un ejemplo de cómo escribir un XMLResponse

private void Echo(Request e,Hashtable results)
{
  if(e.Request.GetArguments.Contains("value") == true)
    results.Add("Echo",e.Request.GetArguments["value"]);
  else
    results.Add("ERROR", "No 'value'-parameter transmitted toserver");
}

Todas las XMLResponses deben tener este formato:

  • Valor de retorno:vacío
  • Parámetro: Solicitud (con esto puede acceder al parámetro escrito en la URL)
    Hashtable (aquí usted agrega la respuesta)
  • Si necesita XML apilado, eche un vistazo al método MultiXML en Server.cs

 

Cómo escribir una respuesta JSON:

 

private void ResponseListJSON(Request e, JsonArray j)
{
   JsonObject o;
   foreach(Object k in _Responses.Keys)
   {
     o = newJsonObject();
     o.Add("methodURL", k);
     o.Add("methodName", ((Response)_Responses[k]).Name);
     j.Add(o);
   }
}

Server setup:

Server WebServer = new Server(PinManagement.OnboardLED,80,false,"192.168.0.200","255.255.255.0","192.168.0.2","NETDUINOPLUS"); 
WebServer.AddResponse(newXMLResponse("echo", new XMLResponseMethod(Echo))); 
WebServer.AddResponse(newJSONResponse("jsonResponselist", new JSONResponseMethod(ResponseListJSON)));

 

Cómo acceder a los últimos datos POST:

PostFileReader post = new PostFileReader ();

byte [] postData = post.Read (bufferSize);

 

Mostrar el directorio de archivos:

http://192.168.0.2/SD

 

Archivo de acceso:

http://192.168.0.2/SD/folder/file.txt

 

 

 

Cafetera conectada con Netduino


Netduino es una plataforma electrónica de código abierto utilizando .NET Micro Framework   basada en  un microcontrolador de 32 bits y con un entorno de desarrollo muy rico destinada a ingenieros y aficionados por igual. Netduino Plus   ademas añade  Ethernet integrado (hay una pila de TCP/IP completa )y una ranura para tarjetas microSD para almacenar archivos .No menos importante esta el tema de las conexiones externas,pues   Netduino ofrece 20 GPIOs combinados con SPI, I2C, 2 UARTs (1 RTS/CTS), 4 canales PWM y 6 canales ADC. A gran diferencia con Arduino,   para desarrollo se puede usar tanto   para Windows   (  con Visual Studio,)  o con Xamarin Studio en Mac OS X , ambas  perfectas  para complilar ,depurar  y probar nuestra aplicaciones . Incluso se puede  utilizar el Netduino en equipo Linux y Mac con Mono en lugar de .NET de código abierto 

La familia Netduino se basa en el Cortex-M Micro procesador la v4.3 .NET Micro Framework (NETMF) que como comentabamos está repleto de IO; incluyendo 22 entrada/salida de propósito General (GPIO) puertos, de las cuales 6 apoyo generación de modulación de ancho de pulso (PWM) de hardware, 4 UARTs (comunicación serial), I2C y SPI (Serial Bus de interfaz periférico).

.NET micro Framework combina la facilidad de codificación de alto nivel y las características de los  microcontroladores  soportando  eventos programación multi-threading, depuracion  línea por línea, puntos de interrupción y mucho más en clara diferencia con Arduino.

Antes de continuar  debemos recordar que  Netduino también es pin compatible con Arduino shields  permitiendo  asi  usar algunos escudos  de Arduino  que ofrecen funcionalidades preconstruidas como localización GPS, servo control , etc .

Realmente la potencia de Netduino+  frente a otras placas de igual factor de forma es su conectividad integrada  en la propia placa al  no necesitar ningún escudo adicional,  lo cual le permite llegar a aplicaciones de una forma  muy sencilla  y de una forma muy rápida como vamos a ver

En este ejemplo   vamos demostrar lo fácil que resulta controlar una cafetera  ( o lo que quiera ) desde Internet  por medio de una placa  Netduino+   que esta conectado a  la red ethernet

Para este  proyecto únicamente se usara el pin digital  D2  que se configurara como salida  y al que  conectaremos  una economica placa de un relé   compatible  con Arduino (5V)

Aunque es fácilmente construible por nosotros mismso  usando un relé  ,un transistor  y sus componentes asociados  , debido al bajisimo precio <2€)   de uno ya montado merece la pena adquirirlo  asi pues comunicante habrá que conectar a un pin de datos binario de Netduino , alimentarlo con 5v DC ( obtenidos del propio Netduino+)    y por ultimo usar los contactos del relé  para encender cualquier cosa que se nos ocurra.

Como se puede apreciar en el esquema del circuito , este no puede ser mas simple pues solo hay que alimentar el circuito del rele con la tensión  de 5V procedente de la placa Netduino, conectar el pin de datos  D2 a la entrada IN de la placa del  relé  y finalmente conectar la carga ( en este caso un cafetera)  a los contactos de salida del relé.

Para  probar el funcionamiento del circuito , conecte el Netduino+  a su ordenador , inicie Visual Studio 2012  y cree una nueva aplicación .NET MicroFramework llamada Connected_Coffee_SimpleControl, y agregue referencias a los siguientes dlls:

  • Microsoft.SPOT.Hardware
  • System
  • SecretLabs.NETMF.Hardware.Netduino

A continuación, pegue el siguiente código en su archivo program.cs:

using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
using System.Threading;

namespace Connected_Coffee_SimpleControl
{
    public class Program
    {
        public static void Main()
        {
            // create an output port (a port that can be written to) and 
            // connect it to Digital Pin 2
            OutputPort relay = new OutputPort(Pins.GPIO_PIN_D2, false);

            // run forever
            while (true)
            {
                relay.Write(true); // turn on the relay
                Thread.Sleep(5000); // Leave on for 5 seconds
                relay.Write(false); // turn off the relay
                Thread.Sleep(5000); // leave off for 5 seconds
            }
        }
    }
}

Si observamos que la cafetera se enciende  por unos 5 segundos  y se apaga por 5 segundos en un bucle indefinido, el circuito funciona  perfectamente. así que con todo esto habremos ya  construido la base de la cafetera conectada mediante la creación de lo que era esencialmente una toma de corriente inteligente que podre controlar con un Netduino. Ademas después de montar el hardware, implantamos una  pequeña aplicación que controla el relé para activar la energía del hogar a la cafetera, efectivamente añadiendo un control muy simple.
Si bien esta aplicación es funcional , vamos a realizar un paso más y añadir una web API a la aplicación Netduino para que nosotros podemos controlar  la salida de forma remota.

Una vez tengamos la web API en su lugar, tenemos un punto final que puede ser aprovechado de una variedad de casos de uso. como por ejemplo  construyendo una aplicación móvil de Xamarin.Forms que use esa API para controlar la cafetera  conectado desde un dispositivo móvil

El código de ejemplo para el proyecto de la cafetera conectado todo se puede encontrar en
github.com/WildernessLabs/Netduino_Samples/tree/master/Connected_CoffeeMaker”>Netduino_Samples/Connected_CoffeeMaker y el código que se ejecuta en el Netduino está en la carpeta de la aplicación de ApplianceHost  ( de hecho ese es el código que se va examinar aquí).

Introducción a Maple

Con el fin de exponer la web API para permitir el control remoto de nuestra cafetera, necesitamos un servidor web para acogerla,así que vamos a ver  un servidor web especialmente diseñado para Netduino, el  Aervidor de maple(github.com/WildernessLabs/Maple).
Maple  es un servidor web en  código abierto, ultra ligero, habilitada  para JSON , soportando RESTful   construido específicamente para dispositivos Netduino  con capacidades de red. También se publica como un paquete nuget, por lo que es muy fácil de añadir  funcionalidades de red a sus proyectos. Este servidor esta diseñado específicamente para Netduino por lo que es increíblemente simple, rápido y super fácil de usar. Debe ejecutarse sin problemas en las placas  N3 Ethernet Wifi N3  y N2 +.

A continuación se muestran los comandos con las respectivas asignaciones en RequestHandler.cs:

  • GET http: // IPADDRESS / status – getStatus ()
  • POST http: // IPADDRESS / turnon – postTurnOn ()
  • POST http: // IPADDRESS / apagado – postTurnOff ()

¡Despliegue esto en su Netduino y acceda a estos puntos finales para verlo en acción!

Controladores de solicitudes

Criterios de valoración API web de Maple   se definen mediante la creación de clases personalizadas que heredan de la clase RequestHandlerBase.  Maple  utiliza la reflexión para crear direcciones URL basándose en los nombres de método en las clases personalizadas. Soporta tanto los metodos  get y post  asi como  los nombres de métodos que  deben tener el prefijo con cualquiera de esas cadenas para ser automáticamente en un extremo.

Por ejemplo, la siguiente clase expone tres URL endpoints   :/Status,  /TurnOn  y  TurnOff.

Como indican los nombres de los  métodos, las entradas el estado extremo acepta solicitudes get y los métodos de control de potencia (TurnOff y TurnOn) como se puede ver en el siguiente código:

using System;
using Microsoft.SPOT;
using Maple;
using System.Net;
using System.Collections;

namespace ApplianceHost
{
public class RequestHandler : RequestHandlerBase
{
private static bool _isPowerOn;

public RequestHandler(HttpListenerContext context) : base(context)
{
}

public void getStatus()
{
StatusResponse();
}

public void postTurnOn()
{
TogglePower(true);
StatusResponse();
}

public void postTurnOff()
{
TogglePower(false);
StatusResponse();
}

private void TogglePower(bool val)
{
_isPowerOn = val;
Ports.ONBOARD_LED.Write(val);
Ports.GPIO_PIN_D1.Write(val);
}

private void StatusResponse()
{
this.Context.Response.ContentType = “application/json”;
this.Context.Response.StatusCode = 200;
Hashtable result = new Hashtable {
{ “isPowerOn”, _isPowerOn.ToString().ToLower() }
};
this.Send(result);
}
}
}

Cuando se invoquen a esos extremos, se llama al método adecuado. En el caso de nuestro servidor de control; el método getStatus devuelve un mensaje con formato JSON que contiene el actual estado del relé de encendido/apagado, el método postTurnOnactiva el relé y el método postTurnOffdesactiva el relé. También mantiene el LED a bordo en sincronía con la energía al relé como indicador.

Ports se ha definido la clase ports.cs, que proporcionan accesos OutputPort directos a los objetos que representan el LED a bordo y el pin digital 1, que controla el relé:

using System;

using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

namespace ApplianceHost
{
static class Ports
{
static Ports()
{
ONBOARD_LED = new OutputPort(Pins.ONBOARD_LED, false);
GPIO_PIN_D1 = new OutputPort(Pins.GPIO_PIN_D1, false);
}

public static OutputPort ONBOARD_LED;
public static OutputPort GPIO_PIN_D1;
}
}

Uso de Maple, que es todo el código que se necesita para exponer una web moderna, RESTful API de un Netduino!

Inicialización de la red

A diferencia de aplicaciones tradicionales de escritorio o móvil en el que la interfaz de red durante mucho tiempo se ha inicializado cuando que se ejecuta una aplicación, usted debe inicializar la interfaz de red y espere a obtener su dirección IP, etc, antes de intentar hacer cualquier acceso a la red . Como tal, antes de iniciar el servidor de arce, estas tareas pero ser ejecutado y esperaron en.

La mayor parte del código en el principal extraido de ithub.com/WildernessLabs/Netduino_Samples/blob/master/Connected_CoffeeMaker/ApplianceHost/src/ApplianceHost/Program.cs hace justamente eso: Inicializa la red, espera a que una dirección IP y también hace una solicitud web para la validación. Mayoría del código está dedicado a la depuración y salida de información para ilustrar el proceso y proporcionar información para la instrucción y tiempo de desarrollo de exploración. Esta bien documentado en developer.wildernesslabs.co/Netduino/Input_Output/Network/ y de hecho estan trabajando en el envío de un paquete nuget que controlará todas esta cosas caja negra, en el futuro será aún más fácil de añadir a tus proyectos. Como tal, no voy a cubrir en detalle aquí, excepto to decir que si copia el código de inicialización de la red en su propia aplicación, debe llamar al método y comprobar que es el regreso (de éxito) antes de comenzar cualquier tratamiento que incluye acceso a la red :

InitializeNetwork true

if (InitializeNetwork())
 {
    // start the maple server
    // and start your application processing here 
}



Iniciar servidor de Maple

Una vez que la red se ha inicializado,   servidor Maple necesita ser instanciado y comenzar con método Start : >MapleServer server = new MapleServer(); server.Start(); Para la mayoría de los casos, esto debe ir directamente después de la llamada de inicialización de red, sin embargo, dependiendo de sus necesidades de aplicación, puede iniciarlo cuando sea necesario.

Configuración de la red

El último paso necesario para configurar la muestra ApplicationHost es configurar la red. Algunas piezas de la red, tales como el nombre de red WiFi y la contraseña (si corresponde), necesita ser configurado en implementar tiempo. Si usted está desarrollando en una máquina Windows, puede utilizar MFDeploy, que se instala como parte del SDK .NET MicroFramework. Para desarrolladores de Mac, existe  MacDeploy, que proporciona la misma funcionalidad: Si está usando el WiFi  con  Netduino 3, la autenticación y opciones de cifrado pueden ser un poco confusos, sin embargo, si se está conectando a una red WiFi moderna que requiere una contraseña, usted probablemente necesitará ajustar la autenticación para Compartido y la configuración de cifrado WPA. Además, el SSID se refiere al nombre de la red WiFi.

Probar el servidor de Control de aplicaciones API

Una vez que la red se configura y se implementa la aplicación, ya está listo para probar la funcionalidad  de Maple. Si todo va bien, la ventana de Salida de la aplicación en Visual Studio, debe tener algo similar a  lo siguiente:

Getting all the network interfaces.

Found 802.11

WiFi Interface MAC Address: 60-D7-E3-A0-02-CB

DHCP enabled: True

Dynamic DNS enabled: False

IP Address: 0.0.0.0

Subnet Mask: 0.0.0.0

Gateway: 0.0.0.0

SSID:Cabin in the Woods Found 802.11

WiFi Interface No IP Address

DHCP is enabled, attempting to get an IP Address Sleep while obtaining an IP Sleep while obtaining an IP Sleep while obtaining an IP Got IP

Address: 172.16.42.8

Necesitará la dirección IP para probar el punto final de la API. El extremo del estado es fácil de comprobar a través de un navegador; Asegúrese de que usted está en la misma red que el Netduino y abra una ventana del navegador y vaya a la  url. Debe mostrar una respuesta JSON. Sin embargo, recomiendo conseguir el  programa Postman para probar los extremos. Es gratuito y diseñado específicamente para probar interfaces RESTful. Le  permite publicar solicitudes además de obtener, así como una mirada de otras cosas útiles, incluyendo análisis automático de  respuestas JSON de  la forma http://direccion_ip/Status