1. #include "stdio.h"
   
2. #define _IO volatile
   
3. typedef unsigned int uint32_t;
   
4. typedef _IO uint32_t vu32;
   
5. typedef unsigned short int uint16_t;
   
6. #define GPIO_Pin_0         ((uint16_t)0x0001)
   
7. #define GPIO_Pin_1         ((uint16_t)0x0002)
   
8. #define GPIO_Pin_2         ((uint16_t)0x0004)
   
9. #define GPIO_Pin_3         ((uint16_t)0x0008)
   
10. #define GPIO_Pin_4         ((uint16_t)0x0010)
    
11. #define GPIO_Pin_5         ((uint16_t)0x0020)
    
12. #define GPIO_Pin_6         ((uint16_t)0x0040)
    
13. #define GPIO_Pin_7         ((uint16_t)0x0080)
    
14. #define GPIO_Pin_8         ((uint16_t)0x0100)
    
15. #define GPIO_Pin_9         ((uint16_t)0x0200)
    
16. #define GPIO_Pin_10        ((uint16_t)0x0400)
    
17. #define GPIO_Pin_11        ((uint16_t)0x0800)
    
18. #define GPIO_Pin_12        ((uint16_t)0x1000)
    
19. #define GPIO_Pin_13        ((uint16_t)0x2000)
    
20. #define GPIO_Pin_14        ((uint16_t)0x4000)
    
21. #define GPIO_Pin_15        ((uint16_t)0x8000)
    
22. #define GPIO_Pin_All       ((uint16_t)0xFFFF)
    
23. 
    
24. 
    
25. #define   RCC_APB2Periph_AFIO      ((uint32_t)0x00000001)
    
26. #define   RCC_APB2Periph_GPIOA     ((uint32_t)0x00000004)
    
27. #define   RCC_APB2Periph_GPIOB     ((uint32_t)0x00000008)
    
28. #define   RCC_APB2Periph_GPIOC     ((uint32_t)0x00000010)
    
29. #define   RCC_APB2Periph_GPIOD     ((uint32_t)0x00000020)
    
30. 
    
31. #define LEDON    (GPIOD->BRR = GPIO_Pin_2)
    
32. #define LEDOFF   (GPIOD->BSRR = GPIO_Pin_2)
    
33. 
    
34. 
    
35. #define BITBAND(addr,bitnum)  ((addr & 0xF0000000)+0x2000000+((addr & 0xFFFFF)<<5)+ (bitnum<<2))
    
36. /*******这个的公式是FLASH的话，   0X4200 0000 + ((add-0x4000 0000)*8+n)*4;
    
37.         其中add是你要绑定的寄存器的地址，n是你要绑定的寄存器的位，
    
38.                 现在将其变成这种形式((addr & 0xF0000000)+0x2000000+((addr & 0xFFFFF)<<5 + (bitnum)<<2))
    
39.                 :addr & 0xF000 0000是将其保留最高的思位比如说addr地址是0x4201 8000那么他现在是0x4000 0000
    
40.                 +0x2000000变成了0x4200 0000;(addr-0x4000 0000)这其实就是保留它的后7位(在这里的改变的寄存器的地址都是
    
41.                 0x4001 0000的那么就是说进一步保存的是后五位)(这里注意一点，0x2200_0000这个地址每增加1，实际上就是增加
    
42.                 8个bit（一个地址对应一个字节），实际寄存器中的1个bit对应32个bit，所以就乘以4，地址本身增加1是8bit，
    
43.                 8bit乘以4倍刚好是32bit。)那么现在(addr &0XFFFFF)其实就是保留后五位，<<5就是*32(2^5)，<<2就是*4(2^2);
    
44.                 将((A-0x4000 0000)(这个就是addr &0xFFFFF)*8+n)*4拆开就是(addr & 0XFFFFF)<<5 +(bitnum)<<2了
    
45. **********/
    
46. #define MEM_ADDR(addr)   *((volatile unsigned  long *)(addr))
    
47. #define BIT_ADDR(addr,bitnum) MEM_ADDR(BITBAND(addr, bitnum))
    
48. #define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)
    
49. #define KEY1   PCin(4)
    
50. 
    
51. typedef struct
    
52. {
    
53.     _IO uint32_t   CRL;
    
54.         _IO uint32_t   CRH;
    
55.         _IO uint32_t   IDR;
    
56.         _IO uint32_t   ODR;
    
57.         _IO uint32_t   BSRR;
    
58.         _IO uint32_t   BRR;
    
59.         _IO uint32_t   LCKR;
    
60. }GPIO_TypeDef;
    
61. 
    
62. 
    
63. typedef struct
    
64. {
    
65.     _IO uint32_t  ACR;
    
66.         _IO uint32_t  KEYR;
    
67.         _IO uint32_t  OPTKEYR;
    
68.         _IO uint32_t  SR;
    
69.         _IO uint32_t  CR;
    
70.         _IO uint32_t  AR;
    
71.         _IO uint32_t  OBR;
    
72.         _IO uint32_t  WRPR;
    
73. }FLASH_TypeDef;
    
74. 
    
75. 
    
76. 
    
77. /************GPIOD管脚的内存对应地址********/
    
78. #define PERIPH_BASE          ((uint32_t)0x40000000)
    
79. #define APB2PERIPH_BASE      (PERIPH_BASE + 0x10000)
    
80. #define GPIOD_BASE           (APB2PERIPH_BASE + 0x1400)
    
81. #define GPIOD                     ((GPIO_TypeDef *)GPIOD_BASE)
    
82. 
    
83. 
    
84. //#define PERIPH_BASE          ((uint32_t) 0x40000000)
    
85. //#define APB2PERIPH_BASE      (PERIPH_BASE + 0x10000)
    
86. #define GPIOC_BASE           (APB2PERIPH_BASE + 0x1000)
    
87. #define GPIOC                ((GPIO_TypeDef *)GPIOC_BASE)
    
88. #define GPIOC_IDR_Addr       (GPIOC_BASE+8)
    
89. 
    
90. 
    
91. #define FLASH_BASE           ((uint32_t)0x40022000)
    
92. #define FLASH                ((FLASH_TypeDef *)FLASH_BASE)
    
93. typedef struct
    
94. {
    
95.    _IO uint32_t CR;
    
96.    _IO uint32_t CFGR;
    
97.    _IO uint32_t CIR;
    
98.    _IO uint32_t APB2RSTR;
    
99.    _IO uint32_t APB1RSTR;
    
100.    _IO uint32_t AHBENR;
     
101.    _IO uint32_t APB2ENR;
     
102.    _IO uint32_t APB1ENR;
     
103.    _IO uint32_t BDCR;
     
104.    _IO uint32_t CSR;
     
105.    _IO uint32_t AHBRSTR;
     
106.    _IO uint32_t CFGR2;
     
107. }RCC_TypeDef;
     
108. 
     
109. 
     
110. /****************RCC时钟************/
     
111. #define AHBPERIPH_BASE     (PERIPH_BASE         + 0x20000)
     
112. #define RCC_BASE           (AHBPERIPH_BASE + 0x1000)
     
113. #define RCC                ((RCC_TypeDef *)RCC_BASE)
     
114. void RCC_init(void)
     
115. {
     
116.            RCC->CR|=1<<16;
     
117.         while(!(RCC->CR>>17));
     
118.         RCC->CFGR2|=4<<4;
     
119.         RCC->CFGR2|=6<<8;
     
120.         RCC->CFGR2|=1<<16;
     
121.         RCC->CR|=1<<26;
     
122.         while(!(RCC->CR>>27));
     
123.         RCC->CFGR2|=1<<2;
     
124.         RCC->CFGR|=1<<16;
     
125.         RCC->CFGR|=7<<18;
     
126.         FLASH->ACR|=0x32;
     
127.         RCC->CR|=1<<24;
     
128.         while(!(RCC->CR>>25));
     
129.         //FLASH->ACR|=0x32;//
     
130.         RCC->CFGR|=1<<1;
     
131. }
     
132. 
     
133. 
     
134. void LED_init()
     
135. {
     
136.    RCC->APB2ENR|=RCC_APB2Periph_GPIOD;
     
137.    GPIOD->CRL&=0xFFFFF0FF;
     
138.    GPIOD->CRL|=0x00000300;
     
139. }
     
140. void Delay(vu32 nCount)
     
141. {
     
142.    for(;nCount!=0;nCount--);
     
143. }
     
144. void Key_init()
     
145. {
     
146.     RCC->APB2ENR|=RCC_APB2Periph_GPIOC;//如果你写成RCC->APB2ENR=RCC_APB2Periph_GPIOC;
     
147.         //就不行了，因为这样的话RCC的时钟只为GPIOC打开了，
     
148.         GPIOC->CRL&=0xFFF0FFFF;
     
149.         GPIOC->CRL|=0x00080000;
     
150. }
     
151. int main(void)
     
152. {
     
153.   
     
154.   unsigned int key_up=1,flag;
     
155.   RCC_init();
     
156.   LED_init();
     
157.   Key_init();
     
158.   while(1)
     
159.   {
     
160.       if(key_up)
     
161.             LEDON;
     
162.           else
     
163.             LEDOFF;
     
164.           /************键盘消抖**********
     
165.           这里，因为键盘按下的时候，会有一段波动，不稳定.所以在这里，我们需要消抖
     
166.           首先，我们的按键是按下的时候是0，所以进来一个while()循环(主要是stm32的运转速率太快了)
     
167.           然后在里面我们进行延时等待，为了防止按一下按键stm32跑了很多次的情况，我们设置一个标志flag
     
168.           ，只让他按一下不论多长时间，LED只亮一次。*/
     
169.           while(KEY1==0)//键盘消抖
     
170.           {
     
171.                Delay(0xfffff);
     
172.                    flag++;
     
173.                    if(flag==1)
     
174.                    {
     
175.                        key_up=!key_up;
     
176.                    }
     
177.           }
     
178.           flag=0;
     
179.   }
     
180. }
     
181. 
     
182.        

复制代码

这里有一些关于位绑定的知识大家可以去看看。http://blog.sina.com.cn/s/articlelist_1989261580_0_1.html

wdshuang09 发表于 2016-11-1 22:09
Delay(0xfffff);让系统一直在这等待，不明智的选择，

刚入门，还没接触STM32的定时器，只玩过51的，所以我只能先写个延时的，等学到那个地方，再回来改进

在路上11111111 发表于 2016-11-2 13:03
刚入门，还没接触STM32的定时器，只玩过51的，所以我只能先写个延时的，等学到那个地方，再回来改进 ...

用定时器做，定期采样，

高二毛 发表于 2016-11-2 08:39
不能这样去抖动的。楼上几位说的很好，不能这样阻塞掉。应该用中断处理。 ...

还没接触STM32的定时器，所以才采用了这个

Delay(0xfffff);让系统一直在这等待，不明智的选择，

其实不需要这么复杂，利用系统毫秒滴答，定期采样即可，很稳定

谢楼主分享

peter001 发表于 2016-11-2 00:20
其实不需要这么复杂，利用系统毫秒滴答，定期采样即可，很稳定

赞同，定期采样，程序不会阻塞，效率高

不能这样去抖动的。楼上几位说的很好，不能这样阻塞掉。应该用中断处理。

peter001 发表于 2016-11-2 00:20
其实不需要这么复杂，利用系统毫秒滴答，定期采样即可，很稳定

定时器吗

黑皮男 发表于 2016-11-2 08:08
赞同，定期采样，程序不会阻塞，效率高

还没接触STM32的定时器

放在中断函数定时几十毫秒扫描按键即可，不要延时

不能这样去抖动的

好的，先记下了