Come usare un display Nextion con Arduino Mega

Progetto reale con orologio, temperatura e umidità

I display Nextion sono molto comodi quando vogliamo creare una interfaccia grafica senza scrivere tutta la grafica a basso livello su Arduino. Il display gestisce bottoni, pagine, immagini e testo, mentre Arduino si occupa della logica del progetto e dei sensori.

In questo articolo immaginiamo un progetto reale con:

• Arduino Mega 2560
• display Nextion collegato in seriale
• modulo RTC DS3231 per l'orologio
• sensore DHT22 per temperatura e umidità

L'obiettivo è creare tre schermate:

• una pagina principale con ora, temperatura e umidità
• una pagina per regolare l'orologio
• una pagina per regolare la luminosità del display

Architettura del progetto

La regola pratica migliore è questa:

• il Nextion fa da interfaccia utente
• Arduino legge i sensori e decide cosa mostrare
• il Nextion non contiene la logica del progetto, ma solo la UI

Questo approccio rende il sistema più facile da capire, da testare e da modificare.

Componenti usati

• Arduino Mega 2560
• Nextion Basic o Enhanced
• modulo RTC DS3231
• sensore DHT22
• alimentazione 5 V stabile

Se hai un Nextion Enhanced o Intelligent puoi anche usare alcune funzioni interne in più, ma per un progetto compatibile e semplice conviene lasciare il tempo al DS3231.

Collegamenti

Per evitare problemi con la porta USB usata per il debug, sul Mega conviene usare una seriale hardware dedicata al display.

Struttura delle pagine sul display

Per questo esempio possiamo creare:

Pagina 0: Home

• tTime per l'ora
• tTemp per la temperatura
• tHum per l'umidità
• bGoClock icona per andare alla pagina orologio
• bGoBright icona per andare alla pagina luminosità

Pagina 1: Regolazione orologio

• nHour numero per le ore
• nMin numero per i minuti
• bSaveTime pulsante salva
• bBack1 pulsante ritorno home

Pagina 2: Luminosità

• hBright slider 0..100
• tBright testo con percentuale
• bBack2 pulsante ritorno home

Come creare il progetto nel Nextion Editor

1. Crea un nuovo progetto

Apri il Nextion Editor e crea un nuovo file scegliendo:

• il modello esatto del display
• orientamento corretto
• risoluzione giusta

Questo passaggio è importante: se scegli il modello sbagliato, il file compilato .tft potrebbe non funzionare correttamente sul display reale.

2. Importa le icone

Nel pannello delle risorse importa le immagini che vuoi usare per:

• home
• orologio
• luminosità

Poi inseriscile nella pagina con componenti tipo Picture o con bottoni grafici.

3. Disegna la pagina principale

Nella page0 metti:

• sfondo pulito
• tre aree di testo per ora, temperatura e umidità
• due icone per la navigazione

Nomina bene gli oggetti. Esempio:

• tTime
• tTemp
• tHum
• bGoClock
• bGoBright

4. Disegna la pagina di regolazione ora

Nella page1 inserisci:

• due campi numerici per ore e minuti
• un pulsante salva
• un pulsante torna indietro

Puoi anche aggiungere due testi descrittivi:

• tHourLabel
• tMinLabel

5. Disegna la pagina luminosità

Nella page2 inserisci:

• uno slider hBright
• un testo tBright
• un pulsante bBack2

6. Imposta le azioni locali nel display

Le azioni che non richiedono Arduino è meglio farle gestire direttamente al Nextion.

• su bGoClock metti page page1
• su bGoBright metti page page2
• su bBack1 metti page page0
• su bBack2 metti page page0

Per gli oggetti che devono parlare con Arduino, abilita l'invio degli eventi touch verso la seriale, così Arduino può ricevere i callback della libreria.

Logica lato Arduino

Arduino deve fare queste cose:

• inizializzare RTC, DHT e seriale del Nextion
• leggere ora dal DS3231
• leggere temperatura e umidità dal DHT22
• aggiornare i campi testo del display
• ricevere il tocco dei pulsanti
• salvare una nuova ora sul DS3231
• cambiare la luminosità del Nextion

Librerie Arduino

Per questo progetto vanno benissimo:

• ITEADLIB_Arduino_Nextion per il display
• RTClib per il DS3231
• DHT sensor library di Adafruit
• Adafruit Unified Sensor come dipendenza del DHT

Nota utile: la libreria ufficiale Nextion è pensata per schede con seriale hardware. Nel repository ufficiale è indicato che la configurazione di default è per MEGA2560, con seriale Nextion configurabile da NexConfig.h.

Sketch base di esempio

Questo non vuole essere il firmware finale, ma uno scheletro pulito da cui partire.

#include 
#include 
#include 
#include 

#define DHTPIN 7
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);
RTC_DS3231 rtc;

NexText tTime    = NexText(0, 1, "tTime");
NexText tTemp    = NexText(0, 2, "tTemp");
NexText tHum     = NexText(0, 3, "tHum");
NexButton bGoClock  = NexButton(0, 4, "bGoClock");
NexButton bGoBright = NexButton(0, 5, "bGoBright");

NexNumber nHour  = NexNumber(1, 1, "nHour");
NexNumber nMin   = NexNumber(1, 2, "nMin");
NexButton bSaveTime = NexButton(1, 3, "bSaveTime");

NexSlider hBright = NexSlider(2, 1, "hBright");
NexText tBright   = NexText(2, 2, "tBright");

NexTouch *nex_listen_list[] = {
  &bGoClock,
  &bGoBright,
  &bSaveTime,
  &hBright,
  NULL
};

void updateHomePage() {
  DateTime now = rtc.now();

  char bufTime[9];
  snprintf(bufTime, sizeof(bufTime), "%02d:%02d:%02d",
           now.hour(), now.minute(), now.second());
  tTime.setText(bufTime);

  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (!isnan(t)) {
    char bufTemp[16];
    snprintf(bufTemp, sizeof(bufTemp), "%.1f C", t);
    tTemp.setText(bufTemp);
  }

  if (!isnan(h)) {
    char bufHum[16];
    snprintf(bufHum, sizeof(bufHum), "%.1f %%", h);
    tHum.setText(bufHum);
  }
}

void bSaveTimePopCallback(void *ptr) {
  uint32_t hh = 0;
  uint32_t mm = 0;
  nHour.getValue(&hh);
  nMin.getValue(&mm);

  DateTime now = rtc.now();
  rtc.adjust(DateTime(now.year(), now.month(), now.day(),
                      hh % 24, mm % 60, 0));
}

void hBrightPopCallback(void *ptr) {
  uint32_t value = 0;
  hBright.getValue(&value);

  char cmd[16];
  snprintf(cmd, sizeof(cmd), "dim=%lu", value);
  sendCommand(cmd);

  char txt[16];
  snprintf(txt, sizeof(txt), "%lu%%", value);
  tBright.setText(txt);
}

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600);

  Wire.begin();
  dht.begin();
  rtc.begin();
  nexInit();

  bSaveTime.attachPop(bSaveTimePopCallback, &bSaveTime);
  hBright.attachPop(hBrightPopCallback, &hBright);

  if (rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  updateHomePage();
}

void loop() {
  static unsigned long lastUpdate = 0;

  nexLoop(nex_listen_list);

  if (millis() - lastUpdate >= 1000) {
    lastUpdate = millis();
    updateHomePage();
  }
}

Come funziona questo sketch

• ogni secondo Arduino aggiorna tTime, tTemp e tHum
• quando tocchi bSaveTime, Arduino legge nHour e nMin e aggiorna il DS3231
• quando tocchi lo slider hBright, Arduino legge il valore e invia il comando dim=... al display

Per il comando luminosità, il Nextion usa istruzioni seriali dedicate. La regolazione è in percentuale da 0 a 100.

Compilazione del progetto Nextion

Una volta finita la grafica:

1. fai un test in Debug nel Nextion Editor
2. correggi eventuali ID o nomi errati
3. compila il progetto
4. genera il file .tft

Il file .tft è quello che va caricato nel display.

Caricamento del programma sul display

Upload da Nextion Editor via seriale

Comodo per sviluppo rapido, ma attenzione:

• il display deve essere collegato a una seriale accessibile dal PC
• se il display è ancora collegato al Mega, possono esserci conflitti

Upload via microSD

Spesso è la strada più semplice e robusta:

1. copia il file .tft nella microSD
2. lascia un solo file .tft nella scheda
3. inserisci la microSD nel Nextion
4. riaccendi il display
5. attendi il completamento dell'update

Caricamento del firmware su Arduino

1. installa le librerie
2. verifica che la libreria Nextion punti alla seriale giusta
3. compila lo sketch
4. carica il firmware sul Mega

Se usi la libreria ufficiale Nextion e vuoi una seriale diversa da quella di default, controlla il file NexConfig.h.

Strategia di test consigliata

Test 1: solo display

• crea page0
• scrivi un testo fisso
• verifica che il .tft venga caricato correttamente

Test 2: solo seriale

• invia da Arduino un testo a tTime
• controlla che il display si aggiorni

Test 3: solo RTC

• stampa l'ora sul monitor seriale
• verifica che il DS3231 tenga il tempo

Test 4: solo DHT22

• leggi temperatura e umidità
• ricorda che il DHT22 non va interrogato troppo spesso

Test 5: callback touch

• tocca bSaveTime
• verifica che Arduino riceva l'evento

Test 6: luminosità

• muovi hBright
• verifica che il display cambi intensità

Errori comuni

• TX e RX invertiti male
• alimentazione insufficiente del display
• oggetti Nextion con nomi diversi da quelli usati nello sketch
• page ID o component ID sbagliati
• libreria Nextion configurata su una seriale diversa
• DHT letto troppo spesso
• mancanza di massa comune

Una buona divisione dei compiti

Se vuoi un progetto ordinato, tieni questa regola:

• Nextion: grafica, pagine, bottoni, slider
• Arduino: sensori, tempo, logica, controlli

Con questa divisione il progetto cresce bene. Se domani vuoi aggiungere allarmi, storico temperatura o una pagina impostazioni, non devi rifare tutto da zero.

Conclusione

Un display Nextion con Arduino Mega è una soluzione molto pratica per costruire interfacce touch senza impazzire con la grafica embedded tradizionale.

Per un progetto come questo, il percorso migliore è:

• creare bene le pagine nel Nextion Editor
• nominare gli oggetti in modo coerente
• usare il Mega per tutta la logica
• aggiornare il display via seriale solo quando serve
• testare un blocco alla volta

Se vuoi, da qui puoi anche ricavare una seconda puntata con progetto completo, file .ino più rifinito e lista dettagliata degli oggetti Nextion pagina per pagina.

Riferimenti utili

• Libreria ufficiale Nextion per Arduino
• Tutorial ufficiale Nextion con Mega2560
• Guida editor Nextion
• Instruction set Nextion
• RTClib per DS3231
• DHT sensor library