基于stm32f103zet6的串口学习

进行串口配置的步骤
一、初始化GPIO，配置GPIO模式
一个结构体
GPIO_InitTypeDef{
GPIOMode_TypeDef GPIO_Mode//GPIO模式，输入，输出？
uint16_t GPIO_Pin//哪个管脚？
GPIOSpeed_TypeDef GPIO_Speed//输出响应速度？如果为输入则可以不设置
}
//GPIO_Mode包括以下几种方式
Enumerator: 枚举类型
GPIO_Mode_AIN //模拟输入
GPIO_Mode_IN_FLOATING //悬浮输入
GPIO_Mode_IPD //下拉输入
GPIO_Mode_IPU //上拉输入
GPIO_Mode_Out_OD //开漏输出
GPIO_Mode_Out_PP //推挽输出//push pull 直接输出为高低，当选用开漏的时候需要外接三极管
GPIO_Mode_AF_OD //复用开漏输出
GPIO_Mode_AF_PP //复用推挽输出
//GPIO_Pin包括以下几种方式
#define GPIO_Pin_0 ((uint16_t)0x0001)
#define GPIO_Pin_1 ((uint16_t)0x0002)
#define GPIO_Pin_10 ((uint16_t)0x0400)
#define GPIO_Pin_11 ((uint16_t)0x0800)
#define GPIO_Pin_12 ((uint16_t)0x1000)
#define GPIO_Pin_13 ((uint16_t)0x2000)
#define GPIO_Pin_14 ((uint16_t)0x4000)
#define GPIO_Pin_15 ((uint16_t)0x8000)
#define GPIO_Pin_2 ((uint16_t)0x0004)
#define GPIO_Pin_3 ((uint16_t)0x0008)
#define GPIO_Pin_4 ((uint16_t)0x0010)
#define GPIO_Pin_5 ((uint16_t)0x0020)
#define GPIO_Pin_6 ((uint16_t)0x0040)
#define GPIO_Pin_7 ((uint16_t)0x0080)
#define GPIO_Pin_8 ((uint16_t)0x0100)
#define GPIO_Pin_9 ((uint16_t)0x0200)
#define GPIO_Pin_All ((uint16_t)0xFFFF)
#define IS_GET_GPIO_PIN(PIN)//？？
#define IS_GPIO_PIN(PIN) ((((PIN) & (uint16_t)0x00) == 0x00) && ((PIN) != (uint16_t)0x00)) //？？？
//GPIO_Speed的模式有以下几种，同样是一个枚举类型
Output Maximum frequency selection.
Enumerator:
GPIO_Speed_10MHz
GPIO_Speed_2MHz
GPIO_Speed_50MHz
//TXD为输出，RXD为浮空输入
//选用usart1的时候管脚应该是PA9（TXD），PA10（RXD）
//所以不难得出，初始化的时候它的设计语句应该是
//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP
//GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9
//PIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;


//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING
//GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10
//PIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
那么至此为止，我的猜测GPIO初始化完毕，验证一下！
/* USART1 GPIO config */
/* Configure USART1 Tx (PA.09) as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USART1 Rx (PA.10) as input floating */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
看来问题不是很大，只是最后需要加上 GPIO_Init(GPIOA, &GPIO_InitStructure);
来指定对哪个GPIO进行初始化！
二、接下来初始化串口
// USART_InitTypeDef USART_InitStructure;//定义串口初始化结构体
还一个结构体
USART_InitTypeDef{
uint32_t USART_BaudRate//波特比率
uint16_t USART_HardwareFlowControl//硬件流，所谓硬件流待查证
uint16_t USART_Mode//串口模式，这个比较丰富
uint16_t USART_Parity//虽然不认识，但是参测应该是奇偶校验位
uint16_t USART_StopBits//停止位
uint16_t USART_WordLength//长度
}
1、一个一个进行分析，首先是USART_BaudRate
先来一个计算表达式，这个和arm11的有些类似哈
This member configures the USART communication baud rate.
The baud rate is computed using the following formula:


IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate)))//整数部分
FractionalDivider = ((IntegerDivider - ((u32) IntegerDivider)) * 16) + 0.5//小数部分
//这里涉及到另外一个结构体USART_InitStruct，跟踪下去，发现这是同一个结构体，按就好办了！直接根据波特率
//就能计算出其整数部分和小数部分，它可以取的数虽然多，但是有误差大小之分！9600 、11520等为0误差的！
2、USART_HardwareFlowControl，它的取值可以是这样
#define IS_USART_HARDWARE_FLOW_CONTROL(CONTROL)
#define USART_HardwareFlowControl_CTS ((uint16_t)0x0200)
#define USART_HardwareFlowControl_None ((uint16_t)0x0000)//据介绍应该是不使用硬件流
#define USART_HardwareFlowControl_RTS ((uint16_t)0x0100)
#define USART_HardwareFlowControl_RTS_CTS ((uint16_t)0x0300)
3、USART_Mode，三种
#define IS_USART_MODE(MODE) ((((MODE) & (uint16_t)0xFFF3) == 0x00) && ((MODE) != (uint16_t)0x00)) //双工
#define USART_Mode_Rx ((uint16_t)0x0004)
#define USART_Mode_Tx ((uint16_t)0x0008)
4、USART_Parity有以下几种取值
#define IS_USART_PARITY(PARITY)
#define USART_Parity_Even ((uint16_t)0x0400)
#define USART_Parity_No ((uint16_t)0x0000)//无奇偶标志位
#define USART_Parity_Odd ((uint16_t)0x0600)
5、USART_StopBits、USART_WordLength这两个很明显，不解释了！
分析上面之后基本上能够确定串口的配置了
//USART_InitStructure.USART_BaudRate = 11520
//USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None
//USART_InitStructure.USART_Mode = IS_USART_MODE(MODE)
//USART_InitStructure.USART_Parity = USART_Parity_No
//USART_InitStructure.USART_StopBits = USART_StopBits_1
//USART_InitStructure.USART_WordLength = USART_WordLength_8b
最后几句就是我们常说的8N1
下面来验证一下！
/* USART1 mode config */
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);
/*问题还是有不少啊
1、首先是波特率搞错应该是115200 不是 11520
2、然后是模式选错，全双工应该是USART_Mode_Rx | USART_Mode_Tx;
3、串口只是配置了，又没有初始化
4、还有串口没有使能
三、第一第二步之后，串口初始化完，下面我们就需要使用到串口了，是否还是像以前的单片机那样，
如果想要向串口发送数据就直接写个函数，个BUFF里面写数据呢？不，那效率太低了，我们使用到printf函数
系统库函数调用，下面就需要重定向！
1、我再arm11的参考书上面了解到，所谓重定向就是指，本来如果调用系统库的话，那么printf函数答应的
信息是显示到调试器窗口的，但是当我们重定向后，打印的信息就是在串口里面了，同时也能实现到彩屏上
去。
2、调用库函数必须包含stdio.h函数，现在来跟踪一下这个printf函数到底有什么东西
#include
#include
#include
/* Write formatted output to stdout from the format string FORMAT. */
/* VARARGS1 */
int __printf (const char *format, ...)
{
va_list arg;
int done;


va_start (arg, format);
done = vfprintf (stdout, format, arg);
va_end (arg);


return done;
}
继续看


int vsprintf(char *buf, const char *fmt, va_list args)
{
int len;
unsigned long num;
int i, base;
char *str;
char *s;


int flags; // Flags to number()


int field_width; // Width of output field
int precision; // Min. # of digits for integers; max number of chars for from string
int qualifier; // 'h', 'l', or 'L' for integer fields


for (str = buf; *fmt; fmt++)
{
if (*fmt != '%')
{
*str++ = *fmt;
continue;
}

// Process flags
flags = 0;
repeat:
fmt++; // This also skips first '%'
switch (*fmt)
{
case '-': flags |= LEFT; goto repeat;
case '+': flags |= PLUS; goto repeat;
case ' ': flags |= SPACE; goto repeat;
case '#': flags |= SPECIAL; goto repeat;
case '0': flags |= ZEROPAD; goto repeat;
}

// Get field width
field_width = -1;
if (is_digit(*fmt))
field_width = skip_atoi(&fmt);
else if (*fmt == '*')
{
fmt++;
field_width = va_arg(args, int);
if (field_width < 0)
{
field_width = -field_width;
flags |= LEFT;
}
}


// Get the precision
precision = -1;
if (*fmt == '.')
{
++fmt;
if (is_digit(*fmt))
precision = skip_atoi(&fmt);
else if (*fmt == '*')
{
++fmt;
precision = va_arg(args, int);
}
if (precision < 0) precision = 0;
}


// Get the conversion qualifier
qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')
{
qualifier = *fmt;
fmt++;
}


// Default base
base = 10;


switch (*fmt)
{
case 'c':
if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
*str++ = (unsigned char) va_arg(args, int);
while (--field_width > 0) *str++ = ' ';
continue;


case 's':
s = va_arg(args, char *);
if (!s) s = "";
len = strnlen(s, precision);
if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
for (i = 0; i < len; ++i) *str++ = *s++;
while (len < field_width--) *str++ = ' ';
continue;


case 'p':
if (field_width == -1)
{
field_width = 2 * sizeof(void *);
flags |= ZEROPAD;
}
str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
continue;


case 'n':
if (qualifier == 'l')
{
long *ip = va_arg(args, long *);
*ip = (str - buf);
}
else
{
int *ip = va_arg(args, int *);
*ip = (str - buf);
}
continue;


case 'A':
flags |= LARGE;


case 'a':
if (qualifier == 'l')
str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
else
str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
continue;


// Integer number formats - set up the flags and "break"
case 'o':
base = 8;
break;


case 'X':
flags |= LARGE;


case 'x':
base = 16;
break;


case 'd':
case 'i':
flags |= SIGN;


case 'u':
break;


case 'E':
case 'G':
case 'e':
case 'f':
case 'g':
str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
continue;


default:
if (*fmt != '%') *str++ = '%';
if (*fmt)
*str++ = *fmt;
else
--fmt;
continue;
}


if (qualifier == 'l')
num = va_arg(args, unsigned long);
else if (qualifier == 'h')
{
if (flags & SIGN)
num = va_arg(args, short);
else
num = va_arg(args, unsigned short);
}
else if (flags & SIGN)
num = va_arg(args, int);
else
num = va_arg(args, unsigned int);


str = number(str, num, base, field_width, precision, flags);
}


*str = '';
return str - buf;
}
似乎没有找到我需要的东西，那就算了，这里算我没搞懂了，留着这个问题，直接上代码吧，反正这两个
函数可以肯定是在scanf和printf里面调用的
/*
* 函数名：fputc
* 描述 ：重定向c库函数printf到USART1
* 输入 ：无
* 输出 ：无
* 调用 ：由printf调用
*/
int fputc(int ch, FILE *f)
{
/* 将Printf内容发往串口 */
USART_SendData(USART1, (unsigned char) ch);
while (!(USART1->SR & USART_FLAG_TXE));

return (ch);
}


int fgetc(FILE *f)
{
while(!(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET));

return (USART_ReceiveData(USART1));
}
我等着，大家有人能指出我的疑惑，因为VC的库函数都封装起来了，我在库函数里也没有找到fputc
的函数原型，只有等着有人能给我指出来，谢谢！