EEPW论坛

作业二：

int main(void)

{ 
RCC_Configuration();
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)
{
GPIO_ResetBits(GPIOC,GPIO_Pin_0);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_0);

GPIO_ResetBits(GPIOC,GPIO_Pin_1);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_1);

GPIO_ResetBits(GPIOC,GPIO_Pin_2);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_2);

GPIO_ResetBits(GPIOC,GPIO_Pin_3);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_3);

GPIO_ResetBits(GPIOC,GPIO_Pin_4);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_4);

GPIO_ResetBits(GPIOC,GPIO_Pin_5);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_5);

GPIO_ResetBits(GPIOC,GPIO_Pin_6);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_6);

GPIO_ResetBits(GPIOC,GPIO_Pin_7);
delay_ms(50);
GPIO_SetBits(GPIOC,GPIO_Pin_7);
}
}

按键计数：

#include "stm32f10x.h" 
#include "stm32f10x_rcc.h" 
GPIO_InitTypeDef GPIO_InitStructure;
void RCC_Configuration(void); 
void GPIO_INIT(void) ;
void Function(void) ;

int main(void)
{ 
RCC_Configuration(); 
GPIO_INIT();
Function(); 
} 
void RCC_Configuration(void) 
{ 
ErrorStatus HSEStartUpStatus; 
RCC_DeInit(); 
RCC_HSEConfig(RCC_HSE_ON);
HSEStartUpStatus = RCC_WaitForHSEStartUp(); 
if(HSEStartUpStatus==SUCCESS)
{
RCC_HCLKConfig(RCC_SYSCLK_Div1);
RCC_PCLK1Config(RCC_HCLK_Div2);
RCC_PCLK2Config(RCC_HCLK_Div1);
//RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);
RCC_PLLCmd(ENABLE); 
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
while(RCC_GetSYSCLKSource() != 0x08); 
}
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); 
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(50); 
}
void GPIO_INIT(void) 
{ 
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB, ENABLE); 
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 
GPIO_Init(GPIOC, &GPIO_InitStructure); 
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;//???
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure); 
}

void Number(int a) 
{
switch(a) 
{ 
case 0 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break; 
case 1 : GPIO_ResetBits(GPIOB,GPIO_Pin_9|GPIO_Pin_12);break; 
case 2 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_13|GPIO_Pin_14);break; 
case 3 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_14);break; 
case 4 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12);break; 
case 5 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|GPIO_Pin_14);break; 
case 6 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break; 
case 7 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12);break; 
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; 
case 9 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_14); break; 
} 
} 

void Function(void) 
{ 
int i=0,j=0;

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); 
delay_ms(50);

while(1) 
{ 
GPIO_SetBits(GPIOB,GPIO_Pin_1); 
Number(i); 
delay_ms(200); 
GPIO_ResetBits(GPIOB,GPIO_Pin_1); 
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);

GPIO_SetBits(GPIOB,GPIO_Pin_15); 
Number(j); 
delay_ms(200); 
GPIO_ResetBits(GPIOB,GPIO_Pin_15); 
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);

if(!GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_8)) 
{ 
delay_ms(100); 
if(!GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_8)) 
{ 
i++; 
if(i==10) 
{ 
j++; 
i=0; 
}
if(j==10)
{
j=0;
i=0;
}
}
}

}}

作业四：

#include "stm32f10x.h" 
#include "stdio.h" 
GPIO_InitTypeDef GPIO_InitStructure; 
NVIC_InitTypeDef NVIC_InitStructure; 
USART_InitTypeDef USART_InitStructure; 
USART_ClockInitTypeDef USART_ClockInitStructure; 
#define buff_size 16; 
char rx_buff[],rx_buff_count=0; 
void RCC_Configuration(void) ; 
void GPIO_INIT(void) ; 
void USART_int(long BaudRate); 
void USART_SendStr(char *str); 
void delay_ms(u32 n) ; 
void delay_us(u32 n); 
/****??? ****/ 
int main() 
{ 
RCC_Configuration(); 
GPIO_INIT(); 
USART_int(9600); 
GPIO_ResetBits(GPIOC,0xffff);
delay_ms(200); 
GPIO_SetBits(GPIOC,0xffff);
USART_SendStr("USART Led Speed\r\n"); 
USART_SendStr("\n>");// 
while(1); 
}

void RCC_Configuration(void) 
{ 
ErrorStatus HSEStartUpStatus; 
RCC_DeInit(); 
RCC_HSEConfig(RCC_HSE_ON);
HSEStartUpStatus = RCC_WaitForHSEStartUp(); 
if(HSEStartUpStatus==SUCCESS) 
{ 
RCC_HCLKConfig(RCC_SYSCLK_Div1);
RCC_PCLK1Config(RCC_HCLK_Div2);
RCC_PCLK2Config(RCC_HCLK_Div1);
//RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);//*??PLL?????72M 
RCC_PLLCmd(ENABLE);
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
while(RCC_GetSYSCLKSource() != 0x08);
} 
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); 
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); 
}

void GPIO_INIT(void) 
{ 
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); 
}

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; 
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); 
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; 
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure); 
}

void USART_SendStr(char *str) 
{ 
while((*str)!='\0') 
{ 
USART_SendData(USART1,*str++); 
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); 
} 
}

unsigned int translate(char* pstr) 
{ 
int s = 0; 
while(*pstr != '\0') 
{ 
if(*pstr >= '0' && *pstr <= '9') 
{ 
s = s * 10 + *pstr - '0'; 
} 
pstr++; 
} 
return s; 
} 
void LED(char *S,char LEN) 
{ 
int m,i; 
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}; 
m=translate(S); 
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(100); 
for(i=0;i<8;i++) 
{ 
GPIO_ResetBits(GPIOC,a[i]); 
delay_ms(m); 
GPIO_SetBits(GPIOC,a[i]); 
delay_ms(m); 
} 
} 
void input_ASK() 
{ 
char j; 
LED(rx_buff,rx_buff_count); 
rx_buff_count=0; 
for (j=0;j<10;j++)
{ 
rx_buff[j]='\0'; 
}
USART_SendStr("\n>"); 
}

void USART1_IRQHandler(void) 
{ 
while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET) { } 
if(USART_ReceiveData(USART1)==0x0d) 
{ 
input_ASK(); 
} 
else 
{ 
USART_SendData(USART1,USART_ReceiveData(USART1));
rx_buff[rx_buff_count]= USART_ReceiveData(USART1); 
rx_buff_count++; 
} 
USART_ClearFlag(USART1, USART_FLAG_RXNE); 
}

view plaincopy to clipboardprint?

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

 

评论 yinyin93 菜鸟 2015-12-01 16:38:39    评分 6楼 view plaincopy to clipboardprint?

1. #include "stm32f10x.h"  
2. #include "stm32_eval.h"  
3. #include <stdio.h>  
4. /** @addtogroup STM32F10x_StdPeriph_Examples 
5.   * @{ 
6.   */  
7.   
8. /** @addtogroup EXTI_Config 
9.   * @{ 
10.   */   
11.   
12. /* Private typedef -----------------------------------------------------------*/  
13. /* Private define ------------------------------------------------------------*/  
14. /* Private macro -------------------------------------------------------------*/  
15. /* Private variables ---------------------------------------------------------*/  
16. EXTI_InitTypeDef   EXTI_InitStructure;  
17. GPIO_InitTypeDef   GPIO_InitStructure;  
18. NVIC_InitTypeDef   NVIC_InitStructure;  
19. USART_InitTypeDef USART_InitStructure;  
20. USART_ClockInitTypeDef USART_ClockInitStructure;  
21. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;  
22. TIM_OCInitTypeDef  TIM_OCInitStructure;  
23. int count=0;  
24.   
25. void RCC_Configuration(void)  
26. {/* 
27.   RCC_DeInit(); 
28.   RCC_HSICmd(ENABLE); 
29.   while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET); 
30.   RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI); 
31.   RCC_HSEConfig(RCC_HSE_OFF); 
32.   RCC_LSEConfig(RCC_LSE_OFF); 
33.   RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz 
34.   RCC_PLLCmd(ENABLE); 
35.   while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET); 
36.   RCC_ADCCLKConfig(RCC_PCLK2_Div4); 
37.   RCC_PCLK2Config(RCC_HCLK_Div1); 
38.   RCC_PCLK1Config(RCC_HCLK_Div2); 
39.   RCC_HCLKConfig(RCC_SYSCLK_Div1); 
40.   RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); 
41.   while(RCC_GetSYSCLKSource() != 0x08); 
42. */  
43.   SystemInit();  
44.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
45.   GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
46.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
47.   GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
48.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;  
49.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
50.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
51.   GPIO_Init(GPIOD, &GPIO_InitStructure);  
52.   GPIO_ResetBits(GPIOD,GPIO_Pin_2);  
53.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);  
54.   GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
55.   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;  
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
58.   GPIO_Init(GPIOC, &GPIO_InitStructure);  
59.   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);  
60.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  
61. }  
62.   
63. void USART_int(long BaudRate)  
64. {  
65.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);  
66.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;  
67.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;  
68.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   
69.     GPIO_Init(GPIOA, &GPIO_InitStructure);  
70.     /* PA10 USART1_Rx  */  
71.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  
72.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
73.     GPIO_Init(GPIOA, &GPIO_InitStructure);  
74.   /* USARTx configured as follow: 
75.         - BaudRate = 115200 baud   
76.         - Word Length = 8 Bits 
77.         - One Stop Bit 
78.         - No parity 
79.         - Hardware flow control disabled (RTS and CTS signals) 
80.         - Receive and transmit enabled 
81.   */  
82.   USART_InitStructure.USART_BaudRate = BaudRate;//??????  
83.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;//???????8bit  
84.   USART_InitStructure.USART_StopBits = USART_StopBits_1;//????1  
85.   USART_InitStructure.USART_Parity = USART_Parity_No;//????  
86.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//??????none  
87.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//??????????  
88.   USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;       
89.   USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;        
90.   USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;        
91.   USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;  
92.   USART_ClockInit(USART1, &USART_ClockInitStructure);  
93.   USART_Init(USART1, &USART_InitStructure);  
94.   USART_Cmd(USART1, ENABLE);  
95.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  
96.   USART_Cmd(USART1, ENABLE);  
97. }  
98.   
99. void NVIC_Configuration(void)  
100. {  
101.   NVIC_InitTypeDef NVIC_InitStructure;  
102.   
103.   /* Enable the TIM2 global Interrupt */  
104.   NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;  
105.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
106.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  
107.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
108.   NVIC_Init(&NVIC_InitStructure);  
109. }  
110.   
111. /* Private functions ---------------------------------------------------------*/  
112.   
113. /** 
114.   * @brief  Main program. 
115.   * @param  None 
116.   * @retval None 
117.   */  
118. int main(void)  
119. {  
120.   /*!< At this stage the microcontroller clock setting is already configured,  
121.        this is done through SystemInit() function which is called from startup 
122.        file (startup_stm32f10x_xx.s) before to branch to application main. 
123.        To reconfigure the default setting of SystemInit() function, refer to 
124.        system_stm32f10x.c file 
125.      */       
126.          
127.   /* System Clocks Configuration */  
128.   RCC_Configuration();  
129.   
130.   NVIC_Configuration();  
131. //USART_int(115200);  
132. //  printf("config done...\r\n");  
133.   
134.   /* Time base configuration */  
135.   TIM_TimeBaseStructure.TIM_Period = 36000;  
136.   TIM_TimeBaseStructure.TIM_Prescaler = 100;  
137.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;  
138.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  
139.   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);  
140.   TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE );   
141.     
142.   /* TIM2 enable counter */  
143.   TIM_Cmd(TIM2, ENABLE);  
144.   
145.   while (1){  
146. //if(flag == 1)  
147. //  {printf("TIM2 interrupt......\r\n");  
148. //flag = 0;  
149. }  
150. //else{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);}  
151. //}  
152. }  
153.   
154. void TIM2_IRQHandler(void) //TIM3  
155. {  
156. if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)   
157. {  
158. TIM_ClearITPendingBit(TIM2, TIM_IT_Update );  
159. //  flag = ~flag;     
160. //  if(flag){  
161. //  GPIO_SetBits(GPIOC,GPIO_Pin_1);}  
162. //  else {GPIO_ResetBits(GPIOC,GPIO_Pin_1);}  
163. /*flag++; 
164.     if(flag == 50) 
165.         {led = ~led; 
166.          flag = 0;} 
167.     if(led){ 
168.     GPIO_SetBits(GPIOC,GPIO_Pin_1);} 
169.     else {GPIO_ResetBits(GPIOC,GPIO_Pin_1);}*/  
170.     count++;  
171.     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);  
172.         if(count==1)   
173.     GPIO_ResetBits(GPIOC,GPIO_Pin_0);  
174.     if(count==2)   
175.     GPIO_ResetBits(GPIOC,GPIO_Pin_1);  
176.     if(count==3)   
177.     GPIO_ResetBits(GPIOC,GPIO_Pin_2);  
178.     if(count==4)   
179.     GPIO_ResetBits(GPIOC,GPIO_Pin_3);  
180.     if(count==5)   
181.     GPIO_ResetBits(GPIOC,GPIO_Pin_4);  
182.     if(count==6)   
183.     GPIO_ResetBits(GPIOC,GPIO_Pin_5);  
184.     if(count==7)   
185.     GPIO_ResetBits(GPIOC,GPIO_Pin_6);  
186.     if(count==8)   
187.     GPIO_ResetBits(GPIOC,GPIO_Pin_7);  
188.     if(count==9)  
189.     count=0;  
190. }  
191. }  
192.   
193.   
194. #ifdef  USE_FULL_ASSERT  
195.   
196. /** 
197.   * @brief  Reports the name of the source file and the source line number 
198.   *         where the assert_param error has occurred. 
199.   * @param  file: pointer to the source file name 
200.   * @param  line: assert_param error line source number 
201.   * @retval None 
202.   */  
203. void assert_failed(uint8_t* file, uint32_t line)  
204. {   
205.   /* User can add his own implementation to report the file name and line number, 
206.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */  
207.   
208.   /* Infinite loop */  
209.   while (1)  
210.   {  
211.   }  
212. }  
213.   
214. #endif  
215.   
216. /** 
217.   * @} 
218.   */   
219.   
220. /** 
221.   * @} 
222.   */   
223.   
224. #ifdef __GNUC__  
225.   /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf 
226.      set to 'Yes') calls __io_putchar() */  
227. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  
228. #else  
229. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)  
230. #endif /* __GNUC__ */  
231.     
232.   
233.   
234. /** 
235.   * @brief  Retargets the C library printf function to the USART. 
236.   * @param  None 
237.   * @retval None 
238.   */  
239. PUTCHAR_PROTOTYPE  
240. {  
241.   /* Place your implementation of fputc here */  
242.   /* e.g. write a character to the USART */  
243.   USART_SendData(EVAL_COM1, (uint8_t) ch);  
244.   
245.   /* Loop until the end of transmission */  
246.   while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)  
247.   {}  
248.   
249.   return ch;  
250. }  
251.   
252. #ifdef  USE_FULL_ASSERT  
253.   
254. /** 
255.   * @brief  Reports the name of the source file and the source line number 
256.   *         where the assert_param error has occurred. 
257.   * @param  file: pointer to the source file name 
258.   * @param  line: assert_param error line source number 
259.   * @retval None 
260.   */  
261. void assert_failed(uint8_t* file, uint32_t line)  
262. {   
263.   /* User can add his own implementation to report the file name and line number, 
264.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */  
265.   
266.   /* Infinite loop */  
267.   while (1)  
268.   {  
269.   }  
270. }  
271.   
272. #endif  
273.   
274. /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

view plaincopy to clipboardprint?

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