Controllo LED usando Arduino e GUI di elaborazione
Questo articolo riassume i seguenti punti:
1: Introduzione a Arduino GUI
2: Progettazione di Arduino GUI per il controllo a LED
- 2.1: download di elaborazione
- 2.2: Installazione della libreria ControlP5 nell'elaborazione
- 2.3: schema
3: Codice di elaborazione per GUI
4: Codice IDE Arduino per GUI
5: output
Conclusione
1: Introduzione a Arduino GUI
La GUI Arduino, o interfaccia utente grafica, è una piattaforma che consente agli utenti di interagire facilmente con il mondo fisico attraverso l'uso di sensori e altri componenti elettronici. Con l'aiuto della GUI, gli utenti possono creare interfacce grafiche personalizzate per controllare i propri dispositivi, monitorare i dati dei sensori e visualizzare i risultati in tempo reale.
Avere un progetto Arduino con GUI aiuta gli utenti con diversi livelli di competenza tecnica per controllare e monitorare il loro progetto. Ci sono più piattaforme che progettano Arduino Gui e una di queste lo è in lavorazione. Usando questo possiamo installare librerie e creare una GUI personalizzata per il nostro progetto.
2: Progettazione di Arduino GUI per il controllo a LED
La progettazione di un'interfaccia utente grafica (GUI) per un sistema Arduino può essere ottenuta utilizzando il linguaggio di programmazione di elaborazione. Questa combinazione fornisce un'interfaccia intuitiva per interagire con il mondo fisico tramite il microcontrollore.
in lavorazione Offre un ambiente semplice per la creazione di elementi e animazioni grafiche, mentre Arduino fornisce l'interazione e il controllo dell'hardware.
Per progettare la GUI basata su Arduino per il controllo a LED utilizzeremo il software di elaborazione. Usando l'elaborazione progetteremo la GUI e la collegheremo con il codice Arduino usando la comunicazione seriale Arduino.
Il primo passo è scaricare l'elaborazione e installarla nel sistema.
2.1: download di elaborazione
Vai al sito ufficiale di elaborazione e scaricalo.
Passo 1: Scarica l'elaborazione in base al sistema operativo:
Passo 2: Dopo averlo scaricato, estrarre il file:
Passaggio 3: Una volta estratto il file zip, eseguire l'EXE in lavorazione installatore. Dopo un'installazione corretta, aprilo utilizzando il pulsante di avvio o tramite una scorciatoia:
2.2: Installazione della libreria ControlP5 nell'elaborazione
ControlP5 è una libreria per l'ambiente di programmazione dell'elaborazione e per Arduino che fornisce controlli GUI per programmi interattivi. Fornisce un set di widget GUI (e.Pulsanti G, cursori, manopole) e strumenti per la creazione di interfacce utente grafiche per l'elaborazione e i progetti Arduino.
Prima di controllare l'Arduino, dobbiamo installarlo nel software di elaborazione.
Passo 1: Elaborazione aperta e vai a: Schizzo> Libreria di importazione> Gestisci libreria:
Passo 2: Cerca il ControlP5 libreria e fare clic su Installa:
Dopo un'installazione riuscita della libreria ControlP5 possiamo facilmente programmare Arduino con l'elaborazione e creare una GUI interattiva per progetti diversi.
2.3: schema
Progetteremo una GUI di elaborazione per il programma di controllo a LED Arduino. Collegare tre LED al pin D10,11 e 12. Qui stiamo usando la scheda Arduino Nano. Puoi andare con una delle schede Arduino:
3: Codice di elaborazione per GUI
Di seguito è riportato il codice di elaborazione per Arduino GUI. Questo codice aiuta a controllare tre diversi LED utilizzando una semplice interfaccia grafica.
Importa ControlP5.*; /*Includi la libreria ControlP5*/
Elaborazione delle importazioni.seriale.*; /*Importa comunicazione seriale*/
Porta seriale;
ControlP5 CP5; // Crea oggetto ControlP5
Font pfont;
int col1 = colore (255); /*colore per il pulsante 1*/
int col2 = colore (255); /*colore per pulsante 2*/
int col3 = colore (255); /*colore per pulsante 3*/
int col4 = colore (255); /*colore per il pulsante 4*/
booleano toggleValue = false; /*Il valore di disattivazione è inizializzato*/
void setup ()
dimensione (500, 500); /*La larghezza della finestra e l'altezza sono definite*/
font = createFont ("Calibri Light Bold", 20); /*Carattere definito per pulsante e tittle*/
PrintArray (seriale.elenco()); /*Stampa Porte seriali disponibili*/
port = new serial (this, "com8", 9600); /*Porta com per Arduino puoi controllarla usando Arduino IDE*/
/*Ora creando un nuovo pulsante*/
liscio();
cp5 = new ControlP5 (questo);
CP5.AddToggle ("Toggle") /*Pulsante a levetta per LED 1* /
.SetPosition (180, 60) /*X e Y Coordinate del pulsante LED1 a levetta* /
.Impostare (100, 40) /*Dimensione del pulsante Attiva orizzontale e verticalmente* /
.SetValue (true) /*Pulsante a levetta Valore iniziale impostata su true* /
.SetMode (ControlP5.Switch) /*Utilizzo della libreria ControlP5 Imposta il disattivazione come interruttore* /
;
/*Ha progettato in modo simile i restanti tre pulsanti*/
CP5.AddToggle ("Toggle2")
.SetPosition (180, 160)
.SetSize (100, 40)
.SetValue (true)
.SetMode (ControlP5.INTERRUTTORE)
;
CP5.AddToggle ("Toggle3")
.SetPosition (180, 260)
.SetSize (100, 40)
.SetValue (true)
.SetMode (ControlP5.INTERRUTTORE)
;
CP5.AddToggle ("Toggle4")
.SetPosition (180, 360)
.SetSize (100, 40)
.SetValue (true)
.SetMode (ControlP5.INTERRUTTORE)
;
void Draw ()
/*funzione per disegnare e scrivere testo*/
sfondo (0, 0, 0); /*Colore di sfondo della finestra (r, g, b) o (da 0 a 255)*/
riempire (255, 255, 255); /*Colore di testo (r, g, b)*/
TextFont (carattere);
Testo ("GUI di controllo a LED", 155, 30); /*("testo", coordinata x, coordinata)*/
testo ("LED1", 20, 90); /*("testo", coordinata x, coordinata)*/
testo ("LED2", 20, 190); /*("testo", coordinata x, coordinata)*/
testo ("LED3", 20, 290); /*("testo", coordinata x, coordinata)*/
Testo ("All LED", 20, 390); /*("testo", coordinata x, coordinata)*/
PushMatrix ();
if (toggleValue == true)
riempire (255.255.220); /*Transizione a colori se viene premuto l'interruttore a levetta*/
altro
riempire (128.128.110);
tradurre (400,80); /*interruttore interruttore traduci*/
riempire (col1); /*Se l'interruttore a disattivazione viene premuto, modifica il colore di ellisse in bianco*/
Ellisse (0,0,50,50); /*Dimensione dell'ellisse in verticale e orizzontalmente*/
popmatrix ();
/*ha progettato in modo simile il resto di tre pulsanti*/
PushMatrix ();
if (toggleValue == true)
riempire (255.255.220);
altro
riempire (128.128.110);
tradurre (400.180);
riempire (col2);
Ellisse (0,0,50,50);
popmatrix ();
PushMatrix ();
if (toggleValue == true)
riempire (255.255.220);
altro
riempire (128.128.110);
tradurre (400.280);
riempire (Col3);
Ellisse (0,0,50,50);
popmatrix ();
PushMatrix ();
if (toggleValue == true)
riempire (255.255.220);
altro
riempire (128.128.110);
tradurre (400.380);
riempire (Col4);
Ellisse (0,0,50,50);
popmatrix ();
/*funzione per attivare e spegnere LED*/
void toggle (boolean flag1)
if (flag1 == false) /*se il valore è vero* /
porta.scrivere un'); /*Serial a verrà inviato ad Arduino*/
col1 = colore (255); /*Colore di Ellisse cambia in bianco pieno*/
altro
porta.scrivere ('x'); /*altrimenti il LED 1 rimarrà spento e in serie x viene inviato ad Arduino IDE*/
col1 = colore (100); /*Colore grigio chiaro per ellisse quando il bosco non viene premuto*/
/*Ha progettato in modo simile il resto di tre pulsanti*/
void toggle2 (bandiera booleana2)
if (flag2 == false)
porta.scrivere ('b');
Col2 = colore (255);
altro
porta.scrivere ('y');
Col2 = colore (100);
void toggle3 (bandiera booleana3)
if (flag3 == false)
porta.scrivere ('c');
col3 = colore (255);
altro
porta.scrivere ('z');
col3 = colore (100);
void toggle4 (booleano flag4)
if (flag4 == false)
porta.scrivere ('o');
col4 = colore (255);
altro
porta.scrivere ('f');
col4 = colore (100);
Il codice sopra avviato includendo la libreria ControlP5 insieme a un file di comunicazione seriale. Successivamente abbiamo definito 4 diverse variabili che memorizzeranno i colori per diversi stati dei pulsanti.
Nella parte di configurazione è definita la dimensione della finestra della GUI. Successivamente una porta com è definita per la comunicazione seriale con la scheda Arduino. Puoi controllare la porta COM usando l'IDE Arduino.
Successivamente, abbiamo definito quattro pulsanti diversi: le loro dimensioni e posizione. Tutti questi quattro pulsanti il valore iniziale è impostato su True. I primi tre pulsanti controlleranno singolarmente un LED mentre il quarto pulsante attiverà tutti e tre i LED contemporaneamente.
Successivamente nella funzione Draw void abbiamo progettato l'indicatore Ellisse per quattro pulsanti. Quando viene premuto ciascuno dei pulsanti a levetta, il colore dell'ellisse si sposterà alla piena luminosità che ci mostra che il LED è acceso.
Usando la funzione pushmatrix () e popmatrix () abbiamo inizializzato una condizione if per ciascuno degli interruttori a levetta. Quando viene premuto uno dei pulsanti a levetta, si traduce e l'ellisse cambierà il suo colore in 255.
All'inizio del programma, abbiamo definito uno stato di colore separato per ciascuna delle ellissi corrispondenti a un pulsante specifico.
E alla fine viene definita una funzione vuota per ciascuno dei pulsanti a levetta. Questa funzione invierà in modo seriamente un carattere specifico alla scheda Arduino quando viene premuto un interruttore a levetta.
Ad esempio, se il valore Toggle2 è falso un carattere B sarà trasmesso in serie ad Arduino. Che accenderà il LED al pin D11. Allo stesso modo, se il valore toggle2 è vero un carattere y verrà trasmesso in serie che trasformerà il LED sul pin D11.
Le seguenti tabelle ci danno un'idea di come funzionano questi personaggi seriali:
| Carattere seriale | Risposta di output |
|---|---|
| UN | Accendi il LED al pin D10 |
| B | Accendi LED al pin D11 |
| C | Accendi LED al pin D12 |
| X | Disattiva il LED al pin D10 |
| y | Disattiva il LED al pin D11 |
| z | Spegnere il LED al pin D12 |
Nota: Possiamo personalizzare questi caratteri su qualsiasi altro ma assicurarci di utilizzare gli stessi caratteri sia nell'Arduino che nel codice di elaborazione.
4: Codice IDE Arduino per GUI
Di seguito è riportato il codice Arduino scritto in Arduino IDE:
void setup ()
pinMode (10, output); /*PIN per LED1*/
pinMode (11, output); /*PIN per LED2*/
pinMode (12, output); /*PIN per LED3*/
Seriale.Inizia (9600); /*Tasso di baud seriale*/
void loop ()
Se (seriale.Disponit ()) /*Controlla la disponibilità di dati seriali dall'elaborazione* /
char val = seriale.Leggere(); /*Se i dati seriali sono disponibili archiviarli all'interno di una variabile*/
if (val == 'a') /*se a ricevuto* /
DigitalWrite (10, alto); /*attiva LED1*/
if (val == 'b') /*if b ricevuto* /
DigitalWrite (11, alto); /*attiva LED2*/
if (val == 'c') /*if c ricevuto* /
DigitalWrite (12, alto); /*attiva LED3*/
if (val == 'x') /*se x ricevuto* /
DigitalWrite (10, basso); /*disattiva led1*/
if (val == 'y') /*se hai ricevuto* /
DigitalWrite (11, basso); /*disattiva led2*/
if (val == 'z') /*se z ha ricevuto* /
DigitalWrite (12, basso); /*disattiva led3*/
if (val == 'o') /*se o ricevuto* /
DigitalWrite (10, alto);
DigitalWrite (11, alto); /*Accendi tutti i LED*/
DigitalWrite (12, alto);
if (val == 'f') /*if f ricevuto* /
DigitalWrite (10, basso);
DigitalWrite (11, basso); /*disattiva tutti i LED*/
DigitalWrite (12, basso);
Questo codice avviato definendo il PIN per tre LED. Ognuno di questi pin è definito come output usando la funzione pinMode (). Il prossimo codice Arduino verificherà continuamente i dati seriali. Se i dati seriali sono disponibili, genererà una risposta in base a questo.
Ad esempio, se l'interruttore a disattivazione della GUI di elaborazione viene premuto un carattere "UN" sarà ricevuto da Arduino e accenderà il LED al pin D10. Allo stesso modo se il personaggio "X" viene ricevuto in serie, spegnerà il LED al pin D10:
5: output
Dopo aver caricato il codice sulla scheda Arduino, eseguire il codice di elaborazione e assicurarsi che la scheda Arduino sia connessa in serie con il PC.
La finestra seguente si aprirà mostrandoci la GUI progettata per tre LED. Utilizzando questa GUI possiamo controllare uno qualsiasi dei LED campionando in attivazione dell'interruttore:
Possiamo controllare il bagliore a LED usando questa GUI:
Conclusione
L'uso del ControlP5 La biblioteca in combinazione con l'elaborazione e Arduino offre una soluzione potente per la creazione di progetti basati sulla GUI. La libreria fornisce un insieme completo di strumenti e widget che semplificano il processo di creazione di interfacce grafiche intuitive, consentendo agli sviluppatori di concentrarsi sulla funzionalità principale del proprio progetto.