EEPW论坛

作业一：keil安装

猛戳这个程序：

然后出现这个玩意：

接下来的就不要理会那么多了，猛戳Next就对了，出现这个窗口：

剩下的就是等，等出现这玩意：

点击Finish，接下来就要用这个神器和谐Keil：

最后就Duang！！！能用到2020年了！

作业二：流水灯

/**
  ******************************************************************************
  * @file    GPIO/IOToggle/main.c 
  * @author  MCD Application Team
  * @version V3.5.0
  * @date    08-April-2011
  * @brief   Main program body.
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include "stm32_eval.h"
GPIO_InitTypeDef GPIO_InitStructure;
void RCC_Configuration(void)
{
  RCC_DeInit();
    
  RCC_HSICmd(ENABLE);
  while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
  
  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
  
  RCC_HSEConfig(RCC_HSE_OFF);
  RCC_LSEConfig(RCC_LSE_OFF);
  RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz
  RCC_PLLCmd(ENABLE);
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
  RCC_ADCCLKConfig(RCC_PCLK2_Div4);
  RCC_PCLK2Config(RCC_HCLK_Div1);
  RCC_PCLK1Config(RCC_HCLK_Div2);
  RCC_HCLKConfig(RCC_SYSCLK_Div1);
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
  while(RCC_GetSYSCLKSource() != 0x08);
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);
 GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
 GPIO_ResetBits(GPIOD,GPIO_Pin_2);
}
void delay_us(u32 n)
{
 u8 j;
 while(n--)
 for(j=0;j<10;j++);
}
void delay_ms(u32 n)
{
 while(n--)
 delay_us(1000);
}
/**
  * @brief  Main program.
  * @param  None
  * @retval None
  */
int main(void)
{  
 int i;      
 unsigned int a[8]={GPIO_Pin_0,GPIO_Pin_1,GPIO_Pin_2,GPIO_Pin_3,GPIO_Pin_4,GPIO_Pin_5,GPIO_Pin_6,GPIO_Pin_7}; 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1| GPIO_Pin_2| GPIO_Pin_3| GPIO_Pin_4| GPIO_Pin_5| GPIO_Pin_6| GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
while(1)
 {
  for(i=0;i<=7;i++)  
  {   
GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);     
   delay_ms(50);        
GPIO_ResetBits(GPIOC,a[i]);      
delay_ms(50);   
GPIO_SetBits(GPIOC,a[i]);        
delay_ms(50);   
  }      
 
}
}

作业三：0~99按键计数

view plaincopy to clipboardprint?

1. <strong>  
2. <pre name="code" class="c">#include "stm32f10x.h"     
3.   
4. GPIO_InitTypeDef GPIO_InitStructure; // 声明一个结构体  
5.   
6. void RCC_Configuration(void);   
7. void GPIO_INIT(void) ;  
8. void Function(void) ;  
9.   
10. int main(void)     
11. {      
12.     RCC_Configuration();     
13.     GPIO_INIT();  
14.     Function();     
15. }      
16.         
17. void RCC_Configuration(void)    //复位所有的RCC外围设备寄存器  
18. {     
19.         ErrorStatus HSEStartUpStatus;   //  设置错误标志量  
20.     RCC_DeInit();                       //*将外设寄存器RCC重设为初始值   
21.     RCC_HSEConfig(RCC_HSE_ON);//*打开外部高速时钟晶振HSE：  
22.   HSEStartUpStatus = RCC_WaitForHSEStartUp();  //*等待外部高速时钟晶振工作：   
23.   if(HSEStartUpStatus==SUCCESS)  
24.     {  
25.         RCC_HCLKConfig(RCC_SYSCLK_Div1);//*AHB使用系统时钟,负责外部存储器的时钟   
26.         RCC_PCLK1Config(RCC_HCLK_Div2);//*APB1 负责DA,USB,SPI,I2C,CAN，串口2345，普通TIM  
27.         RCC_PCLK2Config(RCC_HCLK_Div1);//*APB2负责AD,I/O,高级TIM,串口1   
28.         RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);//*设置PLL输入时钟源72M  
29.         RCC_PLLCmd(ENABLE);//*打开PLL：            
30.         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);//*等待PLL工作：  
31.         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//*设置系统时钟  
32.         while(RCC_GetSYSCLKSource() != 0x08);//* 判断PLL是否是系统时钟：      
33.     }  
34.       
35.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//改变管脚的映射SWJ使能，禁用JTAG，选择用于事件输出的GPIO端口  
36.       
37.     /*蜂鸣器*/  
38.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //# 使能被重新映射到GPIOD时钟和使能复用时钟功能  
39.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;       //#管脚号  关闭蜂鸣器  
40.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;         //#输出速度   
41.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;      //#推挽输出    
42.   GPIO_Init(GPIOD, &GPIO_InitStructure);     //#初始化   
43.     GPIO_ResetBits(GPIOD,GPIO_Pin_2);  
44. }   
45.   
46. void delay_us(u32 n)        //延时函数     
47. {     
48.     u8 j;     
49.     while(n--)     
50.             for(j=0;j<10;j++);     
51. }      
52. void  delay_ms(u32 n)       //延时函数     
53. {     
54.    while(n--)     
55.    delay_us(1000);     
56. }  
57.    
58. void GPIO_INIT(void)     
59. {       
60.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB, ENABLE);    
61.       
62.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11;  
63.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //输出速度     
64.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;     
65.         GPIO_Init(GPIOC, &GPIO_InitStructure);  //初始化     
66.        
67.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_1|GPIO_Pin_15|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14;//数码管  
68.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;       
69.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
70.         GPIO_Init(GPIOB, &GPIO_InitStructure);    
71. }     
72.     
73.   
74. void Number(int a)  //数码管显示数字  
75. {  
76.     switch(a)    
77.             {    
78.         case 0 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break;    
79.         case 1 : GPIO_ResetBits(GPIOB,GPIO_Pin_9|GPIO_Pin_12);break;    
80.         case 2 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_13|GPIO_Pin_14);break;    
81.         case 3 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_14);break;    
82.         case 4 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12);break;    
83.         case 5 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|GPIO_Pin_14);break;    
84.         case 6 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break;    
85.         case 7 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12);break;    
86.         case 8 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break;    
87.         case 9 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_14); break;    
88.             }    
89. }    
90.     
91.      
92. void Function(void)   
93. {       
94.         int i=0,j=0;          //i被按下的次数，n延时变量    
95.   
96.         GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);       
97.         delay_ms(50); //关闭数码管      
98.   
99.         while(1)    
100.         {                   
101.                 GPIO_SetBits(GPIOB,GPIO_Pin_1);         //打开个位数码管    
102.                 Number(i);                                //用switch函数显示00    
103.                 delay_ms(t);                              
104.                 GPIO_ResetBits(GPIOB,GPIO_Pin_1);        //关闭个位         
105.                 GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);    
106.   
107.                 GPIO_SetBits(GPIOB,GPIO_Pin_15);           //打开十位    
108.                 Number(j);      
109.                 delay_ms(t);    
110.                 GPIO_ResetBits(GPIOB,GPIO_Pin_15);      //关掉十位数码管       
111.                 GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);    
112.   
113.                 if(!GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_8))   //判断按键是s1否被按下    
114.                 {       
115.                     delay_ms(50);            //延时消抖    
116.                     if(!GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_8))  //再次判断按键是s1否被按下      
117.                     {     
118.                         i++;                     //按键被按下，个位+1    
119.                         if(i==10)       
120.                         {    
121.                             j++;                 
122.                             i=0;                   
123.                         }  
124.                         if(j==10)  
125.                         {  
126.                              j=0;  
127.                                                  i=0;  
128.                         }  
129.                     }  
130.                 }     
131.   
132.   
133.   
134.   
135.   
136.   
137.   
138.   
139. </pre>  
140. <p>  
141.        
142. </p>  
143. </strong>  

作业四：单号uart控制LED流水灯转速

view plaincopy to clipboardprint?

1. <strong>#include "stm32f10x.h"            
2. #include    "stdio.h"  
3.   
4. GPIO_InitTypeDef GPIO_InitStructure;        // 声明结构体  
5. NVIC_InitTypeDef  NVIC_InitStructure;    
6. USART_InitTypeDef  USART_InitStructure;    
7. USART_ClockInitTypeDef  USART_ClockInitStructure;     
8.       
9. #define buff_size  16;        
10. char rx_buff[],rx_buff_count=0;   
11.    
12. void RCC_Configuration(void) ;  
13. void GPIO_INIT(void)  ;  
14. void USART_int(long BaudRate);  
15. void USART_SendStr(char *str);  
16. void  delay_ms(u32 n)  ;  
17. void delay_us(u32 n);   
18.   
19.   
20.   
21. /****主函数 ****/  
22. int main()      
23. {                               
24.     RCC_Configuration();    
25.     GPIO_INIT();    
26.     USART_int(9600);    
27.     GPIO_ResetBits(GPIOC,0xffff);//led全亮，提示程序开始    
28.     delay_ms(200);    
29.     GPIO_SetBits(GPIOC,0xffff);//led全灭    
30.     USART_SendStr("USART Led Speed\r\n");//     
31.     USART_SendStr("\n>");//     
32.     while(1);  
33. }     
34.    
35.   
36. /****   配置RCC ****/  
37. void RCC_Configuration(void)     
38. {       
39.     ErrorStatus HSEStartUpStatus;   //  设置错误标志量  
40.     RCC_DeInit();                       //*将外设寄存器RCC重设为初始值   
41.     RCC_HSEConfig(RCC_HSE_ON);//*打开外部高速时钟晶振HSE：  
42.   HSEStartUpStatus = RCC_WaitForHSEStartUp();  //*等待外部高速时钟晶振工作：   
43.   if(HSEStartUpStatus==SUCCESS)  
44.     {  
45.         RCC_HCLKConfig(RCC_SYSCLK_Div1);//*AHB使用系统时钟,负责外部存储器的时钟   
46.         RCC_PCLK1Config(RCC_HCLK_Div2);//*APB1 负责DA,USB,SPI,I2C,CAN，串口2345，普通TIM  
47.         RCC_PCLK2Config(RCC_HCLK_Div1);//*APB2负责AD,I/O,高级TIM,串口1   
48.         RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);//*设置PLL输入时钟源72M  
49.         RCC_PLLCmd(ENABLE);//*打开PLL：            
50.         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);//*等待PLL工作：  
51.         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//*设置系统时钟  
52.         while(RCC_GetSYSCLKSource() != 0x08);//* 判断PLL是否是系统时钟：      
53.     }  
54.      GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);  
55.       
56.     /*蜂鸣器*/  
57.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);          
58.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;       
59.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;       
60.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       
61.     GPIO_Init(GPIOD, &GPIO_InitStructure);       
62.     GPIO_ResetBits(GPIOD,GPIO_Pin_2);                
63. }     
64.     
65.   
66. /****延时 ****/  
67. void delay_us(u32 n)       
68. {       
69.     u8 j;       
70.     while(n--)       
71.     for(j=0;j<10;j++);       
72. }       
73.   
74. void  delay_ms(u32 n)       
75. {       
76.    while(n--)       
77.     delay_us(1000);       
78. }   
79.   
80.   
81. /**** 初始化GPIO ****/  
82. void GPIO_INIT(void)     
83. {      
84.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);        
85.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;       
86.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;           
87.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 
88.     GPIO_Init(GPIOC, &GPIO_InitStructure);      
89. }    
90.   
91.   
92. /**** USART传输的波特率 ****/   
93. void USART_int(long BaudRate)     
94. {    
95.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);//使能PA和 usart1  
96.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                 
97.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;    
98.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出 PA9作为US1的TX端，打开复用，负责发送数据  
99.         GPIO_Init(GPIOA, &GPIO_InitStructure);    
100.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                          //RX位于PA10          
101.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;     //浮空输入，PA10作为US1的RX端，负责接收数据  
102.                                     //RX初始化PA10  
103.   
104.         USART_InitStructure.USART_BaudRate = BaudRate;//波特率  
105.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//USART_WordLength 在一个帧中传输8位数据（字节）  
106.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//停止位为一个字节  
107.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验        
108.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制   
109.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式  
110.         USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;//时钟低电平活动，开启发送接受数据功能（usart 使能）       
111.         USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;      //SCLK输出时钟低电平  
112.         USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;//时钟第二个边沿开始数据捕获        
113.         USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;//最后一位数据不从SCLK发出  
114.         USART_ClockInit(USART1, &USART_ClockInitStructure);//初始化USART1时钟  
115.         USART_Init(USART1, &USART_InitStructure);//初始化USART1  
116.         USART_Cmd(USART1, ENABLE);//USART1使能  
117.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//使能接收中断，在接受移位寄存器中有数据时产生  
118.         USART_Cmd(USART1, ENABLE);  
119.   
120.         //配置NVIC ，设置优先级分组，使用NVIC_Init对NVIC进行初始化  
121.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);//选择中断分组4(先占优先级四位，从优先级0)  
122.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //选择中断通道  
123.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//抢占优先级1-15  
124.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//响应优先级1-15  
125.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//使能中断  
126.         NVIC_Init(&NVIC_InitStructure); //初始化中断    
127.                       
128. }    
129.   
130.   
131.   
132.   
133. /**** usart发送数据 ****/  
134. void USART_SendStr(char *str)   //USART发送数据     
135. {    
136.             while((*str)!='\0')               
137.         {  
138.                     USART_SendData(USART1,*str++);  //通过外设 USARTx 发送单个数据   
139.                     while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);  //检查指定的 USART 标志位设置与否  
140.         }    
141. }    
142.     
143.   
144. /**** 取字符串中的数字 ****/  
145. unsigned int translate(char* pstr)   
146. {     
147.       int s = 0;    
148.         while(*pstr != '\0')        //如果没扫到字符串的最后不停止  
149.         {  
150.                 if(*pstr >= '0' && *pstr <= '9')  //如果字符串中存在0-9的数字  
151.                 {    
152.                         s = s * 10 + *pstr - '0';     
153.                 }    
154.                 pstr++;  
155.         }         
156.     return s;   
157. }   
158.   
159. /****  点亮led****/  
160. void LED(char *S,char LEN)     //(字符串，字符串长度)  
161. {   
162.           int m,i;  
163.         int a[8]={GPIO_Pin_0,GPIO_Pin_1,GPIO_Pin_2,GPIO_Pin_3,GPIO_Pin_4,GPIO_Pin_5,GPIO_Pin_6,GPIO_Pin_7};   
164.             m=translate(S);  
165.       
166.             GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);    
167.             delay_ms(100);            
168.             for(i=0;i<8;i++)   
169.             {  
170.                 GPIO_ResetBits(GPIOC,a[i]);    // 点亮LED  
171.                 delay_ms(m);  
172.                 GPIO_SetBits(GPIOC,a[i]);     //熄灭LED  
173.                 delay_ms(m);  
174.             }  
175. }  
176.   
177.   
178. void input_ASK()  
179. {    
180.     char j;    
181.     LED(rx_buff,rx_buff_count);  
182.     rx_buff_count=0;    
183.     for (j=0;j<rx_buff_count;j++)    
184.     {  
185.             rx_buff[j]='\0';  
186.         }//判断读入信息是否结束，如果结束则准备下一次读入    
187.     USART_SendStr("\n>");    
188. }   
189.   
190.   
191.   /****接收中断****/  
192. void USART1_IRQHandler(void)     
193. {     
194.         while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET)  { }   //判断接收中断是否打开  
195.     if(USART_ReceiveData(USART1)==0x0d)     
196.     {  
197.             input_ASK();  
198.         }    
199.     else    
200.     {    
201.             USART_SendData(USART1,USART_ReceiveData(USART1));  //将数据传回给电脑  
202.             rx_buff[rx_buff_count]= USART_ReceiveData(USART1);    
203.       rx_buff_count++;    
204.     }    
205.           
206.         USART_ClearFlag(USART1, USART_FLAG_RXNE);  //清除中断接受完成标志位  
207.     
208. }  </strong>  

 

//作业五：

#include "stm32f10x.h"  

#include "stm32_eval.h"  
#include <stdio.h>  
 
EXTI_InitTypeDef   EXTI_InitStructure;  
GPIO_InitTypeDef   GPIO_InitStructure;  
NVIC_InitTypeDef   NVIC_InitStructure;  
USART_InitTypeDef USART_InitStructure;  
USART_ClockInitTypeDef USART_ClockInitStructure;  
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;  
TIM_OCInitTypeDef  TIM_OCInitStructure;  
int count=0;  
  
void RCC_Configuration(void)  
{
  SystemInit();  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
  GPIO_Init(GPIOD, &GPIO_InitStructure);  
  GPIO_ResetBits(GPIOD,GPIO_Pin_2);  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
  GPIO_Init(GPIOC, &GPIO_InitStructure);  
  GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  
}  
  
void USART_int(long BaudRate)  
{  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);  
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;  
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
   
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
  
  USART_InitStructure.USART_BaudRate = BaudRate;
  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_ClockInitStructure.USART_Clock = USART_Clock_Disable;       
  USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;        
  USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;        
  USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;  
  USART_ClockInit(USART1, &USART_ClockInitStructure);  
  USART_Init(USART1, &USART_InitStructure);  
  USART_Cmd(USART1, ENABLE);  
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  
  USART_Cmd(USART1, ENABLE);  
}  
  
void NVIC_Configuration(void)  
{  
  NVIC_InitTypeDef NVIC_InitStructure;  
    
  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;  
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
  NVIC_Init(&NVIC_InitStructure);  
}  
  
/* Private functions ---------------------------------------------------------*/  
  

int main(void)  
{  
      
         
  RCC_Configuration();  
  
  NVIC_Configuration();  

  TIM_TimeBaseStructure.TIM_Period = 36000;  
  TIM_TimeBaseStructure.TIM_Prescaler = 100;  
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;  
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);  
  TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE );   
    
  TIM_Cmd(TIM2, ENABLE);  
  
  while (1){  
   }    
  }  
  
void TIM2_IRQHandler(void) //TIM3  
{  
if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)   
{  
TIM_ClearITPendingBit(TIM2, TIM_IT_Update );  

    count++;  
    GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);  
        if(count==1)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_0);  
    if(count==2)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_1);  
    if(count==3)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_2);  
    if(count==4)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_3);  
    if(count==5)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_4);  
    if(count==6)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_5);  
    if(count==7)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_6);  
    if(count==8)   
    GPIO_ResetBits(GPIOC,GPIO_Pin_7);  
    if(count==9)  
    count=0;  
}  
}  
  
  
#ifdef  USE_FULL_ASSERT  
  

void assert_failed(uint8_t* file, uint32_t line)  
{   
 
  while (1)  
  {  
  }  
}  
  
#endif  
  
  
#ifdef __GNUC__  
 
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  
#else  
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)  
#endif /* __GNUC__ */  
    
  
 
PUTCHAR_PROTOTYPE  
{  
 
  USART_SendData(EVAL_COM1, (uint8_t) ch);  
  
  while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)  
  {}  
  
  return ch;  
}  
  
#ifdef  USE_FULL_ASSERT  
  
void assert_failed(uint8_t* file, uint32_t line)  
{   
  
  while (1)  
  {  
  }  
}  
  
#endif  

//定时器 5 通道 1 输入捕获配置

TIM_ICInitTypeDef TIM5_ICInitStructure;

void TIM5_Cap_Init(u16 arr,u16 psc)

{ 

GPIO_InitTypeDef GPIO_InitStructure;

TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

NVIC_InitTypeDef NVIC_InitStructure;

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE); //①使能 TIM5 时钟

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //①使能 GPIOA 时钟

//初始化 GPIOA.0 ①

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //PA0 设置

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0 输入

GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化 GPIOA.0

GPIO_ResetBits(GPIOA,GPIO_Pin_0);  //PA0 下拉

//②初始化 TIM5 参数

TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值

TIM_TimeBaseStructure.TIM_Prescaler =psc; //预分频器

TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // TDTS = Tck_tim

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //TIM 向上计数模式

TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure); //初始化 TIMx

//③初始化 TIM5 输入捕获通道 1

TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1; //选择输入端 IC1 映射到 TI1 上

TIM5_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;  //上升沿捕获

TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到 TI1 上

TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1; //配置输入分频,不分频

TIM5_ICInitStructure.TIM_ICFilter = 0x00; //IC1F=0000 配置输入滤波器 不滤波

TIM_ICInit(TIM5, &TIM5_ICInitStructure); //初始化 TIM5 输入捕获通道 1

//⑤初始化 NVIC 中断优先级分组

NVIC_InitStructure.NVIC_IRQChannel = TIM5_IRQn; //TIM3 中断

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //先占优先级 2 级

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //从优先级 0 级

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ 通道被使能

NVIC_Init(&NVIC_InitStructure); //初始化 NVIC

TIM_ITConfig( TIM5,TIM_IT_Update|TIM_IT_CC1,ENABLE);//④允许更新中断捕获中断

TIM_Cmd(TIM5,ENABLE ); //⑥使能定时器 5

}

u8 TIM5CH1_CAPTURE_STA=0;  //输入捕获状态 

u16 TIM5CH1_CAPTURE_VAL; //输入捕获值

//⑤定时器 5 中断服务程序

void TIM5_IRQHandler(void)

{

if((TIM5CH1_CAPTURE_STA&0X80)==0)//还未成功捕获

{ 

if (TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)

{ 

if(TIM5CH1_CAPTURE_STA&0X40) //已经捕获到高电平了

{

if((TIM5CH1_CAPTURE_STA&0X3F)==0X3F)//高电平太长了

{

TIM5CH1_CAPTURE_STA|=0X80; //标记成功捕获了一次

TIM5CH1_CAPTURE_VAL=0XFFFF;

}else TIM5CH1_CAPTURE_STA++;

   } 

}

if (TIM_GetITStatus(TIM5, TIM_IT_CC1) != RESET) //捕获 1 发生捕获事件

{ 

if(TIM5CH1_CAPTURE_STA&0X40) //捕获到一个下降沿

{ 

TIM5CH1_CAPTURE_STA|=0X80;  //标记成功捕获到一次上升沿

TIM5CH1_CAPTURE_VAL=TIM_GetCapture1(TIM5);

TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Rising); //设置为上升沿捕获

}else //还未开始,第一次捕获上升沿

{

TIM5CH1_CAPTURE_STA=0;  //清空

TIM5CH1_CAPTURE_VAL=0;

TIM_SetCounter(TIM5,0);

TIM5CH1_CAPTURE_STA|=0X40;  //标记捕获到了上升沿

TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Falling); //设置为下降沿捕获

   } 

  } 

 }

TIM_ClearITPendingBit(TIM5, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位

}

//timer.h

extern u8 TIM5CH1_CAPTURE_STA;  //输入捕获状态 

extern u16  TIM5CH1_CAPTURE_VAL; //输入捕获值

int main(void)

{

u32 temp=0;

delay_init();  //延时函数初始化

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置 NVIC 中断分组 2

uart_init(115200); //串口初始化波特率为 115200

LED_Init();  //LED 端口初始化

TIM3_PWM_Init(899,0); //不分频。PWM 频率=72000/(899+1)=80Khz

TIM5_Cap_Init(0XFFFF,72-1);  //以 1Mhz 的频率计数

while(1)

{

delay_ms(10);

TIM_SetCompare2(TIM3,TIM_GetCapture2(TIM3)+1);

if(TIM_GetCapture2(TIM3)==300)

TIM_SetCompare2(TIM3,0);

if(TIM5CH1_CAPTURE_STA&0X80)//成功捕获到了一次上升沿

{

temp=TIM5CH1_CAPTURE_STA&0X3F;

temp*=65536;//溢出时间总和

temp+=TIM5CH1_CAPTURE_VAL;//得到总的高电平时间

printf("HIGH:%d us\r\n",temp); //打印总的高点平时间

TIM5CH1_CAPTURE_STA=0; //开启下一次捕获

       }

   }

 }

1. //ADC改变灯的颜色：
2. #include "stm32f10x.h"    
3. #include "stm32_eval.h"    
4. #include <stdio.h>    
5. #define VREF 3.3    
6. GPIO_InitTypeDef   GPIO_InitStructure;    
7. USART_InitTypeDef USART_InitStructure;    
8. USART_ClockInitTypeDef USART_ClockInitStructure;    
9. int volt;    
10. unsigned int temp0,temp1,temp2;    
11. void RCC_Configuration(void)    
12. {/*  
13.   RCC_DeInit();  
14.       
15.   RCC_HSICmd(ENABLE);  
16.   while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);  
17.     
18.   RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);  
19.     
20.   RCC_HSEConfig(RCC_HSE_OFF);  
21.   RCC_LSEConfig(RCC_LSE_OFF);  
22.   RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz  
23.   RCC_PLLCmd(ENABLE);  
24.   while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);  
25.   RCC_ADCCLKConfig(RCC_PCLK2_Div4);  
26.   RCC_PCLK2Config(RCC_HCLK_Div1);  
27.   RCC_PCLK1Config(RCC_HCLK_Div2);  
28.   RCC_HCLKConfig(RCC_SYSCLK_Div1);  
29.   RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);  
30.   while(RCC_GetSYSCLKSource() != 0x08);  
31. */    
32.     SystemInit();    
33.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);    
34.  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
35. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);    
36.  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
37.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;    
38.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
39.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
40.   GPIO_Init(GPIOD, &GPIO_InitStructure);    
41.     GPIO_ResetBits(GPIOD,GPIO_Pin_2);    
42.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);    
43.  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
44.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;    
45.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
46.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
47.   GPIO_Init(GPIOC, &GPIO_InitStructure);    
48.     GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);    
49.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);    
50. }     
51.     
52. void USART_int(long BaudRate)    
53. {    
54.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);    
55.        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;    
56.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;    
57.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     
58.     GPIO_Init(GPIOA, &GPIO_InitStructure);    
59.     /* PA10 USART1_Rx  */    
60.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;    
61.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    
62.     GPIO_Init(GPIOA, &GPIO_InitStructure);    
63.   /* USARTx configured as follow:  
64.         - BaudRate = 115200 baud    
65.         - Word Length = 8 Bits  
66.         - One Stop Bit  
67.         - No parity  
68.         - Hardware flow control disabled (RTS and CTS signals)  
69.         - Receive and transmit enabled  
70.   */    
71.   USART_InitStructure.USART_BaudRate = BaudRate;   
72.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;   
73.   USART_InitStructure.USART_StopBits = USART_StopBits_1;    
74.   USART_InitStructure.USART_Parity = USART_Parity_No;    
75.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    
76.     USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;         
77.     USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;          
78.     USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;          
79.     USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;    
80.     USART_ClockInit(USART1, &USART_ClockInitStructure);    
81.   USART_Init(USART1, &USART_InitStructure);    
82.   USART_Cmd(USART1, ENABLE);    
83.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);    
84.  USART_Cmd(USART1, ENABLE);    
85. }    
86. void delay_us(u32 n)    
87. {    
88.     u8 j;    
89.     while(n--)    
90.     for(j=0;j<10;j++);    
91. }    
92. void  delay_ms(u32 n)    
93. {    
94.     while(n--)    
95.     delay_us(1000);    
96. }    
97. void PWM_Config()    
98. {    
99.     uint16_t PrescalerValue = 0;    
100.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;    
101.   TIM_OCInitTypeDef  TIM_OCInitStructure;    
102.     /* TIM2 clock enable */    
103.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);    
104.   /* GPIOA  enable */    
105.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);    
106.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;//PWM&RGB- PA1 PA2 PA3    
107.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    
108.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
109.   GPIO_Init(GPIOA, &GPIO_InitStructure);    
110.         TIM_Cmd(TIM2, ENABLE);    
111.       /* Compute the prescaler value */    
112.   PrescalerValue = (uint16_t) (SystemCoreClock / 24000000) - 1;    
113.   /* Time base configuration */    
114.   TIM_TimeBaseStructure.TIM_Period = 0x07FF;    
115.   TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;    
116.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;    
117.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;    
118.   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);    
119.   TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;    
120.   TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;    
121.   /* PWM1 Mode configuration: Channel2 ,PA1在通道2*/    
122.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;    
123.   TIM_OCInitStructure.TIM_Pulse = 0xFFFF;    
124.   TIM_OC2Init(TIM2, &TIM_OCInitStructure);    
125.     /* PWM1 Mode configuration: Channel3 PA2在通道3*/    
126.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;    
127.   TIM_OCInitStructure.TIM_Pulse = 0xFFFF;    
128.   TIM_OC3Init(TIM2, &TIM_OCInitStructure);    
129.     /* PWM1 Mode configuration: Channel4 PA3在通道4*/    
130.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;    
131.   TIM_OCInitStructure.TIM_Pulse = 0xFFFF;    
132.   TIM_OC4Init(TIM2, &TIM_OCInitStructure);    
133.   TIM_ARRPreloadConfig(TIM2, ENABLE);    
134. }    
135. void ADC_CONFIG(){    
136.     ADC_InitTypeDef ADC_InitStructure;    
137.     #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)    
138.   /* ADCCLK = PCLK2/2 */    
139.   RCC_ADCCLKConfig(RCC_PCLK2_Div2);     
140. #else    
141.   /* ADCCLK = PCLK2/4 */    
142.   RCC_ADCCLKConfig(RCC_PCLK2_Div4);     
143. #endif    
144. ADC_DeInit(ADC1);    
145.   /* Enable ADC1 and GPIOC clock */    
146.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE);    
147.     /* Configure PB0 (ADC Channel14) as analog input -------------------------*/    
148.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;//ADC所在端口PB0    
149.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;//模拟输入模式    
150.   GPIO_Init(GPIOB, &GPIO_InitStructure);    
151.   /* ADC1 configuration ------------------------------------------------------*/    
152.   ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;    
153.   ADC_InitStructure.ADC_ScanConvMode = ENABLE;    
154.   ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;    
155.   ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;    
156.   ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;//ADC数据右对齐    
157.   ADC_InitStructure.ADC_NbrOfChannel = 1;//ADC通道数为1    
158.   ADC_Init(ADC1, &ADC_InitStructure);//初始化ADC1    
159.   /* Enable ADC1 DMA */    
160.   ADC_DMACmd(ADC1, ENABLE);    
161.   /* Enable ADC1 */    
162.   ADC_Cmd(ADC1, ENABLE);    
163. }    
164.     
165. int Get_ADC(){    
166.      /* ADC1 regular channel configuration */     
167.   ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_55Cycles5);//通道：8 ，采样时间    
168.     /* Enable ADC1 reset calibration register */       
169.   ADC_ResetCalibration(ADC1);//重置ADC1的校准寄存器    
170.   /* Check the end of ADC1 reset calibration register */    
171.   while(ADC_GetResetCalibrationStatus(ADC1));//确认重置完毕    
172.   /* Start ADC1 calibration */    
173.   ADC_StartCalibration(ADC1);    
174.   /* Check the end of ADC1 calibration */    
175.   while(ADC_GetCalibrationStatus(ADC1));    
176.   /* Start ADC1 Software Conversion */     
177.   ADC_SoftwareStartConvCmd(ADC1, ENABLE);  
178.     return ADC_GetConversionValue(ADC1);    
179. }    
180. void PWM_TEST()    
181. {    
182.      
183.     unsigned int temp0=volt,temp1=0,temp2=volt;    
184.     printf("PWM-RGB TEST......\r\n");    
185.    for(;(temp0>0)||(temp1<volt);temp0--,temp1++)     
186.    {    
187.        TIM_SetCompare2(TIM2, temp0);//temp0:volt~0    
188.      TIM_SetCompare3(TIM2, temp1);//temp1:0~volt    
189.        delay_us(1000);    
190.    }    
191.      for(;(temp0<volt)||(temp2>0);temp0++,temp2--)    
192.      {    
193.        TIM_SetCompare2(TIM2, temp0);//temp0:0~volt    
194.        TIM_SetCompare4(TIM2, temp2);//temp2:volt~0    
195.        delay_us(1000);    
196.    }    
197.    for(;(temp1>0)||(temp2<volt);temp1--,temp2++)  
198.    {    
199.        TIM_SetCompare4(TIM2, temp2);//temp2:0~volt    
200.        TIM_SetCompare3(TIM2, temp1);//temp1:volt~0    
201.        delay_us(1000);    
202.    }    
203. }    
204. int main(void)    
205. {    
206.   float Volt=0.00;    
207.     int ADValue = 0;    
208.   RCC_Configuration();    
209.   USART_int(115200);    
210.     ADC_CONFIG();    
211.     Get_ADC();    
212.     PWM_Config();    
213.     delay_ms(1000);    
214.     printf(" config done...\r\n");    
215.     while(1)    
216.     {    
217.         ADValue = Get_ADC();    
218.         Volt = VREF*ADValue/4095;    
219.         volt=Volt*1000;    
220.         printf("===============================\r\n");    
221.         printf("The ADC value is:%d\r\n",ADValue);    
222.         printf("The Volt is:%f V\r\n",Volt);    
223.         printf("The volt is:%d \r\n",volt);    
224.         PWM_TEST();    
225.         delay_ms(500);    
226.     }    
227. }    
228.     
229. #ifdef  USE_FULL_ASSERT    
230.     
231. void assert_failed(uint8_t* file, uint32_t line)    
232. {     
233.   while (1)    
234.   {    
235.   }    
236. }    
237.     
238. #endif    
239.     
240. #ifdef __GNUC__    
241.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)    
242. #else    
243.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)    
244. #endif /* __GNUC__ */    
245.       
246. PUTCHAR_PROTOTYPE    
247. {    
248.     
249.   USART_SendData(EVAL_COM1, (uint8_t) ch);    
250.   while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)    
251.   {}    
252.     
253.   return ch;    
254. }    
255.     
256. #ifdef  USE_FULL_ASSERT    
257.     
258. void assert_failed(uint8_t* file, uint32_t line)    
259. {     
260.   while (1)    
261.   {    
262.   }    
263. }    
264. #endif