STM32 串口DMA接收 Openmv / K210 整数、小数字符串数据 (基于HAL库)

已于 2022-01-25 02:18:48 修改
阅读量6.3k 收藏 149
点赞数 19
分类专栏： 电赛 文章标签： 单片机 stm32 嵌入式 串口通信 字符串
于 2021-03-16 21:01:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44457994/article/details/114874113
版权

目录

平台: STM32 Cube IDE

前言

许多科创比赛中经常会有其他设备与STM32串口通讯的需求，比如可能需要Openmv / K210向STM32串口发送坐标的情况。下面我将介绍一种基于HAL库的串口DMA不定长数据收发和数据解读的方案。

一、工程配置

1.选择好芯片、配置好时钟和debug模式后，使能要用到的串口。
在这里插入图片描述
2.使能该串口的收发收发DMA:
在这里插入图片描述
3.使能串口全局中断，并生成工程文件。在这里插入图片描述

二、串口DMA部分代码

本部分代码修改自xia0816大佬写的《真正实现了STM32 HAL串口不定长数据的接收发送功能(DMA方式，不用限定单次接收长度和添加结束标志)》

1.源文件UART_DMA.c

#include "UART_DMA.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

uint8_t RxBuffer[UART_RX_BUF_SIZE] = {0};
uint8_t TxBuffer[UART_RX_BUF_SIZE] = {0};
uint8_t sendCompleteSign = 1;
uint8_t TxLen = 0;

void DataProcess(void)
{
	//在这里加入数据处理的函数

}

//到USARTx_IRQHandler中添加，如:
//void USART1_IRQHandler(void)
//{
//  /* USER CODE BEGIN USART1_IRQn 0 */
//  if(__HAL_UART_GET_FLAG(&USB_Huart,UART_FLAG_IDLE))
//  {
//	  HAL_UART_IdleCallback(&USB_Huart);
//  }
//
//  /* USER CODE END USART1_IRQn 0 */
//  HAL_UART_IRQHandler(&huartx);
//}
void HAL_UART_IdleCallback(UART_HandleTypeDef *huart)
{
	__HAL_UART_CLEAR_IDLEFLAG(huart);
	{
		HAL_UART_DMAStop(huart);

        ProcessData();

        StartUartRxDMA();
	}
}

void ProcessData()
{
    uint32_t len = 0;

    //得到已经接收了多少个字节 = 总共要接收的字节数 - ?NDTR F1为CNDTR F4为NDTR
    #ifdef __STM32F1xx_HAL_H
    	len = UART_RX_BUF_SIZE - USB_Huart.hdmarx->Instance->CNDTR;
    	#define ProcessDataOK
    #endif

    #ifdef  __STM32F4xx_HAL_H
        len = UART_RX_BUF_SIZE - USB_Huart.hdmarx->Instance->NDTR;
    	#define ProcessDataOK
    #endif

    #ifndef ProcessDataOK
    	增加所用芯片的版本
    #endif

    if(len > 0)
    {
        if(sendCompleteSign == 1)
        {
#if UART_RXTX_Switch
            memset((void *)TxBuffer, 0, sizeof(TxBuffer));
            memcpy(TxBuffer, RxBuffer, len);
            TxLen = len;
            StartUartTxDMA();	//串口回显
#endif
            {
            	//在这里面加入数据处理的函数
            	DataProcess();
            }
        }
    }
}

void USB_DMA_printf(const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit_DMA(&USB_Huart,TxBuffer,length);
}

void USB_printf(const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit(&USB_Huart,TxBuffer,length,0xFFFF);
}

/**
  * @brief  Tx Transfer completed callbacks.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
//  UNUSED(huart);
    if(huart == &USB_Huart)
    {
        sendCompleteSign = 1;
    }
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_TxCpltCallback could be implemented in the user file
   */
}

/**
  * @brief  Rx Transfer completed callbacks.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
//  UNUSED(huart);
    if(huart == &USB_Huart)
    {
        ProcessData();

        StartUartRxDMA();
    }
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_RxCpltCallback could be implemented in the user file
   */
}

uint8_t UartTxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len)
{
	HAL_StatusTypeDef status;
	uint8_t ret = 1;

	if(sendCompleteSign == 0 || len == 0)
	{
		return 0;
	}

    sendCompleteSign = 0;

	status = HAL_UART_Transmit_DMA(huart, (uint8_t*)buf, len);

	if(HAL_OK != status)
	{
		ret = 0;
	}

	return ret;
}

//启动DMA发送
uint8_t StartUartTxDMA()
{
    return UartTxData(&USB_Huart, TxBuffer, TxLen);
}

uint8_t UartRxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len)
{
	HAL_StatusTypeDef status;
	uint8_t ret = 1;

	status = HAL_UART_Receive_DMA(huart, (uint8_t*)buf, len);
	if(HAL_OK != status)
	{
		ret = 0;
	}
	else
	{
		/* 开启空闲接收中断 */
	    __HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
	}

	return ret;
}

//启动DMA接收
uint8_t StartUartRxDMA()
{
    return UartRxData(&USB_Huart, RxBuffer, UART_RX_BUF_SIZE);
}

void ProcessData()中可能需要视所用芯片情况作部分修改，目前只测试过STM32F103VET6和STM32F411CEU6

    //得到已经接收了多少个字节 = 总共要接收的字节数 - ?NDTR F1为CNDTR F4为NDTR
    #ifdef __STM32F1xx_HAL_H
    	len = UART_RX_BUF_SIZE - USB_Huart.hdmarx->Instance->CNDTR;
    	#define ProcessDataOK
    #endif

    #ifdef  __STM32F4xx_HAL_H
        len = UART_RX_BUF_SIZE - USB_Huart.hdmarx->Instance->NDTR;
    	#define ProcessDataOK
    #endif

    #ifndef ProcessDataOK
    	增加所用芯片的版本
    #endif

2.头文件UART_DMA.h

#ifndef UART_DMA_UART_DMA_H_
#define UART_DMA_UART_DMA_H_

#include "main.h"

extern UART_HandleTypeDef huart1;	//修改为所用串口
#define USB_Huart huart1			//修改为所用串口

#define UART_RX_BUF_SIZE 128

#define UART_RXTX_Switch 1			//串口回显开关

/*
要在Cube中开串口全局中断和收发DMA
 */

extern uint8_t RxBuffer[UART_RX_BUF_SIZE];
extern uint8_t TxBuffer[UART_RX_BUF_SIZE];
extern uint8_t TxLen;

void USB_DMA_printf(const char *format,...);			//printf DMA方式
void USB_printf(const char *format,...);				//printf 普通方式
uint8_t UartTxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len);
uint8_t StartUartRxDMA();								//接收DMA初始化
uint8_t StartUartTxDMA();								//不需要自己调用
void ProcessData();										//在里面添加数据处理函数
void HAL_UART_IdleCallback(UART_HandleTypeDef *huart);	//到USARTx_IRQHandler中添加

#endif /* UART_DMA_UART_DMA_H_ */

3.stm32f1xx_it.c的修改

需要到stm32f1xx_it.c中的USARTx_IRQHandler添加几句话

//...
/* USER CODE BEGIN Includes */
#include "../UART_DMA/UART_DMA.h"
/* USER CODE END Includes */
//...

//...
/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
  if(__HAL_UART_GET_FLAG(&USB_Huart,UART_FLAG_IDLE))
  {
	  HAL_UART_IdleCallback(&USB_Huart);
  }
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}
//...

4.串口收发DMA测试

(2022年1月25日补充)新版Cube MX有BUG，生成的初始化代码顺序有问题，见STM32 HAL串口DMA发送一直失败 —— 攻城狮_鲨鱼，故建议在生成的初始化代码前手动

  MX_DMA_Init();
  MX_USART1_UART_Init();

如
在这里插入图片描述

启动串口DMA接收

//...
  /* USER CODE BEGIN 2 */
  StartUartRxDMA();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */
//...

进入debug跑起来，将接收区缓存RxBuffer加入 现场表达式

//...
	uint8_t RxBuffer[UART_RX_BUF_SIZE] = {0};
	uint8_t TxBuffer[UART_RX_BUF_SIZE] = {0};
	uint8_t sendCompleteSign = 1;
	uint8_t TxLen = 0;
//...

在这里插入图片描述
在ProcessData()中的该处打上断点。
在这里插入图片描述
打开串口调试助手，选择好参数后发送一段测试字符串，可以发现该字符串已成功存入缓冲区。
在这里插入图片描述
随后又成功将数据通过DMA回显
在这里插入图片描述
至此串口DMA收发已成功实现。

而源文件中附有的USB_DMA_printf()和USB_printf()分别为DMA方式的printf和普通的printf

void USB_DMA_printf(const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit_DMA(&USB_Huart,TxBuffer,length);
}

void USB_printf(const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit(&USB_Huart,TxBuffer,length,0xFFFF);
}

效果如下:
在这里插入图片描述
为了进一步处理数据，下面介绍字符串数字提取的方案。

三、字符串数字提取代码

改进型代码见C语言字符串数字提取函数，支持负数、浮点数、科学记数法
实测double数据直接传参数据会出错，故采取了指针的方式。

1.源文件NumAndStr.c:

/*
 * NumAndStr.c
 *
 *  Created on: Mar 15, 2021
 *      Author: 乙酸氧铍
 */
#include "../NumAndStr/NumAndStr.h"
#include  <stdlib.h>

int32_t str2int(uint8_t * str, uint8_t flag, uint8_t no)
{
	uint8_t No = 1;
	uint8_t * Str = str;
	uint8_t NumTemp[TempIntLen];
	while(No!=no)
	{
		if(*Str == flag)
			No++;
		Str++;
	}
	No = 0;
	while(*Str != flag && *Str != '\r' && *Str != '\n' && *Str != '\0' && No < (TempIntLen - 1))
	{
		NumTemp[No] = *Str;
		Str++;
		No++;
	}
	NumTemp[No] = '\0';
	return atoi(NumTemp);
}

void str2double(uint8_t * str, uint8_t flag, uint8_t no, double * Output)
{
	uint8_t No = 1;
	uint8_t * Str = str;
	uint8_t NumTemp[TempDoubleLen];
	uint8_t NumTemp_int[TempDoubleLen];
	double OutputNum;
	while(No!=no)
	{
		if(*Str == flag)
			No++;
		Str++;
	}
	No = 0;
	while(*Str != flag && *Str != '\r' && *Str != '\n' && *Str != '\0' && No < (TempDoubleLen - 1))
	{
		NumTemp[No] = *Str;
		Str++;
		No++;
	}
	NumTemp[No] = '\0';
	NumTemp[(TempDoubleLen - 1)] = 0;
	No = 0;
	while(NumTemp[NumTemp[(TempDoubleLen - 1)]] != '\0' && NumTemp[(TempDoubleLen - 1)] < (TempDoubleLen - 1))
	{
		if(NumTemp[NumTemp[(TempDoubleLen - 1)]] == '.')
		{
			NumTemp[(TempDoubleLen - 1)]++;
			NumTemp_int[(TempDoubleLen - 1)] = NumTemp[(TempDoubleLen - 1)];
		}
		NumTemp_int[No] = NumTemp[NumTemp[(TempDoubleLen - 1)]];
		No++;
		NumTemp[(TempDoubleLen - 1)]++;
	}
	NumTemp_int[No]='\0';
	NumTemp[(TempDoubleLen - 1)] = NumTemp_int[(TempDoubleLen - 1)]++;
	OutputNum = (double)atoi(NumTemp_int);
	while(NumTemp[NumTemp[(TempDoubleLen - 1)]] != '\0')
	{
		OutputNum /= 10;
		NumTemp[(TempDoubleLen - 1)] ++;
	}
	*Output = OutputNum;
}

2.头文件NumAndStr.h:

/*
 * NumAndStr.h
 *
 *  Created on: Mar 15, 2021
 *      Author: 乙酸氧铍
 */

#ifndef NUMANDSTR_NUMANDSTR_H_
#define NUMANDSTR_NUMANDSTR_H_

#include "main.h"

#define TempDoubleLen 18
#define TempIntLen 11

/*
str:数字字符串首地址
flag:分隔符
no:第no个数字 从1开始计
Output: 小数存放地址
 */
extern int32_t str2int(uint8_t * str, uint8_t flag, uint8_t no);
extern void str2double(uint8_t * str, uint8_t flag, uint8_t no, double * Output);

#endif /* NUMANDSTR_NUMANDSTR_H_ */

str:数字字符串首地址
flag:分隔符
no:第no个数字 从1开始计
Output: 小数存放地址

3.测试:

修改UART_DMA.c中的DataProcess()函数

#include "../NumAndStr/NumAndStr.h"		//包含头文件

int32_t a,b,c;
double  d,e,f;
void DataProcess(void)
{
	//在这里加入数据处理的函数
	a = str2int(RxBuffer, ' ', 1);
	b = str2int(RxBuffer, ' ', 2);
	c = str2int(RxBuffer, ' ', 3);
	str2double(RxBuffer, ' ', 4, &d);
	str2double(RxBuffer, ' ', 5, &e);
	str2double(RxBuffer, ' ', 6, &f);
}

进入debug模式，监视变量a、b、c、d、e、f，使用串口调试助手再次发送一段测试字符串
效果如图所示:
在这里插入图片描述
可以看到六个数据都已成功存入对应的变量中，并成功回显。
在这里插入图片描述
且多次测试都能成功解读
在这里插入图片描述

四、Openmv / K210 发送、STM32接收测试

(示例) 平台: MaixPy IDE、K210 Maix Bit

K210 串口测试程序
延时500ms时

import utime
from board import board_info
from Maix import freq
from fpioa_manager import fm
from machine import UART

import random

fm.register(9,fm.fpioa.UART1_TX)
fm.register(10,fm.fpioa.UART1_RX)
UART_USB = UART(UART.UART1, 115200, 8, None, 1, timeout = 1000, read_buf_len = 128)

while(True):
    Tube_X = random.randint(-200,200)
    Tube_Y = random.randint(-200,200)
    Tube_Angle = random.random()
    print('%d %d %f'%(Tube_X, Tube_Y, Tube_Angle))
    UART_USB.write('%d %d %f\r\n'%(Tube_X, Tube_Y, Tube_Angle))
    utime.sleep_ms(500)

修改UART_DMA.c中的DataProcess()函数

int32_t Tube_X = 0, Tube_Y = 0;
double  Tube_Angle = 0;
void DataProcess(void)
{
	//在这里加入数据处理的函数
	Tube_X = str2int(RxBuffer, ' ', 1);
	Tube_Y = str2int(RxBuffer, ' ', 2);
	str2double(RxBuffer, ' ', 3, &Tube_Angle);
}

进入debug，如图所示，数据提取成功
在这里插入图片描述
延时15ms时

#...
while(True):
    Tube_X = random.randint(-200,200)
    Tube_Y = random.randint(-200,200)
    Tube_Angle = random.random()
    print('%d %d %f'%(Tube_X, Tube_Y, Tube_Angle))
    UART_USB.write('%d %d %f\r\n'%(Tube_X, Tube_Y, Tube_Angle))
    utime.sleep_ms(15)
    #...

在这里插入图片描述

总结

本文介绍了一种STM32 串口DMA收发并解读的方案，对CPU要求较小，只需自己选择分隔符号，不需要设计复杂的通信协议就能得到对应位置的数据，应该可以应用到使用STM32的多种科创比赛项目中去。

修订版本

UART_DMA.c

/*
 * UART_DMA.c
 *
 *  Created on: Mar 14, 2021
 *      Author: Royic
 */
#include "UART_DMA.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

uint8_t RxBuffer[UART_RX_BUF_SIZE] = {0};
uint8_t TxBuffer[UART_RX_BUF_SIZE] = {0};
uint8_t sendCompleteSign = 1;
uint8_t TxLen = 0;
uint8_t USE_UART_DMA = 0;

void DataProcess(UART_HandleTypeDef *huart, uint32_t Len)
{
	//在这里加入数据处理的函数
#ifdef USB_Huart_1
	if(huart == &USB_Huart_1)
    {
        ;
    }
#endif
#ifdef USB_Huart_2
	if(huart == &USB_Huart_2)
	{
		;
	}
#endif
}

//到USARTx_IRQHandler中添加，如:
//void USART1_IRQHandler(void)
//{
//  /* USER CODE BEGIN USART1_IRQn 0 */
//  if(__HAL_UART_GET_FLAG(&USB_Huart_1,UART_FLAG_IDLE))
//  {
//	  HAL_UART_IdleCallback(&USB_Huart_1);
//  }
//
//  /* USER CODE END USART1_IRQn 0 */
//  HAL_UART_IRQHandler(&huartx);
//}
void HAL_UART_IdleCallback(UART_HandleTypeDef *huart)
{
	__HAL_UART_CLEAR_IDLEFLAG(huart);
	{
		HAL_UART_DMAStop(huart);

        ProcessData(huart);

        StartUartRxDMA(huart);
	}
}

void ProcessData(UART_HandleTypeDef *huart)
{
    uint32_t len = 0;

	len = UART_RX_BUF_SIZE - __HAL_DMA_GET_COUNTER(huart->hdmarx);

    if(len > 0)
    {
        if(sendCompleteSign == 1)
        {
#if UART_RXTX_Switch
            memset((void *)TxBuffer, 0, sizeof(TxBuffer));
            memcpy(TxBuffer, RxBuffer, len);
            TxLen = len;
            StartUartTxDMA(huart);	//串口回显
#endif
        }
        {
        	//在这里面加入数据处理的函数
        	DataProcess(huart, len);
        }
    }
}

void USB_DMA_printf(UART_HandleTypeDef *huart, const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit_DMA(huart,TxBuffer,length);
}

void USB_printf(UART_HandleTypeDef *huart, const char *format,...)
{
	uint32_t length;
	va_list args;

	va_start(args, format);
	length = vsnprintf((char*)TxBuffer, sizeof(TxBuffer)+1, (char*)format, args);
	va_end(args);

	HAL_UART_Transmit(huart,TxBuffer,length,0xFFFF);
}

/**
  * @brief  Tx Transfer completed callbacks.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
	sendCompleteSign = 1;
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_TxCpltCallback could be implemented in the user file
   */
}

/**
  * @brief  Rx Transfer completed callbacks.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
	ProcessData(huart);
	StartUartRxDMA(huart);
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_RxCpltCallback could be implemented in the user file
   */
}

uint8_t UartTxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len)
{
	HAL_StatusTypeDef status;
	uint8_t ret = 1;

	if(sendCompleteSign == 0 || len == 0)
	{
		return 0;
	}

    sendCompleteSign = 0;

	status = HAL_UART_Transmit_DMA(huart, (uint8_t*)buf, len);

	if(HAL_OK != status)
	{
		ret = 0;
	}

	return ret;
}

//启动DMA发送
uint8_t StartUartTxDMA(UART_HandleTypeDef *huart)
{
    return UartTxData(huart, TxBuffer, TxLen);
}

uint8_t UartRxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len)
{
	HAL_StatusTypeDef status;
	uint8_t ret = 1;

	status = HAL_UART_Receive_DMA(huart, (uint8_t*)buf, len);
	if(HAL_OK != status)
	{
		ret = 0;
	}
	else
	{
		/* 开启空闲接收中断 */
	    __HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
	}

	return ret;
}

//启动DMA接收
uint8_t StartUartRxDMA(UART_HandleTypeDef *huart)
{
	USE_UART_DMA = 1;
    return UartRxData(huart, RxBuffer, UART_RX_BUF_SIZE);
}

UART_DMA.h

/*
 * UART_DMA.h
 *
 *  Created on: Mar 14, 2021
 *      Author: Royic
 */

#ifndef UART_DMA_UART_DMA_H_
#define UART_DMA_UART_DMA_H_

#include "main.h"

#define USB_Huart_1 huart1			//修改为所用串口
extern UART_HandleTypeDef USB_Huart_1;

#define USB_Huart_2 huart2			//修改为所用串口
extern UART_HandleTypeDef USB_Huart_2;

#define UART_RX_BUF_SIZE 128

#define UART_RXTX_Switch 0			//串口回显开关
//#define UART_DMA_Switch 0			

/*
要在Cube中开串口全局中断和收发DMA
 */

extern uint8_t RxBuffer[UART_RX_BUF_SIZE];
extern uint8_t TxBuffer[UART_RX_BUF_SIZE];
extern uint8_t TxLen;
extern uint8_t USE_UART_DMA;

void USB_DMA_printf(UART_HandleTypeDef *huart, const char *format,...);			//printf DMA方式
void USB_printf(UART_HandleTypeDef *huart, const char *format,...);				//printf 普通方式
uint8_t UartTxData(UART_HandleTypeDef *huart, uint8_t *buf, const uint32_t len);
uint8_t StartUartRxDMA(UART_HandleTypeDef *huart);								//接收DMA初始化
uint8_t StartUartTxDMA(UART_HandleTypeDef *huart);								//不需要自己调用
void ProcessData(UART_HandleTypeDef *huart);										//在里面添加数据处理函数
void HAL_UART_IdleCallback(UART_HandleTypeDef *huart);	//到USARTx_IRQHandler中添加

#endif /* UART_DMA_UART_DMA_H_ */
乙酸氧铍
关注
  • 19
    点赞
  • 踩
  • 149
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
STM32F4 串口（DMA发送接收方式）代码例程
02-24
STM32F4 串口（DMA发送接收方式）代码例程 STM32F4 DMA收发 经过稳定测试 初始化后直接用
使用openMV3与stm32进行通讯
qq_43243338的博客
04-21 4万+
使用openMV3与stm32进行通讯 想用openMV与stm32通讯，在网上找了一大圈，最后决定使用串口 可以找到openMV的引脚资源图如下： 这里使用P4(USART3_TX)与P5(USART3_RX)脚与stm32的USART1交叉联接。 openMV的代码如下,功能是进行色块识别并把中心点传给stm32,需要注意的是对数据的打包格式，用到了ustruct.pack这个函数： im...
stm32f103与openmv串口通信
m0_64357419的博客
03-21 1927
在while循环中，你可以使用USART1_SendChar()或USART1_SendString()函数向OpenMV发送数据，也可以使用USART1_GetChar()函数接收OpenMV发送的数据。总之，串口通信是嵌入式系统中非常重要的一种通信方式，它可以方便地进行调试、控制、通信和数据传输等操作，为嵌入式系统的开发和应用提供了强大的支持。控制和通信：嵌入式设备可以通过串口与其他设备进行通信，例如与传感器、执行器、显示器等设备进行数据交互和控制。
物联网毕设 -- 基于K210的瓶子识别（STM32+K210）
最新发布
herui_2的博客
02-22 945
这段话描述了一个系统，该系统包括一个OLED显示屏，用于实时显示设备状态；一个K210设备，用于进行图像识别并将识别结果通过串口发送给主控芯片STM32F103C8T6；以及主控芯片，负责接收识别结果并显示出来。整个系统协同工作，将设备状态和图像识别结果实时显示在屏幕上。关注微信公众号--星之援工作室 发送关键字（项目清单）可获取项目清单资料➡️🫡🫡🫡🫡🫡🫡🫡🫡➡️⚠️⚠️（本文章仅提供思路和实现方法，并不包含代码，需要代码的同学请自行联系博主）
【学习笔记】stm32+openmv串口通信实现颜色识别
nuizaihenmang的博客
05-27 5691
stm32+openmv串口通信实现获取颜色的坐标
OpenMV入门
热门推荐
ArtoriaLili的博客
02-20 8万+
1. 什么是OpenMV OpenMV 是一个开源，低成本，功能强大的 机器视觉模块。 OpenMV上的机器视觉算法包括 寻找色块、人脸检测、眼球跟踪、边缘检测、标志跟踪等。 以STM32F427CPU为核心，集成了OV7725摄像头芯片，在小巧的硬件模块上，用C语言高效地实现了核心机器视觉算法，提供Python编程接口。 （这也就意味着，我们可以通过python来对他进行编程，所以我们就需要学习一点基础的python知识） ———————————————— 2. 关于OpenM...
K210使用记录
时时总结，常常分享
05-20 5875
文章目录1、基本资料来源2、基本视觉功能3、训练K210环境搭建1、CUDA和CUDNN的安装配置2、开始安装3、anaconda环境配置3、训练神经网络模型4、K210运行神经网络模型 本文算是对K210使用的一个记录吧，这样以后方便后面的学弟学妹快速学习了解K210的基本知识和入门使用 1、基本资料来源 2、基本视觉功能 3、训练K210环境搭建 1、CUDA和CUDNN的安装配置 需要配置这两个才能成功调用电脑的GPU来训练，不然这个训练速度简直就不是一个速度级别的，差距有很大，所以电脑有GPU还
openmv识别红色物体并返回坐标给stm32单片机，通过pid控制舵机云台
qq_52798893的博客
07-18 1万+
openmv识别红色物体并返回坐标给stm32单片机，通过pid控制舵机云台
STM32串口接收变量（浮点型 float；整型int）
ABYSS_CL的博客
07-20 1万+
一，原理 主设备（stm32）串口接收数据时，使用单次中断即接收一个字符后触发中断。 从设备串口发送的数据格式为 [变量一，变量二，变量三] (方括号和逗号不可缺少)，例如：[-12.3,12,234] ；注意发送的变量(包括小数点和负号)长度小于8，小数点后位数最好小于2位。 函数将接收到的变量转换成实数（浮点型 float；整型int）储存在（arrays）数组中，数组默认保存三个实数（可更改）。 二，函数代码 /** *函数功能 ：接收到的数据转换成浮点型 *rx ：单次接收到的字符 *a
STM32串口数据接收处理，数据分割为整形浮点型数据。
qq_44515486的博客
04-19 6490
stm32、串口、数据接收、数据分割、字符转换
[STM32]基于外设USART实现单字符、字符串发送，接受功能实现
游戏人生
04-17 6021
[STM32]基于外设USART实现单字符、字符串发送，接受功能实现
基于stm32与K210,openmv串口通信
11-05
stm32端代码 -> stm32串口调试.zip k210端代码 -> k210.py openmv端代码 -> openmv.py stm32端 引脚定义: 四脚I2C OLED: SCL -> B12 SDA -> B13 串口1: TX->A9 RX->A10 波特率9600 功能: 接收数据并显示在OLED上 ...
STM32HAL库＋K210实现遥控＋避障＋循迹小车
04-16
文件内涵代码解释视频和作品演示视频，以及各种详细说明，使用STM32CUBEMX对STM32F103C8T6进行配置，K210与单片机进行串口通信，K210将识别到的黑色色块中心坐标发送单片机，将一帧数据传给单片机之后，单片机判断...
基于stm32f407的送药小车，k210识别，openmv巡线
07-20
基于stm32f407的送药小车，k210识别，openmv巡线，附带几个研究题目
openmv/k210/opencv学习资料
05-05
有关openmv,opencv.k210的资料，比较全。可以快速上手用来做一些嵌入式相关的小东西或者需要视觉识别的比赛
STM32之串口发送宽度为9位的数据
01-06
最近为了配置一个芯片使用到了串口发送9位数据位的情况，在此小记一下。 1. 串口硬件和参数初始化 将数据位宽度配置成：UART_WORDLENGTH_9B ，其他参数和常规配置一样。 UART_HandleTypeDef husart3; void HAL_UART_...
【51单片机快速入门指南】4.3.1： MPU6050调用DMP库获取四元数和欧拉角
乙酸氧铍的博客
11-24 1万+
目录DMP.cDMP.h测试程序实验现象 普中51-单核-A2 STC89C52 Keil uVision V5.29.0.0 PK51 Prof.Developers Kit Version:9.60.0.0 上位机：Vofa+ 1.3.10 小改自ksws0263785大佬的51单片机使用 mpu6050DMP，使之调用统一的I2C函数，方便移植到其它单片机。        stdint.h见【51单片机快速入门指南】1：基础
适用于单片机的FFT快速傅里叶变换算法，51单片机都能用
乙酸氧铍的博客
11-10 1万+
目录源码FFT.cFFT.h使用方法效果其他部分的代码main.c 普中51-单核-A2 STC89C52 Keil uVision V5.29.0.0 PK51 Prof.Developers Kit Version:9.60.0.0 算法来自FFT算法的使用说明与C语言版实现源码 —— 原作者：吉帅虎 移植十分简单，不依赖其他库，可自定义点数 源码 FFT.c /********************************************************************
【电路补习笔记】10、电感式开关电源（BUCK 降压电路）
乙酸氧铍的博客
02-06 1万+
目录分类工作原理 老师的主页：唐老师讲电赛 视频地址： 电源大师4—电感式开关电源（BUCK 降压电路）工作原理、数据手册、PCB设计         分类 工作原理 占空比D=tonton+toff=tonTs 占空比 D =\frac{t_{on}}{t_{on}+t_{off}}=\frac{t_{on}}{T_s}占空比D=ton​+toff​ton​​=Ts​ton​​ 开关频率fsw=1/Ts开关频率 f_{sw}=
stm32cubemx二维坐标控制舵机
08-03
在使用STM32CubeMX进行二维坐标控制舵机的过程中，可以按照以下步骤进行操作： 1. 配置串口：在STM32CubeMX中选择对应的串口，并设置波特率等参数，以便与OpenMV进行通信。 2. 配置舵机控制引脚：选择一个PWM输出引脚作为舵机的控制引脚，并设置对应的定时器和通道。 3. 编写串口接收中断函数：在Keil等开发环境中编写串口接收中断函数，用于接收OpenMV发送的坐标数据。 4. 解析坐标数据：在串口接收中断函数中，解析接收到的坐标数据，并计算与目标中心点的差值。 5. 使用PID控制舵机：根据差值计算出的偏差，使用PID控制算法来控制舵机的旋转角度。可以根据差值的正负来确定舵机旋转的方向和角度。 6. 生成代码并烧录：在STM32CubeMX中生成代码，并将生成的代码烧录到STM32单片机中。 通过以上步骤，就可以实现使用STM32CubeMX进行二维坐标控制舵机的功能。请注意，具体的代码实现和参数设置需要根据具体的硬件和需求进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乙酸氧铍

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值