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 < 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 < UnitRepetition; j++)
    {
 
        if (RightToLeft)
        {
            int ledUnit = SevenSegmentsUnits - 1; // 0 based index
 
            for (int i = stringToShow.Length; i > 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 < 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 < 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 > 1) numberString =
             numberString.Substring(numberString.Length - 1, 1);
 
    // Send Low to the common anode/cathode of SevelSegmentLED
    for (int i = 0; i < 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 < 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 <= 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

 

 

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