网站首页
这些小活动你都参加了吗？快来围观一下吧！>>
电子产品世界 » 论坛首页 » 高校专区 » 漓东e学堂 » 13号作业

共6条 1/1 1 跳转至页

13号作业

战狼
菜鸟
2016-01-03 16:33:27     打赏

第一次：http://forum.eepw.com.cn/thread/278858/1#1

第二次：http://forum.eepw.com.cn/thread/278858/1#2

第三次：http://forum.eepw.com.cn/thread/278858/1#3

第四次：http://forum.eepw.com.cn/thread/278858/1#4

第五次：http://forum.eepw.com.cn/thread/278858/1#5

第六次：http://forum.eepw.com.cn/thread/278858/1#6









回复
收藏
0


战狼
菜鸟
2016-01-03 16:42:56     打赏
2楼

作业二：

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);
}
}

评论
战狼
菜鸟
2016-01-03 16:44:04     打赏
3楼

按键计数：

#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;
}
}
}

}}


评论
战狼
菜鸟
2016-01-03 16:46:38     打赏
4楼

作业四：

#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); 
}


评论
战狼
菜鸟
2016-01-19 16:19:13     打赏
5楼
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****/

评论
战狼
菜鸟
2016-01-19 16:20:42     打赏
6楼
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 

评论
共6条 1/1 1 跳转至页

回复

匿名不能发帖！请先 [ 登陆 注册 ]