dplimin
/
F203
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
F203/Core/Src/usart.c

1024 lines
20 KiB
C
Raw Normal View History

first commit
2023-12-13 16:59:07 +03:00
/**
******************************************************************************
* @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}; //<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> float-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
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****/