febrero 2015 – Página 3 – Soloelectronicos.com

Tutorial Netduino Parte 5

febrero 19, 2015mayo 9, 2024soloelectronicosDeja un comentario

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 Parte 4

febrero 18, 2015mayo 9, 2024soloelectronicosDeja un comentario

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