Tutorial Netduino Parte 6


 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  donde se trataba de  escribir en una tarjeta SD ,  aprendido a escribir en una tarjeta SD,como ya habrán experimentado, con el fin de ver lo que se ha escrito, tenemos que salir de la SD y luego conectarlo a un ordenador, lo que obviamente no es muy conveniente todo el tiempo. Así, en este tutorial vamos a leer un archivo de texto (mismo archivo / información que escribimos en tutorial anterior ) y enviar el texto a un ordenador. Nuestra comunicación entre la tarjeta SD y Netduino ordenador se establece mediante la comunicación serie mediante USB al dispositivo UART TTL. Por lo tanto, la información será transferida a una computadora en un puerto Component Object Model (COM).

Hay dos grandes partes de este tutorial; primera lectura de los datos de la tarjeta SD y enviarla a un ordenador, la segunda una aplicación escuchando a un puerto COM para recuperar los datos. Además de estos, en este tutorial vamos a tocar después de grandes objetos:

  • Comunicación en serie
  • InterruptPort
  • EventHandler (Nativo y SerialDataReceived)
  • StreamReader

Configuración de Circuito y Teoría

Desde el equipo que estoy usando no tiene un puerto serie (la mayor parte del equipo en estos días no tienen uno) por lo que un UART USB (Universal Asíncrono receptor-transmisor) adaptador (comprado aquí ) se utiliza lo que nos permite enviar serial datos a un ordenador a través de un USB.

Netduino soporta de forma nativa UART RX y TX en los pines digitales 0 y 1 pins. Así, el pasador de 0 Netduino va a RXD y el pin 1 está conectado a TXD del dispositivo USB-UART. Cuando la información se envía desde Netduino al dispositivo USB UART, necesitamos una aplicación informática para aprovechar esa información desde el puerto COM. Con el fin de recibir dicha información escribí una herramienta COM Talk.

COM Talk (Aplicación Informática)

Vamos a crear una aplicación que puede recibir información de los puertos COM. También he añadido algunas funciones para que pueda enviar información a través del puerto COM seleccionado, sin embargo, no vamos a discutir en esa parte. No voy a entrar en detalles acerca de cómo funciona esta herramienta, ya que es más cosas .NET (que la programación de microcontroladores). Esta aplicación se puede utilizar para recibir información sobre cualquier puerto COM para que no se limita a este tutorial. Es así como la interfaz de usuario de esta herramienta se parece.

La sección de entrada de COM Talk mostrará la información recibida en el puerto COM seleccionado. Internamente, bytes recibidos se convierten en cadena y se muestra. La sección de salida permite enviar información al puerto COM. Esta sección no se utiliza en el tutorial. Necesitamos tener esta herramienta en marcha cada vez que queremos para recibir datos en un puerto COM.
Aquí está todo el código relacionado con esta OCM Talk.

 

public static void Log(params object[] strings)
{
    string message = string.Empty;
    for (int i = 0; i < strings.Length; i++)
    {
        message = message + strings[i].ToString() + " ";
    }
    WriteLog(message, StreamWriter, PrefixDateTime, LogToFile );
}

Uno de los argumentos utilizados es StreamWriter que es una propiedad y se crea una nueva instancia de StreamWriter cuando llamó por primera vez.

private static StreamWriter StreamWriter
{
    get
    {
        if (_streamWriter == null) _streamWriter = new StreamWriter(LogFilePath,(bool)Append);
        return _streamWriter;
    }
}

El método WriteLog, primero se añade la marca de tiempo si es necesario y luego llama al método WriteLine de un escritor corriente. Tenga en cuenta que Netduino no tiene reloj interno así que el tiempo registrado por Netduino no será la misma que la hora del reloj.

private static void WriteLog(string message, StreamWriter streamWriter, bool addDateTime, bool logToFile)
{
    if (addDateTime)
    {
        DateTime current = DateTime.Now;
        message = "[" + current + ":" + current.Millisecond + "] " + message;
    }
 
    Debug.Print(message);
    if (logToFile) streamWriter.WriteLine(message);
}

 

Salida

 

Utilización de la clase SerialPort pudimos enviar los datos al COM1 de Netduino llamando al método Write. Y el programa independiente COM Talk fue capaz de mostrar fielmente los datos entrantes a un puerto COM.

He aquí un pequeño vídeo de enviar datos desde Netduino a la computadora.

Descargar

C # .NET Code (Solución de archivos)

Fuente  aqui
Anuncios

Tutorial Netduino Parte 5


 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  donde se trataba la gestión  de un display de leds de 7 segmentos en esta   ocasión vamos   a tratar la  gestión de la escritura/lectura en una  memoria externa microsd   .

Memoria ampliable siempre es un plus, no importa si se trata de un teléfono, una cámara o un microcontrolador. Incluso es ventajoso si sabemos cómo usarlo. En esta parte (la quinta entrega ), vamos a aprender algunas operaciones de escritura sobre una tarjeta SD. Vamos a aprender cómo escribir en un archivo de texto, se muestra como un ejemplo de escritura de un registro. La clase Logger también es capaz de crear un archivo de texto en cualquier lugar determinado y luego escribir algo de información de texto a la misma.

 

Configuración de Circuito y Teoría

El  plus de incluir  la ranura de microsd  en Netduino +  y Neetduino 2+ ,    puede ser muy  util  (no  hay cables desordenados  ni mas módulos externos)

Cuando se inserta una tarjeta SD en la ranura, Netduino Plus automáticamente montarlo como directorio SD. Así que la raíz de particular es SD. El archivo logger, por defecto crea un registro en la ubicación SD \ Report \ logger.txt. Si tiene que escribir en una ubicación personalizada a continuación, utilizar el método LogCustom.

Después de iniciar sesión, por lo general al final de su programa, debe llamar al método Close de lo contrario la información no se guardará a menos que llame método Flush de la clase Logger.

C Programa # .NET

Escribir en un archivo de texto (o registro) se realiza a través de la clase Logger. Para hacer la vida poco más simple, hay algunas propiedades estáticas y métodos que se pueden llamar directamente a escribir en una tarjeta SD. Veamos el diagrama de clase de la clase Logger. Los métodos resaltados / propiedades son miembros estáticos.

Echemos un vistazo a algunos de los métodos principales de esta clase tales como registro, StreamWriter, etc. En el método, simplemente ponemos juntos todos los argumentos en una cadena y luego se llama a WriteLog.

 

public static void Log(params object[] strings)
{
    string message = string.Empty;
    for (int i = 0; i < strings.Length; i++)
    {
        message = message + strings[i].ToString() + " ";
    }
    WriteLog(message, StreamWriter, PrefixDateTime, LogToFile );
}

Uno de los argumentos utilizados es StreamWriter que es una propiedad y se crea una nueva instancia de StreamWriter cuando llamó por primera vez.

 

private static StreamWriter StreamWriter
{
    get
    {
        if (_streamWriter == null) _streamWriter = new StreamWriter(LogFilePath,(bool)Append);
        return _streamWriter;
    }
}

 

El método WriteLog, primero se añade la marca de tiempo si es necesario y luego llama al método WriteLine de un escritor corriente. Tenga en cuenta que Netduino no tiene reloj interno así que el tiempo registrado por Netduino no será la misma que la hora del reloj.

 

private static void WriteLog(string message, StreamWriter streamWriter, bool addDateTime, bool logToFile)
{
    if (addDateTime)
    {
        DateTime current = DateTime.Now;
        message = "[" + current + ":" + current.Millisecond + "] " + message;
    }
 
    Debug.Print(message);
    if (logToFile) streamWriter.WriteLine(message);
}

Cuando llamamos directamente la clase Logger y comenzamos registros envío como a continuación (código), la salida puede ser similar a la imagen de abajo

 

// Directly start logging, no need to create any instance of Logger class
Logger.LogToFile = true;    // if false it will only do Debug.Print()
Logger.Append = true;       // will append the information to existing if any
Logger.PrefixDateTime = true; // add a time stamp on each Log call. Note: Netduino time is not same as clock time.
 
// any number of arguments can be passed. They will appended by a white space
Logger.Log("All", "these", "will", "be", "combined", "in", "to", "one", "string");
Logger.Log("This should go into the second line.");
Debug.Print(Logger.LogFilePath);

He aquí un ejemplo de escritura a una ubicación personalizada

 

// Create an instance of Logger if you need to write to a custom location.
Logger customLogger = new Logger(@"One\OneOne", "one.txt", true);
customLogger.CustomPrefixDateTime = false;
customLogger.CustomLogToFile = true;
customLogger.LogCustom("All", "these", "will", "be", "combined", "in", "to", "one", "string", "-CustomLogger1.");
Debug.Print(customLogger.CustomFilePath);

Descarga

1) Código C # .NET (Solución de archivos)

Lo Siguiente

Ahora mismo, si usted necesita para comprobar lo que está escrito en la tarjeta SD, usted tiene que tomar físicamente la tarjeta y luego insertarlo en el ordenador, lo que obviamente, no quiere hacer más frecuencia. Por lo tanto, vamos a aprender acerca de la lectura en lugar de enviar la información del archivo de texto al ordenador a través de comunicación serie, ninguna necesidad de sacar la tarjeta!

 

 

 

Fuente aqui

Tutorial Netduino parte2


 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  donde se trataba al gestión  de I/O     en esta   ocasión vamos   a tratar la  gestion de un 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 dan un aspecto más profesional a su proyecto. Hoy vamos a explorar cómo conectar un LCD de caracteres HD44780 a Netduino para mostrar caracteres alfanuméricos. 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  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 los 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 Activar (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 fuente de 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, que profundize en la conexión de un LCD de caracteres , la comunicación en el modo de 4 bits y también  sobre los fundamentos de controlador HD44780 LCD. Para más detalles técnicos, ver Hitachi HD44780U (LCD-II) ficha técnica .

Conexión Con Netduino / Netduino Plus

C Programa # .NET

Hay dos maneras en que podemos mirar el programa, uno de una manera muy sencilla y la otra manera, obviamente, más compleja. En la  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.

 

LCD lcd = new LCD(
    Pins.GPIO_PIN_D11, // RS
    Pins.GPIO_PIN_D9,  // Enable
    Pins.GPIO_PIN_D7,  // D4
    Pins.GPIO_PIN_D5,  // D5
    Pins.GPIO_PIN_D3,  // D6
    Pins.GPIO_PIN_D1,  // D7
    20,                // Number of Columns
    LCD.Operational.DoubleLIne, // LCD Row Format
    4,                 // Number of Rows in LCD
    LCD.Operational.Dot5x8);    // Dot Size of LCD
 
lcd.ShowCursor = true;
lcd.Show("www.Embedded-Lab.comWelcome's you to Netduino Tutorial site.  Happy Learning! :)", 200, true);
Thread.Sleep(1000); // reading time for the viewe

 

 

 

 

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 Show. Hay dos métodos Mostrar, uno mostrará el texto dado todo a la vez y el otro método Show mostrará una letra a la vez.

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

 

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();
}

 

 

 

En la sección constructor, que, básicamente, crea algunos Outport, guarda las propiedades LCD y luego llama al método Initialize. En este método, establecemos las propiedades visuales, inicializar algunas matrices y luego preparar el 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 carta texto dado por carta como se puede ver el bucle está estructurado para cada carácter en el texto dado

 

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);
    }
}

 

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.

 

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

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[] 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 &amp; halfAddress[0]) &gt; 0);
    D5.Write((value &amp; halfAddress[1]) &gt; 0);
    D6.Write((value &amp; halfAddress[2]) &gt; 0);
    D7.Write((value &amp; halfAddress[3]) &gt; 0);
 
    Enable.Write(true);
    Enable.Write(false);
    //Debug.Print("Wrote " + value.ToString());
}

Salida

 

Después de conectar algunos cables, al ejecutar su código y visualizar el texto que usted quiere, pone una sonrisa en su rostro. Dependiendo del método que está utilizando dará a obtener resultados diferentes Show, uno 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.

 

Un pequeño vídeo basado en el siguiente código:

 

lcd.ShowCursor = true;
lcd.Show("www.Embedded-Lab.comWelcome's you to Netduino Tutorial site.  Happy Learning! :)", 200, true);
Thread.Sleep(1000); // reading time for the viewer
 
lcd.ClearDisplay();
lcd.Show("That was cool! Let's clear the display and show all text at once", 200, true);
Thread.Sleep(1000); // reading time for the viewer
 
lcd.ClearDisplay();
lcd.ShowCursor = false;
lcd.Show("ABCDEFGHILKLMnopqrstuvwxyz0123456789                              -Thanks!");

 

 

 

Descargas

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

2) archivo Flitizing

 

 

 

 

 

Fuente aqui

Curso básico de Netduino Plus Parte 1


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).

Los siguientes tutoriales  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.
LED parpadeante con diagrama del circuito de potenciómetro
Comenzaremos esta serie de tutoriales sobre  Netduino con un proyecto muy básico de parpadear un LED. El objetivo de este proyecto es explorar conceptos básicos de pines Netduino de E / S, así como para asegurarse de que todo está configurado correctamente, incluyendo la instalación de software y configuración del hardware.En este proyecto, vamos a utilizar un pin analógico para leer la salida analógica de un potenciómetro, y un pin digital a parpadear un LED.

La frecuencia de parpadeo de LED se varía basándose en la salida del potenciómetro. Se parpadeará en un intervalo de 10 milisegundos a 1000 milisegundos basándose en la posición del limpiador del potenciómetro. En Netduino, puede establecer el rango de salida del ADC de 10 bits de un código port.Writing analógico si se lleva a cabo en Visual Studio con C # como lenguaje de programación.
Podemos dividir el experimento en dos partes, primero alrededor de la entrada analógica, que esa  alrededor del potenciómetro y segunda vuelta de la E / S digital es decir, alrededor de transistor y LED.  En la sección analógica, simplemente conectamos dos terminales finales de potenciómetro a masa y 3v3 y el conductor central al puerto A1 del Netduino.
En el código, han definido el alcance de este dispositivo analógico de 10 milisegundos a 1000 milisegundos.Así que, cuando se hace girar el cursor del potenciometro (su resistencia se cambia), el microcontrolador nos alimenta a un valor entre rango dado en consecuencia. Hemos convertido nuestra señal analógica a señal digital! . El potenciómetro es un dispositivo analógico y varió su valor de 10 milisegundos a 1 segundo. En la segunda mitad de la conexión, el D1 (Digital I / O) de Netduino está conectado a la base de un transistor junto con un resistor . Cuando abrimos el puerto D1 a alta, el transistor alcanzará su estado de saturación y por lo tanto la corriente comienza a fluir a lo largo de la base y del colector . En el momento esto sucede, nuestro LED se encenderá, porque un circuito completo se forma a partir 5v al suelo. En consecuencia, cuando el puerto D1 es baja, no circulará corriente a través de la base y el colector causando un circuito incompleto de 5V a la tierra. De ahí LED se apagará.

// use any analog pin
AnalogInput aInPin = new AnalogInput(Pins.GPIO_PIN_A1);
 
// give a range.
aInPin.SetRange(10, 1000); 
 
// at D1, we will send signal for LED
OutputPort led = new OutputPort(Pins.GPIO_PIN_D1, false);
 
while (true)
{
    // Read Pot value
    int potValue = (int)aInPin.Read();
    Debug.Print("Pot Value: " + potValue.ToString());
 
    // turn LED ON
    led.Write(true);
    // let it be ON for potValue
    Thread.Sleep(potValue);
 
    // turn LED OFF and let it stay OFF for potValue
    led.Write(false);
    Thread.Sleep(potValue);
}

Como podemos ver en el programa es muy simple.Las primeras líneas crean una instancia AnalogInput y establecer su rango de 10 a 1000. Luego, otra instancia de puerto de salida se ha creado para enviar la señal a un LED. Entonces tenemos un bucle infinito muy simple que se convertirá el LED de encendido y apagado. El valor de retardo viene de la entrada analógica que es un potenciómetro en nuestro caso.  Si el valor analógico es de 50, el LED se encenderá durante 50 milisegundos y luego se quedan fuera de la misma cantidad de tiempo.

Como salida de este ejemplo usted verá el LED parpadeará y su tasa de parpadeo depende de potenciómetro (pot) valor. Si gira el potenciometro hasta el final a uno de los extremos, el led permanecerá encendido durante un segundo y OFF por un segundo.Del mismo modo, si a su vez  lo gira  todo el camino hasta el otro lado, el LED aparecerá parpadeando, ya que sólo se queda ON por décima de segundo como podemos ver en el siguiente video.

1) C#.NET código (Fichero de solución)

2) Esquema en Fritzing File

 

 

Fuente  aqui

Tutorial Netduino Parte 3


 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  donde se trataba la gestión  de un display  LCD     en esta   ocasión vamos   a tratar la  gestion de un display  de 7 segmentos de  led   con nuestro Netduino

 

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. La forma en que están interrelacionadas de las siete segmentos LED se conoce como multiplexado, lo que permite ahorrar algunos pines de E / S de Netduino en comparación con la conducción de forma individual Los siete LED de segmento son los recursos y hambrientos de poder, sino que van a hacer este experimento sólo para conseguir nuestros pies mojados en el microcontrolador o incrustado mundo y entender los conceptos básicos de un niño de siete segmentos de pantallas LED.

 

En el experimento de hoy, vamos a leer una tensión analógica de un sensor LDR y mostrar la salida del ADC en cuatro de siete LEDs de segmento. Como debe saber siete segmentos LED se hace con siete más un LEDs. Cada LED tiene su propio nombre, como podemos ver en la imagen.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. Ahora, digamos que tenemos que mostrar “12” La forma en que hacemos es, se muestra “1” en una de unidad de LED y luego apagarlo y luego vamos a mostrar “2” en la segunda unidad de LED y luego apagarlo también, pero vamos a convertir en la primera. Por lo tanto, vamos a alternar la visualización de cada letra en un bucle que resulta en todo el dígito que nos gusta mostrar. Esto básicamente es la multiplexación.

Configuración de Circuito y Teoría

En este tutorial también, podemos dividir nuestras conexiones en dos categorías, analógico y digital. 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á causar el cambio en el voltaje.> Este tipo de conexión se denomina en algún momento como divisor de tensión.La caída o subida de tensión a través de la LDR serán un insumo para nuestro pin analógico.

En la sección digital, las conexiones son sencillas. Cada pin (a hasta g) de los siete segmentos LED están conectados a la E / S digital de la Netduino través de una resistencia y de nuestro código somos control que a su vez alta o baja. Los siete segmentos LED utilizado en este tutorial es un cátodo común y hay cuatro unidades de ellos combinados en uno cuya conexión interna se parece a esto.

Para encender el LED, tenemos que ajustar los pines de ánodo a cátodo alta y seleccionado a tierra. La pregunta es, ¿cómo podemos conectar a tierra el pin seleccionado cuando necesitamos? Si somos capaces de conectar un interruptor y luego alternar el interruptor cuando necesitan a tierra va a trabajar para nosotros. Para facilitar esto, podemos utilizar transistor como interruptor. Conexión transistor como interruptor es lo que ya hemos aprendido en primer tutorial . Como se muestra en el circuito, hemos conectado la base de cada transistor a cierta E / S digital de nuestra Netduino, emisor está conectado a tierra y el colector está conectado a ánodos de siete segmentos LED. Cuando la base del transistor está ajustado a alta, el interruptor de transistor se enciende entonces el ánodo correspondiente se conecta a tierra, que completa el circuito y convierte el LED ON.

Conexión con Netduino o Netduino Plus

C Programa # .NET

Esta vez nuestro código es poco intensiva como he creado 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);  //use any analog pin
    aInPin.SetRange(0, 1234); //give a range.
 
    Debug.Print("Analog value: " + aInPin.Read());
 
    // initialize the seven segments LED and pass appropriate pins
    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 });
 
    // Display value read by analog device
    sevenSegments.FlickerDelay = 5; // Pause between each letter during repetition in a LED unit
    sevenSegments.UnitSevenSegmentLedDelay = 1; //Duration of a LED unit being ON
    sevenSegments.UnitRepetition = 50; // Repetition of entire strip
    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 pasadores de ánodo o cátodo común son recibidos como una matriz. Ahora, para mostrar una carta o un alfabeto, he 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)
{
    // (wire color is for personal reference)
    OutputPort PinD0Out_a = new OutputPort(a, false); //11  Black 
    OutputPort PinD1Out_b = new OutputPort(b, false); //7   Brown
    OutputPort PinD2Out_c = new OutputPort(c, false); //4   Red
    OutputPort PinD3Out_d = new OutputPort(d, false); //2   orange
    OutputPort PinD4Out_e = new OutputPort(e, false); //1   Yellow
    OutputPort PinD5Out_f = new OutputPort(f, false); //10  Green
    OutputPort PinD6Out_g = new OutputPort(g, false); //5   Blue
 
    segmentPins = new OutputPort[] { PinD0Out_a, PinD1Out_b, PinD2Out_c, PinD3Out_d,
                                                PinD4Out_e, PinD5Out_f, PinD6Out_g };
 
    // initialize commonAnodeCathodePin
    ledSegmentUnit = new OutputPort[commonAnodeCathodePin.Length];
    for (int i = 0; i &lt; commonAnodeCathodePin.Length; i++)
    {
        ledSegmentUnit[i] = new OutputPort(commonAnodeCathodePin[i], false);
    }
 
    // create a list of supported display
    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 });
 
    // Initialize fields to its default
    FlickerDelay = 5;
    SevenSegmentsUnits = commonAnodeCathodePin.Length;
    UnitSevenSegmentLedDelay = 0;
    UnitRepetition = 50;
    RightToLeft = true;
}

Para mostrar un dígito o alfabeto, hemos expuesto un método Show de la clase. Hay tres sobrecargas de este método Show. 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, 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)
{
 
    // this loop will make it appear that all the LED units remained ON.
    for (int j = 0; j &lt; UnitRepetition; j++)
    {
 
        if (RightToLeft)
        {
            int ledUnit = SevenSegmentsUnits - 1; // 0 based index
 
            for (int i = stringToShow.Length; i &gt; 0; i--)
            {
                string eachLetter = stringToShow.Substring(i - 1, 1);
                Show(eachLetter, ledUnit);
                ledUnit -= 1;
 
                // If length of  stringToShow is greater than SevenSegmentsUnits rest it
                if (ledUnit &lt; 0) ledUnit = SevenSegmentsUnits - 1; // - 1 as it's 0 based index
 
                Thread.Sleep(UnitSevenSegmentLedDelay);
            }
        }
        else
        {
            int ledUnit = 0; // 0 based index
            for (int i = 0; i &lt; stringToShow.Length; i++)
            {
                string eachLetter = stringToShow.Substring(i, 1);
                Show(eachLetter, ledUnit);
                ledUnit += 1;
 
                // If length of  stringToShow is greater than SevenSegmentsUnits rest it
                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 mostrar es decir, en el que el aparato la visualización LED. Desde la HashTable definido durante la construcción, se entera de la matriz correcta de Boole entonces pin correspondiente se establece en alta o baja en base a esta matriz booleana. En el paso final, todos los pasadores de ánodo o cátodo común se establecen en baja, entonces sólo la unidad LED apropiado se establece en alto

 

public void Show(string numberString, int ledUnit)
{
    bool[] ledSegmentOnOffValues;
    numberString = numberString.ToLower();
 
    // at this level, string of unit lenght is supported so drop the rest
    if (numberString.Length &gt; 1) numberString =
             numberString.Substring(numberString.Length - 1, 1);
 
    // Send Low to the common anode/cathode of SevelSegmentLED
    for (int i = 0; i &lt; ledSegmentUnit.Length; i++)
    {
        ledSegmentUnit[i].Write(false);
    }
 
    if (!ledSegmentTable.Contains(numberString))
    {
        // when non supported letter is passed display "-"
        ledSegmentOnOffValues = (bool[])ledSegmentTable["-"];
    }
    else
    {
        // get the true/false array
        ledSegmentOnOffValues = (bool[])ledSegmentTable[numberString];
    }
 
    for (int i = 0; i &lt; segmentPins.Length; i++)
    {
        //make the corresponding pin high
        segmentPins[i].Write(ledSegmentOnOffValues[i]);
    }
 
    // Only send signal to the selected Anode/Cathode
    ledSegmentUnit[ledUnit].Write(true);
}

La expansión de SevenSegments Clase con un contador

Con muy pocas líneas de código podemos ampliar o añadir funcionalidades adicionales como un contador que cuenta del 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 ha configurado 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 &lt;= maxValue; i++)
    {
        Show(i);
        Debug.Print(i.ToString());
    }
}

Salida

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étodo de venta libre que hemos añadido a nuestra clase SevenSegments. Con el siguiente código, vamos a ver los números de contar en SevenSegments LED 980-1020

sevenSegments.FlickerDelay = 5; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 1; //Duration of a LED unit being ON
sevenSegments.UnitRepetition = 5; // Repetition of entire strip
sevenSegments.RightToLeft = true;
while (true)
{
    sevenSegments.Counter(980, 1020);
}

 

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

 

sevenSegments.FlickerDelay = 10; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 500; //Duration of a LED unit being ON
sevenSegments.UnitRepetition = 1; // Repetition of entire strip
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; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 200; //Delay Duration of a LED unit being ON
sevenSegments.UnitRepetition = 50; // Repetition of entire strip
sevenSegments.RightToLeft = false;
while (true)
{
    sevenSegments.Show("-Lab");
}

 

 

Y para terminar , es el siguinte video podermos ver el código presentado ejecutandose con al electrónica descrita

Fuente   aqui