1024 lines
20 KiB
C
1024 lines
20 KiB
C
/**
|
||
******************************************************************************
|
||
* @file usart.c
|
||
* @brief This file provides code for the configuration
|
||
* of the USART instances.
|
||
******************************************************************************
|
||
* @attention
|
||
*
|
||
* <h2><center>© 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****/
|