Category: Netduino

Control de un display de 7 segmentos con Netduino+

Tercera entrega manual de netduino básico. Trata sobre la gestión de un display de 7 segmentos


 Netduino es una plataforma de desarrollo de código abierto integrado similar a la famosa plataforma  Arduino, excepto que utiliza .NET Micro Framework para su 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 ,pero  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).

En el  siguiente ejemplo  extraido de  embedded-lab.com  ademas de intenatr  dar  una  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 vamos   a ver la  gestiona de un display  de 7 segmentos de  led   con nuestro Netduino Plus .

Netduino-Plus como webserver interactuando con dispositivos

Una salida visual siempre añade valor a cualquier proyecto .En esta  ocasión , vamos a mostrar un poco de información numérica, alfabética, así como dos personajes simbólicos en un módulo LED de siete segmentos de 4 dígitos en función de luminosidad captada por una foto-resistencia,es decir vamos a  leer una tensión analógica de un sensor LDR y mostraremos la salida del ADC en cuatro  módulos de siete segmentos.

En realidad el control de un display de 7 segmentos ( en realidad 8 si contamos con el punto) , es bastante intuitivo  , si  se piensa en que cada segmento  corresponde a un solo led .Por ejemplo para mostrar dígito “1”, tenemos que enviar la señal de alto para el LED “b” y “c” solamente y tierra el cátodo.

Como un display cuenta con siete segmentos LED se hace con siete más un LED, cada LED tiene su propio nombre, por ejemplo ,si   tenemos que mostrar “15” la forma en que hacemos es mostrando un  “1” ( segmentos B y C) en un bloque LED ,luego  apagamos ese primer display ( cátodo a uno lógico)    y luego nos vamos a mostrar “5” en el segundo display LED( segmentos A,F,G y D)   y luego  lo apagamos también (cátodo a uno lógico),  y repetimos el bucle indefinidamente :esto es  básicamente  la multiplexación porque todos lo segmentos los unimos eléctricamente para ahorrar bits de control  de modo que solo controlamos el encendido de uno de ellos a una frecuencia tan rápida que sea inapreciable por el ojo humano

.

15.png

 

Configuración de Circuito y Teoría

En la sección analógica, hemos utilizado una LDR como nuestro dispositivo de entrada analógica. Con la iluminación, la resistencia de la LDR cambiará causando el cambio en el voltaje  debido al divisor de tensión formado por el LDR y  una resistencia de 10k .La caída o subida de tensión entre el punto de unión entre el  LDR  y la resistencia nos dará  una tensión que conectemos a  nuestro pin analógico A1 de  Netduino

En la sección digital, las conexiones son  también muy  sencillas. Cada pin (a hasta g) de los siete segmentos LED están conectados a los pines digitales DO a D6  de  Netduino+ través de una resistencia de 330 ohmios . Posteriormente cada display de siete segmentos LED al ser estos de  cátodo común y haber cuatro unidades , los controlaremos por  medio de 4  transistores NPN ( por ejemplo BC547)  con  sus resistencias de base de 10k  que conectaremos a los pines digitales D8,D9;D10 y D11 de nuestro Netduino

Cuando la base del transistor está forzado a un uno lógico, el  transistor conduce y  entonces el ánodo correspondiente se conecta a tierra, que completaría  el circuito justo en los segmentos cuyos pines lógicos estén a uno logico encendiendo así  el LED correspondiente a ese led

.
displayleds

 

Programa en c#

El  código escrito por  embedded-lab va usar una  pequeña biblioteca (Clase SevenSegments) que soporta un poco más que los dígitos que muestran. Veamos paso a paso. En el código de abajo, primero creamos una instancia de la clase AnalogInput lo que nos permite obtener el valor de nuestro dispositivo analógico que es LDR en este caso. Luego creamos una instancia independiente de la clase SevenSegments. El constructor de esta clase lleva varios pines como argumentos. Una vez que tenemos SevenSetments instancia simplemente llamar al método Show y pasar el valor que se lee desde el dispositivo analógico

public static void Main()
{AnalogInput aInPin = new AnalogInput(Pins.GPIO_PIN_A1);

//se puede usar cualquier pin analógico

aInPin.SetRange(0, 1234); //dar un rango.
 Debug.Print(“Analog value: ” + aInPin.Read());
 // inicializacion del display de 7 segmentos pasando los pines adecuados
SevenSegments sevenSegments = new SevenSegments(
Pins.GPIO_PIN_D0, Pins.GPIO_PIN_D1, Pins.GPIO_PIN_D2,
Pins.GPIO_PIN_D3, Pins.GPIO_PIN_D4, Pins.GPIO_PIN_D5, Pins.GPIO_PIN_D6,
new Cpu.Pin[] { Pins.GPIO_PIN_D8, Pins.GPIO_PIN_D9, Pins.GPIO_PIN_D10, Pins.GPIO_PIN_D11 });

// Valor de pantalla leido por en entrada analogica
sevenSegments.FlickerDelay = 5;
 // Pausa entra cada letra durante la repeticio en una unidd de LED
sevenSegments.UnitSevenSegmentLedDelay = 1;
 //Duracion de una unida led estando a ON
sevenSegments.UnitRepetition = 50;
/// Repeticion de todo la tira
while (true)
{
sevenSegments.Show(aInPin.Read());
Debug.Print(aInPin.Read().ToString());
}
}

El   proceso  pesados ​​principal se hace en la clase SevenSegment. Por lo tanto, vamos a echar un vistazo rápido a las diferentes secciones de esta clase.

Sección constructor de la clase SevenSegment

Aquí hemos definido algunas E / S digitales para los segmentos de LED a hasta g. Para soportar cualquier número de unidades LED, los pines asociados  a ánodos o al cátodo común son recibidos como una matriz. Ahora, para mostrar una carta o un alfabeto, se ha  construido una serie de Boole. Todas estas matrices se almacenan en una tabla hash con una clave que corresponde a un dígito o un alfabeto o un símbolo. Finalmente algunas propiedades se inicializan con algunos valores

 

public SevenSegments(Cpu.Pin a, Cpu.Pin b, Cpu.Pin c, Cpu.Pin d, Cpu.Pin e, Cpu.Pin f,
Cpu.Pin g, Cpu.Pin[] commonAnodeCathodePin)
{
     OutputPort PinD0Out_a = new OutputPort(a, false);
    OutputPort PinD1Out_b = new OutputPort(b, false);
    OutputPort PinD2Out_c = new OutputPort(c, false);
    OutputPort PinD3Out_d = new OutputPort(d, false);
    OutputPort PinD4Out_e = new OutputPort(e, false);
    OutputPort PinD5Out_f = new OutputPort(f, false);
    OutputPort PinD6Out_g = new OutputPort(g, false);
     segmentPins = new OutputPort[] { PinD0Out_a, PinD1Out_b, PinD2Out_c, PinD3Out_d,
PinD4Out_e, PinD5Out_f, PinD6Out_g };
 
    // inicializacion de commonAnodeCathodePin
    ledSegmentUnit = new OutputPort[commonAnodeCathodePin.Length];
    for (int i = 0; i < commonAnodeCathodePin.Length; i++)
    {
        ledSegmentUnit[i] = new OutputPort(commonAnodeCathodePin[i], false);
    }
 
    // crear una lista de caracteres soportados
    ledSegmentTable = new Hashtable();
    ledSegmentTable.Add(“0”, new bool[] { true, true, true, true, true, true, false });
    ledSegmentTable.Add(“1”, new bool[] { false, true, true, false, false, false, false });
    ledSegmentTable.Add(“2”, new bool[] { true, true, false, true, true, false, true });
    ledSegmentTable.Add(“3”, new bool[] { true, true, true, true, false, false, true });
    ledSegmentTable.Add(“4”, new bool[] { false, true, true, false, false, true, true });
    ledSegmentTable.Add(“5”, new bool[] { true, false, true, true, false, true, true });
    ledSegmentTable.Add(“6”, new bool[] { true, false, true, true, true, true, true });
    ledSegmentTable.Add(“7”, new bool[] { true, true, true, false, false, false, false });
    ledSegmentTable.Add(“8”, new bool[] { true, true, true, true, true, true, true });
    ledSegmentTable.Add(“9”, new bool[] { true, true, true, true, false, true, true });
    ledSegmentTable.Add(“a”, new bool[] { true, true, true, false, true, true, true });
    ledSegmentTable.Add(“b”, new bool[] { false, false, true, true, true, true, true });
    ledSegmentTable.Add(“c”, new bool[] { true, false, false, true, true, true, false });
    ledSegmentTable.Add(“d”, new bool[] { false, true, true, true, true, false, true });
    ledSegmentTable.Add(“e”, new bool[] { true, false, false, true, true, true, true });
    ledSegmentTable.Add(“f”, new bool[] { true, false, false, false, true, true, true });
    ledSegmentTable.Add(“g”, new bool[] { true, true, true, true, false, true, true }); ;
    ledSegmentTable.Add(“h”, new bool[] { false, false, true, false, true, true, true });
    ledSegmentTable.Add(“i”, new bool[] { false, true, true, false, false, false, false });
    ledSegmentTable.Add(“j”, new bool[] { false, true, true, true, true, false, false });
    ledSegmentTable.Add(“l”, new bool[] { false, false, false, true, true, true, false });
    ledSegmentTable.Add(“n”, new bool[] { false, false, true, false, true, false, true });
    ledSegmentTable.Add(“o”, new bool[] { false, false, true, true, true, false, true });
    ledSegmentTable.Add(“p”, new bool[] { true, true, false, false, true, true, true });
    ledSegmentTable.Add(“q”, new bool[] { true, true, true, false, false, true, true });
    ledSegmentTable.Add(“r”, new bool[] { false, false, false, false, true, false, true });
    ledSegmentTable.Add(“s”, new bool[] { true, false, true, true, false, true, true });
    ledSegmentTable.Add(“t”, new bool[] { false, false, false, true, true, true, true });
    ledSegmentTable.Add(“u”, new bool[] { false, false, true, true, true, false, false });
    ledSegmentTable.Add(“y”, new bool[] { false, true, true, false, false, true, true });
    ledSegmentTable.Add(“-“, new bool[] { false, false, false, false, false, false, true });
    ledSegmentTable.Add(“?”, new bool[] { false, true, true, false, true, true, false });
    ledSegmentTable.Add(“?”, new bool[] { true, false, false, true, false, false, true });
 
    // Inicializar campos por defecto
    FlickerDelay = 5;
    SevenSegmentsUnits = commonAnodeCathodePin.Length;
    UnitSevenSegmentLedDelay = 0;
    UnitRepetition = 50;
    RightToLeft = true;
}

Para mostrar un dígito o un signo del alfabeto, vemos  un método Show de esta clase. Hay tres sobrecargas de este método Show  que vamos a ver a continuación.

 

El primero toma int como argumento y llama directamente segundo método Mostrar que tiene cadena como argumento. En este método, dependiendo de si RightToLeft se establece en verdadero o falso, y el código salta a la sección correspondiente. Esta sección básicamente extrae la letra correcta para mostrar y luego llama el tercer método Mostrar.

public void Show(string stringToShow)
{

// este bucle hará que parezca que todos los leds permanezcan encendidos
for (int j = 0; j < UnitRepetition; j++)
{   if (RightToLeft)
{ int ledUnit = SevenSegmentsUnits – 1; // indice basados en 0 index   for (int i = stringToShow.Length; i > 0; i–)
{
string eachLetter = stringToShow.Substring(i – 1, 1);
Show(eachLetter, ledUnit);
ledUnit -= 1;
 
// si longitud de stringToShowes mayor que
// SevenSegmentsUnits los restamos
if (ledUnit < 0) ledUnit = SevenSegmentsUnits – 1;
// – 1 es un indice basado en 0x
 
Thread.Sleep(UnitSevenSegmentLedDelay);
}
}
else
{
int ledUnit = 0; // indice basado en 0
for (int i = 0; i < stringToShow.Length; i++)
{
string eachLetter = stringToShow.Substring(i, 1);
Show(eachLetter, ledUnit);
ledUnit += 1;
 
// Si longitud de stringToShow es mayor
//que SevenSegmentsUnits restalo
ledUnit = ledUnit % SevenSegmentsUnits;
 
Thread.Sleep(UnitSevenSegmentLedDelay);
}
}
 
Thread.Sleep(FlickerDelay);
}
 
}

El tercer método Mostrar toma dos argumentos, primero es la cadena que se mostrará y segundo es dónde mostrara es decir, en  que bumero de display LED. En la HashTable definida durante la construcción, se rellena  la matriz correcta de Boole  y entonces el pin correspondiente se establece a nivel alta o baja en base a esta matriz booleana. En el paso final, todos los pines asociados al  ánodo o al cátodo común se establecen a nivel bajo de modo que sólo el  LED apropiado se establece a nivel  alto.

public void Show(string numberString, int ledUnit)
{
bool[] ledSegmentOnOffValues;
numberString = numberString.ToLower();
 
// en este nivel, se admite la longitud de la cadena, por lo que descarta el resto
if (numberString.Length > 1) numberString =
numberString.Substring(numberString.Length – 1, 1);
 
// Enviar nivel bajo al ánodo / cátodo común de SevelSegmentLED
for (int i = 0; i < ledSegmentUnit.Length; i++)
{
ledSegmentUnit[i].Write(false);
}
 
if (!ledSegmentTable.Contains(numberString))
{
// cuando se pasas una letra no soportada muestra  “-“
ledSegmentOnOffValues = (bool[])ledSegmentTable[“-“];
}
else
{
// consigue el array a  true/false 
ledSegmentOnOffValues = (bool[])ledSegmentTable[numberString];
}
 
for (int i = 0; i < segmentPins.Length; i++)
{
//poner el  pin correspondiente a nivel alto
segmentPins[i].Write(ledSegmentOnOffValues[i]);
}
 
// solamente envia la señal al catodo o anodo seleccionado
ledSegmentUnit[ledUnit].Write(true);
}

Valores  maximos y/o minimos

Con muy pocas líneas de código podemos ampliar o añadir funcionalidades adicionales como un contador que toma cuenta del valor  mínimo al valor máximo. Este contador es un ejemplo muy simple que toma dos argumentos, el valor mínimo y el valor máximo. Un bucle for se puede configurar  a partir de este minuto a valor máximo y el método Show que se ha llamado de pasar el incremento de bucle de corriente. Este método nos permite mostrar el contador en nuestros siete segmentos unidad LED

 

public void Counter(int minValue, int maxValue)
{
for (int i = minValue; i <= maxValue; i++)
{
Show(i);
Debug.Print(i.ToString());
}
}

Pruebas finales

Con nuestra clase SevenSegments, tenemos varias salidas. En primer lugar vamos a ver la salida de nuestro circuito. Aquí podemos ver el valor más bajo en nuestra pantalla cuando LDR está cubierto sin embargo el número aumenta a medida que iluminamos nuestro LDR.

Ahora echemos un vistazo a nuestro métodoque hemos añadido a nuestra clase SevenSegments. Con el siguiente código, po rjemplo vamos a ver los números  desde  980 a 1020:
sevenSegments.FlickerDelay = 5;
sevenSegments.UnitSevenSegmentLedDelay = 1;
sevenSegments.UnitRepetition = 5;
sevenSegments.RightToLeft = true;
while (true)
{
sevenSegments.Counter(980, 1020);
}

 

Vamos a darle una cadena de más de nuestros Siete unidades LED del segmento y  ver qué pasa:

sevenSegments.FlickerDelay = 10;
sevenSegments.UnitSevenSegmentLedDelay = 500;

sevenSegments.UnitRepetition = 1;

sevenSegments.RightToLeft = false;
while (true)
{
sevenSegments.Show(“1234567890abcdefghijklmnopqrstuvwxyz”);
sevenSegments.Show(“????”);
sevenSegments.Show(“Embedded-Lab”);
 
}

Ahora, vamos a ajustar algunas de sus propiedades y ver un efecto de laminación

sevenSegments.FlickerDelay = 5;

sevenSegments.UnitSevenSegmentLedDelay = 200;
sevenSegments.UnitRepetition = 50;

sevenSegments.RightToLeft = false;
while (true)
{
sevenSegments.Show(“-Lab”);
}

 

Y para terminar , es el siguiente video podemos ver el código presentado ejecutándose con la electrónica descrita

Los display leds de 7 segmentos  ( o mas ) como se puede ver son bastante sencillos de manejar  desde Netduino  gracias a la  multiplexacion como hemso visto en el ejemplo

Fuente   aqui

Display inteligente para Netduino

TextDisplayMenu es una biblioteca menú de plug-and-play increíblemente potente, pero muy fácil de usar, jerárquica, editable, que le permite añadir fácilmente una interfaz gráfica LCD alimentado a su proyecto de hardware. Puede ser conducido con un codificador rotatorio (piensen en: control de volumen en el estéreo), o tres botones, con muy poco código


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

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

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

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

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

Utilización

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

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

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

Resumiendo estas son las conexiones del display lcd:

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

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

Código de ejemplo

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

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

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

            display.SetBrightness();

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

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

El código  completo se puede encontrar aquí.

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

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

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

Carga un menú desde JSON

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

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

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

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

Agregar el menú JSON como un recurso

Para agregar el archivo JSON al proyecto como un recurso:

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

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

Soporte de eventos

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

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

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

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

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

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

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

Construcción de  tipos

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

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

Creación de tipos de elementos de menú personalizado

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

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

Ejemplo de NumericBase personalizado

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

using System;
using Microsoft.SPOT;

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

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

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

Nuevos aires para Netduino

Wilderness Labs se está preparando para hacer que el desarrollo de hardware sea tan rápido y fácil como el software. Netduino está lleno de IO; incluyendo 22 puertos de Entrada / Salida de Propósito General (GPIO), 6 de los cuales soportan hardware de generación de modulación de ancho de pulso (PWM), 4 UART (comunicación en serie), I2C y SPI (Bus de Interfaz de Periférico Serial).


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

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

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

 

 

 

 

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

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

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

Plataforma Netduino plus

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

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

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

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

 

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

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

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

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

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

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

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

Netduino 3

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

Existe comercialmente en tres variantes:

N3

384 KB Code Flash Storage

SIn ethenert  ni wif

N3 Ethernet

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

Con ethernet

N3 WiFi

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

Con adaptador WiFI

Netduino 2

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

N2

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

SIn ethenert  ni wif

N2 Plus

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

Con intrefaz Ethernet

 

 

Netduino Foundation

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

 

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

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

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

 

Hackster_Contest_Description_Banner.png

Concurso Netduino

 

Presentaciones del proyecto

Presentación debe incluir:

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

Línea de tiempo

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

 

 

Estos serán los premios a este concurso;

  • Mejor presentación general – 1er lugar

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

  • Presentacion honorable

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

  • Acceso de la Beta Meadow

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

 

  • ¿Listo para comenzar?

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

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

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

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

 

 

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