LED de control utilizando Arduino y GUI de procesamiento
Este artículo resume los siguientes puntos:
1: Introducción a Arduino GUI
2: Diseño de la GUI Arduino para el control LED
- 2.1: Procesamiento de descarga
- 2.2: Instalación de la biblioteca Controlp5 en el procesamiento
- 2.3: Esquema
3: Código de procesamiento de GUI
4: Código de Arduino IDE para GUI
5: salida
Conclusión
1: Introducción a Arduino GUI
La GUI Arduino, o la interfaz gráfica de usuario, es una plataforma que permite a los usuarios interactuar fácilmente con el mundo físico mediante el uso de sensores y otros componentes electrónicos. Con la ayuda de la GUI, los usuarios pueden crear interfaces gráficas personalizadas para controlar sus dispositivos, monitorear los datos del sensor y visualizar los resultados en tiempo real.
Tener un proyecto Arduino con GUI ayuda a los usuarios a tener diferentes niveles de experiencia técnica para controlar y monitorear su proyecto. Hay múltiples plataformas que diseñan la GUI Arduino y una de ellas es Procesando. Usando esto podemos instalar bibliotecas y crear una GUI personalizada para nuestro proyecto.
2: Diseño de la GUI Arduino para el control LED
El diseño de una interfaz gráfica de usuario (GUI) para un sistema Arduino se puede lograr utilizando el lenguaje de programación de procesamiento. Esta combinación proporciona una interfaz fácil de usar para interactuar con el mundo físico a través del microcontrolador.
Procesando Ofrece un entorno simple para crear elementos y animaciones gráficas, mientras que Arduino proporciona la interacción y el control de hardware.
Para diseñar GUI basado en Arduino para el control LED, utilizaremos el software de procesamiento. Usando el procesamiento, diseñaremos GUI y lo vincularemos con el código Arduino utilizando la comunicación de Arduino en serie.
El primer paso es descargar el procesamiento e instalarlo en el sistema.
2.1: Procesamiento de descarga
Vaya al sitio oficial de procesamiento y descargue.
Paso 1: Descargue el procesamiento de acuerdo con su sistema operativo:
Paso 2: Después de descargarlo, extraiga el archivo:
Paso 3: Una vez que se extrae el archivo zip, ejecute el exe Procesando instalador. Después de una instalación exitosa, ábralo con el botón Inicio o a través de un atajo:
2.2: Instalación de la biblioteca Controlp5 en el procesamiento
Controlp5 es una biblioteca para el entorno de programación de procesamiento y para Arduino que proporciona controles de GUI para programas interactivos. Proporciona un conjunto de widgets de GUI (E.Botones G, controles deslizantes, perillas) y herramientas para crear interfaces gráficas de usuario para procesamiento y proyectos de Arduino.
Antes de controlar el Arduino, necesitamos instalarlo en el software de procesamiento.
Paso 1: Abra el procesamiento y vaya a: Sketch> Import Library> Administrar biblioteca:
Paso 2: Buscar el Controlp5 Biblioteca y haga clic en Instalar:
Después de la instalación exitosa de la biblioteca Controlp5, podemos programar fácilmente Arduino con el procesamiento y crear una GUI interactiva para diferentes proyectos.
2.3: Esquema
Vamos a diseñar una GUI de procesamiento para el programa de control LED de Arduino. Conecte tres LED al pin D10,11 y 12. Aquí estamos usando el arduino nano board. Puedes ir con cualquiera de los tableros Arduino:
3: Código de procesamiento de GUI
El siguiente es el código de procesamiento de Arduino GUI. Este código ayuda a controlar tres LED diferentes utilizando una interfaz gráfica simple.
importar controlp5.*; /*Incluya la biblioteca Controlp5*/
procesamiento de importación.de serie.*; /*Importar comunicación en serie*/
Puerto serial;
Controlp5 CP5; // Crear objeto Controlp5
Pfont Font;
int col1 = color (255); /*Color para el botón 1*/
int col2 = color (255); /*Color para el botón 2*/
int col3 = color (255); /*Color para el botón 3*/
int col4 = color (255); /*Color para el botón 4*/
boolean toggleValue = false; /*El valor de la palanca se inicializa*/
setup () void
tamaño (500, 500); /*El ancho de la ventana y la altura se definen*/
font = createFont ("Calibri Light Bold", 20); /*fuente definida para el botón y tittle*/
printArray (serie.lista()); /*Imprime puertos serie disponibles*/
puerto = nuevo serial (esto, "COM8", 9600); /*Puerto COM para Arduino Puede verificarlo usando Arduino IDE*/
/*Ahora creando un nuevo botón*/
liso();
CP5 = nuevo controlp5 (esto);
CP5.addToggle ("Toggle") /*Toggle Botón para LED 1* /
.SetPosition (180, 60) /*x e y coordenadas del botón LED1 Toggle* /
.setSize (100, 40) /*Tamaño del botón de alternación horizontal y verticalmente* /
.setValue (true) /*Botón de alternación Valor inicial establecido en True* /
.setMode (controlp5.Interruptor) /*Uso de la biblioteca Controlp5 Establezca el interruptor como el interruptor* /
;
/*Diseñó de manera similar los tres botones restantes*/
CP5.addToggle ("toggle2")
.SetPosition (180, 160)
.setSize (100, 40)
.setValue (verdadero)
.setMode (controlp5.CAMBIAR)
;
CP5.addToggle ("toggle3")
.SetPosition (180, 260)
.setSize (100, 40)
.setValue (verdadero)
.setMode (controlp5.CAMBIAR)
;
CP5.addToggle ("toggle4")
.SetPosition (180, 360)
.setSize (100, 40)
.setValue (verdadero)
.setMode (controlp5.CAMBIAR)
;
void draw ()
/*función para dibujar y escribir texto*/
antecedentes (0, 0, 0); /*Color de fondo de la ventana (R, G, B) o (0 a 255)*/
llenar (255, 255, 255); /*Color de texto (R, G, B)*/
textFont (fuente);
texto ("GUI de control LED", 155, 30); /*("texto", x coordenada, y coordenada)*/
texto ("LED1", 20, 90); /*("texto", x coordenada, y coordenada)*/
texto ("LED2", 20, 190); /*("texto", x coordenada, y coordenada)*/
texto ("LED3", 20, 290); /*("texto", x coordenada, y coordenada)*/
texto ("Todos los LED", 20, 390); /*("texto", x coordenada, y coordenada)*/
pushmatrix ();
if (toggleValue == true)
llenar (255,255,220); /*Transición de color si se presiona el interruptor de palanca*/
demás
llenar (128,128,110);
traducir (400,80); /*interruptor de palanca traducir*/
llenar (col1); /*Si se presiona el interruptor de palanca, cambie el color elipse a blanco*/
elipse (0,0,50,50); /*tamaño de elipse vertical y horizontalmente*/
popMatrix ();
/*Diseñó de manera similar el resto de tres botones*/
pushmatrix ();
if (toggleValue == true)
llenar (255,255,220);
demás
llenar (128,128,110);
traducir (400,180);
llenar (col2);
elipse (0,0,50,50);
popMatrix ();
pushmatrix ();
if (toggleValue == true)
llenar (255,255,220);
demás
llenar (128,128,110);
traducir (400,280);
llenar (col3);
elipse (0,0,50,50);
popMatrix ();
pushmatrix ();
if (toggleValue == true)
llenar (255,255,220);
demás
llenar (128,128,110);
traducir (400,380);
llenar (col4);
elipse (0,0,50,50);
popMatrix ();
/*función para encender y apagar LED*/
alternar vacío (Boolean Flag1)
if (flag1 == false) /*Si el valor es verdadero* /
puerto.escribe un'); /*Serial A se enviará a Arduino*/
col1 = color (255); /*Color del elipse Cambiar a blanco completo*/
demás
puerto.escribir ('x'); /*de lo contrario el LED 1 permanecerá apagado y en serie X se envía a Arduino IDE*/
col1 = color (100); /*Color gris claro para elipse cuando no se presiona la alternativa*/
/*Diseñó de manera similar el resto de tres botones*/
void toggle2 (boolean flag2)
if (flag2 == falso)
puerto.escribir ('b');
col2 = color (255);
demás
puerto.escribir ('y');
col2 = color (100);
nulo toggle3 (boolean flag3)
if (flag3 == falso)
puerto.escribir ('c');
col3 = color (255);
demás
puerto.escribir ('z');
col3 = color (100);
Void Toggle4 (Boolean Flag4)
if (flag4 == falso)
puerto.escribir ('o');
col4 = color (255);
demás
puerto.escribir ('f');
col4 = color (100);
El código anterior iniciado incluyendo la biblioteca Controlp5 junto con un archivo de comunicación en serie. A continuación, definimos 4 variables diferentes que almacenarán los colores para diferentes estados de botones.
En la parte de configuración se define el tamaño de la ventana de la GUI. A continuación, se define un puerto Com para la comunicación en serie con el tablero de Arduino. Puede verificar el puerto COM con el IDE Arduino.
A continuación, definimos cuatro botones diferentes: su tamaño y posición. El valor inicial de todos estos cuatro botones se establece en verdadero. Los primeros tres botones controlarán individualmente un LED, mientras que el cuarto botón alternará los tres LED a la vez.
A continuación, en la función de dibujo vacío, diseñamos el indicador de elipse para cuatro botones. Cuando se presione cada uno de los botones de alternancia, el color de elipse cambiará al brillo total que nos muestra el LED está encendido.
Usando la función pushmatrix () y popMatrix (), inicializamos una condición IF para cada uno de los interruptores de alternancia. Cuando se presione cualquiera de los botones de alternancia, se traducirá y la elipse cambiará su color a 255.
Al comienzo del programa, definimos un estado de color separado para cada uno de los elipses correspondientes a un botón específico.
Y por fin se define una función nula para cada uno de los botones. Esta función enviará en serie un carácter específico a la placa Arduino cuando se presione un interruptor de palanca.
Por ejemplo, si el valor toggle2 es falso un carácter b se transmitirá en serie a Arduino. Que encenderá el LED en el pin D11. Del mismo modo, si el valor toggle2 es verdadero un carácter Y se transmitirá en serie, lo que convertirá el LED en el pin D11 a apagado.
Las siguientes tablas nos dan una idea sobre cómo funcionan estos personajes en serie:
| Personaje en serie | Respuesta de salida |
|---|---|
| a | Encienda el LED en el pin D10 |
| b | Encienda el LED en el pin D11 |
| C | Encienda el LED en el pin D12 |
| X | Apague el LED en el pin D10 |
| Y | Apague el LED en el pin D11 |
| z | Apague el LED en el pin D12 |
Nota: Podemos personalizar estos caracteres a cualquier otro, pero asegúrese de usar los mismos caracteres tanto en Arduino como en código de procesamiento.
4: Código de Arduino IDE para GUI
El siguiente es el código Arduino escrito en Arduino IDE:
setup () void
PinMode (10, salida); /*Pin para LED1*/
PinMode (11, salida); /*Pin para LED2*/
PinMode (12, salida); /*Pin para LED3*/
De serie.comenzar (9600); /*Tasa de baudios en serie*/
bucle void ()
if (serial.disponible ()) /*Verifique la disponibilidad de datos en serie desde el procesamiento* /
char val = Serial.leer(); /*Si los datos en serie están disponibles, guárdelo dentro de una variable*/
if (val == 'a') /*si un recibido* /
DigitalWrite (10, alto); /*encender LED1*/
if (val == 'b') /*Si B recibió* /
DigitalWrite (11, alto); /*ENCENDER LED2*/
if (val == 'c') /*si C recibió* /
DigitalWrite (12, alto); /*encender LED3*/
if (val == 'x') /*si x recibió* /
DigitalWrite (10, bajo); /*Apague LED1*/
if (val == 'y') /*si y recibió* /
DigitalWrite (11, bajo); /*Apague LED2*/
if (val == 'z') /*si z recibió* /
DigitalWrite (12, bajo); /*Apague LED3*/
if (val == 'o') /*if o recibió* /
DigitalWrite (10, alto);
DigitalWrite (11, alto); /*Encienda todos los LED*/
DigitalWrite (12, alto);
if (val == 'f') /*si f recibió* /
DigitalWrite (10, bajo);
DigitalWrite (11, bajo); /*Apague todos los LED*/
DigitalWrite (12, bajo);
Este código comenzó definiendo el PIN para tres LED. Cada uno de estos pines se define como salida usando la función pinmode (). El siguiente código Arduino verificará continuamente los datos en serie. Si los datos en serie están disponibles, generará una respuesta de acuerdo con eso.
Por ejemplo, si el interruptor de alternancia de GUI de procesamiento 1 se presiona un carácter "a" será recibido por Arduino y encenderá el LED en el pin D10. Del mismo modo si el personaje "X" se recibe en serie, apagará el LED en el pin D10:
5: salida
Después de cargar código en la placa Arduino, ejecute el código de procesamiento y asegúrese de que la placa Arduino esté conectada en serie con la PC.
La siguiente ventana se abrirá mostrándonos la GUI diseñada para tres LED. Usando esta GUI podemos controlar cualquiera de los LED muestras alternando el interruptor:
Podemos controlar LED GLOW usando esta GUI:
Conclusión
El uso del Controlp5 Biblioteca en combinación con procesamiento y Arduino ofrece una solución poderosa para crear proyectos basados en GUI. La biblioteca proporciona un conjunto completo de herramientas y widgets que simplifican el proceso de crear interfaces gráficas fáciles de usar, lo que permite a los desarrolladores centrarse en la funcionalidad central de su proyecto.