main.c

Go to the documentation of this file.

/* USER CODE BEGIN Header */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <math.h>
#include "entryPointCPP.hpp"
#include "touchZones.h"
#ifdef TOUCH_SELFTEST_ENABLE
#include "touchSelfTest.h"
#endif
 
/* #define TSC2046_DEBUG_POLL */  /* temporary raw-read diagnostic; enable to debug */
 
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define OUT_ON   GPIO_PIN_RESET
#define OUT_OFF  GPIO_PIN_SET
 
 
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
 
SPI_HandleTypeDef hspi1;
 
UART_HandleTypeDef huart1;
 
/* USER CODE BEGIN PV */
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_SPI1_Init(void);
/* USER CODE BEGIN PFP */
static void outputsAllOff(void);
static void applyZoneAction(touchZone_t zone);
#ifdef TSC2046_DEBUG_POLL
static void tsc2046RawDebug(const char *name, uint8_t cmd);
#endif
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
 
#ifdef REDIRECT_PRINTF
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
 
PUTCHAR_PROTOTYPE
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
 
  return ch;
}
#endif
 
/* USER CODE END 0 */
 
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_USART1_UART_Init();
  MX_SPI1_Init();
  /* USER CODE BEGIN 2 */
 
  printf("\x1b[2J\x1b[H");  // Clear the dumb terminal screen
 
  outputsAllOff();
  initTSC2046();
  printf("TSC2046 touch controller initialized.\r\n");
#ifdef TOUCH_SELFTEST_ENABLE
  touchSelfTestRunAll();
#endif
  printf("Touch the panel...\r\n");
 
  /* Poll state: only report while touched, plus one line on release. */
  bool wasTouched = false;
  uint32_t lastPrintMs = 0;
  touchZone_t lastZone = TOUCH_ZONE_NONE;
  touchZone_t candidateZone = TOUCH_ZONE_NONE;
  uint8_t candidateCount = 0;
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
 
#ifdef TSC2046_DEBUG_POLL
    // TEMPORARY diagnostic: every 500 ms print pin levels and a raw read
    // regardless of IRQ, to see whether the panel responds to polled reads.
    {
      static uint32_t lastDbgMs = 0;
      if (HAL_GetTick() - lastDbgMs >= 500)
      {
        lastDbgMs = HAL_GetTick();
        int16_t dx = 0, dy = 0;
        float dp = 0.0f;
        tsc2046GetPoint(&dx, &dy, &dp);
        printf("DBG irq=%d busy=%d raw X=%4d Y=%4d P=%ld\r\n",
               (int)HAL_GPIO_ReadPin(TSC2046_IRQ_GPIO_Port, TSC2046_IRQ_Pin),
               (int)HAL_GPIO_ReadPin(TSC2046_BUSY_GPIO_Port, TSC2046_BUSY_Pin),
               dx, dy, (long)dp);
        tsc2046RawDebug("X ", 0xD0);
        tsc2046RawDebug("Y ", 0x90);
        tsc2046RawDebug("Z1", 0xB0);
        tsc2046RawDebug("Z2", 0xC0);
      }
    }
#endif
 
    // Poll every 10 ms. "Touched" needs ALL of:
    //  - pressure in a real-touch band: >= 40 ohm (idle/untouched junk reads 0-18 ohm,
    //    measured) and < 1500 ohm (light touches); real touches measured ~110-600 ohm.
    //  - the point inside the accepted touch area (idle junk gives X=0 / X=3855 etc.).
    // PENIRQ is NOT used: on this panel it is disturbed by the polled SPI reads.
    // A zone is acted on after 2 consecutive samples agree (fast enough for quick taps),
    // and a press ends after 3 consecutive untouched samples. The LED/buzzer action runs
    // BEFORE any printf: at 19200 baud one printed line blocks the loop for ~25 ms.
    static uint32_t lastPollMs = 0;
    static uint8_t untouchedCount = 0;
    if (HAL_GetTick() - lastPollMs >= 10)
    {
      lastPollMs = HAL_GetTick();
      int16_t x = 0, y = 0;
      float pressure = 0.0f;
      bool rawTouched = false;
      touchZone_t zone = TOUCH_ZONE_NONE;
      if (tsc2046GetPoint(&x, &y, &pressure))
      {
        zone = touchZoneFromPoint(x, y);
        rawTouched = isfinite(pressure) && pressure >= 40.0f && pressure < 1500.0f
                     && zone != TOUCH_ZONE_NONE;
      }
 
      if (rawTouched)
      {
        untouchedCount = 0;
 
        if (zone == candidateZone)
        {
          if (candidateCount < 255) candidateCount++;
        }
        else
        {
          candidateZone = zone;
          candidateCount = 1;
        }
 
        if (candidateCount >= 2 && candidateZone != lastZone)
        {
          lastZone = candidateZone;
          wasTouched = true;
          applyZoneAction(lastZone);                       // act first...
          printf("Zone: %s\r\n", touchZoneName(lastZone)); // ...then print
        }
        else if (wasTouched && HAL_GetTick() - lastPrintMs >= 200)
        {
          lastPrintMs = HAL_GetTick();
          printf("Touch: X=%4d  Y=%4d  Pressure=%ld ohm\r\n", x, y, (long)pressure);
        }
      }
      else
      {
        if (untouchedCount < 255) untouchedCount++;
        candidateCount = 0;
        candidateZone = TOUCH_ZONE_NONE;
 
        if (wasTouched && untouchedCount >= 3)
        {
          wasTouched = false;
          lastZone = TOUCH_ZONE_NONE;
          HAL_GPIO_WritePin(Buzzer_GPIO_Port, Buzzer_Pin, OUT_OFF);   // release ends the beep
          printf("Released\r\n");
        }
      }
    }
  }
  /* USER CODE END 3 */
}
 
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
 
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
 
  while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
 
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 60;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLQ = 5;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
 
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
                              |RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
  RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
}
 
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_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 0x0;
  hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  hspi1.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi1.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi1.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi1.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi1.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi1.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi1.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi1.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi1.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */
 
  /* USER CODE END SPI1_Init 2 */
 
}
 
static void MX_USART1_UART_Init(void)
{
 
  /* USER CODE BEGIN USART1_Init 0 */
 
  /* USER CODE END USART1_Init 0 */
 
  /* USER CODE BEGIN USART1_Init 1 */
 
  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 19200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}
 
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_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOE_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LED01_GPIO_Port, LED01_Pin, GPIO_PIN_SET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(Buzzer_GPIO_Port, Buzzer_Pin, GPIO_PIN_SET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LED03_GPIO_Port, LED03_Pin, GPIO_PIN_SET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(TSC2046_CS_GPIO_Port, TSC2046_CS_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LED02_GPIO_Port, LED02_Pin, GPIO_PIN_SET);
 
  /*Configure GPIO pin : LED01_Pin */
  GPIO_InitStruct.Pin = LED01_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LED01_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pins : Buzzer_Pin LED03_Pin */
  GPIO_InitStruct.Pin = Buzzer_Pin|LED03_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
 
  /*Configure GPIO pin : TSC2046_IRQ_Pin */
  GPIO_InitStruct.Pin = TSC2046_IRQ_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(TSC2046_IRQ_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pin : TSC2046_BUSY_Pin */
  GPIO_InitStruct.Pin = TSC2046_BUSY_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(TSC2046_BUSY_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pin : TSC2046_CS_Pin */
  GPIO_InitStruct.Pin = TSC2046_CS_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(TSC2046_CS_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pin : LED02_Pin */
  GPIO_InitStruct.Pin = LED02_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LED02_GPIO_Port, &GPIO_InitStruct);
 
  /* USER CODE BEGIN MX_GPIO_Init_2 */
 
  /* USER CODE END MX_GPIO_Init_2 */
}
 
/* USER CODE BEGIN 4 */
 
static void outputsAllOff(void)
{
  HAL_GPIO_WritePin(LED01_GPIO_Port, LED01_Pin, OUT_OFF);
  HAL_GPIO_WritePin(LED02_GPIO_Port, LED02_Pin, OUT_OFF);
  HAL_GPIO_WritePin(LED03_GPIO_Port, LED03_Pin, OUT_OFF);
  HAL_GPIO_WritePin(Buzzer_GPIO_Port, Buzzer_Pin, OUT_OFF);
}
 
static void applyZoneAction(touchZone_t zone)
{
  switch (zone)
  {
  case TOUCH_ZONE_LED1_ON:  HAL_GPIO_WritePin(LED01_GPIO_Port, LED01_Pin, OUT_ON);  break;
  case TOUCH_ZONE_LED1_OFF: HAL_GPIO_WritePin(LED01_GPIO_Port, LED01_Pin, OUT_OFF); break;
  case TOUCH_ZONE_LED2_ON:  HAL_GPIO_WritePin(LED02_GPIO_Port, LED02_Pin, OUT_ON);  break;
  case TOUCH_ZONE_LED2_OFF: HAL_GPIO_WritePin(LED02_GPIO_Port, LED02_Pin, OUT_OFF); break;
  case TOUCH_ZONE_LED3_ON:  HAL_GPIO_WritePin(LED03_GPIO_Port, LED03_Pin, OUT_ON);  break;
  case TOUCH_ZONE_LED3_OFF: HAL_GPIO_WritePin(LED03_GPIO_Port, LED03_Pin, OUT_OFF); break;
  default: break;
  }
  HAL_GPIO_WritePin(Buzzer_GPIO_Port, Buzzer_Pin, (zone == TOUCH_ZONE_BEEP) ? OUT_ON : OUT_OFF);
}
 
#ifdef TSC2046_DEBUG_POLL
static void tsc2046RawDebug(const char *name, uint8_t cmd)
{
  uint8_t tx[3] = { cmd, 0x00, 0x00 };
  uint8_t rx[3] = { 0xAA, 0xAA, 0xAA };   // sentinel: shows if HAL never wrote rx
 
  HAL_GPIO_WritePin(TSC2046_CS_GPIO_Port, TSC2046_CS_Pin, GPIO_PIN_RESET);
  HAL_StatusTypeDef st = HAL_SPI_TransmitReceive(&hspi1, tx, rx, 3, 100);
  HAL_GPIO_WritePin(TSC2046_CS_GPIO_Port, TSC2046_CS_Pin, GPIO_PIN_SET);
 
  unsigned value = (((unsigned)rx[1] << 8 | rx[2]) >> 3) & 0xFFF;
  printf("RAW %s cmd=%02X hal=%d state=%d err=0x%lX rx=%02X %02X %02X -> %4u\r\n",
         name, cmd, (int)st, (int)HAL_SPI_GetState(&hspi1),
         (unsigned long)HAL_SPI_GetError(&hspi1), rx[0], rx[1], rx[2], value);
}
#endif
 
 
void _Error_Handler(const char *file, int line)
{
    __disable_irq();
 
#ifdef REDIRECT_PRINTF
    char buf[80];
 
    snprintf(buf, sizeof(buf),
            "Trapped in _Error_Handler(). Called from: %s, line: %d\r\n",
            file, line);
    printf("%s", buf);
#endif
 
    /* User can add an implementation to report the HAL error return state. */
    while(1)
    {
    }
}
 
/* USER CODE END 4 */
 
 
#ifdef  USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* assert_param() can fire from inside any HAL call -- including before
   * REDIRECT_PRINTF's UART is fully set up, or from an unusual calling
   * context -- so this only attempts to report when REDIRECT_PRINTF is
   * available, then halts either way. Continuing after a failed HAL
   * parameter check is undefined behavior, not something safe to log
   * and ignore. */
  __disable_irq();
 
#ifdef REDIRECT_PRINTF
  {
    char buf[96];
 
    snprintf(buf, sizeof(buf),
             "assert_param failed: file %s, line %lu\r\n",
             (char *)file, (unsigned long)line);
    printf("%s", buf);
  }
#endif
 
  while (1)
  {
  }
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */