Tutorial: uLCD-32PT e Arduino come programmatore seriale

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

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.