Controle LED usando Arduino e Processing GUI
Este artigo resume os seguintes pontos:
1: Introdução ao Arduino GUI
2: Projetando Arduino GUI para controle de LED
- 2.1: Download de processamento
- 2.2: Instalando a Biblioteca Controlp5 no processamento
- 2.3: esquemático
3: Código de processamento para GUI
4: Código de IDE Arduino para GUI
5: saída
Conclusão
1: Introdução ao Arduino GUI
A GUI Arduino, ou interface gráfica do usuário, é uma plataforma que permite aos usuários interagir facilmente com o mundo físico através do uso de sensores e outros componentes eletrônicos. Com a ajuda da GUI, os usuários podem criar interfaces gráficas personalizadas para controlar seus dispositivos, monitorar dados do sensor e visualizar resultados em tempo real.
Ter um projeto Arduino com a GUI ajuda os usuários a ter diferentes níveis de experiência técnica para controlar e monitorar seu projeto. Existem várias plataformas que projetam Arduino GUI e uma delas é Em processamento. Usando isso, podemos instalar bibliotecas e criar uma GUI personalizada para o nosso projeto.
2: Projetando Arduino GUI para controle de LED
O design de uma interface gráfica do usuário (GUI) para um sistema Arduino pode ser alcançada usando a linguagem de programação de processamento. Esta combinação fornece uma interface amigável para interagir com o mundo físico via microcontrolador.
Em processamento oferece um ambiente simples para criar elementos e animações gráficas, enquanto o Arduino fornece a interação e controle de hardware.
Para projetar a GUI baseada em Arduino para controle de LED, usaremos o software de processamento. Usando o processamento, projetaremos a GUI e o vincularemos ao código Arduino usando a comunicação serial Arduino.
O primeiro passo é baixar o processamento e instalá -lo no sistema.
2.1: Download de processamento
Vá para o site oficial do processamento e faça o download.
Passo 1: Faça o download do processamento de acordo com o seu sistema operacional:
Passo 2: Depois de baixá -lo, extraia o arquivo:
Etapa 3: Depois que o arquivo zip for extraído, execute o exe Em processamento instalador. Após a instalação bem -sucedida, abra -o usando o botão Iniciar ou através de um atalho:
2.2: Instalando a Biblioteca Controlp5 no processamento
ControlP5 é uma biblioteca para o ambiente de programação de processamento e para Arduino que fornece controles de GUI para programas interativos. Ele fornece um conjunto de widgets da GUI (e.B Botões, Sliders, botões) e ferramentas para criar interfaces gráficas de usuário para processamento e projetos de Arduino.
Antes de controlarmos o Arduino, precisamos instalá -lo no software de processamento.
Passo 1: Abra o processamento e vá para: Sketch> Import Library> Gerenciar biblioteca:
Passo 2: Procure o Controlp5 Biblioteca e clique em Instalar:
Após a instalação bem -sucedida da Biblioteca Controlp5, podemos programar facilmente Arduino com processamento e criar uma GUI interativa para diferentes projetos.
2.3: esquemático
Vamos projetar uma GUI de processamento para o Programa de Controle LED de Arduino. Conecte três LEDs no pino D10,11 e 12. Aqui estamos usando o conselho do Arduino Nano. Você pode ir com qualquer um dos quadros do Arduino:
3: Código de processamento para GUI
A seguir, o código de processamento para Arduino GUI. Este código ajuda a controlar três LEDs diferentes usando uma interface gráfica simples.
Importar ControlP5.*; /*Incluir Biblioteca Controlp5*/
Processamento de importação.serial.*; /*importar comunicação serial*/
Porta serial;
CONTROLP5 CP5; // Crie ControlP5 Objeto
Fonte pfont;
int col1 = cor (255); /*cor para o botão 1*/
int col2 = cor (255); /*cor para o botão 2*/
int col3 = cor (255); /*cor para o botão 3*/
int col4 = cor (255); /*cor para o botão 4*/
boolean ToggleValue = false; /*O valor de alternância é inicializado*/
Void Setup ()
tamanho (500, 500); /*A largura e a altura da janela são definidas*/
font = createfont ("calibri leve em negrito", 20); /*Fonte definida para o botão e Tittle*/
PrintArray (serial.lista()); /*Imprime portas seriais disponíveis*/
porta = nova serial (this, "com8", 9600); /*COM PORT PARA ARDUINO Você pode verificar usando Arduino IDE*/
/*Agora criando um novo botão*/
suave();
cp5 = new ControlP5 (this);
CP5.AddToggle ("alternância") /*Botão de alternância para LED 1* /
.SetPosition (180, 60) /*x e y coordenadas do botão de alternância LED1* /
.Setsize (100, 40) /*Tamanho do botão de alternância horizontal e verticalmente* /
.SetValue (true) /*botão de alternância Valor inicial definido como true* /
.SetMode (ControlP5.Switch) /*Usando a biblioteca Controlp5 Defina a alternância como interruptor* /
;
/*Projetado da mesma forma Os três botões restantes*/
CP5.AddToggle ("Toggle2")
.setPosition (180, 160)
.Setsize (100, 40)
.setValue (true)
.SetMode (ControlP5.TROCAR)
;
CP5.AddToggle ("Toggle3")
.setPosition (180, 260)
.Setsize (100, 40)
.setValue (true)
.SetMode (ControlP5.TROCAR)
;
CP5.AddToggle ("Toggle4")
.setPosition (180, 360)
.Setsize (100, 40)
.setValue (true)
.SetMode (ControlP5.TROCAR)
;
void draw ()
/*função para desenhar e escrever texto*/
fundo (0, 0, 0); /*cor de fundo da janela (r, g, b) ou (0 a 255)*/
preenchimento (255, 255, 255); /*cor de texto (r, g, b)*/
textfont (fonte);
texto ("GUI de controle de LED", 155, 30); /*("Texto", x coordenada, coordenada y)*/
texto ("LED1", 20, 90); /*("Texto", x coordenada, coordenada y)*/
texto ("LED2", 20, 190); /*("Texto", x coordenada, coordenada y)*/
texto ("LED3", 20, 290); /*("Texto", x coordenada, coordenada y)*/
texto ("todos os LEDs", 20, 390); /*("Texto", x coordenada, coordenada y)*/
pushMatrix ();
if (ToggleValue == true)
preenchimento (255.255.220); /*Transição colorida se a chave de alternância for pressionada*/
outro
preenchimento (128.128.110);
traduzir (400,80); /*interruptor de alternância Traduzir*/
preencher (col1); /*Se o interruptor de alternância for pressionado, altere a cor elipse para branco*/
Ellipse (0,0,50,50); /*Tamanho da elipse vertical e horizontalmente*/
PopMatrix ();
/*Projetado da mesma forma o restante de três botões*/
pushMatrix ();
if (ToggleValue == true)
preenchimento (255.255.220);
outro
preenchimento (128.128.110);
traduzir (400.180);
preencher (col2);
Ellipse (0,0,50,50);
PopMatrix ();
pushMatrix ();
if (ToggleValue == true)
preenchimento (255.255.220);
outro
preenchimento (128.128.110);
traduzir (400.280);
preencher (col3);
Ellipse (0,0,50,50);
PopMatrix ();
pushMatrix ();
if (ToggleValue == true)
preenchimento (255.255.220);
outro
preenchimento (128.128.110);
traduzir (400.380);
preencher (col4);
Ellipse (0,0,50,50);
PopMatrix ();
/*Função para ligar e desligar o LED*/
TOLGLE VOID (BANGO BOOLEANS)
if (flag1 == false) /*se o valor for verdadeiro* /
porta.escreva ('a'); /*Serial A será enviado para Arduino*/
col1 = cor (255); /*Cor de elipse mudar para branco completo*/
outro
porta.escreva ('x'); /*caso contrário, o LED 1 permanecerá desligado e o X em série é enviado para Arduino IDE*/
col1 = cor (100); /*Cor cinza claro para elipse quando a alternância não é pressionada*/
/*Projetado da mesma forma o restante de três botões*/
Void Toggle2 (bandeira booleana)
if (flag2 == false)
porta.escreva ('b');
col2 = cor (255);
outro
porta.escreva ('y');
col2 = cor (100);
Void Toggle3 (bandeira booleana)
if (flag3 == false)
porta.escreva ('c');
col3 = cor (255);
outro
porta.escreva ('z');
col3 = cor (100);
Void Toggle4 (bandeira booleana)
if (flag4 == false)
porta.escreva ('O');
col4 = cor (255);
outro
porta.escreva ('f');
col4 = cor (100);
O código acima começou incluindo a biblioteca Controlp5, juntamente com um arquivo de comunicação serial. Em seguida, definimos 4 variáveis diferentes que armazenarão as cores para diferentes estados de botão.
Na parte de configuração, o tamanho da janela da GUI é definido. Em seguida, uma porta COM é definida para comunicação serial com a placa Arduino. Você pode verificar a porta COM usando o Arduino IDE.
Em seguida, definimos quatro botões diferentes: seu tamanho e posição. Todo o valor inicial desses quatro botões é definido como true. Os três primeiros botões controlarão individualmente um LED enquanto o quarto botão alternará os três LEDs de uma só vez.
Em seguida na função de draw void, projetamos o indicador Ellipse para quatro botões. Quando cada um dos botões de alternância é pressionado, a cor Ellipse mudará para o brilho total, mostrando -nos o LED está ligado.
Usando a função PushMatrix () e PopMatrix (), inicializamos uma condição IF para cada um dos interruptores de alternância. Quando qualquer um dos botões de alternância for pressionado, ele se traduzirá e a elipse mudará sua cor para 255.
No início do programa, definimos um estado de cores separado para cada uma das elipses correspondentes a um botão específico.
E finalmente uma função vazia para cada um dos botões de alternância é definida. Esta função enviará em série um caractere específico para a placa Arduino quando um interruptor de alternância for pressionado.
Por exemplo, se o valor de Toggle2 for falso um personagem b será transmitido em série para Arduino. Que ligará o LED no pino D11. Da mesma forma, se o valor de Toggle2 for verdadeiro um personagem y será transmitido em série, que virará o LED no pino D11 para Off.
As mesas a seguir nos dão uma idéia sobre como esses caracteres em série estão funcionando:
| Caráter em série | Resposta de saída |
|---|---|
| a | Ligue o LED no pino D10 |
| b | Ligue o LED no pino D11 |
| c | Ligue o LED no pino D12 |
| x | Desligue o LED no pino D10 |
| y | Desligue o LED no pino D11 |
| z | Desligue o LED no pino D12 |
Observação: Podemos personalizar esses personagens para qualquer outro, mas não se esqueça de usar os mesmos caracteres em Arduino e Código de Processamento.
4: Código de IDE Arduino para GUI
A seguir, o código Arduino escrito no Arduino IDE:
Void Setup ()
pinmode (10, saída); /*Pino para LED1*/
pinmode (11, saída); /*Pino para led2*/
pinmode (12, saída); /*Pino para LED3*/
Serial.começar (9600); /*Taxa de transmissão serial*/
Void Loop ()
se (serial.disponível ()) /*Verifique a disponibilidade de dados serial do processamento* /
char val = serial.ler(); /*Se os dados seriais estiverem disponíveis armazenam -os dentro de uma variável*/
if (val == 'a') /*se um recebido* /
DigitalWrite (10, alto); /*Ligue o LED1*/
if (val == 'b') /*se b recebido* /
DigitalWrite (11, alto); /*Ligue o LED2*/
if (val == 'c') /*se c recebido* /
DigitalWrite (12, alto); /*Ligue o LED3*/
if (val == 'x') /*se x recebido* /
DigitalWrite (10, baixo); /*Desligue o LED1*/
if (val == 'y') /*se y recebido* /
DigitalWrite (11, baixo); /*Desligue o LED2*/
if (val == 'z') /*se z recebeu* /
DigitalWrite (12, baixo); /*Desligue o LED3*/
if (val == 'o') /*se o recebido* /
DigitalWrite (10, alto);
DigitalWrite (11, alto); /*Ligue todos os LEDs*/
DigitalWrite (12, alto);
if (val == 'f') /*se f recebido* /
DigitalWrite (10, baixo);
DigitalWrite (11, baixo); /*Desligue todos os LEDs*/
DigitalWrite (12, baixo);
Este código começou definindo o pino para três LEDs. Cada um desses pinos é definido como saída usando a função pinmode (). O próximo código do Arduino verificará continuamente os dados seriais. Se os dados em série estiverem disponíveis, ele gerará uma resposta de acordo com isso.
Por exemplo, se o interruptor de alternância da GUI de processamento 1 for pressionado um caractere "a" será recebido por Arduino e ligará o LED no pino D10. Da mesma forma se o personagem "X" é recebido em série, ele desligará o LED no pino D10:
5: saída
Depois de fazer o upload de código para o conselho do Arduino, execute o código de processamento e verifique se a placa Arduino está conectada em série com o PC.
A janela a seguir será aberta, mostrando -nos a GUI projetada para três LEDs. Usando esta GUI, podemos controlar qualquer um dos LEDs, amostragem da alternância:
Podemos controlar o LED Glow usando esta GUI:
Conclusão
O uso do Controlp5 Biblioteca em combinação com processamento e Arduino oferece uma solução poderosa para criar projetos baseados em GUI. A biblioteca fornece um conjunto abrangente de ferramentas e widgets que simplificam o processo de criação de interfaces gráficas amigáveis, permitindo que os desenvolvedores se concentrem na funcionalidade principal de seu projeto.