/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 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 "usart.h"

/* USER CODE BEGIN 0 */
extern adc_struct adc_str;//структура ацп
#include "icd.h"
uint8_t TX_BUF[TX_PLOAD_WIDTH+1];
uint8_t MESH_BUF[MESH_PLOAD_WIDTH+1];
/* USER CODE END 0 */

UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart1_rx;

/* USART1 init function */

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 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* USART1 clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PB6     ------> USART1_TX
    PB7     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    __HAL_AFIO_REMAP_USART1_ENABLE();

    /* USART1 DMA Init */
    /* USART1_TX Init */
    hdma_usart1_tx.Instance = DMA1_Channel4;
    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_tx.Init.Mode = DMA_NORMAL;
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);

    /* USART1_RX Init */
    hdma_usart1_rx.Instance = DMA1_Channel5;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);

    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspDeInit 0 */

  /* USER CODE END USART1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART1_CLK_DISABLE();

    /**USART1 GPIO Configuration
    PB6     ------> USART1_TX
    PB7     ------> USART1_RX
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_6|GPIO_PIN_7);

    /* USART1 DMA DeInit */
    HAL_DMA_DeInit(uartHandle->hdmatx);
    HAL_DMA_DeInit(uartHandle->hdmarx);

    /* USART1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
void print_usart(const char *pFormat, ...)
{
	va_list ap;
	static char tbuff[256];
	static HAL_StatusTypeDef res;
    // Forward call to vsprintf
    va_start(ap, pFormat);
    vsprintf(tbuff, pFormat, ap);
//    HAL_UART_Transmit(&huart1, (unsigned char*)tbuff, strlen(tbuff), 10);
    res = HAL_UART_Transmit_DMA(&huart1, (unsigned char*)tbuff, strlen(tbuff));
    va_end(ap);
}

void ble_control(ctrl_struct* control)
{
	if(control->ble_mode_now != control->ble_mode_set)
	{
		if(control->ble_mode_set == ble_off)
		{
			HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, RESET);
			control->ble_mode_now = ble_off;
		}
		if(control->ble_mode_set == ble_raw)
		{
			HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, RESET);
			HAL_GPIO_WritePin(BLE_PWRC_GPIO_Port, BLE_PWRC_Pin, RESET);
			HAL_Delay(100);
			control->ble_mode_now = ble_off;
			HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, SET);
			HAL_Delay(2000);
			print_usart("AT+ROLE0\r\n");//это режим мастер-слейв в нем устройство потребляет 1мА
			HAL_Delay(100);
			print_usart("AT+NAMEECG_RAW_%04x\r\n",control->serial_number);//set name
			HAL_Delay(100);
			print_usart("AT+TYPE1\r\n");//slave
			HAL_Delay(100);
			print_usart("AT+PIN%06d\r\n",control->password);//slave
			HAL_Delay(100);
			print_usart("AT+RESET\r\n");//подтверждение настроек
			HAL_Delay(1000);
			HAL_GPIO_WritePin(BLE_PWRC_GPIO_Port, BLE_PWRC_Pin, SET);
			control->ble_mode_now = ble_raw;
		}
		if(control->ble_mode_set == ble_mesh)
		{
			HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, RESET);
			HAL_GPIO_WritePin(BLE_PWRC_GPIO_Port, BLE_PWRC_Pin, RESET);
			HAL_Delay(100);
			control->ble_mode_now = ble_off;
			HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, SET);
			HAL_Delay(2000);
			print_usart("AT+ROLE5\r\n");//в режиме MESH 4мА
			HAL_Delay(100);
			print_usart("AT+MADDR%04x\r\n",control->serial_number);//адрес в сети должен быть разным у всех устройств сети
			HAL_Delay(100);
			print_usart("AT+NETID%04x\r\n",control->mesh_netid);//номер сети должен быть одним у всех устройсв сети
			HAL_Delay(100);
			print_usart("AT+NAMEECG_MESH_%04x\r\n",control->serial_number);//set name
			HAL_Delay(100);
			print_usart("AT+RESET\r\n");//подтверждение настроек
			HAL_Delay(1000);
			HAL_GPIO_WritePin(BLE_PWRC_GPIO_Port, BLE_PWRC_Pin, SET);
			control->ble_mode_now = ble_mesh;
		}
	}
}
void ble_deinit(void)
{
	HAL_GPIO_WritePin(BLE_PWR_GPIO_Port, BLE_PWR_Pin, RESET);
}


void ble_HEX(ctrl_struct* control, adc_struct* adc,bool send)
{
	//HAL_GPIO_WritePin(GPIOA, LED_Pin, SET);
	TX_BUF[0]	=	0x55;//стартовый байт
    //акселерометры и гироскоп можно в одно место пихать, только
    //пакуем акселерометры
	TX_BUF[13]	= (adc->ecg_1_raw >> 8) & 0xFF;
	TX_BUF[14]	= (adc->ecg_1_raw & 0xFF);

	TX_BUF[15] = (adc->ecg_2_raw >> 8) & 0xFF;
	TX_BUF[16] = (adc->ecg_2_raw & 0xFF);

	TX_BUF[17] = (adc->ecg_3_raw >> 8) & 0xFF;
	TX_BUF[18] = (adc->ecg_3_raw & 0xFF);

//    TX_BUF[28]   = (control->rf_counter >> 16) & 0xFF;
//    TX_BUF[29]   = (control->rf_counter >> 8)  & 0xFF;
//    TX_BUF[30]   = (control->rf_counter & 0xFF);

    TX_BUF[31] = 0x77;//конечный байт
    //HAL_GPIO_WritePin(GPIOA, LED_Pin, RESET);
    //данные шлём не всегда.
    if((control->ble_mode_set == ble_raw) && (control->ble_mode_now == ble_raw))
    	if(send) HAL_UART_Transmit_DMA(&huart1, TX_BUF, TX_PLOAD_WIDTH);//TX_PLOAD_WIDTH);//было до этого TX_PLOAD_WIDTH+1 но работало не очень
}

void float2Bytes(float float_variable,uint8_t bytes_temp[4])
{
  memcpy(bytes_temp, (unsigned char*) (&float_variable), 4);
}


void ble_HEX_new(ctrl_struct* control, icd_str * icd_str, adc_struct* adc,bool send)
{
	//HAL_GPIO_WritePin(GPIOA, LED_Pin, SET);
	TX_BUF[0]	=	0x55;//стартовый байт

	static uint8_t bytes[4];


	TX_BUF[1]   = (icd_str->counter >> 24) & 0xFF;
    TX_BUF[2]   = (icd_str->counter >> 16) & 0xFF;
    TX_BUF[3]   = (icd_str->counter >> 8)  & 0xFF;
    TX_BUF[4]   = (icd_str->counter & 0xFF);

	float2Bytes(icd_str->ecg_rv_din_treshold,&bytes[0]);//fixme временно

	TX_BUF[5]  = bytes[0];
	TX_BUF[6]  = bytes[1];
	TX_BUF[7]  = bytes[2];
	TX_BUF[8]  = bytes[3];

	float2Bytes(icd_str->ecg_rv_pos_sig,&bytes[0]);

	TX_BUF[9]  = bytes[0];
	TX_BUF[10] = bytes[1];
	TX_BUF[11] = bytes[2];
	TX_BUF[12] = bytes[3];

	if(icd_str->dc_cut)
		float2Bytes((icd_str->ecg_rv_filt - icd_str->ecg_rv_mov_av),&bytes[0]);
	else
		float2Bytes((icd_str->ecg_rv_filt),&bytes[0]);

	TX_BUF[13] = bytes[0];
	TX_BUF[14] = bytes[1];
	TX_BUF[15] = bytes[2];
	TX_BUF[16] = bytes[3];

//	TX_BUF[17] = ((icd_str->last_RR_poz_rel*5) >> 8) & 0xFF;
//	TX_BUF[18] = ((icd_str->last_RR_poz_rel*5) & 0xFF);
//	TX_BUF[17] = ((adc->hv_volt) >> 8) & 0xFF;
//	TX_BUF[18] = ((adc->hv_volt) & 0xFF);
	TX_BUF[17] = ((adc->bat_volt) >> 8) & 0xFF;
	TX_BUF[18] = ((adc->bat_volt) & 0xFF);

	TX_BUF[19] = (((uint8_t)icd_str->search_now_mode & 0x7)<<5)
			| (((uint8_t)icd_str->sub_mode & 0x7)<<2)| (((uint8_t)icd_str->terapy_now & 0x3)<<0);

	TX_BUF[20] = (((uint8_t)icd_str->filter_on & 0x1)<<7) |(((uint8_t)icd_str->work_set_mode & 0x3)<<5)|
			(((uint8_t)icd_str->LV_on & 0x1)<<4) | (((uint8_t)icd_str->HV_on & 0x1)<<3)|
			(((uint8_t)icd_str->rr_now & 0x1)<<2)| (((uint8_t)icd_str->last_QRS & 0x3)<<0);
//	bool	LV_on;// реально стимулируем низковольтно
//	bool	HV_on;// реально стимулируем высоковольтно


	//2 байта запас
	//счётчик до последнего события в мс
//	TX_BUF[13] = ((icd_str->last_RR_poz_rel*5) >> 8) & 0xFF;
//	TX_BUF[14] = ((icd_str->last_RR_poz_rel*5) & 0xFF);
//	TX_BUF[13] = ((icd_str->now_energy) >> 8) & 0xFF;
//	TX_BUF[14] = ((icd_str->now_energy) & 0xFF);
	//значение последнего периода fixme по идее не имеет смысла
//	TX_BUF[15] = ((icd_str->last_period*5) >> 8) & 0xFF;
//	TX_BUF[16] = ((icd_str->last_period*5) & 0xFF);
//	TX_BUF[15] = ((icd_str->now_energy) >> 8) & 0xFF;
//	TX_BUF[16] = ((icd_str->now_energy) & 0xFF);
//		TX_BUF[15] = 0;
//		TX_BUF[16] = (((uint8_t)icd_str->sub_mode) & 0xFF);


	//не будем выпендриваться займём 8последних байт
	if(icd_str->counter % 10 == 0)
	{
		float2Bytes(icd_str->min_tres,&bytes[0]);
		TX_BUF[23] = bytes[0];
		TX_BUF[24] = bytes[1];
		TX_BUF[25] = bytes[2];
		TX_BUF[26] = bytes[3];

		float2Bytes(icd_str->max_tres,&bytes[0]);//fixme временно
		TX_BUF[27] = bytes[0];
		TX_BUF[28] = bytes[1];
		TX_BUF[29] = bytes[2];
		TX_BUF[30] = bytes[3];

	}
	else if(icd_str->counter % 10 == 1)
	{
		float2Bytes(icd_str->square_coef,&bytes[0]);
		TX_BUF[23] = bytes[0];
		TX_BUF[24] = bytes[1];
		TX_BUF[25] = bytes[2];
		TX_BUF[26] = bytes[3];

		float2Bytes(icd_str->triangle_coef,&bytes[0]);//fixme временно
		TX_BUF[27] = bytes[0];
		TX_BUF[28] = bytes[1];
		TX_BUF[29] = bytes[2];
		TX_BUF[30] = bytes[3];
	}
	else if(icd_str->counter % 10 == 2)
	{
		//	время слепоты при включении
		TX_BUF[23] = ((icd_str->start_up_time*5) >> 8) & 0xFF;
		TX_BUF[24] = ((icd_str->start_up_time*5) & 0xFF);
		//	время поиска в базовом режиме с минимальным порогом
		TX_BUF[25] = ((icd_str->base_time*5) >> 8) & 0xFF;
		TX_BUF[26] = ((icd_str->base_time*5) & 0xFF);
		//	Время в мс которое алгоритм ищет максимум
		TX_BUF[27] = ((icd_str->max_search_time*5) >> 8) & 0xFF;
		TX_BUF[28] = ((icd_str->max_search_time*5) & 0xFF);
		//	Время в мс нахождения в режиме поиска квадратов
		TX_BUF[29] = ((icd_str->square_time*5) >> 8) & 0xFF;
		TX_BUF[30] = ((icd_str->square_time*5) & 0xFF);
	}
	else if(icd_str->counter % 10 == 3)
	{
		TX_BUF[24] = (((uint8_t)icd_str->dc_cut & 0x1)<<3)|
				(((uint8_t)icd_str->sd_card & 0x1)<<2)| (((uint8_t)icd_str->active_ch & 0x3)<<0);
		//сопротивление потенциометра
		TX_BUF[25] = ((icd_str->spi_pot_set)) & 0xFF;
		//напряжение в процентах
		TX_BUF[26] = ((adc_str.bat_pers) & 0xFF);
		//напряжение на АКБ
		TX_BUF[27] = ((adc_str.bat_volt) >> 8) & 0xFF;
		TX_BUF[28] = ((adc_str.bat_volt) & 0xFF);
		//напряжение на конденсаторе
		TX_BUF[29] = ((adc_str.hv_volt) >> 8) & 0xFF;
		TX_BUF[30] = ((adc_str.hv_volt) & 0xFF);
	}
	else if(icd_str->counter % 10 == 4)
	{
		//	время слепоты при включении
		TX_BUF[23] = ((icd_str->lv_stop_time*5) >> 8) & 0xFF;
		TX_BUF[24] = ((icd_str->lv_stop_time*5) & 0xFF);
		//	время на весь qrs
		TX_BUF[25] = ((icd_str->max_time*5) >> 8) & 0xFF;
		TX_BUF[26] = ((icd_str->max_time*5) & 0xFF);
		//	время между последним и предпоследним событием
		TX_BUF[27] = ((icd_str->last_period*5) >> 8) & 0xFF;
		TX_BUF[28] = ((icd_str->last_period*5) & 0xFF);
	}
	else if(icd_str->counter % 10 == 5)
	{
		//счётчик собственных сокращений сердца 24 бита
		TX_BUF[23] = ((icd_str->Vs_cnt) >> 16) & 0xFF;
		TX_BUF[24] = ((icd_str->Vs_cnt) >> 8) & 0xFF;
		TX_BUF[25] = ((icd_str->Vs_cnt) & 0xFF);
		//счётчик собственных сокращений которые в шуме(не детектируется
		TX_BUF[26] = ((icd_str->Vn_cnt) >> 8) & 0xFF;
		TX_BUF[27] = ((icd_str->Vn_cnt) & 0xFF);
		//счётчик принудительных стимуляций сердца низким напряжением(низковольтная стимуляция)
		TX_BUF[28] = ((icd_str->Vp_cnt) >> 16) & 0xFF;
		TX_BUF[29] = ((icd_str->Vp_cnt) >> 8) & 0xFF;
		TX_BUF[30] = ((icd_str->Vp_cnt) & 0xFF);
	}
	else if(icd_str->counter % 10 == 6)
	{
		//порог периода фибриляции если период меньше, чем это число это фибриляция
		TX_BUF[23] = ((icd_str->fibr_tres*5) >> 8) & 0xFF;
		TX_BUF[24] = ((icd_str->fibr_tres*5) & 0xFF);
		//порог периода Тахикардии 2 если период меньше, чем это число это Тахикардия 2
		TX_BUF[25] = ((icd_str->tachy_2_tres*5) >> 8) & 0xFF;
		TX_BUF[26] = ((icd_str->tachy_2_tres*5) & 0xFF);
		//порог периода Тахикардии 1 если период меньше, чем это число это Тахикардия 1
		TX_BUF[27] = ((icd_str->tachy_1_tres*5) >> 8) & 0xFF;
		TX_BUF[28] = ((icd_str->tachy_1_tres*5) & 0xFF);
		//сбрасываемый счётчик Vs событи
		TX_BUF[29] = ((icd_str->vs_cnt_last) >> 8) & 0xFF;
		TX_BUF[30] = ((icd_str->vs_cnt_last) & 0xFF);
	}
	else if(icd_str->counter % 10 == 7)
	{
		//фильтрованный скользящим средним период
		TX_BUF[23] = ((icd_str->filt_period*5) >> 8) & 0xFF;
		TX_BUF[24] = ((icd_str->filt_period*5) & 0xFF);
		//счётчик фибриляции при обнаружении короткого RR он растёт
		TX_BUF[25] = ((icd_str->fibr_cnt) & 0xFF);
		//счётчик Тахикардии 2 при обнаружении короткого RR он растёт
		TX_BUF[26] = ((icd_str->tachy_2_cnt) & 0xFF);
		//счётчик Тахикардии 1 при обнаружении короткого RR он растёт
		TX_BUF[27] = ((icd_str->tachy_1_cnt) & 0xFF);
		//счётчик нормальных событий при достижении 5 сбрасываем все корзины
		TX_BUF[28] = ((icd_str->norm_cnt) & 0xFF);
		//порог счётчика фибриляций при котором начинаем терапию
		TX_BUF[29] = ((icd_str->fibr_max_tres) & 0xFF);
	}
	else if(icd_str->counter % 10 == 8)
	{
		//фильтрованный скользящим средним период
		TX_BUF[23] = (((uint8_t)icd_str->hv_step_number & 0xF)<<4)|(((uint8_t)icd_str->hv_step_cnt & 0xF)<<0);
		//сколько джоулей в одном шаге считаем в зависимости от минимума и максимума.
		TX_BUF[24] = ((icd_str->hv_step_energy) >> 8) & 0xFF;
		TX_BUF[25] = ((icd_str->hv_step_energy) & 0xFF);
		//так как всегда мало потратим 1 байт
		TX_BUF[26] = (icd_str->min_energy) & 0xFF;
		//текущая энергия конденсатора
		TX_BUF[27] = ((icd_str->now_energy) >> 8) & 0xFF;
		TX_BUF[28] = ((icd_str->now_energy) & 0xFF);
		//максимальная энергия конденсатора
		TX_BUF[29] = ((icd_str->max_energy) >> 8) & 0xFF;
		TX_BUF[30] = ((icd_str->max_energy) & 0xFF);
	}
	else if(icd_str->counter % 10 == 9)
	{
		//время которое мы слепы после HV разряда
		TX_BUF[23] = ((icd_str->hv_blind_time*5) >> 8) & 0xFF;
		TX_BUF[24] = ((icd_str->hv_blind_time*5) & 0xFF);
		//какой длинны мы заполныем буффер при редетекции//сколько нам нужно плохих событий для запуска терапии
		TX_BUF[25] = (((uint8_t)icd_str->redet_num & 0xF)<<4)|((uint8_t)icd_str->redet_bad & 0xF);
		//сколько всего событий в редетекции//сколько реально плохих событий
		TX_BUF[26] = (((uint8_t)icd_str->redet_cnt & 0xF)<<4)|(((uint8_t)icd_str->redet_bad_cnt & 0xF)<<0);
		//время которое мы ничего не делаем если терапия не сработала
		TX_BUF[27] = ((icd_str->standby_timer) >> 24) & 0xFF;
		TX_BUF[28] = ((icd_str->standby_timer) >> 16) & 0xFF;
		TX_BUF[29] = ((icd_str->standby_timer) >> 8) & 0xFF;
		TX_BUF[30] = ((icd_str->standby_timer) & 0xFF);
	}


    TX_BUF[31] = 0x77;//конечный байт
    //HAL_GPIO_WritePin(GPIOA, LED_Pin, RESET);
    //данные шлём не всегда.
    if((control->ble_mode_set == ble_raw) && (control->ble_mode_now == ble_raw))
    	if(send) HAL_UART_Transmit_DMA(&huart1, TX_BUF, TX_PLOAD_WIDTH);//TX_PLOAD_WIDTH);//было до этого TX_PLOAD_WIDTH+1 но работало не очень
}
/* USER CODE END 1 */

