提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
目录
前言
最近在学到了STM32F103C8T6通过串口收发数据这一部分，通过学习B站江科大和野火stm32的教程，对stm32的串口收发数据有了一些了解，结合之前学习ADC采集使用DMA的经验，尝试了一下将串口数据收发用DMA进行转运，最终实现了实验目的。希望更多的朋友能掌握串口使用和DMA对数据的转运过程，所以在这里分享一下。希望大家能够点个赞支持一下，非常感谢！
1.DMA介绍
DMA，全称为：Direct Memory Access，即直接存储器访问。它可以对于外设和存储器之间或存储器和存储器之间的数据进行高速传输。这个过程无须 CPU 干预，数据可以通过 DMA 快速地移动，这就节省了 CPU 的资源来做其他操作。DMA 传输方式无需 CPU 直接控制传输，也没有中断处理方式那样保留现场和恢复现场的过程，通过硬件为 RAM 与 I/O 设备开辟一条直接传送数据的通路， 能使 CPU 的效率大为提高。
2.串口接收数据
通过这段时间对于串口收发数据的学习，了解到常见的对于串口接收的处理有三种方法，分别是：查询等待接收数据、中断的方式接收数据和DMA转运的收发数据。
首先查询等待接收数据时，在遇到数据传输速度比较快的时候，可能会遇到来不及处理上一个接收到的数据就马上收到下一个数据，从而导致数据被覆盖或者丢失，并且在等待的时间里也浪费掉了CPU的资源。
其次是中断的方式，通过检测完成标志位，再对数据进行处理，这种方式每当接收到一帧数据，程序就会中断一次，使得程序频繁进入中断，而且数据在传输时同样要等待一些时间。
而使用DMA对数据进行传输是不需要CPU的参与，属于一个纯硬件的过程，节约了CPU的资源，以便让它可以去更高效处理其他事情。像2.4G模块，TFT屏幕等，它们在运行时都会有大量的数据需要处理，所以DMA处理数据是非常有必要去了解的。
3.实验现象
1.实验电路图
2.串口收发不定长数据视频演示
串口收发不定长数据演示
3.OLED 显示接收数据
4.代码部分
1.1串口模块
这里使用的是串口1，不太了解的朋友在这里可以参考学习B站江科大对于串口的教程[9-2] USART串口外设_哔哩哔哩_bilibili
serial.c
#include "serial.h"
#include "oled.h"
uint8_t USART1_TX_BUF[USART1_MAX_TX_LEN]; //发送缓冲,最大USART1_MAX_TX_LEN字节
uint8_t u1rxbuf[USART1_MAX_RX_LEN]; //发送数据缓冲区1
uint8_t u2rxbuf[USART1_MAX_RX_LEN]; //发送数据缓冲区2
uint8_t witchbuf=0; //标记当前使用的是哪个缓冲区,0：使用u1rxbuf；1：使用u2rxbuf
uint8_t USART1_TX_FLAG; //USART1发送标志，启动发送时置1
uint8_t USART1_RX_FLAG; //USART1接收标志，启动接收时置1
void Serial_Init(void)
{
//开启串口1和外设GPIO时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
//初始化串口的GPIO口
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;//发送TXD
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//接收RXD
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//初始化串口结构体
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate=9600;
USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode=USART_Mode_Tx| USART_Mode_Rx;;
USART_InitStructure.USART_Parity=USART_Parity_No;
USART_InitStructure.USART_StopBits=USART_StopBits_1;
USART_InitStructure.USART_WordLength=USART_WordLength_8b;
USART_Init(USART1,&USART_InitStructure);
//使能串口1
USART_Cmd(USART1,ENABLE);
}
//可变参串口打印函数
void USART1_printf(char *format, ...)
{
va_list arg_ptr; //实例化可变长参数列表
while(USART1_TX_FLAG); //等待上一次发送完成（USART2_TX_FLAG为1即还在发送数据）
va_start(arg_ptr, format); //初始化可变参数列表，设置format为可变长列表的起始点（第一个元素）
// USART1_MAX_TX_LEN+1可接受的最大字符数(非字节数，UNICODE一个字符两个字节), 防止产生数组越界
vsnprintf((char*)USART1_TX_BUF, USART1_MAX_TX_LEN+1, format, arg_ptr); //从USART1_TX_BUF的首地址开始拼合，拼合format内容；USART1_MAX_TX_LEN+1限制长度，防止产生数组越界
va_end(arg_ptr); //注意必须关闭
DMA_USART1_Tx_Data(USART1_TX_BUF,strlen((const char*)USART1_TX_BUF)); //发送USART1_TX_BUF内容
}
//串口通过DMA 发送数据
//buffer-->发送数据地址
//size-->发送的字节大小
void DMA_USART1_Tx_Data(u8 *buffer, u32 size)
{
while(USART1_TX_FLAG); //等待上一次发送完成（USART1_TX_FLAG为1即还在发送数据）
USART1_TX_FLAG=1; //USART1发送标志（启动发送）
DMA1_Channel4->CMAR = (uint32_t)buffer; //设置要发送的数据地址
DMA1_Channel4->CNDTR = size; //设置要发送的字节数目
DMA_Cmd(DMA1_Channel4, ENABLE); //开始DMA发送
}
//DMA1通道4中断，判断上次数据串口是否已经发送完成
void DMA1_Channel4_IRQHandler(void)
{
if(DMA_GetITStatus(DMA1_IT_TC4)!= RESET) //DMA接收完成标志
{
DMA_ClearITPendingBit(DMA1_IT_TC4); //清除中断标志
USART_ClearFlag(USART1,USART_FLAG_TC); //清除串口1的标志位
DMA_Cmd(DMA1_Channel4, DISABLE ); //关闭USART1 TX DMA1 所指示的通道
USART1_TX_FLAG=0; //USART1发送标志(关闭)
}
}
//串口1中断函数
void USART1_IRQHandler(void)
{
uint8_t *p;
uint8_t USART1_RX_LEN = 0; //接收数据长度
if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET) //串口2空闲中断
{
USART_ReceiveData(USART1); //清除串口1空闲中断IDLE标志位
USART_ClearFlag(USART1,USART_FLAG_TC); //清除USART1标志位
DMA_Cmd(DMA1_Channel5, DISABLE ); //关闭USART1 TX DMA1 所指示的通道
USART1_RX_LEN = USART1_MAX_RX_LEN - DMA1_Channel5->CNDTR; //获得接收到的字节数
if(witchbuf) //之前用的u2rxbuf，切换为u1rxbuf
{
p=u2rxbuf; //先保存前一次数据地址再切换缓冲区
DMA1_Channel5->CMAR=(u32)u1rxbuf; //切换为u1rxbuf缓冲区地址
witchbuf=0; //下一次切换为u2rxbuf
}else //之前用的u1rxbuf，切换为u2rxbuf
{
p=u1rxbuf; //先保存前一次数据地址再切换缓冲区
DMA1_Channel5->CMAR=(u32)u2rxbuf; //切换为u2rxbuf缓冲区地址
witchbuf=1; //下一次切换为u1rxbuf
}
DMA1_Channel5->CNDTR = USART1_MAX_RX_LEN; //DMA通道的DMA缓存的大小
DMA_Cmd(DMA1_Channel5, ENABLE); //使能USART1 TX DMA1 所指示的通道
//******************数据处理******************//
// 数据接收到p所指向的指针区域，数据大小为 USART1_RX_LEN
OLED_ShowHexNum(2,1,p[0],2);//将接收到的数据打印至OLED
OLED_ShowHexNum(2,4,p[1],2);
OLED_ShowHexNum(2,7,p[2],2);
OLED_ShowHexNum(2,10,p[3],2);
DMA_USART1_Tx_Data(p,USART1_RX_LEN);//将接收到的数据发送至串口显示
}
}
serial.h
#ifndef __SERIAL_H
#define __SERIAL_H
#include "sys.h"
#include <stdio.h>
#include <stdarg.h>
#define USART1_MAX_TX_LEN 256
#define USART1_MAX_RX_LEN 256
extern uint8_t USART1_TX_FLAG; //USART2发送标志，启动发送时置1
extern uint8_t USART1_RX_FLAG; //USART2接收标志，启动接收时置1
extern size_t strlen(const char *);
extern uint8_t USART1_TX_BUF[USART1_MAX_TX_LEN]; //发送缓冲,最大USART2_MAX_TX_LEN字节
extern uint8_t u1rxbuf[USART1_MAX_RX_LEN]; //发送数据缓冲区1
extern uint8_t u2rxbuf[USART1_MAX_RX_LEN]; //发送数据缓冲区2
void Serial_Init(void);
void USART1_printf(char *format, ...);
void DMA_USART1_Tx_Data(u8 *buffer, u32 size);
#endif
1.2NVIC配置
这里使用了串口空闲中断，这时候就借助DMA传输完成中断。既然打开了中断，那一定要注意中断优先级，这里特别指出串口的中断优先级应低于串口DMA通道的中断优先级。
nvic.c
#include "nvic.h"
void NVIC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//串口的中断优先级一定要低于串口DMA通道的中断优先级
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 8;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);
//DMA1通道5 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel5_IRQn; //NVIC通道设置
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化NVIC寄存器
//DMA1通道4 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn; //NVIC通道设置
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //子优先级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化NVIC寄存器
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);//开启串口接收中断
USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口空闲中断
USART_ITConfig(USART1, USART_IT_IDLE, ENABLE); //开启检测串口空闲状态中断
USART_ClearFlag(USART1,USART_FLAG_TC); //清除USART1标志位
}
nvic.h
#ifndef __NVIC_H
#define __NVIC_H
#include "sys.h"
void NVIC_Config(void);
#endif
1.3DMA配置
dma.c
#include "dma.h"
void MyDMA_Init(void)
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
DMA_InitTypeDef DMA_InitStructure;
DMA_DeInit(DMA1_Channel4); //tx 发送数据
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART1_TX_BUF;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = USART1_MAX_TX_LEN;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel4,&DMA_InitStructure);
DMA_DeInit(DMA1_Channel5);
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)u1rxbuf;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = USART1_MAX_RX_LEN;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel5,&DMA_InitStructure);
DMA_ITConfig(DMA1_Channel5,DMA_IT_TC,ENABLE); //开USART2 Rx DMA中断
DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE); //开USART2 Tx DMA中断
DMA_Cmd(DMA1_Channel5,ENABLE); //使DMA通道5停止工作
DMA_Cmd(DMA1_Channel4,DISABLE); //使DMA通道4停止工作
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE); //开启串口DMA发送
USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE); //开启串口DMA接收
}
dma.h
#ifndef __DMA_H
#define __DMA_H
#include "sys.h"
#include "serial.h"
void MyDMA_Init(void);
#endif
1.4其他模块
sys.c
#include "sys.h"
//
//THUMB指令不支持汇编内联
//采用如下方法实现执行汇编指令WFI
void WFI_SET(void)
{
__ASM volatile("wfi");
}
//关闭所有中断
void INTX_DISABLE(void)
{
__ASM volatile("cpsid i");
}
//开启所有中断
void INTX_ENABLE(void)
{
__ASM volatile("cpsie i");
}
//设置栈顶地址
//addr:栈顶地址
__asm void MSR_MSP(u32 addr)
{
MSR MSP, r0 //set Main Stack value
BX r14
}
sys.h
#ifndef __SYS_H
#define __SYS_H
#include "stm32f10x.h"
//0,不支持ucos
//1,支持ucos
#define SYSTEM_SUPPORT_OS 0 //定义系统文件夹是否支持UCOS
//位带操作,实现51类似的GPIO控制功能
//具体实现思想,参考<<CM3权威指南>>第五章(87页~92页).
//IO口操作宏定义
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2))
#define MEM_ADDR(addr) *((volatile unsigned long *)(addr))
#define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum))
//IO口地址映射
#define GPIOA_ODR_Addr (GPIOA_BASE+12) //0x4001080C
#define GPIOB_ODR_Addr (GPIOB_BASE+12) //0x40010C0C
#define GPIOC_ODR_Addr (GPIOC_BASE+12) //0x4001100C
#define GPIOD_ODR_Addr (GPIOD_BASE+12) //0x4001140C
#define GPIOE_ODR_Addr (GPIOE_BASE+12) //0x4001180C
#define GPIOF_ODR_Addr (GPIOF_BASE+12) //0x40011A0C
#define GPIOG_ODR_Addr (GPIOG_BASE+12) //0x40011E0C
#define GPIOA_IDR_Addr (GPIOA_BASE+8) //0x40010808
#define GPIOB_IDR_Addr (GPIOB_BASE+8) //0x40010C08
#define GPIOC_IDR_Addr (GPIOC_BASE+8) //0x40011008
#define GPIOD_IDR_Addr (GPIOD_BASE+8) //0x40011408
#define GPIOE_IDR_Addr (GPIOE_BASE+8) //0x40011808
#define GPIOF_IDR_Addr (GPIOF_BASE+8) //0x40011A08
#define GPIOG_IDR_Addr (GPIOG_BASE+8) //0x40011E08
//IO口操作,只对单一的IO口!
//确保n的值小于16!
#define PAout(n) BIT_ADDR(GPIOA_ODR_Addr,n) //输出
#define PAin(n) BIT_ADDR(GPIOA_IDR_Addr,n) //输入
#define PBout(n) BIT_ADDR(GPIOB_ODR_Addr,n) //输出
#define PBin(n) BIT_ADDR(GPIOB_IDR_Addr,n) //输入
#define PCout(n) BIT_ADDR(GPIOC_ODR_Addr,n) //输出
#define PCin(n) BIT_ADDR(GPIOC_IDR_Addr,n) //输入
#define PDout(n) BIT_ADDR(GPIOD_ODR_Addr,n) //输出
#define PDin(n) BIT_ADDR(GPIOD_IDR_Addr,n) //输入
#define PEout(n) BIT_ADDR(GPIOE_ODR_Addr,n) //输出
#define PEin(n) BIT_ADDR(GPIOE_IDR_Addr,n) //输入
#define PFout(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出
#define PFin(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入
#define PGout(n) BIT_ADDR(GPIOG_ODR_Addr,n) //输出
#define PGin(n) BIT_ADDR(GPIOG_IDR_Addr,n) //输入
//以下为汇编函数
void WFI_SET(void); //执行WFI指令
void INTX_DISABLE(void);//关闭所有中断
void INTX_ENABLE(void); //开启所有中断
void MSR_MSP(u32 addr); //设置堆栈地址
#endif
oled.c
#include "stm32f10x.h"
#include "oled.h"
#include "OLED_Font.h"
/*引脚配置*/
#define OLED_W_SCL(x) GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
#define OLED_W_SDA(x) GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))
/*引脚初始化*/
void OLED_I2C_Init(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_Init(GPIOB, &GPIO_InitStructure);
OLED_W_SCL(1);
OLED_W_SDA(1);
}
/**
* @brief I2C开始
* @param 无
* @retval 无
*/
void OLED_I2C_Start(void)
{
OLED_W_SDA(1);
OLED_W_SCL(1);
OLED_W_SDA(0);
OLED_W_SCL(0);
}
/**
* @brief I2C停止
* @param 无
* @retval 无
*/
void OLED_I2C_Stop(void)
{
OLED_W_SDA(0);
OLED_W_SCL(1);
OLED_W_SDA(1);
}
/**
* @brief I2C发送一个字节
* @param Byte 要发送的一个字节
* @retval 无
*/
void OLED_I2C_SendByte(uint8_t Byte)
{
uint8_t i;
for (i = 0; i < 8; i++)
{
OLED_W_SDA(Byte & (0x80 >> i));
OLED_W_SCL(1);
OLED_W_SCL(0);
}
OLED_W_SCL(1); //额外的一个时钟，不处理应答信号
OLED_W_SCL(0);
}
/**
* @brief OLED写命令
* @param Command 要写入的命令
* @retval 无
*/
void OLED_WriteCommand(uint8_t Command)
{
OLED_I2C_Start();
OLED_I2C_SendByte(0x78); //从机地址
OLED_I2C_SendByte(0x00); //写命令
OLED_I2C_SendByte(Command);
OLED_I2C_Stop();
}
/**
* @brief OLED写数据
* @param Data 要写入的数据
* @retval 无
*/
void OLED_WriteData(uint8_t Data)
{
OLED_I2C_Start();
OLED_I2C_SendByte(0x78); //从机地址
OLED_I2C_SendByte(0x40); //写数据
OLED_I2C_SendByte(Data);
OLED_I2C_Stop();
}
/**
* @brief OLED设置光标位置
* @param Y 以左上角为原点，向下方向的坐标，范围：0~7
* @param X 以左上角为原点，向右方向的坐标，范围：0~127
* @retval 无
*/
void OLED_SetCursor(uint8_t Y, uint8_t X)
{
OLED_WriteCommand(0xB0 | Y); //设置Y位置
OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4)); //设置X位置低4位
OLED_WriteCommand(0x00 | (X & 0x0F)); //设置X位置高4位
}
/**
* @brief OLED清屏
* @param 无
* @retval 无
*/
void OLED_Clear(void)
{
uint8_t i, j;
for (j = 0; j < 8; j++)
{
OLED_SetCursor(j, 0);
for(i = 0; i < 128; i++)
{
OLED_WriteData(0x00);
}
}
}
/**
* @brief OLED显示一个字符
* @param Line 行位置，范围：1~4
* @param Column 列位置，范围：1~16
* @param Char 要显示的一个字符，范围：ASCII可见字符
* @retval 无
*/
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
{
uint8_t i;
OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8); //设置光标位置在上半部分
for (i = 0; i < 8; i++)
{
OLED_WriteData(OLED_F8x16[Char - ' '][i]); //显示上半部分内容
}
OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8); //设置光标位置在下半部分
for (i = 0; i < 8; i++)
{
OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]); //显示下半部分内容
}
}
/**
* @brief OLED显示字符串
* @param Line 起始行位置，范围：1~4
* @param Column 起始列位置，范围：1~16
* @param String 要显示的字符串，范围：ASCII可见字符
* @retval 无
*/
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
{
uint8_t i;
for (i = 0; String[i] != '\0'; i++)
{
OLED_ShowChar(Line, Column + i, String[i]);
}
}
/**
* @brief OLED次方函数
* @retval 返回值等于X的Y次方
*/
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
uint32_t Result = 1;
while (Y--)
{
Result *= X;
}
return Result;
}
/**
* @brief OLED显示数字（十进制，正数）
* @param Line 起始行位置，范围：1~4
* @param Column 起始列位置，范围：1~16
* @param Number 要显示的数字，范围：0~4294967295
* @param Length 要显示数字的长度，范围：1~10
* @retval 无
*/
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
uint8_t i;
for (i = 0; i < Length; i++)
{
OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
}
}
/**
* @brief OLED显示数字（十进制，带符号数）
* @param Line 起始行位置，范围：1~4
* @param Column 起始列位置，范围：1~16
* @param Number 要显示的数字，范围：-2147483648~2147483647
* @param Length 要显示数字的长度，范围：1~10
* @retval 无
*/
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
{
uint8_t i;
uint32_t Number1;
if (Number >= 0)
{
OLED_ShowChar(Line, Column, '+');
Number1 = Number;
}
else
{
OLED_ShowChar(Line, Column, '-');
Number1 = -Number;
}
for (i = 0; i < Length; i++)
{
OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
}
}
/**
* @brief OLED显示数字（十六进制，正数）
* @param Line 起始行位置，范围：1~4
* @param Column 起始列位置，范围：1~16
* @param Number 要显示的数字，范围：0~0xFFFFFFFF
* @param Length 要显示数字的长度，范围：1~8
* @retval 无
*/
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
uint8_t i, SingleNumber;
for (i = 0; i < Length; i++)
{
SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
if (SingleNumber < 10)
{
OLED_ShowChar(Line, Column + i, SingleNumber + '0');
}
else
{
OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
}
}
}
/**
* @brief OLED显示数字（二进制，正数）
* @param Line 起始行位置，范围：1~4
* @param Column 起始列位置，范围：1~16
* @param Number 要显示的数字，范围：0~1111 1111 1111 1111
* @param Length 要显示数字的长度，范围：1~16
* @retval 无
*/
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
uint8_t i;
for (i = 0; i < Length; i++)
{
OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
}
}
/**
* @brief OLED初始化
* @param 无
* @retval 无
*/
void OLED_Init(void)
{
uint32_t i, j;
for (i = 0; i < 1000; i++) //上电延时
{
for (j = 0; j < 1000; j++);
}
OLED_I2C_Init(); //端口初始化
OLED_WriteCommand(0xAE); //关闭显示
OLED_WriteCommand(0xD5); //设置显示时钟分频比/振荡器频率
OLED_WriteCommand(0x80);
OLED_WriteCommand(0xA8); //设置多路复用率
OLED_WriteCommand(0x3F);
OLED_WriteCommand(0xD3); //设置显示偏移
OLED_WriteCommand(0x00);
OLED_WriteCommand(0x40); //设置显示开始行
OLED_WriteCommand(0xA1); //设置左右方向，0xA1正常 0xA0左右反置
OLED_WriteCommand(0xC8); //设置上下方向，0xC8正常 0xC0上下反置
OLED_WriteCommand(0xDA); //设置COM引脚硬件配置
OLED_WriteCommand(0x12);
OLED_WriteCommand(0x81); //设置对比度控制
OLED_WriteCommand(0xCF);
OLED_WriteCommand(0xD9); //设置预充电周期
OLED_WriteCommand(0xF1);
OLED_WriteCommand(0xDB); //设置VCOMH取消选择级别
OLED_WriteCommand(0x30);
OLED_WriteCommand(0xA4); //设置整个显示打开/关闭
OLED_WriteCommand(0xA6); //设置正常/倒转显示
OLED_WriteCommand(0x8D); //设置充电泵
OLED_WriteCommand(0x14);
OLED_WriteCommand(0xAF); //开启显示
OLED_Clear(); //OLED清屏
}
oled.h
#ifndef __OLED_H
#define __OLED_H
void OLED_Init(void);
void OLED_Clear(void);
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char);
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
#endif
1.5主函数
main.c
#include "sys.h"
#include "oled.h"
#include "serial.h"
#include "delay.h"
#include "dma.h"
#include "nvic.h"
uint8_t array[5]={0x41,0x42,0x25,0x12,0x56};//向串口要发的数据
int main(void)
{
OLED_Init();
Serial_Init();
MyDMA_Init();
NVIC_Config();
OLED_ShowString(1,1,"Hello World!");
USART1_printf("Hello World!\r\n");
DMA_USART1_Tx_Data(array,5);
while(1)
{
}
}
总结
以上就是本文的所有内容辣，本文仅仅介绍了串口接收数据通过DMA进行转运，这种方法有效提高了数据传输的稳定性，提高了CPU的效率，这种方法在实际中有着很广泛的应用。
3217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
