sketch.ino

diagram.json

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "runtime.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi1;
I2C_HandleTypeDef hi2c1;
UART_HandleTypeDef huart2;
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI1_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_I2C1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t __io_putchar(char ch)
{
	HAL_UART_Transmit(&huart2, (uint8_t*)&ch, 1, HAL_MAX_DELAY);
	return ch;
}
uint8_t __io_getchar(char ch)
{
    return HAL_UART_Transmit(&huart2, (uint8_t*)&ch, 1, HAL_MAX_DELAY);

}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_SPI1_Init();
  MX_USART2_UART_Init();
  MX_I2C1_Init();
  /* USER CODE BEGIN 2 */

  printf("HAL init done\n");
  usr_setup();
  printf("User init done\n");
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    usr_loop();
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}


/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void){
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
}
/**
  * @brief I2C1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.Timing = 0x20303E5D;//0x2010091A;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }

  /** Configure Analogue filter
  */
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }

  /** Configure Digital filter
  */
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_Init 2 */

}

HAL_StatusTypeDef edited_HAL_SPI_Init(SPI_HandleTypeDef *hspi)
{
  uint32_t frxth;

  /* Check the SPI handle allocation */
  if (hspi == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
  assert_param(IS_SPI_MODE(hspi->Init.Mode));
  assert_param(IS_SPI_DIRECTION(hspi->Init.Direction));
  assert_param(IS_SPI_DATASIZE(hspi->Init.DataSize));
  assert_param(IS_SPI_NSS(hspi->Init.NSS));
  assert_param(IS_SPI_NSSP(hspi->Init.NSSPMode));
  assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler));
  assert_param(IS_SPI_FIRST_BIT(hspi->Init.FirstBit));
  assert_param(IS_SPI_TIMODE(hspi->Init.TIMode));
  if (hspi->Init.TIMode == SPI_TIMODE_DISABLE)
  {
    assert_param(IS_SPI_CPOL(hspi->Init.CLKPolarity));
    assert_param(IS_SPI_CPHA(hspi->Init.CLKPhase));

    if (hspi->Init.Mode == SPI_MODE_MASTER)
    {
      assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler));
    }
    else
    {
      /* Baudrate prescaler not use in Motoraola Slave mode. force to default value */
      hspi->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
    }
  }
  else
  {
    assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler));

    /* Force polarity and phase to TI protocaol requirements */
    hspi->Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi->Init.CLKPhase    = SPI_PHASE_1EDGE;
  }

  hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;

  if (hspi->State == HAL_SPI_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    hspi->Lock = HAL_UNLOCKED;
      
    /* Init the low level hardware : GPIO, CLOCK, NVIC... */
      
    // HAL_SPI_MspInit is defined in another file, to which we don't have access on wokwi, so i just redefined the function here instead
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_I2S1;
    PeriphClkInit.I2s1ClockSelection = RCC_I2S1CLKSOURCE_SYSCLK;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    {
      Error_Handler();
    }
    
    /* Peripheral clock enable */

    __HAL_RCC_SPI1_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**SPI1 GPIO Configuration
    PB4     ------> SPI1_MISO
    PB5     ------> SPI1_MOSI
    PB6     ------> SPI1_SCK
    */
    GPIO_InitStruct.Pin = MISO_Pin|MOSI_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = SCK_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF10_SPI1;
    HAL_GPIO_Init(SCK_GPIO_Port, &GPIO_InitStruct);

  }

  hspi->State = HAL_SPI_STATE_BUSY;

  /* Disable the selected SPI peripheral */
  __HAL_SPI_DISABLE(hspi);

  /* Align by default the rs fifo threshold on the data size */
  if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
  {
    frxth = SPI_RXFIFO_THRESHOLD_HF;
  }
  else
  {
    frxth = SPI_RXFIFO_THRESHOLD_QF;
  }

  /* CRC calculation is valid only for 16Bit and 8 Bit */
  if ((hspi->Init.DataSize != SPI_DATASIZE_16BIT) && (hspi->Init.DataSize != SPI_DATASIZE_8BIT))
  {
    /* CRC must be disabled */
    hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  }

  /*----------------------- SPIx CR1 & CR2 Configuration ---------------------*/
  /* Configure : SPI Mode, Communication Mode, Clock polarity and phase, NSS management,
  Communication speed, First bit and CRC calculation state */
  WRITE_REG(hspi->Instance->CR1, ((hspi->Init.Mode & (SPI_CR1_MSTR | SPI_CR1_SSI)) |
                                  (hspi->Init.Direction & (SPI_CR1_RXONLY | SPI_CR1_BIDIMODE)) |
                                  (hspi->Init.CLKPolarity & SPI_CR1_CPOL) |
                                  (hspi->Init.CLKPhase & SPI_CR1_CPHA) |
                                  (hspi->Init.NSS & SPI_CR1_SSM) |
                                  (hspi->Init.BaudRatePrescaler & SPI_CR1_BR_Msk) |
                                  (hspi->Init.FirstBit  & SPI_CR1_LSBFIRST) |
                                  (hspi->Init.CRCCalculation & SPI_CR1_CRCEN)));

  /* Configure : NSS management, TI Mode, NSS Pulse, Data size and Rx Fifo threshold */
  WRITE_REG(hspi->Instance->CR2, (((hspi->Init.NSS >> 16U) & SPI_CR2_SSOE) |
                                  (hspi->Init.TIMode & SPI_CR2_FRF) |
                                  (hspi->Init.NSSPMode & SPI_CR2_NSSP) |
                                  (hspi->Init.DataSize & SPI_CR2_DS_Msk) |
                                  (frxth & SPI_CR2_FRXTH)));

  /* Activate the SPI mode (Make sure that I2SMOD bit in I2SCFGR register is reset) */
  CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);

  hspi->ErrorCode = HAL_SPI_ERROR_NONE;
  hspi->State     = HAL_SPI_STATE_READY;

  return HAL_OK;
}

/**
  * @brief SPI1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI1_Init(void)
{

  /* USER CODE BEGIN SPI1_Init 0 */

  /* USER CODE END SPI1_Init 0 */

  /* USER CODE BEGIN SPI1_Init 1 */

  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 7;
  hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  if (edited_HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */

  /* USER CODE END SPI1_Init 2 */
}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void){

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(Led_GPIO_Port, Led_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, gpio4_Pin|gpio3_Pin|gpio2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(gpio1_GPIO_Port, gpio1_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : User_Button_Pin */
  GPIO_InitStruct.Pin = User_Button_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(User_Button_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : PA2 PA3 */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF1_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : Led_Pin */
  GPIO_InitStruct.Pin = Led_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(Led_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : gpio4_Pin gpio3_Pin gpio2_Pin */
  GPIO_InitStruct.Pin = gpio4_Pin|gpio3_Pin|gpio2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /*Configure GPIO pin : gpio1_Pin */
  GPIO_InitStruct.Pin = gpio1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(gpio1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : PB8 PB9 */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF6_I2C1;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void){
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line){
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */


main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.h
  * @brief          : Header for main.c file.
  *                   This file contains the common defines of the application.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __MAIN_H
#define __MAIN_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32c0xx_hal.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */

/* USER CODE END ET */

/* Exported constants --------------------------------------------------------*/
/* USER CODE BEGIN EC */
extern SPI_HandleTypeDef hspi1;
extern I2C_HandleTypeDef hi2c1;

/* USER CODE END EC */

/* Exported macro ------------------------------------------------------------*/
/* USER CODE BEGIN EM */

/* USER CODE END EM */

/* Exported functions prototypes ---------------------------------------------*/
void Error_Handler(void);

/* USER CODE BEGIN EFP */

/* USER CODE END EFP */

/* Private defines -----------------------------------------------------------*/
#define User_Button_Pin GPIO_PIN_13
#define User_Button_GPIO_Port GPIOC
#define User_Button_EXTI_IRQn EXTI4_15_IRQn
#define Led_Pin GPIO_PIN_5
#define Led_GPIO_Port GPIOA
#define gpio4_Pin GPIO_PIN_1
#define gpio4_GPIO_Port GPIOD
#define gpio3_Pin GPIO_PIN_2
#define gpio3_GPIO_Port GPIOD
#define gpio2_Pin GPIO_PIN_3 // a l'air d'avoir des problèmes, je ne sais pourquoi
#define gpio2_GPIO_Port GPIOD // 
#define gpio1_Pin GPIO_PIN_3
#define gpio1_GPIO_Port GPIOB
#define MISO_Pin GPIO_PIN_4
#define MISO_GPIO_Port GPIOB
#define MOSI_Pin GPIO_PIN_5
#define MOSI_GPIO_Port GPIOB
#define SCK_Pin GPIO_PIN_6
#define SCK_GPIO_Port GPIOB


/* USER CODE BEGIN Private defines */

/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

main.h

#include "display_driver.h"
#include "display_graphics.h"
#include "graphics_menu.h"

#include "touch_driver.h"

static item_test_t item1 = {
  .type = test,
  .x = 10,
  .y = 10,
  .height = 100,
  .width = 100,
  .color = red,
};

static item_test_t item2 = {
  .type = test,
  .x = 20,
  .y = 20,
  .height = 100,
  .width = 100,
  .color = blue,
};

static item_label_t item3 = {
  .type = label,
  .x = 30,
  .y = 30,
  .text = "salut",
  .font = font_medium,
  .color = black,
  .background = cyan,
  .outline = dark_grey,
};

static item_checkbox_t item4 = {
  .type = checkbox,
  .x = 30,
  .y = 50,
  .height = 20,
  .width = 20,
  .color = dark_green,
  .background = orange,
  .outline = dark_grey,
};

graphics_menu_t menu2 = {
  .type = menu,
  .x = 10,
  .y = 10,
  .height = 150,
  .width = 150,
  .outline = red,
  .background = purple,
  .items = {
    {&item1},
    {&item2},
    {&item3},
    {&item4},
  },
  .items_count = 4,
};

graphics_menu_t display = {
  .type = menu,
  .x = 10,
  .y = 10,
  .height = 200,
  .width = 200,
  .outline = yellow,
  .background = dark_green,
  .items = {
    {&menu2},
  },
  .items_count = 1,
};

void usr_setup(){
  displayInit();
  //printf("Touch init : %d\n",touchInit());

ftTouched();

  initMenu(&display);
  drawMenu(&display);
  
  drawChar(10, 250, south, 's', font_medium, black, white);
  drawString(10, 220, south, "salutations", font_medium, black, white);

/*
  HAL_Delay(2000);
  hide(&menu2, 1);
  HAL_Delay(2000);
  hide(&display, 0);
  HAL_Delay(2000);
  show(&display, 0);
*/
}

void usr_loop(){
  if(ftTouched()){
    printf("click %d %d\n",ftGetX(),ftGetY());
    //clickMenu(&display, ftGetX(), ftGetY());
  }
}

runtime.c

#ifndef _RUNTIME_H_
#define _RUNTIME_H_

void usr_setup();
void usr_loop();

#endif

runtime.h

#ifndef _ILI9341_DRIVER_H_
#define _ILI9341_DRIVER_H_

#include "main.h"

// ============ Mandatory (do not remove) ============ //

typedef enum color_e {
  transparent = 0, // 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;

void displayInit(void);
void displayDraw(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color); // draw a rectangle on screen, defined by two opposing corners (starting from top left)
void displayDrawPixel(uint16_t X, uint16_t Y, color_t color);

// ============ Mandatory display constants (to be filled in by the user) ============ //

#define DISPLAY_WIDTH 240
#define DISPLAY_HEIGHT 320

#endif



display_driver.h

#include "display_driver.h"
#include "main.h"

#include "stdbool.h"
#include "stdio.h"

#define DISPLAY_INSTANCE &hspi1 // SPI peripheral adress to use
#define DISPLAY_TRANS_TIMEOUT HAL_MAX_DELAY // ms, timeout before transmission to display is aborted

#define DISPLAY_CS_PORT gpio1_GPIO_Port
#define DISPLAY_CS_PIN gpio1_Pin
#define DISPLAY_DC_PORT gpio4_GPIO_Port
#define DISPLAY_DC_PIN gpio4_Pin
#define DISPLAY_RST_PORT gpio3_GPIO_Port
#define DISPLAY_RST_PIN gpio3_Pin

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 ================================ //

// Dirty trick to speed up this function, should be replaced asap !
HAL_StatusTypeDef FAST_HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, int32_t rep, uint32_t Timeout)
{
  uint32_t tickstart;
  HAL_StatusTypeDef errorcode = HAL_OK;
  uint16_t initial_TxXferCount;

  /* Process Locked */
  __HAL_LOCK(hspi);

  /* Init tickstart for timeout management*/
  tickstart = HAL_GetTick();
  initial_TxXferCount = rep;

  if (hspi->State != HAL_SPI_STATE_READY)
  {
    errorcode = HAL_BUSY;
    goto error;
  }

  if ((pData == NULL))
  {
    errorcode = HAL_ERROR;
    goto error;
  }

  /* Set the transaction information */
  hspi->State       = HAL_SPI_STATE_BUSY_TX;
  hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
  hspi->pTxBuffPtr  = (uint8_t *)pData;
  hspi->TxXferSize  = 2;
  hspi->TxXferCount = rep;

  /*Init field not used in handle to zero */
  hspi->pRxBuffPtr  = (uint8_t *)NULL;
  hspi->RxXferSize  = 0U;
  hspi->RxXferCount = 0U;
  hspi->TxISR       = NULL;
  hspi->RxISR       = NULL;

  /* Check if the SPI is already enabled */
  if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
  {
    /* Enable SPI peripheral */
    __HAL_SPI_ENABLE(hspi);
  }

  while (rep > 0)
  {
    /* Wait until TXE flag is set to send data */
    while(!__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE));
    
      /* write on the data register in packing mode */
      hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);
      rep -= 1;
      hspi->TxXferCount--;
    /*
    }
    else
    {
      // Timeout management
      if ((((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))
      {
        errorcode = HAL_TIMEOUT;
        goto error;
      }
    }
    */
  }
  
  /* Check the end of the transaction */
  /*
  if (SPI_EndRxTxTransaction(hspi, Timeout, tickstart) != HAL_OK)
  {
    hspi->ErrorCode = HAL_SPI_ERROR_FLAG;
  }
  */

    __HAL_SPI_CLEAR_OVRFLAG(hspi);

  if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)
  {
    errorcode = HAL_ERROR;
  }

error:
  hspi->State = HAL_SPI_STATE_READY;
  /* Process Unlocked */
  __HAL_UNLOCK(hspi);
  return errorcode;
}



// 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
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
void displayDraw(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, color_t color) {
  if(color == transparent) 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);

  uint8_t data[] = {color >> 8,color & 0xFF};
  displayMode(data_mode);
  FAST_HAL_SPI_Transmit(DISPLAY_INSTANCE, data, size, DISPLAY_TRANS_TIMEOUT);

  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
void displayDrawPixel(uint16_t X, uint16_t Y, color_t color) {
  if (color == transparent) 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);
}


display_driver.c

#include "display_graphics.h"
#include "display_driver.h"

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_t font, color_t color, color_t background){
  uint8_t i, j;
  uint16_t b;
  
  if(background != transparent) // 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_t 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;
    }
  }
}


display_graphics.c

display_graphics.h

#include "graphics_item.h"
#include "display_graphics.h"

void prepareItem(gfx_attr_t* item){
  if(item->outline == 0) item->outline = item->background;
}

void outlineItem(gfx_attr_t* item){
  drawRectangle(item->abs_x, item->abs_y, item->abs_x + item->width, item->abs_y + item->height, item->outline);
  fillRectangle(item->abs_x +1, item->abs_y +1, item->abs_x + item->width -1, item->abs_y + item->height -1, item->background);
}

void moveItem(gfx_attr_t* item, uint16_t x_offset, uint16_t y_offset, side_t side){
  item->abs_x = item->x + x_offset;
  item->abs_y = item->y + y_offset;

  item->side = side;
}


graphics_item.c

#ifndef _GRAPHICS_ITEM_H_
#define _GRAPHICS_ITEM_H_

#include "display_graphics.h"

#include <stdbool.h>
#include <stdint.h>

typedef enum item_type_e {
  no_type = 0,
  menu,
  test,
  label,
  checkbox,
} item_type_t;

typedef enum item_state_e {
  incoherent = -1,
  uninit = 0,
  ready,
} item_state_t;

#define graphics_item_inheritance \
item_type_t type;                 \
                                  \
uint16_t x, y;                    \
uint16_t height, width;           \
side_t side;                      \
                                  \
uint16_t abs_x, abs_y;            \
                                  \
color_t outline;                  \
color_t background;               \
                                  \                                  
item_state_t state;               \ 

typedef struct gfx_attr_s {graphics_item_inheritance} gfx_attr_t;

void moveItem(gfx_attr_t* item, uint16_t x_offset, uint16_t y_offset, side_t side);

#endif

graphics_item.h


#include "display_graphics.h"
#include "graphics_menu.h"
#include "graphics_item.h"

#include <stdbool.h>

bool collision(gfx_attr_t* item1, gfx_attr_t* item2){
  if(item1->x < item2->x + item2->width && item1->x > item2->x) return true;
  if(item1->y < item2->y + item2->height && item1->y > item2->y) return true;
  if(item1->x + item1->width < item2->x + item2->width && item1->x + item1->width > item2->x) return true;
  if(item1->y + item1->height < item2->y + item2->height && item1->y + item1->height > item2->y) return true;
  return false;
}

bool inside(gfx_attr_t* item, uint16_t x, uint16_t y){
  if( x > item->abs_x &&
      x < item->abs_x + item->width &&
      y > item->abs_y &&
      y < item->abs_y + item->height    
    ) return true;

  return false;
}

void initMenu(graphics_menu_t* menu){
  for(uint16_t i = 0; i < menu -> items_count; i++) {
    initItem(menu -> items[i].item_ptr);
    menu->items[i].shown = true;
  }
}

void drawMenu(graphics_menu_t *menu) {
  outlineItem((gfx_attr_t*)menu);

  for (uint16_t i = 0; i < menu -> items_count; i++){
    if(menu->items[i].shown == true) drawItem(menu -> items[i].item_ptr, menu->abs_x, menu->abs_y, menu->side);
  }
}

bool clickMenu(graphics_menu_t* menu, uint16_t x, uint16_t y){
  if(inside(menu, x, y))
    for(uint16_t i = menu -> items_count; i > 0; i--) {
      if(inside(menu -> items[i].item_ptr, x, y)){
        clickItem(menu -> items[i].item_ptr, x, y);
        return true;
      }
    }
  return false;
}


void hide(graphics_menu_t *menu, uint16_t index){  
  gfx_attr_t* item_attr = menu->items[index].item_ptr;

  fillRectangle(menu->abs_x + item_attr->x,
                menu->abs_y + item_attr->y,
                menu->abs_x + item_attr->x + item_attr->width,
                menu->abs_y + item_attr->y + item_attr->height, 
                menu->background);

  for (uint16_t i = 0; i < menu -> items_count; i++){
    if(menu -> items[i].shown)
      if(collision(menu->items[i].item_ptr, item_attr)){
        drawItem(menu -> items[i].item_ptr, menu->abs_x, menu->abs_y, menu->side);
      }
  }
  menu->items[index].shown = false;
}

void show(graphics_menu_t *menu, uint16_t index){
  drawItem(menu -> items[index].item_ptr, menu->abs_x, menu->abs_y, menu->side);
  menu->items[index].shown = true;
}

graphics_menu.c

#ifndef _GRAPHICS_MENU_H_
#define _GRAPHICS_MENU_H_

#include "graphics_item.h"
#include <stdint.h>

typedef struct menu_item_s {
  void* item_ptr;
  bool shown;
} menu_item_t;

typedef struct graphics_menu_s { graphics_item_inheritance
  uint16_t items_count;
  menu_item_t items[];
} graphics_menu_t;

void initMenu(graphics_menu_t *menu);
void drawMenu(graphics_menu_t *menu);
bool clickMenu(graphics_menu_t* menu, uint16_t x, uint16_t y);

#include "item_test.h"
#include "item_label.h"
#include "item_checkbox.h"

static void initItem(void* item){
  switch (((gfx_attr_t*)item)->type){
    default : printf("item init not implemented !\n"); break;
    case menu : initMenu(item); break;
    case test : initItemTest(item); break;
    case label : initItemLabel(item); break;
    case checkbox : initItemCheckbox(item); break;
  }
}

static void drawItem(void* item, uint16_t x_offset, uint16_t y_offset, side_t side){
  moveItem((gfx_attr_t*)item, x_offset, y_offset, side);

  switch (((gfx_attr_t*)item)->type){
    default : printf("item draw not implemented !\n"); break;
    case menu : drawMenu(item); break;
    case test : drawItemTest(item); break;
    case label : drawItemLabel(item); break;
    case checkbox : drawItemCheckbox(item); break;
  }
}

static void clickItem(void* item, uint16_t x, uint16_t y){
  switch (((gfx_attr_t*)item)->type){
    default : printf("item click not implemented !\n"); break;
    case menu : clickMenu(item,x,y); break;
    case checkbox : clickCheckox(item); break;
  }
}

#endif

graphics_menu.h

#ifndef _ITEM_TEST_H_
#define _ITEM_TEST_H_

#include "display_graphics.h"
#include "graphics_item.h"

typedef struct item_test_s { graphics_item_inheritance
  color_t color;
} item_test_t;

static void initItemTest(item_test_t* item){

}

static void drawItemTest(item_test_t* item){
  fillRectangle(item->abs_x, item->abs_y, item->abs_x + item->width, item->abs_y + item->height, item->color);
}

#endif

item_test.h

#ifndef _ITEM_LABEL_H_
#define _ITEM_LABEL_H_

#include "display_graphics.h"
#include "graphics_item.h"

typedef struct item_label_s { graphics_item_inheritance
  char* text;
  font_t font;
  uint8_t offset_x, offset_y;
  color_t color;
} item_label_t;

static void initItemLabel(item_label_t* item){
  if(item->height == 0) item->height = item->font.height +3;
  if(item->width == 0) item->width = item->font.width * strlen(item->text) +1;
}

static void drawItemLabel(item_label_t* item){
  outlineItem((gfx_attr_t*)item);

  drawString(item->abs_x + item->offset_x +1, item->abs_y + item->offset_y +2, item->side, item->text, item->font, item->color, transparent); // background already handled y the outline
}

#endif

item_label.h

#ifndef _ITEM_CHECKBOX_H_
#define _ITEM_CHECKBOX_H_

#include "display_graphics.h"
#include "graphics_item.h"

#include "stdio.h"

typedef struct item_checkbox_s { graphics_item_inheritance
  bool data;
  color_t color;
} item_checkbox_t;

static void initItemCheckbox(item_checkbox_t* item){
  prepareItem((gfx_attr_t*)item);
}

static void drawItemCheckbox(item_checkbox_t* item){
  drawRectangle(item->abs_x, item->abs_y, item->abs_x + item->width, item->abs_y + item->height, item->outline);
  fillRectangle(item->abs_x +1, item->abs_y +1, item->abs_x + item->width -1, item->abs_y + item->height -1, (item->data ? item-> color : item->background));
}

static void clickCheckox(item_checkbox_t* item){
  printf("clicked");
}

#endif

item_checkbox.h

#ifndef _TOUCH_H_
#define _TOUCH_H_

#include <stdio.h>
#include "main.h"

// Quick and dirty driver for the touch ic, intended to be replaced on final hardware

#define FT62XX_I2C_INSTANCE &hi2c1
#define FT62XX_TIMEOUT HAL_MAX_DELAY

#define FT62XX_DEFAULT_ADDR (0x38<<1)   //!< 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 val;
  HAL_I2C_Master_Transmit(FT62XX_I2C_INSTANCE, FT62XX_DEFAULT_ADDR, &reg, 1, FT62XX_TIMEOUT);
  HAL_I2C_Master_Receive(FT62XX_I2C_INSTANCE, FT62XX_DEFAULT_ADDR, &val, 1, FT62XX_TIMEOUT);
  return val;
}

void ftWriteRegister8(uint8_t reg, uint8_t val) {
  uint8_t buff[2] = {reg,val};
  HAL_I2C_Master_Transmit(FT62XX_I2C_INSTANCE, FT62XX_DEFAULT_ADDR, buff, 2, FT62XX_TIMEOUT);
}

void ftReadData(void) {
  uint8_t data[16];
  uint8_t addr = 0;
  
  HAL_I2C_Master_Transmit (FT62XX_I2C_INSTANCE, FT62XX_DEFAULT_ADDR, addr, 1, FT62XX_TIMEOUT);
  HAL_I2C_Master_Receive (FT62XX_I2C_INSTANCE, FT62XX_DEFAULT_ADDR, data, 16, FT62XX_TIMEOUT);

  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 (false){//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