diagram.json

#ifndef _UTILS_H_
#define _UTILS_H_

typedef enum {
  none = 0x1FFFF, // basically simulating transparent, just makes any display draw return immediately instead of printing the pixels to the display, leaving the current pixels displayed
	white = 0xFFFF,
  black = 0x0001, // cannot use 0 as it is the default value for uninitialized structs 

  light_grey = 0xBDF7,
  dark_grey = 0x7BEF,
  light_gray = light_grey, // 'mericans
  dark_gray = dark_grey,
  
  red = 0xF800,
  yellow = 0xFFE0,
  orange = 0xFBE0,
  
  brown = 0x79E0,
  
  light_green = 0x7E0,
  dark_green = 0x0603,

  cyan = 0x7FF,
  blue = 0x1F,
  
  beige = 0xe5d6,
  pink = 0xF81F,
  purple = 0xb81f
} color_t;

typedef enum {
  north = 0,
  east = 1,
  south = 2,
  west = 3
} side_t;

#define SIZE_OF(x) sizeof(x)/sizeof(x[0])

#define NO_DATA 0

typedef enum {
  hard_fault = 2, // dit. not. work
  soft_fault = 1, // something went wrong, but the main goal of the function was fulfilled
  success = 0// like . . . do I need to explain ?
} return_code_t;


/*
struct rect_one_s { // defined by one point and a height/width
  uint16_t x, y, height, width;
};
struct rect_two_s { // defined by two opposing corners
  uint16_t x1, y1, x2, y2;
};
struct rect_side_s { // defined by a side, an offset from the left wall (with the selected side facing you) and a height/width (from that side)
  side_t side;
  uint16_t left_offset;
  uint16_t height;
  uint16_t width;
};

static inline rect_two_s to_rect_one (rect_one_s rect_one) {
  return rect_two_s {
    rect_one.x,
    rect_one.y,
    rect_one.x + rect_one.width,
    rect_one.y + rect_one.height
  };
}
*/
/*
static inline rect_two_s to_rect_one(rect_side_s rect_side) {
  switch (rect_side.side){
    case north :

      break;
    case south : 

      break;
  }
}
*/

#endif

utils.h

#ifndef _SETTINGS_H_
#define _SETTINGS_H_

// ================= DISPLAY ================= //

#define DISPLAY_INSTANCE 123 // SPI peripheral adress to use
#define DISPLAY_TRANS_TIMEOUT 1 // ms, timeout before transmission to display is aborted

#define DISPLAY_CS_PORT 123
#define DISPLAY_CS_PIN 10
#define DISPLAY_DC_PORT 123
#define DISPLAY_DC_PIN 9
#define DISPLAY_RST_PORT 123
#define DISPLAY_RST_PIN 8

//#define STRING_WRAP // Comment to disable text wraping when reaching right side of screen

// ================= MAIN MENU ================= //

#define DEFAULT_TILE_HEIGHT       40 // px
#define DEFAULT_TILE_COLOR        white // color_t (see utils.h)
#define DEFAULT_HEADER_COLOR      black // color_t (see utils.h)
#define DEFAULT_TILE_BACKGROUND   light_gray // color_t (see utils.h)

#define TILE_HEADER_FONT          Font_7x10 // font_s (see font.h)
#define TILE_HEADER_OFFSET        1 // px

#define DATA_VIEW_LATERAL_OFFSET  3 //px
#define DATA_VIEW_VERTICAL_OFFSET 3 //px
#define DATA_VIEW_HEIGHT          11 //px, not including bottom line
#define DATA_VIEW_DEFAULT_COLOR   dark_green

// ================= INTERACTABLES ================= //

#define DEFAULT_INTERACTABLES_HEADER_FONT Font_7x10 // font_s (see font.h)
#define CHECKBOX_SIZE                     (interactable -> gfx.height -10) // px, lenght of the sides of the box
#define CHECKBOX_LEFT_OFFSET              5
#define CHECKBOX_COLOR                    dark_green
#define INCREMENT_SIGNS_OFFSET            5

// ================= DATA STREAMS ================= //

#define DATA_STREAM_TYPE int16_t // has to be signed !
#define DATA_STREAM_MAX_VALUE 1023 // has to be enough for stuff like servos





// ================= Menus ================= // 

#define DEFAULT_MENU_COLOR white
#define DEFAULT_MENU_BACKGROUND black

// ================= Graphics Items ================= // 

#define DEFAULT_ITEM_COLOR white
#define DEFAULT_ITEM_BACKGROUND black

// Progress Bars //
#define DEFAULT_INFILL_COLOR blue




#endif

settings.h

#ifndef _DEBUG_H_
#define _DEBUG_H_

#include "HAL.h"

// TODO :
// add line logging to crash
// add fast way to know if logging or displaying is required (implement priorities)

typedef enum{
  crash = -2, // unexpected state that might lead to unintended behaviour. a debug message with this flag reboots the board
  hardware_fault = -1, // could not communicate with an onboard peripheral

  missing_init,
  ui_config,

  milestone = 1, // major waypoint in code
  info = 0 // general purpose information
} severity_t;


void debug(char* message, severity_t severity){
  char* prefix = "";

  switch (severity){
    case crash :
      prefix = "BOARD CRASH !!! ";
      break;
  };

  char end_message[40];
  sprintf(end_message,"[DBG] %s : %s \n",prefix,message);
  Serial_print(end_message);

  if (severity == crash){
    while(true) {
      //Serial.println("restarting...");
      NVIC_SystemReset();
    }
  }
}

#endif

debug.h

#include <Wire.h>
#include <EEPROM.h>
#include <SPI.h>
#include "touch_driver.h"
#include "ILI9341_driver.h"
#include "GFX.h"

#include "settings.h"
#include "utils.h"

#include "runtime.c"

void setup() {
  Serial.begin(115200);
  SPI.begin();

  pinMode(DISPLAY_DC_PIN, OUTPUT);
  pinMode(DISPLAY_CS_PIN, OUTPUT);
  digitalWrite(DISPLAY_CS_PIN, HIGH);

  user_setup();
}

void loop() {
  user_loop();
}


bridge.ino

font.h

#ifndef _GFX_H_
#define _GFX_H_

#include "settings.h"
#include "utils.h"
#include "font.h"
#include "ILI9341_driver.h"

void drawPixel(uint16_t X, uint16_t Y, color_t color);

void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color);
void drawArbitraryLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color); // if you know your line isn't straight (ie. vertical or horizontal), you can call this function directly, but it'll be called by drawLine anyways

void drawRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color);
void fillRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color);

// with X,Y the circle center
void drawCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color);
void fillCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color);

void drawChar(uint16_t x, uint16_t y, side_t orientation, char c, font_s font, color_t color, color_t background);
void drawString(uint16_t x, uint16_t y, side_t orientation, const char* str, font_s font, color_t color, color_t background);
/*

//USING CONVERTER: http://www.digole.com/tools/PicturetoC_Hex_converter.php
//65K colour (2Bytes / Pixel)
void ILI9341_Draw_Image(const char* Image_Array, uint8_t Orientation);

*/

void drawPixel(uint16_t X, uint16_t Y, color_t color) {
  displayDrawPixel(X, Y, color);
}

// might be from adafruit GFX . . . who knows . . .
void drawArbitraryLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color) {
  int16_t steep = abs(y1 - y0) > abs(x1 - x0);
  if (steep) {
    int16_t z;
    z = x0;
    x0 = y0;
    y0 = z;

    z = x1;
    x1 = y1;
    y1 = z;
  }

  if (x0 > x1) {
    int16_t z;
    z = x0;
    x0 = x1;
    x1 = z;

    z = y0;
    y0 = y1;
    y1 = z;
  }

  int16_t dx, dy;
  dx = x1 - x0;
  dy = abs(y1 - y0);

  int16_t err = dx / 2;
  int16_t ystep;

  if (y0 < y1) {
    ystep = 1;
  } else {
    ystep = -1;
  }

  for (; x0 <= x1; x0++) {
    if (steep) {
      displayDrawPixel(y0, x0, color);
    } else {
      displayDrawPixel(x0, y0, color);
    }
    err -= dy;
    if (err < 0) {
      y0 += ystep;
      err += dx;
    }
  }
}

void drawLine(int16_t X1, int16_t Y1, int16_t X2, int16_t Y2, color_t color) {
  if (X1 == X2 || Y1 == Y2) displayDraw(X1, Y1, X2, Y2, color);
  else drawArbitraryLine(X1, Y1, X2, Y2, color);
}

void drawRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  displayDraw(X1, Y1, X1, Y2, color);
  displayDraw(X2, Y1, X2, Y2, color);
  displayDraw(X1, Y1, X2, Y1, color);
  displayDraw(X1, Y2, X2, Y2, color);
}

void fillRectangle(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  displayDraw(X1, Y1, X2, Y2, color);
}

void fillCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color) {
  int x = radius - 1;
  int y = 0;
  int dx = 1;
  int dy = 1;
  int err = dx - (radius << 1);

  while (x >= y) {
    displayDraw(X - y, Y + x, X + y, Y + x, color);
    displayDraw(X - x, Y + y, X + x, Y + y, color);
    displayDraw(X - x, Y - y, X + x, Y - y, color);
    displayDraw(X - y, Y - x, X + y, Y - x, color);

    if (err <= 0) {
      y++;
      err += dy;
      dy += 2;
    }
    if (err > 0) {
      x--;
      dx += 2;
      err += (-radius << 1) + dx;
    }
  }
}

//Draw hollow circle at X,Y location with specified radius and colour. X and Y represent circles center
void drawCircle(uint16_t X, uint16_t Y, uint16_t radius, color_t color) {
  int x = radius - 1;
  int y = 0;
  int dx = 1;
  int dy = 1;
  int err = dx - (radius << 1);

  while (x >= y) {
    displayDrawPixel(X + x, Y + y, color);
    displayDrawPixel(X + y, Y + x, color);
    displayDrawPixel(X - y, Y + x, color);
    displayDrawPixel(X - x, Y + y, color);
    displayDrawPixel(X - x, Y - y, color);
    displayDrawPixel(X - y, Y - x, color);
    displayDrawPixel(X + y, Y - x, color);
    displayDrawPixel(X + x, Y - y, color);

    if (err <= 0) {
      y++;
      err += dy;
      dy += 2;
    }
    if (err > 0) {
      x--;
      dx += 2;
      err += (-radius << 1) + dx;
    }
  }
}

void drawChar(uint16_t x, uint16_t y, side_t orientation, char c, font_s font, color_t color, color_t background){
  uint8_t i, j;
  uint16_t b;
  
  if(background != none) // avoid tons of coordinates calculations to pass to the function . . . just not to draw the rectangle
    switch (orientation){
      case south : displayDraw(x,y - 1,x + font.width - 1, y + font.height,background); break;
      case north : displayDraw(x - font.width - 1,y - font.height,x, y + 1,background); break;
      case east : displayDraw(x - 1,y - font.width + 1,x + font.height, y,background); break;
      case west : displayDraw(x - font.height,y,x + 1, y + font.width - 1,background); break;
    }

  for(i = 0; i < font.height; i++) {
    b = font.data[(c - 32) * font.height + i];
    for(j = 0; j < font.width; j++) {
      if((b << j) & 0x8000)  {
        switch (orientation){
          case south : displayDrawPixel(x + j, y + i,color); break;
          case north : displayDrawPixel(x - j, y - i,color); break;
          case east : displayDrawPixel(x + i,y - j,color); break;
          case west : displayDrawPixel(x - i,y + j,color); break;
        }
      }
    }
  }
}

void drawString(uint16_t x, uint16_t y, side_t orientation, const char* str, font_s font, color_t color, color_t background) {
  uint8_t lenght = strlen(str);
/*
  if(center) {
    x -= (lenght * font.width)/2;
    y -= font.height/2;
  }
*/
  for (uint8_t i = 0; i < lenght; i++) {
    #ifdef STRING_WRAP
    if(x + font.width >= DISPLAY_WIDTH) {
      x = 0;
      y += font.height;
      if(y + font.height >= DISPLAY_HEIGHT) {
        break;
      } 

      if(*str == ' ') {
        // skip spaces in the beginning of the new line
        str++;
        continue;
      }
    }
    #endif 

    drawChar(x, y, orientation, str[i], font, color, background);

    switch (orientation){
      case south : x += font.width; break;
      case north : x -= font.width; break;
      case east : y -= font.width; break;
      case west : y += font.width; break;
    }
  }
}

#endif


GFX.h

#ifndef _ILI9341_DRIVER_H_
#define _ILI9341_DRIVER_H_

#include "HAL.h"

#include "settings.h"
#include "utils.h"

#define DISPLAY_WIDTH 240
#define DISPLAY_HEIGHT 320

typedef enum {
  data_mode = GPIO_PIN_SET,
  command_mode = GPIO_PIN_RESET
} display_mode_t;

static uint8_t buffer[20]; // note : adress 0 is the command, next adresses are the data

// ================================ Hardware abstraction ================================ //

static void displayMode(display_mode_t mode) {
  HAL_GPIO_WritePin(DISPLAY_DC_PORT, DISPLAY_DC_PIN, mode);
}

static void displaySelect(bool state) {
  HAL_GPIO_WritePin(DISPLAY_CS_PORT, DISPLAY_CS_PIN, !state);
}

// ================================ Low level ================================ //

// Send command (char) to LCD
static void displayWrite(uint8_t *data_buffer, uint16_t lenght, display_mode_t mode) {
  displayMode(mode);
  HAL_SPI_Transmit(DISPLAY_INSTANCE, data_buffer, lenght, DISPLAY_TRANS_TIMEOUT);
}
void displaySend(uint8_t *data_buffer, uint16_t lenght) { // data_buffer[0] should be the command byte, lenght is the number of DATA BYTES (not including the command byte)
  displaySelect(true);
  displayWrite(&data_buffer[0], 1, command_mode);
  if (lenght != 0) displayWrite(&data_buffer[1], lenght, data_mode);
  displaySelect(false);
}
void displayCommand(uint8_t command) {
  displaySelect(true);
  displayWrite(&command, 1, command_mode);
  displaySelect(false);
}

//HARDWARE RESET
static void displayReset(void) {
  HAL_GPIO_WritePin(DISPLAY_RST_PORT, DISPLAY_RST_PIN, GPIO_PIN_RESET);
  displaySelect(false);
  HAL_Delay(200);
  HAL_GPIO_WritePin(DISPLAY_RST_PORT, DISPLAY_RST_PIN, GPIO_PIN_SET);
}

//Initialize LCD display
static void displayInit(void) {

  displayReset();

  //SOFTWARE RESET
  displayCommand(0x01);
  //HAL_Delay(1000);
  HAL_Delay(200);

  //POWER CONTROL A
  buffer[0] = 0xCB;
  buffer[1] = 0x39;
  buffer[2] = 0x2C;
  buffer[3] = 0x00;
  buffer[4] = 0x34;
  buffer[5] = 0x02;
  displaySend(buffer, 5);

  //POWER CONTROL B
  buffer[0] = 0xCF;
  buffer[1] = 0x00;
  buffer[2] = 0xC1;
  buffer[3] = 0x30;
  displaySend(buffer, 3);

  //DRIVER TIMING CONTROL A
  buffer[0] = 0xE8;
  buffer[1] = 0x85;
  buffer[2] = 0x00;
  buffer[3] = 0x78;
  displaySend(buffer, 3);

  //DRIVER TIMING CONTROL B
  buffer[0] = 0xEA;
  buffer[1] = 0x00;
  buffer[2] = 0x00;
  displaySend(buffer, 2);

  //POWER ON SEQUENCE CONTROL
  buffer[0] = 0xED;
  buffer[1] = 0x64;
  buffer[2] = 0x03;
  buffer[3] = 0x12;
  buffer[4] = 0x81;
  displaySend(buffer, 4);

  //PUMP RATIO CONTROL
  buffer[0] = 0xF7;
  buffer[1] = 0x20;
  displaySend(buffer, 1);

  //POWER CONTROL,VRH[5:0]
  buffer[0] = 0xC0;
  buffer[1] = 0x23;
  displaySend(buffer, 1);

  //POWER CONTROL,SAP[2:0];BT[3:0]
  buffer[0] = 0xC1;
  buffer[1] = 0x10;
  displaySend(buffer, 1);

  //VCM CONTROL
  buffer[0] = 0xC5;
  buffer[1] = 0x3E;
  buffer[2] = 0x28;
  displaySend(buffer, 2);

  //VCM CONTROL 2
  buffer[0] = 0xC7;
  buffer[1] = 0x86;
  displaySend(buffer, 1);

  //MEMORY ACCESS CONTROL
  buffer[0] = 0x36;
  buffer[1] = 0x48;
  displaySend(buffer, 1);

  //PIXEL FORMAT
  buffer[0] = 0x3A;
  buffer[1] = 0x55;
  displaySend(buffer, 1);

  //FRAME RATIO CONTROL, STANDARD RGB COLOR
  buffer[0] = 0xB1;
  buffer[1] = 0x00;
  buffer[2] = 0x18;
  displaySend(buffer, 2);

  //DISPLAY FUNCTION CONTROL
  buffer[0] = 0xB6;
  buffer[1] = 0x08;
  buffer[2] = 0x82;
  buffer[3] = 0x27;
  displaySend(buffer, 3);

  //3GAMMA FUNCTION DISABLE
  buffer[0] = 0xF2;
  buffer[1] = 0x00;
  displaySend(buffer, 1);

  //GAMMA CURVE SELECTED
  buffer[0] = 0x26;
  buffer[1] = 0x01;
  displaySend(buffer, 1);

  //POSITIVE GAMMA CORRECTION
  buffer[0] = 0xE0;
  buffer[1] = 0x0F;
  buffer[2] = 0x31;
  buffer[3] = 0x2B;
  buffer[4] = 0x0C;
  buffer[5] = 0x0E;
  buffer[6] = 0x08;
  buffer[7] = 0x4E;
  buffer[8] = 0xF1;
  buffer[9] = 0x37;
  buffer[10] = 0x07;
  buffer[11] = 0x10;
  buffer[12] = 0x03;
  buffer[13] = 0x0E;
  buffer[14] = 0x09;
  buffer[15] = 0x00;
  displaySend(buffer, 15);

  //NEGATIVE GAMMA CORRECTION
  buffer[0] = 0xE1;
  buffer[1] = 0x00;
  buffer[2] = 0x0E;
  buffer[3] = 0x14;
  buffer[4] = 0x03;
  buffer[5] = 0x11;
  buffer[6] = 0x07;
  buffer[7] = 0x31;
  buffer[8] = 0xC1;
  buffer[9] = 0x48;
  buffer[10] = 0x08;
  buffer[11] = 0x0F;
  buffer[12] = 0x0C;
  buffer[13] = 0x31;
  buffer[14] = 0x36;
  buffer[15] = 0x0F;
  displaySend(buffer, 15);

  //EXIT SLEEP
  displayCommand(0x11);
  HAL_Delay(120);

  //TURN ON DISPLAY
  displayCommand(0x29);

  //SET ROTATION
  buffer[0] = 0x36;
  buffer[1] = 0x40|0x08;
  displaySend(buffer,1);
}

// ================================ Display primitives ================================ //

// TODO : optimize color sending (make less calls to HAL's function, using proper array dimensions)
//Set Address - Location block - to draw into
static void displayDraw(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  if(color == none) return;

  uint16_t Z;
  if(X1 > X2){
    Z = X2;
    X2 = X1;
    X1 = Z;
  }
  if(Y1 > Y2){
    Z = Y2;
    Y2 = Y1;
    Y1 = Z;
  }

  if(X1 >= DISPLAY_WIDTH || Y1 >= DISPLAY_HEIGHT || X2 < 0 || Y2 < 0) return; // trying to display outside of the screen

  if(X2 > DISPLAY_WIDTH -1) X2 = DISPLAY_WIDTH -1;
  if(Y2 > DISPLAY_HEIGHT -1) Y2 = DISPLAY_HEIGHT -1;
  if(X1 < 0) X1 = 0;
  if(Y1 < 0) Y1 = 0;
 
  buffer[0] = 0x2A;
  buffer[1] = X1 >> 8;
  buffer[2] = X1;
  buffer[3] = X2 >> 8;
  buffer[4] = X2;
  displaySend(buffer, 4);

  buffer[0] = 0x2B;
  buffer[1] = Y1 >> 8;
  buffer[2] = Y1;
  buffer[3] = Y2 >> 8;
  buffer[4] = Y2;
  displaySend(buffer, 4);

  uint32_t size = (uint32_t)(X2 - X1 +1) * (uint32_t)(Y2 - Y1 +1);

  // cannot use standard displaySend function due to the absolutely absurt amount of data sent out
  displaySelect(true);
  buffer[0] = 0x2C;
  displayWrite(buffer,1,command_mode);
  for(; size > 0; size--){  
    uint8_t data[] = {color >> 8,color & 0xFF};
    displayWrite(data,2,data_mode);
  }
  displaySelect(false);
}

//DRAW PIXEL AT XY POSITION WITH SELECTED COLOUR
//Using pixels to draw big simple structures is not recommended as it is really slow
//Try using either rectangles or lines if possible
static void displayDrawPixel(uint16_t X, uint16_t Y, color_t color) {
  if (color == none) return;
  if (X >= DISPLAY_WIDTH || Y >= DISPLAY_HEIGHT || X < 0 || Y < 0) return;	// Out of screen

  //XDATA
  buffer[0] = 0x2A;
  buffer[1] = X >> 8;
  buffer[2] = X;
  buffer[3] = (X) >> 8;
  buffer[4] = (X);
  displaySend(buffer, 4);

  //YDATA
  buffer[0] = 0x2B;
  buffer[1] = Y >> 8;
  buffer[2] = Y;
  buffer[3] = (Y) >> 8;
  buffer[4] = (Y);
  displaySend(buffer, 4);

  //COLOR
  buffer[0] = 0x2C;
  buffer[1] = color >> 8;
  buffer[2] = color;
  displaySend(buffer, 2);
}

// ================================ Graphics primitives ================================ //

// fill the entire screen with selected color (no effect if using "none" color obviously)
static void displayFill(color_t color) {
  displayDraw(0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1, color);
}

#endif



ILI9341_driver.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries



libraries.txt

#ifndef _HAL_H_
#define _HAL_H_

#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>

#define GPIO_PIN_SET 1
#define GPIO_PIN_RESET 0

#define HAL_MAX_DELAY 0xFFFF

#define STRUCT_FILLER 0

void NVIC_SystemReset(void);
void HAL_GPIO_WritePin(uint8_t port, uint8_t pin, bool value);
void HAL_SPI_Transmit(void *instance, uint8_t *data, uint16_t lenght, uint32_t timeout);
void HAL_Delay(uint16_t ms);
void HAL_I2C_Master_Transmit (void* instance, uint16_t addr, uint8_t *data, uint16_t lenght, uint32_t Timeout);
void HAL_I2C_Master_Receive (void* instance, uint16_t addr, uint8_t *data, uint16_t size, uint32_t Timeout);
void Serial_print(char* message);

#endif

HAL.h

#include <Arduino.h>
#include <SPI.h>
#include <Wire.h>

#include <avr/wdt.h>
void NVIC_SystemReset() {
  wdt_enable(WDTO_15MS);
  while (true);
}

void HAL_GPIO_WritePin(uint8_t port, uint8_t pin, bool value) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, value);
}

void HAL_SPI_Transmit(void *instance, uint8_t *data, uint16_t lenght, uint32_t timeout) {
  SPI.beginTransaction(SPISettings(20000000, MSBFIRST, SPI_MODE0));
  SPI.transfer(data, lenght);
  SPI.endTransaction();
}

void HAL_Delay(uint16_t ms) {
  delay(ms);
}

void HAL_I2C_Master_Transmit (void* instance, uint16_t addr, uint8_t *data, uint16_t lenght, uint32_t Timeout){
  Wire.beginTransmission((uint8_t)addr);
  Wire.write(data,lenght);
  Wire.endTransmission();
}

void HAL_I2C_Master_Receive (void* instance, uint16_t addr, uint8_t *data, uint16_t size, uint32_t Timeout){
  Wire.requestFrom((uint8_t)addr, size);
  for (uint16_t i = 0; i < size; i++)
    data[i] = Wire.read();
  Wire.endTransmission();
}

void Serial_print(char* message){
  Serial.print(message);
}

HAL.cpp

#ifndef _MAIN_MENU_TILES_H_
#define _MAIN_MENU_TILES_H_

/*
#include "utils.h"
#include "GFX.h"
#include "outputs.h"
#include "debug.h"
#include "graphics_item.h"

struct menu_tile_s {
  char* header;
  output_s* output;
  tile_view_t view_type;
  uint16_t left_offset;
  side_t side;
  uint16_t width;

  // optional
  uint8_t height;
  color_t view_color;
  color_t color;
  color_t header_color;
  color_t background;

  // do not populate
  uint16_t x1, y1, x2, y2; // absolute to screen coordinates, will be populated when the tile is drawn for the first time
  uint16_t header_x, header_y;
  data_view_s view1, view2;
  bool initialized;
  bool incoherent;
};

// approch here is that, since we have loads of ram, calculate all attributes in advance and store them, only retrieving them at drawing time, limiting CPU usage
// in a nutshell : trading ram for performance
static void initItem(menu_tile_s *tile){ 
  // initializes all missing parameters for a tile
  if(tile -> height == 0) tile -> height = DEFAULT_TILE_HEIGHT;
  if(tile -> color == 0) tile -> color = DEFAULT_TILE_COLOR;
  if(tile -> header_color == 0) tile -> header_color = DEFAULT_HEADER_COLOR;
  if(tile -> background == 0) tile -> background = DEFAULT_TILE_BACKGROUND;
  if(tile -> view_color == 0) tile -> view_color = DATA_VIEW_DEFAULT_COLOR;

  tile -> view1.color = tile -> view_color;
  tile -> view1.background = &(tile -> background);
  tile -> view2.color = tile -> view_color;
  tile -> view2.background = &(tile -> background);

  // initializes all relevant coordinates (kinda ugly to do it this way, but don't really have the choice)
  switch (tile -> side){
    case north :
      // calculate tile coordinates
      tile -> x1 = DISPLAY_WIDTH - tile -> left_offset - tile -> width;
      tile -> y1 = 0;
      tile -> x2 = DISPLAY_WIDTH - tile -> left_offset;
      tile -> y2 = tile -> height;

      // calculate header coordinates
      tile -> header_x = tile->x1 + tile->width/2 + strlen(tile->header)*TILE_HEADER_FONT.width/2 -1;
      tile -> header_y = TILE_HEADER_FONT.height + TILE_HEADER_OFFSET;

      // calculate data view coordinates
      tile -> view1.x1 = tile -> x1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_VERTICAL_OFFSET -1;
      tile -> view1.y1 = tile -> view1.y2 - DATA_VIEW_HEIGHT +1; 

      if(tile -> view_type == progress_bars){ // need to divide the space in two bars in this case
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x2 = tile -> view1.x2;
        
        tile -> view1.y1 += DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.y2 = tile -> view1.y1 -2;
      }

      // add data view attributes
      tile -> view1.invert = true;
      tile -> view2.invert = true;
      break;
    case south :
      tile -> x1 = tile -> left_offset;
      tile -> y1 = DISPLAY_HEIGHT -1 - tile -> height;
      tile -> x2 = tile -> left_offset + tile -> width;
      tile -> y2 = DISPLAY_HEIGHT -1;

      tile -> header_x = tile->x1 + tile->width/2 - strlen(tile->header)*TILE_HEADER_FONT.width/2 +1;
      tile -> header_y = DISPLAY_HEIGHT -1 - TILE_HEADER_FONT.height - TILE_HEADER_OFFSET;

      tile -> view1.x1 = tile -> x1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_VERTICAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.y2 = tile -> view1.y1 + DATA_VIEW_HEIGHT -1;

      if(tile -> view_type == progress_bars){
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y2 = tile -> view1.y2;
        tile -> view2.x2 = tile -> view1.x2;
        
        tile -> view1.y2 -= DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.y1 = tile -> view1.y2 +2;
      }

      break;
    case east :
      tile -> x1 = DISPLAY_WIDTH -1 - tile -> height;
      tile -> y1 = DISPLAY_HEIGHT - (tile -> left_offset + tile -> width);
      tile -> x2 = DISPLAY_WIDTH -1;
      tile -> y2 = DISPLAY_HEIGHT - tile -> left_offset -1;

      tile -> header_x = DISPLAY_WIDTH -1 - TILE_HEADER_FONT.height - TILE_HEADER_OFFSET;
      tile -> header_y = tile->y1 + tile->width/2 + strlen(tile->header)*TILE_HEADER_FONT.width/2 -1;
      
      tile -> view1.x1 = tile -> x1 + DATA_VIEW_VERTICAL_OFFSET +1;
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> view1.x1 + DATA_VIEW_HEIGHT -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_LATERAL_OFFSET -1;

      if(tile -> view_type == progress_bars){
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x2 = tile -> view1.x2;
        tile -> view2.y2 = tile -> view1.y2;
        
        tile -> view1.x2 -= DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.x1 = tile -> view1.x2 +2;
      }

      tile -> view1.vertical = true;
      tile -> view1.invert = true;
      tile -> view2.vertical = true;
      tile -> view2.invert = true;
      break;
    case west :
      tile -> x1 = 0;
      tile -> y1 = tile -> left_offset;
      tile -> x2 = tile -> height;
      tile -> y2 = tile -> left_offset + tile -> width;

      tile -> header_x = TILE_HEADER_FONT.height + TILE_HEADER_OFFSET;
      tile -> header_y = tile->y1 + tile->width/2 - strlen(tile->header)*TILE_HEADER_FONT.width/2 +1;
      
      tile -> view1.y1 = tile -> y1 + DATA_VIEW_LATERAL_OFFSET +1;
      tile -> view1.x2 = tile -> x2 - DATA_VIEW_VERTICAL_OFFSET -1;
      tile -> view1.y2 = tile -> y2 - DATA_VIEW_LATERAL_OFFSET -1;
      tile -> view1.x1 = tile -> view1.x2 - DATA_VIEW_HEIGHT +1;
      
      if(tile -> view_type == progress_bars){
        tile -> view2.y1 = tile -> view1.y1;
        tile -> view2.x1 = tile -> view1.x1;
        tile -> view2.y2 = tile -> view1.y2;
        
        tile -> view1.x1 += DATA_VIEW_HEIGHT/2 + 1;
        tile -> view2.x2 = tile -> view1.x1 -2;
      }
      
      tile -> view1.vertical = true;
      tile -> view2.vertical = true;
      break;
  }

  // determine if tile config is coherent (mostly if it is in screen)
  if (  tile -> x1 < 0 ||
        tile -> y1 < 0 ||
        tile -> x2 >= DISPLAY_WIDTH || 
        tile -> y2 >= DISPLAY_HEIGHT
  ){
    debug("tile config incoherent, cannot display", tile_config);
    debug(tile -> header, tile_config);
    tile -> incoherent = true;
  } else {
    tile -> incoherent = false; // might do dynamic tile modifications at some point, so we want to be able to clear this flag if we run init again
  }

  tile -> initialized = true;
}

static void updateItem(menu_tile_s *tile){
  if(tile -> incoherent) return;
    
  switch (tile -> view_type){
    case progress_bars :
      updateItem(&(tile -> view2), tile -> output -> data2);    
    case progress_bar :
      updateItem(&(tile -> view1), tile -> output -> data1);    
      break;
  }
}

static void drawItem(menu_tile_s *tile){ // display a tile in absolute coordinates on a specified side
  if(!tile->initialized) initItem(tile);
  if(tile -> incoherent) return;

  // tile itself and background
  fillRectangle(tile -> x1,tile -> y1,tile -> x2,tile -> y2,tile -> background);
  drawRectangle(tile -> x1,tile -> y1,tile -> x2,tile -> y2,tile -> color);

  //header
  drawString(tile -> header_x, tile -> header_y, tile -> side, tile -> header, TILE_HEADER_FONT, tile -> header_color, none);
  
  // data view outline
  switch (tile -> view_type){
    case progress_bars :
      drawRectangle(tile -> view2.x1 -1, tile -> view2.y1 -1, tile -> view2.x2 +1, tile -> view2.y2 +1,tile -> color);
    case progress_bar:
      drawRectangle(tile -> view1.x1 -1, tile -> view1.y1 -1, tile -> view1.x2 +1, tile -> view1.y2 +1,tile -> color);
      break;
  }
}

static bool isInside(menu_tile_s *tile, uint16_t x, uint16_t y){
  return (x >= tile -> x1 && x <= tile -> x2 && y >= tile -> y1 && y <= tile -> y2);
}

*/
#endif

main_menu_tiles.h

#ifndef _OUTPUTS_H_
#define _OUTPUTS_H_

typedef enum{
  not_output_type = 0,
  servo,
  pwm,
  analog,

} output_types_t;

struct output_s {
  output_types_t type;
  DATA_STREAM_TYPE data1;
  DATA_STREAM_TYPE data2;

  bool can_reverse;
};

#endif

outputs.h

#ifndef _PROGRESS_BAR_H_
#define _PROGRESS_BAR_H_

#include "HAL.h"

#include "utils.h"
#include "settings.h"
#include "graphics_item.h"
#include "debug.h"

typedef struct progress_bar_s{
  graphics_attributes_s gfx;

  color_t infill;

  // optional (defaults to left ot right, horizontal to allow for easy general progress bar implementation)
  bool vertical;
  bool invert;
  bool can_reverse;
} progress_bar_s;

static return_code_t initBar(progress_bar_s *bar){
  return_code_t to_return = success;
  bar -> gfx.type = progress_bar;

  if (bar -> gfx.x2 == NO_DATA) bar -> gfx.x2 = bar -> gfx.x + bar -> gfx.width;
  if (bar -> gfx.y2 == NO_DATA) bar -> gfx.y2 = bar -> gfx.y + bar -> gfx.height;

  if (bar -> gfx.color == NO_DATA) bar -> gfx.color = DEFAULT_ITEM_COLOR;
  if (bar -> infill == NO_DATA) bar -> infill = DEFAULT_INFILL_COLOR;
  if (bar -> gfx.background == NO_DATA) bar -> gfx.background = DEFAULT_ITEM_BACKGROUND;

  if (bar -> gfx.x == bar -> gfx.x2 || bar -> gfx.y == bar -> gfx.y2){
    bar -> gfx.incoherent = true; 
    to_return = hard_fault;
  }

  if (to_return != success) debug("bar init failed",ui_config);
  return to_return;
}

static void updateBar(progress_bar_s *bar){

}

static return_code_t moveBar(progress_bar_s *bar, uint16_t offset_x, uint16_t offset_y){
  bar -> gfx.x += offset_x;
  bar -> gfx.y += offset_y;

  bar -> gfx.x2 += offset_x;
  bar -> gfx.y2 += offset_y;
}

static return_code_t drawBar(progress_bar_s *bar){
  fillRectangle(bar->gfx.x, bar->gfx.y, bar->gfx.x2, bar->gfx.y2, bar->gfx.background);
  drawRectangle(bar->gfx.x, bar->gfx.y, bar->gfx.x2, bar->gfx.y2, bar->gfx.color);
  updateBar(bar);
}







/*
static void updateItem(data_view_s *view, DATA_STREAM_TYPE new_data){
  if(new_data == view -> old_data) return;
  view -> old_data = new_data;

  int16_t lower_bound = view -> can_reverse ? -DATA_STREAM_MAX_VALUE : 0;
  int16_t upper_bound = DATA_STREAM_MAX_VALUE;

  int16_t value = map(
    new_data,
    lower_bound,
    upper_bound,
    0,
    (view -> vertical ? view -> y2 - view -> y1 : view -> x2 - view -> x1) //full infill and no infill are reserved for absolute max and 0
  );

  if (value == view -> old_value) return;
  view -> old_value = value;

  if (view -> vertical){
    // mask off previous bar
    if (new_data != DATA_STREAM_MAX_VALUE) fillRectangle(view -> x1, view -> y1 + value, view -> x2, view -> y2,*(view -> background));
    // fill new bar
    if (new_data != 0) fillRectangle(view -> x1, view -> y1, view -> x2, view -> y1 + value,view -> color);
  } else {
    if (new_data != DATA_STREAM_MAX_VALUE) fillRectangle(view -> x1 + value, view -> y1, view -> x2, view -> y2,*(view -> background));
    if (new_data != 0) fillRectangle(view -> x1, view -> y1, view -> x1 + value, view -> y2,view -> color);
  }
}
*/

#endif

progress_bar.h

#ifndef _TOUCH_C_
#define _TOUCH_C_

// Quick and dirty driver for the touch ic, intended to be replaced on final hardware

#include "HAL.h"

#define FT62XX_DEFAULT_ADDR 0x38   //!< I2C address
#define FT62XX_G_FT5201ID 0xA8     //!< FocalTech's panel ID
#define FT62XX_REG_NUMTOUCHES 0x02 //!< Number of touch points

#define FT62XX_NUM_X 0x33 //!< Touch X position
#define FT62XX_NUM_Y 0x34 //!< Touch Y position

#define FT62XX_REG_MODE 0x00        //!< Device mode, either WORKING or FACTORY
#define FT62XX_REG_CALIBRATE 0x02   //!< Calibrate mode
#define FT62XX_REG_WORKMODE 0x00    //!< Work mode
#define FT62XX_REG_FACTORYMODE 0x40 //!< Factory mode
#define FT62XX_REG_THRESHHOLD 0x80  //!< Threshold for touch detection
#define FT62XX_REG_POINTRATE 0x88   //!< Point rate
#define FT62XX_REG_FIRMVERS 0xA6    //!< Firmware version
#define FT62XX_REG_CHIPID 0xA3      //!< Chip selecting
#define FT62XX_REG_VENDID 0xA8      //!< FocalTech's panel ID

#define FT62XX_VENDID 0x11  //!< FocalTech's panel ID
#define FT6206_CHIPID 0x06  //!< Chip selecting
#define FT6236_CHIPID 0x36  //!< Chip selecting
#define FT6236U_CHIPID 0x64 //!< Chip selecting
#define FT6336U_CHIPID 0x64 //!< Chip selecting

// calibrated for Adafruit 2.8" ctp screen
#define FT62XX_DEFAULT_THRESHOLD 0 //!< Default threshold for touch detection

uint16_t touchX, touchY;
uint16_t max_x, max_y;

// ================================ Low level ================================ //

uint8_t ftReadRegister8(uint8_t reg) {
  uint8_t buffer[1] = {reg};
  HAL_I2C_Master_Transmit(123, FT62XX_DEFAULT_ADDR, buffer, 1, 123);
  HAL_I2C_Master_Receive(123, FT62XX_DEFAULT_ADDR, buffer, 1, 123);
  return buffer[0];
}

void ftWriteRegister8(uint8_t reg, uint8_t val) {
  uint8_t buffer[2] = {reg, val};
  HAL_I2C_Master_Transmit(123, FT62XX_DEFAULT_ADDR, buffer, 2, 123);
}

void ftReadData(void) {
  uint8_t data[16];
  uint8_t addr = 0;
  
  HAL_I2C_Master_Transmit (123, FT62XX_DEFAULT_ADDR, addr, 1, 123);
  HAL_I2C_Master_Receive (123, FT62XX_DEFAULT_ADDR, data, 16, 123);

  touchX = data[2] & 0x0F;
  touchX <<= 8;
  touchX |= data[3];
  touchY = data[4] & 0x0F;
  touchY <<= 8;
  touchY |= data[5];
/*
  for(int i = 0; i<16; i++){
    Serial.print(data[i],HEX);
    Serial.print(" ");
  }

  Serial.println();
*/
}
// ================================ High level ================================ //

bool touchInit() {
  // change threshhold to be higher/lower if desired
  ftWriteRegister8(FT62XX_REG_THRESHHOLD, FT62XX_DEFAULT_THRESHOLD);

  if (ftReadRegister8(FT62XX_REG_VENDID) != FT62XX_VENDID) {
    return false;
  }
  
  uint8_t id = ftReadRegister8(FT62XX_REG_CHIPID);
  if ((id != FT6206_CHIPID) && (id != FT6236_CHIPID) && (id != FT6236U_CHIPID) && (id != FT6336U_CHIPID)) {
    return false;
  }

  return true;
}

uint8_t ftTouched(void) {
  return ftReadRegister8(FT62XX_REG_NUMTOUCHES);
}

uint16_t ftGetX(void){
  return 240 - touchX;
}

uint16_t ftGetY(void){
  return 320 - touchY;
}

#endif

touch_driver.h

#ifndef _INTERACTABLES_H_
#define _INTERACTABLES_H_


/*
#include "graphics_item.h"

typedef enum interactable_t {
  no_interactable = 0,
  checkbox,
  yesno,
  list,
  button,
  slider,
  increment
};

struct checkbox_s {
  uint16_t box_x1, box_y1, box_x2, box_y2;
};

struct increment_s {
  uint16_t  line1_x, line2_x, line1_y, line2_y, // actually, y is the second point while x is the first (needed because coordinates for interactables are represented by height/width)
            minus_x1, minus_x2, minus_y, 
            plus_x1, plus_y1, plus_y2, 
            plus_x2, plus_x3, plus_y3,
            value_x, value_y;
};

struct interactable_s {
  graphics_attributes_s gfx;
  char* header;
  interactable_t type;
  font_s font;

  // optional
  DATA_STREAM_TYPE value;
  bool can_reverse;
  // TODO : pointeur sur fonction lors de l'update

  // do not populate
  union {
    checkbox_s checkbox;
    increment_s increment;
  };
  uint16_t header_x, header_y;
  DATA_STREAM_TYPE old_value;
};

// approch here is that, since we have loads of ram, calculate all attributes in advance and store them, only retrieving them at drawing time, limiting CPU usage
// in a nutshell : trading ram for performance
static void initItem(interactable_s *interactable){ 
  // initializes all missing parameters for the interactable
  if(interactable -> gfx.color == 0) interactable -> gfx.color = DEFAULT_TILE_COLOR;
  if(interactable -> gfx.background == 0) interactable -> gfx.background = DEFAULT_TILE_BACKGROUND;
  
  interactable -> header_x = interactable -> gfx.width/2 - strlen(interactable->header)*interactable -> font.width/2 +1;
  
  switch (interactable -> type){
    case checkbox:
      //interactable -> header_x += CHECKBOX_LEFT_OFFSET + CHECKBOX_SIZE; // actually looks better without it
      interactable -> header_y = interactable -> gfx.height/2 - interactable -> font.height/2;
      interactable -> checkbox.box_x1 = CHECKBOX_LEFT_OFFSET;
      interactable -> checkbox.box_y1 = interactable -> gfx.height/2 - CHECKBOX_SIZE/2;
      interactable -> checkbox.box_x2 = interactable -> checkbox.box_x1 + CHECKBOX_SIZE;
      interactable -> checkbox.box_y2 = interactable -> checkbox.box_y1 + CHECKBOX_SIZE;
      break;
    case increment :
      interactable -> increment.value_x = interactable -> gfx.width/2 - 4*interactable -> font.width/2 +1;
      interactable -> increment.value_y = interactable -> gfx.height/2 - interactable -> font.height/2;

      interactable -> increment.line1_x = interactable -> gfx.height;
      interactable -> increment.line1_y = interactable -> gfx.height;
      interactable -> increment.line2_x = interactable -> gfx.width - interactable -> gfx.height;
      interactable -> increment.line2_y = interactable -> gfx.height;

      interactable -> increment.minus_x1 = INCREMENT_SIGNS_OFFSET;
      interactable -> increment.minus_x2 = interactable -> increment.line1_x - INCREMENT_SIGNS_OFFSET;
      interactable -> increment.minus_y = interactable -> gfx.height/2; 

      interactable -> increment.plus_x1 = interactable -> increment.line2_x + (interactable -> gfx.width - interactable -> increment.line2_x)/2;
      interactable -> increment.plus_y1 = INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_y2 = interactable -> gfx.height - INCREMENT_SIGNS_OFFSET;

      interactable -> increment.plus_x2 = interactable -> gfx.width - INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_x3 = interactable -> increment.line2_x + INCREMENT_SIGNS_OFFSET;
      interactable -> increment.plus_y3 = interactable -> gfx.height/2;
      //interactable -> header_x = interactable->x + interactable->width/2 - 4*interactable -> font.width/2 +1;
      break;
  }

  interactable -> gfx.initialized = true;
}

static void updateItem(interactable_s *interactable){
  if(interactable -> gfx.incoherent) return;
  if(interactable -> value == interactable -> old_value) return;
  interactable -> old_value = interactable -> value;

  switch (interactable -> type){
    case checkbox :
      fillRectangle(interactable -> checkbox.box_x1 +1,interactable -> checkbox.box_y1 +1,interactable -> checkbox.box_x2 -1,interactable -> checkbox.box_y2 -1,(interactable -> value != 0 ? CHECKBOX_COLOR : black));
      break;
  }
}


static void drawItem(interactable_s *interactable, uint16_t x, uint16_t y){ // display a tile in absolute coordinates on a specified side
  if(!interactable -> gfx.initialized) initItem(interactable);
  if(interactable -> gfx.incoherent) return;

  // interactable itself and background
  fillRectangle(x +1,y +1,x + interactable -> gfx.width -1,y + interactable -> gfx.height -1,interactable -> gfx.background);
  drawRectangle(x,y,x + interactable -> gfx.width,y + interactable -> gfx.height,interactable -> gfx.color);

  //header
  drawString(interactable -> header_x, interactable -> header_y, south, interactable -> header, interactable -> font, interactable -> gfx.color, none); 

  switch (interactable -> type){
    case checkbox:
      drawRectangle(interactable -> checkbox.box_x1,interactable -> checkbox.box_y1,interactable -> checkbox.box_x2,interactable -> checkbox.box_y2,interactable -> gfx.color);
      break;
    case increment :
      char text[4];
      sprintf(text, "%03d%%", map(interactable -> value,
                                  (interactable -> can_reverse ? -DATA_STREAM_MAX_VALUE : 0),
                                  DATA_STREAM_MAX_VALUE,
                                  (interactable -> can_reverse ? -100 : 0),
                                  100)
              );
      drawString(interactable -> increment.value_x, interactable -> increment.value_y, south, text, interactable -> font, interactable -> gfx.color, none); 

      drawLine(interactable -> increment.line1_x, y, interactable -> increment.line1_x, interactable -> increment.line1_y, interactable -> gfx.color);
      drawLine(interactable -> increment.line2_x, y, interactable -> increment.line2_x, interactable -> increment.line2_y, interactable -> gfx.color);

      drawLine(interactable -> increment.minus_x1, interactable -> increment.minus_y, interactable -> increment.minus_x2, interactable -> increment.minus_y, interactable -> gfx.color);

      drawLine(interactable -> increment.plus_x1, interactable -> increment.plus_y1, interactable -> increment.plus_x1, interactable -> increment.plus_y2, interactable -> gfx.color);
      drawLine(interactable -> increment.plus_x2, interactable -> increment.plus_y3, interactable -> increment.plus_x3, interactable -> increment.plus_y3, interactable -> gfx.color);
      break;
  }

  interactable -> old_value = -1; // force update
  updateItem(interactable);
}

/* should be done by the menu
static uint8_t isInside(interactable_s *interactable, uint16_t x, uint16_t y){
  uint8_t to_return = 0;
  // first, check if we are even inside the interactable's hitbox
  if(x >= interactable -> gfx.x && x <= interactable -> gfx.x + interactable -> gfx.width && y >= interactable -> gfx.y && y <= interactable -> gfx.y + interactable -> gfx.height) to_return = 1;
  else return false;

  switch(interactable -> type){
    case (increment):
      if(x < interactable -> increment.line1_x) to_return = 2;
      else if (x > interactable -> increment.line2_x) to_return = 3;
      break;
  }

  return to_return;
}
*/

#endif

interactables.h

#ifndef _GRAPHICS_ITEM_H_
#define _GRAPHICS_ITEM_H_

#include "utils.h"

typedef enum {
  no_type = 0,
  progress_bar,

} item_type_t;

typedef enum {
  constant = 3, // on every frame
  regular = 2, // every couple frames
  on_click = 1, // when clicked
  never = 0
} refresh_t;

typedef struct graphics_attributes_s{ // shall be added to every item IN FIRST POSITION as a standardized way to access important data (first position is important as we do pointer arithmetics on it afterwards)
  item_type_t type; 
  
  char* name;

  uint16_t x, y, x2, y2;
  uint16_t width, height;

  //pointer arithmetics done here and there up to this one, don't move'em !

  color_t color;
  color_t background;

  refresh_t refresh;
  bool clickable;

  bool disabled;
  bool incoherent;
} graphics_attributes_s;

#endif

graphics_item.h

#ifndef _GRAPHICS_MENU_H_
#define _GRAPHICS_MENU_H_

#include "utils.h"
#include "graphics_item.h"

#include "progress_bar.h"

typedef struct { // wrapper for use with an item manager
  void* item_ptr;

  uint8_t nb_to_redraw;
  void* to_redraw[]; // pointer to all elements that need to be redrawn when the item is deleted (is technically a graphics_item_s*)
} graphics_item_s;

typedef struct {
  graphics_attributes_s gfx;
  uint8_t items_count;
  graphics_item_s items[];
} graphics_menu_s;

// ================= utils ================= //

bool collide(graphics_attributes_s* item1, graphics_attributes_s* item2){
  return ((item1->x) < (item2->x2)) && ((item1->x2) > (item2->x)) && ((item1->y) < (item2->y2)) && ((item1->y2) > (item2->y));
}

// ================= abstraction ================= //

return_code_t initItem(graphics_item_s* item){
  item_type_t type = *((item_type_t*) item);

  switch (type){
    case progress_bar :
      initBar((progress_bar_s*)item);
      break;
  }
}

return_code_t drawItem(graphics_item_s* item){
  item_type_t type = *((item_type_t*) item);

  switch (type){
    case progress_bar :
      drawBar((progress_bar_s*)item);
      break;
  }
}

return_code_t updateItem(graphics_item_s* item){
  item_type_t type = *((item_type_t*) item);

  switch (type){
    case progress_bar :
      updateBar((progress_bar_s*)item);
      break;
  }
}

// ================= methods ================= //

// give it a pointer to a menu array, and the item will be initialized and linked to that menu
static return_code_t initMenu(graphics_menu_s *menu) {
  menu -> items_count = 0;

  while(menu -> items[menu -> items_count].item_ptr != NULL){
    initItem(menu -> items[menu -> items_count].item_ptr);

    menu -> items_count++;
  }
}

static return_code_t clickMenu(graphics_menu_s *menu, uint16_t x, uint16_t y){
  //if(!menu -> gfx.clickable) return hard_fault;
}

static return_code_t drawMenu(graphics_menu_s *menu) {
  for (uint16_t i = 0; i < menu -> items_count; i++){
    drawItem(menu -> items[i].item_ptr);

    menu->items[i].nb_to_redraw = 0;

    for(int j = 0; j < menu->items_count; j++){ // check in already drawn items      
      if(collide((graphics_attributes_s*)menu->items[i].item_ptr,(graphics_attributes_s*)menu->items[j].item_ptr)){ // if the tested item and the current item collide 
        debug("found one",milestone);

        char mot[30];
        sprintf(mot, "%d", ((graphics_attributes_s*)menu->items[i].item_ptr) -> x); // test d'accès aux données
        
        //menu->items[i].to_redraw[menu->items[i].nb_to_redraw] = menu -> items[j].item_ptr; // get the item pointer of the tested item, and save it in the current's item redraw list
        menu->items[i].nb_to_redraw ++; // increment the item redraw count
      }
    }
  }
}

static return_code_t updateMenu(graphics_menu_s *menu) {
  for (uint16_t i = 0; i < menu -> items_count; i++)
    updateItem(menu -> items[i].item_ptr);
}

#endif

graphics_menu.h

//TESTING FILE


//include all files to force them to compile using C
#include "utils.h"
#include "settings.h"
#include "debug.h"

#include "font.h"
#include "GFX.h"
#include "ILI9341_driver.h"
#include "touch_driver.h"

#include "progress_bar.h"

#include "graphics_menu.h"
 
//note : CubeIDE supports designated init, unlike arduino for some reason, just fill the blanks with 0 for now
//using unions for width/x2 and height/y2 leads to the same problem
static progress_bar_s bar1 = {
  .gfx = {
    .type = progress_bar,
    .name = "test1",
    .x = 0,
    .y = 0,
    .x2 = STRUCT_FILLER,
    .y2 = STRUCT_FILLER,
    .width = 100,
    .height = 20,
    .color = white,
    .background = black,
    .refresh = never,
    .clickable = false,
  },
  .infill = blue,
};
static progress_bar_s bar2 = {
  .gfx = {
    .type = progress_bar,
    .name = "test2",
    .x = 10,
    .y = 10,
    .x2 = STRUCT_FILLER,
    .y2 = STRUCT_FILLER,
    .width = 100,
    .height = 20,
    .color = white,
    .background = blue,
    .refresh = never,
    .clickable = false,
  },
  .infill = blue,
};
static progress_bar_s bar3 = {
  .gfx = {
    .type = progress_bar,
    .name = "test3",
    .x = 20,
    .y = 5,
    .x2 = STRUCT_FILLER,
    .y2 = STRUCT_FILLER,
    .width = 100,
    .height = 20,
    .color = purple,
    .background = red,
    .refresh = never,
    .clickable = false,
  },
  .infill = blue,
};


static graphics_menu_s menu1 = {
  .gfx = {},
  .items_count = STRUCT_FILLER,
  .items = {
    {&bar1},
    {&bar2},
    {&bar3},
  }
};



void user_setup(){
  debug("HAL init done, proceeding ...", milestone);

  displayInit();
  touchInit();
  debug("display init done", info);

  initMenu(&menu1);
  drawMenu(&menu1);


  debug("User init done, proceeding ...", milestone);
}

void user_loop(){

  if(ftTouched()){
    ftReadData();
/*
    if(isInside(&interactables[0], ftGetX(), ftGetY())){
      interactables[0].value = !interactables[0].value;
      updateItem(&interactables[0]);
    }

  
    Serial.print(ftGetX()); Serial.print(" "); Serial.println(ftGetY());
    
    if(isInside(&interactables[0], ftGetX(), ftGetY())){
      interactables[0].value = !interactables[0].value;
      updateItem(&interactables[0]);
    }

    for(int i = 0; i < SIZE_OF(interactables); i++)
      Serial.println(isInside(&interactables[i], ftGetX(), ftGetY()));
    Serial.println();

    for (int i = 0; i < SIZE_OF(tiles); i++)
      Serial.print(isInside(&tiles[i], ftGetX(), ftGetY()));
    Serial.println();
*/
    while(ftTouched());
  }

  HAL_Delay(5);
}
