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

 

 

 

Anuncio publicitario

Pushing usando Parse desde Netduino a Xamarin.Forms


Parse es un proveedor BaaS (Backend as a service) que, entre su conjunto de características, ofrece un servicio de notificaciones Push . Se usa  ese servicio para enviar las notificaciones push a nuestros  dispositivos. Es bastante sencillo comenzar, en primer lugar, crear una nueva aplicación, tomar las claves (para ambas REST API y .NET), escribir  un código y empezaré a enviar pushes.

Configurando el Netduino

Se puede utilizar  un simple interruptor de contacto magnético(es decir un rele reed)  para detectar cuándo la puerta se abrió o se cerró, en el código se verá algo así como var doorPort = new InputPort(... y un bucle infinito en el que reside la lógica «principal»). while el netduino lee el estado actual del sensor, lo compara con un estado previo y, si hay algún cambio, envía la notificación de inserción utilizando mi biblioteca parse-dotnetmf .

La biblioteca parse-dotnetmf

Para consumir las funciones REST Api de Parse de un Netduino 3, se puede í crear una biblioteca de clientes para facilitar las cosas , esta biblioteca actualmente solo admite el envío de notificaciones push o Parse, pero puede ampliarse fácilmente para admitir todas las demás funciones también , es fácil de usar simplemente cree un cliente var pc = new ParseClient("AppId", "Api Key"); y luego envíe una notificación push así: pc.SendPushToChannel("Hey!"); .

Esta biblioteca está muy inspirada en la biblioteca MicroTweet2 de Matt Isenhower. Utiliza la clase HttpWebRequest , no requiere dependencias adicionales y cabe fácilmente en un tablero de Wi-Fi Netduino 3.

Configuración de la aplicación Xamarin.Forms

Hay algunos pasos que debe seguir para implementar Parse Push en su aplicación Xamarin, le recomiendo que siga los tutoriales que ya existen en el sitio web de Parse. Voy a hacer un resumen rápido de lo que hice (además de tratar de crear mi propio complemento).

En primer lugar, para Windows Phone no hay pasos obligatorios que no sean seguir este tutorial , por otro lado, para Android tendrás que hacer dos cosas:
1. Marque este tutorial pero haga solo la parte de AndroidManifest.xml .
2. Compruebe la muestra en GitHub , en particular la implementación de la clase ParseApplication en el proyecto de Android.

El complemento CrossParse

Como sabemos, cuando queremos ofrecer experiencias específicas de la plataforma desde una aplicación Xamarin.Forms podemos usar o crear un complemento que nos permita resumir las funcionalidades de cada plataforma para interactuar con cada plataforma a través de una API común.

Tratar de hacer un complemento para manejar todas las interacciones con Parse push o resulta que no es tan fácil como se puede pensar al principio, pues  los Componentes Xamarin de Parse para cada plataforma ya son compatibles con las notificaciones push, pero no existe una capa de abstracción que pueda usarse con formularios, sin mencionar que hay algunos pasos especiales necesarios para cada plataforma que debe gestionar explícitamente en cada proyecto específico de plataforma como por ejemplo crear la clase ParseApplication extra en el proyecto de Android, por ejemplo).

Por lo tanto, este complemento no es tan útil o, pero aún ayuda proporcionando la capa de abstracción mencionada e instalando los nugets de Parse por ti. Con este complemento, puede suscribirse / darse de baja de los canales y gestionar las notificaciones mientras el usuario se encuentra en la aplicación. Realmente esperemos que Parse lance un complemento para formularios pronto, ya que es bastante fácil de hacer dado que ya tienen los componentes.

El autor ha realizado un video donde mostra cómo funciona el sistema:

Enlaces

No pretendemos desde este blog  crear una publicación llena de enlaces, así que aquí están los enlaces a los complementos GitHub repos (y su respectiva página NuGet):

Alarma casera usando Raspberry Pi, Netduino Plus y ATtiny85


En el post de vamos a tratar un interesante sistema de monitoreo de alarma para el hogar de código abierto ,que como peculiaridad  usa tres plataformas  completamente diferentes   como son una  Raspbery Pi , Netduino Plus , ATtiny 85   para mejorar  un típico sistema de alarma para el hogar  basada en  los controles  PC5010 Digital Security Controls (DSC) PowerSeries Security System control panel   y sensores.

Concretando un poco el hardware empleado el creador  ha usado un Netduino Plus 1 ejecutando  .NET Micro Framework 4.2 (o QFE1 qfe2) y una  Raspbery Pi Modelo A con Debian GNU / Linux 7.0 (wheezy).

El autor  Gilberto Garcia  empezó el  proyecto  HomeAlarmPlus en febrero de 2012 con la intención de tener un simple sistema de monitorización de alarma para el hogar  y aprender más acerca de los microcontroladores usando como base una placa Netduino. A medida que fue mejorando sus  conocimientos, también lo hizo la complejidad de los circuitos, el sistema y los requisitos.Entonces apareció la idea de usar  una placa  Raspbery Pi para complementar el proyecto existente mediante el uso de la capacidad total del servidor Web Apache. Esto implicó cambios masivos en el código  del  proyecto original  como lo refleja  incluso el nombre final: HomeAlarmPlusPi.

El Objetivo por tanto del proyecto fue utilizar las capacidades completas de Raspbery Pi y Netduino Plus para controlar el sistema de alarma de una casa y reportar cualquier actividad de sensor o detector de movimiento a través de correo electrónico (mediante simple de transferencia de correo (SMTP)), un servidor web local, notificaciones (usando PushingBox ) y Pachube (despues  Cosm  y ahora xively) .

Dada la diversidad de plataformas empleadas , también lo fueron los  lenguajes de Programación  empleados para este proyecto, los cuales  fueron  los siguientes:

En Netduino Plus

  • C # para Netduino Plus
  • HTML para Web Server con hojas de estilo en cascada (CSS)
  • JavaScript para Web Server

En Raspbery Pi

  • HTML5
  • PHP
  • Java script
  • JSON
  • jQuery
  • El tiempo en API
  • Python (en desarrollo: uso de GPIO)

En ATtiny85

  • C / C ++ para programar el ATtiny85. Programado gracias a un escudo ArduinoISP, que construyo siguiendo las instrucciones  del  MIT High-Low Tech Group.
Arduino «programador en-sistema» (ISP) escudo ATtiny programador.

 

El hardware necesario

  • Raspbery Pi Modelo A o B
  • Netduino Plus
  • ATtiny85 (ATTINY85-20PU).
  • Tarjeta de memoria SD de 4 GB o superior (clase 10 preferido).
  • 5V 1A (1000mA) puerto USB fuente de alimentación .
  • Tarjeta Micro SD de 2 GB
  • Wi-Fi (802.11b / g / n) Módulo USB [1] , [2] o [3]
  • Adaptador de tarjetas SD
  • 3mm verde diodo emisor de luz (LED) por zona de alarma y detector de movimiento.
  • 330 ohmios para cada LED.
  • Transistor NPN
  • 10k ohmios resistencia variable
  • Resistencia de 1k ohmios para la base del transistor.
  • 5600 ohmios por resistencia de la zona de alarma y detector de movimiento.
  • Diodo Schottky por zona de alarma. Diodo Schottky debe tener baja caída de tensión como el SBR10U40CT .
  • ScrewShield (Proto-Screwshield (Wingshield) Kit de [1] o [2] ).
  • Conexión WiFi a Internet utilizando cualquier adaptador Wi-Fi. Probado en NetgearWNCE3001 y IOGEAR GWU627 .
  • 16×2 carácter básico LCD [1] u otros [2] .
  • Interruptor DPDT [1] u otros [2] para la selección de voltaje LCD.
  • Registro de desplazamiento 74HC595

Hardware opcional

 

  • Robusto, USB / Panel de conectores a prueba de agua ( RR-211300-30 )
  • Receptor RF Toggle Type para armar / desarmar [1] .
  • Cable USB 2.0, tipo A macho a un varón (10 pies o más arriba). Se utiliza para acceder alNetduino Plus tabla en el panel de alarma.
  • 200 vatios / 350 VA UPS ( APC Sistema UPS BE350G o similar ).
  • Pulsador de rearme externo.
  • Arduino Proto Escudo R3. Más espacio para componentes adicionales. [1] o de otros [2] ,[3] .
  • Bajo perfil adaptador de tarjetas microSD para Raspberry Pi [1] .
  • Caja  Raspbery Pi [1] u otros [2]
  • Interruptor de encendido en la línea de 2,1 mm jack barril [1] o [2] .
  • Raspbery Pi conjunto de disipador de calor [1] .
  • Ventilador de 12 V CC Micro se enfríe Raspbery Pi [1] .

 

Ajustes
Para HomeAlarmPlus y HomeAlarmPlus Pi el símbolo condicional ALARM_DEBUG permite depurar alarma en Visual Studio. Para habilitar la depuración en la correcta proyecto presione AlarmByZones, seleccione propiedades, seleccione la pestaña Build de Visual Studio y añadir ALARM_DEBUG en «símbolos de compilación condicional».

configuración de depuración

Más capacidades de depuración se llevarán a cabo para Raspbery Pi y ATtiny85.

Circuitería
El  siguiente Fritzing diagrama muestra cómo se conectan el Netduino además, los LED y las zonas de alarma (o detector de movimiento). En comparación de la aplicación anterior ( HomeAlarmPlus ) se ha añadido un  ATtiny85 con el fin de reducir los hilos en el Netduino Plus 1. De esta manera se han salvado 2 KB de RAM y dando  más espacio de código.

HomeAlarmPlus Pi diagrama de conexión I. Rev

 

circuitos HomeAlarmPlus Pi
HomeAlarmPlus Pi detalles de circuitos

Tenga en cuenta que una o más zonas consisten en lo siguiente:
a) 1 normalmente abierto de contacto y 1 Contacto normalmente cerrado con resistencia de fin de línea (EOL).
b) Doble circuito EOL, 1 contacto normalmente cerrado con una resistencia EOL 5.6kohm y el diodoSchottky. Esto hará que la protección necesaria para el Netduino o Arduino.
c) Cada zona de tierra debe ser conectado a la ProtoScrewShield GND.

Netduino / ProtoScrewShield Pin
Descripción
A0 Zona # 1
A1 Zona # 2
A2 Zona # 3
A3 Zona # 4
A4 Sensor # 1 [detector de movimiento]
D0 XBee RX
D2 LED de zona # 1
D3 LED de zona # 2
D4 Zona LED # 3
D5 Zona LED # 4
D6 LED Sensor # 1 [detector de movimiento]
D7 RF pasador articulado (Receptor RF)
D8 ATtiny85 poder
D9 Alarma antirrobo o Mini zumbador
D10, D11 y D13 LCD registro de desplazamiento

Opciones de servidor Web en Netduino Plus

opciones
Descripción
/ página raíz formato de escritorio.
/open Abrir último archivo en la tarjeta SD.
/ sdcard Lista los archivos en la tarjeta SD.
/ Do superusuario. Muestra opciones adicionales.
/ Pachube Muestra la actividad Pachube por zona / Datastream.
/about créditos de la aplicación y la versión. [Versión desktop]
/ about-mobile créditos de la aplicación y la versión. [Versión móvil]
/ delete-confirm Eliminar último archivo en la tarjeta SD [ventana de confirmar].
/ delete-last Eliminar último archivo en la tarjeta SD [ninguna ventana de confirmación].
/ diag Muestra la memoria disponible en Netduino y fuerzas para despejar el recolector de basura. [Versión de escritorio]
/ diag-mobile Muestra la memoria disponible en Netduino y fuerzas para despejar el recolector de basura. [Versión móvil]
/date Obtiene fecha y hora de Raspbery Pi.
/mobile página raíz formato móvil.

 

HomeAlarmPlus [Versión de escritorio]
HomeAlarmPlus [Versión móvil]

Opciones de servidor Web en Raspbery Pi

opciones
Descripción
/ página raíz formato de escritorio.
/index.php página raíz formato de escritorio.
/weather.html los datos de tiempo en Wunderground. [Versión desktop]
/móvil página raíz formato móvil.
/mobile/index.php página raíz formato móvil.
/references.htm Proyecto enlaces de referencia.
/about créditos de la aplicación y la versión.
/NetduinoPlus/setNetduinoTimer.php Configuración / Actualización Netduino Plus hora / fecha.

 

servidor web HomeAlarmPlus Pi [Versión de escritorio]
HomeAlarmPlus Pi servidor web [Versión móvil]

 

HomeAlarmPlus Pi [pantalla móvil Apple]

Arquitectura de software

HomeAlarmPlus Arquitectura de Software Pi

 

Arquitectura de Software detallada

Producto final

Producto final mostrando el acceso móvil, Raspbery Pi, Netduino Plus 1, escudo personalizados para el panel de alarma Netduino y Home

En desarrollo

  • Interfaz web para dispositivos basados en tabletas. [Pruebas, no publicado]
  • Las cámaras con sensor de movimiento integrado y la visión nocturna. Cámara debe integrarse con Raspbery Pi GPIO.
  • Más capacidades de depuración de Raspbery Pi y ATtiny85.
  • Explora las opciones de notificación adicionales como IFTTT. [Hecho. Lanzamiento 17 de de julio de, 2013]

Referencias muy interesantes para profundizar:

Repositorio de código y documentación
HomeAlarmPlusPi

Advertencia
El proyecto  contiene información relacionada con un típico sistemas de alarma. Por favor, tenga en cuenta que este procedimiento puede anular la garantía. Cualquier sistema de alarma o cualquier tipo puede ser comprometido deliberadamente o puede fallar al operar como se espera por una variedad de razones.

El autor, Gilberto García, no se hace responsable de los fallos del sistema, tales como: instalación inadecuada, el conocimiento penal, el acceso de intrusos, fallo de alimentación, el fallo de las baterías reemplazables, el compromiso de la radiofrecuencia dispositivos (inalámbricos), los usuarios del sistema, detectores de humo, movimiento detectores, dispositivos de alarma (sirenas, campanas, cuernos), líneas telefónicas, tiempo insuficiente, fallo de un componente, pruebas insuficientes, de seguridad y de seguros (de propiedad o de seguros de vida).

Una última cosa:Desconecte la alimentación de c.a.  y de teléfono antes de hacer cualquier cosa.

Fuente aqui

Envío de tweets con Netduino+


 Hemos hablado en muchísmas ocasiones en este blog   de Netduino Plus,  una  placa pequeña (pero poderoso) basado en un microprocesador Atmel 32 bits con el mismo factor de forma que un Arduino   que ademas  puede ejecutar programas escritos en C# para Micro de .NET Framework y la versión «Plus» añade un puerto 10/100 Mbps Ethernet, proporcionándole un dispositivo compatible con redes muy potente para alrededor de $59 USD.

¿Qué puede hacer con él? Mucho, realmente, como  puede ver  en los foros Netduino:tiene acceso a conexiones de red mediante System.Net.Sockets, puede realizar peticiones HTTP mediante System.Http, y hay incluso algunas implementaciones de servidores web ligero disponibles(Neomilka Web Server)

Lo único que no pude encontrar fácilmente  es una biblioteca para Twitter, por lo que el autor   inspirándose   en la  Biblioteca Tweet para Arduino, que envía tweets a través de un sitio web externo, presumiblemente para evitar aplicar OAuth de Arduino,  decidió  hacer que  Netduino se comunique con la API de Twitter directamente, lo que significa que no son necesarios  webs ni proxies .

Resumen de OAuth

Twitter actualmente requiere que todas las llamadas API sean autenticados con OAuth. Para comunicarse con la API de Twitter, usted debe primero registrar una aplicación para obtener los valores clave de consumo y del consumidor secreto necesarios. Llamadas a la API cuenta específicas requieren un Token de acceso y el Token de acceso secreto, que se generan después de dar un permiso de la aplicación para acceder a tu cuenta. Un Token de acceso y acceso secreto Token se proporcionan automáticamente por su cuenta cuando se registre una aplicación.

Cada solicitud de API debe tener un encabezado de autenticación con ciertos parámetros OAuth. Uno de estos parámetros es la firma OAuth, que se genera mediante la creación de un valor HMAC-SHA1 hash del método HTTP, la URL normalizada y variables POST, los otros parámetros OAuth, (o parámetros de cadena de consulta de solicitudes GET). Esta firma está codificada en una cadena Base64.

Generación de la firma OAuth es la parte más cálculo intensiva de hacer llamadas a la API. He encontrado que tarda alrededor de 500-1500ms para generar la firma en un Netduino Plus dependiendo de los parámetros de entrada.

También cabe mencionar que uno de los parámetros de OAuth es la fecha y hora actuales con formato como un timestamp de Unix. Sin una fecha y hora exacta fallarán todas las solicitudes de API, así que es importante para asegurarse de que se actualiza el reloj de la Netduino antes de hacer llamadas a la API.

Implementación

Para este proyecto, se usan  las siguientes bibliotecas de terceros:

  • SHA/HMAC Digest clase, con una modificación para manejar adecuadamente secretos valores > 84 caracteres de Elze Kool
  • La clase NearlyGenericArrayList del proyecto MicroLinq
  • El método NTPTime publicado por Chris Seto en los foros de Netduino

La clase OAuth creada para este proyecto implementa la mayor parte de la especificación OAuth, con unos accesos directos adoptadas ahorrar tiempo y programa espacio de procesamiento.Por ejemplo, asume que URLs han sido normalizadas correctamente antes de que se pasan al método OAuth.GetOAuthRequest.

La clase TweetBot se ha separado en dos archivos diferentes: TweetBot.cs para la estructura de la clase principal y TweetBot.HTTPRequests.cs para las solicitudes HTTP. Mientras que actualmente hay sólo un método de solicitud HTTP, esta estructura ayudará a asegurarse de que el código sigue siendo fácil de entender como desarrollo continúa.

TweetBot instancias tendrán un evento DebugMessage que se puede conectar a imprimir los mensajes de depuración a un puerto serie, un archivo de registro en una tarjeta SD, etc..

Actualmente, se realizan todas las operaciones HTTP sincrónicamente pero probablemente puede modificar que ejecuta asincrónicamente bastante fácilmente. Además, actualmente hay muy poca errores así que si no puede alcanzarse la API de Twitter o si entras en las teclas de acceso mal probablemente obtendrá una excepción no controlada. Tal vez sea una buena idea para envolver todo método TweetBot llamadas en un bloque try/catch.

Utilizando la clase TweetBot

Uso TweetBot es bastante sencillo. En primer lugar, especificar sus datos de cuenta y aplicación en algún lugar en su programa.

Debe primero registrar una nueva aplicación para conseguir un Consumer Key y Consumer Secret. Una vez que haya completado el procedimiento de registro, abra la página de Aplicaciones de Twitter, ver los detalles de su aplicación y haga clic en el enlace que dice «Mi Token de acceso». Esa página mostrará de su cuenta usuario acceso Token y secreto Token de acceso de usuario.

Con el fin de crear las solicitudes válidas de OAuth, reloj de la Netduino debe establecerse con la hora correcta. Aquí hay un ejemplo de los foros Netduino para recuperar el tiempo actual de un servidor NTP. (Este código también está incluido en la aplicación de demostración).

Para enviar un tweet, crear una nueva instancia de la clase TweetBot y llamar a su método SendTweet:

Eso es todo! SendTweet devuelve true si el mensaje fue enviado con éxito.

Programa de demostración

El programa demo incluido con este proyecto crea una serie de «consola» en puerto COM1 el Plus’ Netduino funcionando a 115200bps. Este puerto utiliza pin digital 0 en el N + para Rx y pin 1 para Tx( el autor ha usando un Bus Pirate para comunicarse con el puerto serial de la Netduino, pero también puede usar un dispositivo FT232R (o similar) a 3.3V o un convertidor de nivel).

Bus Pirate

Tres conexiones son necesarias:

  • Autobús pirata Gnd a Netduino Gnd
  • Autobús pirata Tx a Netduino Rx
  • Bus Pirate Rx de Tx Netduino

Consulte el manual de Bus Pirate de números pin específico como pueden variar entre los dispositivos. Una vez que todo está conectado y encendido, configurar el Bus Pirate para 115200bps UART con «Normalidad» (3, 3V / Gnd) salida. La secuencia de comandos es m, 3, 9, 1, 1, 1, 2.

A continuación, inicie la macro «Puente transparente» escribiendo «(1)» (con el paréntesis) y luego «y» aceptar la advertencia. Esto configura el Bus Pirate para actuar como un puente UART transparente, así los caracteres de entrada se envían a la Netduino y todos los resultados de la Netduino se muestran en su terminal.

Consola demo

Cuando se ejecuta el programa de demostración, un mensaje de ayuda se escribirán en el puerto serie. Si se conecta después de que se ha enviado el mensaje inicial, sólo tienes que escribir «?» y pulse enter para verlo otra vez.
Para enviar un tweet, tipo «p < mensaje >» y pulse enter. También puede omitir el mensaje a enviar un mensaje genérico de «Hola desde un [OEMString]!». (Tenga en cuenta que si intenta enviar el mismo mensaje varias veces probablemente obtendrá un error de «mensaje repetido»).
Si todo sale bien, se registrará su mensaje en Twitter desde tu cuenta:

Código

 Este proyecto está ahora en CodePlex: MicroTweet – Twitter OAuth biblioteca API para la Micro de .NET Framework

Como software de Netduino, este código está liberado bajo la licencia Apache 2.0.

 

 

 

Fuente   aqui

Monitorizacion consumo de agua con Netduino


Dejan Levec  necesitaba una manera de medir el agua utilizada fuera de la casa. Hay algunos productos comerciales, como Gardena inteligente Medidor de flujo de agua, pero  no son baratos y no pueden dibujar gráficos con buen aspecto.

Esto parecía un buen proyecto de fin de semana y al final optó  por  utilizar módulos inalámbricos XRF  que basicamente son radios Xbee con un montón de características:

  • Trabajan fuera de la caja,
  • Tienen  Xbee-como patillas,
  • Compatible con el cifrado AES de 128 bits
Cuestan 15 € cada uno, pero porque necesitan tensión de alimentación de 3,3 V y tienen el diseño paso de 2 mm, pero  tambien necesita algunas placas de interfaz activa. Lamentablemente, no hay mucha documentación al respecto en Internet, ya que hay para los módulos Xbee.
De todos modos, tienen un modo de configuración muy fácil. Para acceder al mismo tiene que enviar + + + y espere 1 segundo antes y después de enviarl , por ejemplo el autor usa la siguiente configuración:

ATEA contraseña
ATEE 1
ATID 0000
ATAC
ATDn

Esta cadena  permite el cifrado AES, establece la contraseña para ‘password’ y especifica  el ID de red, 0000. Las nuevas líneas se representan como \ r char, y comandos devuelven bien si tiene éxito.

Decidió  usar la siguiente configuración:

Medidor de flujo en intervalos regulares envían datos sobre el consumo de agua a la puerta de enlace Netduino Plus.Netduino Plus escucha red XRF y envía cada mensaje recibido a aplicación web alojada por Google App Engine.

El autor tiene  la intención de actualizar la puerta de enlace para apoyar la comunicación de dos vías, sin embargo, en primer lugar tiene  que hacer un interfaz GUI web para visualizar los datos del medidor de flujo muy bien, ya que los números sin gráficos son poco atractivos.

Medidor de caudal

Dispositivo medidor de flujo compuesto por una sonda de Seeedstudio Caudal de agua, módulo de XRF, Atmega8 microcontrolador, y actualmente está construido en placa. Voy a moverlo a PCB, cuando encuentro tiempo suficiente (próximo fin de semana de sonido bueno). El sensor de flujo de agua contiene el sensor de efecto Hall y envía un pulso por cada giro del rotor. Después de algunas pruebas esta es e fórmula que uso:

flujo de agua [dcl] = pulsos / 3,2 por período medido

Ejemplo: Si envía 3,2 pulsos en uno de segundos, esto significa que el flujo de agua es 1 DCL por segundo.
El autor se decidió  a probar el flujo de agua durante un periodo diez segundos y enviar suma de esos valores a la aplicación web cada cinco minutos.

Gateway Netduino

Netduino Plus escucha inalámbrica los  datos XRF y envía todos los recibidos de comandos para aplicación web con una petición  HTTP GET .
Los comandos se componen de los siguientes datos: iniciar carácter, dos Identificación del receptor dígito, dos dígitos Identificación del emisor, los datos y el carácter extremo.
Ejemplo de comando:

! 0102hello mundo $

que envía hola string mundo desde el dispositivo n º 02 al dispositivo con el id # 01. La Aplicación Web guarda esta información incluyendo fecha y hora actual a la base de datos.

Google App Engine
El autor uso  GAE  con  Python. Documentación y ejemplos son muy buenos y la comunidad web de Python es bastante grande, así que no es difícil de encontrar diferentes bibliotecas. Las bases de datoses muy flexible , ya que no es necesario especificar las columnas de avanzada, así que es como MongoDB, Tristemente, marcos web como Django mayoría esperan base de datos relacional.
De todos modos, la única cosa que el autor tubo problemas  con e GAE son sus cuotas libres fue las actualizaciones  y la cuota gratuita (en 1 hora de prueba le  enviaron hasta 10 actualizaciones por minuto y ya ha usado 10% de la cuota de base de datos en aproximadamente 1 hora).

Fuente aqui

 

Si no se puede compilar su código con Netduino


En ocasiones debido a continuos reflasheos de nuestro Netduino es posible que llegue un momento en que, simpre que no sea por errores en el propio código que intentamos compilar ,   ya  nos sea imposible compilar nuestro código dando error de comunicaciones ,error desconocido ,etc

Para solucionar el problema en el 99,9%  de las ocasiones  tan solo hay que ejecutar  la utilidad Mdfdeploy incluida en el SDK (normalmente estará en C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.3\Tools\MdfDeploy.exe)

Una vez  lanzado el MdfDeploy  ,en primer lugar pulsaremos en Device  USB y a que  la opción por defecto es serial

Acto seguido, si tenemos pinchado nuestro Netduino al USB,  debería aparecer nuestro  Netduino  en la caja de la derecha de USB

Para comprobar de que es funcional podemos pulsar Ping

netduino1

Como vemos responde,  procedamos a eliminar el  ultimo software que se compilo, para lo cual   simplemente pulsaremos  el boton  ”Erase”.

Nos pide confirmación  (deberemos  volver  a pulsar Erase  o Cancel  si no estamos seguros )

netduino2

Ahora  nos ira apareciendo una barra de progreso hasta  terminar al 100%, momento en el cual podemos volver a intentar  volver a flashear nuestro Netduino.

 

M2M con Netduino y Yaler


Netduino puede  ser  accesible desde cualquier lugar a través de la infraestructura de retransmisión Yaler.Como requisitos previos  para la configuración de su dispositivo requiere un Framework   que puede instalarse uno mismo   en un servidor Linux  o Windows  o si no lo dispone puede registrarse en Yaler para obtener una cuenta gratis para conseguir uno.
Para  hacerlo  funcionar usaremos la  biblioteca Gsiot.Server de Cuno Pfister que se ejecuta en   Netduino Plus , Netduino Plus 2 , Mountaineer y otra spalacas   NET Micro Framework. .

Siga estos pasos en el equipo de Windows para asegurarse de que DHCP del Netduino está activado y una dirección MAC está establecida:

  1. Inicio MFDeploy.exe situado en
      C:.. \ Archivos de programa (x86) \ Microsoft NET Micro Framework \ v4 x \ Tools \ MFDeploy.exe
  2. Seleccione el tipo de dispositivos USB
  3. Conecte su Netduino a través de USB
  4. Haga clic en el botón Ping hasta que el Netduino responde con
      Haciendo ping a ...  TinyCLR
  5. Para abrir el cuadro de diálogo de configuración de red, seleccione el menú
      Target> Configuración> Conexiones de red
  6. Asegúrese de que la casilla de verificación Habilitar DHCP se comprueba
  7. Asegúrese de que la dirección MAC es la misma que la dirección impresa en la etiqueta en su Netduino
  8. Haga clic en Actualizar para guardar los cambios en el Netduino
  9. Reinicie el Netduino desenchufando y enchufando el cable USB
  10. Hecho.

Instalación de la biblioteca Gsiot.Server

Siga estos pasos para agregar la biblioteca Gsiot.Server de Cuno Pfister para Visual Studio.

  1. Para Netduino Plus, descarga
      Proyectos + V20110526 ...  . Zip

    Para Netduino Plus 2 o tableros Mountaineer, descarga

      Muestras Gsiot + + para + NETMF 4.2 ...  . Zip
  2. En Windows, abra el ZIP y copiar las carpetas Gsiot.Server y HelloWeb (y, si están disponibles, Oberon.Netmf.Compatibility)para
      C: \ Users \ nombre_usuario \ Documents \ Visual Studio 2012 \ Projects
  3. Hecho.

Ejecución de un ejemplo de servicio Web

  1. En Windows en Visual Studio, abra el proyecto
      HelloWeb
  2. Reemplace <insertar su dominio de retransmisión here> con su dominio de retransmisión, por ejemplo, para el relé de dominio gsiot-ffmq-ttd5 que sería
      RelayDomain = "gsiot-ffmq-ttd5",
  3. Reemplace <insertar su here> clave secreta con su clave, por ejemplo, para la claveo5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89 eso sería
      RelaySecretKey = "o5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89",
  4. Construir y cargar el código de ejemplo a su Netduino
  5. Hecho. Ahora, ver cómo acceder a su dispositivo desde un navegador Web o con Curl (añadir /hello para que funcione).

Fuente aqui

Flashear sin peligro tu Netduino plus a Netduino Plus V2


Flashear siempre es un riesgo en casi todos los dispositivos programables básicamente porque en el 99% de las veces ira bien y como fruto tendremos un sistema actualizado ,pero desgraciadamente  puede haber un 1% donde no ira bien y el resultado no sera agradable «bricked»   pues por desgracia no siempre se podra arreglar

En el caso de contar con el netduino con 4.1.0 (version anterior) podria estar más que justificado realizar  laa actualizacion ,pues el nuevo firmware 4.2.1  incluye las siguientes actualizaciones :

  1. Corrección de errores PWM (periodo / frecuencia ahora ajustada correctamente)
  2. 64Kb flash  y 50% más de memoria RAM: 42KB (4.2.0.0) vs 28KB (4.1.0.6)
  3. Visual Basic es ahora un lenguaje soportado por. NET MF
  4. Nuevas clases AnalogInput y PWM básicos; clases compatibles con versiones anteriores disponibles a través de add-on asambleas.
  5. Nuevos drivers WinUSB (para remediar problemas BSOD en 4.2 beta)
  6. Recolector de basura ahora recoge plenamente objetos antiguos
  7. Ver netmf.codeplex.com para los detalles completos de todas las correcciones de errores

Para empezar ,para encontrar la versión actual de su firmware Netduino Plus:

  1.  Ir al inicio Menú> Programas> Microsoft. NET Micro Framework 4.2> Herramientas
  2. Ejecute MFDeploy.exe. Tenga cuidado al ejecutar MFDeploy.exe y no MFDeploy.exe.config (como las extensiones de archivo están ocultas de manera predeterminada)
  3. Conecte su Netduino Plus a su PC usando un cable USB Micro.
  4. En la sección de dispositivos en la parte superior, seleccione USB en lugar de en serie. Su Netduino Plus debe aparecer en la lista desplegable, si no, seleccionarlo.
  5. Seleccione la opción de menú Target, Capacidades de dispositivo.
  6. En el cuadro de salida, encontrar el valor «SolutionReleaseInfo.solutionVersion». Esta es la versión del firmware.

Si su version es la antigua (4.1,x)  puede seguir  bajo su responabilidad los siguintes pasos  para actualizar   el firmware:

TinyBooterDecompressor

Para empezar necesitara  descargar e instalar SAM-BA 2.12 CDC para Windows (XP, Vista, W7) de esta página de descarga(Usted tendrá que registrarse para descargar, pero no hay ningún coste). Para obtener los mejores resultados actualizar el controlador de Windows (utilizando el administrador de dispositivos) para los controladores ubicados en (dependiendo de su sistema) Archivos de programa \ Atmel Corporation \ sam-ba_2.12 \ drv ANTES de utilizar esta herramienta. Si esto no funciona para usted, algún éxito ha estado utilizando el SAM-BA 2.9 no CDC disponible aquí .

Restablecer completamente su Netduino conectando 3,3 V hasta la plaza de metal debajo de E / S digital pin 0, mientras que el Netduino está encendido como se  muestra en la foto .
Imagen

Ahora  reconectar el Netduino al PC. Se instalará un controlador para un puerto COM emulado. Inicie la herramienta SAM-BA. Si un controlador de un puerto COM emulado no está instalado en una máquina x64 de Windows 7, pruebe esta página wiki .

Seleccione el puerto serie (puerto COM) emulado  del Netduino al que se conectara(normalmente sera  el com10), seleccione el chip adecuado para su Netduino (la información del chip del procesador «Atmel» que  tendrá un identificador como «AT91SAM7X512-ek.»,aunque el valor real dependerá del Netduino particular que usted tenga) y finalmente  haga clic en «Conectar».
Imagen

Ahora tenemos que ejecutar dos scripts. En primer lugar, seleccione «Inicio desde flash (GPNVM2)» y haga clic en «Ejecutar».
Imagen

Luego tenemos que hacer lo mismo con la opción «Habilitar el acceso de Flash»-script.

Ahora asegúrese  de que estamos en la lengüeta de «Flash». Por «Send File Name», seleccione el archivo «TinyBooterDecompressor.bin» y haga clic en «Enviar Archivo». Este archivo se encuentra en el archivo ZIP Netduino Firmware en el último hilo del foro
Imagen

Entonces nos hará un pregunta sobre  sobre regiones bloqueadas. Haga clic en «No»
Imagen

Después de que podemos cerrar la herramienta SAM-BA  tenemos que  probar si funciona,para lo  cual vuelva a conectar el Netduino y ejecute  MFDeploy.exe. Seleccione USB y el Netduino, a continuación, haga clic en Ping.
Imagen

Ahora ya está listo para grabar el firmware

GRABAR EL FIRMWARE

En primer lugar, ejecutar MFDeploy. Seleccione USB, el Netduino y luego haga clic en «Ping» para verificar que el dispositivo está disponible:

Imagen
Ahora haga clic en «Browse» y seleccione tanto el archivos ER_FLASH ER_CONFIG y. (Mantenga presionada la tecla «Ctrl» para seleccionar el segundo archivo)

Imagen
Cuando se seleccionan dos archivos, haga clic en DEPLOY (Implementar) pudiendo tomar unos 4  o 5 minutos  máximo …
Imagen

Una vez acabados el Deploy ( mensaje  SIGNATURE PASS)  , retire el conector  y vuelva a colocar su Netduino mediante el cable microUSB para completar la operación de flash.

Después de parpadear y reiniciar el Netduino, ahora puede comprobar la versión del firmware actual seleccionando la opción de menú «Target-> Capacidades de dispositivo»
Imagen

Esto seria un ejemplo  de resultado:

HalSystemInfo.halVersion: 4.2.0.0
HalSystemInfo.halVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
HalSystemInfo.oemCode: 34
HalSystemInfo.modelCode: 177
HalSystemInfo.skuCode: 4097
HalSystemInfo.moduleSerialNumber: 00000000000000000000000000000000
HalSystemInfo.systemSerialNumber: 0000000000000000
ClrInfo.clrVersion: 4.2.0.0
ClrInfo.clrVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
ClrInfo.targetFrameworkVersion: 4.2.0.0
SolutionReleaseInfo.solutionVersion: 4.2.0.0
SolutionReleaseInfo.solutionVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
SoftwareVersion.BuildDate: Sep 19 2012
SoftwareVersion.CompilerVersion: 410894
FloatingPoint: True
SourceLevelDebugging: True
ThreadCreateEx: True
LCD.Width: 0
LCD.Height: 0
LCD.BitsPerPixel: 0
AppDomains: True
ExceptionFilters: True
IncrementalDeployment: True
SoftReboot: True
Profiling: False
ProfilingAllocations: False
ProfilingCalls: False
IsUnknown: False

RESTABLECER CONFIGURACION DE RED

 Después de flashear  un Netduino Plus, tendrá que restablecer la configuración de red .
Como ejecuta el firmware 4.2  es necesario mantener pulsado el botón de la placa Netduino  mientras se conecta el USB para poner el dispositivo en modo de arranque.
Ahora, lanzar MFDeploy, que se puede encontrar en el menú Programas del menú Inicio en «Microsoft. NET Micro Framework x», donde x es la versión del marco de su ‘usando. Luego, en el menú Herramientas.
Imagen
Seleccione USB y su Netduino Plus desde el menú despegable.Imagen

Pulse ahora el botón «Ping» para asegurarse de que su Netduino está funcionando correctamente, debería ver algo así como «Haciendo ping … TinyCLR» después de un momento en la mitad inferior de la pantalla.

Imagen

Desde el menú Destino seleccione Configuración, Red

Imagen

Esto abrirá la ventana de configuración de red que contiene todos los valores de red de su Netduino Plus. Desde aquí se puede configurar una dirección IP estática o habilitar DHCP, también puede configurar la dirección MAC y los ajustes de DNS para su Netduino,pero sobre todo restituya el valor de la  direccion MAC  que encontrará en la pegatina de la parte posterior de su placa  Netduino

Imagen

Cambie los ajustes que necesita y pulse Actualizar y configuración Netduino Plus y ‘se actualizará.

!Respire ya ha concluido!

 

Fuente aqui

 

Colorimetro basado en Netduino


En este post  vamos a tratar  de  un original  sensor de color    controlado con  Netduino,Netduino Plus o Netduino Go.

Gracias al sensor de Color de Sparkfun   ADJD-S371-q999 y un Netduino  en este proyectos    se imprimirá el nombre de color HTML (es decir DarkRed) de un objeto que se ve( de hecho esta  aplicacion podria ser particularme  interesante  para las personas  daltónicas , pues basandose en este  sensor, podrian  obtener  un rango de mejora)

He aquí un breve video para demostrar el  fuincionamiento del sensor :

El ADJD-S371 es un 4 canal de sensor RGB + Claro que utiliza el protocolo I2C 2 hilos para comunicar con el microcontrolador. Es un poco complejo  el  dispositivo   pues no se limita a dar el color correcto cuando usted la pida  y necesitaremos  usar el algoritmo de calibración de ganancia,aunque para realizar pruebas sencillas puede utilizar el código descrito en este post

El código fue creado originalmente por Nathan Seidle para el microcontrolador PIC y fue portado y modificado para el Arduino por Marcus de Matter Interactive  y despues  Paul King lo porto en  lenguaje C # para el net Framework Micro..

Haga clic para ampliar
Haga clic para ampliar

El esquema de arriba    muestra el  sencillo circuito con   Netduino,donde  hay que a tener en cuenta, que  se usa un LED externo solo como  fuente de luz  por lo que no hay necesidad de conectar el pin LED en el ADJD-S371-Q999.  En cuanto a los  piuertos  podemos  utilizar cualquiera de las IO pines digitales: sólo tiene que cambiar un poco de código al configurar los puertos de salida. Por último, el LED RGB puede ser conectado a 3.3V o 5V y es posible que tenga que ajustar el tamaño de resistencias para su RGB LED de todos modos.

A continuación   se describe el código en c#   de este demo:

C # Código

1
2
3
4
5
6
using System;
utilizando System.IO.Ports;
using System.Threading;
utilizando Microsoft.SPOT;
utilizando Microsoft.SPOT.Hardware;
utilizando SecretLabs.NETMF.Hardware.Netduino;

Las líneas 1 a 6 definen un espacio de nombres, lo cual permite utilizar las clases o tipos sin tener que escribir el espacio de nombres completo donde existen esos tipos.

Por ejemplo, en lugar de escribir:
SecretLabs . NETMF . Hardware . Netduino . Pins . ONBOARD_LED

Podemos escribir simplemente:
Pins . ONBOARD_LED

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
namespace Squintz. colorímetro
{
Programa clase pública
{
I2C_ADDRESS público static byte = 0x74; / / 7bit
byte static REG_CAP_RED = 0x06;
REG_CAP_GREEN byte static = 0x07;
REG_CAP_BLUE byte static = 0x08;
REG_CAP_CLEAR byte static = 0x09;byte static REG_INT_RED_LO = 0x0A;
REG_INT_RED_HI público static byte = 0x0B;
byte static REG_INT_GREEN_LO = 0x0C;
byte public static REG_INT_GREEN_HI = 0x0D;
byte public static REG_INT_BLUE_LO = 0x0E;
REG_INT_BLUE_HI público static byte = 0x0F;
REG_INT_CLEAR_LO byte static = 0x10;
REG_INT_CLEAR_HI byte static = 0x11;REG_DATA_RED_LO byte static = 0x40;
REG_DATA_RED_HI byte static = 0x41;
REG_DATA_GREEN_LO byte static = 0x42;
REG_DATA_GREEN_HI byte static = 0x43;
REG_DATA_BLUE_LO byte static = 0x44;
REG_DATA_BLUE_HI byte static = 0x45;
REG_DATA_CLEAR_LO byte static = 0x46;
REG_DATA_CLEAR_HI byte static = 0x47;
public static I2CDevice rtc = nueva I2CDevice ( nueva . I2CDevice configuración (I2C_ADDRESS, 100));

byte static [] = readBuffer nuevo byte [1];

Líneas 7 a 33 son constantes definidas en la documentación y sensores de color. Línea 35 crea un nuevo objeto de dispositivo C I 2 llamado rtc. Utilizamos este objeto para enviar realmente los datos de la Netduino al sensor de color. I 2 C es un protocolo de bus que significa que varios dispositivos pueden compartir los mismos cables. Así el objeto I2CDevice nos obliga a darle una dirección de esclavo  para lo cual  se ha definido  como la constante  I2C_Address en la línea 11. El objeto I2CDevice también nos requiere que se especifique un tipo en kilohercios (en este ejemplo se ja usado 100 Khz)

Línea 37 crea una variable de tipo array de bytes  que debe tener en cuenta que solamente estamos inicializando el tamaño de la matriz a 1. El sensor de color no necesita realmente una matriz de bytes, pero el metodo  I2CDevice.CreateReadTransaction requiere una matriz de bytes como uno de sus parámetros y no tiene un método sobrecargado para usar sólo un byte.

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
public static void Main ()
{
OutputPort redpin = nueva OutputPort (pines GPIO_PIN_D10, cierto.);
OutputPort greenpin = nueva OutputPort (pines GPIO_PIN_D9, cierto.);
OutputPort BluePin = nueva OutputPort (pines GPIO_PIN_D7, cierto.);int cc = 0;
int rojo = 0;
int verde = 0;
int azul = 0;int clearGain;
int colorGain;int num_samples;

int i;

while (true)
{
clearGain = getClearGain ();
set_gain (REG_INT_CLEAR_LO, clearGain);
colorGain = getColorGain ();
set_gain (REG_INT_RED_LO, colorGain);
set_gain (REG_INT_GREEN_LO, colorGain);
set_gain (REG_INT_BLUE_LO, colorGain);

num_samples = 10;

for (i = 0; i <num_samples; i + +)
{
. Programa performMeasurement ();
cc + = get_readout (REG_DATA_CLEAR_LO);
rojo + = get_readout (REG_DATA_RED_LO);
verde + = get_readout (REG_DATA_GREEN_LO);
azul + = get_readout (REG_DATA_BLUE_LO);
}
cc / = num_samples;
rojo / = num_samples;
verde / = num_samples;
azules / = num_samples;

. redpin Escriba (false);
. greenpin Escriba (false);
. BluePin Escriba (false);

if (red> verde && red> blue)
. redpin Escriba (true);
más
if (verde> rojo && verde> azul)
. greenpin Escriba (true);
más
if (azul> rojo && azul> verde)
. BluePin Escriba (true);

. Depuración de impresión («C:» + (byte) (cc >> 2) + «» + «R:» + (byte) (rojo >> 2) + «» + «G:» + (byte) (verde >> 2) + «» + «B» + (byte) (azul >> 2));
. Thread Sleep (500);
}
}

Líneas 38 es el principal punto de entrada para nuestro programa. En las líneas 40 a 42 definen  que 3 puertos de I/O estamos utilizando para controlar un LED RGB. Al añadir el SecretLabs.NETMF.Hardware.Netduino.dll a nuestra lista de recursos y declarándola con la instrucción using de la línea 6 que no tenemos que recordar los números de pin microcontroladores reales. SecretLabs ya ha visto todo esto para nosotros y que nos permitirá usar Pins.xxxxx.(de hecho  con la función completa de código alias intellisense de Visual Studio automáticamente aparece un menú contextual que le permite seleccionar de una lista de pines disponibles).

[* ACTUALIZACIÓN:. Si utiliza el instalador del  SDK SecretLabs  puede iniciar una nueva «Aplicación Netduino», que elimina la necesidad de añadir manualmente las dll a su lista de recursos y también elimina la necesidad de añadir manualmente los SecretLabs usando declaraciones]

En la línea 56 creamos un bucle infinito de modo que nuestro programa no se acaba nunca. Sin este nuestro programa sólo se ejecutará una vez y luego terminaria.

Líneas 58 y 64 es donde se puede ser creativo. La hoja de datos de sensores de color y nota de aplicación son un poco borroso en la explicación de la manera adecuada para calibrar y ajustar la ganancia de su sensor. Sin embargo, se debe establecer la ganancia de cada color antes de que usted solicite el color pues de NO ajustar la ganancia solo  recibiría resultados bajos.

Líneas 65 a la 78 es donde nos muestra los colores mediante el uso de unos métodos de ayuda que usted va a leer a continuación. La clave a destacar aquí es que cuantas más muestras se toma  más estable aparecerán sus números. En este caso se toman  muestras de 10 y se suman los resultados juntos y se dividen por 10 para obtener el valor medio.

Líneas 80 a 93 es donde establecemos el color de nuestra RGB LED. El algoritmo usado es  muy simple para determinar el color más dominan y encender sólo el pin  del LED RGB via experimental

En la línea 95 que llamamos Debug.Print e imprimir los valores de la ventana de resultados de Visual Studios. El valor claro indica una intensidad de luz general que los valores Azul Rojo, Verde, y son la intensidad, como se ve a través de un filtro de luz.

99
100
101
102
public static void performMeasurement ()
{
set_register (0x00, 0x01); / / inicio de detección
}

Ahora empezamos a conseguir profundamente en el protocolo de sensores de color. Para decir el sensor de color para tomar una muestra fijamos el registro 0 × 00 con el valor de 0 × 01. El sensor de color a continuación,  toma una muestra y la almacena.

103
104
105
106
static int get_readout (readRegister byte)
{
volver read_register (readRegister) + (read_register ((byte) (readRegister + 0x01)) << 8);
}

El sensor de color almacena sus valores de color en dos registros de 8 bits. Así. en las líneas 103 a 106, get_readout () toma el primer registro como parámetro y asume el siguiente registro está a sólo 1 más direcciones por encima de ese registro. Así leemos el valor del primer registro y luego leemos el valor del segundo registro y luego cambiamos el valor del segundo registro de 8 bits a la izquierda que nos deja con el pleno entero de 16 bits. Sin embargo, sólo 10 bits se ponen realmente en el entero debido a que los altos registros sólo devuelven los dos bits menos significativos y el bajo registro devuelve 7 Bits.

107
108
109
110
111
112
113
114
115
116
117
public static void set_gain (gainRegister byte, int ganancia)
{
if (ganancia <4,096)
{
byte hi = (byte) (ganancia >> 8);
lo = byte (byte) (ganancia);set_register (gainRegister, lo);
set_register ((byte) (gainRegister + 1), hi);
}
}

Cada color tiene dos de sus propios registros de ganancia. Definimos estos en nuestros constantes en las primeras líneas. Aquí  suponemos que ya que sabemos la dirección del registro del registro inferior, por lo que sólo podemos añadir 1 a la dirección para obtener la dirección del registro superior. Luego asignamos los valores de ganancia a través de la ayuda de set_register ().

118
119
120
121
122
123
124
125
126
public static void set_register (byte r, byte v)
{rtc. Ejecutar ( nueva I2CDevice. I2CTransaction []
{
I2CDevice. CreateWriteTransaction ( nuevo byte [] {r, v})}, 5000);
}

set_register es donde sucede la magia. Aquí creamos una nueva matriz de bytes que contiene dos valores. La primera es r para el registro y el segundo es v por valor. Transmitimos esta matriz de bytes a un nuevo objeto I2CDevice.CreateWriteTransaction y luego pasamos ese objeto con el método rtc.Execute. Usted debe recordar que rtc es nuestro objeto I2CDevice que sabe acerca de la dirección del esclavo de nuestro sensor de color. Así, en pocas palabras nuestra función set_register es donde empaquetamos todo y lo enviamos en su camino.

127
128
129
130
131
132
133
134
135
136
read_register público static byte (byte r)
{
rtc. Ejecutar ( nueva I2CDevice. I2CTransaction [] {
I2CDevice. CreateWriteTransaction ( nuevo byte [] {r})
,
I2CDevice. CreateReadTransaction (readBuffer)
}, 5000);volver readBuffer [0];
}

En líneas 127 a 136  estamos enviando una solicitud de nuestros valores de color. Nos pasamos ‘r’, que es el color que queremos leer. Recuerde que esto ocurre dos veces para cada color con el fin de obtener el valor total. Esperamos 5.000 milisegundos o 5 segundos para que el regreso antes de tiempo de espera.

137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
public static int getClearGain ()
{
int gainFound = 0;
int upperBox = 4,096;
int lowerBox = 0;
int media = 0;
int halfValue;mientras que (gainFound == 0)
{
media = ((upperBox – lowerBox) / 2) + lowerBox;
/ / Possbile no más lejos Halfing
if (media == lowerBox)
{
gainFound = 1;
}
más
{
set_gain (REG_INT_CLEAR_LO, medio);
performMeasurement ();
halfValue = get_readout (REG_DATA_CLEAR_LO);si (halfValue> 1000)
{
upperBox = medio;
}
else if (halfValue <1,000)
{
lowerBox = medio;
}
más
{
gainFound = 1;
}
}
}
devolver la mitad;
}

Líneas 137-174 es donde usted puede volver a probar  para perfeccionar sus resultados. Usted tendrá que obtener una forma de obtener un valor de ganancia que compensa la luz ambiental y todos los demás factores ambientales que pueden cambiar la sensibilidad.

175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
public static int getColorGain ()
{
int gainFound = 0;
int upperBox = 4,096;
int lowerBox = 0;
int media = 0;
int halfValue;mientras que (gainFound == 0)
{
media = ((upperBox – lowerBox) / 2) + lowerBox;
/ / Possbile no más lejos Halfing
if (media == lowerBox)
{
gainFound = 1;
}
más
{
set_gain (REG_INT_RED_LO, medio);
set_gain (REG_INT_GREEN_LO, medio);
set_gain (REG_INT_BLUE_LO, medio);
performMeasurement ();
halfValue = 0;halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_RED_LO))..;
halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_GREEN_LO))..;
halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_BLUE_LO))..;si (halfValue> 1000)
{
upperBox = medio;
}
else if (halfValue <1,000)
{
lowerBox = medio;
}
más
{
gainFound = 1;
}
}
}
devolver la mitad;
}
}
}

Por último, las líneas 175-220 intenta establecer una ganancia adecuada para cada color. Esto será llamado 3 veces porque cada color tiene una sensibilidad diferente. Usted puede ser creativo aquí y venir con su propio algoritmo que se adapte a su aplicación específica. Si usted tuviera un ambiente controlado, en teoría, esto sería muy simple.

Fuente aqui

 

Receptor ultrasonico para Netduino


El circuito receptor de ultrasonidos que se presenta en este post , es el encargado de recibir y amplificar la señal  enviada por el circuito de transmisión,(explicado en este blog en un post anterior)  para  ser  posteriormente procesada  por Netduino   por ejemplo para medir tiempos de demora en cruzar una distancia franqueada por dos transmisores y receptores ,medir distancias o  simplemente detectar obstáculos.

Para  realizar este propósito este circuito consta de cuatro partes:

  • Un circuito amplificador de dos etapas
  • Un rectificador  e media onda identificada como circuito de detección
  • Un detector de señal formada por un  comparador de la señal ingresada con un nivel de voltaje determinado
  • Un circuito aislador de señal.

Para el cálculo de la función de transferencia a la salida del circuito amplificador, es
factible dividir el circuito, debido a que se tiene la misma configuración tanto en la
primera como en la segunda etapa,utilizándose  ademas  el principio del cortocircuito virtual, en el que tenemos que el voltaje al terminal positivo del amplificador, es igual al voltaje del terminal negativo del amplificador.

Con estos criterios  la tensión de salida del primer Amplificador Operaconial configurado en modo inversor es :

V2 = (( Vp RC ( RD + RA )) / ( ( RB + RC ) RA )) – ( V1 RD / RA )

La señal de ultrasonido recibida por el sensor receptor es amplificada mil veces, con el amplificador operacional en dos etapas. Esto es cien veces en la primera etapa y diez veces más en la segunda.

Este circuito trabaja con una única fuente de alimentación de + 9 v. Es por esta razón que a la entrada positiva del amplificador, se tiene un partidor de tensión con la finalidad de tener un nuevo nivel de voltaje de referencia, este nuevo nivel de referencia, tiene como objetivo principal, que tanto la parte positiva, como la parte negativa de la onda recibida sean igualmente amplificadas. Cosa que no seria posible si el nivel de referencia seria de 0v por poseer este amplificador una sola fuente de alimentación.

El circuito de detección diseñado tiene como objetivo principal el rectificar la señal ultrasónica recibida mediante una rectificación de media onda, la misma que usa la barrera de diodos Shottky debido a sus buenas características de recuperación inversa.
Este voltaje rectificado será utilizado en el circuito detector de señal.

El amplificador operacional internamente tiene cientos o miles de micro factores, de tal forma que cuando la entrada positiva, se hace un poco mayor que la entrada negativa, la diferencia es cientos o miles de veces amplificada y el voltaje a la salida llega a ser la misma que la tensión suministrada. En el caso contrario, cuando la entrada positiva se hace un poco menor a la entrada negativa, la diferencia es cientos o miles de veces
amplificada y el voltaje a la salida se hace casi cero.
En este circuito, la salida del circuito de detección esta conectada con la entrada positiva
del detector de señal. Mientras que a la entrada negativa se tiene un voltaje constante,siendo este el voltaje de referencia para la comparación de señales.

Sustituyendo los valores propuestos obtenemos :

Vrf = (Rb * Vcc) / (Ra + Rb)
Vrf = (47 x 103 * 9) / (1 x 10 6 + 47 x 10 3 )
Vrf = 0.4 v Voltaje de Referencia

De esta forma, tenemos que cuando la señal ultrasónica rectificada sea mayor a 0.4 v, la
salida del detector de señal tendrá un valor máximo, aproximadamente de 9 v

Por ultimo queda el circuito aislador  de señal, el cual es el encargado de aislar el circuito receptor de la señal lógica que será enviada al microprocesador en el instante que exista un retorno de la señal ultrasónica enviada por el circuito transmisor.
Para este cometdio  se emplea un optotransistor de manera que evitemos el ingreso de ruidos que podrían alterar el correcto funcionamiento del circuito, la señal lógica enviada hacia el microprocesador es de + 5 Vcc.

A continuación el esquema eléctrico del circuito propuesto:

receptor ultrasonidos