Termocamera IR- scala colore

Ciao a tutti, ho questo codice per costruire una termocamera IR con un sensore AMG8833 e un display 1.44'' TFT

thermal_cam.ino (4,4 KB)

collegati come in figura

Benchè il codice funzioni, non è molto utile in quanto sul display non vi è una scala di colore che assegna a un determinato colore un valore in °C ; cioè, quello che mi servirebbe è una scala come quella in questo plot

che quindi permette di misurare la temperatura in ogni pixel del display. Qualcuno sa aiutarmi a scrivere il codice per aggiungere la scala?

Dovrebbe essere abbastanza semplice.

Aggiungi un ciclo for che scansiona
tutto l'array dei colori e disegna un paio di pixel sulla destra colore per colore scalando la posizione verticale (impostando il colore del singolo pixel oppure con un tft.fillRect()).

Ciao, innanzitutto grazie

Ho cercato tft.fillRect() e ho trovato questo Tft.fillRect() - Microduino Wiki quindi, se ho ben capito la scala colore si disegna così

tft.fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)

Invece, la scansione, il riempimento del colore e il valore numerico nella scala colore con cosa devo farlo?

@faca87 devi cercare l'istruzione relativa alla libreria che stai usando!
Graphics Primitives | Adafruit GFX Graphics Library | Adafruit Learning System

Comunque va bene copiaincollare del codice preso online, ma è fondamentale cercare di capire cosa fa se vuoi metterci le mani.
Io ad esempio quando mi capita, riscrivo tutti i commenti dei passaggi essenziali per chiarirmi cosa voleva ottenere il programmatore.

Ad esempio in questo caso (ho omesso tutto ciò che è dichiarativo o poco importante per capirne il funzionamento):

// Array di unsigned int che contiene i valori dei colori da visualizzare
const uint16_t camColors[] = { ................  };

// Array di float che andrà a memorizzare i valori di 
// intensità IR letti dal sensore AMG (matrice 8x8 = 64 pixel)
float pixels[AMG88xx_PIXEL_ARRAY_SIZE];

// Dimensione orizzontale e verticale di ciascun rettangolo che verrà disegnato
uint16_t displayPixelWidth, displayPixelHeight;

void loop() {
  // lettura della matrice 8x8 dal sensore AMG e salvataggio dei valori nell'array pixels[]
  amg.readPixels(pixels);

  // per ciascun valore letto viene disegnato un rettangolino del colore equivalente
  for(int i=0; i<AMG88xx_PIXEL_ARRAY_SIZE; i++){
	// Estrazione del colore da visualizzare in funzione del valore IR 
	// I colori totali sono 256, quindi viene approssimato con map a quello più vicino
    uint8_t colorIndex = map(pixels[i], MINTEMP, MAXTEMP, 0, 255);
    colorIndex = constrain(colorIndex, 0, 255);

    // Questa istruzione disegna un rettangolo del colore selezionato 
	// spostando di volta in volta la posizione XY in funzione di i
	// In totale saranno 64 rettangoli con dimensione pari a tft.with/8 e tft.height/8 
	// Di solito i display tft da 1.44" sono 128*128 pixel
    tft.fillRect(displayPixelHeight * floor(i / 8), displayPixelWidth * (i % 8),
        displayPixelHeight, displayPixelWidth, camColors[colorIndex]);
  }
  
  // Per disegnare la scala dei colori, dobbiamo scansionare l'array dei colori e 
  // disegnare spostandoci nella direzione voluta. Purtroppo i pixel disponibili 
  // sono meno dei coloti totali (128 pixel vs 256 colori), quindi disegniamo solo una riga
  // mappando i colori in funzione della dimensione del display LCD.
  // Nel caso specifico potremmo disegnare un colore ogni due, ma è meglio scrivere un codice più generico che contempla anche altri casi

  for(int i=0; i<tft.height(); i++){
	// Estrazione del colore da visualizzare in funzione del valore IR 
	// I colori totali sono 256, quindi viene approssimato con map a quello più vicino
    uint8_t colorIndex= map(i, 0, tft.height(), 0, 255);
    colorIndex = constrain(colorIndex, 0, 255);

    // Questa istruzione disegna una piccola riga orizzontale da 3 pixel 
	// spostando di volta in volta la posizione verticale in funzione di i
	// In totale saranno 128 linee contigue che formeranno un rettangolo 
    // da 3*128 pixel con il gradiente di tutti i colori possibili.
    tft.drawLine(0, i, 2, i, camColors[colorIndex]);
  }
  
}

Ciao scusa, non mi ero accorto che avevi risposto.

Ho provato il codice, la barra viene disegnata, però "traballa" non è una barra fissa e quindi non si riesce a leggere.
Forze bisogna ridimensionare la parte che mostra i colori e lasciare quello spazio solo per la barra? Cioè non mettere la barra sopra l'immagine che viene creata?Altrimenti, aggiornandosi l'immagine sotto fa "tremare" anche la barra

Si è plausibile come spiegazione.

Avevo valutato che il secondo for sovrascrive dei pixel già impostati in precedenza, ma pensavo che la cosa non avrebbe avuto effetti visibili.

L'ideale sarebbe disegnarla nel setup() e poi evitare di sovrascrivere quei pixel nel loop().

@faca87 prova cosi e vedi se migliora.

// Array di unsigned int che contiene i valori dei colori da visualizzare
const uint16_t camColors[] = { ................  };

// Array di float che andrà a memorizzare i valori di 
// intensità IR letti dal sensore AMG (matrice 8x8 = 64 pixel)
float pixels[AMG88xx_PIXEL_ARRAY_SIZE];

// Dimensione orizzontale e verticale di ciascun rettangolo che verrà disegnato
uint16_t displayPixelWidth, displayPixelHeight;


void setup () {
  ..........

  // Ciclo che disegna la scala dei colori verticale spostata in setup()
  for(int i=0; i<tft.height(); i++){
    uint8_t colorIndex= map(i, 0, tft.height(), 0, 255);
    colorIndex = constrain(colorIndex, 0, 255);
    tft.drawLine(0, i, 2, i, camColors[colorIndex]);
  }
  
}

void loop() {
  // lettura della matrice 8x8 dal sensore AMG e salvataggio dei valori nell'array pixels[]
  amg.readPixels(pixels);

  // per ciascun valore letto viene disegnato un rettangolino del colore equivalente
  for(int i=0; i<AMG88xx_PIXEL_ARRAY_SIZE; i++){
	// Estrazione del colore da visualizzare in funzione del valore IR 
	// I colori totali sono 256, quindi viene approssimato con map a quello più vicino
    uint8_t colorIndex = map(pixels[i], MINTEMP, MAXTEMP, 0, 255);
    colorIndex = constrain(colorIndex, 0, 255);

    // Questa istruzione disegna un rettangolo del colore selezionato 
	// spostando di volta in volta la posizione XY in funzione di i
	// In totale saranno 64 rettangoli con dimensione pari a tft.with/8 e tft.height/8 
	// Di solito i display tft da 1.44" sono 128*128 pixel

    // Se si tratta della prima colonna, il rettangolo disegnato sarà più piccolo di 3 pixel
    if (floor(i / 8) == 0)
      tft.drawCanvas( 3,  displayPixelWidth * (i % 8),
            displayPixelHeight, displayPixelWidth, camColors[colorIndex]);
    else 
      tft.fillRect(displayPixelHeight * floor(i / 8), displayPixelWidth * (i % 8),
            displayPixelHeight, displayPixelWidth, camColors[colorIndex]);
  }
  
 
}

Ciao, grazie. Ho provato il codice, ma la libreria mi dice che non ha tft.draCanvas

exit status 1
'class Adafruit_ST7735' has no member named 'drawCanvas'; did you mean 'drawChar'?

Colpa mia, avevo usato questo simulatore online per testare il funzionamento che purtroppo supporta solo un'altra libreria per display grafici.

Devi mettere le istruzioni corrette per la libreria che usi come quelle usate nella prima versione che sfarfalla.

Ciao, grazie per l'aiuto!