Modulación por ancho de pulso (PWM)

En esta pequeña introducción a la programación mediante señales PWM veremos qué significa exactamente este concepto, analizaremos ejemplos de código en Arduino y veremos algunos casos prácticos.

Concepto de PWM

PWM son las siglas de Pulse Width Modulation, que en español se traduciría como modulación por ancho de pulso. Una señal PWM consiste en una señal con una determinada frecuencia (y por lo tanto con un mismo periodo) que consta de dos valores fijos de tensión: uno alto (HIGH), que es la amplitud, y otro bajo (LOW), que es el valor nulo.

También consta de otro parámetro, que se denomina ciclo de trabajo (duty cycle), y que se refiere al porcentaje de tiempo que el pulso (la cantidad de voltaje entregada) está en activo durante un ciclo o periodo.

Otro parámetro importante es el ancho de pulso (PW – Pulse Width), que define el tiempo que dura el pulso.

Por tanto, el PWM es una técnica que consiste en variar el ancho de pulso de una señal de voltaje cuadrada con el objetivo de controlar la cantidad de potencia administrada a los componentes o elementos electrónicos conectados. De esta forma, con un ciclo de trabajo del 100 % entregaríamos los 5V totales; un ciclo de trabajo del 50 % entregaría un voltaje de 2.5 V; con un ciclo de trabajo del 10 % conseguiríamos un voltaje del 0.5 V; y así sucesivamente.

Para ilustrar este concepto, vamos a analizar un pequeño programa para controlar el siguiente montaje:

Como se puede observar en la imagen, conectamos el cátodo (-) de un LED directamente a un pin GND (tierra) de la placa y el ánodo (+) a una salida digital PWM, que en Arduino se señalan con el símbolo ~.

Para que sea más visual y fácil de comprender, en vez de programar usando el IDE de Arduino, lo haré mediante LabVIEW:

Si hacéis memoria, este es el mismo programa que ya usé en un post anterior (Arduino & LabVIEW (II). Control de un LED mediante PWM).

Con la barra deslizante (slider) podemos variar la tensión de salida de la señal PWM entre dos valores de tensión fijos (cada uno de los extremos). Los valores de 0 a 255 corresponden al mapeado de la función AnalogWrite de Arduino. 0 se corresponde con 0 voltios de tensión de salida y 255 se corresponden con 5 voltios de tensión de salida de la placa. Los valores entre 0 y 255 se corresponden con valores de tensión en el intervalo de 0 a 5 V. En el caso de la myRIO que utilizamos en el equipo UPCT Racing Team, los valores del slider irán del 0 al 1 (en lugar del intervalo 0-255 que utiliza Arduino).

Es muy fácil ver el potencial que tienen las señales PWM. Siguiendo con el ejemplo del LED, con una salida digital normal, solo podríamos programar dos valores: 0 o LOW (apagado) y 1 HIGH (encendido). Sin embargo, mediante una salida digital PWM, podemos no solo apagar y encender un LED, sino variar su brillo.

Otras aplicaciones podrían ser controlar la velocidad de giro de un ventilador, controlar la velocidad de un motor de continua, controlar servomotores…

Algunos ejemplos con Arduino

En Arduino, usaremos la función analogWrite, que sigue el siguiente esquema:

analogWrite(número de pin, valor);

Así por ejemplo, si tomamos cualquiera de las salidas digitales PWM, como la 3:

analogWrite(3,0);                           // Ciclo de trabajo del 0 %

analogWrite(3,64);                         // Ciclo de trabajo del 25 %

analogWrite(3,127);                       // Ciclo de trabajo del 50 %

analogWrite(3,255);                       // Ciclo de trabajo del 100 %

Conociendo el manejo de esta función, procedemos a analizar algunos ejemplos sencillos de código. Estos programas de ejemplo pueden encontrarse en la carpeta Examples en el directorio donde hayamos instalado el IDE de Arduino.

PROGRAMA DE EJEMPLO 1

En este programa se utilizan tres fotorresistores, protegidos por una cubierta de diferentes colores, para encender un LED RGB. Este LED emitirá un determinado color con un determinado brillo en función de la luz que le llegue a las fotorresistencias.

En esta primera parte del programa se declaran las variables necesarias para la ejecución del mismo:

En esta segunda parte se llama a la función setup para iniciar la comunicación con la placa y se configuran los pines en su correspondiente modo (input o output):

En esta cuarta parte se realiza la lectura de los sensores mediante la función analogRead, estableciendo un pequeño retardo (delay) entre cada ejecución, y se saca por pantalla los resultados con la instrucción Serial.print

En esta última parte se mapean los resultados de las medidas de los sensores y se les asigna una nueva variable. Este mapeo se realiza porque los valores que los sensores leen varían entre 0 y 1023, pero la salida PWM solo puede dar un valor entre 0 y 255. Dividiendo entre 4 se consigue que los valores de respuesta asociados a cada valor de entrada sean coherentes (mapeo).

Con este programa tan sencillo hemos aprendido a controlar el brillo y color de un LED RGB en función de unos datos recogidos por sensores.

De manera análoga, podríamos controlar la velocidad de giro de un ventilador en función de los datos que recoge un sensor de temperatura.

PROGRAMA DE EJEMPLO 2

Con este programa aprenderemos a controlar un servomotor. Los servomotores son dispositivos que tienen engranajes integrados y un eje que podemos controlar con gran precisión. Normalmente podemos controlar el ángulo de rotación entre 0 y 180 grados, aunque hay muchos servomotores de rotación continua, como los de Parallax usados en el Home Boe-Bot. Son muy utilizados en robótica. Un servomotor tiene tres cables: alimentación (rojo), masa (negro) y el de señal (que suele ser blanco o amarillo) y que es el que utilizamos para controlar la rotación y comunicarnos con Arduino.

En la primera parte del programa creamos los objetos y variables necesarias, cargamos las librerías correspondientes e iniciamos la comunicación con la placa.

En la entrada analógica A0 leemos el valor del potenciómetro, y lo asignamos a la variable potVal (potentiometer value). Mostramos por pantalla este valor.

Después, realizamos el mapeo necesario para que el servomotor pueda funcionar, con la función map(). Esta función necesita cinco parámetros: el número a escalar (en este caso el valor leído por el potenciómetro y que hemos almacenado en la variable correspondiente), el mínimo valor de la entrada (0), el máximo valor de la entrada (1023), el mínimo valor de la salida (0 = 1 grado) y el máximo valor de la salida (179 = 180 grados).

Después del mapeo le transmitimos la orden al servomotor para que se mueva.

Es importante notar que con las salidas digitales sería impensable realizar este programa. Como he mencionado, las salidas digitales solo pueden enviar dos valores (0 y 1). Sin embargo, con las salidas digitales podemos dar muchos más valores discretos (digital – variable discreta, analógico – variable continua) por lo que podemos tener un movimiento preciso de un servomotor, con apenas unas pocas líneas de código y mapeando correctamente los valores de entrada y salida.

Práctica propuesta

Con este pequeño ejercicio aprenderemos a controlar un motor de continua. Con los dos pulsadores podemos cambiar el sentido de giro del motor, así como apagarlo y encenderlo. Con el potenciómetro seremos capaces de regular la velocidad del motor (mediante una entrada analógica y una salida PWM).

Declaración de variables:

Definimos las entradas y salidas correspondientes:

Cuerpo del programa:

Este mismo concepto puede trasladarse, por ejemplo, al control de la velocidad de giro de un ventilador. Esta velocidad la podremos regular cambiando el potenciómetro por un sensor de temperatura. De esta forma, con el mapeo correcto, podremos controlar la velocidad del ventilador en función de la temperatura que capte el sensor.

---

Todos los ejemplos pueden encontrarse en el libro incluido en el kit de Arduino.
Fuente propia. Imágenes propias (excepto las dos primeras, que son de Wikipedia).

 

Arduino & LabVIEW (II). Control de un LED mediante PWM.

En este tutorial vamos a aprender a controlar con LabVIEW la luminosidad de un LED a través una de las salidas PWM de Arduino.

Recomiendo que antes de comenzar hayáis seguido los pasos para conectar y configurar correctamente la comunicación entre Arduino y LabVIEW: Arduino & LabVIEW (I). Conexión y configuración.

Una vez que lo tengamos todo configurado, procedemos a realizar el siguiente montaje físico:

Como se puede observar es un montaje muy sencillo: conectamos el cátodo (polo negativo) del diodo LED al pin GND, y conectamos el ánodo (polo positivo) al pin PWM 11.

Es importante respetar la polaridad de los terminales para no dañar el LED. En la imagen de la derecha se puede consultar un pequeño esquema para conectar correctamente nuestro diodo, fijándonos en la muesca que tiene en un lateral del encapsulado o en la longitud de los terminales.

Conectamos nuestra placa de Arduino al PC mediante el cable USB.

Para controlar el brillo del LED vamos a usar una de las salidas PWM de Arduino (en nuestro caso la 11, pero vale cualquiera que venga marcada con el símbolo ~ ).

PWM (pulse-width modulation) significa modulación por ancho de pulso. Con esta técnica podemos usar una salida digital para emular a una salida analógica (en vez de dos valores -0 y 1- podremos mandar valores comprendidos entre 0 y 255 – 8 bits = 256 valores). Para más información podéis echar un vistazo al siguiente enlace: Arduino – PWM.

Abrimos LabVIEW y creamos un nuevo proyecto en blanco. Seleccionamos la plantilla «Blank VI«.

Se nos abrirán dos ventanas: «Block diagram» y «Front panel».

En la primera de ellas, «Block diagram» podremos insertar los bloques que conformarán nuestro programa. Será nuestra «mesa de trabajo».

En el «Front panel» podremos controlar las acciones y visualizar los resultados. Será la ventana que nos permita interactuar con Arduino.

Si hacemos click con el botón derecho en cualquier parte del espacio de trabajo, se nos desplegará un menú con una lista de funciones y controles, similar al de la imagen de la izquierda.

Desde este menú podemos navegar hasta encontrar las diferentes funciones que necesitamos.

Para incorporarlas a nuestro espacio de trabajo, simplemente debemos pinchar sobre el icono adecuado, arrastrar y soltar en el lugar deseado.

Se trata de un método fácil y rápido de programar.

Para empezar, debemos situar los elementos necesarios para interactuar con nuestro Arduino. Como ya he mencionado, esto se hace desde el Front Panel.

Debemos situar un control que nos permita seleccionar el valor que enviaremos al pin 11 para modificar el brillo del LED. Dicho control se sitúa, dentro del menú que hemos visto anteriormente, en Numeric > Horizontal Pointer Slide. Pinchamos sobre él, arrastramos y soltamos sobre la cuadrícula.

Podemos ajustar las dimensiones del bloque, cambiar los parámetros, las etiquetas… Lo modificamos para que el intervalo numérico vaya de 0 a 255, aumentamos el tamaño y modificamos la etiqueta para poner el nombre que deseemos. Para ello, simplemente pulsamos sobre los parámetros que queramos modificar y nos permitirá editarlos.

De la misma forma, añadimos otro elemento para visualizar la forma y amplitud de onda de los pulsos que mandaremos. Dicho elemento se encuentra en Modern > Graph > Wavefrom Chart. Para poder ver mejor la onda, aumentamos el tamaño y cambiamos los valores del eje Y de 0 a 260.

También añadimos un botón para parar el programa, que encontramos en Modern > Boolean > Stop Button.

De esta forma, se nos queda un Front Panel como el de la imagen siguiente:

Como podemos observar, podemos modificar los valores a nuestro antojo y disponer los elementos como mejor nos convengan. Haciendo click derecho sobre el elemento, podemos configurar otras opciones importantes.

El control que hemos insertado es deslizante: podemos desplazarlo horizontalmente para alcanzar los valores deseados. En cuanto a la ventana para visualizar la onda del pulso enviado, nos permite realizar una pequeña «monitorización».

Ahora procemos a programar el diagrama de bloques de nuestro programa. Al añadir los dos elementos anteriores al Front Panel, simultáneamente se han añadido dos elementos a la venta Block Diagram, como se puede ver en la imagen:

Esta ventana de Block Diagram opera igual que el Front Panel: podemos modificar la posición de los elementos, añadir otros, cambiar las propiedades, etc. La única diferencia, es que si hacemos click derecho en el espacio de trabajo, en vez de un menú de control, aparecerá un menú de funciones que nos permitirá realizar nuestro programa. Como véis, es bastante sencillo.

En primer lugar vamos a añadir una estructura While Loop. Para ello, la seleccionamos del menú de funciones (se encuentra en Programming > Structures) y dibujamos un rectángulo en el espacio de trabajo.

Dentro de el rectángulo que acabamos de dibujar, que representa la estructura While Loop, metemos los tres elementos anteriores, y conectamos el elemento STOP al botón rojo de la parte inferior derecha del rectángulo. Esto indica la condición de parada. De esta manera, al pulsar el botón desde el Front Panel, el programa cesará su ejecución. Para conectarlos basta con posicionarse sobre el icono, y se resaltarán unos puntos de conexión; pulsamos y arrastramos hasta el elemento deseado. Así de sencillo resulta programar mediante diagramas de bloques.

Es importante que los tipos de datos que maneja Arduino y los de nuestros bloques estén en concordancia. Para cambiarlos, pulsamos con el botón derecho y seleccionamos «Properties»:

En la pestaña Data Type, seleccionamos el icono U8 (Unsigned byte). De esta forma ya podemos enviar datos a Arduino.

Una vez hecho esto, unimos los bloques Control PWM (o el nombre que le hayamos dado al control numérico) y Wavefrom Chart:

Para que nuestro programa tenga conexión con Arduino, debemos añadir dos elementos que sircen para iniciar y finalizar el «puente» de conexión. Estos elementos están dentro de Functions > Arduino, y son Init y Close. Los situamos fuera del bucle while.

Ahora debemos definir los pines y las funciones.

En primer lugar añadimos un bloque «PWM Write Pin«, que se encuentra en Arduino > Low level.

Añadimos una constante numérica para seleccionar el pin (en nuestro caso el 11). Las constantes se encuentran en Programming > Numeric. Le cambiamos el valor de 0 a 11 clickando sobre dicho valor.

También añadiremos un constante que nos permita decidir si el pin se comportará como salida (output) o entrada (input). Este bloque se llama Enum Constant. Modificamos sus propiedades, como ya hemos hecho anteriormente, modificando el tipo de datos a Unsigned Byte. Dentro de la pestaña «Edit Items» de las propiedades del elemento, añadimos la siguiente configuración:

Una vez hayamos hecho esto, y seleccionando el pin como Output, conectamos los bloques a los terminales correspondientes, de esta manera:

Ahora procedemos a realizar la escritura del pin. Para ello, arrastramos otro bloque PWM Write Pin (como el anterior). Lo conectamos de la siguiente forma:

Como se puede ver, las variables se pueden aprovechar en varios bloques, ahorrando así espacio.

Ahora añadiremos el bloque necesario para que al pulsar el botón STOP, el led se apague. Añadimos otro bloque  PWM Write Pin fuera del bucle, y seleccionamos las variables para el pin (11) y el valor de escritura (en este caso 0, porque queremos apagarlo):

Ahora procedemos a conectarlo todo, de la siguiente manera:

Al empezar, para no liaros mucho, sería conveniente que los cables no se cruzasen y así evitar despistaros. Como podemos mover los bloques a nuestro antojo, podemos dejarlo todo un poco más organizado. También es importante cambiar un detalle para que no haya problemas en el bucle:

Debemos cambiar las propiedades (click derecho sobre el elemento) y remplazar los cuadraditos de cada pareja por un «Shift Register». Se nos quedaría todo el esquema del siguiente modo:

Para finalizar guardamos el proyecto. Solo nos queda probarlo. Conectamos nuestro Arduino al puerto USB del ordenador. Para iniciar el programa, lo hacemos desde el Front Panel, en la barra de tareas, donde podemos encontrar el botón Run (una flecha apuntando hacia la derecha).

Os dejo con un vídeo que he grabado del funcionamiento del programa:

Como se puede comprobar, a medida que deslizamos el control, el brillo del LED aumenta o disminuye en consecuencia. También podemos observar la onda (cuadrada) que describe el envío de los pulsos al pin PWM. Además, cuando presionamos el botón STOP, el LED se apaga.

Eso es todo por ahora. Cualquier duda que tengáis podéis dejarla en los comentarios. ¡Muchas gracias por vuestro tiempo!

---

Imágenes, texto y vídeo propios.

Arduino & LabVIEW (I). Conexión y configuración.

Tras varias semanas sin actividad, esta semana vengo para iniciar otra serie de tutoriales relacionados con Arduino. Pero esta vez subiremos de nivel: vamos a aprender a programar Arduino con LabVIEW, de National Instruments.

A diferencia de otros muchos tutoriales que hay disponibles en la red, éste está completo y contiene todos los pasos necesarios para conectar correctamente Arduino a LabVIEW.

Pero, ¿por qué usar LabVIEW en lugar del IDE nativo de Arduino? Dos razones: optimización de tiempo y completa monitorización.

Los chicos de National Instruments, conscientes de que muchos usuarios no pueden hacer frente al coste de una tarjeta DAQ (Data Acquisition),  y debido al boom de las placas Arduino, han desarrollado una herramienta para que podamos programar una placa Arduino como si de una de sus tarjetas profesionales se tratase.

Para los que no habéis usado LabVIEW nunca, puede que al principio os cueste acostumbraros a la programación mediante diagrama de bloques. En cuanto llevéis un timepo con el programa, descubriréis el potencial que supone el uso de LabVIEW.

En este primer tutorial vamos a aprender todos los pasos necesarios para poder conectar nuestro Arduino a LabVIEW.

Requisitos necesarios:

• Placa Arduino (el tutorial está hecho para placas Arduino UNO originales, desconozco si funciona para otros modelos).
• Cable USB para comunicar Arduino con el PC.

Para empezar, debemos tener instalado LabVIEW, con licencia (recomendada) o la versión de prueba. Podemos encontrar la versión trial en el siguiente enlace:

NI – Descagas LabVIEW

Es necesario tener la última versión disponible de VIPM (VI Package Manager). Este programa se instala junto a LabVIEW, pero en caso de tener que actualizarlo, podemos descargarlo gratis desde el siguiente enlace (Step one):

Descargar VI Package Manager (Step One)

Una vez instalado el programa, debemos instalar el paquete NI LabVIEW Interface for Arduino Toolkit. Para instalarlo, podemos descargarlo del siguiente enlace (Step two), que debemos abrir con el programa VIPM.

 Descargar VI Package Manager (Step Two)

Mi recomendación es buscar el archivo con VIPM e instalarlo desde el mismo programa. Para ello, abrimos VIPM (si no tenéis un acceso directo, debemos buscarlo por VI Package Manager). Una vez abierto, buscamos el paquete LabVIEW Interface for Arduino (debemos asegurarnos que descargamos la última versión disponible, la v 2.2.0.79). Cuando lo hayamos seleccionado, procedemos a instalarlo presionando el botón correspondiente (ver imagen). Seguimos las instrucciones y finalizamos la instalación.

Después de haber instalado el paquete, debemos instalar los drivers correspondientes para la correcta comunicación LabVIEW – Arduino.

Necesitamos un paquete adicional llamado NI-VISA. Aunque en este tutorial voy a instalar NI-VISA 5.2, existe una versión actualizada que ofrece soporte para las versiones más recientes de Windows. He de decir que trabajo con Windows 10 y no he tenido ningún problema con la versión 5.2.

Descargamos el paquete del siguiente enlace, seleccionando el enlace 2 marcado como Standard Download (full versión, 705.31 MB):

Descargar NI-VISA 5.2

De esta forma hemos acabado de configurar LabVIEW. Ahora procedemos a configurar Arduino.

Es importante que tengamos instalada la versión  1.0.5 r2 del IDE de Arduino. De lo contrario, no funcionará. Podemos encontrar esta versión en los antiguos repositorios de Arduino, en el siguiente enlace:

Descargar Arduino 1.0.5 r2

Si tenemos una versión más actualizada del IDE, debemos desinstalarla.

Una vez instalado, debemos instalar la interfaz gráfica de LabVIEW en Arduino. Simplemente es instalar el sketch que nos proporciona LabVIEW para poder manejar Arduino desde el programa. Este paso solo es necesario hacerlo la primera vez que vayamos a programar con LabVIEW (obviamente, si subimos un nuevo sketch sobrescribiremos el anterior, y deberemos instalarlo de nuevo si queremos programar otra vez con LabVIEW).

Abrimos el IDE de Arduino, y abrimos el sketch LIFA_Base.ino, que podemos encontrar en la siguiente ruta:

C:\Program Files\National Instruments\LabVIEW 2014\vi.lib\LabVIEW Interface for Arduino\Firmware\LIFA_Base

Esta ruta dependerá de la versión instalada, pero el archivo siempre se encuentra en la carpeta de instalación del programa > vi.lib > LabVIEW Interface for Arduino > Firmware > LIFA_Base.

Subimos el sketch a nuestro Arduino (debemos asegurarnos previamente de que hemos seleccionado nuestro modelo de Arduino y el puerto COM correspondiente).

Una vez subido el sketch, ya tenemos correctamente configuradas ambas partes para poder empezar a programar.

En los siguientes tutoriales veremos algún ejemplo de introducción  a la programación de Arduino con LabVIEW. Esta noche tendréis el primer ejemplo de programación, donde controlaremos la luminosidad de un led conectado a una de las salidas PWM de nuestro Arduino con LabVIEW.

En caso de alguna duda, podéis dejar un comentario en la entrada.

---

Fuente e imágenes propias