ElectroYou

Ciao a tutti, sto lavorando su dei dispositivi per la gestione degli ambienti per la domotica, dovendo mettere un interfaccia utente, ho cercato dei display a colori da poter associare ad un micro e ho trovato dei display da 3.5" con driver ILI9488 che si possono configurare per comunicare tramite interfaccia SPI. Volendo usare un Atmega1284P per una questione di spazio, ho scelto di collegare i piedini del display a delle porte "non SPI" e di generare i segnali della comunicazione tramite semplicissimi HIGH e LOW in modo da evitare il prescaler (minimo di 2) presente nella porta SPI hardware presente nel micro. Effettuati i collegamenti e svolta una prova con i comandi "All Pixel ON" e "All Pixel OFF" sono riuscito a constatare che la comunicazione con il display avviene correttamente. Quando ho comprato i display ho chiesto al venditore di inviarmi i datasheet del dispositivo e all'interno dell'archivio ci ho trovato anche un esempio che però è per degli STM32. Provando la sequenza di inizializzazione il display non funziona e ho alcuni dubbii sulle configurazioni dei registri di Power Control e VCOM Control. Secondo me il problema potrebbe essere lì però non riesco a capire di cosa dovrei tenere conto per configurarli correttamente anche perché tra le note del Power Control 2 viene menzionato "Device damage" e quindi vorrei non dovermi ritrovare con un bel display nuovo da buttare... Guardando il codice di esempio ho stilato questo codice:

Codice: Seleziona tutto

/*
* ili9488.c
*
*  Created on: 30 mag 2025
*      Author: daniele
*/

#include <avr/io.h>
#include <util/delay.h>
#include "ili9488.h"


void send_ilidata(uint8_t type,uint8_t data){
   TOUCH_CS_high;
   SD_CS_high;
   DISPLAY_SCK_low;

   if(type){//Send CMD 1
      DISPLAY_DC_low;
   }else{//Send Data 0
      DISPLAY_DC_high;
   }
   //DISPLAY_SCK_low;
   DISPLAY_CS_low;
   for(type = 0; type < 8; type++){
      if(data & 0b10000000){
         DISPLAY_SDI_high;
      }else{
         DISPLAY_SDI_low;
      }

      DISPLAY_SCK_low;
      DISPLAY_SCK_high;

      data = data << 1;
   }
   DISPLAY_SCK_low;
   DISPLAY_CS_high;

}

void display_direction(uint8_t dir){
   send_ilidata(DISPLAY_send_cmd,0x36);
   switch(dir){
   case 0:
      send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(0<<6)|(0<<7));//BGR==1,MY==0,MX==0,MV==0
   break;
   case 1:
      send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(0<<7)|(1<<6)|(1<<5));//BGR==1,MY==1,MX==0,MV==1
   break;
   case 2:
      send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(1<<6)|(1<<7));//BGR==1,MY==0,MX==0,MV==0
   break;
   case 3:
      send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(1<<7)|(1<<5));//BGR==1,MY==1,MX==0,MV==1
   break;
   default:
      send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(0<<6)|(0<<7));//Case 0
   break;
   }
}

void display_setFrame(uint16_t xStart,uint16_t xEnd, uint16_t yStart,uint16_t yEnd){

   send_ilidata(DISPLAY_send_cmd,0x2A);//0x2A Column Address Set
   send_ilidata(DISPLAY_send_data,(xStart >> 8));
   send_ilidata(DISPLAY_send_data,(0x00FF & xStart));
   send_ilidata(DISPLAY_send_data,(xEnd >> 8));
   send_ilidata(DISPLAY_send_data,(0x00FF & xEnd));

   send_ilidata(DISPLAY_send_cmd,0x2B);//0x2B Page Address Set
   send_ilidata(DISPLAY_send_data,(yStart >> 8));
   send_ilidata(DISPLAY_send_data,(0x00FF & yStart));
   send_ilidata(DISPLAY_send_data,(yEnd >> 8));
   send_ilidata(DISPLAY_send_data,(0x00FF & yEnd));

   send_ilidata(DISPLAY_send_cmd,0x2C);//0x2C Memory Write

}

void display_sendColor16(uint16_t data){
   //18Bit
   send_ilidata(DISPLAY_send_data,(data >> 8) & 0xF8);//Red
   send_ilidata(DISPLAY_send_data,(data >> 3) & 0xFC);//Green
   send_ilidata(DISPLAY_send_data,(data << 3));//Blue

}

void display_clear(uint16_t color){
     display_setFrame(0,50,0,150);
     //DISPLAY_CS_low;
     //DISPLAY_DC_high;
      for(uint16_t tmp1=0;tmp1<50;tmp1++){
         for(uint16_t tmp2;tmp2 < 150;tmp2++){
            display_sendColor16(color);
         }
      }
     //DISPLAY_CS_high;
}
void display_reset(){
   DISPLAY_RST_high;
   _delay_ms(100);
   DISPLAY_RST_low;
   _delay_ms(100);
   DISPLAY_RST_high;
   _delay_ms(100);
}

void init_display(){
   DISPLAY_SDI_init;
   DISPLAY_SDO_init;
   DISPLAY_SCK_init;

   DISPLAY_CS_init;
   DISPLAY_DC_init;
   DISPLAY_RST_init;
   DISPLAY_BL_init;

   TOUCH_CS_init;
   SD_CS_init;

   DISPLAY_CS_high;
   TOUCH_CS_high;
   SD_CS_high;

   DISPLAY_BL_high; //PWM - timer0 OC0A


   display_reset();

   send_ilidata(DISPLAY_send_cmd,0x01);
   _delay_ms(5);
   send_ilidata(DISPLAY_send_cmd,0xB0);//Interface Mode Control
   send_ilidata(DISPLAY_send_data,0x80);//00

   send_ilidata(DISPLAY_send_cmd,0xF7); //ADJUST Control
   send_ilidata(DISPLAY_send_data,0xA9);
   send_ilidata(DISPLAY_send_data,0x51);
   send_ilidata(DISPLAY_send_data,0x2C);
   send_ilidata(DISPLAY_send_data,0x82);

   send_ilidata(DISPLAY_send_cmd,0xC0); //Power Control
   send_ilidata(DISPLAY_send_data,0x11);//11 VREG1OUT 4.625
   send_ilidata(DISPLAY_send_data,0x09);//09 VREG2OUT -4.125

   send_ilidata(DISPLAY_send_cmd,0xC1); //Power Control 2
   send_ilidata(DISPLAY_send_data,0x41);// ??

   send_ilidata(DISPLAY_send_cmd,0xC5); //VCOM Control
   send_ilidata(DISPLAY_send_data,0x00);
   send_ilidata(DISPLAY_send_data,0x0A);// -1.84
   send_ilidata(DISPLAY_send_data,0x80);// use -1.84 VCOM

   send_ilidata(DISPLAY_send_cmd,0xB1); //Frame Rate Control
   send_ilidata(DISPLAY_send_data,0xB0);//B0 Framerate 65.65
   send_ilidata(DISPLAY_send_data,0x11);// 17Clock

   send_ilidata(DISPLAY_send_cmd,0xB4); //Display inversion control
   send_ilidata(DISPLAY_send_data,0x02);

   send_ilidata(DISPLAY_send_cmd,0xB6); //Display Function Control
   send_ilidata(DISPLAY_send_data,0x02);
   send_ilidata(DISPLAY_send_data,0x42);//

   send_ilidata(DISPLAY_send_cmd,0xB7); //Entry Mode Set
   send_ilidata(DISPLAY_send_data,0xC6);

   send_ilidata(DISPLAY_send_cmd,0xBE); //HS Lanes Control
   send_ilidata(DISPLAY_send_data,0x00);
   send_ilidata(DISPLAY_send_data,0x04);

   send_ilidata(DISPLAY_send_cmd,0xE9); //Set Image Function
   send_ilidata(DISPLAY_send_data,0x00);

   send_ilidata(DISPLAY_send_cmd,0x36); //Memory Access Control
   send_ilidata(DISPLAY_send_data,0x00 | (1<<3)|(0<<7)|(1<<6)|(1<<5));

   send_ilidata(DISPLAY_send_cmd,0x3A);//Interface Pixel Format
   send_ilidata(DISPLAY_send_data,0x66);//DBI 18Bit-Pixel,DPI 18Bit-Pixel
   //send_ilidata(DISPLAY_send_data,0x77); //24Bit

   send_ilidata(DISPLAY_send_cmd,0xE0); //Positive Gamma Control
   send_ilidata(DISPLAY_send_data,0x00);
   send_ilidata(DISPLAY_send_data,0x07);
   send_ilidata(DISPLAY_send_data,0x10);
   send_ilidata(DISPLAY_send_data,0x09);
   send_ilidata(DISPLAY_send_data,0x17);
   send_ilidata(DISPLAY_send_data,0x0B);
   send_ilidata(DISPLAY_send_data,0x41);
   send_ilidata(DISPLAY_send_data,0x89);
   send_ilidata(DISPLAY_send_data,0x4B);
   send_ilidata(DISPLAY_send_data,0x0A);
   send_ilidata(DISPLAY_send_data,0x0C);
   send_ilidata(DISPLAY_send_data,0x0E);
   send_ilidata(DISPLAY_send_data,0x18);
   send_ilidata(DISPLAY_send_data,0x1B);
   send_ilidata(DISPLAY_send_data,0x0F);

   send_ilidata(DISPLAY_send_cmd,0xE1); //Negative Gamma Control
   send_ilidata(DISPLAY_send_data,0x00);
   send_ilidata(DISPLAY_send_data,0x17);
   send_ilidata(DISPLAY_send_data,0x1A);
   send_ilidata(DISPLAY_send_data,0x04);
   send_ilidata(DISPLAY_send_data,0x0E);
   send_ilidata(DISPLAY_send_data,0x06);
   send_ilidata(DISPLAY_send_data,0x2F);
   send_ilidata(DISPLAY_send_data,0x45);
   send_ilidata(DISPLAY_send_data,0x43);
   send_ilidata(DISPLAY_send_data,0x02);
   send_ilidata(DISPLAY_send_data,0x0A);
   send_ilidata(DISPLAY_send_data,0x09);
   send_ilidata(DISPLAY_send_data,0x32);
   send_ilidata(DISPLAY_send_data,0x36);
   send_ilidata(DISPLAY_send_data,0x0F);



   send_ilidata(DISPLAY_send_cmd,0x11); //Sleep OUT
   _delay_ms(120);
   //while(1);
   send_ilidata(DISPLAY_send_cmd,0x21); //Display Inversion OFF
   send_ilidata(DISPLAY_send_cmd,0x29); //Display ON
   // //All Pixel OFF(0x22) ON(0x23)
   while(1){
      send_ilidata(DISPLAY_send_cmd,0x23);
      _delay_ms(1000);
      send_ilidata(DISPLAY_send_cmd,0x22);
      _delay_ms(1000);
   }
   display_direction(0);
   display_clear(COLOR_GREEN);

}


Commentando il blocco while(1) ottengo sul display non l'area di 50x150 di colore verde ma tutto il display di colore bianco e a mia impressione poco acceso rispetto al "All Pixel ON" il che mi porta a pensare che ci sia qualcosa di sbagliato nella sezione di inizializzazione.
Guardando nel datasheet come detto in precedenza ci sono dei campi nominati "Power control" 1,2,3,4,5 e VCOM Control. Nel Power Control 1 si impostano due tensioni: una positiva e una negativa, però non riesco a capire sulla base di cosa dovrei individuare il valore corretto di questo parametro. Nel Power Control 2 ci sono ad esempio "VCI x 5", "VCI x 4" che mi portano al dubbio che possa essere un valore da moltiplicare per un qualche altra cosa ma non riesco a capire ccome interpretare questa tabella e sotto questa tra le note c'è scritto "To prevent the device damage". Nel Power Control 3 invece si imposta una frequenza di uno step up che anche questo non capisco a cosa serve ma comunque in genere penso sia necessario conoscere su quale area di circuito e in che modo sinterviene questo parametro prima di impostare una determinata frequenza. Nel Power Control 4 C'è sempre una frequenza da impostare, stessa cosa nel Power Control 5. Per quanto riguarda il VCOM, dipende dal VREG2OUT ed è una tensione. A pagina 323 c'è una tabella con dei valori indicati ma non dice nulla di più di quello indicato nei comandi. Ci sono anche i Negative / Positive Gamma Control che da altre parti (cercando su internet) ho trovato anche con valori differenti,che però non li vedo forniti e non è presente uno "standard". Potete indicarmi come dovrei procedere per risolvere questo problema?

Scrivere un driver per questi display partendo da zero non è semplicissimo! A meno che tu non lo faccia a scopo didattico, comporta un bel po' di impegno. Posso consigliarti di fare una ricerca su GitHub con le chiavi "ili9488 atmega NOT arduino " per evitare che ti tiri fuori migliaia di sorgenti per il malefico Arduino. Credo che potresti trovare quello che cerchi o magari uno spunto di partenza.
Forse qui c'è qualcosa :
https://github.com/vitaliy-bobrov/avr-t ... or-tester/

Lo so, i driver per questi display sono un po problematici però un 16 caratteri per due righe mi sembra orrendo da usare per gestire le configurazioni di un ambiente, in passato avevo trovato una libreria per ili9341 funzionante, però comunque il display da 2.4" mi sembrava un po piccolo, questi da 3.5" sono grandi circa mezzo telefono e così ne ho comprati una dozzina visto che comunque riuscito a farne funzionare uno, gli altri di conseguenza funzionano... Quando li ho comprati non speravo di trovare una libreria già pronta ma comunque di riuscire a fare qualcosa leggendo il datasheet, comunque scorrendolo fino a quasi la fine ho trovato una tabella dove sono indicati alcuni valori utili per identificare i valori da settare sul Power Control 2 (i campi VGH e VGL) rimane il mistero di questi VCOM e le frequenze dei regolatori... Comunque ora provo a guardare meglio il link che hai postato, forse trovo qualcosa che non ho considerato... Grazie...

Secondo me molti parametri vanno lasciati di default. Ho guardato il codice di inizializzazione di un driver per ESP32 e la sequenza di init del Display è questa di seguito. Power control 4 e 5 non vengono proprio impostati:

Codice: Seleziona tutto

#else
   // from Bodmer TFT_eSPI
   // see also https://components.espressif.com/components/atanisoft/esp_lcd_ili9488
   //          https://github.com/jaretburkett/ILI9488/blob/master/ILI9488.cpp

   lcd_init_cmd_t ili_init_cmds[]={
      { /* 0xE0 */ ILI9488_CMD_POSITIVE_GAMMA_CORRECTION, {0x00, 0x03, 0x09, 0x08, 0x16, 0x0A, 0x3F, 0x78, 0x4C, 0x09, 0x0A, 0x08, 0x16, 0x1A, 0x0F}, 15},
      { /* 0xE1 */ ILI9488_CMD_NEGATIVE_GAMMA_CORRECTION, {0x00, 0x16, 0x19, 0x03, 0x0F, 0x05, 0x32, 0x45, 0x46, 0x04, 0x0E, 0x0D, 0x35, 0x37, 0x0F}, 15},
      { /* 0xC0 */ ILI9488_CMD_POWER_CONTROL_1,           {0x17, 0x15}, 2},
      { /* 0xC1 */ ILI9488_CMD_POWER_CONTROL_2,           {0x41}, 1},
      { /* 0xC5 */ ILI9488_CMD_VCOM_CONTROL_1,            {0x00, 0x12, 0x80}, 3},
      { /* 0x36 */ ILI9488_CMD_MEMORY_ACCESS_CONTROL,     {0x48}, 1},     // changed  MX, BGR
      { /* 0x3A */ ILI9488_CMD_COLMOD_PIXEL_FORMAT_SET,   {0x66}, 1},     // 18-bit colour for SPI
      { /* 0xB0 */ ILI9488_CMD_INTERFACE_MODE_CONTROL,    {0x00}, 1},
      { /* 0xB1 */ ILI9488_CMD_FRAME_RATE_CONTROL_NORMAL, {0xA0}, 1},
      { /* 0xB4 */ ILI9488_CMD_DISPLAY_INVERSION_CONTROL, {0x02}, 1},
      { /* 0xB6 */ ILI9488_CMD_DISPLAY_FUNCTION_CONTROL,  {0x02, 0x02, 0x3B}, 3},  // changed
      { /* 0xB7 */ ILI9488_CMD_ENTRY_MODE_SET,            {0xC6}, 1},              // added
      { /* 0xF7 */ ILI9488_CMD_ADJUST_CONTROL_3,          {0xA9, 0x51, 0x2C, 0x02}, 4},
      { /* 0x11 */ ILI9488_CMD_SLEEP_OUT,                 {0x00}, 0x80},
      { /* 0x29 */ ILI9488_CMD_DISPLAY_ON,                {0x00}, 0x80},
      {0, {0}, 0xff},
   };
#endif

ti allego i sorgenti del driver.

Appena provato, stessa cosa, schermo bianco... Però secondo me c'è qualcosa che manca perché nei codici che mi hanno inviato l'SPI è configurata sul fronte di discesa invece il display che ho io funziona sul fronte di salita (come indicato nel datasheet) quindi è possibile che manca qualcosa, però è stano, nel datasheet ci dovrebbe essere tutto, guardando tra i varii comandi c'è il Interface Mode Control (B0h) dove è presente il bit per impostare se l'interfaccia è in rising o falling del clock, nel momento in cui viene impostato questo bit vanno riconfigurati i registri del micro in modo da impostare l'interfaccia sul fronte di discesa, nel codice di esempio è direttamente impostato sul fronte di discesa, questo valore permane se l'informazione viene registrata nella non volatile memory (Cosa che non ho intenzione di usare), quindi è possibile che in fabbrica impostino qualcosa, i display quando li ho ricevuti erano completamente nuovi non assemblati e imballati separatamente dalla scheda, quindi sicuramente nuovi di fabbrica e non configurati, cosa che invece è possibile che fanno nel caso in cui se ne compra uno solo. Nel frattempo ho contattato il venditore, e mi ha sottolineato di eseguire la procedura di inizializzazione indicata in un altro file, ma ugualmente non funziona. E' possibile che manchi qualcosa, vedo cosa mi dice...

pusillus ha scritto:... per evitare che ti tiri fuori migliaia di sorgenti per il malefico Arduino ...

Che poi sarebbero piu o meno tutti usabili anche con l'Atmega1284P, alla fine

Scherzi a parte, perche' proprio il 9488 ? ... per la comunicazione SPI e risparmiare qualche filo ? ... se si, non era meglio usare la SPI dell'Atmega ed una libreria preesistente ? (primo esempio trovato)

Comunque, parlano un po tutti di una certa lentezza usando le MCU Atmel con quei display, e suggeriscono di passare a roba piu veloce, anche se non so se a te' serva velocita' di refresh.

Potresti magari provarlo con un Arduino per vedere se funziona e poi lavorare sul tuo codice ...del resto chi non ha un Arduino buttato da qualche parte

pusillus ha scritto: ...del resto chi non ha un Arduino buttato da qualche parte

Io non ho un'arduino buttato da qualche parte ... cioe', non uno solo

Credo di avere una decina di schedine fra nano, uno, mega, mini ... principalmente cloni (ma forse sepolto da qualche parte deve esserci anche un'originale, si, ben uno ), comunque anch'io di solito li uso solo per testare i codici, perche' poi uso le MCU in standalone, sui miei PCB.

Cercavo un display un po' più grande del 2.4" e ho trovato questi da 3.5" con l'ili9488, il display può anche essere configurato per la comunicazione parallela, ma sono molti più pin che non ho a meno che non passo al 2560 che mi viene impossibile da saldare a casa, L'SPI del micro ha il difetto di avere un prescaler minimo di 2x quindi da 20Mhz massimo scende a 10Mhz invece utilizzando le uscite dirette come ho fatto nel codice in [1] siamo a poco meno di 20Mhz (qualche istruzione de ritardo per shift/for/if/pin high e low). Una libreria preesistente include diciamo "tutte" le funzioni che potrebbero servire, invece a me servirebbe qualcosa di basilare perché alcune parti grafiche voglio metterle su una microsd e a parte qualche numero da stampare e qualcosa non troppo eccessiva dovrei farcela con un micro anche non troppo prestante... Ho anche dei micro più potenti tipo degli STM32 o il raspberry pico (130Mhz dual core) ma ancora non li so usare, per quanto riguarda il refresh gli atmega sono lenti se si vuole aggiornare tutto il display: sono 320x480 pixel (18 bit ciascuno) però se le aree da aggiornare sono piccole e non si fanno grandi calcoli per generare queste aree non è poi così lento... Con il display da 2.4" avevo impostato il prescaler dell'SPI a 4, eh si, era veramente lento con un quarzo da 16Mhz il clock della porta scendeva 4Mhz e ci metteva un po'... Arduino ormai è da un po che non lo uso, non ho più micro con il bootloader e mi trovo in difficoltà ad utilizzare anche solo l'ide per la porta seriale, non lo installo più, però più di una volta mi sono detto che potrebbe essere utile anche solo per testare i dispositivi che compro, ma nulla, non lo uso più... Comunque ho provato anche l'inizializzazione dell'altro codice che avete postato ma nulla, il risultato è sempre lo stesso, schermo bianco... Domani mando una mail al fornitore con il codice e vedo un po cosa mi dice, probabilmente ci sarà qualcuno che si occupa di fornire supporto considerato che spesso questi dispositivi vengono venduti per schede di sviluppo tipo arduino che in pratica dovrebbero rendere più semplice il processo di realizzazione di un circuto...

Se ho capito bene gestisci la SPI "a mano"
Scelta secondo me discutibile
Hai provato ad esaminare il traffico sulla SPI?
Rispetto della sincronizzazione dei segnali
Se quello che invii è quello che effettivamente vedi
Se il clock è a posto
Spesso con le cose fatte a mano se ti arriva un interrupt nel mezzo di un trasferimento su allunga il clock e infastidisce la periferica
Prova a trasferire su SPI a interrupt disabilitati quando trasferisci un byte e lo riabiliti tra un byte e la trasmissione del successivo