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