Embedded_RD/WTZSSoftWare
15
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
fb2ca87ca2
WTZSSoftWare/Src/Communicaion.c

494 lines
16 KiB
C
Raw Normal View History

版本管理首次远端推送
2025-09-29 02:42:07 +00:00
#include "cmsis_os.h"
#include "cmsis_os2.h"
#include "main.h"
#include "stdio.h"
#include "usb_device.h"
#include <math.h>
#include <stdint.h>
#include <string.h>
typedef struct
{
const char *cmd;
int cmd_id;
} CmdTable;
/*
自定义协议
帧头 0xAA 55
帧长度 1字节
帧序号 1字节
帧类型 1字节
数据域 N字节
帧校验 1字节
| 帧头 | 命令 | 长度 | 帧号 | 数据 (128B) | CRC16 |
|--------|------|--------|------|-------------|--------|
| AA 55 | 01 | 00 80 | 01 | [0xXX...] | 2字节 |
| 帧头 | 命令 | 长度 | 帧号 | 数据 (128B) | CRC16 |
|--------|------|--------|------|-------------|--------|
| AA 55 | 04 | 00 80 | FF | 00 |
*/
// extern uint8_t Uart_ReadCache[128];
// extern _Bool ReadFlag;
// uint8_t CPk = 0; // 当前包计数
// void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
// {
// UNUSED(huart);
// __HAL_UART_CLEAR_OREFLAG(huart);
// __HAL_UART_CLEAR_IDLEFLAG(huart);
// if(__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE) != RESET) //
// 空闲中断标记被置位
// {
// __HAL_UART_CLEAR_IDLEFLAG(huart); // 清除中断标记
// HAL_UART_DMAStop(huart); // 停止DMA接收
// CPk = __HAL_DMA_GET_COUNTER(huart->hdmarx); // 总数据量
// HAL_UARTEx_ReceiveToIdle_DMA(huart, Uart_ReadCache, 128); //
// 重新启动DMA接收
// }
// // if ((Uart_ReadCache[0] == 'C') && (Uart_ReadCache[1] == 'M') &&
// (Uart_ReadCache[2] == 'D'))
// // {
// // char buf[10];
// // uint16_t i,j,k= 0;
// // HAL_GPIO_WritePin( GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
// // for( k = 0; k < 8; k ++ )
// // {
// // for( i = 0; i < 3; i ++)
// // {
// // for( j = 0; j < 98; j ++)
// // {
// // sprintf( buf, "%.4f\r\n", OutPut1[k][i][j]);
// // HAL_UART_Transmit(&huart, (uint8_t
// *)buf,strlen(buf),0xFFFF);
// // while(HAL_UART_GetState(&huart) ==
// HAL_UART_STATE_BUSY_TX);//锟斤拷锟経ART锟斤拷锟酵斤拷锟斤拷
// // }
// // }
// // }
// // ReadFlag = 1;
// // HAL_GPIO_WritePin( GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
// // }
// // HAL_UARTEx_ReceiveToIdle_IT(&huart1, (uint8_t *)&Uart_ReadCache, 100);
// //锟劫匡拷锟斤拷锟斤拷锟斤拷锟叫讹拷
// }
// #include "command.h"
// 假设每个通道每个频率点4字节(float)，每帧最大数据长度为120字节(30个float)
#define MAX_FRAME_DATA_LEN 120
// 指令的最小长度
#define COMMAND_MIN_LENGTH 4
// 循环缓冲区大小
#define BUFFER_SIZE 121
// 循环缓冲区
uint8_t buffer[BUFFER_SIZE];
// 循环缓冲区读索引
uint8_t readIndex = 0;
// 循环缓冲区写索引
uint8_t writeIndex = 0;
/**
* @brief 增加读索引
* @param length 要增加的长度
*/
void Command_AddReadIndex(uint8_t length)
{
readIndex += length;
readIndex %= BUFFER_SIZE;
}
/**
* @brief 读取第i位数据 超过缓存区长度自动循环
* @param i 要读取的数据索引
*/
uint8_t Command_Read(uint8_t i)
{
uint8_t index = i % BUFFER_SIZE;
return buffer[index];
}
/**
* @brief 计算未处理的数据长度
* @return 未处理的数据长度
* @retval 0 缓冲区为空
* @retval 1~BUFFER_SIZE-1 未处理的数据长度
* @retval BUFFER_SIZE 缓冲区已满
*/
// uint8_t Command_GetLength() {
// // 读索引等于写索引时，缓冲区为空
// if (readIndex == writeIndex) {
// return 0;
// }
// // 如果缓冲区已满,返回BUFFER_SIZE
// if (writeIndex + 1 == readIndex || (writeIndex == BUFFER_SIZE - 1 &&
// readIndex == 0)) {
// return BUFFER_SIZE;
// }
// // 如果缓冲区未满,返回未处理的数据长度
// if (readIndex <= writeIndex) {
// return writeIndex - readIndex;
// } else {
// return BUFFER_SIZE - readIndex + writeIndex;
// }
// }
uint8_t Command_GetLength() { return (writeIndex + BUFFER_SIZE - readIndex) % BUFFER_SIZE; }
/**
* @brief 计算缓冲区剩余空间
* @return 剩余空间
* @retval 0 缓冲区已满
* @retval 1~BUFFER_SIZE-1 剩余空间
* @retval BUFFER_SIZE 缓冲区为空
*/
uint8_t Command_GetRemain() { return BUFFER_SIZE - Command_GetLength(); }
/**
* @brief 向缓冲区写入数据
* @param data 要写入的数据指针
* @param length 要写入的数据长度
* @return 写入的数据长度
*/
uint8_t Command_Write(uint8_t *data, uint16_t length)
{
// 如果缓冲区不足 则不写入数据 返回0
if (Command_GetRemain() < length)
{
return 0;
}
// 使用memcpy函数将数据写入缓冲区
if (writeIndex + length < BUFFER_SIZE)
{
memcpy(buffer + writeIndex, data, length);
writeIndex += length;
}
else
{
uint8_t firstLength = BUFFER_SIZE - writeIndex;
memcpy(buffer + writeIndex, data, firstLength);
memcpy(buffer, data + firstLength, length - firstLength);
writeIndex = length - firstLength;
}
return length;
}
/**
* @brief 尝试获取一条指令
* @param command 指令存放指针
* @return 获取的指令长度
* @retval 0 没有获取到指令
*/
uint8_t Command_GetCommand(uint8_t *command)
{
/*
| 帧头 | 命令 | 长度 | 帧号 | 数据 (128B) | CRC16 |
|--------|------|--------|------|-------------|--------|
| AA 55 | 04 | 80 | FF | 00 |
*/
// 寻找完整指令
while (1)
{
// 如果缓冲区长度小于COMMAND_MIN_LENGTH 则不可能有完整的指令
if (Command_GetLength() < COMMAND_MIN_LENGTH)
{
return 0;
}
// 如果不是包头 则跳过 重新开始寻找
if (((Command_Read(readIndex) != 0xAA) || (Command_Read(readIndex + 1) != 0x55)))
{
Command_AddReadIndex(1);
continue;
}
// 如果缓冲区长度小于指令长度 则不可能有完整的指令
uint8_t length = Command_Read(readIndex + 3);
if (Command_GetLength() < length)
{
return 0;
}
// 如果校验和不正确 则跳过 重新开始寻找
uint16_t sum = 0;
for (uint8_t i = 0; i < length - 2; i++)
{
sum += Command_Read(readIndex + i);
}
if (sum != (Command_Read(readIndex + length - 2) << 8 | Command_Read(readIndex + length - 1)))
{
Command_AddReadIndex(1);
continue;
}
// 如果找到完整指令 则将指令写入command 返回指令长度
for (uint8_t i = 0; i < length; i++)
{
command[i] = Command_Read(readIndex + i);
}
Command_AddReadIndex(length);
return length;
}
}
extern osSemaphoreId_t Command_Semaphore;
extern UART_HandleTypeDef huart1;
extern uint16_t CLKHZ[98];
extern void CLKHZSET(uint16_t Deep);
extern float LineCheckF[32];
union
{
float ufloat;
uint32_t u32;
uint16_t u16[2];
uint8_t u8[4];
} uDataCover;
uint16_t FramePack(uint8_t *buf, uint8_t cmd, uint8_t frameNum, uint8_t *data, uint16_t dataLength)
{
uint8_t Lenth = 0;
uint16_t crcSum = 0;
memset(buf, 0, 128);
buf[0] = 0xAA; // 帧头
buf[1] = 0x55; // 帧头
buf[2] = cmd; // 命令
buf[3] = 0x00; // 长度
buf[4] = frameNum; // 帧号
Lenth = 7;
for (uint8_t i = 0; i < 5; i++)
{
crcSum += buf[i];
}
for (uint8_t i = 0; i < dataLength; i++)
{
buf[i + 5] = data[i];
crcSum += data[i];
Lenth += 1;
}
buf[3] = Lenth; // 更新长度
crcSum +=Lenth;
buf[Lenth - 2] = crcSum >> 8; // CRC高字节
buf[Lenth - 1] = crcSum & 0xFF; // CRC低字节
return Lenth;
}
struct uCommunication CommunicationData;
extern float OutPut1[8][4][98];
extern float OutPut2[8][4][98];
extern float OutPut3[8][4][98];
extern float OutPut4[8][4][98];
extern uint8_t Uart_ReadCache[128];
uint8_t command[50];
uint8_t SendBuf[128];
int commandLength = 0;
uint8_t dtime = 10;
void Command_Deal(void)
{
osSemaphoreAcquire(Command_Semaphore, osWaitForever); // 等待命令信号量
do
{
memset(command,0,50);
commandLength = Command_GetCommand(command);
if (commandLength == 0)
{
return;
}
uint8_t cmd = command[2]; // 获取命令
uint8_t SenDataLenth = 0;
switch (cmd)
{
case 1: // 开始测试命令
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_RESET);
osDelay(50);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
CommunicationData.MeasurementPrecision = 0;
CommunicationData.MeasurementFlag = 1;
break;
case 2: // 终止测试命令
CommunicationData.MeasurementPrecision = 0;
CommunicationData.MeasurementFlag = 0;
break;
case 3: // 设定深度
CommunicationData.Deep = (command[5] << 8) | command[6];
CLKHZSET(CommunicationData.Deep);
break;
case 4: // 设置增益
CommunicationData.Gain = command[5];
break;
case 5: // 设定通道数量
CommunicationData.ChannelNum = command[5];
break;
case 6: // 道接地信号强度测试命令
CommunicationData.SingelStrengthMeasurementFlag = 1;
CommunicationData.MeasurementPrecision = 0;
break;
case 7: // 获取通道接地信号强度
if (CommunicationData.MeasurementPrecision == 100.0f)
{
SenDataLenth = FramePack(SendBuf, 0x07, 0x01, (uint8_t *)LineCheckF, 16 * 4);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
; // 等待UART发送完成
osDelay(50);
SenDataLenth = FramePack(SendBuf, 0x07, 0xFF, (uint8_t *)(LineCheckF + 16), 16 * 4);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
;
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
osDelay(100);
HAL_UARTEx_ReceiveToIdle_DMA(&huart1, Uart_ReadCache, 128); // 重新启动DMA接收
}
break;
case 8: // 获取测量进度
{
SenDataLenth = FramePack(SendBuf, 0x08, 0xFF, (uint8_t *)&CommunicationData.MeasurementPrecision, 1);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
; // 等待UART发送完成
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
break;
}
case 9: // 获取测量结果
if (CommunicationData.MeasurementPrecision == 100.0f)
{
uint8_t totalChannels = CommunicationData.ChannelNum;
uint8_t totalFreqs = 0;
for (uint8_t i = 0; i < 98; i++)
{
if (CLKHZ[i] != 0)
totalFreqs++;
else
break;
}
uint32_t totalDataLen = totalChannels * totalFreqs * 4;
uint8_t frameNum = 1;
uint32_t sentLen = 0;
while (sentLen < totalDataLen)
{
/**
* 根据剩余待发送数据长度，计算本次发送的数据长度，并组装数据帧。
*
* 1. 计算本次发送的数据长度 sendLen，不超过 MAX_FRAME_DATA_LEN。
* 2. 初始化数据缓冲区 dataBuf。
* 3. 遍历每个待发送的 float 数据（每 4 字节为一个 float），根据 globalIdx 计算通道号 ch 和频点 freq。
* 4. 根据通道号 ch 从对应的 OutPut 数组中获取数据 val。
* - ch < 8: 从 OutPut1 取数据
* - ch < 16: 从 OutPut2 取数据
* - ch < 24: 从 OutPut3 取数据
* - ch < 32: 从 OutPut4 取数据
* 5. 将获取到的 float 数据 val 拷贝到 dataBuf 中，准备发送。
*
* 参数说明：
* - totalDataLen: 总数据长度（字节）
* - sentLen: 已发送的数据长度（字节）
* - MAX_FRAME_DATA_LEN: 单帧最大数据长度（字节）
* - totalChannels: 总通道数
* - OutPut1~4: 四组输出数据数组
*/
uint32_t remain = totalDataLen - sentLen;
uint8_t sendLen = (remain > MAX_FRAME_DATA_LEN) ? MAX_FRAME_DATA_LEN : remain;
uint8_t dataBuf[MAX_FRAME_DATA_LEN];
// 组装数据
uint32_t dataIdx = 0;
uint32_t globalIdx = sentLen / 4;
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
osDelay(dtime);
for (uint8_t i = 0; i < sendLen / 4; i++)
{
uint8_t ch = (globalIdx % totalChannels);
uint8_t freq = (globalIdx / totalChannels);
float val = 0.0f;
if (ch < 8)
val = OutPut1[ch][0][freq];
else if (ch < 16)
val = OutPut2[ch - 8][0][freq];
else if (ch < 24)
val = OutPut3[ch - 16][0][freq];
else if (ch < 32)
val = OutPut4[ch - 24][0][freq];
memcpy(&dataBuf[dataIdx], &val, 4);
dataIdx += 4;
globalIdx++;
}
uint8_t thisFrameNum = (sentLen + sendLen >= totalDataLen) ? 0xFF : frameNum;
SenDataLenth = FramePack(SendBuf, 0x09, thisFrameNum, dataBuf, sendLen);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
;
sentLen += sendLen;
frameNum++;
}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
osDelay(100);
HAL_UARTEx_ReceiveToIdle_DMA(&huart1, Uart_ReadCache, 128); // 重新启动DMA接收
}
break;
case 10: // 获取电池电压
SenDataLenth = FramePack(SendBuf, 0x0A, 0x01, (uint8_t *)&CommunicationData.BatteryVoltage, 4);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
; // 等待UART发送完成
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
break;
case 11: // 获取电流
SenDataLenth = FramePack(SendBuf, 0x0B, 0x01, (uint8_t *)&CommunicationData.BatteryCurrent, 4);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, SendBuf, SenDataLenth, HAL_MAX_DELAY);
while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
; // 等待UART发送完成
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
break;
}
}
while(commandLength != 0);
}
/*
| 帧头 | 命令 | 长度 | 帧号 | 数据 (128B) | CRC16 |
|--------|------|--------|------|-------------|--------|
| AA 55 | 04 | 80 | FF | 00 |
设定频率
设置增益
设定通道数量
道接地信号强度测试命令
获取通道接地信号强度
开始测试命令
终止测试命令
获取测量进度
获取测量结果
获取电池电压
获取电流
CmdTable cmd_table[] = {
{"CMD_START", 1}, // 开始测试命令
{"CMD_STOP", 2}, // 终止测试命令
{"CMD_SET_FREQ", 3}, // 设定深度
{"CMD_SET_GAIN", 4}, // 设置增益
{"CMD_SET_CHANNELS", 5}, // 设定通道数量
{"CMD_TEST_GROUND", 6}, // 道接地信号强度测试命令
{"CMD_GET_GROUND", 7}, // 获取通道接地信号强度
{"CMD_GET_PROGRESS", 8}, // 获取测量进度
{"CMD_GET_RESULT", 9}, // 获取测量结果
{"CMD_GET_BATTERY_VOLTAGE", 10}, // 获取电池电压
{"CMD_GET_CURRENT", 11}, // 获取电流
// ...更多命令
};
*/
Reference in New Issue Copy Permalink