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

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

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s