STM32 HardFault в коде. strtok

cnt = 0;           
char *pV;
for( pV = strtok(nmeaSnt, ","); pV != NULL; pV = strtok(NULL, ","))      // Find
{
    cnt++;
}

/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
 
// Oled
#include "ssd1306.h"
#include "fonts.h"
#include "oled_ssd1306.h"
 
#include "Humidity_and_Temperature_SI7021_sensor.h"
#include <string.h>
#include "GPS_NEO_6M.h"
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define ON 1
#define OFF 0
 
// INIT PERIPHERAL ////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#define OLED OFF
#define T_and_H_SI7021 OFF
#define GPS OFF
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
 
// -----------------------------------------------------------------------------
uint8_t flag = 0;                   // Flag signals what GPS buffer is full
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    flag = 1;
}
//
//int nmea0183_checksum(char *msg) {
//
//                              int checksum = 0;
//                              int j = 0;
//
//                              // the first $ sign and the last two bytes of original CRC + the * sign
//                              for (j = 1; j < strlen(msg) - 4; j++) {
//                                  checksum = checksum ^ (unsigned) msg[j];
//                              }
//
//                              return checksum;
//                           }
// -----------------------------------------------------------------------------
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;
 
TIM_HandleTypeDef htim1;
 
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;
DMA_HandleTypeDef hdma_usart3_rx;
 
/* USER CODE BEGIN PV */
 
//uint8_t buff[512];
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM1_Init(void);
static void MX_USART3_UART_Init(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
 
/* 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_DMA_Init();
  MX_I2C1_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  MX_USART3_UART_Init();
  /* USER CODE BEGIN 2 */
   //I2C_1_scaner();
//
 
//    # if  OLED
//         init_oled();
//         test_oled();
//  # endif
//
//  # if T_and_H_SI7021
//         HAL_TIM_Base_Start_IT(&htim1);   // Start timer. Read Temperature and Humidity from SI7021
//  # endif
 
//  read_T_and_H_SI7021();
 
     // GPS module
     // 1. Print input data from GPS module   work ok
//   uint8_t gps_RX_buff[255];
//   memset(gps_RX_buff ,0 ,sizeof(gps_RX_buff));
 
 
    ///////////////////////////////////////////////////////////////////////////
    uint8_t buff[255];
    char buffStr[255];
    char nmeaSnt[80];
 
    char *rawSum;
    char smNmbr[3];
 
    char *latRaw;
    char latDg[2];
    char latMS[7];
    char *hemNS;
 
    char *lonRaw;
    char lonDg[3];
    char lonMS[7];
    char *hemEW;
 
    char *utcRaw; // raw UTC time from the NMEA sentence in the hhmmss format
    char strUTC[8]; // UTC time in the readable hh:mm:ss format
 
    char hH[2]; // hours
    char mM[2]; // minutes
    char sS[2]; // seconds
 
    uint8_t cnt = 0;
 
    HAL_UART_Receive_DMA(&huart1, buff, 255);
    ///////////////////////////////////////////////////////////////////////////
 
 
 
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  // --------------------------------------------------------------------------------------
  while (1)
  {
 
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
 
//   #if GPS
//        parsing_GPS(GPS_buff, 512);
//        //simple_read_stream_data_from_GPS (GPS_buff, 512) ;
//   #endif
 
    /* USER CODE BEGIN 3 */
 
  }
  /* USER CODE END 3 */
}

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
 
// Oled
#include "ssd1306.h"
#include "fonts.h"
#include "oled_ssd1306.h"
 
#include "Humidity_and_Temperature_SI7021_sensor.h"
#include <string.h>
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define ON 1
#define OFF 0
#define SAMPLE_READ_STRIND_GPS OFF
 
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;
 
TIM_HandleTypeDef htim1;
 
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;
DMA_HandleTypeDef hdma_usart3_rx;
 
/* USER CODE BEGIN PV */
struct GPS
{
    char latDg[3];          // Широта в градусах
    char latMS[8];          // Широта в мінутах секундах
    char lonDg[4];          // Довгота в градусах
    char lonMS[8];          // Довгота в мінутах секундах
 
    char clock[12];
} GPS_data;
 
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM1_Init(void);
static void MX_USART3_UART_Init(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t flag = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    flag = 1;
}
 
int nmea0183_checksum(char *msg)
{
    int checksum = 0;
    int j = 0;
 
    for(j = 1; j < strlen(msg) - 4; j++)
    {
        checksum = checksum^(unsigned)msg[j];
    }
    return checksum;
}
 
/* 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_DMA_Init();
  MX_I2C1_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  MX_USART3_UART_Init();
  /* USER CODE BEGIN 2 */
   I2C_1_scaner();
//
//   init_oled();
//   test_oled();
 
   // Start timer
   // In timer:
   // 1. Read Temperature and Humidity from SI7021
   // HAL_TIM_Base_Start_IT(&htim1);   // Start timer
 
 
//  read_T_and_H_SI7021();
 
     // GPS module
     // 1. Print input data from GPS module   work ok
//   uint8_t gps_RX_buff[255];
//   memset(gps_RX_buff ,0 ,sizeof(gps_RX_buff));
 
 
   uint8_t buff[512];
   char buffStr[512];
   char nmeaSnt[80];
 
   char *rawSum;
   char smNmbr[3];
 
   char *latRaw;
   char latDg[2];
   char latMS[7];
   char *hemNS;
 
   char *lonRaw;
   char lonDg[3];
   char lonMS[7];
 
   char *hemEW;
 
   char *utcRaw;
   char strUTC[8];
 
   char hH[2];
   char mM[2];
   char sS[2];
 
   uint8_t cnt = 0;
 
   memset(buff ,0 ,sizeof(buff));
   HAL_UART_Receive_DMA(&huart3, buff, 512);
   int i=0;
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
      #if SAMPLE_READ_STRIND_GPS
          // GPS module
          // 1. Print all input data from GPS module   work ok ------------------------------------------------
          // in $GPGLL
 
          if(flag == 1)
          {
              HAL_UART_Transmit(&huart1, buff, 512, 200);
              memset(buff, 0, 512);
              flag = 0;
              //HAL_UART_Transmit(&huart1 , (uint8_t *)str3, size, 0xFFFF);
          }
 
          char str[50]={0};
          uint8_t size=0;
 
          sprintf(str,"\n\r <<<<<<<<<<<<<<<<<\n\r");      // convert   in  str
          size = sizeof(str);
          HAL_UART_Transmit(&huart1 , (uint8_t *)str, size, 200);
          memset(str, 0 , sizeof(str));   // Clean str
 
          HAL_Delay(500);
      // -------------------------------------------------------------------------------------------
 
     #else
          // 2. Parsing string
 
          if(flag == 1)                             //If data from GPS module in buffer
          {
              memset(buffStr, 0, 255);                           // Clean buffStr
              sprintf(buffStr, "%s", buff);                      // Save in buffStr string from biff
              char *token;                                       // Create pointer on char
              char *string;                                      // Create pointer on char
 
              string = strdup(buffStr);                          // Дублювання buffStr в string
 
              while((token = strsep(&string, "\n")) != NULL)
              {
                  memset(nmeaSnt, 0, 80);
                  sprintf(nmeaSnt, "%s", token);
 
                  if((strstr(nmeaSnt, "$GPGLL") != 0) && strlen(nmeaSnt) > 49 && strstr(nmeaSnt, "*") != 0)
                  {
                      rawSum = strstr(nmeaSnt, "*");                        // знайти "*" в nmeaSnt.
                                                                            // Функція вертає показник на знак
                      memcpy(smNmbr, &rawSum[1], 2);                        // Копіювання даних після "*"
                      smNmbr[2]='\0';
                      uint8_t intSum = nmea0183_checksum(nmeaSnt);          // знаходження контрольної суми
                      char hex[2];
                      sprintf(hex, "%x", intSum);
 
 
                      if(strstr(smNmbr, hex) != NULL)
                      {
                          // Розділ строки на лексеми
                          // $GPGLL  1111.11    a  ууууy.уу      a  hhmmss.ss   A*hh
                          // $GPGLL, 5532.8492, N, 03729.0987, E, 004241.469, A*33
                          cnt = 0;
                          for(char *pV = strtok(nmeaSnt, ","); pV != NULL; pV = strtok(NULL, ","))
                          {
                              switch (cnt)
                              {
                              case 1:
                                  latRaw = strdup(pV);       // 1
                                  break;
                              case 2:
                                  hemNS = strdup(pV);
                                  break;
                              case 3:
                                  lonRaw = strdup(pV);
                                  break;
                              case 4:
                                  hemEW = strdup(pV);
                                  break;
                              case 5:                       // лексема часу
                                  utcRaw = strdup(pV);
                                  break;
                              }
                              cnt++;
                          }
                          // Копіювання координат в змінні
                          memcpy(latDg, &latRaw[0], 2);       // Широта в градусах
                          latDg[2] = '\0';
 
                          memcpy(latMS, &latRaw[2], 7);       // Широта в мінутах секундах
                          latMS[7] = '\0';
 
                          memcpy(lonDg, &lonRaw[0], 3);       // Довгота в градусах
                          lonDg[3] = '\0';
 
                          memcpy(lonMS, &lonRaw[3], 7);       // Довгота в мінутах секундах
                          lonMS[7] = '\0';
                          //
 
                          // Запис даних позиціонування в структуру
                          //struct GPS_data p;
                          memcpy(GPS_data.latDg, &latDg[0], 2);      // Copy
                          GPS_data.latDg[2] = '\0';
                          memcpy(GPS_data.latMS, &latMS[0], 7);
                          GPS_data.latMS[7] = '\0';
                          memcpy(GPS_data.lonDg, &lonDg[0], 3);
                          GPS_data.lonDg[3] = '\0';
                          memcpy(GPS_data.lonMS, &lonMS[0], 7);
                          GPS_data.lonMS[7] = '\0';
 
                          // Global Time
                          char strLonMS[7];
                          sprintf(strLonMS, "%s", lonMS);     // Перетворення строки lonMS в стрінг і запис її в strLonMS
                          //converting the UTC time in the hh:mm:ss format
                          memcpy(hH, &utcRaw[0], 2);
                          hH[2] = '\0';
                          memcpy(mM, &utcRaw[2], 2);
                          mM[2] = '\0';
                          memcpy(sS, &utcRaw[4], 2);
                          sS[2] = '\0';
 
                          strcpy(strUTC, hH);
                          strcat(strUTC, ":");
                          strcat(strUTC, mM);
                          strcat(strUTC, ":");
                          strcat(strUTC, sS);
                          strUTC[8] = '\0';
 
                          // Copy time data in struct variabble
                          memcpy(GPS_data.clock, strUTC, 8);
                      }
                  }
              }
 
              flag = 0;
          }
 
          HAL_Delay(1000);
          i++;    // for debug
 
        #endif
    /* 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_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != 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.ClockSpeed = 400000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */
 
  /* USER CODE END I2C1_Init 2 */
 
}
 
/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{
 
  /* USER CODE BEGIN TIM1_Init 0 */
 
  /* USER CODE END TIM1_Init 0 */
 
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
 
  /* USER CODE BEGIN TIM1_Init 1 */
 
  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 1440;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 50000;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */
 
  /* USER CODE END TIM1_Init 2 */
 
}
 
/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
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 = 115200;
  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;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}
 
/**
  * @brief USART3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART3_UART_Init(void)
{
 
  /* USER CODE BEGIN USART3_Init 0 */
 
  /* USER CODE END USART3_Init 0 */
 
  /* USER CODE BEGIN USART3_Init 1 */
 
  /* USER CODE END USART3_Init 1 */
  huart3.Instance = USART3;
  huart3.Init.BaudRate = 9600;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */
 
  /* USER CODE END USART3_Init 2 */
 
}
 
/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{
 
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();
 
  /* DMA interrupt init */
  /* DMA1_Channel3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
 
}
 
/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
 
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
 
  /*Configure GPIO pins : PA4 PA5 PA6 PA7 */
  GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PB0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
}
 
/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
        if(htim->Instance == TIM1) //check if the interrupt comes from TIM1
        {
             HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
             read_T_and_H_SI7021();
             HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
        }
}
/* 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 */
 
  /* 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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/