Vreemd gedrag Adafruit GFX Fonts

setTextColor(uint16_t fgcolor, uint16_t bgcolor, bool bgfill = false)

    tft.setTextColor(ST77XX_RED, ST77XX_BLACK, true );

setTextColor(uint16_t fgcolor, uint16_t bgcolor, bool bgfill = false)

   void setBackgroundFillMethod(BgFillMethod method);

enum class BgFillMethod {
	None,    ///< Does not fill the background.
	Minimum, ///< Fill in the smallest area that surrounds each character.
	Block,   ///< Fill in the smallest area that surrounds the string.
};

   tft.setBackgroundFillMethod(Block);

    tft.setTextColor(ST77XX_RED, ST77XX_BLACK, true );

tft.fillRect(300, 221, 4, 4, ST77XX_WHITE);               // Degree circle <= Dit was het
tft.drawRect(300, 221, 4, 4, ST77XX_WHITE);               // Degree circle <= En dit is het nu, probleem opgelost

// --------------------------------------------------------------------------------
// Place Time values on the screen
// --------------------------------------------------------------------------------
void Print_Time() {

    DateTime time = rtc.now();  
    tft.setFont(&FreeMonoOblique9pt7b);                   // Set specifieke font
    tft.setCursor(227, 208);                              // Positie waar de tijdwaarde op het scherm komt
    tft.setTextSize(1);                                   // Tekst grote is 1
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);         // Zet de voorgrond en de achtergrond kleur van de tijd
    tft.fillRect(228, 198, 88, 12, ST77XX_BLACK);         // Zwarte "wis balk"
    tft.print(time.timestamp(DateTime::TIMESTAMP_TIME));  // Plaatst te tijd op het scherm
    tft.setFont();                                        // Reset naar de standaard GFX font
}

tft.drawCircle(302, 222, 2, ST77XX_WHITE);    // Degree circle

     if (line & 1) {
          if (size_x == 1 && size_y == 1)
            writePixel(x + i, y + j, color);
          else
            writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y,
                          color);
        } else if (bg != color) {
          if (size_x == 1 && size_y == 1)
            writePixel(x + i, y + j, bg);
          else
            writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y, bg);
        }

// --------------------------------------------------------------------------------
// Place Time values on the screen
// --------------------------------------------------------------------------------
static char oldtime[11];

void Print_Time() {

    DateTime time = rtc.now();  
    tft.setFont(&FreeMonoOblique9pt7b);                   // Set specifieke font
    tft.setCursor(227, 208);                              // Positie waar de tijdwaarde op het scherm komt
    tft.setTextSize(1);                                   // Tekst grote is 1
    tft.setTextColor(ST77XX_BLACK, ST77XX_BLACK);         // Zet tekstkleur op achtergrond
    tft.print(oldtime);
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);         // Zet de voorgrond 
    //tft.fillRect(228, 198, 88, 12, ST77XX_BLACK);         // Zwarte "wis balk"
    strcpy(oldtime, time.timestamp(DateTime::TIMESTAMP_TIME);
    tft.print(oldtime);  // Plaatst te tijd op het scherm
    tft.setFont();                                        // Reset naar de standaard GFX font
}

// --------------------------------------------------------------------------------
// Place Time values on the screen
// --------------------------------------------------------------------------------
String oldtime;

void Print_Time() {

    DateTime time = rtc.now();  
    tft.setFont(&FreeMonoOblique9pt7b);                   // Set specifieke font
    tft.setCursor(227, 208);                              // Positie waar de tijdwaarde op het scherm komt
    tft.setTextSize(1);                                   // Tekst grote is 1
    tft.setTextColor(ST77XX_BLACK, ST77XX_BLACK);         // Zet tekstkleur op achtergrond
    tft.print(oldtime);
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);         // Zet de voorgrond 
    //tft.fillRect(228, 198, 88, 12, ST77XX_BLACK);         // Zwarte "wis balk"
    oldtime = time.timestamp(DateTime::TIMESTAMP_TIME);
    tft.print(oldtime);  // Plaatst te tijd op het scherm
    tft.setFont();                                        // Reset naar de standaard GFX font
}

    DateTime time = rtc.now();  
    tft.setFont(&FreeMonoOblique9pt7b);                   // Set specifieke font
    tft.setCursor(227, 208);                              // Positie waar de tijdwaarde op het scherm komt
    tft.setTextSize(1);                                   // Tekst grote is 1
    tft.setTextColor(ST77XX_BLACK, ST77XX_BLACK);         // Zet tekstkleur op achtergrond
    tft.print(oldtime);                                   // Plaatst oude tijd in "zwart" over de aanwezigwe waarde heen
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);         // Zet de voorgrond kleur nieuwe tijd waarde
    oldtime = time.timestamp(DateTime::TIMESTAMP_TIME);   // Volt de "String" oldtime met de nieuwe klok tijd
    tft.setCursor(227, 208);                              // Positie waar de nieuwe tijdwaarde op het scherm moet komen
    tft.print(oldtime);                                   // Plaatst te tijd uit de string op het scherm
    tft.setFont();                                        // Reset naar de standaard GFX font

/**************************************************************************
// Color definitions
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
 **************************************************************************/

#include <Adafruit_GFX.h>                                                               // Core graphics library
#include <Adafruit_ST7789.h>                                                            // Hardware-specific library for ST7789
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <UniversalTimer.h>
#include <Adafruit_ADS1X15.h>
#include <Adafruit_BME280.h>
#include "RTClib.h"
#include <ADC.h>
#include <I2C_Rotary_003.h>

// Extra Font
#include <Fonts/FreeMonoOblique9pt7b.h>
#include <Fonts/FreeSans9pt7b.h>


ADC *adc = new ADC();                                                                 // ADC object for the Teensy ADC

Adafruit_ADS1115 ads;                                                                 // Start ADC                                  
Adafruit_BME280 bme;                                                                  // Start BME Sensor
RTC_DS3231 rtc;                                                                       // Start Real Time Clock

unsigned long delayTime;

// Pin defenition SPI Display
  #define TFT_CS  10
  #define TFT_RST 8 
  #define TFT_DC  7

// For 1.3", 1.54", and 2.0" TFT with ST7789:
  Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);

// Timer Setting for BME280 Sensor value on the display
  UniversalTimer bme_Timer(5000, true);                                               // Every 5 seconds

// Timer Setting for DS3231 Time on the display
  UniversalTimer klok_Time_Timer(1000, true);                                         // Every 0.2 seconds

// Timer Setting for DS3231 Date on the display
  UniversalTimer klok_Date_Timer(60000, true);                                        // Every 60 seconds

// Timer Setting for DS3231 Date on the display
  UniversalTimer Main_oven_Temp_Timer(200, true);                                     // Every 0.2 seconds


// Thermistor properties Vishay NTCLE300E3502SB
#define RT0 5000                                                                      // NTC 25C value
#define B   3977                                                                      // Beta value Vishay NTC
//#define VCC 3,29901                                                                 // External reference voltage
#define VCC 1.247565                                                                  // External reference voltage
#define RA1 2540.000                                                                  // Pull-Up weerstand naar de referentie spanning voor de NTC in Ohm voor de A0 input ADS1115
#define RA2 2539.984                                                                  // Pull-Up weerstand naar de referentie spanning voor de NTC in Ohm voor de A1 input ADS1115
#define T0  (25 + 273.15)                                                             // Temperature T0 from datasheet, conversion from Celsius to kelvin for the NTC Sensor


float AVG_Celcius;


// Temperature progres bar settings
byte X = 10;
byte Y = 60;
byte W = 240;
byte H = 10;
byte progress = 0;

// -------------------------------------------------------------------------
//  Filter Classsetup
// -------------------------------------------------------------------------
class Filter 
{
public:
  int N = 0;                                                                          // Aantal te middelen waarde
  float *meetwaardes;                                                                 // Opslag individuele meetwaarden
  float accumulator = 0;                                                              // Optelsom van alle individuele meetwaarden
  int index = 0;                                                                      // Meetwaarden teller

  Filter(const int n)
  {
    meetwaardes = new float[n];
    N = n;
    for(int i = 0; i < n; i++)
    {  
      meetwaardes[i] = 0;
    }
  }

  ~Filter()
  {
    delete[] meetwaardes;
  }

  void AddSample(float NewSample)
  {  
    accumulator -= meetwaardes[index];        
    meetwaardes[index] = NewSample;                                                   // Bewaar nieuwe meetwaarde
    accumulator += meetwaardes[index];                                                // Accumuleer nieuwste meetwaarde
    index++; 
    index %= N;                                                                       // Teller loopt van 0 tot N-1
  }

  float Average()
  {  
    return accumulator/N;                                                             // Bereken de gemmiddelde waarde
  }
};

// Configuration averaging for the ADC inputs
Filter Filter_Oven(128);
Filter Filter_Ruimte(64);
Filter Filter_Voeding(16);
Filter Filter_Current(16);


String oldtime;


// 'Knuppel-235', 235x235px boot Logo Bitmap

// Hier staat normaal de code voor de BitMap Logo, maar de forum softare staat dit niet toe, te veel karakters :-)

// Declare 3 rotary objects.
// - All use the same I2C address
// - But different switch nrs 
I2C_Rotary Rotary_SW1(0xA0, 1);  // SW1
I2C_Rotary Rotary_SW2(0xA0, 2);  // SW2
I2C_Rotary Rotary_SW3(0xA0, 3);  // SW3

int SW1 = 0;
int SW2 = 0;
int SW3 = 0;



// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void setup(void) {
    
  Serial.begin(115200);
  Serial.println("Hello!");

// -------------------------------------------------------------------------
// Configuration Teensy LC ADC_0
// -------------------------------------------------------------------------
  adc->adc0->setReference(ADC_REFERENCE::REF_EXT);                                    // Selecteer de externe referentie ingang voor ADC_0
  adc->adc0->setAveraging(64);                                                        // Selecteer de middeling van de gebruikte ADC
  adc->adc0->setResolution(16);                                                       // Selecteerd de resolutie van de geselecteerde ADC
  adc->adc0->setConversionSpeed(ADC_CONVERSION_SPEED::HIGH_SPEED_16BITS);             // Selecteerd de conversie snelheid
  adc->adc0->setSamplingSpeed(ADC_SAMPLING_SPEED::LOW_SPEED);                         // Selecteerd de sample snelheid
  adc->adc0->recalibrate();                                                           // Kalibreeer de ADC



// This initializer 240x320 TFT:
  tft.init(240, 320);                                                                     // Init ST7789 240x320
  tft.fillScreen(ST77XX_BLACK);
  tft.setRotation(3);
  tft.setSPISpeed(40000000);

// Displays NoiseAmp Logo on the screen
//  tft.drawBitmap(45, 0, epd_bitmap_Knuppel_235, 235, 235, ST77XX_BLACK, ST77XX_WHITE);
//  delay(500);                                                                           //Keeps the logo 0.5 seconds on the screen before Looping

//
  if (!ads.begin()) {
    Serial.println("Failed to initialize ADS.");
    while (1);
  }
// Setup ADS1115 ADC
  ads.setGain(GAIN_ONE);                                                                // 1x gain   +/- 4.096V  1 bit = 2mV      0.125mV
  ads.startADCReading(ADS1X15_REG_CONFIG_MUX_DIFF_0_1, /*continuous=*/true);            // Start continuous conversions.
  ads.setDataRate(128);                                                                 // Set SampleRate


// Start the BME sensor at the correct i2c address
  bme.begin(0x76, &Wire);

// BME280 Sensor configuratie
  bme.setSampling(Adafruit_BME280::MODE_NORMAL,
                   Adafruit_BME280::SAMPLING_X16,                                       // temperature
                   Adafruit_BME280::SAMPLING_X16,                                       // pressure
                   Adafruit_BME280::SAMPLING_X16,                                       // humidity
                   Adafruit_BME280::FILTER_X16,
                   Adafruit_BME280::STANDBY_MS_250 );

// Srart the DS3231 Clock function 
  rtc.begin();

// Place standard characters and lines on the screen
  Basic_Screen_Setup();

// Put Date and Time for the first time on the screen
  Print_Date();

// Place the BME sensor value on the screen for the first time
  Print_bme();

// Start the timers
  bme_Timer.start();
  klok_Time_Timer.start();
  klok_Date_Timer.start();
  Main_oven_Temp_Timer.start();


// Temporary code for the three rotary encoders
   
// Set parameters for Rotary_SW1
  Rotary_SW1.m_MinValue =   5;
  Rotary_SW1.m_MaxValue = +314;
  Rotary_SW1.m_StepSize =   1;
  Rotary_SW1.m_Value    =   10;
  Rotary_SW1.SetDirection(0);
  Rotary_SW1.SetAccelleration(1);

// Set parameters for Rotary_SW2
  Rotary_SW2.m_MinValue =  0;
  Rotary_SW2.m_MaxValue =  +320;
  Rotary_SW2.m_StepSize =   1;
  Rotary_SW2.m_Value    =  10;
  Rotary_SW2.SetDirection(0);
  Rotary_SW2.SetAccelleration(1);

// Set parameters for Rotary_SW3
  Rotary_SW3.m_MinValue =  0;
  Rotary_SW3.m_MaxValue =  +320;
  Rotary_SW3.m_StepSize =   1;
  Rotary_SW3.m_Value    =  10;
  Rotary_SW3.SetDirection(0);
  Rotary_SW3.SetAccelleration(1);
// End temporary code for the three rotary encoders

}




// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
void loop() {

unsigned long startTime = millis();                                                       // Get the current time at the start of the loop, just some debug code

int16_t adc_TI_0;
float volts0;

// ADC-0 of the ADS1115 is read here asymmetrically in the raw ADC conversion value
  adc_TI_0 = ads.readADC_SingleEnded(0);

// Here, from the ADS1115, the voltage is calculated from the ADC-0 input
  volts0 = ads.computeVolts(adc_TI_0);


// NTC Thermistors Steinhart and Hart Equation
float sample_Filter_Oven = (float)analogRead(A1);           // Here the oven NTC is still read by the Teensy LC ADC for the time being
float VRT = 1.247565 * sample_Filter_Oven / 65536.00; 
float VR = VCC - VRT;
float RT = VRT * RA1 / VR; 
float ln = log(RT / RT0);
float TX = (1 / ((ln / B) + (1 / T0)));                                        
 float Oven_Celcius = TX - 273.15;   

// Samples toevoegen en uitlezen van het middelings filter.
  Filter_Oven.AddSample(Oven_Celcius);
  float avg_Oven_Celcius = Filter_Oven.Average();

tft.setCursor(75, 35);                                    //Tijdelijke tekst Teensy ADC Thermistor Rode tekst op zwarte achtergrond
tft.setTextSize(2);
tft.setTextColor(ST77XX_RED, ST77XX_BLACK);
  tft.print(avg_Oven_Celcius, 4);



// Temporary code for setting various text positions using variable SW1, SW2 and SW3.
unsigned long loopTime = millis() - startTime;            // Calculate the loop time  Debug code
Serial.print("Loop time: ");
Serial.print(loopTime);
Serial.println(" ms");                                    // Print the loop time in milliseconds

int  Clicks2 = Rotary_SW2.Clicks();
int  Clicks3 = Rotary_SW3.Clicks();
int  Clicks1 = Rotary_SW1.Clicks();

SW1 = Rotary_SW1.m_Value;
SW2 = Rotary_SW2.m_Value;
SW3 = Rotary_SW3.m_Value;

Serial.print("SW1- "); Serial.println(SW1);
Serial.print("SW2- "); Serial.println(SW2);
Serial.print("SW3- "); Serial.println(SW3);
// End of temporary code


// Bar meter
tft.fillRect(5, 115, 310, 20, ST77XX_BLACK);                  // Zwarte "wis balk"
tft.drawFastVLine(SW1, 115, 20, ST77XX_RED);                  // Rode vertikale lijn, welke een ingezoomd deel deel van de waarde van de oven sensor aangeeft


// Here the timers are controlled for functions to be executed at a certain time
 if  (bme_Timer.check()) 
    {
      Print_bme();
    }
 if (klok_Time_Timer.check())
     {
      Print_Time();
     }
if (klok_Date_Timer.check())
     {
      Print_Date();
     }
}
// ------------------------ End loop ---------------------------------------




void Main_oven_Temp() {

// Samples toevoegen en uitlezen van het middelings filter.
//   Filter_Oven.AddSample(Oven_Celcius);
//   float avg_Oven_Celcius = Filter_Oven.Average();

// tft.setCursor(75, 35);                                    //Tijdelijke tekst Teensy ADC Thermistor Rode tekst op zwarte achtergrond
// tft.setTextSize(4);
// tft.setTextColor(ST77XX_RED, ST77XX_BLACK);
//   tft.print(avg_Oven_Celcius, 4);
}


void Print_Date() {

// Place Date values on the screen
  DateTime time = rtc.now();
  tft.setFont(&FreeMonoOblique9pt7b);
tft.setCursor(57, 208);
tft.setTextSize(1);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillRect(58, 198, 110, 12, ST77XX_BLACK);               // Black &#8220;erase bar&#8221;
  tft.print(time.timestamp(DateTime::TIMESTAMP_DATE));      // Places time on the display

   
tft.setCursor(3, 208);
tft.setTextSize(1);
tft.setTextColor(ST77XX_GREEN, ST77XX_BLACK);
tft.print("Date:");
tft.setCursor(173, 208);
tft.setTextColor(ST77XX_GREEN, ST77XX_BLACK);
tft.print("Time:");
tft.setFont();                                              // Reset font
}


void Print_Time() {

// Place Time values on the screen
  DateTime time = rtc.now();  
    tft.setFont(&FreeMonoOblique9pt7b);                   // Set specifieke font
    tft.setCursor(227, 208);                              // Positie waar de tijdwaarde op het scherm komt
    tft.setTextSize(1);                                   // Tekst grote is 1
    tft.setTextColor(ST77XX_BLACK, ST77XX_BLACK);         // Zet tekstkleur op achtergrond
    tft.print(oldtime);                                   // Plaatst oude tijd in "zwart" over de aanwezigwe waarde heen
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);         // Zet de voorgrond kleur nieuwe tijd waarde
    oldtime = time.timestamp(DateTime::TIMESTAMP_TIME);   // Volt de "String" oldtime met de nieuwe klok tijd
    tft.setCursor(227, 208);                              // Positie waar de nieuwe tijdwaarde op het scherm moet komen
    tft.print(oldtime);                                   // Plaatst te tijd uit de string op het scherm
    tft.setFont();                                        // Reset naar de standaard GFX font
}

void Print_bme() {

// Places the humidity value from the BME sensor on the display     
  tft.setFont(&FreeMonoOblique9pt7b);    
tft.setCursor(121, 182);
tft.setTextSize(1);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillRect(121, 172, 33, 12, ST77XX_BLACK);               // Black &#8220;erase bar&#8221;
  tft.print(bme.readHumidity(), 0);  

// Places the Pressure value from the BME sensor on the display
tft.setCursor(238, 182);
tft.setTextSize(1);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillRect(237, 172, 78, 12, ST77XX_BLACK);               // Black &#8220;erase bar&#8221;
  tft.print(bme.readPressure()/100);  
        
// Places the Temperature value from the BME sensor on the display
tft.setCursor(238, 232);
tft.setTextSize(1);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.fillRect(239, 222, 56, 12, ST77XX_BLACK);               // Black &#8220;erase bar&#8221;
  tft.print(bme.readTemperature());
tft.setFont();
}


// ----------------------------------------------------------------------------------
// Below is the code for the characters that are always on the screen and only written once.
// ----------------------------------------------------------------------------------
void Basic_Screen_Setup() {
  
  tft.fillScreen(ST77XX_BLACK);                               // Erase the screen to black
tft.drawRect(0, 0, 320, 240, ST77XX_WHITE);                   // Frames and lines for screen layout
tft.drawFastHLine(0, 164, 320, ST77XX_WHITE);                 // Frames and lines for screen layout
tft.drawFastHLine(0, 190, 320, ST77XX_WHITE);                 // Frames and lines for screen layout
tft.drawFastHLine(0, 216, 320, ST77XX_WHITE);                 // Frames and lines for screen layout
tft.drawFastVLine(171, 166, 51, ST77XX_WHITE);                // Vertical line for separation of values at the bottom of the display

tft.fillRect(4, 140, 313, 4, 0x07E0);                         // Thick green line for the meter scale
tft.fillRect(150, 134, 21, 12, 0xFFEA);                       // Yellow block in the middle indicating the +0.01C and the -0.01C oven temperature range.
tft.drawFastVLine(10, 136, 10, 0xFFE0);                       // Vertical Yellow Line for Bar 47.85 C
tft.drawFastVLine(60, 136, 10, 0xFFE0);                       // Vertical Yellow Line for Bar 47.90 C
tft.drawFastVLine(110, 136, 10, 0xFFE0);                      // Vertical Yellow Line for Bar 47.95 C
tft.drawFastVLine(210, 136, 10, 0xFFE0);                      // Vertical Yellow Line for Bar 4.05 C
tft.drawFastVLine(260, 136, 10, 0xFFE0);                      // Vertical Yellow Line for Bar 48.10 C
tft.drawFastVLine(310, 136, 10, 0xFFE0);                      // Vertical Yellow Line for Bar 48.15 C

tft.drawFastVLine(159, 135, 11, 0xF800);                      //
tft.drawFastVLine(160, 135, 11, 0xF800);                      // Vertical RED Line for Bar 48.00C, three in the middle of the yellow bar
tft.drawFastVLine(161, 135, 11, 0xF800);                      //

tft.drawFastHLine(4, 112, 312, ST77XX_GREEN);                 //
tft.drawFastVLine(4, 112, 30, ST77XX_GREEN);                  // Green frame around the red meter pointer
tft.drawFastVLine(316, 112, 30, ST77XX_GREEN);                //

tft.drawFastHLine(4, 92, 312, ST77XX_GREEN);                 //
tft.drawFastVLine(4, 92, 22, ST77XX_GREEN);                  // Green frame around the P.I.D Value
tft.drawFastVLine(316, 92, 22, ST77XX_GREEN);                //

// Characters P, I and D Value's
  tft.setFont(&FreeMonoOblique9pt7b);
tft.setTextSize(1);
tft.setTextColor(0x07E0);
tft.setCursor(7, 106);
tft.print("P:");
tft.setCursor(128, 106);
tft.print("I:");
tft.setCursor(220, 106);
tft.print("D:");
tft.setFont();

// Characters under the meter scale
  tft.setFont(&FreeMonoOblique9pt7b);
tft.setTextSize(1);
tft.setTextColor(0x07E0);
tft.setCursor(35, 159);
tft.print("47.9");
tft.setCursor(148, 159);
tft.print("48");
tft.setCursor(235, 159);
tft.print("48.1");

// Humidity characters BME sensor  
tft.setCursor(3, 182);
tft.setTextSize(1);
tft.setTextColor(ST77XX_GREEN);
tft.print("Humidity:");
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(156, 182);
tft.print("%");

// Preasure characters BME sensor
tft.setCursor(176, 182);
tft.setTextSize(1);
tft.setTextColor(ST77XX_GREEN);
tft.print("hPa: ");
tft.setFont();

// characters ambient temperature
  tft.setFont(&FreeMonoOblique9pt7b);
tft.setCursor(3, 232);
tft.setTextSize(1);
tft.setTextColor(ST77XX_GREEN);
tft.print("LAB Temperature: ");

// Degree caracters BME sensor    
tft.setCursor(1, 111);
tft.setTextSize(1);
tft.drawCircle(302, 222, 2, ST77XX_WHITE);                     // Degree circle
tft.setTextColor(ST77XX_WHITE);    
tft.setCursor(304, 232);
tft.print("C");                                                // "C&#8221; from the degree unit
tft.setFont();

}

void printTFT (float oldValue, int xOld, float value, int x, int y, int color, int bgcolor) {
  if (oldValue != value) {
    tft.setCursor(xOld, y);
    tft.setTextColor(bgcolor, bgcolor);
    tft.print(oldValue);
    tft.setCursor(x, y);
    tft.setTextColor(color, bgcolor);
    tft.print(value);
  }
}

printTFT(oldTemp, 15, newTemp, 15, 100, white, black);
oldTemp = newTemp;
xOld = laatste X waarde;

if (value < 0){
  color = red;
}