First commit.

Author: embedded-kiddie

.gitignore

@@ -1,32 +1,7 @@
-# Prerequisites
-*.d
+# VSCODE
+*/.theia
+*/.vscode
 
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
+# Mac special files
+*/.DS_store
+*/._*

MLX90640.ino

@@ -0,0 +1,209 @@
+/*================================================================================
+ * Thermograpy camera
+ * Copyright (c) 2024 - 2025 embedded-kiddie
+ * Released under the MIT license
+ * https://opensource.org/license/mit
+ *================================================================================*/
+#include <Arduino.h>
+#include "pin_assign.h"
+
+#define DEBUG true
+#if     DEBUG
+#define DBG_EXEC(x) x
+#else
+#define DBG_EXEC(x)
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Step 1: Configure Operational settings
+ *--------------------------------------------------------------------------------*/
+#define ENA_INTERPOLATION   true  // Enable interpolation
+#define ENA_MULTITASKING    true  // Enable multi-task by FreeRTOS
+#define ENA_OUTWARD_CAMERA  false // Camera orientation (true: Outward, false: Selfie)
+
+/*--------------------------------------------------------------------------------
+ * Step 2: Select GFX Library
+ *--------------------------------------------------------------------------------*/
+#if   1
+/*--------------------------------------------------------------------------------
+ * LovyanGFX
+ * Note: Currently 'AUTODETECT' only works for 'ESP32 2432S028R'.
+ * For other boards you need to configure appropriately to fit your device.
+ * See https://github.com/lovyan03/LovyanGFX/blob/master/src/lgfx/boards.hpp
+ *--------------------------------------------------------------------------------*/
+#define USE_LOVYAN_GFX
+#define USE_AUTODETECT  true
+
+#else
+/*--------------------------------------------------------------------------------
+ * TFT_eSPI
+ * It does not allow the display and touch screen to be on different SPI buses.
+ *--------------------------------------------------------------------------------*/
+#define USE_TFT_ESPI
+#ifdef  CYD_TFT_CS
+#error Not yet supported  // CYD needs XPT2046_Touchscreen library
+#endif
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Step 3: Configure flash memory setting to save touch calibration data
+ *--------------------------------------------------------------------------------*/
+#define USE_PREFERENCES true
+
+/*--------------------------------------------------------------------------------
+ * Step 4: Configure MLX90640 settings
+ *--------------------------------------------------------------------------------*/
+#if ENA_INTERPOLATION
+#define INTERPOLATE_SCALE 8
+#define BOX_SIZE          1
+#define REFRESH_RATE      (ENA_MULTITASKING ? MLX90640_32_HZ : MLX90640_16_HZ)
+#else
+#define INTERPOLATE_SCALE 1
+#define BOX_SIZE          8
+#define REFRESH_RATE      (ENA_MULTITASKING ? MLX90640_32_HZ : MLX90640_16_HZ)
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Heat map
+ *--------------------------------------------------------------------------------*/
+#define N_HEATMAP   512 // 256 or 512 --> heatmap.h
+constexpr uint16_t heatmap[2][N_HEATMAP] = {
+#include "heatmap.h"    // 0; Rainbow, 1: Inferno
+};
+
+/*--------------------------------------------------------------------------------
+ * Load modules
+ *--------------------------------------------------------------------------------*/
+#include "mlx.hpp"
+#include "gfx.hpp"
+#include "task.hpp"
+#include "touch.hpp"
+#include "sdcard.hpp"
+#include "filter.hpp"
+#include "interpolation.hpp"
+#include "widget.hpp"
+
+/*--------------------------------------------------------------------------------
+ * Input process - Get thermal image from MLX90640
+ *--------------------------------------------------------------------------------*/
+void ProcessInput(uint8_t bank) {
+  // Refresh MLX90640 when refresh rate changes
+  bool refresh = mlx_refresh();
+
+  // Get new image
+  if (mlx.getFrame(src[bank]) != 0) {
+    gfx_printf(TFT_WIDTH / 2 - FONT_WIDTH * 2, TFT_HEIGHT / 2 - FONT_HEIGHT * 4, "Failed");
+    DBG_EXEC(printf("Failed\n"));
+    delay(1000); // false = no new frame capture
+  }
+
+  if (refresh) {
+    // Avoid cluttered image
+    for (int i = 0; i < MLX90640_COLS * MLX90640_ROWS; ++i) {
+      src[bank][i] = (float)mlx_cnf.range_min;
+    }
+  } else {
+    // Measure temperature of min/max/pickup
+    filter_temperature(src[bank]);
+  }
+}
+
+/*--------------------------------------------------------------------------------
+ * Output process - Interpolate thermal image and display on LCD.
+ *--------------------------------------------------------------------------------*/
+void ProcessOutput(uint8_t bank, uint32_t inputStart, uint32_t inputFinish) {
+  // Widget controller
+  State_t state = widget_control();
+  if (bank != NOT_UPDATED && (state == STATE_MAIN || state == STATE_THERMOGRAPH)) {
+    static uint32_t outputFinish, outputPeriod, prevStart;
+    uint32_t outputStart = millis();
+
+    const int dst_rows = mlx_cnf.interpolation * MLX90640_ROWS;
+    const int dst_cols = mlx_cnf.interpolation * MLX90640_COLS;
+    const int box_size = mlx_cnf.box_size;
+
+    GFX_EXEC(startWrite());
+    GFX_FAST(createSprite(dst_cols * box_size, dst_rows * box_size));
+
+    interpolate_image(src[bank], MLX90640_ROWS, MLX90640_COLS, dst_rows, dst_cols);
+
+    if (mlx_cnf.marker_mode) {
+      static uint32_t prevUpdate;
+      if (outputStart - prevUpdate > 1000) {
+        prevUpdate = outputStart;
+        filter_update();
+      }
+      DrawTemperatureMarker();
+    }
+
+    if (mlx_cnf.range_auto) {
+      DrawTemperatureRange(2);
+    }
+
+    if (state == STATE_MAIN) {
+      gfx_printf(260 + FONT_WIDTH, LINE_HEIGHT * 3.5, "%4d", inputFinish - inputStart); // input processing time
+      gfx_printf(260 + FONT_WIDTH, LINE_HEIGHT * 5.0, "%4d", outputPeriod); // output processing time
+
+      float v = 1000.0f / (float)(outputStart - prevStart);
+      gfx_printf(260 + FONT_WIDTH, LINE_HEIGHT * 2.0, "%4.1f", v); // FPS
+
+      v = mlx.getTa(false);
+      if (0.0f < v && v < 100.0f) {
+        gfx_printf(260 + FONT_WIDTH, LINE_HEIGHT * 6.5, "%4.1f", v); // Sensor temperature
+      }
+    }
+
+    GFX_FAST(pushSprite(0, 0));
+    GFX_FAST(deleteSprite());
+    GFX_EXEC(endWrite());
+
+    // Save video
+    if (mlx_cap.recording) {
+      sdcard_record((uint8_t*)src[bank], sizeof(src[bank]), mlx_cap.filename);
+    }
+
+#if DEBUG
+  // Capture screen
+  else if (Serial.available()) {
+    Serial.readStringUntil('\n');
+    sdcard_save();
+  }
+#endif
+
+    // Update processing time
+    prevStart = outputStart;
+    outputFinish = millis();
+    outputPeriod = outputFinish - outputStart;
+  }
+}
+
+void setup() {
+  // Prevent blocking when the USB cable is not connected to PC
+  DBG_EXEC(Serial.begin(115200));
+  DBG_EXEC(delay(500));
+
+  // Initialize peripherals
+  mlx_setup();
+  gfx_setup();
+  sdcard_setup();
+  touch_setup();
+  widget_setup();
+
+  // Initialize interpolation
+  interpolate_setup(mlx_cnf.interpolation);
+
+  // Start tasks
+#if ENA_MULTITASKING
+  task_setup(ProcessInput, ProcessOutput);
+#endif
+}
+
+void loop() {
+#if ENA_MULTITASKING
+  delay(1000);
+#else
+  uint32_t inputStart = millis();
+  ProcessInput(0); // always use bank 0
+  ProcessOutput(0, inputStart, millis());
+#endif
+}

User_Setup.h

@@ -0,0 +1,17 @@
+/*================================================================================
+ * TFT_eSPI configuration
+ * https://github.com/espressif/arduino-esp32/tree/master/variants
+ *================================================================================*/
+#include "./pin_assign.h"
+
+// variants/jczn_2432s028r/pins_arduino.h
+#if defined (CYD_TP_CS)
+// false: Panel driver: ILI9341 (micro-USB x 1 type)
+// true : Panel driver: ST7789  (micro-USB x 1 + USB-C x 1 type)
+#define DISPLAY_CYD_2USB  true
+#include "./boards/Setup_CYD_2432S028R.h"
+
+// variants/XIAO_ESP32S3/pins_arduino.h
+#elif defined (ARDUINO_XIAO_ESP32S3)
+#include "./boards/Setup_XIAO_ESP32S3_ST7789.h"
+#endif

boards/LGFX_CYD_2432S028R.hpp

@@ -0,0 +1,234 @@
+#pragma once
+
+#include <LovyanGFX.hpp>
+
+// Example of settings for LovyanGFX on ESP32
+// https://github.com/espressif/arduino-esp32/blob/master/variants/jczn_2432s028r/pins_arduino.h
+
+/*
+Copy this file, give it a new name, and change the settings to suit your environment.
+The created file can be used by including it in your user program.
+
+The new file can also be placed in the "lgfx_user" folder of the library,
+but please note that in this case it may be deleted when the library is updated.
+
+To operate safely, make a backup or place it in the user project folder.
+//*/
+
+// false: Panel driver: ILI9341 (micro-USB x 1 type)
+// true : Panel driver: ST7789  (micro-USB x 1 + USB-C x 1 type)
+#ifndef DISPLAY_CYD_2USB
+#error DISPLAY_CYD_2USB should be defined.
+#endif
+
+/// Create a class for your own settings by deriving from LGFX_Device.
+class LGFX : public lgfx::LGFX_Device
+{
+/*
+You can change the class name from "LGFX" to a different name.
+When using with AUTODETECT, "LGFX" is used, so change it to a name other than LGFX.
+Also, if you are using multiple panels at the same time, give each panel a different name.
+If you change the class name, you must also change the constructor name to the same name.
+
+You can name it whatever you like, but in case the number of settings increases,
+for example, if you are setting up an SPI-connected ILI9341 with ESP32 DevKit-C, 
+you can name it like LGFX_DevKitC_SPI_ILI9341 to match the file name and class name, 
+which will make it less confusing when using it.
+//*/
+
+// Select an instance that matches the type of panel.
+//lgfx::Panel_GC9A01      _panel_instance;
+//lgfx::Panel_GDEW0154M09 _panel_instance;
+//lgfx::Panel_HX8357B     _panel_instance;
+//lgfx::Panel_HX8357D     _panel_instance;
+//lgfx::Panel_ILI9163     _panel_instance;
+//lgfx::Panel_ILI9341     _panel_instance;
+//lgfx::Panel_ILI9342     _panel_instance;
+//lgfx::Panel_ILI9481     _panel_instance;
+//lgfx::Panel_ILI9486     _panel_instance;
+//lgfx::Panel_ILI9488     _panel_instance;
+//lgfx::Panel_IT8951      _panel_instance;
+//lgfx::Panel_RA8875      _panel_instance;
+//lgfx::Panel_SH110x      _panel_instance; // SH1106, SH1107
+//lgfx::Panel_SSD1306     _panel_instance;
+//lgfx::Panel_SSD1327     _panel_instance;
+//lgfx::Panel_SSD1331     _panel_instance;
+//lgfx::Panel_SSD1351     _panel_instance; // SSD1351, SSD1357
+//lgfx::Panel_SSD1963     _panel_instance;
+//lgfx::Panel_ST7735      _panel_instance;
+//lgfx::Panel_ST7735S     _panel_instance;
+//lgfx::Panel_ST7789      _panel_instance;
+//lgfx::Panel_ST7796      _panel_instance;
+
+#if DISPLAY_CYD_2USB
+  lgfx::Panel_ST7789      _panel_instance;
+#else
+  lgfx::Panel_ILI9341     _panel_instance;
+#endif
+
+// Select an instance that matches the type of bus for your panel.
+  lgfx::Bus_SPI       _bus_instance;   // SPI bus instance
+//lgfx::Bus_I2C       _bus_instance;   // I2C bus instance (ESP32 only)
+//lgfx::Bus_Parallel8 _bus_instance;   // 8-bit parallel bus instance (ESP32 only)
+
+// If backlight control is possible, set an instance. (Delete if not needed)
+  lgfx::Light_PWM     _light_instance;
+
+// Select an instance that matches the touch screen type. (Delete if not needed)
+//lgfx::Touch_CST816S          _touch_instance;
+//lgfx::Touch_FT5x06           _touch_instance; // FT5206, FT5306, FT5406, FT6206, FT6236, FT6336, FT6436
+//lgfx::Touch_GSL1680E_800x480 _touch_instance; // GSL_1680E, 1688E, 2681B, 2682B
+//lgfx::Touch_GSL1680F_800x480 _touch_instance;
+//lgfx::Touch_GSL1680F_480x272 _touch_instance;
+//lgfx::Touch_GSLx680_320x320  _touch_instance;
+//lgfx::Touch_GT911            _touch_instance;
+//lgfx::Touch_STMPE610         _touch_instance;
+//lgfx::Touch_TT21xxx          _touch_instance; // TT21100
+  lgfx::Touch_XPT2046          _touch_instance;
+
+public:
+
+  // Create a constructor and set various settings here.
+  // When you change the class name, specify the same name for the constructor.
+  LGFX(void)
+  {
+    { //Sets the bus control.
+      auto cfg = _bus_instance.config();    // Get the bus configuration structure.
+
+// SPI bus settings
+      cfg.spi_host = HSPI_HOST;     // Select the SPI (ESP32-S2,C3: SPI2_HOST or SPI3_HOST / ESP32: VSPI_HOST or HSPI_HOST)
+      // Due to the ESP-IDF version upgrade, the VSPI_HOST and HSPI_HOST are deprecated, so if an error occurs, use SPI2_HOST and SPI3_HOST instead.
+      cfg.spi_mode = 0;             // SPI communication mode (0 to 3)
+#if DISPLAY_CYD_2USB
+      cfg.freq_write = 80000000;    // SPI clock for transmit (Maximum 80MHz, rounded to an integer value of 80MHz)
+#else
+      cfg.freq_write = 40000000;    // SPI clock for transmit (Maximum 80MHz, rounded to an integer value of 80MHz)
+#endif
+      cfg.freq_read  = 16000000;    // SPI clock for receive
+      cfg.spi_3wire  = false;       // Set to true if receive on the MOSI pin
+      cfg.use_lock   = true;        // Set to true if transaction lock is used
+      cfg.dma_channel = SPI_DMA_CH_AUTO; // Set the DMA channel (0=DMA not used / 1=1ch / 2=2ch / SPI_DMA_CH_AUTO=automatic)
+      // Due to the ESP-IDF version upgrade, SPI_DMA_CH_AUTO is recommended. Specifying 1ch or 2ch is no longer recommended.
+      cfg.pin_sclk = CYD_TFT_SCK;   // Set the SPI SCLK pin
+      cfg.pin_mosi = CYD_TFT_MOSI;  // Set the SPI MOSI pin
+      cfg.pin_miso = CYD_TFT_MISO;  // Set the SPI MISO pin (-1 = disable)
+      cfg.pin_dc   = CYD_TFT_DC;    // Set the SPI D/C  pin (-1 = disable)
+     // When you use a common SPI bus with the SD card, be sure to set MISO and do not omit it.
+//*/
+/*
+// I2C bus settings
+      cfg.i2c_port    = 0;          // Select the I2C port to use (0 or 1)
+      cfg.freq_write  = 400000;     // Clock for transmit
+      cfg.freq_read   = 400000;     // Clock for receive
+      cfg.pin_sda     = 21;         // SDA pin number
+      cfg.pin_scl     = 22;         // SCL pin number
+      cfg.i2c_addr    = 0x3C;       // I2C device address
+//*/
+/*
+// 8-bit parallel bus settings
+      cfg.i2s_port = I2S_NUM_0;     // Select the I2S port to use (I2S_NUM_0 or I2S_NUM_1) (Use the I2S LCD mode of ESP32)
+      cfg.freq_write = 20000000;    // Clock for transmit (Maximum 20MHz, rounded to an integer division of 80MHz)
+      cfg.pin_wr =  4;              // WR pin number
+      cfg.pin_rd =  2;              // RD pin number
+      cfg.pin_rs = 15;              // RS(D/C) pin number
+      cfg.pin_d0 = 12;              // D0 pin number
+      cfg.pin_d1 = 13;              // D1 pin number
+      cfg.pin_d2 = 26;              // D2 pin number
+      cfg.pin_d3 = 25;              // D3 pin number
+      cfg.pin_d4 = 17;              // D4 pin number
+      cfg.pin_d5 = 16;              // D5 pin number
+      cfg.pin_d6 = 27;              // D6 pin number
+      cfg.pin_d7 = 14;              // D7 pin number
+//*/
+
+      _bus_instance.config(cfg);    // Configure setting values in the bus.
+      _panel_instance.setBus(&_bus_instance); // Set the bus on the panel.
+    }
+
+    { // Configure the display panel control settings.
+      auto cfg = _panel_instance.config();    // Get the structure for display panel settings.
+
+      cfg.pin_cs           = CYD_TFT_CS;  // CS   pin number (-1 = disable)
+      cfg.pin_rst          = -1;          // RST  pin number (-1 = disable) CYD_TFT_RS = CYD_TFT_CS, RESET is connected to board RST
+      cfg.pin_busy         = -1;          // BUSY pin number (-1 = disable)
+
+      // The following are set to general values, so try commenting out if you are unsure of.
+
+      cfg.panel_width      =   240;  // Panel width
+      cfg.panel_height     =   320;  // Panel height
+      cfg.offset_x         =     0;  // Panel offset in X direction
+      cfg.offset_y         =     0;  // Panel offset in Y direction
+#if DISPLAY_CYD_2USB
+      cfg.offset_rotation  =     0;  // Rotation direction offset 0~7 (4~7 are upside down)
+      cfg.dummy_read_pixel =    16;  // Number of dummy read bits before pixel read
+#else
+      cfg.offset_rotation  =     2;  // Rotation direction offset 0~7 (4~7 are upside down)
+      cfg.dummy_read_pixel =     8;  // Number of dummy read bits before pixel read
+#endif
+      cfg.dummy_read_bits  =     1;  // Number of dummy read bits before reading non-pixel data
+      cfg.readable         =  true;  // Set to true if data can be read
+      cfg.invert           = false;  // Set to true if the panel is inverted
+      cfg.rgb_order        = false;  // Set to true if the red and blue of the panel are swapped
+      cfg.dlen_16bit       = false;  // Set to true if the panel transmit data in 16-bit via 16-bit parallel or SPI
+      cfg.bus_shared       = false;  // Set to true if the bus is shared with the SD card (The bus is controlled for drawJpg etc.)
+
+// Set the following only if your display is misaligned, such as ST7735 or ILI9163, which have variable pixel counts.
+      cfg.memory_width     =   240;  // Maximum width  supported by driver IC
+      cfg.memory_height    =   320;  // Maximum height supported by driver IC
+
+      _panel_instance.config(cfg);
+    }
+
+//*
+    { // Set the backlight control. (Delete if not required)
+      auto cfg = _light_instance.config();    // Get the backlight setting structure
+
+      cfg.pin_bl = CYD_TFT_BL;      // Backlight pin number
+      cfg.invert = false;           // Set to true if the backlight brightness is inverted
+      cfg.freq   = 12000;           // Backlight PWM frequency
+      cfg.pwm_channel = 7;          // The PWM channel number
+
+      _light_instance.config(cfg);
+      _panel_instance.setLight(&_light_instance);  // Set the backlight on the panel.
+    }
+//*/
+
+//
+    { // Configure touch screen control (delete if not needed)
+      auto cfg = _touch_instance.config();
+
+      cfg.x_min =  240;         // Minimum X value (raw value) from touch screen
+      cfg.x_max = 3800;         // Maximum X value (raw value) from touch screen
+      cfg.y_min = 3700;         // Minimum Y value (raw value) from touch screen
+      cfg.y_max =  200;         // Maximum Y value (raw value) from touch screen
+      cfg.pin_int = CYD_TP_IRQ; // Interrupt pin number
+      cfg.bus_shared = false;   // Set to true if the bus shared with the screen
+#if DISPLAY_CYD_2USB
+      cfg.offset_rotation = 2;  // Adjust when display and touch orientation do not match (0~7)
+#else
+      cfg.offset_rotation = 0;  // Adjust when display and touch orientation do not match (0~7)
+#endif
+
+// For SPI connection
+      cfg.spi_host = -1;            // Select the SPI (HSPI_HOST or VSPI_HOST) or only XPT2046 can be set to -1.
+      cfg.freq = 1000000;           // Set the SPI clock
+      cfg.pin_sclk = CYD_TP_CLK;    // SCLK pin number
+      cfg.pin_mosi = CYD_TP_MOSI;   // MOSI pin number
+      cfg.pin_miso = CYD_TP_MISO;   // MISO pin number
+      cfg.pin_cs   = CYD_TP_CS;     // CS   pin number
+
+// For I2C connection
+      //cfg.i2c_port = 1;      // Select the I2C (0 or 1)
+      //cfg.i2c_addr = 0x38;   // I2C device addres
+      //cfg.pin_sda  = 23;     // SDA pin number
+      //cfg.pin_scl  = 32;     // SCL pin number
+      //cfg.freq = 400000;     // Set the I2C clock
+
+      _touch_instance.config(cfg);
+      _panel_instance.setTouch(&_touch_instance);  // Set the touch screen on the panel.
+    }
+//*/
+
+    setPanel(&_panel_instance); // Set the panel to be used.
+  }
+};

boards/LGFX_XIAO_ESP32S3_ST7789.hpp

@@ -0,0 +1,217 @@
+#pragma once
+
+#define LGFX_USE_V1
+#include <LovyanGFX.hpp>
+
+// Configuration to share the SPI bus host with SD
+// https://github.com/espressif/esp-idf/blob/master/components/esp_driver_sdspi/include/driver/sdspi_host.h#L23-L29
+#include <driver/sdspi_host.h>
+#define SPI_HOST  SDSPI_DEFAULT_HOST
+
+// ESP32でLovyanGFXを独自設定で利用する場合の設定例
+
+/*
+このファイルを複製し、新しい名前を付けて、環境に合わせて設定内容を変更してください。
+作成したファイルをユーザープログラムからincludeすることで利用可能になります。
+
+複製したファイルはライブラリのlgfx_userフォルダに置いて利用しても構いませんが、
+その場合はライブラリのアップデート時に削除される可能性があるのでご注意ください。
+
+安全に運用したい場合はバックアップを作成しておくか、ユーザープロジェクトのフォルダに置いてください。
+//*/
+
+
+/// 独自の設定を行うクラスを、LGFX_Deviceから派生して作成します。
+class LGFX : public lgfx::LGFX_Device
+{
+/*
+ クラス名は"LGFX"から別の名前に変更しても構いません。
+ AUTODETECTと併用する場合は"LGFX"は使用されているため、LGFX以外の名前に変更してください。
+ また、複数枚のパネルを同時使用する場合もそれぞれに異なる名前を付けてください。
+ ※ クラス名を変更する場合はコンストラクタの名前も併せて同じ名前に変更が必要です。
+
+ 名前の付け方は自由に決めて構いませんが、設定が増えた場合を想定し、
+ 例えばESP32 DevKit-CでSPI接続のILI9341の設定を行った場合、
+  LGFX_DevKitC_SPI_ILI9341
+ のような名前にし、ファイル名とクラス名を一致させておくことで、利用時に迷いにくくなります。
+//*/
+
+
+// 接続するパネルの型にあったインスタンスを用意します。
+//lgfx::Panel_GC9A01      _panel_instance;
+//lgfx::Panel_GDEW0154M09 _panel_instance;
+//lgfx::Panel_HX8357B     _panel_instance;
+//lgfx::Panel_HX8357D     _panel_instance;
+//lgfx::Panel_ILI9163     _panel_instance;
+//lgfx::Panel_ILI9341     _panel_instance;
+//lgfx::Panel_ILI9342     _panel_instance;
+//lgfx::Panel_ILI9481     _panel_instance;
+//lgfx::Panel_ILI9486     _panel_instance;
+//lgfx::Panel_ILI9488     _panel_instance;
+//lgfx::Panel_IT8951      _panel_instance;
+//lgfx::Panel_RA8875      _panel_instance;
+//lgfx::Panel_SH110x      _panel_instance; // SH1106, SH1107
+//lgfx::Panel_SSD1306     _panel_instance;
+//lgfx::Panel_SSD1327     _panel_instance;
+//lgfx::Panel_SSD1331     _panel_instance;
+//lgfx::Panel_SSD1351     _panel_instance; // SSD1351, SSD1357
+//lgfx::Panel_SSD1963     _panel_instance;
+//lgfx::Panel_ST7735      _panel_instance;
+//lgfx::Panel_ST7735S     _panel_instance;
+  lgfx::Panel_ST7789      _panel_instance;
+//lgfx::Panel_ST7796      _panel_instance;
+
+
+// パネルを接続するバスの種類にあったインスタンスを用意します。
+  lgfx::Bus_SPI       _bus_instance;   // SPIバスのインスタンス
+//lgfx::Bus_I2C       _bus_instance;   // I2Cバスのインスタンス (ESP32のみ)
+//lgfx::Bus_Parallel8 _bus_instance;   // 8ビットパラレルバスのインスタンス (ESP32のみ)
+
+// バックライト制御が可能な場合はインスタンスを用意します。(必要なければ削除)
+//lgfx::Light_PWM     _light_instance;
+
+// タッチスクリーンの型にあったインスタンスを用意します。(必要なければ削除)
+//lgfx::Touch_CST816S          _touch_instance;
+//lgfx::Touch_FT5x06           _touch_instance; // FT5206, FT5306, FT5406, FT6206, FT6236, FT6336, FT6436
+//lgfx::Touch_GSL1680E_800x480 _touch_instance; // GSL_1680E, 1688E, 2681B, 2682B
+//lgfx::Touch_GSL1680F_800x480 _touch_instance;
+//lgfx::Touch_GSL1680F_480x272 _touch_instance;
+//lgfx::Touch_GSLx680_320x320  _touch_instance;
+//lgfx::Touch_GT911            _touch_instance;
+//lgfx::Touch_STMPE610         _touch_instance;
+//lgfx::Touch_TT21xxx          _touch_instance; // TT21100
+  lgfx::Touch_XPT2046          _touch_instance;
+
+public:
+
+  // コンストラクタを作成し、ここで各種設定を行います。
+  // クラス名を変更した場合はコンストラクタも同じ名前を指定してください。
+  LGFX(void)
+  {
+    { // バス制御の設定を行います。
+      auto cfg = _bus_instance.config();  // バス設定用の構造体を取得します。
+
+// SPIバスの設定
+      cfg.spi_host = SPI_HOST;            // 使用するSPIを選択  ESP32-S2,C3 : SPI2_HOST or SPI3_HOST / ESP32 : VSPI_HOST or HSPI_HOST
+      // ※ ESP-IDFバージョンアップに伴い、VSPI_HOST , HSPI_HOSTの記述は非推奨になるため、エラーが出る場合は代わりにSPI2_HOST , SPI3_HOSTを使用してください。
+      cfg.spi_mode = SPI_MODE;            // SPI通信モードを設定 (0 ~ 3)
+      cfg.freq_write = SPI_FREQUENCY;     // 送信時のSPIクロック (最大80MHz, 80MHzを整数で割った値に丸められます)
+      cfg.freq_read  = SPI_READ_FREQUENCY;// 受信時のSPIクロック
+      cfg.spi_3wire  = false;             // 受信をMOSIピンで行う場合はtrueを設定
+      cfg.use_lock   = true;              // トランザクションロックを使用する場合はtrueを設定
+      cfg.dma_channel = SPI_DMA_CH_AUTO;  // 使用するDMAチャンネルを設定 (0=DMA不使用 / 1=1ch / 2=ch / SPI_DMA_CH_AUTO=自動設定)
+      // ※ ESP-IDFバージョンアップに伴い、DMAチャンネルはSPI_DMA_CH_AUTO(自動設定)が推奨になりました。1ch,2chの指定は非推奨になります。
+      cfg.pin_sclk = TFT_SCLK;            // SPIのSCLKピン番号を設定
+      cfg.pin_mosi = TFT_MOSI;            // SPIのMOSIピン番号を設定
+      cfg.pin_miso = TFT_MISO;            // SPIのMISOピン番号を設定 (-1 = disable)
+      cfg.pin_dc   = TFT_DC;              // SPIのD/Cピン番号を設定  (-1 = disable)
+     // SDカードと共通のSPIバスを使う場合、MISOは省略せず必ず設定してください。
+//*/
+/*
+// I2Cバスの設定
+      cfg.i2c_port    = 0;          // 使用するI2Cポートを選択 (0 or 1)
+      cfg.freq_write  = 400000;     // 送信時のクロック
+      cfg.freq_read   = 400000;     // 受信時のクロック
+      cfg.pin_sda     = 21;         // SDAを接続しているピン番号
+      cfg.pin_scl     = 22;         // SCLを接続しているピン番号
+      cfg.i2c_addr    = 0x3C;       // I2Cデバイスのアドレス
+//*/
+/*
+// 8ビットパラレルバスの設定
+      cfg.i2s_port = I2S_NUM_0;     // 使用するI2Sポートを選択 (I2S_NUM_0 or I2S_NUM_1) (ESP32のI2S LCDモードを使用します)
+      cfg.freq_write = 20000000;    // 送信クロック (最大20MHz, 80MHzを整数で割った値に丸められます)
+      cfg.pin_wr =  4;              // WR を接続しているピン番号
+      cfg.pin_rd =  2;              // RD を接続しているピン番号
+      cfg.pin_rs = 15;              // RS(D/C)を接続しているピン番号
+      cfg.pin_d0 = 12;              // D0を接続しているピン番号
+      cfg.pin_d1 = 13;              // D1を接続しているピン番号
+      cfg.pin_d2 = 26;              // D2を接続しているピン番号
+      cfg.pin_d3 = 25;              // D3を接続しているピン番号
+      cfg.pin_d4 = 17;              // D4を接続しているピン番号
+      cfg.pin_d5 = 16;              // D5を接続しているピン番号
+      cfg.pin_d6 = 27;              // D6を接続しているピン番号
+      cfg.pin_d7 = 14;              // D7を接続しているピン番号
+//*/
+
+      _bus_instance.config(cfg);    // 設定値をバスに反映します。
+      _panel_instance.setBus(&_bus_instance);      // バスをパネルにセットします。
+    }
+
+    { // 表示パネル制御の設定を行います。
+      auto cfg = _panel_instance.config();    // 表示パネル設定用の構造体を取得します。
+
+      cfg.pin_cs           = TFT_CS;  // CSが接続されているピン番号   (-1 = disable)
+      cfg.pin_rst          = TFT_RST; // RSTが接続されているピン番号  (-1 = disable)
+      cfg.pin_busy         = -1;      // BUSYが接続されているピン番号 (-1 = disable)
+
+      // ※ 以下の設定値はパネル毎に一般的な初期値が設定されていますので、不明な項目はコメントアウトして試してみてください。
+
+      cfg.panel_width      = TFT_WIDTH;   // 実際に表示可能な幅
+      cfg.panel_height     = TFT_HEIGHT;  // 実際に表示可能な高さ
+      cfg.offset_x         =     0;  // パネルのX方向オフセット量
+      cfg.offset_y         =     0;  // パネルのY方向オフセット量
+      cfg.offset_rotation  =     0;  // 回転方向の値のオフセット 0~7 (4~7は上下反転)
+      cfg.dummy_read_pixel =     8;  // ピクセル読出し前のダミーリードのビット数
+      cfg.dummy_read_bits  =     1;  // ピクセル以外のデータ読出し前のダミーリードのビット数
+      cfg.readable         =  true;  // データ読出しが可能な場合 trueに設定
+      cfg.invert           = false;  // パネルの明暗が反転してしまう場合 trueに設定
+      cfg.rgb_order        = false;  // パネルの赤と青が入れ替わってしまう場合 trueに設定
+      cfg.dlen_16bit       = false;  // 16bitパラレルやSPIでデータ長を16bit単位で送信するパネルの場合 trueに設定
+      cfg.bus_shared       =  true;  // SDカードとバスを共有している場合 trueに設定(drawJpgFile等でバス制御を行います)
+
+// 以下はST7735やILI9163のようにピクセル数が可変のドライバで表示がずれる場合にのみ設定してください。
+//    cfg.memory_width     =   240;  // ドライバICがサポートしている最大の幅
+//    cfg.memory_height    =   320;  // ドライバICがサポートしている最大の高さ
+
+      _panel_instance.config(cfg);
+    }
+
+/*
+    { // バックライト制御の設定を行います。（必要なければ削除）
+      auto cfg = _light_instance.config();    // バックライト設定用の構造体を取得します。
+
+      cfg.pin_bl = 32;              // バックライトが接続されているピン番号
+      cfg.invert = false;           // バックライトの輝度を反転させる場合 true
+      cfg.freq   = 44100;           // バックライトのPWM周波数
+      cfg.pwm_channel = 7;          // 使用するPWMのチャンネル番号
+
+      _light_instance.config(cfg);
+      _panel_instance.setLight(&_light_instance);  // バックライトをパネルにセットします。
+    }
+*/
+
+//*
+    { // タッチスクリーン制御の設定を行います。（必要なければ削除）
+      auto cfg = _touch_instance.config();
+
+      cfg.x_min      =  240;      // タッチスクリーンから得られる最小のX値(生の値)
+      cfg.x_max      = 3800;      // タッチスクリーンから得られる最大のX値(生の値)
+      cfg.y_min      = 3700;      // タッチスクリーンから得られる最小のY値(生の値)
+      cfg.y_max      =  200;      // タッチスクリーンから得られる最大のY値(生の値)
+      cfg.pin_int    = TOUCH_IRQ; // INTが接続されているピン番号
+      cfg.bus_shared = true;      // 画面と共通のバスを使用している場合 trueを設定
+      cfg.offset_rotation = 0;    // 表示とタッチの向きのが一致しない場合の調整 0~7の値で設定
+
+// SPI接続の場合
+      cfg.spi_host = SPI_HOST;        // 使用するSPIを選択 (HSPI_HOST or VSPI_HOST)
+      cfg.freq = SPI_TOUCH_FREQUENCY; // SPIクロックを設定
+      cfg.pin_sclk = TFT_SCLK;        // SCLKが接続されているピン番号
+      cfg.pin_mosi = TFT_MOSI;        // MOSIが接続されているピン番号
+      cfg.pin_miso = TFT_MISO;        // MISOが接続されているピン番号
+      cfg.pin_cs   = TOUCH_CS;        //   CSが接続されているピン番号
+
+// I2C接続の場合
+//    cfg.i2c_port = 1;      // 使用するI2Cを選択 (0 or 1)
+//    cfg.i2c_addr = 0x38;   // I2Cデバイスアドレス番号
+//    cfg.pin_sda  = 23;     // SDAが接続されているピン番号
+//    cfg.pin_scl  = 32;     // SCLが接続されているピン番号
+//    cfg.freq = 400000;     // I2Cクロックを設定
+
+      _touch_instance.config(cfg);
+      _panel_instance.setTouch(&_touch_instance);  // タッチスクリーンをパネルにセットします。
+    }
+//*/
+
+    setPanel(&_panel_instance); // 使用するパネルをセットします。
+  }
+};

boards/Setup_CYD_2432S028R.h

@@ -0,0 +1,79 @@
+/*================================================================================
+ * Multitasking helper functions
+ *================================================================================*/
+#define TIME_CONSTANT   3.0f // [sec]
+
+/*--------------------------------------------------------------------------------
+ * Low pass filter (x: input, T: sampling time [sec])
+ *--------------------------------------------------------------------------------*/
+typedef struct {
+  float y;
+  float filter(float x, const float T) {
+    return (y += (T / (T + TIME_CONSTANT) * (x - y)));
+  }
+} LowPass_t;
+
+static LowPass_t lp_min, lp_max, lp_pick;
+
+/*--------------------------------------------------------------------------------
+ * Set the initial value for the low-pass filter
+ *--------------------------------------------------------------------------------*/
+void filter_reset(void) {
+  lp_min.y  = MINTEMP;
+  lp_max.y  = MAXTEMP;
+  lp_pick.y = (MINTEMP + MAXTEMP) / 2;
+}
+
+/*--------------------------------------------------------------------------------
+ * Measure temperature and update it's range & min/max points
+ *--------------------------------------------------------------------------------*/
+#if false
+#define CHECK_VALUE
+#include <math.h>
+#endif
+
+typedef struct {
+  uint16_t  x, y;
+  float     v;
+} Temperature_t;
+
+static Temperature_t te_min, te_max, _te_min, _te_max, te_pick;
+
+void filter_update(void) {
+  _te_min = te_min;
+  _te_max = te_max;
+}
+
+void filter_temperature(float *src) {
+  // Measure the temperature at the picked up point
+  if (te_pick.x != 0 || te_pick.y != 0) {
+    te_pick.v = src[te_pick.x + (te_pick.y * MLX90640_COLS)];
+    te_pick.v = lp_pick.filter(te_pick.v, mlx_cnf.sampling_period);
+  }
+
+  // Measure min/max temperature
+  te_min.v =  999.0f;
+  te_max.v = -999.0f;
+
+  for (uint16_t y = 0; y < MLX90640_ROWS; ++y) {
+    for (uint16_t x = 0; x < MLX90640_COLS; ++x, ++src) {
+      float t = *src;
+#ifdef  CHECK_VALUE
+      if (isinf(t) || isnan(t) || t < -30.0f || 300.0f < t) {
+        continue;
+      }
+#endif
+      if (t < te_min.v) { te_min.x = x; te_min.y = y; te_min.v = t; } else
+      if (t > te_max.v) { te_max.x = x; te_max.y = y; te_max.v = t; }
+    }
+  }
+
+  if (mlx_cnf.range_auto) {
+    #define RANGE_STEP  (1) // --> 'TERMOGRAPH_STEP' in widgets.hpp
+    mlx_cnf.range_min = ((int)((float)lp_min.filter(te_min.v, mlx_cnf.sampling_period) / (float)RANGE_STEP) + 0.5f) * RANGE_STEP;
+    mlx_cnf.range_max = ((int)((float)lp_max.filter(te_max.v, mlx_cnf.sampling_period) / (float)RANGE_STEP) + 0.5f) * RANGE_STEP;
+
+    // debug for serial ploter
+    // DBG_EXEC(printf("%4.1f, %4.1f, %4.1f, %4.1f\n", te_min.v, te_max.v, lp_min.y, lp_max.y));
+  }
+}

boards/Setup_XIAO_ESP32S3_ST7789.h

@@ -0,0 +1,133 @@
+/*================================================================================
+ * GFX Library
+ * For the 'drawBmpFile()' function to work correctly, LovyanGFX requires 
+ * that the SD library header file be included before '<LovyanGFX.hpp>`.
+ *================================================================================*/
+#include <SD.h>
+#include <SPI.h>
+
+/*--------------------------------------------------------------------------------
+ * LovyanGFX
+ * https://github.com/lovyan03/LovyanGFX
+ *--------------------------------------------------------------------------------*/
+#ifdef USE_LOVYAN_GFX
+
+  #define SCREEN_ROTATION 3
+  #define GFX_EXEC(x) lcd.x
+  #define GFX_FAST(x) lcd_sprite.x
+
+  /*--------------------------------------------------
+  * variants/jczn_2432s028r/pins_arduino.h
+  *--------------------------------------------------*/
+  #if defined (CYD_TP_CS)
+    #if USE_AUTODETECT
+    #define LGFX_AUTODETECT
+    #include <LovyanGFX.h>
+    #else
+    #include <LovyanGFX.h>
+    // false: (micro-USB x 1 type, ILI9341)
+    // true : (micro-USB x 1 + USB-C x 1 type, ST7789)
+    #define DISPLAY_CYD_2USB  true
+    #include "./boards/LGFX_CYD_2432S028R.hpp"
+    #endif
+
+  /*--------------------------------------------------
+  * variants/XIAO_ESP32S3/pins_arduino.h
+  *--------------------------------------------------*/
+  #elif defined (ARDUINO_XIAO_ESP32S3)
+    #include <LovyanGFX.h>
+    #include "./boards/LGFX_XIAO_ESP32S3_ST7789.hpp"
+
+  /*--------------------------------------------------
+  * variants/your_board_type/pins_arduino.h
+  *--------------------------------------------------*/
+  #else
+  #endif
+
+/*--------------------------------------------------------------------------------
+ * TFT_eSPI
+ * https://github.com/Bodmer/TFT_eSPI
+ *--------------------------------------------------------------------------------*/
+#elif defined (USE_TFT_ESPI)
+#include <TFT_eSPI.h>
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Definitions of graphics helpers
+ *--------------------------------------------------------------------------------*/
+// Font size for setTextSize(2)
+#define FONT_WIDTH    12 // [px] (Device coordinate system)
+#define FONT_HEIGHT   16 // [px] (Device coordinate system)
+#define LINE_HEIGHT   18 // [px] (FONT_HEIGHT + margin)
+
+uint16_t lcd_width;
+uint16_t lcd_height;
+
+/*--------------------------------------------------------------------------------
+ * LovyanGFX
+ *--------------------------------------------------------------------------------*/
+#if defined (LOVYANGFX_HPP_)
+
+LGFX lcd;
+LGFX_Sprite lcd_sprite(&lcd);
+
+void gfx_setup(void) {
+  GFX_EXEC(init());
+  GFX_EXEC(initDMA());
+  GFX_EXEC(clear(TFT_BLACK));
+  GFX_EXEC(setBrightness(128)); // 0 ~ 255
+  GFX_EXEC(setRotation(SCREEN_ROTATION));
+  GFX_EXEC(setTextColor(TFT_WHITE, TFT_BLACK));
+  lcd_width  = GFX_EXEC(width());
+  lcd_height = GFX_EXEC(height());
+}
+
+/*--------------------------------------------------------------------------------
+ * TFT_eSPI
+ *--------------------------------------------------------------------------------*/
+#elif defined (_TFT_eSPIH_)
+
+TFT_eSPI tft = TFT_eSPI();
+TFT_eSprite tft_sprite(&tft);
+
+#define SCREEN_ROTATION 3
+#define GFX_EXEC(x) tft.x
+#define GFX_FAST(x) tft_sprite.x
+#define setClipRect setViewport
+#define clearClipRect resetViewport
+
+void gfx_setup(void) {
+  GFX_EXEC(init());
+  GFX_EXEC(initDMA(false)); // 'true' breaks SD card function
+  GFX_EXEC(fillScreen(0));
+  GFX_EXEC(setRotation(SCREEN_ROTATION));
+  GFX_EXEC(setTextColor(TFT_WHITE, TFT_BLACK));
+  lcd_width  = GFX_EXEC(width());
+  lcd_height = GFX_EXEC(height());
+}
+#endif // LovyanGFX or TFT_eSPI
+
+/*--------------------------------------------------------------------------------
+ * Common function
+ *--------------------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifndef BUF_SIZE
+#define BUF_SIZE  64
+#endif
+
+void gfx_printf(uint16_t x, uint16_t y, const char* fmt, ...) {
+  int len = 0;
+  char buf[BUF_SIZE];
+
+  va_list arg_ptr;
+  va_start(arg_ptr, fmt);
+  len = vsnprintf(buf, sizeof(buf), fmt, arg_ptr);
+  va_end(arg_ptr);
+
+  // use the followings:
+  // setTextColor(foreground_color, background_color);
+  // setTextDatum(textdatum_t::...);
+  GFX_EXEC(drawString(buf, x, y));
+}

draw.hpp

@@ -0,0 +1,114 @@
+#if   (N_HEATMAP == 256)
+{
+/* Railbow */
+0x480F,0x400F,0x400F,0x400F,0x4010,0x3810,0x3810,0x3810,0x3810,0x3010,0x3010,0x3010,0x2810,0x2810,0x2810,0x2810,
+0x2010,0x2010,0x2010,0x1810,0x1810,0x1811,0x1811,0x1011,0x1011,0x1011,0x0811,0x0811,0x0811,0x0011,0x0011,0x0011,
+0x0011,0x0011,0x0031,0x0031,0x0051,0x0072,0x0072,0x0092,0x00B2,0x00B2,0x00D2,0x00F2,0x00F2,0x0112,0x0132,0x0152,
+0x0152,0x0172,0x0192,0x0192,0x01B2,0x01D2,0x01F3,0x01F3,0x0213,0x0233,0x0253,0x0253,0x0273,0x0293,0x02B3,0x02D3,
+0x02D3,0x02F3,0x0313,0x0333,0x0333,0x0353,0x0373,0x0394,0x03B4,0x03D4,0x03D4,0x03F4,0x0414,0x0434,0x0454,0x0474,
+0x0474,0x0494,0x04B4,0x04D4,0x04F4,0x0514,0x0534,0x0534,0x0554,0x0554,0x0574,0x0574,0x0573,0x0573,0x0573,0x0572,
+0x0572,0x0572,0x0571,0x0591,0x0591,0x0590,0x0590,0x058F,0x058F,0x058F,0x058E,0x05AE,0x05AE,0x05AD,0x05AD,0x05AD,
+0x05AC,0x05AC,0x05AB,0x05CB,0x05CB,0x05CA,0x05CA,0x05CA,0x05C9,0x05C9,0x05C8,0x05E8,0x05E8,0x05E7,0x05E7,0x05E6,
+0x05E6,0x05E6,0x05E5,0x05E5,0x0604,0x0604,0x0604,0x0603,0x0603,0x0602,0x0602,0x0601,0x0621,0x0621,0x0620,0x0620,
+0x0620,0x0620,0x0E20,0x0E20,0x0E40,0x1640,0x1640,0x1E40,0x1E40,0x2640,0x2640,0x2E40,0x2E60,0x3660,0x3660,0x3E60,
+0x3E60,0x3E60,0x4660,0x4660,0x4E60,0x4E80,0x5680,0x5680,0x5E80,0x5E80,0x6680,0x6680,0x6E80,0x6EA0,0x76A0,0x76A0,
+0x7EA0,0x7EA0,0x86A0,0x86A0,0x8EA0,0x8EC0,0x96C0,0x96C0,0x9EC0,0x9EC0,0xA6C0,0xAEC0,0xAEC0,0xB6E0,0xB6E0,0xBEE0,
+0xBEE0,0xC6E0,0xC6E0,0xCEE0,0xCEE0,0xD6E0,0xD700,0xDF00,0xDEE0,0xDEC0,0xDEA0,0xDE80,0xDE80,0xE660,0xE640,0xE620,
+0xE600,0xE5E0,0xE5C0,0xE5A0,0xE580,0xE560,0xE540,0xE520,0xE500,0xE4E0,0xE4C0,0xE4A0,0xE480,0xE460,0xEC40,0xEC20,
+0xEC00,0xEBE0,0xEBC0,0xEBA0,0xEB80,0xEB60,0xEB40,0xEB20,0xEB00,0xEAE0,0xEAC0,0xEAA0,0xEA80,0xEA60,0xEA40,0xF220,
+0xF200,0xF1E0,0xF1C0,0xF1A0,0xF180,0xF160,0xF140,0xF100,0xF0E0,0xF0C0,0xF0A0,0xF080,0xF060,0xF040,0xF020,0xF800,
+},
+{
+/* Inferno */
+0x304A,0x304A,0x304A,0x304A,0x304B,0x304B,0x384B,0x384B,0x384B,0x384B,0x384C,0x384C,0x384C,0x406C,0x406C,0x406C,
+0x406C,0x406D,0x406D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x506E,0x506E,0x506E,0x506E,0x508E,0x508E,
+0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x608E,0x608E,0x608E,0x608E,0x608E,0x60AE,0x60AE,0x68AE,0x68AE,0x68AE,
+0x68AE,0x68AE,0x68AE,0x70AE,0x70AE,0x70AE,0x70CE,0x70CE,0x70CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x80CE,
+0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x88EE,0x88ED,0x890D,0x890D,0x890D,0x890D,0x910D,0x910D,0x910D,0x910D,
+0x912D,0x912D,0x992D,0x992D,0x992C,0x992C,0x992C,0x994C,0x994C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA16B,0xA16B,
+0xA96B,0xA96B,0xA96B,0xA96B,0xA98B,0xA98B,0xB18B,0xB18A,0xB18A,0xB18A,0xB1AA,0xB1AA,0xB1AA,0xB1AA,0xB9AA,0xB9A9,
+0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xC1E9,0xC1E9,0xC1E8,0xC1E8,0xC1E8,0xC1E8,0xC208,0xCA08,0xCA08,0xCA08,0xCA07,
+0xCA27,0xCA27,0xCA27,0xCA27,0xCA47,0xD247,0xD247,0xD247,0xD246,0xD266,0xD266,0xD266,0xD266,0xDA86,0xDA86,0xDA86,
+0xDA85,0xDA85,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xE2C5,0xE2C5,0xE2C5,0xE2C5,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE304,0xE304,
+0xE304,0xEB24,0xEB24,0xEB24,0xEB24,0xEB43,0xEB43,0xEB43,0xEB43,0xEB63,0xEB63,0xEB63,0xEB83,0xF383,0xF383,0xF383,
+0xF3A3,0xF3A3,0xF3A3,0xF3C3,0xF3C3,0xF3C2,0xF3E2,0xF3E2,0xF3E2,0xF3E2,0xF402,0xF402,0xF402,0xF422,0xFC22,0xFC22,
+0xFC42,0xFC42,0xFC42,0xFC62,0xFC62,0xFC62,0xFC82,0xFC82,0xFC82,0xFCA2,0xFCA2,0xFCA2,0xFCC2,0xFCC2,0xFCC2,0xFCE3,
+0xFCE3,0xFD03,0xFD03,0xFD03,0xFD23,0xFD23,0xFD23,0xFD43,0xFD43,0xFD43,0xFD63,0xFD63,0xFD84,0xFD84,0xFD84,0xFDA4,
+0xFDA4,0xFDC4,0xFDC4,0xFDC4,0xFDE4,0xFDE5,0xFE05,0xFE05,0xFE05,0xFE25,0xFE25,0xFE46,0xFE46,0xFE66,0xFE66,0xFE66,
+0xFE87,0xFE87,0xF6A7,0xF6A7,0xF6C7,0xF6C8,0xF6C8,0xF6E8,0xF6E8,0xF709,0xF709,0xF729,0xF729,0xF74A,0xF74A,0xF74A,
+},
+#elif (N_HEATMAP == 512)
+{
+/* Railbow */
+
+0x480E,0x400F,0x400F,0x400F,0x400F,0x400F,0x4010,0x4010,0x4010,0x4010,0x4010,0x3811,0x3811,0x3811,0x3811,0x3811,
+0x3812,0x3812,0x3812,0x3812,0x3012,0x3013,0x3013,0x3013,0x3013,0x3013,0x3014,0x3014,0x3014,0x3014,0x2814,0x2815,
+0x2815,0x2815,0x2815,0x2815,0x2816,0x2816,0x2816,0x2016,0x2016,0x2017,0x2017,0x2017,0x2017,0x2017,0x2018,0x2018,
+0x2018,0x1818,0x1818,0x1819,0x1819,0x1819,0x1819,0x1819,0x181A,0x181A,0x101A,0x101A,0x101A,0x101B,0x101B,0x101B,
+0x101B,0x101B,0x101C,0x081C,0x081C,0x081C,0x081C,0x081D,0x081D,0x081D,0x081D,0x081D,0x081E,0x001E,0x001E,0x001E,
+0x001E,0x001F,0x001F,0x001F,0x001F,0x001F,0x001F,0x003F,0x003F,0x005F,0x005F,0x007F,0x009F,0x009F,0x00BF,0x00BF,
+0x00DF,0x00FF,0x00FF,0x011F,0x011F,0x013F,0x015F,0x015F,0x017F,0x017F,0x019F,0x01BF,0x01BF,0x01DF,0x01DF,0x01FF,
+0x021F,0x021F,0x023F,0x023F,0x025F,0x027F,0x027F,0x029F,0x029F,0x02BF,0x02DF,0x02DF,0x02FF,0x02FF,0x031F,0x033F,
+0x033F,0x035F,0x035F,0x037F,0x039F,0x039F,0x03BF,0x03BF,0x03DF,0x03FF,0x03FF,0x041F,0x041F,0x043F,0x043F,0x045F,
+0x047F,0x047F,0x049F,0x049F,0x04BF,0x04DF,0x04DF,0x04FF,0x04FF,0x051F,0x053F,0x053F,0x055F,0x055F,0x057F,0x059F,
+0x059F,0x05BF,0x05BF,0x05DF,0x05FF,0x05FF,0x061F,0x061F,0x063F,0x065F,0x065F,0x067F,0x067F,0x069F,0x06BF,0x06BF,
+0x06DF,0x06DF,0x06FF,0x071F,0x071F,0x073F,0x073F,0x075F,0x077F,0x077F,0x079F,0x079F,0x07BF,0x07DF,0x07DF,0x07FF,
+0x07FF,0x07FF,0x07FF,0x07FF,0x07FE,0x07FE,0x07FE,0x07FD,0x07FD,0x07FD,0x07FC,0x07FC,0x07FC,0x07FC,0x07FB,0x07FB,
+0x07FB,0x07FA,0x07FA,0x07FA,0x07F9,0x07F9,0x07F9,0x07F9,0x07F8,0x07F8,0x07F8,0x07F7,0x07F7,0x07F7,0x07F6,0x07F6,
+0x07F6,0x07F6,0x07F5,0x07F5,0x07F5,0x07F4,0x07F4,0x07F4,0x07F3,0x07F3,0x07F3,0x07F3,0x07F2,0x07F2,0x07F2,0x07F1,
+0x07F1,0x07F1,0x07F0,0x07F0,0x07F0,0x07F0,0x07EF,0x07EF,0x07EF,0x07EE,0x07EE,0x07EE,0x07EE,0x07ED,0x07ED,0x07ED,
+0x07EC,0x07EC,0x07EC,0x07EB,0x07EB,0x07EB,0x07EB,0x07EA,0x07EA,0x07EA,0x07E9,0x07E9,0x07E9,0x07E8,0x07E8,0x07E8,
+0x07E8,0x07E7,0x07E7,0x07E7,0x07E6,0x07E6,0x07E6,0x07E5,0x07E5,0x07E5,0x07E5,0x07E4,0x07E4,0x07E4,0x07E3,0x07E3,
+0x07E3,0x07E2,0x07E2,0x07E2,0x07E2,0x07E1,0x07E1,0x07E1,0x07E0,0x07E0,0x07E0,0x07E0,0x07E0,0x07E0,0x0FE0,0x0FE0,
+0x0FE0,0x0FE0,0x17E0,0x17E0,0x17E0,0x1FE0,0x1FE0,0x1FE0,0x27E0,0x27E0,0x27E0,0x27E0,0x2FE0,0x2FE0,0x2FE0,0x37E0,
+0x37E0,0x37E0,0x3FE0,0x3FE0,0x3FE0,0x3FE0,0x47E0,0x47E0,0x47E0,0x4FE0,0x4FE0,0x4FE0,0x57E0,0x57E0,0x57E0,0x57E0,
+0x5FE0,0x5FE0,0x5FE0,0x67E0,0x67E0,0x67E0,0x6FE0,0x6FE0,0x6FE0,0x6FE0,0x77E0,0x77E0,0x77E0,0x7FE0,0x7FE0,0x7FE0,
+0x87E0,0x87E0,0x87E0,0x87E0,0x8FE0,0x8FE0,0x8FE0,0x97E0,0x97E0,0x97E0,0x97E0,0x9FE0,0x9FE0,0x9FE0,0xA7E0,0xA7E0,
+0xA7E0,0xAFE0,0xAFE0,0xAFE0,0xAFE0,0xB7E0,0xB7E0,0xB7E0,0xBFE0,0xBFE0,0xBFE0,0xC7E0,0xC7E0,0xC7E0,0xC7E0,0xCFE0,
+0xCFE0,0xCFE0,0xD7E0,0xD7E0,0xD7E0,0xDFE0,0xDFE0,0xDFE0,0xDFE0,0xE7E0,0xE7E0,0xE7E0,0xEFE0,0xEFE0,0xEFE0,0xF7E0,
+0xF7E0,0xF7E0,0xF7E0,0xFFE0,0xFFE0,0xFFE0,0xFFE0,0xFFC0,0xFFC0,0xFFA0,0xFFA0,0xFF80,0xFF60,0xFF60,0xFF40,0xFF40,
+0xFF20,0xFF00,0xFF00,0xFEE0,0xFEE0,0xFEC0,0xFEA0,0xFEA0,0xFE80,0xFE80,0xFE60,0xFE40,0xFE40,0xFE20,0xFE20,0xFE00,
+0xFDE0,0xFDE0,0xFDC0,0xFDC0,0xFDA0,0xFD80,0xFD80,0xFD60,0xFD60,0xFD40,0xFD20,0xFD20,0xFD00,0xFD00,0xFCE0,0xFCC0,
+0xFCC0,0xFCA0,0xFCA0,0xFC80,0xFC60,0xFC60,0xFC40,0xFC40,0xFC20,0xFC00,0xFC00,0xFBE0,0xFBE0,0xFBC0,0xFBC0,0xFBA0,
+0xFB80,0xFB80,0xFB60,0xFB60,0xFB40,0xFB20,0xFB20,0xFB00,0xFB00,0xFAE0,0xFAC0,0xFAC0,0xFAA0,0xFAA0,0xFA80,0xFA60,
+0xFA60,0xFA40,0xFA40,0xFA20,0xFA00,0xFA00,0xF9E0,0xF9E0,0xF9C0,0xF9A0,0xF9A0,0xF980,0xF980,0xF960,0xF940,0xF940,
+0xF920,0xF920,0xF900,0xF8E0,0xF8E0,0xF8C0,0xF8C0,0xF8A0,0xF880,0xF880,0xF860,0xF860,0xF840,0xF820,0xF820,0xF800,
+},
+{
+/* Inferno */
+0x304A,0x304A,0x304A,0x304A,0x304A,0x304A,0x304A,0x304B,0x304B,0x304B,0x304B,0x304B,0x384B,0x384B,0x384B,0x384B,
+0x384B,0x384B,0x384B,0x384C,0x384C,0x384C,0x384C,0x384C,0x384C,0x404C,0x406C,0x406C,0x406C,0x406C,0x406C,0x406C,
+0x406C,0x406D,0x406D,0x406D,0x406D,0x406D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,0x486D,
+0x486D,0x486D,0x486D,0x506D,0x506E,0x506E,0x506E,0x506E,0x506E,0x506E,0x506E,0x506E,0x508E,0x508E,0x508E,0x588E,
+0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x588E,0x608E,0x608E,0x608E,0x608E,
+0x608E,0x608E,0x608E,0x608E,0x608E,0x608E,0x60AE,0x60AE,0x60AE,0x68AE,0x68AE,0x68AE,0x68AE,0x68AE,0x68AE,0x68AE,
+0x68AE,0x68AE,0x68AE,0x68AE,0x68AE,0x70AE,0x70AE,0x70AE,0x70AE,0x70AE,0x70AE,0x70AE,0x70CE,0x70CE,0x70CE,0x70CE,
+0x70CE,0x70CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x78CE,0x80CE,0x80EE,
+0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x80EE,0x88EE,0x88EE,0x88EE,0x88ED,0x88ED,
+0x890D,0x890D,0x890D,0x890D,0x890D,0x890D,0x890D,0x910D,0x910D,0x910D,0x910D,0x910D,0x910D,0x910D,0x910D,0x910D,
+0x912D,0x912D,0x912D,0x912D,0x992D,0x992D,0x992D,0x992C,0x992C,0x992C,0x992C,0x992C,0x992C,0x992C,0x994C,0x994C,
+0x994C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14C,0xA14B,0xA16B,0xA16B,0xA16B,0xA96B,
+0xA96B,0xA96B,0xA96B,0xA96B,0xA96B,0xA96B,0xA96B,0xA96B,0xA98B,0xA98B,0xA98B,0xA98B,0xB18B,0xB18A,0xB18A,0xB18A,
+0xB18A,0xB18A,0xB18A,0xB18A,0xB1AA,0xB1AA,0xB1AA,0xB1AA,0xB1AA,0xB1AA,0xB1AA,0xB9AA,0xB9AA,0xB9AA,0xB9A9,0xB9A9,
+0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xB9C9,0xC1C9,0xC1E9,0xC1E9,0xC1E9,0xC1E9,0xC1E8,0xC1E8,
+0xC1E8,0xC1E8,0xC1E8,0xC1E8,0xC1E8,0xC208,0xC208,0xC208,0xCA08,0xCA08,0xCA08,0xCA08,0xCA08,0xCA08,0xCA07,0xCA27,
+0xCA27,0xCA27,0xCA27,0xCA27,0xCA27,0xCA27,0xCA27,0xCA27,0xCA47,0xD247,0xD247,0xD247,0xD247,0xD247,0xD247,0xD246,
+0xD246,0xD266,0xD266,0xD266,0xD266,0xD266,0xD266,0xD266,0xD266,0xD266,0xDA86,0xDA86,0xDA86,0xDA86,0xDA86,0xDA86,
+0xDA85,0xDA85,0xDA85,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xDAA5,0xDAC5,0xE2C5,0xE2C5,0xE2C5,0xE2C5,
+0xE2C5,0xE2C5,0xE2C5,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE2E4,0xE304,0xE304,0xE304,0xE304,0xE304,
+0xE304,0xEB04,0xEB24,0xEB24,0xEB24,0xEB24,0xEB24,0xEB24,0xEB24,0xEB23,0xEB43,0xEB43,0xEB43,0xEB43,0xEB43,0xEB43,
+0xEB43,0xEB63,0xEB63,0xEB63,0xEB63,0xEB63,0xEB63,0xEB63,0xEB83,0xEB83,0xF383,0xF383,0xF383,0xF383,0xF383,0xF3A3,
+0xF3A3,0xF3A3,0xF3A3,0xF3A3,0xF3A3,0xF3A3,0xF3C3,0xF3C3,0xF3C3,0xF3C3,0xF3C2,0xF3C2,0xF3E2,0xF3E2,0xF3E2,0xF3E2,
+0xF3E2,0xF3E2,0xF3E2,0xF402,0xF402,0xF402,0xF402,0xF402,0xF402,0xF422,0xF422,0xF422,0xFC22,0xFC22,0xFC22,0xFC42,
+0xFC42,0xFC42,0xFC42,0xFC42,0xFC42,0xFC62,0xFC62,0xFC62,0xFC62,0xFC62,0xFC62,0xFC82,0xFC82,0xFC82,0xFC82,0xFC82,
+0xFC82,0xFCA2,0xFCA2,0xFCA2,0xFCA2,0xFCA2,0xFCA2,0xFCC2,0xFCC2,0xFCC2,0xFCC2,0xFCC2,0xFCC2,0xFCE3,0xFCE3,0xFCE3,
+0xFCE3,0xFCE3,0xFD03,0xFD03,0xFD03,0xFD03,0xFD03,0xFD03,0xFD23,0xFD23,0xFD23,0xFD23,0xFD23,0xFD43,0xFD43,0xFD43,
+0xFD43,0xFD43,0xFD43,0xFD63,0xFD63,0xFD63,0xFD63,0xFD63,0xFD84,0xFD84,0xFD84,0xFD84,0xFD84,0xFDA4,0xFDA4,0xFDA4,
+0xFDA4,0xFDA4,0xFDC4,0xFDC4,0xFDC4,0xFDC4,0xFDC4,0xFDE4,0xFDE4,0xFDE5,0xFDE5,0xFDE5,0xFE05,0xFE05,0xFE05,0xFE05,
+0xFE05,0xFE25,0xFE25,0xFE25,0xFE25,0xFE26,0xFE46,0xFE46,0xFE46,0xFE46,0xFE66,0xFE66,0xFE66,0xFE66,0xFE66,0xFE86,
+0xFE87,0xFE87,0xFE87,0xF687,0xF6A7,0xF6A7,0xF6A7,0xF6A7,0xF6C7,0xF6C8,0xF6C8,0xF6C8,0xF6C8,0xF6E8,0xF6E8,0xF6E8,
+0xF6E8,0xF708,0xF709,0xF709,0xF709,0xF709,0xF729,0xF729,0xF729,0xF72A,0xF74A,0xF74A,0xF74A,0xF74A,0xF74A,0xF76A,
+},
+#else
+#error  'N_HEATMAP' in 'MLX90649' needs to be set correctly
+#endif

filter.hpp

@@ -0,0 +1,95 @@
+/*================================================================================
+ * Pixel interpolation
+ *================================================================================*/
+inline float get_point(float *p, const int rows, const int cols, int x, int y) __attribute__((always_inline));
+inline float get_point(float *p, const int rows, const int cols, int x, int y) {
+//if (x < 0) { x = 0; } else
+  if (x >= cols) { x = cols - 1; }
+//if (y < 0) { y = 0; } else
+  if (y >= rows) { y = rows - 1; }
+  return p[y * cols + x];
+}
+
+/*--------------------------------------------------------------------------------------------
+ * Bilinear interpolation
+ * https://algorithm.joho.info/image-processing/bi-linear-interpolation/
+ *--------------------------------------------------------------------------------------------*/
+static float table_ratio[INTERPOLATE_SCALE][2];
+
+void interpolate_setup(const int scale) {
+  for (int i = 0; i < scale; ++i) {
+    table_ratio[i][0] = (float)i / (float)scale;
+    table_ratio[i][1] = 1.0f - table_ratio[i][0];
+  }
+}
+
+#define FURTHER_OPTIMIZATION  true // Is the compiler smart enough?
+
+void interpolate_image(float *src, const int src_rows, const int src_cols, const int dst_rows, const int dst_cols) {
+  int X, Y;
+  float X0Y0, X1Y0, X0Y1, X1Y1;
+  float x_ratio_lo, x_ratio_hi;
+  float y_ratio_lo, y_ratio_hi;
+  const int scale = dst_rows / src_rows;
+#if FURTHER_OPTIMIZATION
+  float v0, v1, w0, w1;
+#endif
+  const int box_size = mlx_cnf.box_size;
+  const uint16_t *hm = heatmap[mlx_cnf.color_scheme];
+
+  // Bilinear interpolation
+  for (int y = 0; y < src_rows; ++y) {
+    Y = y * scale;
+
+    for (int x = 0; x < src_cols; ++x) {
+      X = x * scale;
+
+      X0Y0 = get_point(src, src_rows, src_cols, x,     y    );
+      X1Y0 = get_point(src, src_rows, src_cols, x + 1, y    );
+      X0Y1 = get_point(src, src_rows, src_cols, x,     y + 1);
+      X1Y1 = get_point(src, src_rows, src_cols, x + 1, y + 1);
+
+      for (int j = 0; j < scale; ++j) {
+        y_ratio_lo = table_ratio[j][0];
+        y_ratio_hi = table_ratio[j][1];
+
+#if FURTHER_OPTIMIZATION
+        v0 = y_ratio_hi * X0Y0;
+        v1 = y_ratio_hi * X1Y0;
+        w0 = y_ratio_lo * X0Y1;
+        w1 = y_ratio_lo * X1Y1;
+#endif
+        for (int i = 0; i < scale; ++i) {
+          x_ratio_lo = table_ratio[i][0];
+          x_ratio_hi = table_ratio[i][1];
+
+#if FURTHER_OPTIMIZATION
+          float t = v0 * x_ratio_hi + v1 * x_ratio_lo +
+                    w0 * x_ratio_hi + w1 * x_ratio_lo;
+#else
+          float t = y_ratio_hi * (x_ratio_hi * X0Y0 + x_ratio_lo * X1Y0) +
+                    y_ratio_lo * (x_ratio_hi * X0Y1 + x_ratio_lo * X1Y1);
+#endif
+          t = min((int)t, (int)mlx_cnf.range_max);
+          t = max((int)t, (int)mlx_cnf.range_min); 
+
+          int colorIndex = map(t, mlx_cnf.range_min, mlx_cnf.range_max, 0, N_HEATMAP - 1);
+
+#if ENA_OUTWARD_CAMERA
+          if (box_size == 1) {
+            GFX_FAST(drawPixel(dst_cols - 1 - (X + i), (Y + j), hm[colorIndex]));
+          } else {
+            GFX_FAST(fillRect((dst_cols - 1 - (X + i)) * box_size, (Y + j) * box_size, box_size, box_size, hm[colorIndex]));
+          }
+#else // Selfie Camera
+          if (box_size == 1) {
+            GFX_FAST(drawPixel(X + i, Y + j, hm[colorIndex]));
+          } else {
+            GFX_FAST(fillRect((X + i) * box_size, (Y + j) * box_size, box_size, box_size, hm[colorIndex]));
+          }
+#endif
+        }
+      }
+    }
+  }
+}

gfx.hpp

@@ -0,0 +1,41 @@
+// icon-icon_marker0.png
+// https://lang-ship.com/tools/image2data/
+// RAW File Dump
+static constexpr unsigned char icon_marker0[230] = {
+0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 
+0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x23, 0x72, 
+0x0d, 0x00, 0x00, 0x00, 0xad, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x05, 0xc1, 0x3b, 0xd2, 0xc1, 
+0x50, 0x00, 0x86, 0xe1, 0x37, 0xc1, 0x98, 0x64, 0x05, 0xfe, 0x8b, 0x0a, 0x85, 0x05, 0x30, 0x24, 
+0x8d, 0x45, 0x88, 0xc9, 0x71, 0x06, 0x67, 0x23, 0x34, 0xd6, 0xa0, 0x61, 0x3f, 0x32, 0x6e, 0x05, 
+0x85, 0xb0, 0x0a, 0x44, 0xef, 0xf3, 0x3c, 0x00, 0x54, 0x3b, 0xc6, 0x74, 0xab, 0x00, 0x00, 0xc9, 
+0x59, 0x92, 0x2e, 0x09, 0x00, 0xcc, 0x75, 0x72, 0xed, 0xf6, 0xec, 0xa8, 0x05, 0xc0, 0x50, 0x9b, 
+0x4a, 0xcd, 0x98, 0x5a, 0x79, 0xad, 0x04, 0x82, 0xeb, 0xa9, 0x92, 0x3c, 0xa4, 0xc7, 0xa8, 0x7c, 
+0xcc, 0x03, 0x7a, 0xb2, 0x3f, 0xcf, 0xc3, 0x60, 0xb0, 0x7f, 0xfd, 0x8e, 0xd5, 0x63, 0xa2, 0xd6, 
+0x44, 0x31, 0x44, 0x9a, 0x36, 0x35, 0xf5, 0x3d, 0xe4, 0xf1, 0x81, 0x0f, 0x9e, 0x80, 0xbe, 0xcc, 
+0x5f, 0x91, 0xc5, 0xd1, 0xb6, 0xf8, 0x4f, 0x15, 0x11, 0xdc, 0xf6, 0x25, 0x5b, 0x48, 0x6f, 0x5b, 
+0xda, 0xdd, 0x43, 0x48, 0xb5, 0xf2, 0xeb, 0xce, 0xd5, 0xfd, 0x95, 0x52, 0x80, 0xa5, 0x32, 0xd3, 
+0x68, 0xa4, 0x99, 0x96, 0x00, 0x60, 0x73, 0x49, 0xca, 0x2d, 0x00, 0x40, 0x18, 0x3b, 0x17, 0x87, 
+0x00, 0x5f, 0x62, 0xd3, 0x4c, 0x80, 0x38, 0x4d, 0x80, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 
+0x4e, 0x44, 0xae, 0x42, 0x60, 0x82, };
+
+// icon-icon_marker1.png
+// https://lang-ship.com/tools/image2data/
+// RAW File Dump
+static constexpr unsigned char icon_marker1[270] = {
+0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 
+0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x98, 0xa0, 
+0xbd, 0x00, 0x00, 0x00, 0xd5, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0x35, 0xce, 0x03, 0x52, 0x45, 
+0x01, 0x00, 0x86, 0xd1, 0x2f, 0x73, 0x09, 0xcf, 0xd6, 0x30, 0xaf, 0x24, 0xd7, 0x4e, 0xb2, 0x07, 
+0xd9, 0xe6, 0x20, 0xad, 0x23, 0x7b, 0x94, 0x5b, 0xc2, 0x33, 0xef, 0x9f, 0xcf, 0x0a, 0x0e, 0xdf, 
+0xb0, 0x37, 0x8d, 0x8d, 0x35, 0xd9, 0xf9, 0x67, 0x59, 0x8e, 0xe8, 0x4b, 0x64, 0xd9, 0x02, 0xdf, 
+0xaa, 0x9f, 0xf4, 0xb0, 0x96, 0xc9, 0xac, 0xdd, 0xeb, 0xb9, 0x1a, 0xc0, 0xfc, 0xa2, 0xc1, 0x4a, 
+0x57, 0x26, 0xe3, 0xaa, 0x1c, 0xd4, 0x8b, 0x05, 0x58, 0xd5, 0x20, 0x04, 0xa5, 0x20, 0x0c, 0x6a, 
+0x0d, 0xec, 0xd1, 0xfb, 0x62, 0x28, 0x9b, 0x9b, 0x2b, 0x83, 0xe2, 0xbb, 0x98, 0x9d, 0x26, 0x2d, 
+0x7a, 0xdc, 0x45, 0x00, 0x45, 0x6e, 0xcf, 0x82, 0x9a, 0xd8, 0x56, 0x2a, 0x99, 0x98, 0x06, 0x98, 
+0x4e, 0x24, 0x53, 0x3a, 0x60, 0x4f, 0x99, 0x4c, 0x7a, 0x01, 0x60, 0x21, 0x9d, 0xc9, 0xe8, 0x98, 
+0x66, 0x2d, 0x85, 0x82, 0x25, 0x00, 0x25, 0xc1, 0xd0, 0x92, 0x9a, 0x71, 0xc6, 0x6f, 0x0a, 0xa1, 
+0x74, 0x62, 0xa2, 0x14, 0x0a, 0xaf, 0xe3, 0x4e, 0xd8, 0x54, 0x0f, 0x04, 0xa4, 0x00, 0xf4, 0x68, 
+0x0b, 0xb0, 0xbd, 0xab, 0xbb, 0xec, 0x3b, 0x56, 0xd6, 0xad, 0x0f, 0x1b, 0x40, 0xfd, 0xbb, 0xae, 
+0x16, 0x32, 0x99, 0x85, 0x2b, 0xbd, 0x37, 0xc0, 0x37, 0xc7, 0x66, 0x42, 0x5f, 0x12, 0x5b, 0x0e, 
+0xfe, 0x79, 0x3a, 0x4e, 0x4f, 0x3b, 0x3d, 0x7c, 0xfb, 0x04, 0x7f, 0xfb, 0x69, 0x12, 0x9f, 0xf2, 
+0x94, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82, };

heatmap.h

@@ -0,0 +1,153 @@
+#include <atomic>
+/*--------------------------------------------------------------------------------
+ * MLX90640 instance
+ *--------------------------------------------------------------------------------*/
+#include <Wire.h>
+#include <Adafruit_MLX90640.h>
+Adafruit_MLX90640 mlx;
+
+/*--------------------------------------------------------------------------------
+ * The size of thermal image (max INTERPOLATE_SCALE = 8)
+ *--------------------------------------------------------------------------------*/
+#define MLX90640_COLS 32
+#define MLX90640_ROWS 24
+#define INTERPOLATED_COLS (MLX90640_COLS * 8)
+#define INTERPOLATED_ROWS (MLX90640_ROWS * 8)
+
+/*--------------------------------------------------------------------------------
+ * Thermography image
+ *--------------------------------------------------------------------------------*/
+#if ENA_MULTITASKING
+float src[2][MLX90640_ROWS  * MLX90640_COLS];
+#else
+float src[1][MLX90640_ROWS  * MLX90640_COLS];
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Initial values for range of temperature
+ *--------------------------------------------------------------------------------*/
+#define MINTEMP 20  // Low  temperature range
+#define MAXTEMP 35  // High temperature range
+
+/*--------------------------------------------------------------------------------
+ * MLX90640 control configuration
+ *--------------------------------------------------------------------------------*/
+typedef struct MLXConfig {
+  // Member Variables
+  uint8_t   interpolation;    // 1, 2, 4, 6, 8
+  uint8_t   box_size;         // 1, 2, 4, 8
+  uint8_t   refresh_rate;     // sampline frequency (mlx90640_refreshrate_t)
+  uint8_t   color_scheme;     // 0: rainbow, 1: inferno
+  uint8_t   marker_mode;      // 0: off, 1: min/max, 2: picked up by user
+  bool      range_auto;       // automatic measurement of temperature min/max
+  int16_t   range_min;        // minimum temperature
+  int16_t   range_max;        // maximum temperature
+  float     sampling_period;  // sampling period [sec]
+
+  // Comparison Operators
+  bool operator >= (const MLXConfig &RHS) {
+    return (
+      (interpolation != RHS.interpolation) ||
+      (box_size      != RHS.box_size     ) ||
+      (refresh_rate  != RHS.refresh_rate )
+    );
+  }
+  bool operator != (const MLXConfig &RHS) {
+    return (
+      (color_scheme  != RHS.color_scheme ) ||
+      (marker_mode   != RHS.marker_mode  ) ||
+      (range_auto    != RHS.range_auto   ) ||
+      (range_min     != RHS.range_min    ) ||
+      (range_max     != RHS.range_max    )
+    );
+  }
+  // Copy some members
+  MLXConfig operator <<= (const MLXConfig &RHS) {
+    color_scheme = RHS.color_scheme;
+    marker_mode  = RHS.marker_mode;
+    range_auto   = RHS.range_auto;
+    range_min    = RHS.range_min;
+    range_max    = RHS.range_max;
+    return RHS;
+  };
+
+  // Setup refresh_rate according to INTERPOLATE_SCALE and BOX_SIZE
+  void init(void) {
+    sampling_period = 2.0f / pow(2.0f, (float)(refresh_rate - 1));
+
+    void filter_reset(void);
+    filter_reset();
+  }
+} MLXConfig_t;
+
+constexpr MLXConfig_t mlx_ini = {
+  .interpolation  = INTERPOLATE_SCALE,  // 1, 2, 4, 6, 8
+  .box_size       = BOX_SIZE,           // 1, 2, 4, 8
+  .refresh_rate   = REFRESH_RATE,       // sampline frequency (32Hz, 16Hz, 8Hz, 4Hz, 2Hz)
+  .color_scheme   = 0,                  // 0: rainbow, 1: inferno
+  .marker_mode    = 0,                  // 0: off, 1: min/max, 2: picked up by user
+  .range_auto     = false,              // automatic measurement of temperature min/max
+  .range_min      = MINTEMP,            // minimum temperature (20 deg)
+  .range_max      = MAXTEMP,            // maximum temperature (35 deg)
+};
+
+MLXConfig_t mlx_cnf = mlx_ini;
+
+/*--------------------------------------------------------------------------------
+ * MLX90640 capture control
+ *--------------------------------------------------------------------------------*/
+typedef struct MLXCapture {
+  uint8_t       capture_mode; // 0: camera, 1: video
+  bool          recording;    // false: stop, true: recording
+  char          filename[30]; // "/MLX90640/mlx%04d.raw"
+} MLXCapture_t;
+
+MLXCapture_t mlx_cap = {
+  .capture_mode   = 0,        // 0: camera, 1: video
+  .recording      = false,    // false: stop, true: recording
+};
+
+/*--------------------------------------------------------------------------------
+ * Set MLX90640 refresh rate
+ *--------------------------------------------------------------------------------*/
+bool mlx_refresh(void) {
+  // The initial value 64Hz is out of range
+  static uint8_t refreshRate = MLX90640_64_HZ;
+
+  // Refresh MLX90640 when refresh rate changes
+  if (refreshRate != mlx_cnf.refresh_rate) {
+    mlx.setRefreshRate((mlx90640_refreshrate_t)(refreshRate = mlx_cnf.refresh_rate));
+    mlx_cnf.init();
+    delay(100); // Wait a bit for the change to take effect
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/*--------------------------------------------------------------------------------
+ * MLX90640 initializing
+ *--------------------------------------------------------------------------------*/
+void mlx_setup(void) {
+#ifdef  MLX_I2C_SDA
+  Wire.begin(MLX_I2C_SDA, MLX_I2C_SCL);
+#else
+  Wire.begin();
+#endif
+
+  // Initialize MLX90640 with I2C
+  if (!mlx.begin(MLX90640_I2CADDR_DEFAULT, &Wire)) {
+    DBG_EXEC(printf("MLX90640 not found!\n"));
+  } else {
+    DBG_EXEC(printf("MLX90640 found at I2C address 0x%X.\n", MLX90640_I2CADDR_DEFAULT));
+    DBG_EXEC(printf("Serial number: %04X%04X%04X\n", mlx.serialNumber[0], mlx.serialNumber[1], mlx.serialNumber[2]));
+  }
+
+  // I2C bus clock for MLX90640 (Officially, the ESP32S3 supports up to 800KHz)
+  Wire.setClock(1000000); // 400 KHz (Sm) or 1 MHz (Fm+)
+
+  // Set MLX90640 operating mode
+  mlx.setMode(MLX90640_CHESS); // or MLX90640_INTERLEAVED
+  mlx.setResolution(MLX90640_ADC_18BIT);  // 16BIT, 17BIT, 18BIT (default) or 19BIT
+  mlx_refresh();
+}

interpolation.hpp

@@ -0,0 +1,84 @@
+/*================================================================================
+ * I2C / SPI pin assign
+ * https://github.com/espressif/arduino-esp32/tree/master/variants
+ *================================================================================*/
+#ifndef _PIN_ASSIGN_H_
+#define _PIN_ASSIGN_H_
+
+/*--------------------------------------------------------------------------------
+ * I2C pin assignment
+ *--------------------------------------------------------------------------------*/
+// variants/jczn_2432s028r/pins_arduino.h
+#if defined (CYD_TP_CS)
+#define MLX_I2C_SDA 22
+#define MLX_I2C_SCL 27
+#endif
+
+/*--------------------------------------------------------------------------------
+ * Display panel resolution (defalult orientation: portrait)
+ *--------------------------------------------------------------------------------*/
+#define TFT_WIDTH     240
+#define TFT_HEIGHT    320
+
+/*--------------------------------------------------------------------------------
+ * SPI pin assignment
+ *--------------------------------------------------------------------------------*/
+// variants/jczn_2432s028r/pins_arduino.h
+#if   defined (CYD_SD_SS)
+#define TFT_DC        CYD_TFT_DC      //  2
+#define TFT_MISO      CYD_TFT_MISO    // 12
+#define TFT_MOSI      CYD_TFT_MOSI    // 13
+#define TFT_SCLK      CYD_TFT_SCK     // 14
+#define TFT_CS        CYD_TFT_CS      // 15
+#define TFT_RST       -1              //  2 (CYD_TFT_RS = CYD_TFT_DC)
+#define TFT_BL        CYD_TFT_BL      // 21
+#define TFT_SPI_BUS   CYD_TFT_SPI_BUS // HSPI
+
+#define TOUCH_IRQ     CYD_TP_IRQ      // 36
+#define TOUCH_MOSI    CYD_TP_MOSI     // 32
+#define TOUCH_MISO    CYD_TP_MISO     // 39
+#define TOUCH_CLK     CYD_TP_CLK      // 25
+#define TOUCH_CS      CYD_TP_CS       // 33
+#define TOUCH_SPI_BUS -1              // CYD_TP_SPI_BUS (VSPI)
+
+#define SD_CS         CYD_SD_SS       //  5
+#define SD_MOSI       CYD_SD_MOSI     // 23
+#define SD_MISO       CYD_SD_MISO     // 19
+#define SD_SCK        CYD_SD_SCK      // 18
+#define SD_SPI_BUS    CYD_SD_SPI_BUS  // VSPI
+#define SPI_MODE      SPI_MODE0       // SPI_MODE0, SPI_MODE2 or SPI_MODE3
+
+// false: Panel driver: ILI9341 (micro-USB x 1 type)
+// true : Panel driver: ST7789  (micro-USB x 1 + USB-C x 1 type)
+#if DISPLAY_CYD_2USB
+#define SPI_FREQUENCY       80000000  // 80 MHz (ST7789)
+#else
+#define SPI_FREQUENCY       40000000  // 40 MHz (ILI9341)
+#endif
+#define SPI_SD_FREQUENCY    50000000  // 50 MHz
+#define SPI_READ_FREQUENCY  16000000  // 16 MHz
+#define SPI_TOUCH_FREQUENCY  1000000  //  1 MHz
+
+// variants/XIAO_ESP32S3/pins_arduino.h
+#elif defined (ARDUINO_XIAO_ESP32S3)
+#define TFT_SCLK      SCK       // D8  = 7
+#define TFT_MISO      MISO      // D9  = 8
+#define TFT_MOSI      MOSI      // D10 = 9
+#define TFT_CS        D2        //  3
+#define TFT_RST       D1        //  2
+#define TFT_DC        D0        //  1
+#define TOUCH_CS      D3        //  4
+#define TOUCH_IRQ     D7        // 44
+#define SD_CS         D6        // 43
+#define SPI_MODE      SPI_MODE3 // SPI_MODE0, SPI_MODE2 or SPI_MODE3
+
+#define SPI_FREQUENCY       80000000  // 80 MHz
+#define SPI_SD_FREQUENCY    50000000  // 50 MHz
+#define SPI_READ_FREQUENCY   4000000  //  4 MHz
+#define SPI_TOUCH_FREQUENCY   250000  // 250KHz
+
+#else
+#error Pin assignment required depending on your board
+#endif
+
+#endif // _PIN_ASSIGN_H_

marker.h

@@ -0,0 +1,160 @@
+/*================================================================================
+ * Multitasking helper functions
+ *================================================================================*/
+#define TASK1_CORE      1
+#define TASK2_CORE      0
+
+#define TASK1_STACK     8192
+#define TASK2_STACK     8192
+
+#define TASK1_PRIORITY  2
+#define TASK2_PRIORITY  1
+
+// Message queue sent from task 1 to task 2
+typedef struct {
+  uint8_t   bank;   // Exclusive bank numbers for Task 1 and Task 2
+  uint32_t  start;  // Task 1 start time
+  uint32_t  finish; // Task 1 Finish Time
+} MessageQueue_t;
+
+// Define two tasks on the core
+void Task1(void *pvParameters);
+void Task2(void *pvParameters);
+
+// Define pointers to the tasks
+static void (*Process1)(uint8_t bank);
+static void (*Process2)(uint8_t bank, uint32_t start, uint32_t finish);
+
+// Message queues and semaphores for handshaking
+static TaskHandle_t taskHandle[2];
+static QueueHandle_t queHandle;
+static SemaphoreHandle_t semHandle;
+
+#define HALT()      { for(;;) delay(1000); }
+#define WAIT_QUEUE  portTICK_PERIOD_MS  // portMAX_DELAY
+#define NOT_UPDATED 0xFF
+
+// The setup function runs once when press reset or power on the board
+void task_setup(void (*task1)(uint8_t), void (*task2)(uint8_t, uint32_t, uint32_t)) {
+  // Pointers to the tasks to be executed.
+  Process1 = task1;
+  Process2 = task2;
+
+  // Task1 start immediately --> Process1 --> Task1 send queue --> Task1 wait for semaphre
+  // --> Task2 receive queue --> Process2 --> Task2 give semaphre --> Task2 wait queue
+  // --> Task1 take sepahore --> Process1 --> ...
+  semHandle = xSemaphoreCreateCounting(1, TASK1_CORE != TASK2_CORE ? 0 : 0);
+  queHandle = xQueueCreate(1, sizeof(MessageQueue_t));
+
+  // Check if the queue or the semaphore was successfully created
+  if (queHandle == NULL || semHandle == NULL) {
+    DBG_EXEC(printf("Can't create queue or semaphore.\n"));
+    HALT();
+  }
+
+  // Set up sender task in core 1 and start immediately
+  xTaskCreatePinnedToCore(
+    Task1, "Task1",
+    TASK1_STACK,    // The stack size
+    NULL,           // Pass reference to a variable describing the task number
+    TASK1_PRIORITY, // priority
+    &taskHandle[0], // Pass reference to task handle
+    TASK1_CORE
+  );
+
+  // Set up receiver task on core 0 and start immediately
+  xTaskCreatePinnedToCore(
+    Task2, "Task2",
+    TASK2_STACK,    // The stack size
+    NULL,           // Pass reference to a variable describing the task number
+    TASK2_PRIORITY, // priority
+    &taskHandle[1], // Pass reference to task handle
+    TASK2_CORE
+  );
+}
+
+/*--------------------------------------------------*/
+/*------------------- Handshake --------------------*/
+/*--------------------------------------------------*/
+uint8_t SendQueue(uint8_t bank, uint32_t start, uint32_t finish) {
+  MessageQueue_t queue = {
+    bank, start, finish
+  };
+
+  if (xQueueSend(queHandle, &queue, portMAX_DELAY) == pdTRUE) {
+//  DBG_EXEC(printf("Give queue: %d\n", queue.bank));
+  } else {
+    DBG_EXEC(printf("unable to send queue\n"));
+  }
+
+  return !bank;
+}
+
+MessageQueue_t ReceiveQueue() {
+  MessageQueue_t queue;
+
+  if (xQueueReceive(queHandle, &queue, portMAX_DELAY) == pdTRUE) {
+//  DBG_EXEC(printf("Take queue: %d\n", queue.bank));
+  } else {
+    DBG_EXEC(printf("Unable to receive queue.\n"));
+  }
+
+  return queue;
+}
+
+bool ScanQueue(MessageQueue_t &queue) {
+  if (xQueueReceive(queHandle, &queue, WAIT_QUEUE) == pdTRUE) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void TakeSemaphore(void) {
+  if (xSemaphoreTake(semHandle, portMAX_DELAY) == pdTRUE) {
+//  DBG_EXEC(printf("Take semaphore.\n"));
+  } else {
+    DBG_EXEC(printf("Unable to take semaphore.\n"));
+  }
+}
+
+void GiveSemaphore(void) {
+  if (xSemaphoreGive(semHandle) == pdTRUE) {
+//  DBG_EXEC(printf("Give semaphore.\n"));
+  } else {
+    DBG_EXEC(printf("Unable to give semaphore.\n"));
+  }
+}
+
+/*--------------------------------------------------*/
+/*--------------------- Tasks ----------------------*/
+/*--------------------------------------------------*/
+void Task1(void *pvParameters) {
+  uint8_t bank = 0;
+
+  while (true) {
+    uint32_t start = millis();
+
+    Process1(bank);
+
+    bank = SendQueue(bank, start, millis());
+
+    TakeSemaphore();
+  }
+}
+
+void Task2(void *pvParameters) {
+  MessageQueue_t queue;
+
+  while (true) {
+    if (ScanQueue(queue)) {
+      GiveSemaphore();
+    } else {
+      queue.bank = NOT_UPDATED;
+    }
+
+    Process2(queue.bank, queue.start, queue.finish);
+
+    yield(); // Prevent the watchdog from firing
+  }
+}

mlx.hpp

@@ -0,0 +1,354 @@
+/*================================================================================
+ * Touch event manager
+ *================================================================================*/
+
+/*--------------------------------------------------------------------------------
+ * Touch panel calibration configuration
+ *--------------------------------------------------------------------------------*/
+typedef struct TouchConfig {
+  // Member variables
+  uint16_t    cal[8];
+  int8_t      offset[2];
+
+  // Comparison operator
+  bool operator >= (TouchConfig &RHS) {
+    return !bcmp(cal, RHS.cal, sizeof(cal));
+  }
+  bool operator <= (TouchConfig &RHS) {
+    return (offset[0] != RHS.offset[0]) || (offset[1] != RHS.offset[1]);
+  }
+  bool operator != (TouchConfig &RHS) {
+    return bcmp(cal, RHS.cal, sizeof(cal)) || (offset[0] != RHS.offset[0]) || (offset[1] != RHS.offset[1]);
+  }
+} TouchConfig_t;
+
+/*--------------------------------------------------------------------------------
+ * Touch panel calibration parameters
+ * When 'USE_PREFERENCES' is 'false', the calibration result must be embedded.
+ *--------------------------------------------------------------------------------*/
+TouchConfig_t tch_cnf = {
+#if   defined (LOVYANGFX_HPP_)
+  .cal = { 0, 0, 0, 0, 0, 0, 0, 0 },
+#elif defined (_TFT_eSPIH_)
+  .cal = { 0, 0, 0, 0, 0, },
+#else // defined (_XPT2046_Touchscreen_h_)
+  .cal = { 0, },
+#endif
+  .offset = { 0, },
+};
+
+/*--------------------------------------------------------------------------------
+ * Event definition
+ *--------------------------------------------------------------------------------*/
+#define PERIOD_DEBOUNCE     25  // [msec]
+#define PERIOD_TOUCHED      50  // [msec]
+#define PERIOD_TAP2         200 // [msec]
+#define PERIOD_CLEAR_EVENT  100 // [msec]
+
+typedef enum {
+  EVENT_NONE    = (0x00), // considered as 'HIGH'
+  EVENT_RISING  = (0x01), //   touch --> untouch
+  EVENT_FALLING = (0x02), // untouch -->   touch
+  EVENT_TOUCHED = (0x04), //   touch -->   touch
+  EVENT_TAP2    = (0x08), // double tap
+  EVENT_WATCH   = (0x10), // execute a callback every watch cycle
+
+  // alias
+  EVENT_INIT    = (EVENT_NONE),
+  EVENT_UP      = (EVENT_RISING),
+  EVENT_DOWN    = (EVENT_FALLING),
+  EVENT_DRAG    = (EVENT_FALLING | EVENT_TOUCHED),
+  EVENT_TAP     = (EVENT_FALLING | EVENT_RISING),
+  EVENT_CLICK   = (EVENT_FALLING | EVENT_RISING),
+  EVENT_CHANGE  = (EVENT_FALLING | EVENT_RISING),
+  EVENT_SELECT  = (EVENT_FALLING | EVENT_TAP2),
+  EVENT_ALL     = (EVENT_FALLING | EVENT_RISING | EVENT_TOUCHED),
+} Event_t;
+
+typedef struct Touch {
+  Event_t     event;  // Detected event
+  uint16_t    x, y;   // The coordinates where the event fired
+} Touch_t;
+
+/*--------------------------------------------------------------------------------
+ * Function prototyping
+ *--------------------------------------------------------------------------------*/
+bool touch_setup(void);
+bool touch_event(Touch_t &touch);
+void touch_clear(void);
+void touch_calibrate(TouchConfig_t *config);
+bool touch_save(TouchConfig_t *config);
+bool touch_load(TouchConfig_t *config);
+
+/*--------------------------------------------------------------------------------
+ * Simple touch point correction
+ *--------------------------------------------------------------------------------*/
+extern uint16_t lcd_width;
+extern uint16_t lcd_height;
+
+/*--------------------------------------------------------------------------------
+ * Setup touch manager
+ *--------------------------------------------------------------------------------*/
+bool touch_setup(void) {
+#if USE_PREFERENCES
+  // Load calibration parameters from FLASH
+  if (touch_load(&tch_cnf) == false) {
+    touch_calibrate(&tch_cnf);
+    touch_save(&tch_cnf);
+  }
+#else
+  if (tch_cnf.cal[0] == 0) {
+    touch_calibrate(&tch_cnf);
+  }
+#endif
+
+#if   defined (LOVYANGFX_HPP_)
+
+  // https://github.com/lovyan03/LovyanGFX/discussions/539
+  GFX_EXEC(setTouchCalibrate(tch_cnf.cal));
+  return true;
+
+#elif defined (_TFT_eSPIH_)
+
+  // https://github.com/Bodmer/TFT_eSPI/tree/master/examples/Generic/Touch_calibrate
+  GFX_EXEC(setTouch(tch_cnf.cal));
+  return true;
+
+else  // defined (_XPT2046_Touchscreen_h_)
+
+  if (ts.begin()) {
+    ts.setRotation(SCREEN_ROTATION);
+    return true;
+  } else {
+    return false;
+  }
+
+#endif
+}
+
+/*--------------------------------------------------------------------------------
+ * Touch event manager
+ *--------------------------------------------------------------------------------*/
+bool touch_event(Touch_t &touch) {
+  uint32_t time = millis();
+  static uint32_t prev_time;
+  static uint16_t x, y;
+  static bool prev_stat;
+  static uint8_t count;
+  Event_t event = EVENT_NONE;
+
+#if defined (_XPT2046_Touchscreen_h_)
+
+  bool stat = ts.touched();
+  if (stat) {
+    TS_Point p = ts.getPoint();
+    x = p.x;
+    y = p.y;
+  }
+
+#else // LovyanGFX || TFT_eSPI
+
+  bool stat = GFX_EXEC(getTouch(&x, &y));
+
+#endif // _XPT2046_Touchscreen_h_
+
+  // when state changes, check again after a certain period of time
+  uint32_t dt = time - prev_time;
+  if (stat != prev_stat) {
+    if (dt < PERIOD_DEBOUNCE) {
+      return false;
+    } else {
+      // update the time when state changes
+      prev_time = time;
+
+      // reset double tap counter
+      if (dt > PERIOD_TAP2 || count >= 4) {
+        count = 0;
+      }
+    }
+  }
+
+  // untouch --> touch
+  if (prev_stat == false && stat == true) {
+    event = EVENT_FALLING;
+    count = (count == 0 ? count + 1 : (dt <= PERIOD_TAP2 ? count + 1 : 0));
+  } else
+
+  // touch --> untouch
+  if (prev_stat == true && stat == false) {
+    event = EVENT_RISING;
+    count = dt <= PERIOD_TAP2 ? count + 1 : 0;
+  } else
+
+  // touch --> touch
+  if (prev_stat == true && stat == true) {
+    event = EVENT_TOUCHED;
+  }
+
+  // update state
+  prev_stat = stat;
+
+  if (event != EVENT_NONE) {
+    if (stat) {
+        x += tch_cnf.offset[0];
+        y += tch_cnf.offset[1];
+        x = constrain(x, 0, lcd_width  - 1);
+        y = constrain(y, 0, lcd_height - 1);
+    }
+
+    // TAP2 = FALLING --> RISING --> FALLING --> RISING
+    touch.event = (Event_t)(event | (count >= 4 ? EVENT_TAP2 : EVENT_NONE));
+    touch.x = x;
+    touch.y = y;
+
+//  DBG_EXEC(printf("event: %d, x: %d, y: %d, dt: %d, count: %d\n", touch.event, x, y, dt, count));
+    return true;
+  }
+
+  return false;
+}
+
+/*--------------------------------------------------------------------------------
+ * Wait until there are no more touch events
+ *--------------------------------------------------------------------------------*/
+void touch_clear(void) {
+  Touch_t touch;
+  delay(PERIOD_CLEAR_EVENT);
+  while(touch_event(touch));
+}
+
+/*--------------------------------------------------------------------------------
+ * Calibrating the touch panel
+ *--------------------------------------------------------------------------------*/
+void touch_calibrate(TouchConfig_t *config) {
+#if   defined (_XPT2046_Touchscreen_h_)
+
+#elif defined (LOVYANGFX_HPP_)
+
+  // https://github.com/lovyan03/LovyanGFX/tree/master/examples/HowToUse/2_user_setting
+  GFX_EXEC(clear(0));
+  GFX_EXEC(setTextSize(2));
+  GFX_EXEC(setTextDatum(textdatum_t::middle_center));
+  GFX_EXEC(drawString("touch the arrow marker.", lcd_width >> 1, lcd_height >> 1));
+  GFX_EXEC(setTextDatum(textdatum_t::top_left));
+  GFX_EXEC(calibrateTouch(config->cal, TFT_WHITE, TFT_BLACK, std::max(lcd_width, lcd_height) >> 3));
+
+  DBG_EXEC({
+    printf("\n// LovyanGFX\n");
+    printf(".cal = { ");
+    for (uint8_t i = 0; i < 8; ++i) {
+      printf("%d\n", config->cal[i]);
+      printf(i < 7 ? ", " : " },\n");
+    }
+  });
+
+#elif defined (_TFT_eSPIH_)
+
+  // https://github.com/Bodmer/TFT_eSPI/tree/master/examples/Generic/Touch_calibrate
+  GFX_EXEC(fillScreen(TFT_BLACK));
+  GFX_EXEC(setCursor(20, 20));
+  GFX_EXEC(setTextSize(2));
+  GFX_EXEC(setTextColor(TFT_WHITE, TFT_BLACK));
+  GFX_EXEC(println("Touch corners in order"));
+  GFX_EXEC(calibrateTouch(config->cal, TFT_MAGENTA, TFT_BLACK, 15));
+
+  DBG_EXEC({
+    printf("\n// TFT_eSPI\n");
+    printf(".cal = { ");
+    for (uint8_t i = 0; i < 5; ++i) {
+      printf("%d\n", config->cal[i]);
+      printf(i < 4 ? ", " : "0, },\n");
+    }
+  });
+
+#endif
+
+  // clear offset
+  config->offset[0] = config->offset[1] = 0;
+}
+
+/*--------------------------------------------------------------------------------
+ * Saving and loading calibration configurations using preferences.h
+ * https://docs.espressif.com/projects/arduino-esp32/en/latest/tutorials/preferences.html
+ * https://github.com/espressif/arduino-esp32/tree/master/libraries/Preferences
+ *--------------------------------------------------------------------------------*/
+#include <Preferences.h>
+
+#define RW_MODE   false
+#define RO_MODE   true
+#define INIT_KEY  "initialized"
+
+#if     defined   (_XPT2046_Touchscreen_h_)
+#define PREF_KEY  "XPT2046"
+#elif   defined   (LOVYANGFX_HPP_)
+#define PREF_KEY  "LovyanGFX"
+#elif   defined   (_TFT_eSPIH_)
+#define PREF_KEY  "TFT_eSPI"
+#endif
+
+bool touch_save(TouchConfig_t *config) {
+#if USE_PREFERENCES
+  Preferences touchPref;
+
+  if (touchPref.begin(PREF_KEY, RW_MODE) == false) {
+    DBG_EXEC(printf("Preferences: begin(%s) failed.\n", PREF_KEY));
+    return false;
+  }
+
+  if (touchPref.putBytes("cal", static_cast<const void*>(config->cal), sizeof(config->cal)) != sizeof(config->cal)) {
+    DBG_EXEC(printf("Preferences: putBytes(cal) failed.\n"));
+    touchPref.end();
+    return false;
+  }
+
+  if (touchPref.putBytes("offset", static_cast<const void*>(config->offset), sizeof(config->offset)) != sizeof(config->offset)) {
+    DBG_EXEC(printf("Preferences: putBytes(offset) failed.\n"));
+    touchPref.end();
+    return false;
+  }
+
+  if (touchPref.putBool(INIT_KEY, true) != sizeof(true)) {
+    DBG_EXEC(printf("Preferences: putBool(%s) failed.\n", INIT_KEY));
+    touchPref.end();
+    return false;
+  }
+
+  touchPref.end();
+#endif
+  return true;
+}
+
+bool touch_load(TouchConfig_t *config) {
+#if USE_PREFERENCES
+  Preferences touchPref;
+  TouchConfig_t c;
+
+  if (touchPref.begin(PREF_KEY, RO_MODE) == false) {
+    DBG_EXEC(printf("Preferences: %s does not exist.\n", PREF_KEY));
+    return false;
+  }
+
+  // Check if it already exists
+  if (touchPref.isKey(INIT_KEY) == false) {
+    DBG_EXEC(printf("Preferences: %s does not exist.\n", INIT_KEY));
+    touchPref.end();
+    return false;
+  }
+
+  if (touchPref.getBytes("cal", static_cast<void*>(&c.cal), sizeof(c.cal)) != sizeof(c.cal)) {
+    DBG_EXEC(printf("Preferences: getBytes(cal) failed.\n"));
+    touchPref.end();
+    return false;
+  }
+
+  if (touchPref.getBytes("offset", static_cast<void*>(&c.offset), sizeof(c.offset)) != sizeof(c.offset)) {
+    DBG_EXEC(printf("Preferences: getBytes(offset) failed.\n"));
+    touchPref.end();
+    return false;
+  }
+
+  *config = c;
+  touchPref.end();
+#endif
+  return true;
+}

pin_assign.h

@@ -0,0 +1,253 @@
+/*================================================================================
+ * Wedget manager
+ *================================================================================*/
+#if   false // Check widget area by drawing with RED box
+#define CHECK_WIDGET_AREA(x) GFX_EXEC(x)
+#else
+#define CHECK_WIDGET_AREA(x)
+#endif
+
+/*--------------------------------------------------------------------------------
+ * State of the screen
+ *--------------------------------------------------------------------------------*/
+typedef enum {
+  STATE_ON = 0,
+  STATE_MAIN,
+  STATE_CONFIGURATION,
+  STATE_RESOLUTION,
+  STATE_THERMOGRAPH,
+  STATE_FILE_MANAGER,
+  STATE_FILE_CONFIRM,
+  STATE_CAPTURE_MODE,
+  STATE_CALIBRATION,
+  STATE_ADJUST_OFFSET,
+  STATE_INFORMATION,
+} State_t;
+
+static State_t state = STATE_ON;
+
+/*--------------------------------------------------------------------------------
+ * Widget data definition
+ *--------------------------------------------------------------------------------*/
+typedef struct {
+  const uint8_t   *data;  // pointer to the image
+  const size_t    size;   // size of image data (only for TFT_eSPI with bitbank2/PNGdec)
+} Image_t;
+
+typedef struct Widget {
+  const uint16_t  x, y;   // The top left coordinate of the widget
+  const uint16_t  w, h;   // Widget width and height
+  const Image_t   *image; // Widget image data
+  const Event_t   event;  // The touch event to detect
+  void            (*callback)(const struct Widget *widget, const Touch_t &touch);  // Event handler
+} Widget_t;
+
+#define N_WIDGETS(w)  (sizeof(w) / sizeof(w[0]))
+
+/*--------------------------------------------------------------------------------
+ * Focused widget
+ *--------------------------------------------------------------------------------*/
+static Widget_t const *focus = NULL;
+
+/*--------------------------------------------------------------------------------
+ * Event message to command initialization
+ *--------------------------------------------------------------------------------*/
+static constexpr Touch_t doInit = { EVENT_INIT, 0, 0 };
+
+/*--------------------------------------------------------------------------------
+ * Functions prototyping
+ *--------------------------------------------------------------------------------*/
+void widget_setup(State_t screen = STATE_ON);
+void widget_state(State_t screen = STATE_ON);
+State_t widget_control(void);
+
+/*--------------------------------------------------------------------------------
+ * Widgets
+ *--------------------------------------------------------------------------------*/
+#include "draw.hpp"
+#include "widgets.hpp"
+
+/*--------------------------------------------------------------------------------
+ * Get widget table
+ *--------------------------------------------------------------------------------*/
+static bool widget_get(State_t screen, Widget_t const **widget, int *n) {
+  switch (screen) {
+    case STATE_MAIN:
+      *widget = widget_main;
+      *n = N_WIDGETS(widget_main);
+      return true;
+
+    case STATE_CONFIGURATION:
+      *widget = widget_configuration;
+      *n = N_WIDGETS(widget_configuration);
+      return true;
+
+    case STATE_RESOLUTION:
+      *widget = widget_resolution;
+      *n = N_WIDGETS(widget_resolution);
+      return true;
+
+    case STATE_THERMOGRAPH:
+      *widget = widget_thermograph;
+      *n = N_WIDGETS(widget_thermograph);
+      return true;
+
+    case STATE_FILE_MANAGER:
+      *widget = widget_file_manager;
+      *n = N_WIDGETS(widget_file_manager);
+      return true;
+
+    case STATE_FILE_CONFIRM:
+      *widget = widget_file_confirm;
+      *n = N_WIDGETS(widget_file_confirm);
+      return true;
+
+    case STATE_CAPTURE_MODE:
+      *widget = widget_capture_mode;
+      *n = N_WIDGETS(widget_capture_mode);
+      return true;
+
+    case STATE_CALIBRATION:
+      *widget = widget_calibration;
+      *n = N_WIDGETS(widget_calibration);
+      return true;
+
+    case STATE_ADJUST_OFFSET:
+      *widget = widget_adjust_offset;
+      *n = N_WIDGETS(widget_adjust_offset);
+      return true;
+
+    case STATE_INFORMATION:
+      *widget = widget_information;
+      *n = N_WIDGETS(widget_information);
+      return true;
+
+    case STATE_ON:
+    default:
+      return false;
+  }
+}
+
+/*--------------------------------------------------------------------------------
+ * Handle the widget events on screen
+ *--------------------------------------------------------------------------------*/
+static bool widget_event(const Widget_t *widgets, const size_t n_widgets, Touch_t &touch) {
+  Event_t event = touch.event;
+
+  if (focus == NULL) {
+    for (int i = 0; i < n_widgets; ++i) {
+      // In case the touch events to be handled
+      if ((widgets[i].event & touch.event) && widgets[i].callback) {
+        // Focus the widget where the event fired
+        if (widgets[i].x <= touch.x && touch.x <= widgets[i].x + widgets[i].w &&
+            widgets[i].y <= touch.y && touch.y <= widgets[i].y + widgets[i].h) {
+          focus = &widgets[i];
+          break;
+        }
+      }
+    }
+  }
+
+  // execute the callback function for the focused widget
+  if (focus && (focus->event & touch.event)) {
+    // DBG_EXEC(printf("event = %d(%d), x = %d, y = %d\n", touch.event, focus->event, touch.x, touch.y));
+    touch.event = (Event_t)(touch.event & focus->event); // mask by target event
+    focus->callback(focus, touch);
+  }
+
+  // reset focus when touch leaves screen
+  focus = (event & EVENT_RISING ? NULL : focus);
+
+  return (focus != NULL);
+}
+
+/*--------------------------------------------------------------------------------
+ * Watch events on a specific screen
+ *--------------------------------------------------------------------------------*/
+static bool widget_watch(const Widget_t *widgets, const size_t n_widgets) {
+  Touch_t touch;
+
+  if (touch_event(touch)) {
+    // Returns true when the touch event is handled by a widget
+    if (widget_event(widgets, n_widgets, touch) == true) {
+      return true;
+    }
+  }
+
+  // Execute a special callback every watch cycle
+  else if (widgets[n_widgets-1].event == EVENT_WATCH) {
+    widgets[n_widgets-1].callback(&widgets[n_widgets-1], doInit);
+    return true;
+  }
+
+  return false;
+}
+
+/*--------------------------------------------------------------------------------
+ * Draw all widgets at the start of each state
+ *--------------------------------------------------------------------------------*/
+void widget_setup(State_t screen /* = STATE_ON */) {
+  int n;
+  Widget_t const *widget;
+
+  // reset focused widget
+  focus = NULL;
+
+  if (widget_get(screen, &widget, &n)) {
+    for (int i = 0; i < n; ++i, ++widget) {
+      if (widget->callback) {
+        widget->callback(widget, doInit);
+      }
+      CHECK_WIDGET_AREA(drawRect(widget->x, widget->y, widget->w, widget->h, TFT_RED));
+    }
+  }
+}
+
+/*--------------------------------------------------------------------------------
+ * Change state
+ *--------------------------------------------------------------------------------*/
+void widget_state(State_t screen /*= STATE_ON */) {
+  touch_clear();
+  widget_setup(state = screen);
+}
+
+/*--------------------------------------------------------------------------------
+ * Finite State Machines
+ *--------------------------------------------------------------------------------*/
+State_t widget_control(void) {
+  int n;
+  Widget_t const *widget;
+
+  switch (state) {
+    case STATE_MAIN:
+    case STATE_THERMOGRAPH:
+      if (widget_get(state, &widget, &n)) {
+        widget_watch(widget, n);
+      }
+      break;
+
+    case STATE_CONFIGURATION:
+    case STATE_RESOLUTION:
+    case STATE_FILE_MANAGER:
+    case STATE_FILE_CONFIRM:
+    case STATE_CAPTURE_MODE:
+    case STATE_CALIBRATION:
+    case STATE_ADJUST_OFFSET:
+    case STATE_INFORMATION:
+      if (widget_get(state, &widget, &n)) {
+        State_t initial = state;
+        do {
+          widget_watch(widget, n);
+          delay(1); // reset wdt
+        } while (state == initial);
+      }
+      break;
+
+    case STATE_ON:
+    default:
+      widget_state(STATE_MAIN);
+      break;
+  }
+
+  return state;
+}