本文档详细记录了STM32嵌入式系统实践过程中的多个实例，包括LED灯控制、按键检测、LCD显示及TFT LCD图像显示等。通过具体代码示例介绍了直接寄存器操作和库函数调用两种方式实现的功能，并展示了如何结合硬件进行编程。
这里我会记录我接下来所使用过的所有代码，弄成一个一个函数、供自己以后复习、贴代码。
1、点亮LED灯（流水灯）
#include "stm32f10x.h"
void delay_ms(int t);
void LED_Init();
int i, j;
int main(void)
{
LED_Init();
while(1){
GPIOA->BSRR = 0x01000000; // 置 0
delay_ms(500);
GPIOA->BSRR = 0x00000100; // 置 1
GPIOD->BSRR = 0x00040000; // 置0
delay_ms(500);
GPIOD->BSRR = 0x00000004; // 置 1
}
}
void LED_Init()
{
RCC->APB2ENR|=1<<2; //开启PORTA时钟使能
RCC->APB2ENR|=1<<5; //开启PORTD时钟使能
GPIOA->CRH&=0xFFFFFFF0;
GPIOA->CRH|=0X00000003;//PA.8 通用推挽输出
GPIOA->BSRR=0x00000100; // PA.8 置1
GPIOD->CRL&=0xFFFFF0FF;
GPIOD->CRL|=0X00000300;//PD.2 通用推挽输出
GPIOD->BSRR=0x00000004; // PD.2 置1
}
void delay_ms(int t) // 啥也不干就是浪费时间
{
for(i = 0; i < t; i++){
for(j = 0; j < 1000; j++){
}
}
}
2、通过调用库函数实现LED流水灯
#include "stm32f10x.h"
void delay_ms(int t);
void LED_Init();
void RCC_Configuration(void);
int i, j;
int main(void)
{
LED_Init();
while(1){
GPIO_SetBits(GPIOA,GPIO_Pin_8); // PA.8
delay_ms(500);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
GPIO_SetBits(GPIOD,GPIO_Pin_2); // PD.2
delay_ms(500);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
}
}
void LED_Init()
{
GPIO_InitTypeDef GPIO_InitStructure; // 声明GPIO初始化结构变量
RCC_Configuration(); // 配置时钟
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // IO口配置为推挽输出口
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 频率为50HZ
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; // 配置管脚8
GPIO_Init(GPIOA, &GPIO_InitStructure); // 初始化PA8口
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; // 配置管脚2
GPIO_Init(GPIOD, &GPIO_InitStructure); // 初始化PD2口
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); // 使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE); // 使能GPIOD时钟
}
void delay_ms(int t) // for循环浪费时间的延时
{
for(i = 0; i < t; i++){
for(j = 0; j < 1000; j++){
}
}
}
3、实验内容（点一个键、一个灯闪烁两下，另一个灯闪烁一下，反之亦然）
#include "stm32f10x.h"
#define KEY_ON 0
#define KEY_OFF 1
void delay_ms(int t);
void Init();
void GPIO_Configuration(void);
uint8_t KeyScan( GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin_x );
int i, j;
char flag = 0;
int main(void)
{
Init();
while(1){
if(KeyScan( GPIOC, GPIO_Pin_5 ) == KEY_ON)// 按下 key0 时 （PC.5）
{
flag = 0;
}else if(KeyScan( GPIOA, GPIO_Pin_15 ) == KEY_ON) // 按下 key1时 （PA.15）
{
flag = 1;
}
if(flag)
{
GPIO_SetBits(GPIOA,GPIO_Pin_8); // PA.8 灭，
GPIO_ResetBits(GPIOD,GPIO_Pin_2); // PD.2 亮
delay_ms(500);
GPIO_SetBits(GPIOD,GPIO_Pin_2); // PD.2
delay_ms(500);
GPIO_ResetBits(GPIOD,GPIO_Pin_2); // PD.2
delay_ms(500);
GPIO_ResetBits(GPIOA,GPIO_Pin_8); // PA.8
GPIO_SetBits(GPIOD,GPIO_Pin_2); // PD.2
delay_ms(500);
}
else
{
GPIO_SetBits(GPIOD,GPIO_Pin_2); // PD.2
GPIO_ResetBits(GPIOA,GPIO_Pin_8); // PA.8
delay_ms(500);
GPIO_SetBits(GPIOA,GPIO_Pin_8); // PA.8
delay_ms(500);
GPIO_ResetBits(GPIOA,GPIO_Pin_8); // PA.8
delay_ms(500);
GPIO_ResetBits(GPIOD,GPIO_Pin_2); // PD.2
GPIO_SetBits(GPIOA,GPIO_Pin_8); // PA.8
delay_ms(500);
}
}
}
void Init()
{
GPIO_InitTypeDef GPIO_InitStructure; // 声明GPIO结构变量
GPIO_Configuration(); // 配置时钟，（下面的函数）
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // IO 推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 频率50HZ
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; // 配置管脚8
GPIO_Init(GPIOA, &GPIO_InitStructure); // 初始化PA8口
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; // 配置管脚2
GPIO_Init(GPIOD, &GPIO_InitStructure); // 初始化PD2口
GPIO_SetBits(GPIOA,GPIO_InitStructure.GPIO_Pin);
GPIO_SetBits(GPIOD,GPIO_InitStructure.GPIO_Pin); // 灯都关闭
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 浮空输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; // 配置管脚5
GPIO_Init(GPIOC, &GPIO_InitStructure); // 初始化PC.5口
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15; // 配置管脚15
GPIO_Init(GPIOA, &GPIO_InitStructure); // 初始化PA.15口
}
void GPIO_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); // 使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE); // 使能GPIOD时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE); // 使能GPIOC时钟
}
void delay_ms(int t) // for 循环延时
{
for(i = 0; i < t; i++){
for(j = 0; j < 1000; j++){
}
}
}
static void KeyDelay( uint32_t nCounter ) // 延时 函数
{
while ( nCounter-- );
}
uint8_t KeyScan( GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin_x )
{
if ( GPIO_ReadInputDataBit( GPIOx, GPIO_Pin_x ) == KEY_ON ) // 检测是否有按键按下
{
KeyDelay(0x57E40); // 延时消抖
if ( GPIO_ReadInputDataBit( GPIOx, GPIO_Pin_x ) == KEY_ON )
{
while ( GPIO_ReadInputDataBit( GPIOx, GPIO_Pin_x ) == KEY_ON ); // 等待按键释放
return KEY_ON;
}
else
{
return KEY_OFF;
}
}
return KEY_OFF;
}
4、3的通过寄存器控制完成（延时消抖没有添加）（感谢老师(╯﹏╰)）
#include "stm32f10x.h"
void delay_ms(int t);
void Init();
void GPIO_Configuration(void);
int i, j;
char flag = 0; // 标记
int main(void)
{
Init();
while(1){
if(~GPIOC->IDR & 1 << 5) // 按下 key1 (PA15)
{
flag = 0;
}else if(~GPIOA->IDR & 1 << 15) // 按下0 (PC5)
{
flag = 1;
}
if(flag)
{
GPIOA->BSRR = 0x01000000; // 置 0
delay_ms(500);
GPIOA->BSRR = 0x00000100; // 置 1
delay_ms(500);
GPIOA->BSRR = 0x01000000; // 置 0
delay_ms(500);
GPIOA->BSRR = 0x00000100; // 置 1
GPIOD->BSRR = 0x00040000; // 置 0
delay_ms(500);
GPIOD->BSRR = 0x00000004; // 置 1
}else
{
GPIOD->BSRR = 0x00040000; // 置 0
delay_ms(500);
GPIOD->BSRR = 0x00000004; // 置 1
delay_ms(500);
GPIOD->BSRR = 0x00040000; // 置 0
delay_ms(500);
GPIOD->BSRR = 0x00000004; // 置 1
GPIOA->BSRR = 0x01000000; // 置 0
delay_ms(500);
GPIOA->BSRR = 0x00000100; // 置 1
}
}
}
void Init()
{
RCC->APB2ENR|=1<<2; //使能PORTA时钟
RCC->APB2ENR|=1<<4; //使能PORTC时钟
RCC->APB2ENR|=1<<5; //使能PORTD时钟
GPIOA->CRH&=0xFFFFFFF0;
GPIOA->CRH|=0X00000003;//PA.8 推挽输出
GPIOA->BSRR=0x00000100; // PA.8 置1
GPIOD->CRL&=0xFFFFF0FF;
GPIOD->CRL|=0X00000300;//PD.2 推挽输出
GPIOD->BSRR=0x00000004; // PD.2 置1
GPIOC->CRL&=0XFFF0FFFF;
GPIOC->CRL|=0X00040000;//PC.5 浮空输入
GPIOA->CRH&=0x0FFFFFFF;
GPIOA->CRH|=0X40000000;//PA.15 浮空输入
}
void GPIO_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); // 使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE); // 使能GPIOD时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE); // 使能GPIOC时钟
}
void delay_ms(int t) // 延时
{
for(i = 0; i < t; i++){
for(j = 0; j < 1000; j++){
}
}
}
5、静态数码管：
#include"stm32f10x.h"
unsigned char LED7Code[] =
{~0x3F,~0x06,~0x5B,~0x4F,
~0x66,~0x6D,~0x7D,~0x07,
~0x7F,~0x6F,~0x77,~0x7C,
~0x39,~0x5E,~0x79,~0x71,
}; // 0 -> 9 只需要9个
u8 Count = 0;
void RCC_Configuration(void);
void delay_nms(u16 time);
int main(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_Configuration();
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 设置为推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 工作频率
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
GPIO_Init(GPIOB, &GPIO_InitStructure); // 给 GPIOB 赋予上述属性
GPIO_SetBits(GPIOB,GPIO_InitStructure.GPIO_Pin); // 打开这些管脚
while(1)
{
Count++;
GPIO_Write(GPIOB,LED7Code[Count%10]<<8); // 0 -> 9 循环
delay_nms(500);
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE); // 使能时钟、
}
void delay_nms(u16 time)
{
u16 i=0;
while(time--)
{
i=12000;
while(i--);
}
}6、动态数码管：(*^__^*) 谢谢大家的关注，
#include"stm32f10x.h"
#define LS138A GPIO_Pin_5 // 宏
#define LS138B GPIO_Pin_6
#define LS138C GPIO_Pin_7
#define LS138a(x) x ? GPIO_SetBits(GPIOB, LS138A):GPIO_ResetBits(GPIOB, LS138A) // x为1否？1 执行前面的，0，执行后面的
#define LS138b(x) x ? GPIO_SetBits(GPIOB, LS138B):GPIO_ResetBits(GPIOB, LS138B)
#define LS138c(x) x ? GPIO_SetBits(GPIOB, LS138C):GPIO_ResetBits(GPIOB, LS138C)
u8 Count;
u16 Count0;
unsigned long D[16], LedOut[8];
unsigned char Disp_Tab[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x40}; // 数码管显示、
void RCC_Configuration(void);
void GPIO_Configuration(void);
void delay_nms(u16 time);
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
while(1)
{
unsigned char i;
Count++;
if(Count==100)
{
Count0++;
Count=0;
}
D[1] = D[0] = Count0;
LedOut[0] = Disp_Tab[D[1]%10000/1000]; // 千
LedOut[1] = Disp_Tab[D[1]%1000/100]; // 百
LedOut[2] = Disp_Tab[D[1]%100/10]|0x80; // 十
LedOut[3] = Disp_Tab[D[1]%10]; // 个
LedOut[4] = Disp_Tab[D[0]%10000/1000]; // 千
LedOut[5] = Disp_Tab[D[0]%1000/100]; // 百
LedOut[6] = Disp_Tab[D[0]%100/10]|0x80; // 十
LedOut[7] = Disp_Tab[D[0]%10]; // 个
for(i=0; i<8; i++)
{
GPIO_Write(GPIOB, LedOut[i]<<8); // 位操作 <<8（低八位->高八位）
switch(i) // 1，3，8 译码器
{
case 0: LS138c(0); LS138b(0); LS138a(0); break; // 0 0 0
case 1: LS138c(0); LS138b(0); LS138a(1); break; // 1 0 0
case 2: LS138c(0); LS138b(1); LS138a(0); break; // 0 1 0
case 3: LS138c(0); LS138b(1); LS138a(1); break; // 1 1 0
case 4: LS138c(1); LS138b(0); LS138a(0); break; // 0 0 1
case 5: LS138c(1); LS138b(0); LS138a(1); break; // 1 0 1
case 6: LS138c(1); LS138b(1); LS138a(0); break; // 0 1 1
case 7: LS138c(1); LS138b(1); LS138a(1); break; // 1 1 1
}
delay_nms(1);
}
}
}
void RCC_Configuration(void)
{
SystemInit(); // 72HMHZ
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 使能GPIOB时钟
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
GPIO_Init(GPIOB,&GPIO_InitStructure); //给 GPIOB 赋予上述属性(8 -> 15）
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7; // 管脚5,,6,7
GPIO_Init(GPIOB,&GPIO_InitStructure); // 再次给GPIOB赋予上述属性(5,6,7)
GPIO_SetBits(GPIOB,GPIO_InitStructure.GPIO_Pin); // 置位
}
void delay_nms(u16 time)
{
u16 i=0;
while(time--)
{
i=1000;
while(i--);
}
}7、4*4矩阵键盘
#include "stm32f10x.h"
#define uchar unsigned char
#define uint unsigned int
int keyscan();
void delay_nms(u16 time);
void GPIO_Configuration(void);
unsigned char LED7Code[] = {~0x3F, ~0x06, ~0x5B, ~0x4F,
~0x66, ~0x6D, ~0x7D, ~0x07,
~0x7F, ~0x6F, ~0x77, ~0x7C,
~0x39, ~0x5E, ~0x79, ~0x71}; // 0 - F 的数码管显示
int x;
uchar temp;
uchar key;
u16 ReadedData;
int main(void)
{
GPIO_Configuration();
while(1)
{
x = keyscan();
if(x >= 0)
{
GPIO_Write(GPIOA, LED7Code[x] << 8);
}
}
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure; // 声明GPIO初始化结构变量、
// 使能APB2总线外设时钟、
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 开启PB时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); // 开启PA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // 开启复用IO时钟
// ↓ PB3和PB4被用在JTAG接口中，把这两个管脚释放出来，作为普通IO口
GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);
GPIO_InitStructure.GPIO_Pin =
GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 |
GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 输出模式下 i/0输出的速度
GPIO_Init(GPIOA, &GPIO_InitStructure); // PA口初始化
GPIO_Write(GPIOA, LED7Code[8] << 8); // 七段数码管全部点亮、
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 |
GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // I/O口输出速度
GPIO_Init(GPIOB, &GPIO_InitStructure); // PB口初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 |
GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // 上拉输入
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
int keyscan()
{
temp = 0;
GPIO_Write(GPIOB, 0xFFF0); // PB3-PB0 输出低电平
if((GPIOB->IDR & 0x00F0) == 0x00F0) // PB7-PB4全为1，表明没有按键按下，返回-1
{
return -1;
}
else
{
delay_nms(5); // 延时去抖
if((GPIOB->IDR & 0x00F0) == 0x00F0) // 抖动产生的、
{
return -1;
}
}
GPIO_Write(GPIOB, 0xFFFE); // PB3 = PB2 = PB1 = 1、PB0 = 0
temp = ~(GPIOB->IDR | 0xFF0F);
switch(temp) // 对PB7-PB4的值进行判断，
{
case 0x0010 : key = 0; break;
case 0x0020 : key = 1; break;
case 0x0040 : key = 2; break;
case 0x0080 : key = 3; break;
}
GPIO_Write(GPIOB, 0xFFFD); // PB2 = 0，PB0 = PB1 = PB3 = 1
temp = ~(GPIOB->IDR | 0xFF0F);
switch(temp) // 对PB7-PB4的值进行判断，
{
case 0x0010 : key = 4; break;
case 0x0020 : key = 5; break;
case 0x0040 : key = 6; break;
case 0x0080 : key = 7; break;
}
GPIO_Write(GPIOB, 0xFFFB); // PB3 = PB 1 = PB0 = 1, PB2 = 0
temp = ~(GPIOB->IDR | 0xFF0F);
switch(temp)
{
case 0x0010 : key = 8; break;
case 0x0020 : key = 9; break;
case 0x0040 : key = 10; break;
case 0x0080 : key = 11; break;
}
GPIO_Write(GPIOB, 0xFFF7); // PB3 = 0, PB2 = PB1 = PB0 = 1,
temp = ~(GPIOB->IDR | 0xFF0F);
switch(temp)
{
case 0x0010 : key = 12; break;
case 0x0020 : key = 13; break;
case 0x0040 : key = 14; break;
case 0x0080 : key = 15; break;
}
return key;
}
void delay_nms(u16 time)
{
u16 i = 0;
while(time--)
{
i = 12000;
while(i--);
}
}
8、lcd显示
lcd_1602.h
/* LCD1602.h*/
#ifndef __LCD1602_H
#define __LCD1602_H
#define uchar unsigned char
#define uint unsigned int
#define uint unsigned int
void delay(uint a); //延时函数，空循环函数
void delay_ms(uint time); //毫秒级延时
void delay_us(uint time); //微秒级延时
void enable(uchar del); //使能LCD，按时序的底层驱动
void write(uchar del); //写LCD，按时序的底层驱动
void L1602_init(void); //1602初始化
void L1602_char(uchar row, uchar column,char sign); //按行列位置写字符
void L1602_string(uchar row, uchar column,char *p); //从行列位置写字符串
void L1602_Clear(void); //清屏
void L1602_DispNum(uchar row, uchar column, uint num);
void L1602_DispFloatNum(uchar row, uchar column, double num);
#endiflcd.c代码：
#include "stm32f10x.h"
#include "lcd_1602.h"
void RCC_Configuration(void);
void Port_Init(void);
int main(void)
{
RCC_Configuration();
GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE); //禁用SDJ和JTAG，释放口线用作IO输出
Port_Init();
L1602_init();
while (1)
{
L1602_Clear();
L1602_string(1,1,"Hello, World!");
L1602_string(2,1,"I can do that ");
delay(1000);
L1602_Clear();
L1602_string(1,1,"Integer：");
L1602_DispNum(2,1,100); //显示整数数字
L1602_string(2,5,"V.");
delay(1000);
L1602_Clear();
L1602_string(1,1,"Float：");
L1602_DispFloatNum(2,1,123.898); //显示浮点数
L1602_string(2,8,"V.");
delay(1000);
}
}
void RCC_Configuration(void) //配置系统时钟
{
SystemInit();//72MHz
//下面给各模块开启时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|
RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
//TIM2时钟使能
RCC_APB2PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
}
void Port_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure; //声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2; // 管脚PB0、1、2
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //推挽输出
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|
GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|
GPIO_Pin_14|GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStructure);
delay(100);
}
lcd_1602.c：
#include "lcd_1602.h"
#include "stm32f10x_gpio.h"
#include "stdio.h"
#define lcm_ce_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_0) // E-----LCD-Pin6 -----STM32-PB0
#define lcm_ce_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_0)
#define lcm_rst_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_1) // RS----LCD-Pin4-----STM32-PB1
#define lcm_rst_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_1)
#define lcm_wr_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_2) // WR----LCD-Pin5-----STM32-PB2
#define lcm_wr_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_2)
#define DATA_0_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_8) //置0
#define DATA_0_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_8) // 置1
#define DATA_1_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_9)
#define DATA_1_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_9)
#define DATA_2_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_10)
#define DATA_2_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_10)
#define DATA_3_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_11)
#define DATA_3_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_11)
#define DATA_4_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_12)
#define DATA_4_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_12)
#define DATA_5_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_13)
#define DATA_5_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_13)
#define DATA_6_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_14)
#define DATA_6_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_14)
#define DATA_7_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_15)
#define DATA_7_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_15)
void DATA(unsigned int d)
{
if (d&0x01) {DATA_0_HIGH();} else {DATA_0_LOW();}
if (d&0x02) {DATA_1_HIGH();} else {DATA_1_LOW();}
if (d&0x04) {DATA_2_HIGH();} else {DATA_2_LOW();}
if (d&0x08) {DATA_3_HIGH();} else {DATA_3_LOW();}
if (d&0x10) {DATA_4_HIGH();} else {DATA_4_LOW();}
if (d&0x20) {DATA_5_HIGH();} else {DATA_5_LOW();}
if (d&0x40) {DATA_6_HIGH();} else {DATA_6_LOW();}
if (d&0x80) {DATA_7_HIGH();} else {DATA_7_LOW();}
}
void E(unsigned char i) //使能LCD
{
if(i) {lcm_ce_HIGH();} else {lcm_ce_LOW();}
}
void RS(unsigned char i) // 开 RS（0关，!0开）
{
if(i) {lcm_rst_HIGH();} else {lcm_rst_LOW();}
}
void RW(unsigned char i) // 开RW（0关，!0开）
{
if(i) {lcm_wr_HIGH();} else {lcm_wr_LOW();}
}
void delay(uint a)
{
u16 i=0;
while(a--)
{ i=12000;
while(i--) ;
}
}
void delay_us(uint time)
{ u16 i=0;
while(time--)
{ i=10;
while(i--) ;
}
}
void delay_ms(uint time)
{ u16 i=0;
while(time--)
{ i=12000;
while(i--) ;
}
}
void enable(uchar del)
{
DATA(del);
RS(0);
RW(0);
E(0);
delay_ms(10);
E(1);
delay_ms(10);
E(0);
}
void write(uchar del)
{
DATA(del);
RS(1);
RW(0);
E(0);
delay_ms(10);
E(1);
delay_ms(10);
E(0);
}
void L1602_init(void)//1602???,
{
delay_ms(10);
enable(0x38);
delay_ms(10);
enable(0x06);
delay_ms(10);
enable(0x0C);
delay_ms(10);
enable(0x01);
delay_ms(10);
}
void L1602_Clear(void) //1602清屏,
{
delay_ms(10);
enable(0x01);
delay_ms(10);
}
void L1602_char(uchar row, uchar column,char sign)
{
uchar a;
if (row==1) a=0x80;
if (row==2) a=0xc0;
a = a + column - 1;
enable(a);
write(sign);
}
void L1602_string(uchar row, uchar column,char *p)
{
uchar a;
if (row==1) a=0x80;
if (row==2) a=0xc0;
a = a + column - 1;
enable(a);
while(*p!='\0')
{
write(*p);
p++;
}
/*while(1)
{
if (*p==';') break;
write(*p);
p++;
}*/
}
void L1602_DispNum(uchar row, uchar column, uint num)
{
/*
uint i=0,j,k=0,wei,q;
char str[32];
if(num>=10000000)wei=8;
else if(num>=1000000)wei=7;
else if(num>=100000)wei=6;
else if(num>=10000)wei=5;
else if(num>=1000) wei=4;
else if(num>=100)wei=3;
else if(num>=10) wei=2;
else wei=1;
for(i=wei;i>0;i--)
{
q=1;
j=1;
for(;j<i;j++)
{
q *=10; //10*q
}
str[k++]=num/q +'0';
num %= q;
}
str[k] = '\0';
*/
char str[32];
sprintf(str,"%d", num ); // num中存储数据的格式化写入str中
L1602_string(row, column, str); // 在lcd的row行，column列写入str
}
void L1602_DispFloatNum(uchar row, uchar column, double num)
{
char str[32];
sprintf(str,"%.2f", num ); // num中存储的数据格式化写入str中
L1602_string(row, column, str); // 在lcd显示屏的row行，colunm列写str
}
9、LCD结合矩阵键盘输入
lcd_1602.h
/* LCD1602.h*/
#ifndef __LCD1602_H
#define __LCD1602_H
#define uchar unsigned char
#define uint unsigned int
#define uint unsigned int
keyboard.h
int keyscan(void);
void delay_nms(u16 time);
void GPIO_Configuration(void);keyboard.c
#include "stm32f10x.h"
#define uchar unsigned char
#define uint unsigned int
int keyscan();
void delay_nms(u16 time);
void GPIO_Configuration(void);
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure; // 声明GPIO初始化结构变量
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 开启PB时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); // 开始PB时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // 开启复用IO时钟
// ↓ PB3，PB4被用在JTAG接口中，把这两个管脚释放出来，作为普通的IO口
GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 |
GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure); // PA口初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 |
GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // 上拉输入
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
int keyscan(void)
{
uchar temp;
uchar key;
temp = 0;
GPIO_Write(GPIOA, 0xFFF0); // PB3-PB0 输出低电平
if((GPIOA->IDR & 0x00F0) == 0x00F0) // PB7-PB4全为1,没有按键按下
{
return -1;
}
else
{
delay_nms(5); // 延时去抖
if((GPIOA->IDR & 0x00F0) == 0x00F0) // 抖动产生
{
return -1;
}
}
GPIO_Write(GPIOA, 0xFFFE); // PB3 = PB2 = PB1 = 1?PB0 = 0
temp = ~(GPIOA->IDR | 0xFF0F);
switch(temp) // 对PB7-PB4的值进行判断,
{
case 0x0010 : key = 0; break;
case 0x0020 : key = 1; break;
case 0x0040 : key = 2; break;
case 0x0080 : key = 3; break;
}
GPIO_Write(GPIOA, 0xFFFD); // PB2 = 0,PB0 = PB1 = PB3 = 1
temp = ~(GPIOA->IDR | 0xFF0F);
switch(temp)
{
case 0x0010 : key = 4; break;
case 0x0020 : key = 5; break;
case 0x0040 : key = 6; break;
case 0x0080 : key = 7; break;
}
GPIO_Write(GPIOA, 0xFFFB); // PB3 = PB 1 = PB0 = 1, PB2 = 0
temp = ~(GPIOA->IDR | 0xFF0F);
switch(temp)
{
case 0x0010 : key = 8; break;
case 0x0020 : key = 9; break;
case 0x0040 : key = 10; break;
case 0x0080 : key = 11; break;
}
GPIO_Write(GPIOA, 0xFFF7); // PB3 = 0, PB2 = PB1 = PB0 = 1,
temp = ~(GPIOA->IDR | 0xFF0F);
switch(temp)
{
case 0x0010 : key = 12; break;
case 0x0020 : key = 13; break;
case 0x0040 : key = 14; break;
case 0x0080 : key = 15; break;
}
return key;
}
void delay_nms(u16 time)
{
u16 i = 0;
while(time--)
{
i = 12000;
while(i--);
}
}
lcd_1602.c
#include "lcd_1602.h"
#include "stm32f10x_gpio.h"
#include "stdio.h"
#define lcm_ce_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_0) // E-----LCD-Pin6 -----STM32-PB0
#define lcm_ce_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_0)
#define lcm_rst_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_1) // RS----LCD-Pin4-----STM32-PB1
#define lcm_rst_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_1)
#define lcm_wr_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_2) // WR----LCD-Pin5-----STM32-PB2
#define lcm_wr_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_2)
#define DATA_0_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_8) //复位总线第0位
#define DATA_0_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_8) // 置数据总线第0位
#define DATA_1_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_9)
#define DATA_1_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_9)
#define DATA_2_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_10)
#define DATA_2_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_10)
#define DATA_3_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_11)
#define DATA_3_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_11)
#define DATA_4_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_12)
#define DATA_4_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_12)
#define DATA_5_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_13)
#define DATA_5_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_13)
#define DATA_6_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_14)
#define DATA_6_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_14)
#define DATA_7_LOW() GPIO_ResetBits(GPIOB, GPIO_Pin_15)
#define DATA_7_HIGH() GPIO_SetBits(GPIOB, GPIO_Pin_15)
void DATA(unsigned int d) // 根据数据d的8位二进制来确定对数据总线上哪一位置位或清零
{
if (d&0x01) {DATA_0_HIGH();} else {DATA_0_LOW();}
if (d&0x02) {DATA_1_HIGH();} else {DATA_1_LOW();}
if (d&0x04) {DATA_2_HIGH();} else {DATA_2_LOW();}
if (d&0x08) {DATA_3_HIGH();} else {DATA_3_LOW();}
if (d&0x10) {DATA_4_HIGH();} else {DATA_4_LOW();}
if (d&0x20) {DATA_5_HIGH();} else {DATA_5_LOW();}
if (d&0x40) {DATA_6_HIGH();} else {DATA_6_LOW();}
if (d&0x80) {DATA_7_HIGH();} else {DATA_7_LOW();}
}
void E(unsigned char i) //使能LCD
{
if(i) {lcm_ce_HIGH();} else {lcm_ce_LOW();}
}
void RS(unsigned char i) // 根据参数i，确定是置位RS，还是清零RS
{
if(i) {lcm_rst_HIGH();} else {lcm_rst_LOW();}
}
void RW(unsigned char i) // 根据参数i，确定是置位RW，还是清零RW
{
if(i) {lcm_wr_HIGH();} else {lcm_wr_LOW();}
}
void delay(uint a)
{
u16 i=0;
while(a--)
{ i=12000;
while(i--) ;
}
}
void delay_us(uint time)
{ u16 i=0;
while(time--)
{ i=10;
while(i--) ;
}
}
void delay_ms(uint time)
{ u16 i=0;
while(time--)
{ i=12000;
while(i--) ;
}
}
void enable(uchar del) // 1602命令函数，输入的命令值，根据时序来使能LCD
{
DATA(del); // 根据命令集，按照时序来使能LCD
RS(0); // RS = 0，选择写指令寄存器， RS = 1 选择写数据寄存器
RW(0); // RW = 0， 进行写操作， RW = 1 进行读操作
E(0); // E 使能位
delay_ms(10);
E(1); // 使能
delay_ms(10);
E(0);
}
void write(uchar del) // 1602写数据函数，输入的是需要写入1602的数据
{
DATA(del);
RS(1);
RW(0);
E(0);
delay_ms(10);
E(1);
delay_ms(10);
E(0);
}
void L1602_init(void) //1602初始化
{
delay_ms(10);
enable(0x38); // 设置16 * 2显示， 5 * 7点阵，8位数据接口
delay_ms(10);
enable(0x06); // 地址+1，当写入数据，光标右移
delay_ms(10);
enable(0x0C); // 开显示，不显示光标
delay_ms(10);
enable(0x01); // 清屏
delay_ms(10);
}
void L1602_Clear(void) //1602清屏,
{
delay_ms(10);
enable(0x01); // 清屏
delay_ms(10);
}
void L1602_char(uchar row, uchar column,char sign) // 按行列位置写字符
{
uchar a;
if (row==1) a=0x80; // 在第一行显示
if (row==2) a=0xc0; // 在第二行显示
a = a + column - 1; // 计算要显示字符的位置
enable(a);
write(sign); // 写字符sign
}
void L1602_string(uchar row, uchar column,char *p) // 从行列位置写字符串
{
uchar a;
if (row==1) a=0x80; // 在第一行显示
if (row==2) a=0xc0; // 在第二行显示
a = a + column - 1; // 计算要显示字符串的位置
enable(a);
while(*p!='\0') // 一直写（没有到末尾）
{
write(*p); // 写进去（字符）
p++;
}
/*while(1)
{
if (*p==';') break;
write(*p);
p++;
}*/
}
void L1602_DispNum(uchar row, uchar column, uint num) // 写入整数
{
char str[32];
sprintf(str,"%d", num ); // 将 num（整数），转化为字符串
L1602_string(row, column, str); // 写
}
void L1602_DispFloatNum(uchar row, uchar column, double num) // 写入浮点数
{
char str[32];
sprintf(str,"%.2f", num ); // 将浮点数转化为字符串（保留两位小数）
L1602_string(row, column, str); // 写
}
lcd.c
#include "stm32f10x.h"
#include "lcd_1602.h"
#include "keyboard.h"
void RCC_Configuration(void);
void Port_Init(void);
int x;
uchar temp;
uchar key;
u16 ReadedData;
int main(void)
{
GPIO_Configuration();
RCC_Configuration();
GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE);//禁用SDJ和JTAG,释放口线用作IO输出
Port_Init();
L1602_init();
while (1)
{
L1602_Clear();
L1602_string(1,1,"input is Integer！"); //先显示一行，（提示输入）
x = keyscan(); // 获取输入的信息
if(x == -1) // 没有输入就等待
{
while(x == -1)
{
x = keyscan();
}
}
L1602_DispNum(2,1,x); //将得到的x写入
L1602_string(2,5,"xixi");
delay(1000);
L1602_Clear();
}
}
void RCC_Configuration(void) //配置系统时钟
{
SystemInit();//72MHz
//开启各时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
//TIM2时钟使能
RCC_APB2PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
}
void Port_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构体变量
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStructure); // 初始化管脚
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8|GPIO_Pin_9|
GPIO_Pin_10|GPIO_Pin_11|
GPIO_Pin_12|GPIO_Pin_13|
GPIO_Pin_14|GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStructure);
delay(100);
}连线：
10、TFT LCD实验（显示图片）
image2lcd.c
#include "sys.h"
#include "lcd.h"
#include "image2lcd.h"
//从8位数据获得16位颜色
//mode:0,低位在前,高位在后.
// 1,高位在前,低位在后.
//str:数据
u16 image_getcolor(u8 mode,u8 *str)
{
u16 color;
if(mode)
{
color=((u16)*str++)<<8;
color|=*str;
}else
{
color=*str++;
color|=((u16)*str)<<8;
}
return color;
}
//在液晶上画图
//xsta,ysta,xend,yend:画图区域
//scan:见image2lcd V2.9的说明.
//*p:图像数据
void image_show(u16 xsta,u16 ysta,u16 xend,u16 yend,u8 scan,u8 *p)
{
u32 i;
u32 len=0;
LCD_Set_Window(xsta,ysta,xend,yend);
if((scan&0x03)==0)//水平扫描
{
switch(scan>>6)//设置扫描方式
{
case 0:
LCD_Scan_Dir(L2R_U2D);//从左到右,从上到下
LCD_SetCursor(xsta,ysta);//设置光标位置
break;
case 1:
LCD_Scan_Dir(L2R_D2U);//从左到右,从下到上
LCD_SetCursor(xsta,yend);//设置光标位置
break;
case 2:
LCD_Scan_Dir(R2L_U2D);//从右到左,从上到下
LCD_SetCursor(xend,ysta);//设置光标位置
break;
case 3:
LCD_Scan_Dir(R2L_D2U);//从右到左,从下到上
LCD_SetCursor(xend,yend);//设置光标位置
break;
}
}else //垂直扫描
{
switch(scan>>6)//设置扫描方式
{
case 0:
LCD_Scan_Dir(U2D_L2R);//从上到下,从左到右
LCD_SetCursor(xsta,ysta);//设置光标位置
break;
case 1:
LCD_Scan_Dir(D2U_L2R);//从下到上从,左到右
LCD_SetCursor(xsta,yend);//设置光标位置
break;
case 2:
LCD_Scan_Dir(U2D_R2L);//从上到下,从右到左
LCD_SetCursor(xend,ysta);//设置光标位置
break;
case 3:
LCD_Scan_Dir(D2U_R2L);//从下到上,从右到左
LCD_SetCursor(xend,yend);//设置光标位置
break;
}
}
LCD_WriteRAM_Prepare(); //开始写入GRAM
len=(xend-xsta+1)*(yend-ysta+1); //写入的数据长度
for(i=0;i<len;i++)
{
LCD_WR_DATA(image_getcolor(scan&(1<<4),p));
p+=2;
}
#if USE_HORIZONTAL //使用横屏
LCD_Set_Window(0,0,319,239);
#else
LCD_Set_Window(0,0,239,319);
#endif
}
//在指定的位置显示一个图片
//此函数可以显示image2lcd软件生成的任意16位真彩色图片.
//限制:1,尺寸不能超过屏幕的区域.
// 2,生成数据时不能勾选:高位在前(MSB First)
// 3,必须包含图片信息头数据
//x,y:指定位置
//imgx:图片数据(必须包含图片信息头,"4096色/16位真彩色/18位真彩色/24位真彩色/32位真彩色”的图像数据头)
//注意:针对STM32,不能选择image2lcd的"高位在前(MSB First)"选项,否则imginfo的数据将不正确!!
void image_display(u16 x,u16 y,u8 * imgx)
{
HEADCOLOR *imginfo;
u8 ifosize=sizeof(HEADCOLOR);//得到HEADCOLOR结构体的大小
imginfo=(HEADCOLOR*)imgx;
image_show(x,y,x+imginfo->w-1,y+imginfo->h-1,imginfo->scan,imgx+ifosize);
}
main.c
#include "stm32f10x.h"
#include "delay.h"
#include "image2lcd.h"
#include "sys.h"
#include "usart.h"
#include "lcd.h"
#include "led.h"
extern const u8 gImage_zz[];//图片数据(包含信息头),存储在image1.c里面. 需要用Image2Lcd去处理成c语言模式
int main(void)
{
delay_init(); //延时函数初始化
uart_init(9600); //串口初始化为9600
LED_Init(); //初始化与LED连接的硬件接口
LCD_Init();
HEADCOLOR *imginfo;
u16 x=0,y=0;
imginfo=(HEADCOLOR*)gImage_zz; //得到文件信息
POINT_COLOR=RED;
delay_ms(1500);//等待1.5秒
srand(imginfo->h*imginfo->w);
while(1)
{
image_display(x,y,(u8*)gImage_zz);//在指定地址显示图片
LCD_ShowString(130,280,240,12,12,"By QLU_fuchen");
delay_ms(200);
}
}
对于剩下的代码嘛，导入来导入去的，去正点原子的资料里面找吧 （The code comes from 原子哥）
11、中断（把代码贴贴，以后粘贴过去修改）
#include "stm32f10x.h"
char flag = 0;
void RCC_Configuration(void);
void GPIO_Configuration(void);
void EXTI_Configuration(void);
void NVIC_Configuration(void);
void delay_nms(u16 time);
int main(void)
{
RCC_Configuration(); // 时钟
GPIO_Configuration(); // GPIO
EXTI_Configuration(); // 外部中断
NVIC_Configuration(); // 向量中断控制器
while(1)
{
if (flag)
{
GPIO_SetBits(GPIOA,GPIO_Pin_8);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
GPIO_SetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
GPIO_SetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
}else{
GPIO_SetBits(GPIOA,GPIO_Pin_8);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
GPIO_ResetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
delay_nms(500);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
GPIO_SetBits(GPIOA,GPIO_Pin_8);
delay_nms(500);
}
}
}
void RCC_Configuration(void) // 配置时钟
{
SystemInit(); //72MHz
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); // 使能AFIO时钟
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //关掉JTAG，不关SW
// STM32中PA13、PA14、PA15、PB03PB04是默认的FTAG引脚映射
// 释放PA15 (PA15默认为JTAG功能，这里为了使用PA15需要首先释放口线)
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOD,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU; // 上拉输入
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU ;
GPIO_Init(GPIOC,&GPIO_InitStructure);
GPIO_SetBits(GPIOA,GPIO_Pin_8);
GPIO_SetBits(GPIOD,GPIO_Pin_2);
}
void EXTI_Configuration(void) // 配置外部中断源
{
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line=EXTI_Line15|EXTI_Line5; // 外部中短线Line12 | Line5
EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt; //选择中断模式
EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling; //下降沿触发
EXTI_InitStructure.EXTI_LineCmd=ENABLE; //使能中断
EXTI_Init(&EXTI_InitStructure); // 初始化外部中断
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource15); //PA15配置为外部中断源（本质利用AFIO_EXTICR寄存器）
GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource5); //PC5配置为外部中断源(本质利用AFIO_EXTICR寄存器)
}
void NVIC_Configuration(void) // 嵌套向量中断初始化
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // 中断优先级分组
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn; // EXTI9_5中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先优先级设定，取值为0-1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //从优先级设定、取值0-7
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn; //EXTI9_5中断源
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占先优先设计定，取值为0-1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //从优先级设计定，取值为0-7
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void EXTI9_5_IRQHandler(void) // 外部中断源9_5中断子程序
{
if(EXTI_GetITStatus(EXTI_Line5) != RESET)
{
flag=1;
EXTI_ClearFlag(EXTI_Line5);
}
}
void EXTI15_10_IRQHandler(void) // 外部中断源15_10中断子程序
{
if (EXTI_GetITStatus(EXTI_Line15)!=RESET)
{
flag=0;
EXTI_ClearFlag(EXTI_Line15);
}
}
void delay_nms(u16 time) //延时
{
u16 i=0;
while(time--)
{
i = 4000;
while(i--);
}
}
12、USART（串口通信）
/*
基本的USART代码
通过USART1发送数据、PC机上运行串口调试助手软件接收字符
如果串口没有显示正确的输出，检查Target/Code Generation中的Use MicroLIB项是否被选中
*/
#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>
#define RxBufferSize 10
void RCC_Configuration(void);
void GPIO_Configuration(void);
void USART_Configuration(void);
void NVIC_Configuration(void);
int fputc(int ch, FILE *f);/*重定向，修改一下选中Use MicroLIB ,
需要在 Target/Code Generation??Use MicroLIB
才能使用printf */
void delay_nms(u16 time);//延时子程序
unsigned char RxBuffer[RxBufferSize];
unsigned char CmdBuffer[RxBufferSize];
unsigned char Rx_Flag = 0;
unsigned char RxCounter=0;
u16 i;
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
USART_Configuration();
NVIC_Configuration();
USART_ClearFlag(USART1,USART_FLAG_TC);// 清发送结束位
USART_SendData(USART1, 'A'); // 向发送数据寄存器写一个字节
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'B');
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
printf("\r\n");
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
printf("zzzz\n");
printf("打开LED灯,请输入 ON!\n");
printf("关闭LED灯,请输入 OFF!\n");
printf("输入错误的话,LED闪烁10次!\n");
GPIO_SetBits(GPIOA,GPIO_Pin_8);//PA8置位,LED1灯灭
memset(CmdBuffer,10,0);
while(1)
{
if (Rx_Flag == 1)
{
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //关闭接收中断
Rx_Flag = 0;
RxCounter=0;
if(strstr(CmdBuffer,"OFF"))
{
GPIO_SetBits(GPIOA,GPIO_Pin_8);//PA8置位,LED1灯灭
memset(CmdBuffer,10,0);
}
else if(strstr(CmdBuffer,"ON"))
{
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
memset(CmdBuffer,10,0);
}
else
{
memset(CmdBuffer,10,0);
for (i=0;i<10;i++)
{
GPIO_ResetBits(GPIOA,GPIO_Pin_8);//PA8清零,LED1灯亮
delay_nms(200);
GPIO_SetBits(GPIOA,GPIO_Pin_8);//PA8置位,LED1灯灭
delay_nms(200);
}
}
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE = 1)时产生中断
}
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1的时钟
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA10
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8; //配置管脚8
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //IO口配置为推挽输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //工作频率50MHz
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA8口
}
void NVIC_Configuration(void) //NVIC配置
{
//配置NVIC的优先级
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //优先级分组1(0:4, 0位抢占优先级、4位子优先级?
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //设置串口1 中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级 0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级位0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 串口中断使能
NVIC_Init(&NVIC_InitStructure);
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
//USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
int fputc(int ch,FILE *f)
{
if(ch=='\n')
{
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'\r');
}
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET)
;
USART_SendData(USART1,ch);
return ch;
}
void delay_nms(u16 time)//延时子程序
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
void USART1_IRQHandler(void) //串口1 中断服务程序
{
unsigned int i=0;
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //判断接收寄存器是否为空
{
//如果接收寄存器非空，说明检测到中断读入
RxBuffer[RxCounter++] = USART_ReceiveData(USART1); // Read one byte from the receive data register
if (RxBuffer[RxCounter-1]=='\n') //如果检测到换行，则设置接收标志位为1
// \n:换行，光标到下行行首
// \r:回车，光标到本行行首
{
Rx_Flag=1;
for (i=0;i<RxCounter;i++)//把接收的数据缓存到CmdBuffer中
{
CmdBuffer[i]=RxBuffer[i];
}
CmdBuffer[RxCounter]=0; //发送缓冲区结束符
RxCounter=0;
}
if(RxCounter == RxBufferSize) //如菇邮整缓冲区满了
{
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //关闭接收中断
Rx_Flag=1;
CmdBuffer[RxCounter]=0; //接收命令缓冲区结束符
RxCounter=0;
}
}
}USART转发
/*
PA9->USARTI_TX
PA10->USART1_RX
利用USART的中断进行接收和发送数据
用到了串口助手
ps：注意晶振的频率
*/
#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>
#define TxBufferSize (countof(TxBuffer) - 1) //定义UART1的发送缓冲器的字节数
#define RxBufferSize 0x51 //定义USART1的接收缓冲器的字节数
#define countof(a) (sizeof(a) / sizeof(*(a)))
u8 TxBuffer[] = "Stm32.USART->Computer. Developed by Ph.D. A. Dong, Qilu Univerity of Technology.\r\n" ;
u8 RxBuffer[RxBufferSize];
u8 NbrOfDataToTransfer = TxBufferSize;
u8 NbrOfDataToRead = RxBufferSize;
u8 TxCounter = 0;
u16 RxCounter = 0;
u8 Tx_Flag=0;
u8 Rx_Flag=0;
void RCC_Configuration(void); //时钟配置
void GPIO_Configuration(void); //GOPO配置
void USART_Configuration(void);//USART配置
void NVIC_Configuration(void);//NVIC配置
void delay_nms(u16 time);//延时子程序
unsigned int i;
int main(void)
{
RCC_Configuration(); //配置时钟
NVIC_Configuration();//配置NVIC
GPIO_Configuration(); //配置GPIO
USART_Configuration();//配置USART
while(1)
{
USART_ClearFlag(USART1,USART_FLAG_TC);//清发送结束位
USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送
delay_nms(2000);
if(Rx_Flag==1) //如果接收到的一组以换行结束的数据，则将接收到的数据在发送出去
{
//判断是否接收到一帧有效数据
Rx_Flag=0;
for(i=0; i< NbrOfDataToRead; i++) TxBuffer[i] = 0;
// TxBuffer[0]='\n';
// TxBuffer[1]='\r';
for(i=0; i< RxCounter; i++) TxBuffer[i] = RxBuffer[i];
//TxBuffer[RxCounter]='\r';
//TxBuffer[RxCounter+1]='\n';
//TxBuffer[RxCounter+2]='\r';
//将接收缓冲器的数据转到发送缓冲区，并在缓冲区头上加上换行符，准备转发
RxCounter=0;
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
USART_ITConfig(USART1, USART_IT_TXE, ENABLE); //开启发送中断
delay_nms(2000);
}
}
}
void RCC_Configuration(void) // 时钟配置子程序
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1的时钟, USART1挂接到APB2上。其他USART2-5挂接到APB!上
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); // 使能AFIO的时钟，串口属于复用功能
}
void GPIO_Configuration(void) // GPIO配置
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA10
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9
}
void NVIC_Configuration(void) //NVIC配置
{
//配置NVIC相应的优先级位
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //优先级分组1（1：3，1位抢占优先级、3位子优先级）
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //设置串口1中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级 0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 子优先级为0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 串口中断使能
NVIC_Init(&NVIC_InitStructure);
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
void delay_nms(u16 time)//延时子程序
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
void USART1_IRQHandler(void) //串口1 中断服务程序
{
unsigned int i=0;
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //判断接收寄存器是否非空
{
//当检测到中断读入
RxBuffer[RxCounter++] = USART_ReceiveData(USART1); // Read one byte from the receive data register
if (RxBuffer[RxCounter-1]=='\n') //如果检测到换行，则设置接收标志位1
// \n:换行，光标到下行行首
// \r:回车，光标到本行行首
{
Rx_Flag=1;
TxBuffer[RxCounter]=0; //发送缓冲区结束符
}
if(RxCounter == NbrOfDataToRead) //如果接收缓冲区满了
{
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); //关闭接收中断
Rx_Flag=1;
TxBuffer[RxCounter]=0; //发送缓冲区结束符
}
}
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
{
//当检测到发送中断
USART_SendData(USART1, TxBuffer[TxCounter++]); //向发送数据寄存器写一个字节
if(TxCounter == NbrOfDataToTransfer)
{
TxCounter=0;
USART_ITConfig(USART1, USART_IT_TXE, DISABLE); /* Disable the USART1 Transmit interrupt */
}
}
}13、DMA实例
（1）存储器至存储器传输
#include "stm32f10x.h"
#include <stdio.h>
void RCC_Configuration(void);
void GPIO_Configuration(void);
void DMA_Configuration(void);
void USART_Configuration(void);
int fputc(int ch, FILE *f);//重定向
void delay_nms(u16 time);
uint8_t SrcBuf[10]="Hello DMA";
uint8_t DstBuf[10]="DMA Hello";
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
USART_Configuration();
DMA_Configuration();
USART_ClearFlag(USART1,USART_FLAG_TC);//清发送结束位
// USART_SendData(USART1, 'A'); //向发送数据寄存器写一个字节
// while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
// USART_SendData(USART1,'B');
printf("Before the DMA transfer:\n");
printf("DstBuf: %s\n",DstBuf);
DMA_Cmd(DMA1_Channel1,ENABLE);
printf("After the DMA transfer:\n");
printf("DstBuf: %s\n",DstBuf);
while(1)
{
GPIO_SetBits(GPIOA,GPIO_Pin_8);
delay_nms(200);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
delay_nms(200);
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1的时钟, USART1挂接到APB2上
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA10
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8; //配置管脚8
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //IO口配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //工作频率50MHz
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA8口
}
void DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
/* DMA channel1 configuration */
DMA_DeInit(DMA1_Channel1);//重置DMA的寄存器的值，配置为缺省值
DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)SrcBuf;/*设置DMA外设基地址，即源数据存储区的首地址*/
DMA_InitStructure.DMA_MemoryBaseAddr =(u32)DstBuf;/*定义内存基地址*/
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;/*设置数据传输方向，从外设读取数据*/
// DMA_DIR_PeripheralSRC // 两种传输方向的设置
// DMA_DIR_PeripheralDST
DMA_InitStructure.DMA_BufferSize = 10;/*指定DMA通道，DMA缓存的大小*/
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;/*设置外设数据指针调整模数，地址指针自动增加*/
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工作正常模式，即按照指定的缓存大传输，不在进行循环 */
DMA_InitStructure.DMA_M2M = DMA_M2M_Enable; // 开启存储器到存储器模式
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
//USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
int fputc(int ch,FILE *f)
{
if(ch=='\n')
{
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'\r');
}
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET)
;
USART_SendData(USART1,ch);
return ch;
}
void delay_nms(u16 time)//延时子程序
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
（2）DMA存储器到外设传输
使用前再main方法里面调用代码
USART_ClearFlag(USART1,USART_FLAG_TC);//清发送结束位
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
DMA_Cmd(DMA1_Channel4, ENABLE);DMA的配置：
void DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
/* DMA channel1 configuration */
DMA_DeInit(DMA1_Channel4);//重置DMA的寄存器的值，配置为缺省值
DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)&USART1->DR;/*设置DMA外设基地址，即源数据存储区的首地址*/
DMA_InitStructure.DMA_MemoryBaseAddr =(u32)SrcBuf;/*定义内存基地址*/
// DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;/*设置数据传输方向，从外设读取数据*/
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
// DMA_DIR_PeripheralSRC // 两种传输方向的设置
// DMA_DIR_PeripheralDST
DMA_InitStructure.DMA_BufferSize = 11;/*指定DMA通道，DMA缓存的大小*/
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工作正常模式，即按照指定的缓存大传输，不在进行循环 */
DMA_InitStructure.DMA_Priority = DMA_Priority_High;/*设定DMA选定的通道的软件优先级*/
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;// 开启存储器到存储器模式
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
}其他的同（1）代码
（3）DMA外设到存储器传输
#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>
void RCC_Configuration(void);
void GPIO_Configuration(void);
void DMA_Configuration(void);
void USART_Configuration(void);
int fputc(int ch, FILE *f);
void delay_nms(u16 time);//?????
char SrcBuf[12]="xxxxxxxxxxx";
int main(void)
{
char flag = 1;
RCC_Configuration();
GPIO_Configuration();
USART_Configuration();
DMA_Configuration();
USART_ClearFlag(USART1,USART_FLAG_TC);//清发送位
USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);//允许USART接收DMA请求
DMA_Cmd(DMA1_Channel5, ENABLE); // 启动DMA
while(flag)
{
if(strstr(SrcBuf, "LED"))
{
printf(SrcBuf);
flag = 0;
}
}
while(1)
{
GPIO_SetBits(GPIOA,GPIO_Pin_8);
delay_nms(200);
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
delay_nms(200);
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1的时钟, USART1挂接到APB2上
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA10
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8; //配置管脚8
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //IO口配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //工作频率50MHz
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA8口
}
void DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
/* DMA channel1 configuration */
DMA_DeInit(DMA1_Channel5);//重置DMA的寄存器的值，配置为缺省值
DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)&USART1->DR;/*设置DMA外设基地址，即源数据存储区的首地址*/
DMA_InitStructure.DMA_MemoryBaseAddr =(u32)SrcBuf;/*定义内存基地址*/
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;/*设置数据传输方向为从内存到外设*/
// DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 11;/*指定DMA通道，DMA缓存的大小*/
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工作正常模式，即按照指定的缓存大小传输，不在进行循环*/
// DMA_Mode_Circular 循环模式
DMA_InitStructure.DMA_Priority = DMA_Priority_High;/*设定DMA选定的通道的软件的优先级*/
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;//关闭存储器到存储器模式
DMA_Init(DMA1_Channel5, &DMA_InitStructure); // 初始化DMA1_Channel5
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
//USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
//USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
int fputc(int ch,FILE *f)
{
if(ch=='\n')
{
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'\r');
}
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET)
;
USART_SendData(USART1,ch);
return ch;
}
void delay_nms(u16 time)//延时子程序
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
14、ADC，DAC
利用ADC，获得内部电压，和温度
#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>
#define ADC_CH_TEMP ADC_Channel_16 //温度传感器通道
void RCC_Configuration(void);
void GPIO_Configuration(void);
void USART_Configuration(void);
void NVIC_Configuration(void);
//电压的
u16 Get_Adc(u8 ch);
u16 Get_Adc_Average(u8 ch,u8 times);
void Adc_Init(void);
//温度的
void T_Adc_Init(void);
u16 T_Get_Adc(u8 ch);
u16 T_Get_Temp(void);
u16 T_Get_Adc_Average(u8 ch,u8 times);
u16 adcx;
float temp;
float temperate;
int fputc(int ch, FILE *f);//输出重定向
void delay_nms(u16 time);
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
USART_Configuration();
NVIC_Configuration();
Adc_Init(); // 电压的
T_Adc_Init();// 温度的
while(1)
{
adcx = Get_Adc_Average(ADC_Channel_1,10);
temp = (float)adcx*(3.3/4096);
printf("ADC的值为:%d, 转化为电压是：%lfV, QLU_fuchen \n", adcx, temp);
adcx = T_Get_Adc_Average(ADC_CH_TEMP, 10);
temp = (float)adcx * (3.3 / 4096);
temperate = temp;
temperate = (1.43 - temperate) / 0.0043 + 25;
printf("ADC的值为:%d, 转化为温度是：%lf℃, QLU_fuchen \n", adcx, temperate);
printf("\n");
delay_nms(2000);
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1的时钟
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA10
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8; //配置管脚8
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //IO口配置为推挽输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //工作频率50MHz
GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA8口
}
void NVIC_Configuration(void) //NVIC配置
{
//配置NVIC的优先级
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //优先级分组1(0:4, 0位抢占优先级、4位子优先级?
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //设置串口1 中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级 0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级位0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 串口中断使能
NVIC_Init(&NVIC_InitStructure);
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
//USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
int fputc(int ch,FILE *f)
{
if(ch=='\n')
{
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'\r');
}
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET)
;
USART_SendData(USART1,ch);
return ch;
}
void delay_nms(u16 time)//?????
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
//下面是电压的代码
void Adc_Init(void)
{
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_ADC1 , ENABLE ); //使能ADC1通道时钟
RCC_ADCCLKConfig(RCC_PCLK2_Div6); //设置ADC分频因子6 72M/6=12,ADC最大时间不能超过14M
//PA1 作为模拟通道输入引脚
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入引脚
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_DeInit(ADC1); //复位ADC1,将外设 ADC1 的全部寄存器重设为缺省值
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //ADC工作模式:ADC1和ADC2工作在独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE; //模数转换工作在单通道模式
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; //模数转换工作在单次转换模式
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; //转换由软件而不是外部触发启动
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //ADC数据右对齐
ADC_InitStructure.ADC_NbrOfChannel = 1; //顺序进行规则转换的ADC通道的数目
ADC_Init(ADC1, &ADC_InitStructure); //根据ADC_InitStruct中指定的参数初始化外设ADCx的寄存器
ADC_Cmd(ADC1, ENABLE); //使能指定的ADC1
ADC_ResetCalibration(ADC1); //使能复位校准
while(ADC_GetResetCalibrationStatus(ADC1)); //等待复位校准结束
ADC_StartCalibration(ADC1); //开启AD校准
while(ADC_GetCalibrationStatus(ADC1)); //等待校准结束
// ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
}
u16 Get_Adc(u8 ch)
{
//设置指定ADC的规则组通道，一个序列，采样时间
ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5 ); //ADC1,ADC通道,采样时间为239.5周期
ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));//等待转换结束
return ADC_GetConversionValue(ADC1); //返回最近一次ADC1规则组的转换结果
}
u16 Get_Adc_Average(u8 ch,u8 times)
{
u32 temp_val=0;
u8 t;
for(t=0;t<times;t++)
{
temp_val+=Get_Adc(ch);
delay_nms(5);
}
return temp_val/times;
}
// 下面的温度的代码
//初始化ADC
//这里我们仅以规则通道为例
//我们默认将开启通道0~3
void T_Adc_Init(void) //ADC通道初始化
{
ADC_InitTypeDef ADC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_ADC1, ENABLE ); //使能GPIOA,ADC1通道时钟
RCC_ADCCLKConfig(RCC_PCLK2_Div6); //分频因子6时钟为72M/6=12MHz
ADC_DeInit(ADC1); //将外设 ADC1 的全部寄存器重设为缺省值
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //ADC工作模式:ADC1和ADC2工作在独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE; //模数转换工作在单通道模式
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; //模数转换工作在单次转换模式
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; //转换由软件而不是外部触发启动
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //ADC数据右对齐
ADC_InitStructure.ADC_NbrOfChannel = 1; //顺序进行规则转换的ADC通道的数目
ADC_Init(ADC1, &ADC_InitStructure); //根据ADC_InitStruct中指定的参数初始化外设ADCx的寄存器
ADC_TempSensorVrefintCmd(ENABLE); //开启内部温度传感器
ADC_Cmd(ADC1, ENABLE); //使能指定的ADC1
ADC_ResetCalibration(ADC1); //重置指定的ADC1的复位寄存器
while(ADC_GetResetCalibrationStatus(ADC1)); //获取ADC1重置校准寄存器的状态,设置状态则等待
ADC_StartCalibration(ADC1); //
while(ADC_GetCalibrationStatus(ADC1)); //获取指定ADC1的校准程序,设置状态则等待
}
u16 T_Get_Adc(u8 ch)
{
ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5 ); //ADC1,ADC通道3,第一个转换,采样时间为239.5周期
ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));//等待转换结束
return ADC_GetConversionValue(ADC1); //返回最近一次ADC1规则组的转换结果
}
//得到ADC采样内部温度传感器的值
//取10次,然后平均
u16 T_Get_Temp(void)
{
u16 temp_val=0;
u8 t;
for(t=0;t<10;t++)
{
temp_val+=T_Get_Adc(ADC_Channel_16); //TampSensor
delay_nms(5);
}
return temp_val/10;
}
//获取通道ch的转换值
//取times次,然后平均
u16 T_Get_Adc_Average(u8 ch,u8 times)
{
u32 temp_val=0;
u8 t;
for(t=0;t<times;t++)
{
temp_val+=T_Get_Adc(ch);
delay_nms(5);
}
return temp_val/times;
} 
获取DAC通道中存储的数值，并转化为相应的电压通过串口显示
#include "stm32f10x.h"
#include <stdio.h>
#include <string.h>
void Dac1_Init(void); //DAC通道1初始化
void RCC_Configuration(void);
void GPIO_Configuration(void);
void USART_Configuration(void);
void EXTI_Configuration(void);
void NVIC_Configuration(void);
int fputc(int ch, FILE *f);// 输出重定向
void delay_ms(u16 time);
void Adc_Init(void); // ADC的初始化
void Dac1_Init(void); //DAC通道1的初始化
u16 Get_Adc(u8 ch); // 获取 ADC通道值
u16 Get_Adc_Average(u8 ch,u8 times); // 获取一段时间内通道的平均值
u16 adcx;
float temp;
char flag = 0;
u16 dacval = 1000;
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
USART_Configuration();
EXTI_Configuration(); // 配置外部中断源
NVIC_Configuration(); // 嵌套向量中断初始化
Adc_Init(); //ADC初始化
Dac1_Init(); //DAC通道1初始化
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
u8 t = 0;
DAC_SetChannel1Data(DAC_Align_12b_R, dacval);
while(1)
{
while(1)
{
t++;
if(t == 2) //两次刷新一次
{
adcx=DAC_GetDataOutputValue(DAC_Channel_1); //获取DAC通道存储的数值
printf("DAC VAL: %d.\n", adcx);
temp=(float)adcx*(3.3/4096); //得到DAC电压值
printf("DAC VOL: %lfV\n", temp);
adcx=Get_Adc_Average(ADC_Channel_1,10); //得到ADC转换值
temp=(float)adcx*(3.3/4096); //得到ADC电压值
printf("ADC VOL:%lfV\n", temp);
t=0;
printf("\n\n");
}
delay_ms(1000);
}
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //使能AFIO时钟（开始管脚的复用功能）
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //关掉JTAG，不关SW
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构变量
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //配置管脚PA10/USART1_RX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;// 浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9; //配置管脚PA9/USART1_TX
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; //IO配置为复用输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //IO口配置为推挽输出口
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU; //上拉输入
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU ;
GPIO_Init(GPIOC,&GPIO_InitStructure);
}
void EXTI_Configuration(void) // 配置外部中断源
{
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line=EXTI_Line15|EXTI_Line5; // 外部中短线Line12 | Line5
EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt; //选择中断模式
EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling; //下降沿触发
EXTI_InitStructure.EXTI_LineCmd=ENABLE; //使能中断
EXTI_Init(&EXTI_InitStructure); // 初始化外部中断
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource15); //PA15配置为外部中断源（本质利用AFIO_EXTICR寄存器）
GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource5); //PC5配置为外部中断源(本质利用AFIO_EXTICR寄存器)
}
void NVIC_Configuration(void) // 嵌套向量中断初始化
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // 中断优先级分组
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn; // EXTI9_5中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先优先级设定，取值为0-1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //从优先级设定、取值0-7
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn; //EXTI9_5中断源
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先优先设计定，取值为0-1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //从优先级设计定，取值为0-7
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void EXTI9_5_IRQHandler(void) // 外部中断源9_5中断子程序
{
if(EXTI_GetITStatus(EXTI_Line5) != RESET)
{
if(dacval < 4000){
dacval += 200;
}
DAC_SetChannel1Data(DAC_Align_12b_R, dacval);
EXTI_ClearFlag(EXTI_Line5);
}
}
void EXTI15_10_IRQHandler(void) // 外部中断源15_10中断子程序
{
if (EXTI_GetITStatus(EXTI_Line15)!=RESET)
{
if(dacval>200)dacval -= 200;
else dacval=0;
DAC_SetChannel1Data(DAC_Align_12b_R, dacval);
EXTI_ClearFlag(EXTI_Line15);
}
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //USART_WordLength_8b; //8 数据 //USART_WordLength_9b; //9 位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;
//USART_StopBits_1 ;//在帧结尾传输1个停止位
//USART_StopBits_0.5;//在帧结尾传输0.5个停止位
//USART_StopBits_2 ;//在帧结尾传输2个停止位
//USART_StopBits_1.5;//在帧结尾传输1.5个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;
//USART_Parity_No ;//奇偶失能
//USART_Parity_Even;//偶模式
//USART_Parity_Odd ;//奇模式
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//USART_HardwareFlowControl_None; //硬件流控制失能
//USART_HardwareFlowControl_RTS; //发送请求 RTS使能
//USART_HardwareFlowControl_CTS; //清除请求 CTS使能
//USART_HardwareFlowControl_RTS_CTS;//RTS和 CTS使能
USART_InitStructure.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
//USART_Mode_Tx;//发送使能
//USART_Mode_Rx;//接收使能
USART_Init(USART1, &USART_InitStructure);//初始化串口
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启接收中断，接收寄存器不空(RXNE=1)时产生中断
//USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // 开启发送中断，发送寄存器空(TXE=1)时使能产生中断
/*串口的发送中断有两个，分别是：
l、发送数据寄存器空中断(TXE)
2、发送完成中断(TC)*/
USART_Cmd(USART1, ENABLE); //启动USART
}
int fputc(int ch,FILE *f)
{
if(ch=='\n')
{
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
USART_SendData(USART1,'\r');
}
while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET)
;
USART_SendData(USART1,ch);
return ch;
}
void delay_ms(u16 time)
{
u16 i=0;
while(time--)
{
i=12000;
while(i--) ;
}
}
//初始化ADC
//这里我们仅以规则通道为例
//我们默认将开启通道0~3
void Adc_Init(void)
{
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_ADC1 , ENABLE ); //使能ADC1通道时钟
RCC_ADCCLKConfig(RCC_PCLK2_Div6); //设置ADC分频因子6 72M/6=12,ADC最大时间不能超过14M
//PA1 作为模拟通道输入引脚
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入引脚
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_DeInit(ADC1); //复位ADC1,将外设 ADC1 的全部寄存器重设为缺省值
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //ADC工作模式:ADC1和ADC2工作在独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE; //模数转换工作在单通道模式
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; //模数转换工作在单次转换模式
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; //转换由软件而不是外部触发启动
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //ADC数据右对齐
ADC_InitStructure.ADC_NbrOfChannel = 1; //顺序进行规则转换的ADC通道的数目
ADC_Init(ADC1, &ADC_InitStructure); //根据ADC_InitStruct中指定的参数初始化外设ADCx的寄存器
ADC_Cmd(ADC1, ENABLE); //使能指定的ADC1
ADC_ResetCalibration(ADC1); //使能复位校准
while(ADC_GetResetCalibrationStatus(ADC1)); //等待复位校准结束
ADC_StartCalibration(ADC1); //开启AD校准
while(ADC_GetCalibrationStatus(ADC1)); //等待校准结束
// ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
}
//获得ADC值
//ch:通道值 0~3
u16 Get_Adc(u8 ch)
{
//设置指定ADC的规则组通道，一个序列，采样时间
ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5 ); //ADC1,ADC通道,采样时间为239.5周期
ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));//等待转换结束
return ADC_GetConversionValue(ADC1); //返回最近一次ADC1规则组的转换结果
}
u16 Get_Adc_Average(u8 ch,u8 times)
{
u32 temp_val=0;
u8 t;
for(t=0;t<times;t++)
{
temp_val+=Get_Adc(ch);
delay_ms(5);
}
return temp_val/times;
}
//DAC通道1输出初始化
void Dac1_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
DAC_InitTypeDef DAC_InitType;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE ); //使能PORTA通道时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE ); //使能DAC通道时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; // 端口配置
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA,GPIO_Pin_4) ;//PA.4 输出高
DAC_InitType.DAC_Trigger=DAC_Trigger_None; //不使用触发功能 TEN1=0
DAC_InitType.DAC_WaveGeneration=DAC_WaveGeneration_None;//不使用波形发生
DAC_InitType.DAC_LFSRUnmask_TriangleAmplitude=DAC_LFSRUnmask_Bit0;//屏蔽、幅值设置
DAC_InitType.DAC_OutputBuffer=DAC_OutputBuffer_Disable ; //DAC1输出缓存关闭 BOFF1=1
DAC_Init(DAC_Channel_1,&DAC_InitType); //初始化DAC通道1
DAC_Cmd(DAC_Channel_1, ENABLE); //使能DAC1
DAC_SetChannel1Data(DAC_Align_12b_R, 0); //12位右对齐数据格式设置DAC值
}
15、SysTic
精确延时
#include "stm32f10x.h"
#define LED GPIO_Pin_2 //定义LED对应的管脚
void RCC_Configuration(void); //时钟配置
void TIM_Configuration(void);
void NVIC_Configuration(void); //NVIC配置
void GPIO_Configuration(void); //GPIO配置
int main(void)
{
RCC_Configuration();//配置时钟
GPIO_Configuration(); //配置GPIO, 注意，一定要先配置GPIO,在配置TIM和NVIC,否则无效
TIM_Configuration();
NVIC_Configuration();//配置NVIC
GPIO_ResetBits(GPIOA, LED);//PBA清零,LED亮
while(1){}
}
void RCC_Configuration(void)//时钟配置子程序
{
SystemInit(); //72MHz
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);//使能GPIOD的时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);//使能TIM2的时钟
}
void GPIO_Configuration(void) //GPIO配置
{ /*管脚设置*/
GPIO_InitTypeDef GPIO_InitStructure;//声明GPIO初始化结构体变量
GPIO_InitStructure.GPIO_Pin = LED;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
void NVIC_Configuration(void) //NVIC配置
{ //配置NVIC相应的优先级位
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; ;// 设置TIM2中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级 0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 子优先级为 0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 串口中断使能
NVIC_Init(&NVIC_InitStructure);
}
void TIM_Configuration(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);//使能TIM2的时钟
TIM_TimeBaseInitTypeDef TIM_BaseInitStructure;
TIM_BaseInitStructure.TIM_Prescaler = 36000-1; //预分频数值,72 000 000/36000=2000Hz
TIM_BaseInitStructure.TIM_Period = 1000-1; //预装载值,从0记数至1000后,产生中断信号，累计0.5s
TIM_BaseInitStructure.TIM_ClockDivision = 0;
TIM_BaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;//上升计数模式
TIM_BaseInitStructure.TIM_RepetitionCounter = TIM_CKD_DIV1;//滤波器采样分频
TIM_TimeBaseInit(TIM2, &TIM_BaseInitStructure); //清中断，以免一启用中断后立即产生中断
TIM_UpdateRequestConfig(TIM2, TIM_UpdateSource_Regular);
//TIM_ClearFlag(TIM2, TIM_FLAG_Update);
//使能TIM2中断源
TIM_Cmd(TIM2, ENABLE);
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);//TIM2总开关：开启
}
void TIM2_IRQHandler(void){
if(TIM_GetITStatus(TIM2, TIM_IT_Update)== SET)
{
GPIOD->ODR ^= LED; //异或使LED状态改变
TIM_ClearITPendingBit(TIM2, TIM_FLAG_Update); //清除中断标志
}
}
呼吸灯
#include "stm32f10x.h"
void RCC_Configuration(void);
void TIM_Configuration(void);
void GPIO_Configuration(void);
void PWM_Configuration(void);
void delay_ms(u16 time);
int led_fx = 1;
int led_dt = 0;
int main(void)
{
RCC_Configuration();
GPIO_Configuration(); // GPIO要先于 TIM和NVIC配置
TIM_Configuration();
PWM_Configuration();
TIM_Cmd(TIM1, ENABLE); // 使能TIM计时器，开始输出PWM
while(1)
{
delay_ms(5);
if(led_fx == 1)
{
led_dt++;
}
else
{
led_dt--;
}
if(led_dt > 300)
{
led_fx = 0;
}
else if(led_dt == 0)
{
led_fx = 1;
}
TIM_SetCompare1(TIM1, led_dt);
}
}
void RCC_Configuration(void)//配置时钟
{
SystemInit();
//开启GPIO的时钟和复用功能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
//开启TIM1的时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
}
void GPIO_Configuration(void) //GPIO配置
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_PinRemapConfig(GPIO_PartialRemap_TIM1, ENABLE); // 映射引脚，
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//??????50MHz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void TIM_Configuration(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_DeInit(TIM1); //重新将Timer设置为缺省值
TIM_InternalClockConfig(TIM1); //采用内部时钟给TIM2提供时钟源
TIM_TimeBaseStructure.TIM_Prescaler = 1-1; //预分频数值,72000 000/1=72000000
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //定时器时钟(CK_INT)频率与数字滤波器(ETR,TIx)
//使用的采样频率之间的分频比为1
TIM_TimeBaseStructure.TIM_Period = 300-1; //设置计数溢出大小
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //设置计数器模式为向上计数模式(+1)
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); //将配置应用到TIM2中
}
void PWM_Configuration(void)
{
TIM_OCInitTypeDef TimOCInitStructure;
//设置缺省值
TIM_OCStructInit(&TimOCInitStructure);
//PWM模式1输出
TimOCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
//设置占空比 (Led亮度)
TimOCInitStructure.TIM_Pulse = 0;
// TIM输出比较极性高
TimOCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
//使能输出状态
TimOCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
//TIM1的CH4输出
TIM_OC1Init(TIM1, &TimOCInitStructure);
//设置TIM1的PWM输出为使能
TIM_CtrlPWMOutputs(TIM1, ENABLE);
}
void delay_ms(u16 time)
{
u16 i = 0;
while(time--)
{
i=12000;
while(i--);
}
}TIM3产生4路PWM波
/**
2 ******************************************************************************
3 * @file TIM/PWM_Output/main.c
4 * @author MCD Application Team
5 * @version V3.5.0
6 * @date 08-April-2011
7 * @brief Main program body
8 ******************************************************************************
9 * @attention
10 // PA6===TIM3_Ch1, PA7===TIM3_Ch2
11 // PB0===TIM3_Ch3, PB1===TIM3_Ch4
12 */
#include "stm32f10x.h"
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
uint16_t CCR1_Val = 333;
uint16_t CCR2_Val = 249;
uint16_t CCR3_Val = 166;
uint16_t CCR4_Val = 83;
uint16_t PrescalerValue = 0;
/* Private function prototypes -----------------------------------------------*/
void RCC_Configuration(void);
void GPIO_Configuration(void);
int main(void)
{
RCC_Configuration();// System Clocks Configuration
GPIO_Configuration();
/* TIM3：产生4路PWM信号，每路具有不同的占空比
TIM3CLK频率设置为SystemCoreClock (Hz)；
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
35 TIM3的计数器时钟频率设置为24MHz，对应的预分频系数计算公式为：
36 - Prescaler = (TIM3CLK / TIM3 counter clock) - 1
37 SystemCoreClock=72 MHz
38
39 TIM3的工作频率为 36 KHz: TIM3 Frequency = TIM3 counter clock/(ARR + 1)
40 = 24 MHz / 666 = 36 KHz
41 TIM3 Channel1 duty cycle = (TIM3_CCR1/ TIM3_ARR)* 100 = 50%
42 TIM3 Channel2 duty cycle = (TIM3_CCR2/ TIM3_ARR)* 100 = 37.5%
43 TIM3 Channel3 duty cycle = (TIM3_CCR3/ TIM3_ARR)* 100 = 25%
44 TIM3 Channel4 duty cycle = (TIM3_CCR4/ TIM3_ARR)* 100 = 12.5%
45 ----------------------------------------------------------------------- */
/* Compute the prescaler value */
PrescalerValue = (uint16_t) (SystemCoreClock / 24000000) - 1; //计算产生24MHz频率的分频系数
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = 666-1; //设置自重重装载寄存器（ARR）的计数值
TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;//预分频系数
TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置定时器时钟(CK_INT)频率与数字滤波器(ETR，TIx)使用
//的采样频率之间的分频比例的（与输入捕获相关），0表示滤波器的频率和定时器的频率是一样的
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//上计数模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
/* PWM1 Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; //输出比较模式=PWM输出模式1 （PWM输出有两种模式）
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //使能输出
TIM_OCInitStructure.TIM_Pulse = CCR1_Val;//指定将要加载到捕获比较寄存器的脉冲值，当计数器计数到这个值时，电平发生跳变
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;//设置输出比较极性，当定时器计数值小于CCR1_Val时为高电平
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Mode configuration: Channel2 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
TIM_OC2Init(TIM3, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Mode configuration: Channel3 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR3_Val;
//指定将要加载到捕获比较寄存器的脉冲值，当计数器计数到这个值时，电平发生跳变
TIM_OC3Init(TIM3, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Mode configuration: Channel4 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR4_Val;
//指定将要加载到捕获比较寄存器的脉冲值，当计数器计数到这个值时，电平发生跳变
TIM_OC4Init(TIM3, &TIM_OCInitStructure);
TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM3, ENABLE);
TIM_Cmd(TIM3, ENABLE);/* TIM3 enable counter */
while (1)
{}
}
void RCC_Configuration(void)
{
/* TIM3 clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
/* GPIOA and GPIOB clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOA Configuration:TIM3 Channel1, 2, 3 and 4 as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; // PA6===TIM3_Ch1, PA7===TIM3_Ch2
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1; // PB0===TIM3_Ch3, PB1===TIM3_Ch4
GPIO_Init(GPIOB, &GPIO_InitStructure);
}SysTic定时
#include "stm32f10x.h"
__IO uint32_t TimingDelay; //声明外部变量
void RCC_Configuration(void);
void SysTick_Configuration(void);
void NVIC_Configuration(void);
void GPIO_Configuration(void);
void delay_ms(__IO uint32_t nTime);
int main(void)
{
RCC_Configuration();//配置时钟
GPIO_Configuration(); // 要先配置管脚在配置
SysTick_Configuration();
NVIC_Configuration();
GPIO_ResetBits(GPIOA,GPIO_Pin_8);
while(1)
{
delay_ms(500);
GPIOA->ODR^=GPIO_Pin_8;
}
}
void RCC_Configuration(void)
{
SystemInit(); //72MHz
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);//使能TIM7的时钟
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = SysTick_IRQn;//设置SysTic中断
//TIM3_IRQn; ;// @设置TIM3中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 抢占优先级0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 中断使能
NVIC_Init(&NVIC_InitStructure);
}
void SysTick_Configuration(void)
{
SysTick->LOAD = 72000 - 1; //设置1ms重装值
SysTick->CTRL = 0x00000007; // 选用HCLK为中断源
}
void delay_ms(__IO uint32_t nTime)
{
TimingDelay = nTime;
while(TimingDelay != 0)
{};
}
extern __IO uint32_t TimingDelay;
void SysTick_Handler(void) //SysTick中断处理子程序
{
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}16、CMSIS RTOS
/*----------------------------------------------------------------------------
* CMSIS-RTOS 'main' function template
*---------------------------------------------------------------------------*/
#include "stm32f10x.h"
#define osObjectsPublic // define objects in main module
#include "osObjects.h" // RTOS object definitions
/*
* main: initialize and start the system
*/
#define ON 1
#define OFF 0
#define LED1(opt) ((opt) ? (GPIOA->BRR |= 1 << 8) : (GPIOA->BSRR |= 1 << 8))
#define LED2(opt) ((opt) ? (GPIOD->BRR |= 1 << 2) : (GPIOD->BSRR |= 1 << 2))
void LED_Init(void)
{
RCC->APB2ENR |= (1 << 2) | (1 << 5);
GPIOA->CRH &= 0xFFFFFFF0;
GPIOA->CRH |= 0x00000003; // PA8设置为推挽输出
GPIOD->CRL &= 0xFFFFF0FF;
GPIOD->CRL |= 0x00000300; //PD2设置为推挽输出
LED1(OFF);
LED2(OFF); // 关闭两个灯
}
void led_Thread1(void const *p_arg)
{
while(1)
{
LED1(ON);
osDelay(500);
LED1(OFF);
osDelay(500);
}
}
void led_Thread2(void const *p_arg)
{
for(;;)
{
LED2(OFF);
osDelay(500);
LED2(ON);
osDelay(500);
}
}
osThreadDef(led_Thread1, osPriorityNormal, 1, 0); // 定义线程1
osThreadDef(led_Thread2, osPriorityNormal, 1, 0); // 定义线程2
osThreadId T_led_ID1; //线程1的Id
osThreadId T_led_ID2; //线程2的Id
int main (void) {
osKernelInitialize (); // initialize CMSIS-RTOS
// initialize peripherals here
LED_Init();
// create 'thread' functions that start executing,
// example: tid_name = osThreadCreate (osThread(name), NULL);
T_led_ID1 = osThreadCreate(osThread(led_Thread1), NULL); // 线程1
T_led_ID2 = osThreadCreate(osThread(led_Thread2), NULL); // 线程2
osKernelStart (); // start thread execution
}END（嵌入式课程结束）接下来自己走咯，之后的学习记录会重新开贴写
复制了一个学期的代码，再自己修修改改，大概就汇聚在这个上面。
上面几乎所有的类型都囊括了，以后读别人代码的时候，这些基础库函数初始化代码，就是支持我的修改的基石咯
接下来我的学习计划就是把硬件知识提高上来，能读得懂别人的代码，然后利用原子哥的资源，网络上的的各种代码，修修补补，改出自己想要的代码，自己想要的结果，至少我觉得，我现在走的路都是前人走过了，我写的代码也都是前人已经写过的，并且已经开源的，现在能读得懂，并且能改的出自己想要的结果，这个就是我当前很长一段时间的目标，等到了能自己写代码，让人阅读的时候，那我这篇博客的点击量一定会很高吧，毕竟这是大神菜鸡的时候，
哈哈，现在我是真的菜，还是那种没有本事却很跳的那种，不知道以后我回过头来看，我成长的痕迹，看我现在写下的所记录的东西，不知道那时，时间有没有磨平我的棱角，不知道我有没有实现最初的梦想，愿初心不忘，归来仍是少年！
齐鲁工业大学，机电楼A511
2018年6月5日 19:18:02
扫一扫
3346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
