/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "usart.h"
#include "my.h"
#include "tim.h"

UART_HandleTypeDef huart7;

extern __IO bool Initialized;
extern volatile UserData_TypeDef pardata, pardata_old;
extern volatile uint8_t menu;
extern __IO uint32_t ACTIVE_CHANNEL, CNT_CHANNELS, MASK_CHANNELS;

extern volatile bool focused;

uint8_t iobuf[256];
uint8_t rx[256];

uint8_t ip[4] = {0, 0, 0, 0};

__IO bool ASK_COMPLETE = false;
__IO bool UART_ERROR = 0;
__IO bool TX_OK = 0, RX_OK = 0;

uint8_t timeout;
uint16_t lastbyte;
uint8_t iolen = 0;
uint8_t ioa;
bool sendreq = false;
bool setbaud = true;
bool send = true;
__IO uint16_t delayREDE;
__IO bool needSave = false;
__IO bool needParam = false;

__IO uint32_t oldTime = 0, Time = 0, delta = 0;


const int8_t inversely[] = {3, 1, -1,-3};	//��� �������� float-���������� �� �������� �����
const float32_t tempF[] = {0, 0, 0, 0};

__IO bool ip_assigned = false;




void MX_UART7_Init(void)
{

	huart7.Instance = UART7;
	huart7.Init.BaudRate = BAUDRATE[pardata.BAUD];
	switch(pardata.INFB)
	{
		case 0: //NONE
			huart7.Init.WordLength = UART_WORDLENGTH_8B;
			huart7.Init.Parity = UART_PARITY_NONE;
		break;
		case 1:	//ODD
			huart7.Init.WordLength = UART_WORDLENGTH_9B;
			huart7.Init.Parity = UART_PARITY_ODD;
		break;
		case 2:	//EVEN
			huart7.Init.WordLength = UART_WORDLENGTH_9B;
			huart7.Init.Parity = UART_PARITY_EVEN;
		break;
	}
	huart7.Init.StopBits = UART_STOPBITS_1;
	huart7.Init.Mode = UART_MODE_TX_RX;
	huart7.Init.HwFlowCtl = UART_HWCONTROL_NONE;

	if(pardata.BAUD < 9)
		huart7.Init.OverSampling = UART_OVERSAMPLING_16;
		else huart7.Init.OverSampling = UART_OVERSAMPLING_8;

	huart7.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
	huart7.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_SWAP_INIT;
	huart7.AdvancedInit.Swap = UART_ADVFEATURE_SWAP_ENABLE;
	if(HAL_UART_Init(&huart7) != HAL_OK) {
		Error_Handler();
	}


	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
	HAL_Delay(1);
	//SET_BIT(huart7.Instance->CR1, /*USART_CR1_RXNEIE |*/ USART_CR1_PEIE);
}


void MX_USART7_UART_DeInit(void)
{
	if(HAL_UART_DeInit(&huart7) != HAL_OK) {
		Error_Handler();
	}
	HAL_NVIC_DisableIRQ(UART7_IRQn);
}


void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==UART7)
  {
    __HAL_RCC_UART7_CLK_ENABLE();
    __HAL_RCC_GPIOF_CLK_ENABLE();
    /**UART7 GPIO Configuration
    PF6     ------> UART7_RX
    PF7     ------> UART7_TX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF8_UART7;
    HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

    /* UART7 interrupt Init */
    HAL_NVIC_SetPriority(UART7_IRQn, 10, 0);
    HAL_NVIC_EnableIRQ(UART7_IRQn);
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{
	if(uartHandle->Instance==UART7)
	{
		__HAL_RCC_UART7_CLK_DISABLE();
		HAL_GPIO_DeInit(GPIOF, GPIO_PIN_6|GPIO_PIN_7);
		HAL_NVIC_DisableIRQ(UART7_IRQn);
	}
}


void UART7_IRQHandler(void)
{
	if((__HAL_UART_GET_IT_SOURCE(&huart7, UART_IT_RXNE))  &&  (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE)))
	{
		HAL_UART_RxCpltCallback(&huart7);
	}
	else
	{
		HAL_UART_IRQHandler(&huart7);
	}

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_IDLE))
		__HAL_UART_CLEAR_IDLEFLAG(&huart7);
}


uint16_t Crc16(uint16_t len)
{
uint16_t i;
uint16_t crc = 0xFFFF;

	for(i = 0; i < len; i++) {
		crc = (crc >> 8) ^ Crc16Table[(crc & 0xFF) ^ iobuf[i]];
	}
	return crc;
}

uint16_t Crc16_RX(uint16_t len)
{
uint16_t i;
uint16_t crc = 0xFFFF;

	for(i = 0; i < len; i++) {
		crc = (crc >> 8) ^ Crc16Table[(crc & 0xFF) ^ rx[i]];
	}
	return crc;
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
	TX_OK = true;
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	RX_OK = true;
}

void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
	RX_OK = TX_OK = false;
	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
	HAL_UART_Abort_IT(&huart7);
	UART_ERROR = true;
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

int8_t ReadIP(void)
{
int8_t res = -1;
uint16_t i, len = 0, cnt = 0;
uint16_t crc;
__IO uint32_t timeout;


	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));

	iobuf[len++] = 17;
	iobuf[len++] = 0x03;
	iobuf[len++] = HI(4001);
	iobuf[len++] = LO(4001);
	iobuf[len++] = 0;	//
	iobuf[len++] = 2;	//
	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 50));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт

		if(HAL_UART_Receive(&huart7, rx, 9, 100) == HAL_OK)
		{
			crc = (uint16_t) ((rx[8]) << 8 | rx[7]);
			if(crc == Crc16_RX(7))
			{
				ip[0] = rx[3];
				ip[1] = rx[4];
				ip[2] = rx[5];
				ip[3] = rx[6];


				return 0;
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}



int8_t ReadChannel(uint8_t ch)
{
int8_t res = -1;
uint16_t i, len = 0, cnt = 0;
uint16_t crc;
__IO uint32_t timeout;


	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));

	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x03;
	iobuf[len++] = HI(5001);
	iobuf[len++] = LO(5001);
	iobuf[len++] = 0;	//
	iobuf[len++] = 10;	// IIN,IFV,IFN,IKU,IKE,IKD,IKS
	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 50));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт

		if(HAL_UART_Receive(&huart7, rx, 25, 100) == HAL_OK)
		{
			crc = (uint16_t) ((rx[24]) << 8 | rx[23]);
			if(crc == Crc16_RX(23))
			{
				pardata.amplif[ch].IIN = (uint16_t) ((rx[3]) << 8 | rx[4]);
				pardata.amplif[ch].IFV = (uint16_t) ((rx[5]) << 8 | rx[6]);
				pardata.amplif[ch].IFN = (uint16_t) ((rx[7]) << 8 | rx[8]);
				pardata.amplif[ch].IKU = (uint16_t) ((rx[9]) << 8 | rx[10]);
				pardata.amplif[ch].IKE = (uint16_t) ((rx[11]) << 8 | rx[12]);
				pardata.amplif[ch].IKD = (uint16_t) ((rx[13]) << 8 | rx[14]);
				pardata.amplif[ch].IKS = (uint16_t) ((rx[15]) << 8 | rx[16]);
				pardata.amplif[ch].IPZ = (uint16_t) ((rx[17]) << 8 | rx[18]);
				pardata.amplif[ch].OPZ = (uint16_t) ((rx[19]) << 8 | rx[20]);
				pardata.amplif[ch].VAL = (uint16_t) ((rx[21]) << 8 | rx[22]);
				return 0;
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}


int8_t WriteChannel(uint8_t ch)
{
int8_t res = -1;
uint16_t i, len = 0;
uint16_t crc;
__IO uint32_t timeout;

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));

	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x10;
	iobuf[len++] = HI(5001);
	iobuf[len++] = LO(5001);
	iobuf[len++] = 0;
	iobuf[len++] = 10;
	iobuf[len++] = 20;

	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IIN;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IFV;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IFN;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IKU;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IKE;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IKD;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IKS;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].IPZ;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].OPZ;
	iobuf[len++] = 0;
	iobuf[len++] = pardata.amplif[ch].VAL;

	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 200));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт


		if(HAL_UART_Receive(&huart7, rx, 8, 500) == HAL_OK)
		{
			crc = (uint16_t) ((rx[7]) << 8 | rx[6]);
			if(crc == Crc16_RX(6))
			{
				if(rx[0] == (ch + 1))
				  return 0;
					else return (-1);
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}





int8_t ReadChannelSens(uint8_t ch)
{
int8_t res = -1;
uint16_t i, len = 0, cnt = 0;
uint16_t crc;
__IO uint32_t timeout;
sfloat f;


	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));

	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x03;
	iobuf[len++] = HI(7502);
	iobuf[len++] = LO(7502);
	iobuf[len++] = 0;	//
	iobuf[len++] = 1;	// SENS
	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 50));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт

		if(HAL_UART_Receive(&huart7, rx, 9, 100) == HAL_OK)
		{
			crc = (uint16_t) ((rx[8]) << 8 | rx[7]);
			if(crc == Crc16_RX(7))
			{
				f.ch[3] = rx[3];
				f.ch[2] = rx[4];
				f.ch[1] = rx[5];
				f.ch[0] = rx[6];

				if(f.fl < 0.0001f) {
					return (-1);
				}
				else
				{
					pardata.amplif[ch].SENS = f.fl;
				}
				return 0;
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}



int8_t WriteChannelSens(uint8_t ch)
{
int8_t res = -1;
uint16_t i, len = 0;
uint16_t crc;
__IO uint32_t timeout;
sfloat f;

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));

	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x10;
	iobuf[len++] = HI(7502);
	iobuf[len++] = LO(7502);
	iobuf[len++] = 0;
	iobuf[len++] = 1;
	iobuf[len++] = 4;

	f.fl = pardata.amplif[ch].SENS;
	iobuf[len++] = f.ch[3];
	iobuf[len++] = f.ch[2];
	iobuf[len++] = f.ch[1];
	iobuf[len++] = f.ch[0];
	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 200));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт



		if(HAL_UART_Receive(&huart7, rx, 8, 500) == HAL_OK)
		{
			crc = (uint16_t) ((rx[7]) << 8 | rx[6]);
			if(crc == Crc16_RX(6))
			{
				if(rx[0] == (ch + 1))
				  return 0;
					else return (-1);
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}






int8_t Calibr(uint8_t ch, uint8_t on)
{
int8_t res = -1;
uint16_t i, len = 0;
uint16_t crc;
uint16_t reg;
__IO uint32_t timeout;

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));


	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x10;
	iobuf[len++] = HI(3000);
	iobuf[len++] = LO(3000);
	iobuf[len++] = 0;
	iobuf[len++] = 1;
	iobuf[len++] = 2;

	iobuf[len++] = 0;
	if(on)
	  iobuf[len++] = menu - 1;
		else iobuf[len++] = 0;

	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 200));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт


		if(HAL_UART_Receive(&huart7, rx, 8, 500) == HAL_OK)
		{
			crc = (uint16_t) ((rx[7]) << 8 | rx[6]);
			if(crc == Crc16_RX(6))
			{
				if(rx[0] == (ch + 1))
				  return 0;
					else return (-1);
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}


int8_t WriteCorr(uint8_t ch, uint8_t fasecor, uint8_t up)
{
int8_t res = -1;
uint16_t i, len = 0;
uint16_t crc;
uint16_t reg;
__IO uint32_t timeout;

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE))
		__HAL_UART_CLEAR_OREFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE))
		__HAL_UART_CLEAR_PEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE))
		__HAL_UART_CLEAR_FEFLAG(&huart7);

	if(__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE))
		__HAL_UART_CLEAR_NEFLAG(&huart7);

	HAL_Delay(20);
	TX_OK = RX_OK = UART_ERROR = false;
	len = 0;

	memset((void *) &rx, 0, sizeof(rx));


	/*if(fasecor == CALIBR_00) {
		return (-1);
	}*/

	iobuf[len++] = ch + 1;
	iobuf[len++] = 0x10;
	iobuf[len++] = HI(fasecor + 3001);
	iobuf[len++] = LO(fasecor + 3001);
	iobuf[len++] = 0;
	iobuf[len++] = 1;
	iobuf[len++] = 2;

	iobuf[len++] = 0;
	iobuf[len++] = up;

	crc = Crc16(len);
	iobuf[len++] = LO(crc);
	iobuf[len++] = HI(crc);

	timeout = HAL_GetTick();

	HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_SET);
	if(HAL_UART_Transmit_IT(&huart7, iobuf, len) == HAL_OK)
	{
		while((!TX_OK)  &&  (HAL_GetTick() - timeout < 200));
		if(!TX_OK)
		{
			HAL_UART_Abort_IT(&huart7);
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
		HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
		HAL_UART_Receive(&huart7, rx, 1, 100); // пустой байт


		if(HAL_UART_Receive(&huart7, rx, 8, 500) == HAL_OK)
		{
			crc = (uint16_t) ((rx[7]) << 8 | rx[6]);
			if(crc == Crc16_RX(6))
			{
				if(rx[0] == (ch + 1))
				  return 0;
					else return (-1);
			}
			else
			{
				return (-1);
			}
		}
		else
		{
			HAL_GPIO_WritePin(RE_GPIO_Port, RE_Pin, GPIO_PIN_RESET);
			return (-1);
		}
	}

	return res;
}



void CalibrON(void)
{
uint8_t i, ch;
uint32_t MASK_CHANNELS = 0;
uint32_t CNT_CHANNELS = 0;


	for(ch = 0; ch < 4; ch++)
	{
		for(i = 0; i < 3; i++)
		{
			if(Calibr(ch, 1) == 0)
			{
				MASK_CHANNELS |= (1 << ch);
				CNT_CHANNELS++;
				break;
			}
		}
	}
}


void CalibrOFF(void)
{
uint8_t i, ch;
uint32_t MASK_CHANNELS = 0;
uint32_t CNT_CHANNELS = 0;


	for(ch = 0; ch < 4; ch++)
	{
		for(i = 0; i < 3; i++)
		{
			if(Calibr(ch, 0) == 0)
			{
				MASK_CHANNELS |= (1 << ch);
				CNT_CHANNELS++;
				break;
			}
		}
	}
}





















void AskChannels(void)
{
uint8_t i, ch;

	ASK_COMPLETE = false;


	for(i = 0; i < 100; i++)
	{
		RedrawScreen();
		HAL_Delay(10);
	}


	ip_assigned = false;
	for(i = 0; i < 2; i++)
	{
		if(ReadIP() == 0) {
			ip_assigned = true;
			break;
		}
		HAL_Delay(50);
	}



	memset((void *) &pardata.amplif[0], 0, sizeof(AmplifData_TypeDef) * 16u);
	MASK_CHANNELS = CNT_CHANNELS = ACTIVE_CHANNEL = 0;

	for(ch = 0; ch < 8; ch++)
	{
		for(i = 0; i < 2; i++)
		{
			if(ReadChannel(ch) == 0)
			{
				RedrawScreen();
				MASK_CHANNELS |= (1 << ch);
				CNT_CHANNELS++;

				ReadChannelSens(ch);
				break;
			}
			else
				RedrawScreen();
		}
	}


	if(CNT_CHANNELS != 0)
	{
		for(i = 0; i < 8; i++)
		{
			if(MASK_CHANNELS & (1 << i))
			{
				ACTIVE_CHANNEL = i;
				break;
			}
		}

		ASK_COMPLETE = true;
	}
	else
	{
		//Off();
	}


	HAL_Delay(2000);


	//MASK_CHANNELS = 0xf;	//TODO	Удалить
	//CNT_CHANNELS = 4;		//TODO	Удалить
}




void AskPeriodic(void)
{
uint8_t ch;

	for(ch = 0; ch < 8; ch++)
	{
		if(MASK_CHANNELS & (1 << ch))
		{
			if(!focused)
			{
				ReadChannel(ch);
				ReadChannelSens(ch);
			}
		}
	}

}











/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/