Передача данных по Ethernet TCP LWIP

/* USER CODE BEGIN Header */
 
/* USER CODE END Header */
 
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
#include "lwip.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdint.h"
#include "string.h"          // Transformation USART data
#include "ltdc.h"            // LTDC library
#include "MT48LC4M32B2.h"    // CDRAM memory library
#include "fonts.h"           // Fonts of LTDC library
#include "lwip/opt.h"        // LWIP library
#include "lwip/arch.h"       // LWIP library
#include "lwip/api.h"        // LWIP library
#include "semphr.h"          // Library for semaphore
/* 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 ---------------------------------------------------------*/
ADC_HandleTypeDef hadc3;
 
DMA2D_HandleTypeDef hdma2d;
 
LTDC_HandleTypeDef hltdc;
 
UART_HandleTypeDef huart1;
 
SDRAM_HandleTypeDef hsdram1;
 
osThreadId defaultTaskHandle;
osThreadId myTaskLEDsHandle;
osThreadId myAdcTaskHandle;
osThreadId myUsartTaskHandle;
osThreadId myButtonTaskHandle;
/* USER CODE BEGIN PV */
#define LCD_FRAME_BUFFER SDRAM_DEVICE_ADDR         // SDRAM address LCD
char str1[60];
char str_buf[1000]={'\0'};
osThreadId TaskStringOutHandle;
osMessageQId pos_Queue;
osMailQId strout_Queue;
typedef struct struct_sock_t {
  uint16_t y_pos;
  struct netconn *conn;
} struct_sock;
typedef struct struct_out_t {
  //uint32_t tick_count;
  uint16_t y_pos;
  char str[60];
} struct_out;
struct_sock sock01, sock02;
#define MAIL_SIZE (uint32_t) 5
//-------------------------------------------------------
xQueueHandle send_data;                 // Queue for transmit ADC data to USART
xSemaphoreHandle binary_semaphore_1;    // Semaphore for button
//-------------------------------------------------------
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MPU_Config(void);
static void MX_GPIO_Init(void);
static void MX_LTDC_Init(void);
static void MX_DMA2D_Init(void);
static void MX_FMC_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_ADC3_Init(void);
void StartDefaultTask(void const * argument);
void StartTaskLEDs(void const * argument);
void StartAdcTask(void const * argument);
void StartUsartTask(void const * argument);
void StartButtonTask(void const * argument);
 
/* USER CODE BEGIN PFP */
void TaskStringOut(void const * argument);
//-------------------------------------------------------
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin);
//-------------------------------------------------------
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//-------------------------------------------------------
char trans_str[32] = {0};          // USART sending array
uint16_t adcData = 0;
//-------------------------------------------------------
/* USER CODE END 0 */
 
int main(void)
{
  /* USER CODE BEGIN 1 */
 
  /* USER CODE END 1 */
 
  /* MPU Configuration--------------------------------------------------------*/
  MPU_Config();
 
  /* Enable I-Cache---------------------------------------------------------*/
  SCB_EnableICache();
 
  /* Enable D-Cache---------------------------------------------------------*/
  SCB_EnableDCache();
 
  /* 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_LTDC_Init();
  MX_DMA2D_Init();
  MX_FMC_Init();
  MX_USART1_UART_Init();
  MX_ADC3_Init();
  /* USER CODE BEGIN 2 */
  MT48LC4M32B2_init(&hsdram1);
  HAL_LTDC_SetAddress(&hltdc,LCD_FRAME_BUFFER,0);
  TFT_FillScreen(LCD_COLOR_BLACK);
  TFT_SetFont(&Font24);
  TFT_SetTextColor(LCD_COLOR_LIGHTGREEN);
  TFT_DisplayString(0, 10, (uint8_t *)"TCP Server", CENTER_MODE);
  /* USER CODE END 2 */
 
  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */
 
  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
    //-------------------------------------------------------
    vSemaphoreCreateBinary(binary_semaphore_1);              // Semaphore for button
    xSemaphoreTake(binary_semaphore_1, portMAX_DELAY);
    //-------------------------------------------------------
  /* USER CODE END RTOS_SEMAPHORES */
 
  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */
 
  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  osMailQDef(stroutqueue, MAIL_SIZE, struct_out);
  strout_Queue = osMailCreate(osMailQ(stroutqueue), NULL);
  //-------------------------------------------------------
  send_data = xQueueCreate(1, sizeof(uint16_t));           // Queue for transmit ADC data to USART
  //-------------------------------------------------------
  /* USER CODE END RTOS_QUEUES */
 
  /* Create the thread(s) */
  /* definition and creation of defaultTask */
  osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 1280);
  defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
 
  /* definition and creation of myTaskLEDs */
  osThreadDef(myTaskLEDs, StartTaskLEDs, osPriorityIdle, 0, 128);
  myTaskLEDsHandle = osThreadCreate(osThread(myTaskLEDs), NULL);
 
  /* definition and creation of myAdcTask */
  osThreadDef(myAdcTask, StartAdcTask, osPriorityNormal, 0, 128);
  myAdcTaskHandle = osThreadCreate(osThread(myAdcTask), NULL);
 
  /* definition and creation of myUsartTask */
  osThreadDef(myUsartTask, StartUsartTask, osPriorityNormal, 0, 128);
  myUsartTaskHandle = osThreadCreate(osThread(myUsartTask), NULL);
 
  /* definition and creation of myButtonTask */
  osThreadDef(myButtonTask, StartButtonTask, osPriorityNormal, 0, 128);
  myButtonTaskHandle = osThreadCreate(osThread(myButtonTask), NULL);
 
  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  osThreadDef(tskstrout, TaskStringOut, osPriorityBelowNormal, 0, 1280);
  TaskStringOutHandle = osThreadCreate(osThread(tskstrout), NULL);
  /* USER CODE END RTOS_THREADS */
 
  /* Start scheduler */
  osKernelStart();
 
  /* We should never get here as control is now taken by the scheduler */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
 
void SystemClock_Config(void)
{
  // 
}
 
static void MX_ADC3_Init(void)
{
 
  /* USER CODE BEGIN ADC3_Init 0 */
 
  /* USER CODE END ADC3_Init 0 */
 
  ADC_ChannelConfTypeDef sConfig = {0};
 
  /* USER CODE BEGIN ADC3_Init 1 */
 
  /* USER CODE END ADC3_Init 1 */
//
  /* USER CODE BEGIN ADC3_Init 2 */
 
  /* USER CODE END ADC3_Init 2 */
 
}
 
static void MX_DMA2D_Init(void)
{
 
  /* USER CODE BEGIN DMA2D_Init 0 */
 
  /* USER CODE END DMA2D_Init 0 */
 
  /* USER CODE BEGIN DMA2D_Init 1 */
 
  /* USER CODE END DMA2D_Init 1 */
//
  if (HAL_DMA2D_Init(&hdma2d) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_DMA2D_ConfigLayer(&hdma2d, 0) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_DMA2D_ConfigLayer(&hdma2d, 1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DMA2D_Init 2 */
 
  /* USER CODE END DMA2D_Init 2 */
 
}
 
static void MX_LTDC_Init(void)
{
 
  /* USER CODE BEGIN LTDC_Init 0 */
 
  /* USER CODE END LTDC_Init 0 */
 
  LTDC_LayerCfgTypeDef pLayerCfg = {0};
 
  /* USER CODE BEGIN LTDC_Init 1 */
 
  /* USER CODE END LTDC_Init 1 */
 //
  /* USER CODE BEGIN LTDC_Init 2 */
 
  /* USER CODE END LTDC_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;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}
 
/* FMC initialization function */
static void MX_FMC_Init(void)
{
 
  /* USER CODE BEGIN FMC_Init 0 */
 
  /* USER CODE END FMC_Init 0 */
 
  FMC_SDRAM_TimingTypeDef SdramTiming = {0};
 
  /* USER CODE BEGIN FMC_Init 1 */
 
  /* USER CODE END FMC_Init 1 */
 
  /** Perform the SDRAM1 memory initialization sequence
  */
  hsdram1.Instance = FMC_SDRAM_DEVICE;
  /* hsdram1.Init */
  hsdram1.Init.SDBank = FMC_SDRAM_BANK1;
  hsdram1.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_8;
  hsdram1.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_12;
  hsdram1.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_16;
  hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_2;
  hsdram1.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_2;
  hsdram1.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
  hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2;
  hsdram1.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
  hsdram1.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0;
  /* SdramTiming */
  SdramTiming.LoadToActiveDelay = 2;
  SdramTiming.ExitSelfRefreshDelay = 6;
  SdramTiming.SelfRefreshTime = 4;
  SdramTiming.RowCycleDelay = 6;
  SdramTiming.WriteRecoveryTime = 2;
  SdramTiming.RPDelay = 2;
  SdramTiming.RCDDelay = 2;
 
  if (HAL_SDRAM_Init(&hsdram1, &SdramTiming) != HAL_OK)
  {
    Error_Handler( );
  }
 
  /* USER CODE BEGIN FMC_Init 2 */
 
  /* USER CODE END FMC_Init 2 */
}
 
/**
  * @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_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOJ_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOK_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOI_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOK, GPIO_PIN_3, GPIO_PIN_SET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOI, GPIO_PIN_1, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOI, GPIO_PIN_12, GPIO_PIN_SET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_7|GPIO_PIN_6, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6, GPIO_PIN_RESET);
 
  /*Configure GPIO pin : PK3 */
  GPIO_InitStruct.Pin = GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOK, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PI1 */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PI12 */
  GPIO_InitStruct.Pin = GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PI11 */
  GPIO_InitStruct.Pin = GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PC7 PC6 */
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PG6 */
  GPIO_InitStruct.Pin = GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
 
  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
 
}
 
/* USER CODE BEGIN 4 */
//-------------------------------------------------------
// EXTI button function
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
  if(GPIO_Pin== GPIO_PIN_11)
    {
        xSemaphoreGiveFromISR(binary_semaphore_1,&xHigherPriorityTaskWoken);
        portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
    }
    else
    {
        __NOP();
    }
}
//-------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------
void TaskStringOut(void const * argument)
{
  osEvent event;
  struct_out *qstruct;
  for(;;)
  {
    event = osMailGet(strout_Queue, osWaitForever);
    if (event.status == osEventMail)
    {
        qstruct = event.value.p;
        sprintf(str1,"%s", qstruct->str);
        TFT_DisplayString(50, qstruct->y_pos, (uint8_t *)str1, LEFT_MODE);
    }
  }
}
//-----------------------------------------------------------------------------------------------
static void tcp_thread(void *arg)
{
    struct_out *qstruct;                 // Structure for output the string into LCD with help of queue
    err_t err, recv_err;                 // Variables for arguments (errors)
    struct netconn *conn;                // Structure for connection
    struct netbuf *inbuf;                // Pointer to connection buffer
    struct netconn *newconn;             // Pointer to new connection
    struct_sock *arg_sock;               // Pointer to arguments of task
    arg_sock = (struct_sock*) arg;
    conn = arg_sock->conn;
    u16_t buflen;
    char* buf;
    TFT_SetTextColor(LCD_COLOR_BLUE);
    for(;;)
    {
      err = netconn_accept(conn, &newconn); // Binding the socket struck for sending data and TCP struck
      if (err == ERR_OK)
      {
        netconn_write(newconn, "READY", 5, NETCONN_COPY);            // Sending "READY"
        for(;;)
        {
          recv_err = netconn_recv(newconn, &inbuf);                  // Receiving the socket data in inbuf
          if (recv_err == ERR_OK)
          {
            netbuf_data(inbuf, (void**)&buf, &buflen);               // Data transfer of the inbuf data to buf
            if((buf[0]==0x0D)||(buf[0]==0x0A))                       // Checking of the data ending
            {
              netbuf_delete(inbuf);
              continue;
            }
            qstruct = osMailAlloc(strout_Queue, osWaitForever);
            qstruct->y_pos = arg_sock->y_pos;
            strncpy(str_buf,buf,buflen);
            str_buf[buflen]=0;
            sprintf(qstruct->str,"%-20s", str_buf);
            osMailPut(strout_Queue, qstruct);
            osMailFree(strout_Queue, qstruct);
            str_buf[buflen] = '\r';
            str_buf[buflen+1] = '\n';
            netconn_write(newconn, str_buf, buflen+2, NETCONN_COPY);
            netbuf_delete(inbuf);
          }
          else
          {
            netbuf_delete(inbuf);
            netconn_close(newconn);
            netconn_delete(newconn);
            break;
          }
        }
      }
      else
      {
        osDelay(1);
      }
    }
    //for(;;)
    //{
        //osDelay(1);
    //}
}
//-----------------------------------------------------------------------------------------------
/* USER CODE END 4 */
 
/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used 
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void const * argument)
{
  /* init code for LWIP */
  MX_LWIP_Init();
  /* USER CODE BEGIN 5 */
  //-----------------------------------------------------------
  struct netconn *conn;
  err_t err;
  sock01.y_pos = 60;
  sock02.y_pos = 180;
  conn = netconn_new(NETCONN_TCP);
  if(conn!=NULL)
  {
    sock01.conn = conn;
    sock02.conn = conn;
    err = netconn_bind(conn, NULL, 80);
    if (err == ERR_OK)
    {
      netconn_listen(conn);
      sys_thread_new("tcp_thread1", tcp_thread, (void*)&sock01, DEFAULT_THREAD_STACKSIZE, osPriorityNormal );
      sys_thread_new("tcp_thread2", tcp_thread, (void*)&sock02, DEFAULT_THREAD_STACKSIZE, osPriorityNormal );
    }
    else
    {
      netconn_delete(conn);
    }
  }
  //-----------------------------------------------------------
  /* Infinite loop */
  for(;;)
  {
      osDelay(1);
  }
  /* USER CODE END 5 */ 
}
 
/* USER CODE BEGIN Header_StartTaskLEDs */
/**
* @brief Function implementing the myTaskLEDs thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTaskLEDs */
void StartTaskLEDs(void const * argument)
{
  /* USER CODE BEGIN StartTaskLEDs */
  /* Infinite loop */
  for(;;)
  {
    // Toggle pins
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_7);
    osDelay(1000);
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_6);
    osDelay(1000);
  }
  /* USER CODE END StartTaskLEDs */
}
 
/* USER CODE BEGIN Header_StartAdcTask */
/**
* @brief Function implementing the myAdcTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartAdcTask */
void StartAdcTask(void const * argument)
{
  /* USER CODE BEGIN StartAdcTask */
  /* Infinite loop */
  //-------------------------------------------------------
  uint16_t adcData = 0;                       // ADC data
  //volatile uint16_t adcDataArray[2] = {0,0};
  for(;;)
  {
    HAL_ADC_Start(&hadc3);
    HAL_ADC_PollForConversion(&hadc3, 100);
    adcData = HAL_ADC_GetValue(&hadc3);
    HAL_ADC_Stop(&hadc3);
    xQueueSend(send_data, &adcData, 100);
    osDelay(1000);
  }
  //-------------------------------------------------------
  /* USER CODE END StartAdcTask */
}
 
/* USER CODE BEGIN Header_StartUsartTask */
 
/* USER CODE END Header_StartUsartTask */
void StartUsartTask(void const * argument)
{
  /* USER CODE BEGIN StartUsartTask */
  /* Infinite loop */
  //-------------------------------------------------------
  uint16_t adcSendData;                        // ADC send data
  for(;;)
  {
    // USART sending ADC data
    xQueueReceive(send_data, &adcSendData, 100);
    snprintf(trans_str, 32, "%d\r\n", adcSendData);
    HAL_UART_Transmit(&huart1, (uint8_t*)trans_str, strlen(trans_str), 100);
    osDelay(1000);
    //------------------------------------------------------
  }
    //-------------------------------------------------------
  /* USER CODE END StartUsartTask */
}
 
/* USER CODE BEGIN Header_StartButtonTask */
/**
* @brief Function implementing the myButtonTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartButtonTask */
void StartButtonTask(void const * argument)
{
  /* USER CODE BEGIN StartButtonTask */
  /* Infinite loop */
  //-------------------------------------------------------
  // Button function
  for(;;)
  {
    xSemaphoreTake(binary_semaphore_1, portMAX_DELAY);
    HAL_GPIO_TogglePin(GPIOG, GPIO_PIN_6);
    HAL_UART_Transmit(&huart1,(uint8_t*)"Hello!!!\r\n",10,1000);
    osDelay(1);
  }
  //-------------------------------------------------------
  /* USER CODE END StartButtonTask */
}
 
/* MPU Configuration */
 
void MPU_Config(void)
{
  MPU_Region_InitTypeDef MPU_InitStruct = {0};
 
  /* Disables the MPU */
  HAL_MPU_Disable();
  /** Initializes and configures the Region and the memory to be protected 
  */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.BaseAddress = 0xC0000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_4MB;
  MPU_InitStruct.SubRegionDisable = 0x0;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
 
  HAL_MPU_ConfigRegion(&MPU_InitStruct);
  /* Enables the MPU */
  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
 
}
/**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM1 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */
 
  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */
  //--------------------------------------------------------
 
  //--------------------------------------------------------
  /* USER CODE END Callback 1 */
}
 
void Error_Handler(void)
{
}
 
#ifdef  USE_FULL_ASSERT
 
void assert_failed(uint8_t *file, uint32_t line)
{ 
 
}
#endif /* USE_FULL_ASSERT */
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/