Tutorial Netduino Parte 4


 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 un  display  de  siete segmentos LED usando el circuito integrado MAX7215. Como este circuito integrado es compatible con el protocolo de comunicación SPI, se requerirá sólo 3 números de cables para controlar nuestro segmento de siete LED. De ocho dígitos de siete segmentos Display LED con MAX7219

Hemos  aprendido lo básico de siete segmentos pantallas LED acerca de una técnica de multiplexación por división de tiempo que reduce el número de microcontrolador requerido pines I / O para conducir múltiple de siete segmentos LED. Hoy vamos a dar un paso más allá y discutir acerca de una interfaz en serie (SPI) para la conducción de 8 pantallas LED de siete segmentos. La técnica utiliza el chip controlador MAX7219 LED MAXIM que le permite controlar 8 (o más en la configuración en cascada) común de cátodo de siete segmentos LED pantallas con sólo 3 pins E / S de Netduino. Para fines ilustrativos, utilizaremos nuestra serie de siete LED segmento de 8 dígitos módulo de visualización (8DSSSLED) aquí. La ventaja de utilizar MAX7219 es, que va a hacer todo el trabajo duro de la operación de multiplexación y dejar que el microcontrolador hacer trabajos más importantes. Es compatible con SPI protocolo de comunicación serial.

Configuración de Circuito y Teoría

El método de comunicación SPI es el corazón del proyecto, además de los códigos que controlan lo que desea mostrar en los siete segmentos LED. En nuestra configuración, Netduino Plus actúa como dispositivo maestro SPI y 8DSSSLED como un esclavo. Entre los varios pines E / S digital de Netduino, pernos 11, 12 y 13 están diseñados para apoyar la comunicación SPI Bus. Pin 12 es Maestría En Slave Out (MISO), el pin 11 es Master Out Slave In (MOSI), y el pasador 13 sirve como reloj maestro. En nuestro proyecto el Netduino Plus no recibe datos desde el dispositivo esclavo (MAX7219), por lo que el pin MISO no se utiliza. El pin MOSI (11) de Netduino va a DIN de 8DSSSLED y el pasador 13 unidades de la señal CLK de MAX7219. La señal de carga (que es un pasador Selección de Chip de MAX7219) de la junta 8DSSSLED se puede conectar a cualquier E / S digital de un microcontrolador. En nuestro caso hemos especificado esta al pin 10 de Netduino.

 

C Programa # .NET

El programa se centró básicamente en torno a la unidad MAX7219 luego adaptada hacia el 8DSSSLED. El .NET Micro Framwork proporciona una clase SPI por lo que no tenemos que preocuparnos demasiado por el trabajo con SPI. Vamos a aprender más acerca de la SPI en un momento. Echemos un vistazo a la información general de esta clase. Todos los métodos y propiedades se pueden ver en la imagen siguiente. La clase MAX7219, la mayoría de las veces, desactiva el modo BCDDecode y por lo tanto, controla segmentos individuales para mostrar los caracteres alfanuméricos.

Para utilizar la clase MAX7219 primero tenemos que crear una instancia de esta clase y directamente llamar a los métodos de visualización relacionado para mostrar la prueba / números en los siete segmentos LED. En el siguiente ejemplo también estamos estableciendo la intensidad, la limpieza de la pantalla, ajustar el textDirection a LeftToRight.

max = new Max7219(Pins.GPIO_PIN_D10);
max.SetIntensity(Max7219.Intensity.Max);
 
max.LeftToRight = true;
max.DisplayAutoScorllFirstHalf("i_am on first line.", 1000);

Vamos a hablar de la utilización de la MAX7219 en la sección de salida, así que vamos a ver la clase MAX7219. Siguiendo sección muestra el constructor de la clase. Note el argumento no requiere ninguna de las patas SPI sino que pide el pin de datos que es de E / S 10 en nuestro caso. Se puede ver en primer lugar definimos la configuración SPI y luego siempre que a la nueva instancia SPI. Entonces salta al método initialize ().

///

/// Netduino Pin:
/// D11 – SPI MOSI –> DIn of Board
/// D12 – None
/// D13 – SPI CLK –> CLK of Board
///

///
Load pin of Board
public Max7219(Cpu.Pin chipSelect)
{
    SPI.Configuration spiConfiguration = new SPI.Configuration(chipSelect, false, 0, 0, false, true, 2000, SPI.SPI_module.SPI1);
    Spi = new SPI(spiConfiguration);
    Initialize();
}

El método Initialize básicamente inicializa algunos campos y luego crea un Hashtable para los caracteres admitidos. Se llama a algunos otros métodos como EnableDigits, DisplayTest y cierre del sistema para hacer que los siete segmentos listo para tomar la entrada. A medida que estos métodos se definen público, podemos llamar a estos fuera de la clase cuando sea necesario.

Echemos un vistazo a los métodos básicos que controlan el MAX7219 IC.

public void Initialize()
{
    segmentsOneAtaTime = new byte[] { 0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00 };
    segmentsPbarAscending1By1 = new byte[] { 0x00, 0x40, 0x60, 0x70, 0x78, 0x7C, 0x7E };
    segmentsPbarDescending = new byte[] { 0x3E, 0x1E, 0x0E, 0x06, 0x02, 0x00 };
    segmentsPbarAscendingAll = new byte[] { 0x7E, 0x5E, 0x6E, 0x76, 0x7A, 0x7C, 0x3E, 0x7E };
 
 
    CharacterAddressMap = new Hashtable();
    CharacterAddressMap.Add("0", 0x7E);
    CharacterAddressMap.Add("1", 0x30);
    CharacterAddressMap.Add("2", 0x6D);
    CharacterAddressMap.Add("3", 0x79);
    CharacterAddressMap.Add("4", 0x33);
    CharacterAddressMap.Add("5", 0x5B);
    CharacterAddressMap.Add("6", 0x5F);
    CharacterAddressMap.Add("7", 0x70);
    CharacterAddressMap.Add("8", 0x7F);
    CharacterAddressMap.Add("9", 0x7B);
    CharacterAddressMap.Add("A", 0x77);
    CharacterAddressMap.Add("B", 0x1F);
    CharacterAddressMap.Add("C", 0x4E);
    CharacterAddressMap.Add("D", 0x3D);
    CharacterAddressMap.Add("E", 0x4F);
    CharacterAddressMap.Add("F", 0x47);
    CharacterAddressMap.Add("G", 0x5E);
    CharacterAddressMap.Add("H", 0x37);
    CharacterAddressMap.Add("I", 0x30);
    CharacterAddressMap.Add("J", 0x3C);
    CharacterAddressMap.Add("K", 0x2F);
    CharacterAddressMap.Add("L", 0x0E);
    CharacterAddressMap.Add("M", 0x55);
    CharacterAddressMap.Add("N", 0x15);
    CharacterAddressMap.Add("O", 0x1D);
    CharacterAddressMap.Add("P", 0x67);
    CharacterAddressMap.Add("Q", 0x73);
    CharacterAddressMap.Add("R", 0x05);
    CharacterAddressMap.Add("S", 0x5B);
    CharacterAddressMap.Add("T", 0x0F);
    CharacterAddressMap.Add("U", 0x3E);
    CharacterAddressMap.Add("V", 0x1C);
    CharacterAddressMap.Add("W", 0x5C);
    CharacterAddressMap.Add("X", 0x49);
    CharacterAddressMap.Add("Y", 0x3B);
    CharacterAddressMap.Add("Z", 0x6D);
    CharacterAddressMap.Add(" ", 0x00); // white space
    CharacterAddressMap.Add(".", 0x80);
    CharacterAddressMap.Add("-", 0x01);
    CharacterAddressMap.Add("_", 0x08);
 
    SpiWriteBuffer = new ushort[1];
    EnableDigits(8);
 
    DisplayTest(false);
    ShutDown(false);
    Clear();
}
public void Clear(byte numberOfDigits = 8)
{
    for (byte i = 1; i <= numberOfDigits; i++)
        Write(i, 0x00);
}
public void SetIntensity(Intensity intensity)
{
    Write((byte)RegisterAddressMap.Intensity, (byte)intensity);
}
public void SetBCDDecodeMode(BCDDecodeMode decodeMode)
{
    Write((byte)RegisterAddressMap.DecodeMode, (byte)decodeMode);
}
public void DisplayTest(bool enable)
{
    if (enable)
        Write((byte)RegisterAddressMap.DisplayTest, 0x01);
    else
        Write((byte)RegisterAddressMap.DisplayTest, 0x00);
}
public void ShutDown(bool shutDown)
{
    if (shutDown)
        Write((byte)RegisterAddressMap.Shutdown, 0x00);
    else
        Write((byte)RegisterAddressMap.Shutdown, 0x01);
}
public void Write(byte register, byte value)
{
    SpiWriteBuffer[0] = (ushort)register;
    SpiWriteBuffer[0] <<= 8;
    SpiWriteBuffer[0] |= value;
    Spi.Write(SpiWriteBuffer);
 
    Debug.Print(SpiWriteBuffer[0].ToString());
}

Ahora, vamos a ver los métodos que controla la visualización de los LEDs.
El método Blink, simplemente apaga la unidad durante el tiempo dado y lo hace que para un número dado de tiempo.

public void Blink(int times, int delay)
{
    for (int i = 0; i < times; i++)
    {
        Thread.Sleep(delay);
        ShutDown(true);
        Thread.Sleep(delay);
        ShutDown(false);
    }
}

El método principal que se encarga de mostrar la información en el 8DSSSLED es el método de visualización en cadena dada es enrollado para cada carácter de la cadena y luego llama al método de escritura a través _ Método de visualización.

public void Display(string value, byte startDigit)
{
    char[] texts = value.ToCharArray();
    string displayText;
 
    for (int i = 0; i < texts.Length; i++)
    {
        displayText = texts[i].ToString().ToUpper();
        if (CharacterAddressMap.Contains(displayText))
            _Display((byte)startDigit, Convert.ToByte(CharacterAddressMap[displayText].ToString()));
 
        if (LeftToRight)
            startDigit -= 1;
        else
            startDigit += 1;
    }
}

Se añade la funcionalidad de desplazamiento automático on DisplayAutoScroll , DisplayAutoScrollFirstHalf and DisplayAutoScrollSecondHalf methods. DisplayAutoScroll uses los 8 dígitos de los siete segmentos LED mientras DisplayAutoScrollFirstHalf y DisplayAutoScrollSecondHalf utiliza sólo cuatro primeros y los últimos cuatro dígitos respectivamente. El primer argumento es la información para mostrar y segundo argumento de retardo para mantener la pantalla durante mucho tiempo hasta que si se desplaza a otro caracter.

public void DisplayAutoScroll(string value, int delay)
{
    SetBCDDecodeMode(BCDDecodeMode.Disable);
    string text;
 
    byte startDigit = 8;
    if (!LeftToRight) startDigit = 1;
 
    for (int i = 0; i < System.Math.Max(value.Length - 8 + 1, 1); i++)
    {
        text = value.Substring(i, System.Math.Min(8, value.Length));
        Display(text, startDigit);
 
        Thread.Sleep(delay);
    }
}
public void DisplayAutoScorllFirstHalf(string value, int delay)
{
    SetBCDDecodeMode(BCDDecodeMode.Disable);
    string text;
 
    byte startDigit = 4;
    if (!LeftToRight) startDigit = 1;
 
    for (int i = 0; i < System.Math.Max(value.Length - 4 + 1, 1); i++)
    {
        text = value.Substring(i, System.Math.Min(4, value.Length));
        Display(text, startDigit);
 
        Thread.Sleep(delay);
    }
}
public void DisplayAutoScorllSecondHalf(string value, int delay)
{
    SetBCDDecodeMode(BCDDecodeMode.Disable);
    string text;
 
    byte startDigit = 8;
    if (!LeftToRight) startDigit = 5;
 
    for (int i = 0; i < System.Math.Max(value.Length - 4 + 1, 1); i++)
    {
        text = value.Substring(i, System.Math.Min(4, value.Length));
        Display(text, startDigit);
 
        Thread.Sleep(delay);
    }
}

La clase MAX7219 también proporciona una manera agradable de mostrar una señal de ocupado en los siete segmentos LED. Es compatible con los cuatro métodos principales que se pueden duplicando estableciendo la dirección (hacia la derecha / hacia la izquierda).

public void DisplayBusy(bool clockwise, int delay, BusyStyle style)
{
    byte[] segments;
    switch (style)
    {
        case BusyStyle.OneAtaTime:
            segments = segmentsOneAtaTime;
            break;
        case BusyStyle.ProgressBarAscending1By1:
            segments = segmentsPbarAscending1By1;
            break;
        case BusyStyle.ProgressBarDescending:
            segments = segmentsPbarDescending;
            break;
        case BusyStyle.ProgressBarAscendingAll:
            segments = segmentsPbarAscendingAll;
 
            break;
        default:
            segments = segmentsOneAtaTime;
            break;
    }
 
 
    SetBCDDecodeMode(BCDDecodeMode.Disable);
    byte digits = 0;
 
 
    if (clockwise)
    {
        for (byte i = 1; i < 8 + 1; i++)
        {
            for (int j = 0; j < segments.Length; j++)
            {
                digits = LeftToRight ? (byte)(8 - i + 1) : i;
                _Display(digits, segments[j]);
                Thread.Sleep(delay);
            }
        }
    }
    else
    {
        for (byte i = 1; i < 8 + 1; i++)         {             for (int j = segments.Length - 1; j-- > 0; )
            {
                digits = LeftToRight ? (byte)(8 - i + 1) : i;
                _Display(digits, segments[j]);
                Thread.Sleep(delay);
            }
        }
    }
}

Salida

Vamos utilizan la clase MAX7219 y lo utilizan para la visualización de resultados diferentes.

Siguiendo el ejemplo muestra la funcionalidad de desplazamiento automático en primeros cuatro dígitos y luego los cuatro últimos dígitos. El segundo argumento en el método es de retardo para mantener la pantalla durante mucho tiempo.

max = new Max7219(Pins.GPIO_PIN_D10);
max.SetIntensity(Max7219.Intensity.Max);
 
while (true)
{
    max.DisplayBusy(true, 100, Max7219.BusyStyle.OneAtaTime);
}
 
max.Clear();
max.LeftToRight = true;
max.DisplayAutoScorllFirstHalf("i_am on first line.", 1000);
 
max.LeftToRight = false;
max.DisplayAutoScorllSecondHalf("second line here", 1000);

Ahora vamos a utilizar tanto los cuatro primeros y últimos cuatro dentro de un bucle contador y también cambiar la luminosidad / intensidad al mismo tiempo.

Enviemos una larga cadena que se utiliza todos los dígitos y cambiar el LeftToRight true y luego en false para ver el efecto de desplazamiento.

max.LeftToRight = true;
max.DisplayAutoScroll("0123456789abcdefghijklmnopqrstuvwxyz.", 1000);
 
max.DisplayAutoScroll(" --  -- ", 0);
max.Blink(2, 200);
 
max.LeftToRight = false;
max.DisplayAutoScroll("0123456789abcdefghijklmnopqrstuvwxyz.", 1000);

Como se mencionó anteriormente, la clase MAX7219 ofrece algunas señales de ocupado, barra de progreso, así que vamos a echar un vistazo.

max.LeftToRight = true;
max.SetIntensity(Max7219.Intensity.Max);
max.DisplayBusy(true, 100, Max7219.BusyStyle.OneAtaTime);
max.DisplayBusy(false, 100, Max7219.BusyStyle.OneAtaTime);
 
max.Clear();
max.DisplayBusy(true, 100, Max7219.BusyStyle.ProgressBarAscending1By1);
 
 
max.Clear();
max.SetIntensity(Max7219.Intensity.Min);
max.DisplayBusy(true, 100, Max7219.BusyStyle.ProgressBarAscendingAll);
 
max.Clear();
max.DisplayBusy(false, 100, Max7219.BusyStyle.ProgressBarAscendingAll);
 
max.Clear();
max.SetIntensity(Max7219.Intensity.Average);
max.DisplayAutoScroll("00000000", 1); // turn all on
max.DisplayBusy(true, 100, Max7219.BusyStyle.ProgressBarDescending);

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