Tutorial: uLCD-32PT e Arduino come programmatore seriale

Al tuo progetto manca un po’ di grafica e un bel display touch screen?

uLCD-32PT SGC mode

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

in questa modalità di funzionamento arduino si comporta solo come interfaccia seriale-usb, collega il tutto come in figura:

schema arduino serial interface

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:

uLCD-32PT seriale

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 , 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:

arduino compiling error

ho realizzato un video demo di questo sketch dopo averlo uplodato su arduino:

Buon divertimento.

 

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/informatica/tutorial-ulcd-32pt-e-arduino-come-programmatore-seriale.html

33 comments

1 ping

Skip to comment form

    • diego on 9 agosto 2012 at 12:16
    • Reply

    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?

    1. 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 on 20 agosto 2012 at 15:30
    • Reply

    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..

    1. 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 on 28 marzo 2013 at 23:08
    • Reply

    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.

    1. 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 on 30 marzo 2013 at 18:53
    • Reply

    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

    • Michele on 19 novembre 2013 at 14:21
    • Reply

    Buongiorno, ho acquistato il display uLCD-24PT-AR con l’adattatore per arduino, non mi è ancora arrivato, ma vorrei sapere se la procedura indicata sopra cioè il passaggio dalla modalità GFX a quella SGC e viceversa è necessaria? a cosa serve di preciso? (anche perchè i link per scaricare il programma e il firmware non funzionano). Sul sito, purtroppo tutto in inglese ora c’è il programma Workshop4.0 le cui informazioni sono anch’esse in inglese e quindi non ci ho capito molto, serve a programmare in qualche modo direttamente il display? grazie.

    1. Ciao Michele,
      se leggi il mio articolo, in italiano, capirai a cosa serve la conversione tra GFX a SGC ossia da modalità grafica a quella seriale.
      Non conosco l’adattatore arduino in quanto io non l’ho utilizzato come hai letto nell’articolo.
      Il cambio di modalità serve solo se il tuo display arriva in modalità GFX e tu vuoi utilizzarlo in modalità Seriale.

      Infine so che hanno sostituito il vecchio e scarno programma con uno decisamente più interessante e che offre molte possibilità in più semplificandole.
      Ho visto che ci sono dei video che spiegano molto bene sia le potenzialità del programma sia come eseguire le operazioni sul display.
      Solitamente i video aiutano anche se non conosci l’inglese in quanto ti mostrano passo-passo cosa devi fare.

      Mauro

    • Jonny on 24 dicembre 2013 at 15:48
    • Reply

    Buongiorno Mauro,
    complimenti per la fantastica guida. Ho da poco scoperto l’esistenza di questo fantastico display e volevo saperne di più. Ho programmato l’arduino per gestire un impianto d’allarme, con sensori, tasti, display 20×2 sirena ecc, riempiendo totalmente le porte in/out e caricando il codice al massimo. Sarebbe possibile con questo display liberare qualche porta, programmarlo col suo software con tasti e scritte più carine e comunicare in seriale la pressione dei tasti verso arduino e di ritorno scritte da mostrare sul display e cambio delle schermate? Non ho capito se la funzione GFX si possa usare in seriale per trasmettere info ad arduino e viceversa ma gestire la grafica dal software fornito col display o si debba usare esclusivamente usarlo in GSC per dialogare con arduino. Grazie e buone feste

    1. Ciao Jonny,
      puoi seguire i tutorial sul sito ufficiale del display per comprendere come interagire in modalità grafica, io ho provato solo con la comunicazione seriale ma senza grafica.

      Mauro

    • max on 24 gennaio 2014 at 21:22
    • Reply

    avrei bisogno di contattarti in privato .puoi farmi avere la tua mail?
    grazieùmax

    1. Ciao Max,
      trovi la mia email nella sezione contatti nella forma antispam, ossia con la @ scritta come at e il . come dot 🙂

      Mauro

    • Gianluca on 26 febbraio 2014 at 13:27
    • Reply

    Ciao Mauro,
    ci siamo già conosciuti su un altro progetto con arduino.
    Ho visto questo tuo nuovo progetto con il display touch.. Senti volevo chiederti se con questo display e con un arduino uno riesco a far funzionare un relè sotto un controllo di una data di scadenza. Ti spiego io inserisco una data di scadenza sul display e quando arriva la data di scadenza arduino mi deve far attivare un relè..
    Come sempre ti ringrazio..

    1. Ciao Gianluca,
      una sorta di sveglia o allarme? Penso sua necessario aggiungere anche una RTC shield per avere data e ora sempre aggiornati.

        • gianluca on 1 marzo 2014 at 18:30
        • Reply

        Ciao,
        si più o meno un allarme… Per spiegarti meglio io devo comandare 8 relè con arduino, li devo far attivare tramite 8 date diverse/uguali (giorno mese anno) ogni relè possiede la sua data. Siccome non ho la possibilità di programmare ogni volta arduino con il computer, volevo usare il display che hai usato tu…ho visto la RTC Shield si forse è meglio che uso anche quella. Secondo te è fattibile una gestione del genere con display e arduino?Un altra cosa siccome arduino è sempre in tensione, il display posso collegarlo e scollegarlo da arduino, non succede nulla a entrambi ?
        Come sempre ti rigrazio …

        1. Ciao Gianluca,
          per rispondere alla tua prima domanda, si è fattibile.
          Sul display che colleghi e scolleghi potresti causare dei reset di arduino facendo tale operazione, io la sconsiglio.

          Mauro

            • gianluca on 3 marzo 2014 at 19:43

            ciao..
            grazie mille, appena mi arriva il materiale e inizio a lavorarci su te lo dico.. se ho problemi posso osare disturbarti ?

          1. Ciao Gianluca,
            è tanto tempo che non uso più quel display ma se incontri delle difficoltà non descritte nei miei articoli puoi chiedere senza problemi.

    • gianluca on 13 marzo 2014 at 11:57
    • Reply

    ciao Mauro,
    Vorrei farti vedere un mio sketch che non riesco a capire perchè non funziona.. Non so se posso copiarlo qui aspetto la tua conferma. devo far muovere 2 o più servi con arduino collegato ad una scheda ssc-32 in seriale, i movimenti dei servi li voglio fare con un joystick analogico. In attesa di una tua risposta.
    Come sempre ti ringrazio…

    1. Ciao Gianluca,
      non è possibile incollare script sui commenti, vengono rimossi in automatico.
      Solitamente non correggo gli sketch che i lettori mi inviano perché siete in troppi e non ce la farei a star dietro a tutti dovendo almeno procurarmi il materiale identico al vostro per riprodurre le anomalie.
      Capirai che è impossibile.

      Nel tuo caso non possiedo ne conosco la scheda ssc-32 quindi non saprei aiutarti.

    • gianluca on 13 marzo 2014 at 12:27
    • Reply

    Si in effetti non ci avevo pensato.. grazie mille

    • gianluca on 18 marzo 2014 at 21:00
    • Reply

    Ciao Mauro,
    mi è arrivato il display, ma non c’era disponibile il modello che hai usato tu mi è arrivato il modello uLCD-32PTU
    non so dove trovare il file SGC ho visto anche sul sito della 4D… Ho trovato e provato a mettere uLCD-32PTU-A-PmmC ma mi va in errore… come posso fare ? Riesci a dirmi dove trovare il file ? grazie mille

    1. Ciao Gianluca,
      io ho prelevato tutto dal sito della 4DSystem che mi sembra ben fatto e ricco di tutorial.
      Se non trovi il programma adatto o ti da errore prova a scrivere loro.

    • Karim on 16 luglio 2014 at 14:28
    • Reply

    Salve……
    molto interessante il progetto…..volevo chiederle se è possibile utilizzare questo display con arduino uno per memorizzare i caratteri provenienti dalla tastiera touch del display (dopo aver premuto invio) all’interno di arduino…..il tutto ovviamente attraverso comunicazione seriale

    1. Ciao Karim, é molto tempo che non utilizzo questo display tuttavia penso sia possibile farlo.

    • Sergio on 22 marzo 2016 at 20:55
    • Reply

    Ciao,
    mi chiedevo se fosse possibile creare uno stereo con questo display tramite arduino. Mi spiego meglio: un lettore mp3 (pendrive , microSD), che sia in grado di cambiare canzone attraverso il display.
    Grazie in anticipo.

    1. Ciao Sergio,
      penso sia possibile, potresti controllare un riproduttore Mp3 con arduino e interfacciarlo al display.

    • luca on 5 aprile 2016 at 16:23
    • Reply

    ciao mauro
    sto facendo un progetto con arduino e vorrei comprare un display touch..secondo te questo è compatibile con arduino uno? grazie!
    http://www…….it/pollici-Schermo-Pannello-MicroSD-TE175

    1. Ciao Luca,
      come hai letto nelle regole del blog, in fondo ad ogni pagina, è vietato incollare link a siti di aste,e-commerce o generalisti.
      In ogni caso è impossibile, per me, dirti se un display visto su internet sia adatto o meno senza un adeguato test.

    2. Ciao Luca,
      come hai letto nelle regole del blog, in fondo ad ogni pagina, è vietato incollare link a siti di aste,e-commerce o generalisti.
      In ogni caso è impossibile, per me, dirti se un display visto su internet sia adatto o meno senza un adeguato test.

    • Mauro on 15 luglio 2018 at 19:08
    • Reply

    Questo display si può anche abbinare a una scheda Arduino Leonardo per fare questo contapezzi con conta tempo?
    https://m.youtube.com/watch?v=QklgvOB7Y8w

    1. Ciao Mauro,
      dal video mi sembra che sia proprio il medesimo display.

  1. […] 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 […]

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.