¿Qué es NETMF?


NETMF es una plataforma de código abierto, que se convirtió en un proyecto de colaboración de código abierto allá  por  el año 2009, cuya principal virtud es  ampliar  el potencial y la capacidad de adaptación de .NET para el mundo de los dispositivos integrados de modo que programadores de escritorio , también pueden crear aplicaciones que se ejecuten en una amplia gama de sistemas de pequeños dispositivos, como mandos a distancia,  PCs ,servidores en la nube ,etc    todos ellos usando el mismo modelo de programación y herramientas comunes. Así de  este modo ,desarrolladores de sistemas integrados pueden aprovechar las ventajas  de lenguajes de productividad masiva orientados a escritorio y reducir su tiempo de comercialización.

.NET Micro Framework  pues esta diseñado  pues para dispositivos pequeños y por tanto de recursos limitados ofreciendo un entorno completo e innovador de desarrollo y ejecución que trae la productividad de las herramientas informáticas modernas a esta clase de dispositivos,pudiendo utilizarse para construir dispositivos integrados en dispositivos limitados recursos en un microcontrolador con pocos cientos kilobytes de memoria RAM y almacenamiento  como por ejemplo Netduino del que tantas veces hemos tratado en este blog.

Uno de los punto fuertes  respecto a otras plataformas  Open Hardware como Arduino o Raspberry Pi es que los desarrolladores pueden utilizar sus conocimiento de Visual Studio, C# y .net   para escribir rápidamente aplicaciones integradas sin tener que preocuparse por las complejidades de cada microcontrolador, asi que cualquier desarrollador puede comprarse  una placa  compatible con .net, conectar la placa a su equipo de desarrollo con Visual Studio y comenzar a escribir aplicaciones para dispositivos físicos  no  necesitando por tanto amplios conocimientos de diseño de hardware  para empezar a escribir código para dispositivos físicos.

Las  ventajas de NETMF pues son las siguientes:

  • Mejores herramientas  y experiencia para los desarrolladores : al utilizar  tecnologías existentes (c#.net )  y entornos de desarrollo profesionales es evidente que  la experiencia de uso es mucho  mejor que en otros entornos de  desarrollo para crear micro dispositivos inteligentes de depuración.
  • Prototipado rápido :dar vida a sus ideas en horas es fácil (en lugar de días o semanas con otras plataformas) usando por ejemplo los módulos de . net Gadgeteer. Por tanto es una vía rápida y fácil de desarrollar sus invenciones para mostrar a la gente sus diseños creativos.
  • Aprovechamiento de . net y C# : puede usar su  base de conocimientos que ya tenga de C# y. net para hacer dispositivos frescos e innovadoras.

 

Desde el punto de vista del desarrollador ,  trabajar con NETMF tiene dos caras : portarlo al hardware  o  utilizarlo para controlar su hardware . Portarlo  requiere costo considerable , mucho tiempo y mucha experiencia . Una vez hecho esto , podrá usar  NETMF  casi sin esfuerzo .

Usando criterios de calidad y fiabilidad como  directrices principales, otras empresas  como Secrets Labs o GHI  han  enriquecido aún más NETMF con características de valor añadido tales como WiFi, USB servidor y base de datos, lo cual se traduce en soluciones  de bajo riesgo de abandono a un costo mínimo.

benefits

En cuanto al hardware  existen  dos partners de  .NET Micro como son  GHI Electronics y  Secret Labs.

placas

Características fundamentales

NETMF está lleno de características propias de  cualquier lenguaje  moderno,como el soporte de  las siguientes estructuras  y facilidades como son :

  • Arrays
  • Classes
  • Collections — ArrayList, Dictionary, Stack, Queue
  • Cryptography — Encrypting/decrypting, hashing, SSL
  • Displays
  • Dynamic memory management with GC
  • Exceptions
  • File I/O — Files, directories and various storage types.
  • Globalization
  • Graphics — Bitmap, GIF, JPEG, Windows Presentation Foundation (WPF), fonts, touch and gestures.
  • Numerics
  • Power Management
  • Reflection
  • Hardware — Analog Input/Output, Digital Input/Output, I2C, Interrupts, OneWire, PWM, SPI, UART (Serial Port)
  • Math helpers
  • Namespaces
  • Networking — DHCP. DNS. HTTP. Sockets. TCP. UDP. Wireless
  • Runtime Debugging
  • Serialization
  • Strings
  • Text Encoding/Decoding
  • Threading, Events, Delegates, and Timers
  • Time keeping
  • USB Client
  • XML
  • Resources

Hay empresas  como GHI , que ademas construyen sobre las características principales del NETMF anteriormente citadas , extensiones adicionales de valor añadido como pueden ser las siguientes:

  • Configuración de la pantalla y el logotipo de la puesta en marcha
  • E / S – CAN, captura de la señal, generador de señales, I2C Software, USB de almacenamiento masivo
  • En-Campo de actualización
  • PPP
  • Reloj en tiempo real
  • Registro Acceso
  • RLP para cargar código nativo (c / montaje) para los propósitos de velocidad y en tiempo real.
  • Base de datos SQLite
  • USB Client – joystick, teclado, almacenamiento masivo, Ratón
  • USB Host – joystick, teclado, almacenamiento masivo, ratón, USB-Serial, Webcam
  • Perro guardián

.NET Gadgeteer se construye en la parte superior de NETMF para proporcionar una plataforma de desarrollo rápido utilizando placas base y módulos plug-and-play  como sensores .

Supongamos que queremos por ejemplo  hacer una aplicación de registrador de temperatura,  esto requiere una placa base, módulo de tarjeta SD y un  módulo de temperatura. En cuanto al software, ademas también se necesitan  controladores necesarios .

Si contamos  con el hardware ya  preconstruido  y los controladores para estos se incluyen, en el desarrollo de  la nueva aplicación  se reducen significativamente el tiempo de desarrollo.

.NET Gadgeteer es un estándar mantenido por Microsoft para la normalización de las conexiones entre las placas base y módulos. GHI fue  elegido para ser el primer proveedor en ofrecer una tarjeta de .NET Gadgeteer, el FEZ araña. El ecosistema continúa creciendo con más placas base y módulos.

 

Diseñador

Usando el diseñador de .NET Gadgeteer es simple y acelera su diseño.En la pantalla de diseño, se abre la caja de herramientas, arrastrado y soltando los componentes deseados.Haciendo clic y seleccionando «Conectar todos los módulos»  habrá terminado la configuración inicial.

Este proceso  incluye automáticamente todos los archivos DLL necesarios y genera una variable para alcance de cada componente  que le permite centrarse en la escritura de la funcionalidad principal de su diseño sin tener que escribir todo desde el principio ahorrándole tiempo y recursos valiosos.

IntelliSense

Visual Studio de Microsoft incluye una característica denominada IntelliSense. A medida que escribe  su código , IntelliSense entiende lo que podría estar tratando de escribir y muestra cuadros con sugerencias. Es por eso que se envian productos .NET Gadgeteer sin ningún tipo de manuales de programación.

Imaginemos  que esta utilizando un módulo de la cámara:todo lo que necesita hacer es escribir la palabra «rfidReader» y  golpe  el teclado para ver una lista de los métodos admitidos disponibles en los controladores incluidos.

Gadgeteer vs  Arduino Phidgets

¿Cómo se compara Gadgeteer contra otras plataformas de desarrollo?,Si esta interesado puede echar un vistazo  al siguiente vídeo que compara parpadear un LED, el control de un servo con un potenciómetro y un podómetro que muestra los pasos en una matriz de LED todo ello comparando varias plataformas.

 

Fuente   aqui

Anuncio publicitario

Envio de tweets con Netduino 3


En 2011, el autor misenhower  publicó   una biblioteca de cliente de la API OAuth de Twitter para Micro net llamado MicroTweet que  permitía enviar tweets  usando una placa Netduino Plus y Netduino 2 Plus.Han pasado ya  más 5  años  y desde luego el API v1.0 de  Twitter  ha quedada  obsoleta 8   (y desactivada)  a partir de que  Twitter comenzara a aplicar el uso de conexiones de SSL a extremos de acceso al API , lo cual significa que la biblioteca original de MicroTweet no ha sido funcional durante mucho tiempo..

Después de la aparición de Netduino 3  , que ha  incorporado entre  su  muchas nuevas características soporte SSL, el autor  ha visto  interesante revisar esta biblioteca  actualizandola con nuevos requerimientos de API de Twitter. El resultado es MicroTweet 2, cuyo código  ya está disponible  en GitHub ,  y también como un paquete binario de NuGet.

MicroTweet 2 es pues una reescritura completa de la biblioteca original contando  con varias características nuevas útiles para proyectos NETMF . Como requisitos  necesita  NETMF v4.3 , así como una placa  que soporte SSL.

Algunas de las características diferenciadoras  respecto  a la versión anterior son las siguientes

  • Se usa  la clase HttpWebRequest estándar (de System.Http) en lugar de un cliente HTTP a la medida. Esto es en parte debido al nuevo requisito de HTTPS, y en parte porque las más modernas placas  NETMF tiene mucho más espacio de programa que la versión de Netduino Plus .El original Netduino Plus tenía solamente 64 KB de espacio de código disponibles. Ensamblar  System.Http habría exigido más de la mitad de ese espacio, dejando muy poco espacio para el código de usuario. Netduino 3 Wi-Fi cuenta con más de 1.400 KB de espacio de código así como tras  modernas placasNETMF que tienen al menos 384 KB, por lo que ahora es mucho menos preocupante de lo que solía ser.
  • La original biblioteca de MicroTweet podría realmente hacer una cosa: publicar tweets. El autor siempre tenía la intención de añadir más características, pero la memoria limitada de la original Netduino Plus a analizar las respuestas de la API de Twitter lo convertian en una tarea relativamente difícil.El 3 de Netduino tiene significativamente más memoria RAM, por lo que ahora es mucho más fácil de procesar las respuestas recibidas desde Twitter.
  • Todas las respuestas de la API de Twitter se serializan como JSON, así que para 2 de MicroTweet el autor construyó un parser JSON. La aplicación es bastante simple: se toma una matriz de caracteres y va a través de él, analizandocarácter por carácter. Existen otros analizadores JSON para NETMF pero el autor quería construir uno propio para permitir una mayor flexibilidad al añadir cuenta y optimización de rendimiento. En la construcción de esta biblioteca encontró que el Netduino 3 , por decirlo suavemente, no es excesivamente rápido en el análisis de las respuestas JSON(toma alrededor de 4 segundos para analizar una respuesta de 20KB, lo cual es mucho pues  además hay que sumar el tiempo que tarda en recibir la respuesta en primer lugar, que se suma al menos unos segundos más para el tiempo total de procesamiento).
  • La versión anterior de MicroTweet utiliza la bibliotecaMicroLinq .Para MicroTweet 2 se  ha quitado esta dependencia y añadido un método de tipo de inserción sencilla para controlar esta necesidad. Haciendo MicroTweet enteramente autónomo debe ayudar a hacer un poco más fácil mantener actualizado el proyecto.

 

Esta biblioteca como vamos ver puede ser utilizada para registrar y recuperar tweets directamente desde un dispositivo NETMF través de la API de Twitter.

 

 

Para empezar  primero deberá  hacer referencia a la biblioteca de MicroTweet, bien Agregando  el proyecto deMicroTweet a la solución de VS o simplemente instalando la biblioteca a través de NuGet.

Para instalarlo desde NuGet, ejecute el siguiente comando en la consola del administrador de paquetes:

Install-Package MicroTweet

Pueden encontrar instrucciones para usar NuGet y la consola del administrador de paquetes   aqui.
Una vez haga referencia a  MicroTweet assembly  en su aplicación, agregue una  Directiva para el espacio de nombres MicroTweet  en la parte superior del archivo de programa (por ejemplo, Program.cs):
 using MicroTweet;

También, si utiliza DHCP, puede que desee esperar a que una dirección IP para ser adquirida antes de realizar cualquier operación de red, aunque  también puede hacer esto marcando el valor de   IPAddress.GetDefaultLocalAddress()  en el comienzo de su   programa, por ejemplo usando el siguiente código

while (IPAddress.GetDefaultLocalAddress() == IPAddress.Any) 

    Thread.Sleep(50);

 

Ajuste de la hora actual

Es importante destacar  que  las solicitudes de la API de Twitter deben tener un válido timestamp (actual), por  lo que el autor ha incluido  para nuestra comodidad  una clase  SNTP    dentro de la biblioteca MicroTweet para recuperar el tiempo actual de un servidor NTP.

Puede actualizar la hora actual en su placa  puede usar  el código siguiente:

Microsoft.SPOT.Hardware.Utility.SetLocalTime(Sntp.GetCurrentUtcTime());

Inicializando  TwitterClient

Para usar la API de Twitter desde la aplicación usted debe primero registrarlo con Twitter para obtener un conjunto de claves API. Para ello tendrá que ir a la página de gestor de aplicaciones de Twitter para crear una nueva aplicación y obtener las claves necesarias. Usted recibirá dos juegos de llaves: una para la aplicación que creó y otra para su cuenta de usuario acceder a la API a través de la aplicación. Éstas  claves se conocen como las credenciales de la aplicación y las credenciales de usuario.

Puede inicializar una nueva instancia de TwitterClient con un código similar al siguiente:

// Set up application and user credentials
var appCredentials = new OAuthApplicationCredentials()
{
    ConsumerKey = "YOUR_CONSUMER_KEY_HERE",
    ConsumerSecret = "YOUR_CONSUMER_SECRET_HERE",
};
var userCredentials = new OAuthUserCredentials()
{
    AccessToken = "YOUR_ACCESS_TOKEN",
    AccessTokenSecret = "YOUR_ACCESS_TOKEN_SECRET",
};

// Create new Twitter client with these credentials
var twitter = new TwitterClient(appCredentials, userCredentials);

 Enviando  un tweet
Enviando un Tweet uso el método SendTweet para enviar un tweet:

try
{
    var tweet = twitter.SendTweet("Trying out MicroTweet!");
}
catch (Exception e)
{
    // Couldn't send the tweet, the exception may have more information
}

 

Si se recibe un error de API de Twitter, se producirá un TwitterException con más detalles.La propiedad de mensaje de la excepción contiene el mensaje de error real proveniente de Twitter.

 

Recuperar su línea de tiempo inicio

Utilice el método GetHomeTimeline para recuperar los más recientes tweets y retweets, escritos por personas que siguen:

 

try
{
    var tweets = twitter.GetHomeTimeline();
    foreach (Tweet tweet in tweets)
        Debug.Print("Tweet from @" + tweet.User.ScreenName + ": \"" + tweet.Text + "\"");
}
catch (Exception e)
{
    // Couldn't retrieve the timeline, the exception may have more information
}

GetHomeTimeline acepta dos argumentos, sinceID y maxID, para especificar la gama de tweets para recuperar.

Puede utilizar argumentos con nombre para especificar estos valores.

Por ejemplo: var tweets = twitter. GetHomeTimeline(maxID: 603281686600683520);
Recuperar la línea de tiempo de un usuario específico

Utilice el método GetUserTimeline para ver los tweets y retweets publicadas por un usuario específico:

try
{
    var tweets = twitter.GetUserTimeline("twitter");
    foreach (Tweet tweet in tweets)
        Debug.Print("Tweet from @" + tweet.User.ScreenName + ": \"" + tweet.Text + "\"");
}
catch (Exception e)
{
    // Couldn't retrieve the timeline, the exception may have more information
}

De un forma parecida a GetHomeTimeline, puede especificar la gama de tweets para recuperar con sinceID y maxID: var tweets = twitter. GetUserTimeline («twitter», sinceID: 600728701584576512);

Otras clases de TwitterClient

Hay  en esta biblioteca   algunos otros métodos muy útiles:

GetCurrentUser puede utilizarse para verificar las credenciales proporcionadas (claves de API). Si las credenciales son válidas, se devolverá un objeto de usuario con los detalles para el usuario de autenticación.
GetUser recupera la información del usuario con el nombre de usuario especificado o el ID.

Proyecto de muestra

MicroTweet 2 incluye un proyecto de muestra simple que envía un tweet y recupera los últimos tweets de personas que siguen.No hay ninguna funcionalidad de hardware específico en el proyecto de ejemplo incluido, funciona igualmente bien en cualquier junta (o incluso el emulador NETMF).

El autor pensó que sería divertido hacer un proyecto de muestra basado en hardware simple, así que aquí está el reloj de seguidores de Twitter:

Twitter Follower Count

Este proyecto recupera  datos de usuario y muestra su actual cuenta de seguidor en un display de 7 segmentos. Usted podría también, por supuesto, configurar para recuperar el recuento de seguidores de cualquier usuario en Twitter. Aquí está el código para este proyecto.

 

 

 

Fuente aqui

Envio de correo SMTP desde Netduino


Todos sabemos, que Micro Framework no puede tener todas las características de .NET Framework completo. Una cosa que  faltaba es SmtpClient clase que permita el envío de mensajes de correo electrónico utilizandoSimple Mail Transfer Protocol (SMTP). Si nos fijamos en la especificación SMTP encontrará protocolo comuinication muy fácil – es sólo comandos de texto. Comando no, la respuesta Atrás – eso es todo.

Asi  es de fácil puede ser el envío de e-mails de .NET Micro Framework pero  no lamntablemente esta clase no esta disponible para , Net Micro Framework 

 utilizando (SmtpClient smtp = new SmtpClient ("smtp.hostname.net", 25))
 {
     // Enviar mensaje
     smtp.Send ("[email protected]",
               "[email protected]",
               "Buenas noticias",
               "¿Cómo te Foo?");
 }

Esto le  trajo  la idea a Pavel Bánský  de escribir  su propia implementación de la clase SmtpClient para .NET Micro Framework   que ademas  ha decididoser lo más compatible posible con la versión de «escritorio» de System.Net.Mail.SmtpClient clase.

1920px-par_avion_air_mail
«Par avion air mail» by Kristoferb at English Wikipedia. Licensed under CC BY-SA 3.0 via Commons.

 

 

 

Bansky.SPOT.Mail biblioteca de clases

Enviar sencilla correo electrónico mediante SMTP es muy fácil; PERO. Hoy en día la mayor parte del servidor SMTP requiere autenticación. Esto significa, que SmtpClient sin autenticación sería un poco inútil.

En el caso de usar el servidor de correo de terra

SMTP: smtp.terra.com

Puerto 587 o 465 (SSL)

Pero  atención   , no podra usar SSL, por  lo que no olvide  apuntar el puerto 587

Y aquí comienza la diversión. Autenticación SMTP necesita Base64 nombre de usuario y la contraseña codificada. Damned, Base64 no es compatible con Micro Framework. Por lo tanto, la primera tarea es obtener Base64 clase de codificación / decodificación. Una vez que usted pueda codificar datos en Base64, puede codificar los datos de los archivos adjuntos de correo electrónico también. Vamos a implementar System.Net.Mail.Attachment clase. Más funcionalidad necesita el manejo de excepciones más compleja. Ok, agreguela clase  System.Net.Mail.SmtpException .

Después de unos días te despiertas y ves, que ha terminado con la biblioteca de clases completa para el correo electrónico. Eso es cómo se  creo biblioteca de clases Bansky.SPOT.Mail 

Base 64, Autenticación y error en Micro Framework

Cuando el servidor SMTP requiere autenticación, el cliente de sesión de inicio con el comando EHLO domain.com.Servidor responde con métodos compatibles de autenticación. Simplemente dicho, los métodos de las credenciales de codificación. La mayoría de los servidores SMTP soporta método SENCILLOS o entrada o ambos; si no, SmtpClientva a terminar con una excepción. Hay otros métodos de autenticación como CRAM-MD5 y CRAM-SHA1.

Información de autenticación para el método SENCILLOS es esta cadena «usernamepassword» codificado en Base64. El problema es que Micro Framework versión 2.5 (y menos) interpreta «» como un fin de la cadena. Esto significa que la cadena de autenticación SENCILLOS se interpreta como una cadena vacía. Caracteres  después de  «» se ignoran pero esto se puede. En primer lugar debe conviertir  en  serie de «contraseña de usuario» en la matriz de bytes y luego reemplazar los espacios adecuados con el byte 0x00. Tal matriz de bytes es la entrada para el método Base64.Encode ().

Es importante decir que el núcleo de la clase Base 64 se basa en Base64Encoder clase de Timm Martin  y se  he añadido los métodos para dividir los datos codificados en líneas de 76 bytes como es requerido por MIME especificación.

Siguiente código muestra cómo configurar las credenciales de autenticación a clase SmtpClient. Método de autenticación será elegido automáticamente en función de las capacidades del servidor.

 utilizando (SmtpClient smtp = new SmtpClient ("smtp.hostname.net", 25))
 {
     // Crear un mensaje
     MailMessage mensaje = new MailMessage ("[email protected]",
                                           "[email protected]",
                                           "Buenas noticias",
                                           "¿Cómo te Foo?");

     // Authenicate al servidor
     smtp.Authenticate = true;
     smtp.Username = "UserLogin";
     smtp.Password = "userpassword";

     // Enviar mensaje
     smtp.Send (mensaje);
 }

Archivos adjuntos de correo electrónico

Además de los mensajes HTML con formato, la implementación MailMessage soporta archivos adjuntos. Archivo adjunto de e-mail puede ser cualquier dato binario, que se procesan utilizando la codificación Base64 y agregados en mensaje MIME multiparte. Ejemplo de mensaje con archivo adjunto está por debajo.

ADVERTENCIA: codificación de datos binarios en base64 en .NET Micro Framework puede ser extremadamente tiempo y consumo de recursos. Esto significa, que el mayor de los datos es, más tiempo se necesita para procesarla; y si se dice  «más tiempo», es porque  es  realmente mucho tiempo. Por lo tanto, tener cuidado y no se sorprenda.

 MailMessage mensaje = new MailMessage ();
 // Establecer el nombre del remitente y dirección
 message.From = new MailAddress ("[email protected]", "Foo Bar");

 // Destinatarios Set
 message.To.Add (nueva MailAddress ("[email protected]", "John Doe"));
 message.Cc.Add (nueva MailAddress ("[email protected]"));

 message.Subject = "Hola Mundo";
 message.Body = "de ahora en adelante usted puede enviar mensajes de correo electrónico desde <b> .NET Micro Framework </ b>.";
 // Cuerpo Formato como HTML
 message.IsBodyHtml = true;

 // Crear nuevo adjunto y definir su nombre
 Accesorio = nuevo Adjunto ("Snwoflake.gif");        
 attachment.ContentType = "image / gif";
 attachment.TransferEncoding = TransferEncoding.Base64;
 // Contenidos adjuntos
 attachment.Content = Base64.Encode (Resources.GetBytes (
                                     Resources.BinaryResources.Snowflake_gif),
                                     true);

 // Añadir adjunto al mensaje
 message.Attachments.Add (archivo adjunto);

 // Crear instancia SMTP nueva
 SmtpClient smtp = new SmtpClient ("smtp.contoso.com", 25);
 probar
 {
     // Authenicate al servidor
     smtp.Authenticate = true;
     smtp.Username = "UserLogin";
     smtp.Password = "userpassword";

     // Enviar mensaje
     smtp.Send (mensaje);
 }
 capturas (SmtpException e)
 {
     // El manejo de excepciones aquí
     Debug.Print (e.Message);
     Debug.Print ("Código de error:" + e.ErrorCode.ToString ());
 }
 finalmente
 {
     smtp.Dispose ();
 }

Cabeceras adicionales

Cada mensaje de correo contiene cabecera, que especifica la información como la fecha en que se creó el mensaje, el nombre del remitente, etc. Si usted quiere poner información adicional en la cabecera se puede utilizar la propiedadencabezados. Consulte el siguiente ejemplo.

 MailMessage mensaje = new MailMessage ("[email protected]",
                                       "[email protected]",
                                       "Buenas noticias",
                                       "¿Cómo te Foo?");

 message.Headers = "X-Priority: 1 
  ";
 message.Headers + = "X-Microsoft Mail-Prioridad: Alta 
  ";
 message.Headers + = "X-Mailer: Micro Framework mail del remitente 
  ";

Manejo de excepciones

Además excepciones estándar como ArgumentNullException y ArgumentOutOfRangeException, también haySmtpException lanzada por Enviar método de SmtpClient. SmtpException en marco completo contiene propiedadStatusCode, que describe el estado en que se produjo la excepción. Desde mi Enviar método no es tan rico, he reemplazado StatusCode con ErrorCode, que describe la razón de la excepción. La enumeración SmtpErrorCodecontiene valores como BarResponse, AuthFailed, connectionFailed y así sucesivamente.

Demostración y Descarga

Biblioteca completa con las fuentes, documentación y aplicación de la muestra están disponibles para su descarga.Biblioteca fue probado en emulador y Maestro GHI Embedded módulo. Todo el código    el autor  ha  movido el   software al repositorio GitHub.

 

 

 

Fuente

Manejo de pantallas LCD con Netduino


Las pantallas de cristal líquido (LCD) son una gran opción de dispositivo de salida para mostrar caracteres alfanuméricos en tiempo real. También son muy útiles si su proyecto requiere una interfaz de usuario interactiva para la entrada de datos. Además, son de bajo costo, consumen menos energía que las pantallas LED, y le dan un aspecto más profesional a su proyecto.

Gracias a Ebedded Lab , hoy vamos a explorar cómo conectar un LCD personaje basado HD44780 a Netduino para mostrar caracteres alfanuméricos  sin usar las librerías de Crsytal Liquid , que aun siendo muy potentes  y utiles en ocasiones nos pueden dar algún problema .

Para más detalles técnicos del controlador HD44780, por favor lea la hoja de datos, así como su ejemplo de interfaz con chipKIT.

 

Configuración de Circuito y Teoría

La conexión de un LCD  es realmente simple. El LCD funciona en modo de 4 bits, y por lo tanto los pines 7 a 10 (D0-D3) de la pantalla LCD no han sido utilizados. Los cuatro bits de datos más significativos, D4-D7 (pines 12 a 14), recibe datos LCD / comando a través de pasadores Netduino E / S 7, 5, 3 y 1, respectivamente. Del mismo modo, el Registro Select (R / S) y Enable (E) las líneas de señal de la pantalla LCD son impulsados ​​por Netduino pins E / S 11 y 9, respectivamente. Pasadores LCD 1, 2, 3, 4, 15 y 16 están relacionados con la alimentación, ajuste de contraste y pantalla LED de luz de fondo, y están conectados apropiadamente como se muestra a continuación. Para entender cómo funciona LCD, tengo que apuntar a un documento diferente, ya que se explica mejor por allá. En Interconexión un LCD de caracteres, Raj explica acerca de la comunicación en el modo de 4 bits y también habla sobre los fundamentos de controlador HD44780 LCD. Para más detalles técnicos, consulte Hitachi HD44780U (LCD-II) ficha técnica.

Conexión Con Netduino / Netduino Plus

 Programa en # .NET

Hay dos maneras en que podemos mirar el programa, uno de una manera muy sencilla y la otra manera, por supuesto, más difícil.

En forma más simple no nos preocupamos acerca de lo que hay dentro de la clase LCD (o una biblioteca) y no utilizar algunos de los métodos o propiedades expuestas. Echemos un vistazo a las cosas más simples primero:

  //configuracion del LCD compatible con HD44780 de dos lineas
 var lcdProvider = new GpioLiquidCrystalTransferProvider(
 Pins.GPIO_PIN_D8, // RS
 Pins.GPIO_PIN_D9, // enable
 Pins.GPIO_PIN_D10, // d4
 Pins.GPIO_PIN_D11, // d5
 Pins.GPIO_PIN_D12, // d6
 Pins.GPIO_PIN_D13); // d7
 var lcd = new LiquidCrystal(lcdProvider);

lcd.Clear();

 lcd.Begin(16, 2);
 lcd.SetCursorPosition(0, 0);
 lcd.Write("primera linea");// Print a message to the LCD.
 

 lcd.SetCursorPosition(0, 1);

 lcd.Write("segunda linea");

Como se puede ver que hemos creado una instancia de la clase LCD y luego establecemos algunas propiedades de lo que nos gusta y simplemente llamamos al método  Write. Hay dos métodos escribir, uno mostrará el texto de la primera linea y el otro método mostrará la  segunda.

Ahora vamos a profundizar en la parte compleja. Hay varias bibliotecas por ahí, pero yo escribimos mi propia para entender lo que se cuece dentro. Echemos un vistazo a la sección constructor,

 
 /*-------------------------------------------------------------------------------+
|
| Copyright (c) 2012, Embedded-Lab. All Rights Reserved.
|
| Limited permission is hereby granted to reproduce and modify this 
| copyrighted material provided that this notice is retained 
| in its entirety in any such reproduction or modification.
|
| Author: ANir
| First Version Date: 2012/12/27
+-------------------------------------------------------------------------------*/


using System;
using System.Threading;
using Microsoft.SPOT.Hardware;
using System.Text;

namespace EmbeddedLab.NetduinoPlus.Day2.Display
{
 public class LCD
 {
 #region Constructor
 public LCD(Cpu.Pin rs, Cpu.Pin enable,
 Cpu.Pin d4, Cpu.Pin d5, Cpu.Pin d6, Cpu.Pin d7,
 byte columns, Operational lineSize, int numberOfRows, Operational dotSize)
 {
 RS = new OutputPort(rs, false);
 Enable = new OutputPort(enable, false);
 D4 = new OutputPort(d4, false);
 D5 = new OutputPort(d5, false);
 D6 = new OutputPort(d6, false);
 D7 = new OutputPort(d7, false);

 Columns = columns;
 DotSize = (byte)dotSize;
 NumberOfLines = (byte)lineSize;
 NumberOfRows = numberOfRows;

 Initialize();
 }
 #endregion


 #region Public Methods
 public void Show(string text, int delay, bool newLine)
 {
 if (newLine) dirtyColumns = 0;
 foreach (char textChar in text.ToCharArray())
 {
 ResetLines();
 Show(Encoding.UTF8.GetBytes(textChar.ToString()));
 dirtyColumns += 1;
 Thread.Sleep(delay);
 }
 }

 public void Show(string text)
 {
 string[] splitedText = SplitText(text);
 Show(splitedText);
 }


 public void ClearDisplay()
 {
 SendCommand((byte)Command.Clear);
 currentRow = 0;
 dirtyColumns = 0;
 }
 public void GoHome()
 {
 SendCommand((byte)Command.Home);
 currentRow = 0;
 dirtyColumns = 0;
 }
 public void JumpAt(byte column, byte row)
 {
 if (NumberOfLines == (byte)Operational.DoubleLIne) row = (byte)(row % 4);
 else row = (byte)(row % 2);

 SendCommand((byte)((byte)Command.SetDdRam | (byte)(column + rowAddress[row]))); //0 based index
 }

 public void PushContentToLeft()
 {
 SendCommand(0x18 | 0x00);
 }

 public void PushContentToRight()
 {
 SendCommand(0x18 | 0x04);
 }

 #endregion


 #region Private Methods
 private void Initialize()
 {
 //initialize fields
 isVisible = true;
 showCursor = false;
 isBlinking = false;

 rowAddress = new byte[] { 0x00, 0x40, 0x14, 0x54 };
 firstHalfAddress = new byte[] { 0x10, 0x20, 0x40, 0x80 };
 secondHalfAddress = new byte[] { 0x01, 0x02, 0x04, 0x08 };

 currentRow = 0;
 dirtyColumns = 0;

 Thread.Sleep(50); // must wait for a few milliseconds


 // RS to high = data transfer
 // RS to low = command/instruction transfer
 RS.Write(false);

 // Enable provides a clock function to synchronize data transfer
 Enable.Write(false);


 // Set for 4 bit model
 Write(0x03, secondHalfAddress);
 Thread.Sleep(4);
 Write(0x03, secondHalfAddress);
 Thread.Sleep(4);
 Write(0x03, secondHalfAddress);
 Thread.Sleep(150);
 Write(0x02, secondHalfAddress);


 // Set the LCD properties 
 byte operationalValue = (byte)((byte)Operational.FourBit | (byte)NumberOfLines | (byte)DotSize);
 SendCommand((byte)((byte)Command.Operational | operationalValue));

 UpdateDisplayOptions();

 ClearDisplay();

 byte entranceValue = (byte)Entrance.FromLeft | (byte)Entrance.ShiftDecrement;
 SendCommand((byte)((byte)Command.Entrance | entranceValue));

 }

 private string[] SplitText(string str)
 {
 if (str.Length > Columns * NumberOfRows) str = str.Substring(0, Columns * NumberOfRows);

 int stringArrayCounter = 0;
 dirtyColumns = 0;

 char[] charArray = str.ToCharArray();
 int arraySize = (int)System.Math.Ceiling((double)(str.Length + dirtyColumns) / Columns);
 string[] stringArray = new string[arraySize];

 for (int i = 0; i < charArray.Length; i++)
 {
 if (dirtyColumns < Columns)
 {
 stringArray[stringArrayCounter] = stringArray[stringArrayCounter] + charArray[i];
 dirtyColumns += 1;
 }
 else
 {
 dirtyColumns = 1;
 stringArrayCounter += 1;
 stringArray[stringArrayCounter] = stringArray[stringArrayCounter] + charArray[i];
 }
 }
 return stringArray;
 }


 private void ResetLines()
 {
 if (dirtyColumns == 0) return;
 if (dirtyColumns % Columns == 0)
 {
 currentRow += 1;
 JumpAt((byte)0, (byte)(currentRow));
 }
 }

 private void Write(byte[] data)
 {
 foreach (byte value in data)
 {
 Write(value, firstHalfAddress); // First half
 Write(value, secondHalfAddress); // Second half
 }
 }

 private void Write(byte value, byte[] halfAddress)
 {
 D4.Write((value & halfAddress[0]) > 0);
 D5.Write((value & halfAddress[1]) > 0);
 D6.Write((value & halfAddress[2]) > 0);
 D7.Write((value & halfAddress[3]) > 0);

 Enable.Write(true);
 Enable.Write(false);
 //Debug.Print("Wrote " + value.ToString());
 }

 private void SendCommand(byte value)
 {
 RS.Write(false); // command/instruction transfer
 Write(new byte[] { value });

 Thread.Sleep(5);
 }

 private void UpdateDisplayOptions()
 {
 byte command = (byte)Command.DisplayControl;
 command |= isVisible ? (byte)DisplayControl.ScreenOn : (byte)DisplayControl.ScreenOff;
 command |= showCursor ? (byte)DisplayControl.CursorOn : (byte)DisplayControl.CursorOff;
 command |= isBlinking ? (byte)DisplayControl.BlinkBoxOn : (byte)DisplayControl.BlinkBoxOff;

 SendCommand(command);
 }

 private void Show(string[] splitedText)
 {
 foreach (string text in splitedText)
 {
 JumpAt((byte)0, (byte)(currentRow));
 currentRow += 1;

 Show(Encoding.UTF8.GetBytes(text));
 }
 }

 private void Show(byte[] bytes)
 {
 RS.Write(true);
 Write(bytes);
 }

 #endregion

 #region Public Properties

 public bool IsVisible
 {
 get { return isVisible; }
 set { isVisible = value; UpdateDisplayOptions(); }
 }

 public bool IsBlinking
 {
 get { return isBlinking; }
 set { isBlinking = value; UpdateDisplayOptions(); }
 }

 public bool ShowCursor
 {
 get { return showCursor; }
 set { showCursor = value; UpdateDisplayOptions(); }
 }

 #endregion

 #region Fields
 private OutputPort RS;
 private OutputPort Enable;
 private OutputPort D4;
 private OutputPort D5;
 private OutputPort D6;
 private OutputPort D7;
 private byte Columns;
 private byte DotSize;
 private byte NumberOfLines;
 private byte[] rowAddress;
 private byte[] firstHalfAddress;
 private byte[] secondHalfAddress;
 


 private int currentRow;
 private int dirtyColumns;
 private int NumberOfRows;

 private bool isVisible;
 private bool showCursor;
 private bool isBlinking;
 #endregion


 #region Enums
 public enum Command : byte
 {
 Clear = 0x01,
 Home = 0x02,
 Entrance = 0x04,
 DisplayControl = 0x08,
 Move = 0x10,
 Operational = 0x20,
 SetCgRam = 0x40,
 SetDdRam = 0x80
 }

 public enum Entrance : byte
 {
 FromRight = 0x00,
 FromLeft = 0x02,
 ShiftIncrement = 0x01,
 ShiftDecrement = 0x00
 }

 public enum DisplayControl : byte
 {
 ScreenOn = 0x04,
 ScreenOff = 0x00,
 CursorOn = 0x02,
 CursorOff = 0x00,
 BlinkBoxOn = 0x01,
 BlinkBoxOff = 0x00
 }

 public enum Operational : byte
 {
 Dot5x10 = 0x04,
 Dot5x8 = 0x00,
 SingleLine = 0x00,
 DoubleLIne = 0x08,
 FourBit = 0x00
 }
 #endregion
 }
}

En la sección constructor, que básicamente crea cierta Outport, guarda las propiedades de LCD y luego llama al método Initialize. En este método, fijamos las propiedades visuales, inicializar algunas matrices y luego preparar la pantalla LCD para el modo de comunicación de 4 bits.

 private void Initialize()
 {
 //initialize fields
 isVisible = true;
 showCursor = false;
 isBlinking = false;

 rowAddress = new byte[] { 0x00, 0x40, 0x14, 0x54 };
 firstHalfAddress = new byte[] { 0x10, 0x20, 0x40, 0x80 };
 secondHalfAddress = new byte[] { 0x01, 0x02, 0x04, 0x08 };

 currentRow = 0;
 dirtyColumns = 0;

 Thread.Sleep(50); // must wait for a few milliseconds


 // RS to high = data transfer
 // RS to low = command/instruction transfer
 RS.Write(false);

 // Enable provides a clock function to synchronize data transfer
 Enable.Write(false);


 // Set for 4 bit model
 Write(0x03, secondHalfAddress);
 Thread.Sleep(4);
 Write(0x03, secondHalfAddress);
 Thread.Sleep(4);
 Write(0x03, secondHalfAddress);
 Thread.Sleep(150);
 Write(0x02, secondHalfAddress);


 // Set the LCD properties 
 byte operationalValue = (byte)((byte)Operational.FourBit | (byte)NumberOfLines | (byte)DotSize);
 SendCommand((byte)((byte)Command.Operational | operationalValue));

 UpdateDisplayOptions();

 ClearDisplay();

 byte entranceValue = (byte)Entrance.FromLeft | (byte)Entrance.ShiftDecrement;
 SendCommand((byte)((byte)Command.Entrance | entranceValue));

 }

 

Ahora, echemos un vistazo a los métodos que son críticas para mostrar el texto a la pantalla LCD. El primer método Show nos permite mostrar la letra texto dado por carta como se puede ver el bucle está estructurado para cada carácter en el texto dado.

private void Show(string[] splitedText)
 {
 foreach (string text in splitedText)
 {
 JumpAt((byte)0, (byte)(currentRow));
 currentRow += 1;

 Show(Encoding.UTF8.GetBytes(text));
 }
 }

El segundo método Show muestra básicamente todo el texto a la vez, pero antes de que lo haga algún formato para que el texto aparecerá continuamente. Confía en mí mostrando texto dado de una manera continua es uno de lo difícil que resolví en esta clase LCD.

 private void Show(byte[] bytes)
 {
 RS.Write(true);
 Write(bytes);
 }

Por último, el método que escribe información en la pantalla LCD se realiza bajo el método de escritura. El primer método Write llama al método send Escribir pasa el valor de escritura y la dirección donde enviar la información. El segundo método de escritura básicamente escribe la información en la pantalla LCD.

  private void Write(byte value, byte[] halfAddress)
 {
 D4.Write((value & halfAddress[0]) > 0);
 D5.Write((value & halfAddress[1]) > 0);
 D6.Write((value & halfAddress[2]) > 0);
 D7.Write((value & halfAddress[3]) > 0);

 Enable.Write(true);
 Enable.Write(false);
 //Debug.Print("Wrote " + value.ToString());
 }
 

Producción

Después de conectar un par de cables, al ejecutar su código y visualizar el texto que usted quiere, pone una sonrisa en la cara. Dependiendo del método que está utilizando dará a obtener resultados diferentes Show, se mostrará letra por letra y otra mostrará el texto entero de una vez. Al igual que en el video, al girar el potenciómetro, los cambios de contraste de la pantalla.

 

  public static void Main()
 {
 LCD lcd = new LCD(
 Pins.GPIO_PIN_D8, // RS
 Pins.GPIO_PIN_D9, // Enable
 Pins.GPIO_PIN_D10, // D4
 Pins.GPIO_PIN_D11, // D5
 Pins.GPIO_PIN_D12, // D6
 Pins.GPIO_PIN_D13, // D7
 16, // Number of Columns 
 LCD.Operational.DoubleLIne, // LCD Row Format
 1, // Number of Rows in LCD
 LCD.Operational.Dot5x8); // Dot Size of LCD


 lcd.ShowCursor = true;
 lcd.Show("CRN", 200, true);
 Thread.Sleep(5000); // reading time for the viewer
}

 

Descargas

1) Código C # .NET (archivo Solution)

2) archivo Flitizing

 

 

 

Fuente  aqui

MMP: error MMP0000: 0x80131700


No es un error muy descriptivo, ¿verdad? 🙂

Este error  puede  mostrarse  al intentar compilar código  en c# desde Visual Studio 2013 para  desplegarlo sobre Netduino 2 o Netduino 3

 

La posibilidad más probable es que usted tenga  Visual Studio 2010 instalado en su equipo (que utiliza el CLR .NET 4.0), pero no el CLR .NET 2.0 (que el MetaDataProcessor post-procesador para .NET MF 4.1 utiliza al parecer).

Vamos a tratar de una de las dos opciones siguientes primeros:

1. Instalar .NET Framework 3.5 SP1 en el equipo. Esto incluye la última «versión 2.0 de .NET CLR»

2. O crear un archivo MetaDataProcessor.exe.config para forzarlo a utilizar .NET 4.0.

MetaDataProcessor falla con el error anterior durante la construcción del proyecto de .NET Micro Framework en un equipo en el que sólo está instalado .NET Framework 4.0 (por ejemplo, Visual Studio 2012 en una máquina virtual Windows XP Mode limpio). Para solucionar este problema, copie el archivo MetaDataProcessor.exe.config adjunto en un directorio donde se encuentra el archivo .exe (por defecto% ProgramFiles% \ Microsoft .NET Micro Framework \ v4.3 \ Tools); instalar alternativamente .NET Framework 2.0 + (3.5 SP1)

metadata

file attachments

Nueva actualización para Netduino 2plus


En la pagina de Netduino de descargas   ofrecen una actualización  para Netduino 2 Plus,  para pasar del sdk 4.2  a 4.3 , lo cual nos beneficia grandemente, pues entre otras mejoras  se  deberá usar Visual Studio 2013 Express  y por supuesto la versión profesional VS2013 como ambiente de desarrollo para nuestros proyectos.
Algunas otras mejoras contempladas en esta actualizacion:
1. Dirección MAC ahora repoblado automáticamente después de la actualización (de flash de OTP)
2. Modelo universal optimizada «Netduino aplicación» ahora compatible
3. Solución de error: control de flujo COM2 habilitado ahora
4. Solución de error: HTTP clases System.Net ahora comprueban nula durante Deseche

 

Las placas actualizables son las siguientes:

Netduino 2

Netduino2     actualizado a 4.3.2.0

Netduino Plus 2  actualizado  a 4.3.2.1

Netduino go

Netduino Go  actualizada a 4.3.2.0 Beta1

Netduino 3

Netduino 3  actualizado a 4.3.2.2

Netduino 3 Ethernet actualizado a 4.3.2.3

Netduino 3Wifi actualizado a 4.3.2.2

 

 

Pre-requisitos para este firmware
1. Visual 2012 o Visual Studio 2013. O Visual Studio 2015 (beta) Studio.
2. .NET Micro Framework SDK v4.3 qfe2 o más reciente
3. NETMF plug-in para Visual Studio 2012, NETMF plug-in para Visual Studio 2013 o NETMF plug-in para Visual Studio 2015 (beta).
4. Netduino SDK v4.3.2.1 o más reciente

 

 

Para actualizar dichas placas en primer lugar descargaremos el sw desde la página de descargas en la sección de firmware updates  o desde el siguiente enlace de descarga   :

Download Netduino v4.3.2.1 firmware now

netduino

 

Una vez descargado el  fichero zip ,procederemos a descomprimirlo en una carpeta de nuestro equipo

netduion2

 

Como podemos ver el método de actualización es diferente  de los anteriores pues ya no se hace con el mdfeploy sino con la herramienta NetduinoUpdate.

Gracias  a la carpeta firmware que contiene todos los binarios  necesarios   para cada  versión de Netduino compatible,  se actualizará cada placa con su versión de firmware correspondiente..

 

versionesnetduino

 

Pasos siguientes para actualizar  alguna de esas tres placas:

1. Separe su Netduino de su ordenador para apagarlo.
2. Mantenga pulsado el botón de Netduino mientras conectarlo vía USB; esto va a ponerlo en modo de arranque.
3. Ejecute la herramienta Netduino Update (ver enlace más arriba).
a. Si el dispositivo no aparece, instale STDFU drivers + tools v3.0.3.
b. Si el dispositivo aparece como «Dispositivo STM en modo DFU», haga clic en «Opciones», seleccione el tipo de tarjeta de la caja de la selección del producto y cerrar la ventana Opciones.

n2+

options
4. Seleccione la casilla junto a su dispositivo y pulse el botón «Actualizar»
5. Espere a que la operación de actualización completa. Después de parpadear, su Netduino se reiniciará y se eliminará de la lista de actualización.

update
6. Opcional: después de parpadear, establezca la configuración de red utilizando MFDeploy. En MFDeploy, seleccione el destino> Configuración> menú Redes. Vuelva a introducir su configuración de la dirección IP y la dirección MAC.

 

¿Cómo encontrar la versión actual de firmware Netduino ?
1. Vaya al menú Inicio> Programas> Microsoft .NET Micro Framework 4.3
2. MFDeploy Ejecutar.
3. Conecte su Netduino en su PC mediante un cable USB Micro.
4. En la sección de dispositivos en la parte superior, seleccione USB en lugar de en serie. Su Netduino debería aparecer en la lista desplegable; si no, seleccionarlo.
5. Seleccione el menú Destino> opción capacidades del dispositivo.
6. En el cuadro de salida, encontrar el valor «SolutionReleaseInfo.solutionVersion». Esta es la versión del firmware.

 

 

 

 

 

Mas información  aqui

Problemas con Netduino al compilar en Visual Studio


A veces por mucho que lo intentamos no conseguimos desplegar un nuevo software sobre nuestro Netduino ,Netduino plus, Netduino 2  o Netduino 2 plus  obteniendo el  típico error de sin conexión.

El texto del  error es  el siguinte :»An exception ocurred while atenting to launch de debugger» ,es decir referencia a objeto no establecida como instancia de un objeto

 

error netduino

 

Ademas si queremos saber más sobre el error ,esta es la escueta infomación  que nos da Visual Studio

 

error n

Para solucionar este problema, podemos seguir estas indicaciones:

 

  •  Asegurarse de que es reconocido sin errores  el driver de Netduino por el sistema operativo de nuestro PC.
  • Comprobar el acceso con MdfDeploy haciedo un ping al Netduino.
  • Borrar el software cargado   mediante el MdfDeploy.
  • Si persiste el problema activar el modo Debugger  de Visual Studio  en la pestaña  a la derecha de Iniciar (normalmente esta en modo Release).

debug

 

Muy pronto Netduino 3


En los últimos cuatro años y medio juntos, decenas de miles de usuarios hemos construido proyectos increíbles con Netduino, pero  siempre por desgracia  todos nuestros proyectos que  necesitaban conectividad , literalmente necesitaban  un cable de red.

Hoy en este post vamos a hablar de un nuevo Netduino insignia que no usa cables  y con una función de SSL, es decir el  Netduino 3 Wi-Fi, el Netduino inalámbrico de última generación.

n3wbottom-sm.jpg

Aunque puede  que aún necesite en muchos proyecto conectividad ethernet, es cierto que en muchas  otras ocasiones puede que no tenga conectividad  por cable    así que precisamente se ha creado Netduino 3 Wi-Fi para cubrir esa necesidad tan demandada .

Netduino 3 Wi-Fi se basa en las mejores características de la anteriores versiones de Netduino,y además añade un montón de nuevas características.

Éstos son algunos aspectos destacados de lo que es el nuevo y mejorado con Netduino 3 Wi-Fi:

  • Micro: STM32F427VI Rev 3  ,es decir un  nuevo microcontrolador mucho mas potente que el incluido en las anteriores versiones
  • 2 MB de flash de doble banco (el doble que NP2)
  • 256KB de RAM incluyendo 64KB de RAM central acoplada (33% más que NP2), ahora tiene 64 KB más RAM también.
  • Wi-Fi: TI CC3100, 802.11b / g / n (2.4GHz)
  • Soporta redes abierta, WEP y WPA2
  • El soporte integrado para la última seguridad SSL (incluyendo TLS 1.2)
  • Tres puertos GoBus 2.0 (para componentes plug and play)
  • Soporte  incluso de muchos mas  escudos de Arduino (con almohadillas de cabecera ICSP)
  • Nueva pulsador-escudo amigable miniatura
  • Más potencia (mA) a disposición de sus proyectos, la capacidad de apagar los subsistemas que no sean necesarios de forma inteligente y el potencial de todo tipo de nuevos proyectos Netduino.
  • Nuevo subsistema de alimentación de marca y gestión de energía:  alimentación cc desde 12V hasta  5V (idela 9v)  ,pues lo ideal son  tensiones más bajas para mantener el calor hacia abajo ,ya que cualquier cosa por encima de ~ 7.5V es sólo va a conseguir quemar  el LDO).
  • Más de la mitad de todos los componentes son nuevos.

En cuanto al software, Netduino 3 Wi-Fi utiliza una pila de red Netduino.IP híbrido especial (integrado plenamente en el CLR).Sólo tiene que escribir código NETMF regular usando System.Net.Socket, HttpWebRequest, SslStream, etc.

Y, por supuesto Netduino 3 Wi-Fi es impresionante para los proyectos que utilizan Microsoft Azure, por ejemplo  soportando  AMQP.

Esta placa está diseñada con el futuro en mente, y también es ideal para proyectos conectados a Internet de hoy en día.

Netduino 3 Wi-Fi también tendrá firmware actualizable (incluyendo funcionalidad integrada de actualización de firmware para el CC3100) y ganará aún más rica funcionalidad en el tiempo.

Por defecto en realidad asigna el flash como dos secciones 1MB (con 384KB disponibles para el código, como antes). Es un tipo especial de destello del flash de doble llamada del banco que, en teoría, va a recibir una actualización de firmware completa (NETMF, aplicación, etc.) por el aire … y Flash la segunda 1MB con él … y luego reiniciar en la segunda mitad del flash.

En cuanto al nuevo SDK Netduino siguiente sera el  4.3.2  y el IDE recomendado  sera Visual Studio 2013

Para las plantillas … se puede utilizar la aplicación Netduino Plus 2 por ahora. El nuevo SDK incluye un esquema de plantilla simplificado y la nueva plantilla es un super-conjunto de la plantilla Netduino Plus 2.

Por cierto   ,para configurar los ajustes de Wi-Fi, simplemente abrir la red Config de MFDeploy y configurar su SSID y contraseña. WPA2 / PSK se selecciona automáticamente para que usted (y cubre WPA2 también).

Algunos  vínculos  sobre las características  de esta estupenda placa

Fuente   aqui

Solución para el problema «Unable to erase configuration sector memory» con Netduino 2 Plus


Hay una posible solución al error «Unable to erase configuration sector memory»    cuando desde  el  programa MdfDeploy intentamos modificar cualquier  parámetro de red   de nuestro Netduino 2 Plus  ,  accediendo a Target–>Configuation –>Network

error

Después de abrir el programa  mfdeploy  y conectar nuestro  Netduino 2+ al usb de nuestro  ordenador, seleccionar: Plugin> Test> Reboot and Stop   (Reiniciar y Detener)

error2

Hecho esto , sin desenchufar  Netduino 2+  ni cerrar el el programa mdfdeploy   , mágicamente  el propio programa mfdeploy le permitirá configurar los ajustes de red sin dar el error  «Unable to erase configuration sector memory»  , como cabría esperar.

Para  confirmar  que los cambios  se han salvado en nuestro Netduino 2+, podemos  conectar nuevamente este  a la  red y hacer un  ping  y luego para corroborarlo  desconectar y reconectar nuestro N2+, usted   podrá  comprobar como los valores introducidos ya  se almacenan en el dispositivo  sin dar ningún error .

unable2

Estación metereológica basada en Netduino+


En este estupendo proyecto   zmashiah   nos muestra una placa  Netdunio-Plus  usándola para mostrar la información actual y el pronóstico del tiempo en una   pantalla VGA  o  incluso en una pantalla LCD  todo ello  usando  la información de Weather Underground.
El autor    ha publicado recientemente un proyecto similar en el que se utiliza una placa Arduino para mostrar el pronóstico del tiempo por medio del servicio Weather de Google. Este nuevo proyecto es totalmente automático, no requiere configuración, y además incluye arias mejoras en la visualización gráfica (y correcciones de errores).
En el siguinte video podemos verlo en acción:
La salida es gráfica con iconos y con un poco de texto colorido, usando  un código de colores en función de los rangos de temperatura y tiempo. Este proyecto es  uno de esos gadgets que   zmashiah quería tener desde hace algún tiempo , es decir una pantalla de predicción del tiempo que está ahí al igual que el reloj de pared.
Características

  • Identifica automáticamente la ubicación en el mundo
  • Determina automáticamente el horario de verano y la hora local
  • Muestra gráficamente la información actual y previsión del tiempo
  • Sincroniza automáticamente el ahorro de tiempo y la luz del día a través de Internet (utilizando el protocolo NTP)
  • Muestra:
    • Temperatura ,el tiempo, humedad, dirección y velocidad del viento
    • Actual presión barométrica tiempo
    • Tiempo condición texto y el icono
    • Hoy bajas y altas temperaturas
    • Fase de la luna para hoy
    • Salida y puesta del sol para hoy
    • El tiempo para los próximos 3 días, incluyendo:
      • Altas y bajas temperaturas
      • Tiempo condición texto y el icono
      • Humedad
      • Dirección del viento y velocidad
  • No requiere ningún PC de participar, totalmente independiente
  • Fácil de conectar y de reunión, sólo cable Ethernet y fuente de alimentación
  • Soporta DHCP para la conexión a la red
  • Soporta pantallas VGA y pequeñas pantallas 3.2 «

Algunos otras características incluyen el cambio de color de fondo entre la noche (azul oscuro) y el día (azul claro) para el reloj y el cambio de  texto color de fondo de las áreas de datos de tiempo en función de la temperatura (caliente en naranja, normales a la luz azul y frías en azul oscuro ). El ciclo de noche y día son detectados automáticamente por el servicio de Internet de Weather Underground (amanecer y atardecer).

Esta  versión no requiere la configuración de la ciudad en la que se  vive durante tiempo de compilación, y establece el ahorro de forma manual la a luz del día. Aquí todo es automático

.Imagen de la estación meteorológica (metro) con Netduino

En comparación con Google wether  , ofrece características adicionales:

  1. Información Tiempo de hoy incluyendo la presión barométrica
  2. La previsión del tiempo incluye información humedad demasiado para cada día
  3. Tiempo y puesta del sol Sunrise están disponibles para hoy
  4. Información de fase lunar está disponible para hoy
  5. Sustancialmente más iconos en la pantalla y mejorar la visibilidad de la información existente
  6. Soporte para el horario de verano, la ubicación y la hora automática zona
  7. Se muestra Indicadores para la comunicación entre la pantalla y el tablero de acogida

Sin embargo, este proyecto  no puede  medir la temperatura interior y tampoco soporte del sensor de humedad.

Lo componentes que zmashiah  ha usado son los siguientes:
  1.  Netduino Plus ( http://www.sparkfun.com/products/10186 ) ~ $ 60
  2. Pantalla 4D Systems (uLCD-32PT) http://www.sparkfun.com/products/10089o adaptador de pantalla (uVGA II) http://www.sparkfun.com/products/10329~ $ 55 para VGA
  3. Una pantalla VGA en desuso
  4. Cables 5x Jumper (sólo 3 necesarios para el funcionamiento, 5 mientras programa de grabación), tenga el adaptador de pantalla y la pantalla tiene pines machos y Netduino viene con encabezados femeninos, por lo que necesitará un cable de puente que es conector macho en un extremo y conector hembra el otro extremo, como este http://www.ebay.com/itm/Arduino-Solderless-Dupont-Jumper-Wire-AWG-24-Male-Female-Protyping-QTY30-/251028328487?pt=LH_DefaultDomain_0&hash=item3a72745027#ht_1797wt_1393
  5. 2 GB o menos micro-SD (sólo necesita alrededor de 150 KB, así que si usted tiene uno de un teléfono antiguo, puede ser utilizado)
  6. Fuente de alimentación (7.5V o 9V)
  7. Cable Ethernet
  8. Caja para albergar todo el contenido

También para la construcción del aparato, necesitará la siguiente

  1. Tablero FTDI, mejor usar 5Volts uno como este uno.
  2. PC para la programación
  3. Un dispositivo lector de micro-SD
Imagen de Dónde comprar?
Todos los artículos se pueden comprar en Sparkfun o  en su tienda  componentes electrónicos favorita. En cuanto a la pantalla o adaptador de pantalla, vienen pre-cargado con uno de la SGC o GFX tipos de firmware. En realidad, no importa cuál  comprar, pues la conversión de un firmware para el otro es tarea muy sencilla realizada por una herramienta en el PC. Usted sólo necesitará su FTDI y el dispositivo de 4D.
1. Descargar e instalar herramientas
Después de comprar los componentes , descargar el software en su PC, incluyendo:

  1. Herramientas de Sistema 4D para la programación de sus adaptadores o pantallas de aquí
  2. Visual Studio 2010 Express o si tiene un Pro instalado, no hay problema (se puede descargar desde Netduino sitio abajo también)
  3. SDK Netduino de http://netduino.com/downloads/
  4. Microsoft .NET Micro Framework 4.1 de http://netduino.com/downloads /
  5. Registrarse con Weather Underground y generar   una clave 
  6. Modificar una llave en el código Netduino-Plus en la función ‘initlocation‘ en Program.cs archivos para que la línea que dice WeatherData = new WeatherUndergroundData («<< >> yourkey», myLocation.latitude, myLocation.longitude); será cambiado para tener la clave en forma de cadena (entre comillas) en lugar del yourkey.
  7. Registrarse con AskGeo.com y  generar una clave
  8. Actualice su clave AskGeo y cuenta ID en el  fichero NTPThread.cs archivos, buscar // <<< encontrar en qué parte del archivo

2. Cargar el firmware y el software de los dispositivos

  1. Conecte su pantalla 4D o adaptador de pantalla para el FTDI (Vcc a 5V, GND a GND, Rx a Tx y Rx Tx a, DTR en el FTDI restablecer pines) y el FTDI para USB de su PC
  2. Suba el firmware a la derecha en el adaptador de LCD o VGA 4D utilizando herramienta PMMC Loader desde 4D Systems (necesita la versión GFX).   lo ha comprobado con la versión de firmware 2.7
  3. Abra la herramienta Taller sistemas 4D; abrir el archivo de programa en el subdirectorio 4D del archivo ZIP en esta publicación. Siga los pasos como se muestra también en la imagen para que esta herramienta:
    1. Seleccione la pantalla derecha o modelo de adaptador
    2. Seleccione el puerto COM correcto (el que genera el FTDI)
    3. Elige la localidad como «Flash» y no «Ram» (no te olvides de esto!)
    4. Compilar y cargar el programa en la pantalla / adaptord)
  4. Conecte su tablero Netduino Plus a su PC
  5. Herramienta Ejecutar MFDeploy (parte del kit .NETMF y debe estar en C: \ Archivos de programa (x86) \ directorio de Microsoft .NET Micro Framework \ v4.1 \ Tools si está usando Windows 7 de 64 bits PC),
    1. Escoja USB como la conexión de dispositivos
    2. Elija el Netduino Plus
    3. Pulse el Ping para ver el dispositivo está conectado bien y responder
    4. En Target | Configuración | Network set el Netduino-Plus para usar DHCP o IP estática si está utilizando direcciones IP estática en su casa.
  6. Registrarse con AskGeo Servicios (AG) Tiempo-metro (WU) y. Usted debe obtener ID y clave.
  7. Ejecutar Visual Studio y cargar el proyecto para el programa Netduino (En subdirectorio NetduinoPlusWeatherUnderground en el archivo ZIP). Coloca los códigos que obtuvo de WU y AG en el código (búsqueda de los «<<<» marcas). Reconstruir y Desplegar en el tablero.
  8. Cargar la tarjeta micro SD a su lector de tarjetas SD, formato FAT si es necesario
  9. Cargue los iconos del directorio NetduinoPlusWeatherUnderground \ 4DIcons en el archivo ZIP en su tarjeta SD
  10. Extracción segura de la micro-SD del lector y lo coloca en la pantalla o display adaptador
  11. Desconecte la pantalla, el Netduino y el lector de tarjetas SD de su PC.

3. Conexión del hardware juntos
En los siguientes pasos obtendrá su conjunto terminado,

  1. Inserte la tarjeta micro SD para la visualización 4D o al adaptador de pantalla 4D
  2. Conecte la pantalla o adaptador de pantalla a su Netduino Plus (sólo 3 cables requeridos)
    1. Vin o Vcc desde el dispositivo 4D a 5V del tablero Netduino Plus
    2. GND del dispositivo 4D a GND de la junta Netduino Plus
    3. Rx del dispositivo 4D a Digital 3 pines de la placa Netduino Plus
  3. Conecte el Netduino Plus al puerto Ethernet en su router / red
  4. Si está utilizando la tarjeta de adaptador VGA, conecte la pantalla al adaptador 4D
  5. Conecte el suministro eléctrico de su Netduino Plus

 

Imagen ¿Está utilizando Celsius o Fahrenheit?
Este programa muestra la temperatura en grados Celsius. Sin embargo, si usted está usando grados Fahrenheit, se necesitarán ligeras modificaciones en el código:

  1. Edite el archivo de programa de visualización 4GL y cambiar el ShowCelsiusSymbol función y cambiar putStr («C»); a putStr («F»);
  2. Cambiar los umbrales de temperaturas para Hot e indicadores Labial (TEMP_THHOT y TEMP_THCOLD constantes) a lo que crees que es bueno para usted (89 y 68 son los equivalentes de mi configuración Celsius actuales).
  3. Edite el archivo WeatherUnderground.cs y cambie las líneas que recogen las temperaturas Celsius a Fahrenheit uno (temp_c a temp_f etc.) .:
  4. Usted también puede cambiar la información del viento a buscar Millas por hora en lugar de Kilómetro por hora uno
  5. Compilar y cargar los programas a los dispositivos
Imagen ¿Cómo funciona esto?
El Netduino Plus sirve como anfitrión, la conexión a internet, y envía información en el protocolo simple formato de la pantalla 4D (o adaptador de pantalla). La pantalla 4D manipula todas las imágenes en la pantalla.
Pasos de la operación:

  1. Netduino-Plus primeros arrendamientos y dirección IP desde el servidor DHCP
  2. Netduino-Plus va al servicio de internet http://www.geobytes.com/ para averiguar en qué lugar del mundo se encuentra. La salida de este servicio incluye ciudad, país, etc, pero lo que tomamos de ella es la longitud y latitud.
  3. Netduino-Plus va al servicio de internet http://www.askgeo.com/ para averiguar cuál es el desplazamiento de su ubicación con respecto al UTC actual. De esta manera sabemos no sólo su zona horaria, sino también el horario de verano.
  4. Netduino-Plus va al servicio NTP en el Internet para obtener el tiempo atómico precisa y fija el reloj interno Netduino-Plus para esta época junto con el offset nos enteramos antes.
  5. Netduino-Plus va a Tiempo servicio Undergroundhttp://www.wunderground.com/ a buscar información actual y previsión del tiempo.
  6. Netduino-Plus envía los datos del tiempo y el reloj en el dispositivo 4D sobre interfaz serial (UART) utilizando el protocolo simple que voy a omitir la descripción de aquí. Es en el código.
  7. Tiempo de NTP se sincroniza cada 300 minutos (6 horas) que me pareció ser lo suficientemente preciso.
  8. La información meteorológica se descarga cada 10 minutos. Más que suficiente para la mayoría de la gente y de los casos. Actualizaciones más frecuentes de Weather Underground se requieren para ser un usuario pagar.
  9. Tiempo de NetduinoPlus se envía al dispositivo 4D cada 3 minutos (temporizadores Netduino encontraron un poco más preciso que los 4D)
  10. Los formatos de dispositivos 4D datos de flujo de texto que recibió de la Netduino-Plus para gráficos en la pantalla.

Algunas notas:
  le  pareció que  Netduino sería  mejor que Arduino  pues tiene algunos más recursos como la memoria y la CPU más rápida (16MHz en Arduino vs  a 48MHz de Netduino). También logró código  muy atractivo para este tipo de consultas en Internet … pero después supo que se carga el conjunto de analizador genérico XML para el huésped y  se ejecuta fuera de la memoria. Peor que eso, no fue suficiente para agregar las características que quería para la automatización de DST y la ubicación. Decepcionado decidió atenerse a lo que es importante, la automatización y sencillez, y pasar algunas pulsaciones tediosas en analizar XML. El estado de cosas ahora es que el Netduino-Plus está teniendo sus propios desafíos de memoria, y este proyecto encaja bien en y obras, pero hay muy poco espacio para añadir algo más. Así, en comparación con el anterior proyecto con Arduino , en éste no está a la temperatura interior y la humedad. Además, los sensores DHT22 de bajo precio no están apoyados en  Netduino( tampoco  en  .NETMF 4.2 )

El análisis de XML se realiza mediante la lectura de un byte en un momento de la toma de internet. Como este es el código administrado, funciona terriblemente lento. Toma en un  Netduino-Plus unos 19 segundos para analizar la secuencia XML de Weather Underground. Se  podria  optimizarlo para un rendimiento mucho mejor, como el uso de clase Stream y todo, pero ¿adivinen qué? Se queda sin memoria al hacer eso. La verdad del asunto es que podría importar menos si la  CPU de Netduino-Plus  gaste  9 segundos hibernada o procesar  trozos de Weather Underground. No hay da mejor para que haga y aunque quisiera, se deja sin memoriasi hace algo más. Por lo tanto, esos 19 segundos no debería importar mucho a cualquiera.Usted se dará cuenta de que el led de a bordo LED en el Netduino (azul uno frío) se iluminará cuando  hace su análisis de los datos XML.

También el autor ha reutilizado el botón de a bordo en el Netduino-Plus para actuar como «tiempo de sincronización y la información del tiempo ahora» en lugar de reset. Este cambio fue útil para depurar y el autor esta  contento con el reciclaje de energía como de reposición de bienes de todos modos.

Los chicos de Weather Underground realmente hacen cumplir los límites de 500 llamadas diarias o 10 por minuto. Así que es por eso  no esta compartiendo la clave aquí y también usted  debería evitar hacer eso. Ademas ha incluido su logotipo y esas cosas como sus términos de condiciones requieren.

El servicio AskGeo estaba en alfa o beta cuando empezo a usarlo el autor ,pero despues se trasladaron a la nube de Amazon e hicieron ligeras modificaciones en los servicios.   ha actualizado el código en consecuencia, por lo que no debería molestarse con nada de eso. Tenga en cuenta que usted debe registrarse con ellos  también y no debe  compartir su clave pública.

Sobre el «truco» para averiguar la ubicación, no es, sin limitaciones. Debería funcionar en cualquier red en casa, pero en la oficina  podría ser un poco un desafío. Si la red está pasando por un proxy muy remoto, como muchas organizaciones se sigue utilizando para conectar oficinas remotas a Internet, entonces la ubicación del Netduino-Plus es donde se encuentra el servidor proxy . Es bastante fácil de cambiar el código Netduino-Plus para usar ubicación fija en lugar de auto-detección, y    vaa dejar que aquellos que estén interesados ​​lo hacen ellos mismos.

Sugerencia: Todo lo que necesita es el uso fijo longitud y latitud en la función ‘initlocation’ codificado en los Program.cs archivos

Fuente   aqui

Sensores de humo de bajo coste para Arduino o Netduino


Es muy habitual en  nuestros circuitos basados en  Arduino o Netduino usar sensores magnéticos o mecánicos, sensores de luz (fotoeléctricos), sensores de ruido, sensores térmicos  y de humedad ,e incluso sensores de movimiento.

A todo este conjunto  de sensores  sin duda no podíamos olvida un tipo de  sensor   que no esta muy extendido,    pero  que nos puede salvar la vida: en efecto  hablamos  de  los detectores de gases y de humo

Afortunadamente  con la miniaturización  y la espectacular bajada de precios de los componentes , podemos conseguir módulos muy completos   por muy bajo precio    con muchísimas posibilidades   que hasta hace poco  tenúan un coste muy elevado  si   necesitamos detección   compleja de gases  mas allá  de los típicos sensores de  humo basados en interrumpir una barrera de luz infrarroja con el humo

Como ejemplo de un sensor de gases  y humo   avanzado   con alimentación única de 5V DC y  de bajo precio  podemos   destacar   el módulo  SODIAL(R)  basado en el módulo MQ-4,  el cual es un detector de  Humo pero también un detectar de gas  Metano, Propano e   Hidrógeno

sensordehumohumo2

Este detector de medidas mas reducidas de 32X22X27mm   esta basado en el circuito  MQ-4  y   se puede alimentar con 5v  DC   directamente desde la salida  de +5V  de Arduino o Netduino .

Como gran novedad  cuenta  con un modo dual de salida , es decir,por un lado cuenta con una salida de señal analógica  que sera proporcional   a  la señal detectada  (  sensibilidad de nivel TTL)  que de usarla la conectaremos a una entrada analógica de nuestro Arduino  y Netduino  ,y   luego por otro lado una señal  binaria  para indicar presencia de  GLP, el gas, el alcohol, el hidrógeno y mas, que obviamente también conectaremos a una entrada  digital de nuestro Arduino o Nerduino

Gracias a la  miniaturización se consigue una rápida respuesta y recuperación con buena estabilidad y larga vida util. Este tipo de sensores  por tanto es ideal para detección de fugas de gas en casa o fabrica usándose e para la detección de Gas combustible como el GLP, butano, metano, alcohol, propano, hidrógeno, humo, etc.

El circuito cuenta con un led interno que indica presencia de humo y  una resistencia de calibración   que viene ya seleccionada

Veamos  algunos detalle del módulo de sensor MQ-4  que utiliza el módulo de Sodial  descrito

mq4

 

CARACTERÍSTICAS
* Alta sensibilidad a CH4, gas natural.
* Pequeño sensibilidad al alcohol, el humo.
* Respuesta rápida. * Vida estable y de largo * circuito de accionamiento simple
APLICACIÓN
Como hemos visto se utilizan en la detección de fugas de gas equipos en la familia y la industria, son adecuados para la detección de CH4, Natural gas.LNG, evitar el ruido de los vapores de alcohol y de cocina y el humo del cigarrillo.

features mq4

Estructura  y configuración de MQ-4 sensor de gas se muestra como la figura. 1 (configuración A o B), sensor compuesto por tubo de cerámica micro AL2O3, Estaño Dióxido (SnO2) capa sensible, electrodo de medición y el calentador se fijan en un corteza hecha por red de acero de plástico y acero. El calentador ofrece condiciones de trabajo necesarias para el trabajo de componentes sensibles.

El MQ-4 envuelto tienen 6 pines, 4 de ellos se utilizan  para  buscar señales y otros 2 se utilizan para proporcionar corriente de calentamiento.
Circuito de medición de parámetros eléctricos se muestra como la figura 2
E. Sensibilidad curva característica

graf1

Fig.3 se muestra el típico características de sensibilidad de el MQ-4 para varios gases en su: Temp: 20 ℃,Humedad: 65%,Concentración de O2 del 21%,RL = 20kΩ,Ro: resistencia del sensor a 1000 ppm de CH4 en el aire limpio.R: resistencia del sensor en varios  concentraciones de gases.

Fig.4 se muestra la dependencia típica de el MQ-4 de la temperatura y la humedad.Ro: resistencia del sensor a 1000 ppm de CH4 en el aire al 33% de humedad relativa y 20 grados.R: resistencia del sensor a 1000 ppm de CH4 en el aire a diferentes temperaturas y humedades.

AJUSTE SENSIVIDAD
Valor de resistencia de MQ-4 es la diferencia a varios tipos y diversos gases de concentración. Así que, cuando se utiliza  este ajuste componentes, la sensibilidad es muy necesario. le recomendamos que calibre el detector para 5000 ppm de concentración de CH4 en valor el aire y el uso de la resistencia de carga (RL) sobre 20KΩ (10k a 47KΩ).
Al medir con precisión, el punto de alarma adecuado para el detector de gas debe ser determinada después  teniendo en cuenta la temperatura y la humedad influencia.

Por cierto este módulo completo  se puede  comprar en Amazon  SODIAL(R) MQ-4 Humo DC5V Metano Propano Gas Hidrogeno modulo del detector del sensor de Arduino

Un modulo wifi para Arduino


Con  el mini  módulo  ESP8266-EVB ESP8266 Xtensa LX106 Internet de los objetos del sistema completo incluye MOD-WIFI-ESP8266-DEV  que se puede comprar en Amazon  por unos 14 € , con unas medidas de 17 x 13 x 2 cm,  en efecto es posible dotar conectividad wifi a una placa  Arduino pues  se ofrece soporte oficial  éste en el IDE de Arduino 1.0.6.

 

ESP8266.jpg

 

 

Cuando el dispositivo está montado, y como la única aplicación del procesador de la aplicación, la memoria flash se puede iniciar directamente a partir de un movimiento externo. Además la memoria caché incorporada ayudará a mejorar el rendimiento del sistema y reducir los requisitos de memoria.

La aplicación típica de este módulo es cuando puede asumir la tarea de adaptador Wi-FI para el acceso a Internet inalámbrico  agregándolo  a cualquier diseño basado en micro-controlador (como por ejemplo Arduino o  Netduino )  por medio de una  conexión simple, sólo por SPI interfaz / SDIO o procesador central interfaz puente AHB.

El procesamiento y la capacidad de almacenamiento del  ESP8266 es interesante   pues, se pueden integrar a través de sensores de puertos GPIO y otras aplicaciones de equipos específicos para lograr el más bajo temprano en el desarrollo y operación de al menos ocupar recursos del sistema.

Esta placa  tiene todo los elementos integrados  incluyendo la antena balun interruptor, convertidor de la administración de energía, por lo que con la charcutería externa mínima, e incluye módulo de front-end, incluyendo la totalidad de la solución diseñada para minimizar el espacio ocupado por PCB.

Algunas características de este modulo son  el ahorro de energía, capacidad  VoIP ,poder cambiar rápidamente entre los patrones de sueño / vigilia, sistemas de operación de baja potencia de polarización radio adaptable, funciones de procesamiento de señales de front-end, solución de problemas y radio ,protección interferencias  con LCD LVDS DDR.

En el siguiente video podemos ver este módulo conectado a una placa Arduino

 

En  el  vídeo por cierto  se muestra cómo podemos realizar llamadas y enviar mensajes SMS utilizando su conexión Wifi. Por supuesto el módulo de por sí no tiene capacidad para hacerlo, pero puede conectarse a servicios como Twilio que ofrecen una completa API para eso y a precios muy competitivos.

Algunas características del módulo:

  • 802.11 b / g / n
  • Wi-Fi Direct (P2P), soft-AP
  • Construido en la pila de protocolos TCP / IP
  • Incorporado en el interruptor TR, balun, LNA, amplificador de potencia y red de adaptación
  • Incorporado PLL, componentes de administración de energía del regulador de tensión
  • Modo 802.11b + potencia de salida 19.5dBm
  • Sensor de temperatura
  • Soporte de antena de diversidad
  • fuera de la corriente de fuga es menor que 10uA
  • Built-in de baja potencia 32-bit CPU: se puede doblar como un procesador de aplicaciones
  • SDIO 2.0, SPI, UART
  • STBC, MIMO 1×1, 2×1 MIMO
  • A-MPDU, A-MSDU agregación y el 0.4
  • Dentro de estela 2ms, conectar y transferencia de paquetes de datos el consumo de energía de reserva de menos de 1.0mW (DTIM3)

Enlace al foro  de ESP8266  aqui

 

Ejemplo de manejo de un display LCD con Netduino


Si desea mostrar una mejor  presentación  superior a hacer  parpadear  LED’s, un módulo LCD es una buena opción dado que es muy fácil  de   programar, y por lo general, también  muy  asequible.

Los LCD’s vienen en diferentes tamaños siendo los mas normales son de 2 filas numéricos ( es decir sólo dígitos) , pero también son frecuentes  recientemente los módulos de  40×4  de matriz de puntos alfanuméricas.  También existen LCD gráficos, que van desde módulos con resoluciones pequeñas (por ejemplo, 122×32 o 240×128 píxeles) a más profesionales pantallas LCD (por ejemplo, 5 «o 7»)

En este post vamos  a usar simplemente LCD alfanuméricos , los  cuales en su mayoría  se construyen alrededor del  famoso  chip de Hitachi  ,  HD44780 o controlador compatible, dado    que lo habitual es que   todos ellos utilizan la misma interfaz.

LCD alfanuméricos se controlan mediante un puerto paralelo de 8 bits, y algunos hilos mas para control (que controlan la transferencia de datos a través del puerto paralelo), pines para controlar el contraste y luz de fondo (si  le quedan puertos disponibles), y  por supuesto ,  los dos hilos para alimentación y tierra.

En la siguinte tabla podemos ver un ejemplo de configuracion para controlar un display  LCD,  con los bit de  salida completos:

 

LCD Pin Number Symbol Netduino Pin Description
1 VSS GND Ground
2 VDD 5V Logic voltage
3 V0 10K Pot Leg 2 op voltage for LCD. Controls color/contrast
4 RS D12 Register selector
5 R/W GND Low means write, so you can just ground it
6 E D11 Chip enable
7 DB0 D9 Data Bit 0
8 DB1 D8 Data Bit 1
9 DB2 D7 Data Bit 2
10 DB3 D6 Data Bit 3
11 DB4 D5 Data Bit 4
12 DB5 D4 Data Bit 5
13 DB6 D3 Data Bit 6
14 DB7 D2 Data Bit 7
15 LED(+) Resistor to 5V Backlight LED Anode
16 LED(-) Ground Backlight LED Cathode

 

El puerto paralelo también se puede utilizar en el modo de 4 bits, el envío de los datos de 8 bits en dos acciones de escritura,lo cualo ahorra puertos I / O, pero toma más tiempo para actualizar la pantalla LCD.

Hay una excelente biblioteca disponible en CodePlex (con una buena introducción en el blog del autor) para controlar los módulos LCD.

Esta biblioteca hace que muestrar el texto en una pantalla sea  tan fácil como llamar a un método de escritura con la cadena deseada.  Se utiliza un proveedor de patrón para permitir diferentes escenarios de conexión, como conexion directa en los pines GPIO, utilizando un registro de desplazamiento o el uso de un expansor I2C. Además  si usted quiere usar otro escenario, puede añadir su propio proveedor.

lcd

En la imagen se ver un módulo LCD 20×2  conectado directamente a los pines GPIO de un Netduino+ utilizando el puerto paralelo en modo de 4 bits.

Las conexiones se realizan en un circuito, ya que esto hace que sea un poco más fácil de poner todos los cables juntos.

El código de ejemplo proporcionado con la biblioteca contiene un enlace a un esquema muy útil en el sitio web de Arduino.

 

Recuerde conectar la alimentación del módulo LCD al 5V del Netduino pues  la alimentación de 3.3V no es suficiente y  deja en blanco el LCD.

 

La biblioteca contiene un ejemplo sencillo de cómo utilizar la biblioteca.  Se inicializa el LCD, muestra la obligatoria «Hola mundo» y luego entra en un bucle que muestra los milisegundos desde el restablecimiento.Usa los pines GPIO directamente, por lo que hay que cambiar de proveedor como se ve en el ejemplo:

1
2
3
4
5
6
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
public class Program
{
    public static void Main()
    {
        // create the transfer provider, use direct GPIO provider
        // Initialize the library with the numbers of the interface pins
        // Use wiring shown here http://arduino.cc/en/uploads/Tutorial/lcd_schem.png
        var lcdProvider = new GpioLcdTransferProvider(Pins.GPIO_PIN_D12,    // RS
                                                        Pins.GPIO_PIN_D11,    // ENABLE
                                                        Pins.GPIO_PIN_D5,     // D4
                                                        Pins.GPIO_PIN_D4,     // D5
                                                        Pins.GPIO_PIN_D3,     // D6
                                                        Pins.GPIO_PIN_D2);    // D7
 
        // create the LCD interface
        var lcd = new Lcd(lcdProvider);
 
        // set up the LCD's number of columns and rows: 
        lcd.Begin(20, 2);
 
        // print a message to the LCD.
        lcd.Write("Hello world!");
 
        while (true)
        {
            // set the cursor to the first column on the second line
            lcd.SetCursorPosition(0, 1);
 
            // print the number of milliseconds since reset:
            lcd.Write((Utility.GetMachineTime().Ticks / 10000).ToString());
 
            Thread.Sleep(100);
        }
    }
}

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

Un monitor con Netduino


Las ratas se comen cualquier cosa

Hace unos años stewlg  cometío el error de almacenar alimentos en el sótano de una manera que era inferior a salvo de roedores. Un auge de la población pequeña en ratas se produjo antes de que entendíamos lo que estaba sucediendo. Cuando quitamos todo el acceso a la comida en el final del invierno, introdujimos un hambre cuya pánico después nos leemos en los plásticos roídos sobre todo encerrando alimento.

Rat-vs

Todo esto era malo. Caca de rata y orinar son desagradables. Pero lo peor fue que las ratas desesperadas comiendo el tubo de goma y las juntas dentro de nuestra lavadora. Una helada mañana me vino a encontrar jabonosa hemorragia agua fría de la lavadora y que cubre el suelo de nuestro sótano. De repente comprendí por qué alguien querría un monitor de inundación.

Empezó con un acuerdo con pilas de nueve voltios con una alarma audible.

IMG_5217

Esto es mejor que nada, pero no iba a ser capaz de decirle acerca de los problemas cuando estaba fuera de la ciudad, o, para el caso, cuando  stewlg  estaba en el trabajo. Quería más. En concreto,  quería que se conectara a Nagios(un proveedor de Iot) , que comenzó el seguimiento de unas cuantas unidades de disco duro para mí, pero ha crecido a lo largo de los años en algo que una empresa de tamaño medio que podría estar usando para monitorear su red. Nagios se había convertido en la forma en que llevaba la cuenta de los problemas en la casa. Ya paginado y me envió por correo electrónico, y que mantendrá las métricas y datos históricos.

Lo primero que hizo   stewlg   fue buscar un producto comercial que hizo esto – seguramente alguien más necesitado la misma cosa. Y, de hecho, se ha hecho :

SensorMetrix_225Pound

Mientras escribía este post   costaba  alrededor de 425 dólares de Estados Unidos, que todavía parece ridículo, no importa lo industrial y prueba de balas el dispositivo de seguridad es. Eencontró otra empresa que realizaba este también, pero te cobran un precio similar si no mayor para la misma funcionalidad.

¿No podría hacer todo esto con un Arduino ? Y los Internets de cosas?

¿Por qué Netduino

Miró a Arduino, pero una alternativa menos popular  a  stewlg  le  atrajo: Netduino .

* Ya utilizba .NET para el trabajo.  C # es un ambiente verdaderamente excelente.
* Hilos, eventos, temporizadores
Y, probablemente, lo mejor de todo:
* En el circuito de depuración

 stewlg  hizo lo suficiente programación de objetos incrustados para es apreciado tambien  la posibilidad de desplazarse por el código en un depurador o pausando el  programa de modo que  stewlg  estaba dispuesto a pagar un poco más por esto, y de tolerar algunos compromisos en el medio ambiente para evitar ReSharper withdrawl.

También significó mucho para  stewlg   que, si bien la placa de  netduino  cuesta  $ 60 en lugar de ~ $ 30 para un Arduino, pero Netduino +  venía con Ethernet incorporado y no tendría que futz por ahí con un escudo en el primer día. Esto parecía una introducción más suave más amable con el trabajo Arduino-esque.

Portar NRPE a C # y .NET Micro

Como agradable como C # generalmente es que se necesita trabajar en una versión más pequeña de él para recordarle cuánto hay en las bibliotecas, y no en el idioma adecuado. Trabajando en el marco Micro es como trabajar en una cocina cocina en un pequeño velero cuando estás acostumbrado a una cocina de casa decente .Plantillas? Nop. El formato de cadenas? Nop. LINQ? Hah – que es rico.

Afortunadamente, NRPE es un formato muy simple:

  [2 Byte int16_t] - Número de versión
 [2 Byte int16_t] - Tipo (Consulta / Respuesta)
 [4 Byte u_int32_t] - CRC32 Checksum
 [2 int16_t Byte] - código de resultado (OK, WARNING, ERROR DESCONOCIDO)
 [1024 Char Byte] Buffer

Aun así, tubo problemas con el orden de bytes y el relleno por un poco de tiempoantes de averiguarlo. El mayor problema era conseguir un CRC compatible de trabajo, y al final me terminó portar el código a C # . Hubo otro código por ahí que podría haber funcionado, pero casi todo otro código C # hace buen uso viril, sano, de plantillas y LINQ y todo lo que no se puede tener en 192kb de memoria.

¿Cómo funciona

Usted puede tener una mirada en el código mismo, pero los que no tienen una instalación de Nagios puede gustarte una vista previa de cómo funcionan las cosas, una vez que haya instalado las cosas.

He aquí cómo llamar a los diferentes controles manualmente. Aquí nos estamos quedando check_nrpe (el cliente en nuestro servidor Netduino) de Ubuntu:

  # ./check_nrpe -n -H Noah.doodle.local -c check_temp

 OK - Temperatura = 78.1F 25.6C Humedad relativa = 33,6% | temp_celsius = 25.6000004; 35; 38; 0; 100, relative_humidity = 33,6000023%; 70; 80; 0; 100, temp_fahrenheit = 78,080000686645519; 95; 100,40000000000001; 32; 212
  # ./check_nrpe -n -H Noah.doodle.local -c check_flood

 OK - No detectado agua | water_detected = 0
  # ./check_nrpe -n -H Noah.doodle.local -c check_uptime

 OK - Uptime: 03: 42: 51.2740000 memoria libre: 101364 | uptime_in_seconds = 13371, uptime_in_hours = 3, uptime_in_minutes = 222, free_memory = 101364

Estos son los tres servicios que he escrito hasta ahora. Hay tres partes principales visible aquí:

  • OKAY

El código de resultado. En este caso, el servicio se considera estar en un buen estado.

  • Temperatura = 78.1F 25.6C Humedad relativa = 33,6%

Este es el texto de estado legible que aparecerá en Nagios.

  • temp_celsius = 25.6000004; 35; 38; 0; 100, relative_humidity = 33,6000023%; 70; 80; 0; 100, temp_fahrenheit = 78,080000686645519; 95; 100.40000000000001; 32; 212:

Los valores después de la tubería es de datos de rendimiento que es todo lo registra, y puede ser graficada retrospectiva con diversos plug-ins.

Así que aquí está cómo aparece el servicio de Nagios. Aquí al parecer las ratas están de vuelta y han encontrado su camino más allá de las placas de metal que atornilladas a la parte inferior de la lavadora, o tal vez nuestro primer inodoro piso se ha desbordado y se echan por el conducto de calefacción en el sótano de nuevo (no hay ratas la culpa de eso , a menos que mi trasero puede ser considerada como un barco que se hunde) Y algo ha ido mal con el sensor de temperatura -. tal vez los cables han sido comido por las ratas.

NagiosStatusSlice2

Esto es lo que la salida de línea de comandos sería buscar estos dos casos problemáticos:

  ADVERTENCIA - No se puede leer la temperatura.  |
  CRÍTICA - Agua detecta!  | Water_detected = 1

Aquí hay una captura de pantalla de lo que se puede hacer con los datos de rendimiento recogidos a través del tiempo, desde un tiempo sin emergencias o fallas. Podemos ver un tiempo de actividad en constante aumento, y un uso de la memoria constante (no hay fugas aparentemente):

NagiosUptimeInMinutesAndFreeMemoyDemo

Alguna variación en la temperatura y una humedad casi constante:

NagiosTempAndHumidityGraphDemo

Limitaciones

Es importante señalar que la -n aquí es esencial * *:

  ./check_nrpe -n -H noah.doodle.local -c check_uptime

Esto inhabilita SSL para NRPE. Hay al parecer hay espacio en el Netduino para una gran biblioteca tales . Si esto es esencial para que supongo que se podría envolver dentro de un túnel VPN, etc.

Esto es lo que verás si intenta llamar NRPE sin SSL:

  # ./check_nrpe -H Noah.doodle.local -c check_flood
 Check_nrpe: tiempo de espera de socket después de 10 segundos.

También hay algo de cordura comprobar en el código; Si el tipo de consulta no se reconoce TinyNrpeServer no será capaz de responder a la consulta y no intentará.Un mensaje de depuración dará una pista sobre SSL si está conectado a la consola.

Estabilidad

Si se mira a través del código, puede que le resulte bastante paranoico acerca de los errores y accidentes, con dos reinicios duros independientes en el código. Esto se debe a que he probado el código bastante duro y yo estaba esforzándome por evitar que el dispositivo nunca deje de responder y que necesitan un reinicio.

El dispositivo ahora hace un reinicio duro en dos casos:

1) Cuando se hace una excepción

Hay algunas excepciones que descubrí que se producen normalmente, tales como errores de desconexión de socket, que a menudo pueden ser reclamadas a sin recurrir a reiniciar el dispositivo. Por desgracia, no todos ellos parecían ser recuperable, o al menos no de manera consistente, y en lugar de distinguir, me eligieron para reiniciar el dispositivo. En condiciones normales de funcionamiento son bastante raros.

2) Cuando no se haya recibido una consulta para un intervalo de tiempo configurable

En las pruebas, he probado usando condiciones muy abusivos, pero estas condiciones podría conseguir fácilmente el Netduino en un estado donde no sólo mi código no escuchar las conexiones de red entrantes (que podría decirse que tal vez podría ser mi culpa), pila de red del dispositivo se estrellaría, y sería dejar de responder a un ping, que me pareció mucho menos responsables.

En mi código tengo este tiempo de espera configurado así:

  /// <Summary>
 /// Número de milisegundos antes de que la junta se reiniciará.
 /// </ Summary>
 int const público InactivityTimeout = 60 * UpTimeCheck.SecondsPerMinute * UpTimeCheck.MillisecondsPerSecond;

En otras palabras, si no ha tenido un mensaje entrante en una hora, que va a reinicie por sí mismo. Si usted necesita para poner a punto este intervalo, me ponga esto en al menos dos veces el intervalo de control mínimo. Así que si usted comprueba el dispositivo cada 5 minutos, ajusta esto a por lo menos 10 minutos.

Elegí establecer este mucho más alto que yo pueda ver a través de la gráfica el tiempo de actividad, si esto ocurre en realidad nunca – una hora de inactividad debe ser inequívocamente visible.

Para ser justos con la plataforma Netduino, tengo serias dudas de que nadie va a colgar este servidor bajo una carga de red típica. Una encuesta discreta desde un único servidor Nagios cada minuto o dos no va a gravar seriamente nada. Tal vez en un azul-moon, una excepción a la red se producirá y el dispositivo se reinicie en silencio – si lo hace, usted debe ver que se refleja en los datos de rendimiento de tiempo de actividad, pero aún así disfrutar disponibilidad esencialmente ininterrumpida. No espero a nadie a hacer realidad el dispositivo no responde, y activar el reinicio de la vigilancia. Pero por favor dígame cómo va para usted.

Si tuviera que tomar esto más lejos a  stewlg   le gustaría que un temporizador de vigilancia adecuado en hardware .

Expansión

 stewlg   realmente no necesita nada más que un monitor de inundación, pero  pensó en tirar en al menos otra métrica para obtener el código listo para manejar múltiples cheques, por lo tanto, la comprobación de la temperatura.

Aquí es lo menos que había necesidad de hacer para poner en práctica un cheque:

  /// <Summary>
  /// Un ejemplo de lo mínimo que hay que hacer para poner en práctica un cheque
  /// </ Summary>
  DemoCheck clase pública: NrpeCheck
  {
      public override NrpeMessage.NrpeResultState GetStatus (fuera cadena statusString, fuera Hashtable performanceData)
      {
         performanceData = new Hashtable (); var demoMetric = 20;
         performanceData.Add ("demo_metric", demoMetric);
         statusString = "Demo métrica:" + demoMetric.ToString ();
         // Siempre Ok.
         volver NrpeMessage.NrpeResultState.Ok;
      }
  }

Usted probablemente querrá algo de código condicional para el ResultState, y cualquier métrica que tiene probablemente variar. Pero la adición de ningún tipo de supervisión debe ser fácil, al menos desde el punto de vista TinyNrpeServer.

Si usted sube un sensor que desea añadir, envíeme un correo electrónico con un parche o una solicitud de extracción. Me encantaría este servidor NRPE tienen más supervisión que ofrecer fuera de la caja.

Costo

Así que, si no es de $ 425, ¿qué dedico? Probablemente menos de $ 120.Hubiera sido mucho más barato si supiera  lo que estaba haciendo – esto erael primer proyecto de tipo Arduino y los conceptos básicos eran un misterio para  stewlg  . Terminó probando un montón de cosas que no funcionaron antes de encontrar cosas que funcionaron bien pasablemente.

Circuito

Noé V2

Instalación

Prueba inicial de monitor de inundación

Protoshield cableada

Sensor de Inundación comprobación final

Sensor sujeta con cintas para el pelo

Entre las máquinas

Brilla muy prominente en la penumbra

Primeros DHT-22 cableado

DHT-22 en su lugar

Instalado en la caja de ProyectoIMG_5271

Bibliografía y Apreciación

Para ayuda inestimable, indirectos con el protocolo NRPE núcleo, gracias sobre todo a Andreas Marschke y Sadris . Para la clase DhtSensor, Stanislav «CW» Simicek y todo el mundo en este hilo . Para  cluing en aproximadamente perros guardianes y reinicios duras, las personas en estas discusiones . Chris Walker para la clase Cronómetro (y todo lo demás en Netduino, por supuesto).

El Código

https://github.com/StewLG/NetduinoNrpe

 

 

 

Fuente aqui

Conectividad wifi para Netduino +


El MINI300 es un amplificador de señal WiFi  de bajo coste  y tamaño   francamente  muy pequeño (las dimensiones  aproximadas son de 44 x 44 x 14 mm),   que además cuenta con una  conexión  ethernet , lo cual lo  hace ideal  para  dar conectividad  por muy poco coste a nuestro  Netduino +   o Netduino 2 + o cualquier placa que cuente con conexión Ethernet .

En la  siguiente imagen  podemos ver precisamente la  comparación del tamaño del dispositivo frente al tamaño de una tarjeta de crédito (aproximadamente la mitad que ocupa cualquier Arduino o Netduino)

 

En cuanto a  la conectividad WIFI, el dispositivo  puede garantizar la seguridad de la señal inalámbrica, pues apoya mecanismo de seguridad WPA-PSK / WPA2-PSK, 64/128 / WEP. Es compatible con conectar el terminal más de 20 terminales  WiFi al mismo tiempo,  soportando la máxima velocidad de transmisión de 300Mbps, gracias  al  protocolo de transmisión WiFi 802.11b/g/n

Gracias  a  que usa la  técnica  de la adopción del compensado control de la temperatura de frecuencia automática (TAFC) mediante un  original D / A, la estabilidad a largo plazo asegura que no se ha caído la señal WiFi.

Asimismo  usa  tecnología para crear la configuración de IPMP original del dominio virtual para resolver los problemas de configuración de usuario

En cuanto al resto de  los conexiones cuenta  con una toma micro-usb para alimentarlo con 5v DC  , un pulsador para resetearlo y  por ultimo un led interno de actividad

vonets1

En realidad el MINI300     aparte de  poder  trabajar en el modo de repetidor, extendiendo  la cobertura de la señal WiFi original prácticamente al doble (la distancia de transmisión sin obstáculos es de  100m), también  puede usarse  como punto de red  lo cual significa que éste dispositivo  no sólo puede servir para extender la señal wifi, ya que también   puede ofrecer conectividad  a dispositivos que no  cuentan con conectividad wifi  de forma nativa como es el caso de nuestro Netduino+ .

 

Para  configurar la red wifi que repetirá y nos conectaremos , no  puede ser mas simple  :miraremos atrás   de la caja   ,donde  viene el nombre de la red wifi  por defecto  así como las credenciales con  con las que nos tenemos que conectar

En nuestro pc , nos conectaremos a esa red  , accediendo  a  http://192.168.1.1  e introduciendo el usuario   y las clave que hemos visto que hay detrás de la caja

Una vez conectados nos iremos  a «scan HotSpon»     y ahi  introduciremos el nombre de la red,  y  la clave de la red wifi  que intentamos repetir

 

vonets2
En el menú  Operation status podremos ver tras unos segundos que el repetidor  se conecta  la red wifi.

 

 

vonets3

 

Asimismo en el menu Wifi Repeater  podemos  ver la red a la que  nos conectamos y otros parámetros.

vonets4

Por ultimo , el menú Setting  System  podemos   restaurar los valores de fabrica o también realizar un reset parcial al dispositivo.

 

 

vonets5

 

En resumen  , el dispositivo vemos que es  un puente  WiFi inteligente,  con detector inteligente inalámbrico con cable que puede usarse como repetidor WiFi profesional e inteligente.Soporta puntos de acceso WiFi de escaneo automático y función de memoria WiFi hotspot así como la actualización del firmware de forma remota web,ya que  puede obtener la última versión del firmware de forma gratuita.

Asimismo  soporta gestión web local de configuración,( en chino 0 en Inglés ) como hemos visto en las pantallas anteriores.

 

Si lo desea este adaptador esta disponible en Amazon en este link directo: Repetidor Inalámbrico 300Mbps 802.11b/g/n WiFi Cable Micro USB Blanco

Demostración de conexión 11 Netduinos al servicio de Windows Azure


Mike Linen nos enseña en una charla que incluye un laboratorio de construcción de un sistema de automatización de seguridad  domestico  usando nada más y nada menos  que 11 Netduinos 2+  que se    comunican a través de MQTT con la nube  en  Windows Azure.

Este proyecto fue creado para mostrar algunas de las cosas divertidas que se pueden hacer para empezar en el IoT  ( Internet de las Cosas) , pero nunca fue pensado para ser un sistema de Seguridad  para el Hogar de trabajo real, por lo que aconsejan no tratar de usarlo para esto, al menos que usted realmente piense de abordar algunos de los problemas de seguridad de Internet que necesitan ser abordados con un proyecto como este.

Cada dispositivo que se conecta al eje central del sistema llevará a cabo una función específica en la plataforma de seguridad. En un sistema de seguridad real no tendría dispositivos de misión crítica que dependan de la conectividad externa a la nube.La conectividad a un sistema externo de este tipo podría ser fácilmente interrumpida. Una vez más esto es sólo un ejemplo de la diversión para hacerle pensar sobre cómo conectar muchos dispositivos a un servicio en la nube.

Los asistentes a esta charla disfrutaron viendo la demo del laboratorio donde se mostraba como construir diversos componentes de un sistema de seguridad.

Ahora  podemos ver  todo el sistema funcionando  en un vídeo que muestra los diversos componentes del sistema.

 

El hardware utilizado para este proyecto es la Netduino Plus 2 de Secret Labs de LLC .Todos los ejemplos de código que ve en esta vista se centrará en el dispositivo Netduino Plus 2. Sin embargo, el protocolo para comunicarse con el servicio en la nube no es específica de la plataforma por lo que cualquier dispositivo puede ser utilizado para comunicarse con el servicio de Seguridad para el Hogar. Así que no dude en utilizar un dispositivo diferente .Net Framework Micro. Incluso se puede utilizar uno de los dispositivos de Arduino muy populares.

Por supuesto, la parte de servicios cloud de este proyecto se está ejecutando en laplataforma Windows Azure . Hay tantas opciones disponibles para usted con la plataforma Azure. Decidí usar un pequeño subconjunto de las funciones disponibles sólo para demostrar que no se necesita mucho para conseguir algo que hacer en la plataforma Azure.

image

Este proyecto trata pues de la construcción de los dispositivos que completan el sistema de Seguridad para el Hogar. Algunos código básicos ya están  escrito para usted, pero en su mayor parte, será su trabajo completar el código y hacer  el dispositivo funcional. El servicio en la nube que conecta los dispositivos  ya se ha completado y enviado a Windows Azure para su uso, así que usted no tiene que hacer nada de eso codificación.

Sin embargo, el código para el servicio en la nube está disponible en control de código fuente para que usted mire como esta construido.

Se han utilizado  durante la construcción  al menos de uno de los siguientes dispositivos en el sistema de seguridad para el hogar:

  • Puerta de entrada externa – Este dispositivo se encarga de todas las E / S para cualquier puerta externa
  • La puerta Bell – Este dispositivo se encarga de la E / S para permitir que el usuario sepa un timbre de la puerta fue empujada
  • Alarma – Este dispositivo se encarga de la E / S para permitir que el usuario qué se ha disparado la alarma
  • Panel de control de alarma – Este dispositivo se encarga de la E / S para los paneles de control colocados en cada habitación de la casa
  • Panel de Control Maestro – Esto no es realmente un dispositivo (pero podría ser) y que ya está construido para usted. Lo estoy llamando aquí porque sin ella todo el sistema sería un montón de dispositivos que son independientes entre sí, sin control central verdadera gestión de toda la lógica del sistema de seguridad.

Determine cuál de los dispositivos que desee para tratar de construir. Algunos de los dispositivos son más difíciles de completar que otros. Si quiere empezar fácil, entonces usted puede hacer que el dispositivo timbre. Si quiere un reto tan duro y luego seguir adelante y probar el panel de control de alarma.

Habrá un poco de código que ya está escrito por usted para que usted no tiene que preocuparse de los protocolos de comunicación necesarios para publicar y suscribirse a la MQTT bus de mensajes. Dado que el protocolo se abstrae lejos de todo lo que necesitas saber es que los mensajes MQTT son básicamente de dos partes: un tema y un mensaje. Hay mucho más a la norma MQTT que se puede leer por su cuenta pero no lo necesitará para este proyecto. Básicamente, los temas son una serie de palabras separadas por un separador / tema. El mensaje es simplemente cualquier cadena. Se espera que los dispositivos del bus de entender los temas y formatos de mensaje, pero al igual que todos los pub / sub diseña los dispositivos no saben

 

Lo que se está ejecutando en la nube

Hay dos componentes principales que ya existen en Azure que los dispositivos interacción con: MQTT Message Broker y panel de control principal. El intermediario de mensajes se ejecuta bajo un rol Azure Trabajador. El panel de control principal se ejecuta en Windows Azure Papel Web. El corredor simplemente rutas MQTT mensajes y no tiene lógica empresarial específica de seguridad verdadero hogar en él. El Panel de control Master gestiona el estado del sistema de seguridad, así como las reglas de negocio alrededor de cómo funciona el sistema de seguridad en su conjunto. SignalR se utiliza para actualizar los navegadores cliente cuando el estado del sistema de seguridad cambia. Eche un vistazo al panel de control principal para más detalles sobre cómo funciona.

 

image

Como se puede ver es  bastante impresionante.  El código  fuente para el proyecto el autor lo ha puesto disponible  en GitHub :

El sitio web del Sistema de Seguridad se encuentra alojado en un Papel Web y contiene toda la documentación para el laboratorio.

Fuente aqui

Disponible por tiempo limitado el primer ebook sobre Netduino en español


En los últimos años, electrónica e informática han pasado de ser algo que sólo los ingenieros podían comprender, a estar accesible a todo el público en general sin necesitar demasiados conocimientos técnicos.
Netduino 2 plus   precisamente ha crecido hasta convertirse en una parte de esta revolución, proporcionando en una placa del tamaño de una carta un potente entorno gracias a la depuración de programación basada en eventos, multi-threading, ejecución línea a línea, inserción de puntos de interrupción, etc, permitiendo tanto capturar como controlar dispositivos desde Internet de una manera mucho más sencilla y rápida comparada con otras plataformas basadas de hardware abierto.

A propósito del libro, éste intenta cubrir un vacío que existe en el mundo hispano-hablante respecto a Netduino 2+ intentando ser una referencia tanto a las personas que ya manejen esta plataforma para profundizar en algunos aspectos, como aquellas otras que se inician por primera vez, para que de forma paulatina, vayan empezando a entender los entresijos de la programación en c# y su relación con el mundo hw.

Para facilitar   a todos los lectores de este humilde   blog  profundizar  en los  conocimientos sobre Netduino 2+  a partir de mañana 6 de  Marzo  y durante todo el fin semana ,estará disponible para su descarga gratuita en  Amazon el  libro «EL PRIMER LIBRO SOBRE NETDUINO 2 EN ESPAÑOL: Proyectos domóticos paso a paso para todos los niveles»   el cual corresponde a la versión completa del libro  «Netduino 2 en español«.

 

 

A  continuación  se esboza la estructura  de este  libro:

  • La lectura del libro comienza con el hardware de Netduino y su evolución hacia Netduino 2+, este último sobre el que se centrará el resto del libro, explicando con detalle cómo instalar las herramientas necesarias.
  • Una vez el entorno preparado lo primero es probar la comunicación y, tras esto, ya podemos a empezar a escribir nuestro propio primer programa haciendo encender o apagar un led (cap. 2 y3).
  • Cuando controlamos salidas binarias lo siguiente es manejar las entradas binarias, lo cual se ilustra con un ejemplo que usará el pulsador interno (cap. 4).
  • Otro tema interesante puede ser PWM (cap. 5) que puede usarse en infinidad de aplicaciones y que, como ejemplo, usaremos para variar el brillo de un led.
  • En los capítulos siguientes se tratan los diferentes sensores que podemos utilizar en domótica empezando por los sensores de ruido (cap.6) para lo cual necesitaremos el procesamiento de señales analógicas que se trata con un ejemplo. Otro aspecto interesante son los sensores de posición que también se tratan con un ejemplo real (cap. 7).
  • En domótica aparte de las entradas y salidas binarias también se usan sensores de variables físicas como por ejemplo los sensores de temperatura, de luz o de movimiento que se tratan en los cap. 8,9 y 10 (terminando también cada uno con un ejemplo).
  • Una mención especial lo ocupa el cap.11 donde se tratan los sensores de consumo eléctrico tan usuales para monitorizar y optimizar nuestro consumo energético. Como no podría ser menos, también se proponen varios ejemplos de manejo real de éstos.
  • Una vez tratados la mayoría de los sensores, se explica cómo conectar Netduino 2 con un display LCD compatible con el estándar HD44780 para desplegar información en éste que nos interese viéndolo con dos ejemplos reales (cap12).
  • En los siguientes capítulos se describen cómo es posible acceder a todos los sensores y actuadores descritos (y por supuesto todos los que el lector decida) de forma remota, gracias a la conectividad tcp-ip que integra la misma placa Netduino 2 plus. En primer lugar se trata de explicar los entresijos una aplicación que instalaremos en Netduino 2 plus que hace de servidor web, el cual nos va a permitir interactuar de forma remota con éste.
  • Y hablando de control ¿qué mejor que desarrollar una app para permitirnos controlar Netduino 2 a distancia? Pues para ello, se tratara primero de las generalidades de MIT App Inventor (cap14), entorno que nos va a permitir desarrollar una app móvil de una forma muy sencilla desde la nube.
  • Finalizaremos el libro con el desarrollo de una aplicación móvil real que será capaz de interactuar desde Internet con todo el hw descrito en capítulos anteriores , haciendo de colofón del libro ,mostrando de esta forma cómo es posible hacer aplicaciones móviles que interactúen de forma remota con N2 plus de una forma sencilla.

 

Por cierto, si prefiere el formato «tradicional » para todo el  que este interesad,o  también puede  comprar cómodamente  el libro   en Amazon  en formato papel  por   el  precio 7€ con portada blanda a todo color .

.NET Micro Framework – Usando display alfanumericos LCDs


.NET Micro Framework incluye capacidades gráficas de alcance con las bibliotecas WPF  para algunas tarjetas de desarrollo de alta gama bastante ( Tahoe II , ChipworkX o FEZ Cobra por nombrar algunos)donde se  incluyen gráficos de lujo pantallas TFT, a menudo con soporte a  entrada táctil  también . Pero esto tiene  significativamente mayores costos, y requiere una CPU rápida. Por lo tanto, podría parecer que si está utilizando un tablero mucho más barato como Netduino o uno de la familia FEZ, que éstos están condenados a depender sólo parpadear LEDs. No tanto pues en la mayoría de los escenarios  un display LCD alfanumérico podría ser una alternativa barata (o si tiene mayor presupuesto  usted también podría considerar el uso de una pantalla OLED que también trabaja con Netduino ).

alt Para un proyecto más amplio de este post  vamos a  utilizar un LCD alfanumérico para mostrar todo tipo de información de estado. Prácticamente todos los LCDs populares son controlados por un chipset HD44780 compatible con  interfaz paralela. Hay gran variedad de estas pantallas disponibles en varias combinaciones de luz de fondo y el color del texto. El tamaño común es 16×2 caracteres (16 columnas en 2 filas). Eche un vistazo a la amplia selección de pantallas LCD disponible en Sparkfun

Cuando usted compra un  LCD observe  bien si  ese alimenta a 5V o 3V3 versión. Estoy seguro de que ambos funcionan bien con Netduino (que utiliza la lógica 3V3), pero asegúrese de conectarlos para corregir pin fuente de alimentación.

Estas pantallas LCD son bastante fáciles de conectar  y programar. Si nos fijamos en la imagen de arriba notar la cabecera 16pin en la parte superior de la pantalla. El chipset HD44780 utiliza la interfaz paralela para la comunicación de datos y soporta los modos de 8 bits y 4 bits. En el primer caso se utilizará al menos 10 pines de salida digitales del microcontrolador, en el más tarde al menos 6. El pasador de R / W (escritura y lectura) de bits se puede conectar permanentemente a tierra. Puede encontrar las instrucciones de cableado en los ejemplos para la biblioteca Arduino cristal líquido – que funcionará de la misma manera en la Netduino. Para evitar la soldadura también se puede tratar de utilizar el Teclado LCD Escudo DFRobot para Arduino , del Sr. Kogoro Kotobuki ( kotobuki ), es el diseño de un escudo LCD similar que parece funcionar muy bien con Netduino .

Sin embargo, si tomamos el enfoque directo, la pantalla LCD utilice al menos seis de los pines digitales disponibles. Si utiliza un microcontrolador que expone un número masivo de puertos IO (como FEZ Rhino o próxima FEZ Panda ) esto podría estar bien, pero en caso de Netduino o tableros similares que tiene sólo un puñado de los pines digitales esto puede ser no apto. En este caso es posible que desee para multiplexar la salida de más de un menor número de líneas. En mi anterior post ya os hablamos sobre el uso de registros de desplazamiento para evitar tal situación y en este caso se puede reducir el número de salidas a sólo tres.

Otra alternativa podría ser la de comprar un LCD Habilitado Serial . Por lo general, incluyen pensión hija tan especial en la parte posterior (de ahí llamado «mochila») que tiene una MCU responsable de traducir la comunicación UART a la interfaz de la pantalla LCD. Así que si puedes sacrificar uno de los puertos UART en el Netduino esta podría ser una buena opción, pero por lo general cuesta alrededor de $ más que los LCD regulares 10. También podrás comprar la mochila serie solo, por ejemplo el de Sparkfun o el Kit LCD Serial LCD117 de dispositivos modernos .

Para este proyecto  se va a utilizar el mismo registro 74HC595 tal y como Pavel Bansky demostró cómo hacer esto en dispositivos .NET Micro Framework. En su primer post que muestra cómo conectar LCD con 3 cables usando el registro de desplazamiento 4094, y luego en el segundo puesto , añadió soporte para un I 2 C de 8 bits de ampliación de puertos. He modificado y ampliado su biblioteca para incluir funcionalidad disponible en la biblioteca de Arduino LiquidCrystal .

Pavel introdujo una abstracción agradable en su aplicación para separar las funciones de alto nivel LCD de interfaz de transporte subyacente en clases separadas. Así, el constructor de la clase de nivel superior LiquidCrystal, debe proporcionar una instancia de una clase que implementa la interfaz ILiquidCrystalTransferProvider. Esto permite utilizar esta biblioteca con todos los métodos de comunicación descritas anteriormente. En el código fuente ya se encuentra un GpioLiquidCrystalTransferProvider y Shifter74Hc595LiquidCrystalTransferProvider para el registro 74HC595 turno. Más tarde me voy a añadir soporte para el I 2 C de expansión del puerto. Me dieron una bonita mochila LCD de JeeLabs tienda que utiliza el chip MCP23008 pero no sé aún de lo diferente que es de PCF8574P de Pavel. En preparación para este código de manejo de algunas poco comunes ya que se abstrae de la clase BaseShifterLiquidCrystalTransferProvicer.

Aquí se puede ver el cableado he utilizado:

Wiring 16x2 LCD to Netduino via shift register

Observe que porque esta vez voy a usar interfaz SPI los datos en serie está conectado al pin 11 (MOSI) y reloj pin se conecta al pin 13 (SPCK). Pin 10 se conecta a la clavija del pasador, y en el código que se pasa como Slave Select pin al objeto SPIConfiguration. Ya que vamos a utilizar siete salidas desde el registro de desplazamiento la producción restante se conecta a través 2N2222A transistor para controlar la luz de fondo del LCD. Esto nos permite encender la luz de dentro o fuera del código. Finalmente, el potenciómetro de 10K se utiliza para controlar el contraste de la pantalla.

_MG_1274 Foto de la derecha muestra la placa  para el LCD  Tenga en cuenta que debido a que la junta se monta «al revés» las salidas del registro de desplazamiento a LCD se invierten, pero es fácil corregirlo en el código (Shifter74Hc595LiquidCrystalTransferProvider constructor tiene la opción BitOrder opcional).

A continuación puede encontrar una lista de los métodos expuestos por la clase LiquidCrystal:

  • Comience (columnas, líneas) – Utilice este método para inicializar el LCD. Especifica las dimensiones (anchura y altura) de la pantalla.
  • Borrar () – Borra la pantalla LCD y posiciona el cursor en la esquina superior izquierda.
  • Inicio () – Posiciones el cursor en la parte superior izquierda de la pantalla LCD.
  • SetCursorPosition (columna, fila) – Colocar el cursor del LCD; es decir, establecer la ubicación en la que se mostrará el texto escrito posterior a la pantalla LCD.
  • ScrollDisplayLeft () – Desplaza el contenido de la pantalla (texto y cursor) un espacio a la izquierda.
  • ScrollDisplayRight () – Desplaza el contenido de la pantalla (texto y cursor) un espacio a la derecha.
  • Write (texto) – Escribe un texto a la pantalla LCD.
  • Escribe (buffer, offset, count) – Escribe un número especificado de bytes a la pantalla mediante los datos de una memoria intermedia.
  • WriteByte (datos) – Envía un byte de datos a la pantalla.
  • CreateChar (ubicación, charmap)

Y sus propiedades:

  • Luz de fondo – Enciende la luz de fondo del LCD encendido o apagado.
  • BlinkCursor – mostrar u ocultar el cursor de bloque parpadeante en la posición a la que se escribirá el siguiente carácter.
  • ShowCursor – Mostrar u ocultar el cursor del LCD: un guión bajo (línea) en la posición a la que se escribirá el siguiente carácter.
  • Visible – Activa la pantalla LCD encendida o apagada. Esto restaurará el texto (y cursor) que estaba en la pantalla.
  • Codificación – Obtener o establecer la codificación utilizada para asignar la cadena en códigos de bytes que se envían LCD. UTF8 se utiliza por defecto.

 

Y aquí el código de ejemplo de  “hello world” con un lcd:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static void Main()
{
    // create the transfer provider
    var lcdProvider = new Shifter74Hc595LiquidCrystalTransferProvider(<span class="skimlinks-unlinked">SPI_Devices.SPI1</span>,
        <span class="skimlinks-unlinked">SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D10</span>);
    // create the LCD interface
    var lcd = new LiquidCrystal(lcdProvider);
    // set up the LCD's number of columns and rows:
    <span class="skimlinks-unlinked">lcd.Begin(16</span>, 2);
    // Print a message to the LCD.
    <span class="skimlinks-unlinked">lcd.Write("hello</span>ld!");
    while (true)
    {
        // set the cursor to column 0, line 1
        lcd.SetCursorPosition(0, 1);
        // print the number of seconds since reset:
        <span class="skimlinks-unlinked">lcd.Write((Utility.GetMachineTime().Ticks</span> / 10000).ToString());
        <span class="skimlinks-unlinked">Thread.Sleep(100</span>);
    }
}

Fuente aqui

Tutorial Netduino Parte 7


 

 Netduino es una plataforma de desarrollo de código abierto integrado similar al Arduino, excepto que utiliza .NET Micro Framework para la programación.  La placa de desarrollo Netduino tiene el mismo factor que Arduino Uno, y por lo tanto la mayoría de los escudos de Arduino son también compatibles con Netduino.  Las placas de desarrollo Arduino se basan en 8 bits microcontroladores Atmel que corren a una velocidad máxima de reloj de 16 MHz en su versión primera. Por otra parte, el hardware Netduino usa potentes procesadores de 32 bits (en el caso de la primera versión un  Atmel SAM7x en Netduino, y STMicro STM32F4 en versiones Netduino Plus) y funciona a una velocidad mucho más rápida (48 MHz a 168 MHz).

El  siguiente tutorial  extraidos de http://embedded-lab.com/blog    tienen como objetivo proporcionar una amplia introducción a la plataforma Netduino  y asegurar que cualquier principiante, estudiante o aficionado, será rápidamente capaz de empezar a usarlo para sus propios proyectos y diseños embebidos. En todos los ejemplos se usa una placa  Netduino Plus ( es la versión mas antigua con NETMF 4,1) se utiliza para ilustrar la salida en estos experimentos.

Como continuación del curso básico de Netduino https://soloelectronicos.com/2015/02/24/tutorial-netduino-parte-6/    en esta   ocasión vamos   a tratar la  gestión de PWM

Pulse Width Modulation (PWM) es un método digital de la entrega de una cantidad variable de energía a una carga, y por lo tanto se puede utilizar para controlar el brillo de un LED o la velocidad de un motor de corriente continua. El control de la potencia, haremos este tutorial colorido usando un Azul Verde Rojo (RGB) LED. Cada segmento (plomo) de RGB-LED obtendrá una señal PWM a través de la clase RGBLED lo que nos permite iluminar el LED RGB con cualquier color definido por RGB. Esta clase también puede generar colores al azar. Utilización de la clase RGBLED, algunos colores estándar también se pueden enviar a un LED RGB.

Configuración de Circuito y Teoría

Para entender PWM, vamos a entender los términos que conforman unas señales de ancho de pulso modulado. El uno es muy importante pues es del ciclo de trabajo. En términos flexibles este ciclo de trabajo es un valor en porcentaje del estado ON en comparación con el estado OFF. A partir de la figura siguiente podemos ver la fórmula para calcular el ciclo de trabajo.

Ahora, vamos a ver como  co-relacionan lo anterior a nuestro proyecto. Digamos que nos gusta para producir un color «gris». Conocemos el valor RGB para el gris es de 128, 128 y 128. Esto significa, si mezclamos el 50% de rojo (50% de 256 es 128), el 50% de verde y 50% de azul, vamos a obtener un color gris . El valor de 50% provino de 128/256 * 100%. Con respecto a la figura anterior, si T = el 50% para la pierna roja, T = el 50% de la pierna verde y T en = 50% de la pata azul de un LED RGB entonces vamos a tener un color gris a partir de un LED RGB- . El valor calculado es nada más que el ciclo de trabajo de un PWM. En la clase RGBLED, que básicamente ajustar el ciclo de trabajo para iluminar el LED RGB con un color deseado.

Asi se muestra  un ciclo de trabajo de hoja de cálculo Excel para entenderlo un poco mejor  y también la explicación de  la clase RGBLED.

 

Las conexiones no son tan difíciles. Pines digitales Netduino, 5, 6, 9 y 10 se pueden configurar como pines PWM, de los cuales vamos a configurar 5, 6 y 9. Las salidas de estos pines son alimentados a la base de un transistor NPN. Cuando el pulso es alta, el transistor entra en modo de saturación y permite el flujo desde el colector al emisor que está conectado nuestro RGB LED. Dado que el LED RGB usado en este tutorial es ánodo común, el plomo ánodo está conectado a + 5v. El diagrama del circuito siguiente muestra la conexión.

La imagen siguiente muestra la configuración de circuito en un circuito y sus conexiones con el Netduino.

 

 

C Programa # .NET

La utilización de la clase RGBLED es muy simple así que vamos a saltar todo por ahora y  centrarnos en la propia clase. El constructor de la clase toma cuatro argumentos, el número de pin para el rojo, verde y azul y  el último argumento es opcional para commonAnode lo cual es cierto por defecto (en el diagrama del circuito que no es demasiado importante si nos fijamos este valor a verdadero o falso).

En este método constructor nuevas instancias de la clase PWM están embalados luego una tabla de colores Hashtable se rellena con el color estándar.

 

public RgbLed(Cpu.Pin redPwmPin, Cpu.Pin greenPwmPin, Cpu.Pin bluePwmPin, bool commonAnode = true)
{
	RedLED = new PWM(redPwmPin);
	GreenLED = new PWM(greenPwmPin);
	BlueLED = new PWM(bluePwmPin);
	LEDs = new PWM[] { RedLED, GreenLED, BlueLED };
 
	CommonAnode = commonAnode;
	ColorTable = new Hashtable();
	ColorTable.Add(0, new byte[] { 0, 0, 0 });		// Off (~~ Black color)
	ColorTable.Add(1, new byte[] { 0, 100, 100 }); 	// Aqua
	ColorTable.Add(2, new byte[] { 0, 0, 100 });	// Blue
	ColorTable.Add(3, new byte[] { 100, 0, 100 });	// Fuchsia
	ColorTable.Add(4, new byte[] { 50, 50, 50 });	// Gray
	ColorTable.Add(5, new byte[] { 0, 50, 0 });		// Green
	ColorTable.Add(6, new byte[] { 0, 100, 0 });	// Lime
	ColorTable.Add(7, new byte[] { 50, 0, 0 });		// Maroon
	ColorTable.Add(8, new byte[] { 0, 0, 50 });		// Navy
	ColorTable.Add(9, new byte[] { 50, 50, 0 });	// Olive
	ColorTable.Add(10, new byte[] { 50, 0, 50 });	// Purple
	ColorTable.Add(11, new byte[] { 100, 0, 0 });	// Red
	ColorTable.Add(12, new byte[] { 75, 75, 75 });	// Silver
	ColorTable.Add(13, new byte[] { 0, 50, 50 });	// Teal
	ColorTable.Add(14, new byte[] { 100, 100, 100 });// Whilte
	ColorTable.Add(15, new byte[] { 100, 100, 0 });	// Yellow
}

Hay tres métodos públicos disponibles para el establecimiento de un color, el Turnit, escribir y métodos RandomColor. Tener color estándar, llamar al método Turnit y pasar el color estándar de color Enum. El método de escritura toma tres argumentos byte para el color rojo, verde y azul. Finalmente, RandomColor calculará número aleatorio para el valor de color rojo, verde y azul.

 

public void TurnIt(Color color)
{
	if (ColorTable.Contains((int)color))
	{
		colorArray = (byte[])ColorTable[(int)color];
		SetColor();
	}
	else
		throw new Exception("Color not found");
}
public void Write(byte red, byte green, byte blue)
{
	colorArray = new byte[] { (byte)(red * 100 / 255), (byte)(green * 100 / 255), (byte)(blue * 100 / 255) };
	SetColor();
}
public void RandomColor()
{
	Random random = new Random();
	colorArray = new byte[] { (byte)random.Next(100), (byte)random.Next(100), (byte)random.Next(100) };
	SetColor();
}
public override string ToString()
{
	colorString = string.Concat("RGB(", colorArray[0], ", ", colorArray[1], ", ", colorArray[2], ")");
	return colorString;
}

Todos los métodos públicos llaman internamente al método privado SetColor.Este  básicamente cambia el ciclo de trabajo de las instancias de PWM para cada pin de lectura, verde y azul.

 

private void SetColor()
{
	if (CommonAnode) colorArray = AdjustPolarityValue(colorArray);
	LEDs[0].SetDutyCycle((uint)colorArray[0]); // Red
	LEDs[1].SetDutyCycle((uint)colorArray[1]); // Green
	LEDs[2].SetDutyCycle((uint)colorArray[2]); // Blue
}
private byte[] AdjustPolarityValue(byte[] colorArray)
{
	return new byte[] { (byte)(100 - colorArray[0]), (byte)(100 - colorArray[1]), (byte)(100 - colorArray[2]) };
}

Aquí está la clase  del diagrama RGBLED :

Salida

Para demostrar el uso de cada tres métodos públicos, hay tres partes en el vídeo. Primero se muestra el color estándar entonces se muestra el espectro de colores de bucle a través de diferentes lazos de color y finalmente un poco de color al azar.

En este código   se busca mostrar algunos colores estándar

 

RgbLed led = new RgbLed(Pins.GPIO_PIN_D9, Pins.GPIO_PIN_D6, Pins.GPIO_PIN_D5, false   );
 
// Display standard colors
led.TurnIt(RgbLed.Color.Red);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Navy);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Purple);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Green);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Maroon);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Blue);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Fuchsia);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Teal);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Yellow);
WaitAndTurnOff(500, led);

Para mostrar diferentes colores se utilizan tres bucles for  en forma de cascada:

 

for (int red = 0; red < 255; red += 50)
{
    for (int green = 0; green < 255; green += 50)
    {
        for (int blue = 0; blue < 255; blue += 50)
        {
            led.Write((byte)red, (byte)green, (byte)blue);
            Debug.Print(led.ToString());
 
            WaitAndTurnOff(100, led);
        }
    }
}

Y para generar los colores al azar (bucle 20 veces)  se utiliza  este código:

 

for (int i = 0; i < 20; i++)
{
    led.RandomColor();
    WaitAndTurnOff(500, led);
}
private static void WaitAndTurnOff(int time, RgbLed led, byte longerOn = 2)
{
    Thread.Sleep(time * longerOn);
    led.TurnIt(RgbLed.Color.Off);
    Thread.Sleep(time);
}

Y  por   último    un vídeo de salida rápida del código de seguridad.

 

Fuente   aqui