Tutorial Netduino Parte 7

Tutorial sobre el uso de la Modulación de ancho de pulso con Netduino


 

 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 http://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

El primer libro de Netduino 2 en Español

Por fin esta disponible el primer libro en español sobre Netduino 2+ que intenta cubrir un vacío que existe en el mundo hispano-hablante respecto a la plataforma Netduino intentando ser una referencia tanto para las personas que ya manejan dicha plataforma, como para las personas que se inician por primera vez , para que de forma gradual vayan empezando a entender los entresijos de la programacion en c# de forma muy sencilla y su relación con el mundo hardware


En los últimos años, electrónica e informática han pasado de ser algo que sólo los ingenieros podían comprender, a estar accesible a todo el público en general sin necesitar demasiados conocimientos técnicos.

Netduino  como  tantas veces  se ha  hablado en  este blog,  precisamente ha crecido hasta convertirse en una parte de esta revolución, proporcionando en una placa del tamaño de una carta un potente entorno gracias a la depuración de programación basada en eventos, multi-threading, ejecución línea a línea, inserción de puntos de interrupción, etc, permitiendo tanto capturar como controlar dispositivos desde Internet de una manera mucho más sencilla y rápida comparada con otras plataformas basadas en   hardware. abierto.

portada libro

 

A propósito del libro , EL PRIMER LIBRO SOBRE NETDUINO 2 EN ESPAÑOL: Proyectos domóticos paso a paso para todos los niveles, por el momento disponible  en formato kindle  en  Amazon  ,pero muy pronto tambien disponible en papel ( en color y también  en versión eco de bajo coste),   éste intenta cubrir un vacío que existe en el mundo hispano-hablante respecto a  la  plataforma   Netduino 2+ intentando ser una referencia, tanto a las personas que ya manejen esta plataforma para profundizar en algunos aspectos, como aquellas otras que se inician por primera vez, para que de forma paulatina, vayan empezando a entender los entresijos de la programación en c# y su relación con el mundo físico.

La lectura de este nuevo  libro comienza intentando comprender el hardware  de Netduino y su evolución hacia Netduino 2+, este último sobre el que se centrará el resto del libro, explicando con detalle cómo instalar las herramientas necesarias.
Una vez el entorno preparado, lo primero es probar la comunicación y, tras esto, ya podemos a empezar a escribir nuestro propio primer programa haciendo encender o apagar un led (cap. 2 y 3).
Cuando controlamos salidas binarias lo siguiente es manejar las entradas binarias, lo cual se ilustra con un ejemplo que usará el pulsador interno (cap. 4).
Otro tema interesante puede ser PWM (cap. 5) que puede usarse en infinidad de aplicaciones y que, como ejemplo, usaremos para variar el brillo de un led.

En los capítulos siguientes se tratan los diferentes sensores que podemos utilizar en domótica empezando por los sensores de ruido (cap.6) para lo cual necesitaremos el procesamiento de señales analógicas que se trata con un ejemplo. Otro aspecto interesante son los sensores de posición que también se tratan con un ejemplo real (cap. 7).
En domótica aparte de las entradas y salidas binarias también se usan sensores de variables físicas como por ejemplo los sensores de temperatura, de luz o de movimiento que se tratan en los cap. 8,9 y 10 (terminando también cada uno con un ejemplo).
Una mención especial lo ocupa el cap.11 donde se tratan los sensores de consumo eléctrico tan usuales para monitorizar y optimizar nuestro consumo energético. Como no podría ser menos, también se proponen varios ejemplos de manejo real de éstos.
Una vez tratados la mayoría de los sensores, se explica cómo conectar Netduino 2 con un display LCD compatible con el estándar HD44780 para desplegar información en éste que nos interese viéndolo con dos ejemplos reales (cap12).
En los siguientes capítulos se describen cómo es posible acceder a todos los sensores y actuadores descritos (y por supuesto todos los que el lector decida) de forma remota, gracias a la conectividad tcp-ip que integra la misma placa Netduino 2 plus.
En primer lugar se trata de explicar los entresijos una aplicación que instalaremos en Netduino 2 plus que hace de servidor web, el cual nos va a permitir interactuar de forma remota con éste.
Y hablando de control ¿qué mejor que desarrollar una app para permitirnos controlar Netduino 2 a distancia? Pues para ello, se tratara primero de las generalidades de MIT App Inventor (cap14), entorno que nos va a permitir desarrollar una app móvil de una forma muy sencilla desde la nube.

Finaliza  el libro con el desarrollo de una aplicación móvil real que será capaz de interactuar desde Internet con todo el hw descrito en capítulos anteriores , haciendo de colofón del libro ,mostrando de esta forma cómo es posible hacer aplicaciones móviles que interactúen de forma remota con N2 plus de una forma sencilla

 

Espero   que   este libro  pueda  ayudar a comprender  y a  usar esta estupenda plataforma  como es Netduino+

 

Más  información  aqui

M2M con Netduino y Yaler

yaler externo con Netduino


Netduino puede  ser  accesible desde cualquier lugar a través de la infraestructura de retransmisión Yaler.Como requisitos previos  para la configuración de su dispositivo requiere un Framework   que puede instalarse uno mismo   en un servidor Linux  o Windows  o si no lo dispone puede registrarse en Yaler para obtener una cuenta gratis para conseguir uno.
Para  hacerlo  funcionar usaremos la  biblioteca Gsiot.Server de Cuno Pfister que se ejecuta en   Netduino Plus , Netduino Plus 2 , Mountaineer y otra spalacas   NET Micro Framework. .

Siga estos pasos en el equipo de Windows para asegurarse de que DHCP del Netduino está activado y una dirección MAC está establecida:

  1. Inicio MFDeploy.exe situado en
      C:.. \ Archivos de programa (x86) \ Microsoft NET Micro Framework \ v4 x \ Tools \ MFDeploy.exe
  2. Seleccione el tipo de dispositivos USB
  3. Conecte su Netduino a través de USB
  4. Haga clic en el botón Ping hasta que el Netduino responde con
      Haciendo ping a ...  TinyCLR
  5. Para abrir el cuadro de diálogo de configuración de red, seleccione el menú
      Target> Configuración> Conexiones de red
  6. Asegúrese de que la casilla de verificación Habilitar DHCP se comprueba
  7. Asegúrese de que la dirección MAC es la misma que la dirección impresa en la etiqueta en su Netduino
  8. Haga clic en Actualizar para guardar los cambios en el Netduino
  9. Reinicie el Netduino desenchufando y enchufando el cable USB
  10. Hecho.

Instalación de la biblioteca Gsiot.Server

Siga estos pasos para agregar la biblioteca Gsiot.Server de Cuno Pfister para Visual Studio.

  1. Para Netduino Plus, descarga
      Proyectos + V20110526 ...  . Zip

    Para Netduino Plus 2 o tableros Mountaineer, descarga

      Muestras Gsiot + + para + NETMF 4.2 ...  . Zip
  2. En Windows, abra el ZIP y copiar las carpetas Gsiot.Server y HelloWeb (y, si están disponibles, Oberon.Netmf.Compatibility)para
      C: \ Users \ nombre_usuario \ Documents \ Visual Studio 2012 \ Projects
  3. Hecho.

Ejecución de un ejemplo de servicio Web

  1. En Windows en Visual Studio, abra el proyecto
      HelloWeb
  2. Reemplace <insertar su dominio de retransmisión here> con su dominio de retransmisión, por ejemplo, para el relé de dominio gsiot-ffmq-ttd5 que sería
      RelayDomain = "gsiot-ffmq-ttd5",
  3. Reemplace <insertar su here> clave secreta con su clave, por ejemplo, para la claveo5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89 eso sería
      RelaySecretKey = "o5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89",
  4. Construir y cargar el código de ejemplo a su Netduino
  5. Hecho. Ahora, ver cómo acceder a su dispositivo desde un navegador Web o con Curl (añadir /hello para que funcione).

Fuente aqui