Al tuo progetto manca un po’ di grafica e un bel display touch screen?
ho provato il display touch della 4dsystems: uLCD-32PT scoprendo un modo economico per abbellire tutti i miei progetti.
Questo display può funzionare in due modalità: GFX e SGC come descritto sul sito del produttore.
Puoi utilizzarlo con arduino in entrambe le modalità nella modalità grafica dovrai utilizzare il suo linguaggio di programmazione per generare le immagini mostrate e la comunicazione seriale per trasferire ad arduino le coordinate del touch; nella modalità SGC puoi comandare tutto da arduino via seriale.
I display non escono tutti impostati nella medesima modalità, alcuni escono pre-impostati in modalità SGC ed altri in modalità GFX, se il tuo è impostato in modalità GFX dovrai eseguire l’aggiornamento del firmware.
Aggiornamento modalità SGC
per eseguire l’aggiornamento dalla modalità GFX a quella SGC il sito del costruttore rilascia il software PmmC-Loader ed il firmware da caricare sul display: uLCD-32PT-I-SGC-R22.PmmC
Il software funziona solo sotto windows.
Il cambio dalla modalità GFX a quella SGC e viceversa può essere eseguito tutte le volte che vuoi, secondo il sito del produttore, tuttavia riporto il link alle condizioni di garanzia: warranty label direttamente dal sito 4dsystems che ti consiglio di leggere prima di eseguire qualsiasi operazione con il display.
La procedura è alquanto semplice, ti occorre:
- n.1 arduino (Uno o Duemilanove)
- n.1 display uLCD-32PT
- n. 5 cavi femmina/maschio per collegare il display ad Arduino
Important!
ATTENZIONE: estrai il microprocessore ( Atmega328 o altro ) da arduino,
in questa modalità di funzionamento arduino si comporta solo come interfaccia seriale-usb, collega il tutto come in figura:
in pratica devi collegare :
- il pin 1 di arduino ( TX ) al TX del display
- il pin 0 di arduino ( RX ) al RX del display
- il pin +5v di arduino al Vin del display
- il pin GND di arduino al GND del display
- il pin RESET di arduino al RST del display
in questa configurazione tutti i dati che invierai ad arduino mediante la connessione seriale creata dal chip di interfaccia arriverà al display.
Ho realizzato un video in cui puoi vedere i passaggi eseguiti con Windows Xp ed il programma PmmC-Loader.exe:
uLCD-32PT e arduino
A questo punto il tuo display è in modalità SGC, puoi iniziare ad utilizzarlo collegandolo ad arduino.
Per collegarlo puoi seguire lo schema:
avrai notato che i pin TX,RX e RESET sono stati posizionati in modo differente rispetto a quando hai cambiato il firmware del display.
I pin RX e TX di arduino li utilizzerai per inviare lo sketch al microprocessore, i pin 2 e 3 di arduino li utilizzerai per inviare i segnali al display ed il pin 4 come pin di reset.
Lo sketch
Per utilizzare il display uLCD-32PT con arduino io ho scelto di utilizzare le librerie scritte da rei-vilo, all’inizio ho riscontrato delle difficoltà ed ho scritto a Rei che si è dimostrato molto disponibile nel darmi aiuto e mi ha chiarito i primi dubbi sulla modalità GFX e SGC che ho descritto sopra.
Caricate le librerie inArduino ho selezionato:
File -> Examples -> Serial_uLCD -> Examples -> touch_main ( l’ultimo esempio fornito da Rei )
ed ecco lo sketch:
//
/// @file memu_main.pde
/// @brief Example
/// @details
/// @n @a Example for Serial_LCD Library Suite
/// @n @a for 4D Systems uLCD-uLED-uVGA Serial_LCD Library Suite
/// @n on Arduino 0023 and 1.0, chipKIT MPIDE 0023, Wiring 1.0
///
/// @a Developed with [embedXcode](http://embedXcode.weebly.com)
///
/// @author Rei VILO
/// @author http://embeddedcomputing.weebly.com
/// @date Jul 12, 2012
/// @version release 132
/// @n
/// @copyright © Rei VILO, 2010-2012
/// @copyright CC = BY NC SA
/// @n http://embeddedcomputing.weebly.com/serial-lcd.html
/// @n http://github.com/rei-vilo/Serial_LCD
///
/// @see 4D Systems Goldelox and Picaso SGC Command Set
/// @n http://www.4dsystems.com.au/
///
// Core library
#if defined (__AVR_ATmega328P__) || defined (__AVR_ATmega2560__) // Arduino specific
#include "WProgram.h" // — for Arduino 0023
// #include "Arduino.h" // — for Arduino 1.0
#elif defined(__32MX320F128H__) || defined(__32MX795F512L__) // chipKIT specific
#include "WProgram.h"
#elif defined(__AVR_ATmega644P__) // Wiring specific
#include "Wiring.h"
#elif defined(__MSP430G2452__) || defined(__MSP430G2553__) || defined(__MSP430G2231__) // LaunchPad specific
#include "Energia.h"
#endif
// Include application, user and local libraries
#include "Wire.h"
#include "proxySerial.h"
#include "Serial_LCD.h"
#include "GUI.h"
// test release
#if GUI_RELEASE < 114
#error required GUI_RELEASE 114
#endif
// uncomment for I2C serial interface
//#define __I2C_Serial__
// === Serial port choice ===
#if defined(__I2C_Serial__) // I2C serial
#include "Wire.h"
#include "I2C_Serial.h"
I2C_Serial mySerial(0);
#elif defined (__AVR_ATmega328P__) // software serial
#if defined(ARDUINO) && (ARDUINO>=100) // for Arduino 1.0
#include "SoftwareSerial.h"
SoftwareSerial mySerial(2, 3);
#else
#include "NewSoftSerial.h" // for Arduino 23
NewSoftSerial mySerial(2, 3);
#endif
#elif defined(__32MX320F128H__) || defined(__32MX795F512L__) || defined (__AVR_ATmega2560__) || defined(__AVR_ATmega644P__) // hardware serial Serial1
#define mySerial Serial1
#else // error
#error Platform not defined
#endif
// === End of Serial port choice ===
// Define variables and constants
ProxySerial myPort(&mySerial); // hardware abstraction layer
Serial_LCD myLCD(&myPort); // LCD
uint16_t x, y;
uint32_t l;
button b7;
void setup() {
Serial.begin(9600);
Serial.print("\n\n\n***\n");
// === Serial port initialisation ===
#if defined(__I2C_Serial__)
Serial.print("i2c Serial\n");
Wire.begin();
#elif defined(__AVR_ATmega328P__)
Serial.print("Software Serial\n");
#elif defined(__32MX320F128H__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega644P__)
Serial.print("Hardware Serial\n");
#endif
// === End of Serial port initialisation ===
mySerial.begin(9600);
myLCD.begin(4); // 9600 at start-up
// === Serial port speed change ===
if (false) {
myLCD.setSpeed(38400);
mySerial.begin(38400);
}
// === End of Serial port speed change ===
myLCD.setOrientation(0x03);
myLCD.setPenSolid(true);
myLCD.setFontSolid(true);
myLCD.setFont(0);
myLCD.gText( 0, 210, myLCD.WhoAmI());
myLCD.setTouch(true);
l=millis();
myLCD.ellipse(100, 100, 50, 20, myLCD.setColour(0xff,0x00,0x00));
b7.define(&myLCD, 0, 0, 79, 59, setItem(0, "Stop"), myLCD.setColour(0xff, 0xff, 0xff), myLCD.setColour(0xff, 0x00, 0x00), myLCD.setColour(0x88, 0x00, 0x00), 9);
b7.enable(true);
b7.draw();
myLCD.setPenSolid(false);
myLCD.rectangle(40, 40, 200, 200, myLCD.setColour(0x00, 0x00, 0xff));
myLCD.detectTouchRegion(40, 40, 200, 200);
}
uint8_t c;
void loop() {
c=myLCD.getTouchActivity();
myLCD.setFont(3);
myLCD.gText(140, 10, ftoa(c, 0, 5));
if ((c==1) || (c==3)) {
myLCD.getTouchXY(x, y);
myLCD.setFont(1);
myLCD.gText(200, 0, ftoa(x, 0, 5));
myLCD.gText(200, 20, ftoa(y, 0, 5));
myLCD.point(x, y, 0xffff);
// quit
if (b7.check()) {
myLCD.off();
while(true);
}
}
myLCD.setFont(0);
myLCD.setFontSolid(true);
myLCD.gText( 250, 225, String(millis()-l));
l=millis();
}
Non ti spiegherò linea per linea il codice in quanto molto intuitivo e ben commentato, nei prossimi articoli con il display ldc scriverò io del codice e ti spiegherò passo dopo passo le istruzioni che esegue il display, in questo primo tutorial l’obiettivo è cambiare il firmware e testare un esempio di quelli forniti con le librerie.
C’è una modifica che devi eseguire al codice che dipende dalla versione del tuo IDE, sono le linee 27 e 28: se usi la versione dell’IDE 0023 puoi lasciare invariate queste linee, se utilizzi la versione 1.0, come me, devi commentare la linea 27 e decommentare la linea 28:
// #include "WProgram.h" // — for Arduino 0023 #include "Arduino.h" // — for Arduino 1.0
Se devi eseguire la modifica te ne accorgerai subito dopo la pressione del pulsante di compilazione perchè otterrai il seguente errore:
ho realizzato un video demo di questo sketch dopo averlo uplodato su arduino:
Buon divertimento.
7 comments
1 ping
diego
9 agosto 2012 a 12:16 (UTC 2) Link to this comment
Ciao! Ho da poco acquistato lo stesso display. Avevo già trovato le librerie dell’esempio ma sono testardo e vorrei utilizzare le librerie di Arduino.purtroppo i comandi complessi non riesco ad eseguirlo. I comandi come 55 e 45 funzionano. Ma già cambiare il colore dello sfondo è un ostacolo. Credo ci sia qualche problema con le istruzioni serial.print (). Poi darmi qualche dritta?
Mauro Alfieri
10 agosto 2012 a 23:38 (UTC 2) Link to this comment
Ciao Diego,
non ho provato con le librerie arduino. Sono contento che tu sia testardo xchè è dalla tenacia che nasce un buon progetto.
Proverò anch’io prossimamente e se faccio qualche passo avanti. Te lo comunico.
Tienimi aggiornato su cosa scopri, magari lo condividiamo con il team arduino.
Mauro
Leonid
20 agosto 2012 a 15:30 (UTC 2) Link to this comment
Ciao!
Bell’articolo, carino il display, ma mi potresti dire, per piacere, da dove l’hai comprato e a che prezzo? Sul sito del produttore c’è scritto “This product is no longer in stock”..
Grazie, buona giornata!
Leonid..
Mauro Alfieri
20 agosto 2012 a 16:49 (UTC 2) Link to this comment
Ciao Leonid,
si è davvero un ottimo display semplice da programmare
io l’ho acquistato da robot-domestici, cerca: Serial TFT LCD 3.2″
Mauro
benedetto
28 marzo 2013 a 23:08 (UTC 2) Link to this comment
ciao mauro
voglio capire se con arduino e possibile gestire una seri di motori tramite rele e motori passopasso in base a ingressi dati da temperature(lete da sonde ntc) e pressioni (lette da trasdutori razimetrici )e mi incuriosisce il tuo display –> come dire pensi si possa fare in modo che nel display appaiano i valori letti dai vari sensori e lo stato delle varie uscite?
spero tu mi possa dare qualche risposta in positivo.
se ti servono chiarimenti o specifiche tecniche chiedi perche avrei una serie di esigenze derivanti dal mio lavoro.
ti saluto e aspetto verdetto.
Mauro Alfieri
29 marzo 2013 a 10:29 (UTC 2) Link to this comment
Ciao Benedetto,
così come mi descrivi il progetto direi che è possibile.
Tuttavia solo conoscendo i dettagli del tuo progetto potrò essere più preciso.
Questo LCD l’ho utilizzato per un progetto su commissione in cui tramite display touch e shield relè ho automatizzato un ciclo di lavoro legato alla gestione dei lavaggi auto e non solo.
Se ti interessa avere una mia consulenza in ambito lavorativo per il tuo progetto scrivimi i dettagli del progetto, una sorta di workflow e i tipi di sensori all’indirizzo info del blog.
Mauro
benedetto
30 marzo 2013 a 18:53 (UTC 2) Link to this comment
bene
ti ringrazio per la risposta!
quanto prima raccolgo dati e schemi e te li mando.
tieni comunque conto che sto cominciando adesso a mettere il naso in schede di questo tipo ,ho sempre avuto a che fare con prodotti preconfezionati che pero presentano sempre il problema della scarsa flessibilità o buona flessibilità ma con costi esorbitanti.
ti saluto e auguro buona PASQUA a te e a tutti !!!
Benedetto
Tutorial: uLCD-32PT cambiare sfondo e i primi disegni » Mauro Alfieri
17 agosto 2012 a 09:10 (UTC 2) Link to this comment
[...] segnalazione di un appassionato come te e me che ha commentato il primo articolo dedicato al display grafico uLCD-32PT, ho iniziato a testare alcune funzioni della libreria [...]