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 https://soloelectronicos.com/2015/02/24/tutorial-netduino-parte-6/ en esta ocasión vamos a tratar la gestión de PWM
Pulse Width Modulation (PWM) es un método digital de la entrega de una cantidad variable de energía a una carga, y por lo tanto se puede utilizar para controlar el brillo de un LED o la velocidad de un motor de corriente continua. El control de la potencia, haremos este tutorial colorido usando un Azul Verde Rojo (RGB) LED. Cada segmento (plomo) de RGB-LED obtendrá una señal PWM a través de la clase RGBLED lo que nos permite iluminar el LED RGB con cualquier color definido por RGB. Esta clase también puede generar colores al azar. Utilización de la clase RGBLED, algunos colores estándar también se pueden enviar a un LED RGB.
Configuración de Circuito y Teoría
Para entender PWM, vamos a entender los términos que conforman unas señales de ancho de pulso modulado. El uno es muy importante pues es del ciclo de trabajo. En términos flexibles este ciclo de trabajo es un valor en porcentaje del estado ON en comparación con el estado OFF. A partir de la figura siguiente podemos ver la fórmula para calcular el ciclo de trabajo.
Ahora, vamos a ver como co-relacionan lo anterior a nuestro proyecto. Digamos que nos gusta para producir un color «gris». Conocemos el valor RGB para el gris es de 128, 128 y 128. Esto significa, si mezclamos el 50% de rojo (50% de 256 es 128), el 50% de verde y 50% de azul, vamos a obtener un color gris . El valor de 50% provino de 128/256 * 100%. Con respecto a la figura anterior, si T = el 50% para la pierna roja, T = el 50% de la pierna verde y T en = 50% de la pata azul de un LED RGB entonces vamos a tener un color gris a partir de un LED RGB- . El valor calculado es nada más que el ciclo de trabajo de un PWM. En la clase RGBLED, que básicamente ajustar el ciclo de trabajo para iluminar el LED RGB con un color deseado.
Asi se muestra un ciclo de trabajo de hoja de cálculo Excel para entenderlo un poco mejor y también la explicación de la clase RGBLED.
Las conexiones no son tan difíciles. Pines digitales Netduino, 5, 6, 9 y 10 se pueden configurar como pines PWM, de los cuales vamos a configurar 5, 6 y 9. Las salidas de estos pines son alimentados a la base de un transistor NPN. Cuando el pulso es alta, el transistor entra en modo de saturación y permite el flujo desde el colector al emisor que está conectado nuestro RGB LED. Dado que el LED RGB usado en este tutorial es ánodo común, el plomo ánodo está conectado a + 5v. El diagrama del circuito siguiente muestra la conexión.
La imagen siguiente muestra la configuración de circuito en un circuito y sus conexiones con el Netduino.
C Programa # .NET
La utilización de la clase RGBLED es muy simple así que vamos a saltar todo por ahora y centrarnos en la propia clase. El constructor de la clase toma cuatro argumentos, el número de pin para el rojo, verde y azul y el último argumento es opcional para commonAnode lo cual es cierto por defecto (en el diagrama del circuito que no es demasiado importante si nos fijamos este valor a verdadero o falso).
En este método constructor nuevas instancias de la clase PWM están embalados luego una tabla de colores Hashtable se rellena con el color estándar.
public RgbLed(Cpu.Pin redPwmPin, Cpu.Pin greenPwmPin, Cpu.Pin bluePwmPin, bool commonAnode = true)
{
RedLED = new PWM(redPwmPin);
GreenLED = new PWM(greenPwmPin);
BlueLED = new PWM(bluePwmPin);
LEDs = new PWM[] { RedLED, GreenLED, BlueLED };
CommonAnode = commonAnode;
ColorTable = new Hashtable();
ColorTable.Add(0, new byte[] { 0, 0, 0 }); // Off (~~ Black color)
ColorTable.Add(1, new byte[] { 0, 100, 100 }); // Aqua
ColorTable.Add(2, new byte[] { 0, 0, 100 }); // Blue
ColorTable.Add(3, new byte[] { 100, 0, 100 }); // Fuchsia
ColorTable.Add(4, new byte[] { 50, 50, 50 }); // Gray
ColorTable.Add(5, new byte[] { 0, 50, 0 }); // Green
ColorTable.Add(6, new byte[] { 0, 100, 0 }); // Lime
ColorTable.Add(7, new byte[] { 50, 0, 0 }); // Maroon
ColorTable.Add(8, new byte[] { 0, 0, 50 }); // Navy
ColorTable.Add(9, new byte[] { 50, 50, 0 }); // Olive
ColorTable.Add(10, new byte[] { 50, 0, 50 }); // Purple
ColorTable.Add(11, new byte[] { 100, 0, 0 }); // Red
ColorTable.Add(12, new byte[] { 75, 75, 75 }); // Silver
ColorTable.Add(13, new byte[] { 0, 50, 50 }); // Teal
ColorTable.Add(14, new byte[] { 100, 100, 100 });// Whilte
ColorTable.Add(15, new byte[] { 100, 100, 0 }); // Yellow
}
|
Hay tres métodos públicos disponibles para el establecimiento de un color, el Turnit, escribir y métodos RandomColor. Tener color estándar, llamar al método Turnit y pasar el color estándar de color Enum. El método de escritura toma tres argumentos byte para el color rojo, verde y azul. Finalmente, RandomColor calculará número aleatorio para el valor de color rojo, verde y azul.
public void TurnIt(Color color)
{
if (ColorTable.Contains((int)color))
{
colorArray = (byte[])ColorTable[(int)color];
SetColor();
}
else
throw new Exception("Color not found");
}
public void Write(byte red, byte green, byte blue)
{
colorArray = new byte[] { (byte)(red * 100 / 255), (byte)(green * 100 / 255), (byte)(blue * 100 / 255) };
SetColor();
}
public void RandomColor()
{
Random random = new Random();
colorArray = new byte[] { (byte)random.Next(100), (byte)random.Next(100), (byte)random.Next(100) };
SetColor();
}
public override string ToString()
{
colorString = string.Concat("RGB(", colorArray[0], ", ", colorArray[1], ", ", colorArray[2], ")");
return colorString;
}
|
Todos los métodos públicos llaman internamente al método privado SetColor.Este básicamente cambia el ciclo de trabajo de las instancias de PWM para cada pin de lectura, verde y azul.
private void SetColor()
{
if (CommonAnode) colorArray = AdjustPolarityValue(colorArray);
LEDs[0].SetDutyCycle((uint)colorArray[0]); // Red
LEDs[1].SetDutyCycle((uint)colorArray[1]); // Green
LEDs[2].SetDutyCycle((uint)colorArray[2]); // Blue
}
private byte[] AdjustPolarityValue(byte[] colorArray)
{
return new byte[] { (byte)(100 - colorArray[0]), (byte)(100 - colorArray[1]), (byte)(100 - colorArray[2]) };
}
|
Aquí está la clase del diagrama RGBLED :
Salida
Para demostrar el uso de cada tres métodos públicos, hay tres partes en el vídeo. Primero se muestra el color estándar entonces se muestra el espectro de colores de bucle a través de diferentes lazos de color y finalmente un poco de color al azar.
En este código se busca mostrar algunos colores estándar
RgbLed led = new RgbLed(Pins.GPIO_PIN_D9, Pins.GPIO_PIN_D6, Pins.GPIO_PIN_D5, false ); // Display standard colors led.TurnIt(RgbLed.Color.Red); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Navy); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Purple); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Green); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Maroon); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Blue); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Fuchsia); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Teal); WaitAndTurnOff(500, led); led.TurnIt(RgbLed.Color.Yellow); WaitAndTurnOff(500, led); |
Para mostrar diferentes colores se utilizan tres bucles for en forma de cascada:
for (int red = 0; red < 255; red += 50)
{
for (int green = 0; green < 255; green += 50)
{
for (int blue = 0; blue < 255; blue += 50)
{
led.Write((byte)red, (byte)green, (byte)blue);
Debug.Print(led.ToString());
WaitAndTurnOff(100, led);
}
}
}
|
Y para generar los colores al azar (bucle 20 veces) se utiliza este código:
for (int i = 0; i < 20; i++)
{
led.RandomColor();
WaitAndTurnOff(500, led);
}
private static void WaitAndTurnOff(int time, RgbLed led, byte longerOn = 2)
{
Thread.Sleep(time * longerOn);
led.TurnIt(RgbLed.Color.Off);
Thread.Sleep(time);
}
|
Y por último un vídeo de salida rápida del código de seguridad.
Fuente aqui
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.