EEPW论坛

---

和谐好，打开就可以用

  ******************************************************************************
   * @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)
 { unsigned char flag=0;

 RCC_Configuration();

 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
   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_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_SetBits(GPIOC,GPIO_Pin_0);
 GPIO_SetBits(GPIOC,GPIO_Pin_1);
 GPIO_SetBits(GPIOC,GPIO_Pin_2);
 GPIO_SetBits(GPIOC,GPIO_Pin_3);
 GPIO_SetBits(GPIOC,GPIO_Pin_4);
 GPIO_SetBits(GPIOC,GPIO_Pin_5);
 GPIO_SetBits(GPIOC,GPIO_Pin_6);
 GPIO_SetBits(GPIOC,GPIO_Pin_7);

 
  delay_ms(100);
     GPIO_ResetBits(GPIOC,GPIO_Pin_0);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_0);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_1);
 delay_ms(100);
     GPIO_SetBits(GPIOC,GPIO_Pin_1);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_2);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_2);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_3);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_3);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_4);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_4);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_5);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_5);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_6);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_6);
 delay_ms(100);
 GPIO_ResetBits(GPIOC,GPIO_Pin_7);
 delay_ms(100);
 GPIO_SetBits(GPIOC,GPIO_Pin_7);
 delay_ms(100);

 }
 }

01.#include "stm32f10x.h"
02.#include "stm32_eval.h"
03.#include    "stdio.h"
04.#include "math.h"
05.#define buff_size  16;
06.char rx_buff[], rx_buff_count=0;
07.
08.GPIO_InitTypeDef  GPIO_InitStructure;
09.USART_InitTypeDef  USART_InitStructure;
10.NVIC_InitTypeDef  NVIC_InitStructure;
11.USART_ClockInitTypeDef  USART_ClockInitStructure;
12.
13.void RCC_Configuration(void) a
14.{
15.    RCC_DeInit();
16.    RCC_HSICmd(ENABLE);
17.    while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
18.    RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
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.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);
31.    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG
32.    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
33.    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
34.    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
35.    GPIO_Init(GPIOD, &GPIO_InitStructure);
36.    GPIO_ResetBits(GPIOD,GPIO_Pin_2);//关闭蜂鸣器
37.}
38.void GPIO_INIT()
39.{
40.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能PC时钟
41.    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|
42.
43.GPIO_Pin_9|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
44.    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
45.    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
46.    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化PB
47.   GPIO_SetBits(GPIOB, GPIO_Pin_1|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|
48.
49.GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);
50.}
51.
52.void USART_int(long BaudRate)
53.{   USART_InitTypeDef USART_InitStructure;
54.    USART_ClockInitTypeDef USART_ClockInitStructure;
55.     NVIC_InitTypeDef NVIC_InitStructure;
56.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);//使能PA
57.
58.USART1
59.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;//TX 位于PA9
60.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
61.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //推挽输出
62.   GPIO_Init(GPIOA, &GPIO_InitStructure);// TX初始化 PA9
63.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;// RX位于PA10
64.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//悬空输入
65.   GPIO_Init(GPIOA, &GPIO_InitStructure);//RX初始化 PA10
66.  /* USARTx configured as follow:
67.        - BaudRate = 115200 baud
68.        - Word Length = 8 Bits
69.        - One Stop Bit
70.        - No parity
71.        - Hardware flow control disabled (RTS and CTS signals)
72.        - Receive and transmit enabled
73.  */
74.    USART_InitStructure.USART_BaudRate = BaudRate;//传输速率
75.    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长8比特
76.    USART_InitStructure.USART_StopBits = USART_StopBits_1;//停止位1
77.    USART_InitStructure.USART_Parity = USART_Parity_No;//
78.    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//流控位
79.
80.为none
81.    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;// 接受和发送
82.    USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
83.  USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
84.  USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
85.  USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
86.    USART_ClockInit(USART1, &USART_ClockInitStructure);//初始化USART1时钟
87.    USART_Init(USART1, &USART_InitStructure);//初始化USART1时钟
88.    USART_Cmd(USART1, ENABLE);
89.    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
90.    USART_Cmd(USART1, ENABLE);
91.  /* Configure four bit for preemption priority */
92.    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
93.  /* Enable the USART1 Interrupt */
94.    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; //选择USART1中断通道
95.    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 15;
96.    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
97.    NVIC_Init(&NVIC_InitStructure);//初始化中断
98.}
99.
100. /*微秒延时函数*/
101. void delay_us(u32 n)
102.{
103.    u8 j;
104.    while(n--)
105.    for(j=0;j<10;j++);
106.}
107.
108./*毫秒延时函数*/
109.void  delay_ms(u32 n)
110.{
111.   while(n--)
112.    delay_us(1000);
113.}
114.
115.void USART_SendStr(char *str)      //发送字符串函数
116.{
117.   while((*str)!='\0')             //发送完直至最后
118.        {USART_SendData(USART1,*str++);
119.        while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
120.        }
121.unsigned int translate(char* pstr) //字符串
122.{
123.      int s = 0;
124.        while(*pstr != '\0')        //一直扫描到字符串
125.        {
126.                if(*pstr >= '0' && *pstr <= '9') //字符串中有数字0-9
127.                {
128.                        s = s * 10 + *pstr - '0';
129.                }
130.                pstr++;
131.        }
132.    return s;
133.}
134.
135. void Num(int i)
136.{
137.      switch(i)//点亮对应输入的数字
138.    {
139.        case 0 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|
140.
141.GPIO_Pin_13|GPIO_Pin_14);break;
142.        case 1 : GPIO_ResetBits(GPIOB,GPIO_Pin_9|GPIO_Pin_12);
143.
144.                break;
145.        case 2 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_13|
146.
147.GPIO_Pin_14);            break;
148.        case 3 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12|
149.
150.GPIO_Pin_14);            break;
151.        case 4 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12);
152.
153.                break;
154.        case 5 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|
155.
156.GPIO_Pin_14);            break;
157.        case 6 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_12|
158.
159.GPIO_Pin_13|GPIO_Pin_14);break;
160.        case 7 : GPIO_ResetBits(GPIOB,GPIO_Pin_7|GPIO_Pin_9|GPIO_Pin_12);
161.
162.                break;
163.        case 8 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|
164.
165.GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);break;
166.        case 9 : GPIO_ResetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|
167.
168.GPIO_Pin_12|GPIO_Pin_14); break;
169.        }
170.    }
171.    void func(char *S,char LEN)
172.{
173.    int m;
174.   GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_12|
175.
176.GPIO_Pin_13|GPIO_Pin_14);
177.
178.    while(1)
179.    {
180.       m=my_atoi(S);
181.
182.        GPIO_SetBits(GPIOB,GPIO_Pin_1); //打开个位数码管
183.        Num(z%10);                      //点亮各位数
184.        delay_ms(5);                    //延时
185.        GPIO_ResetBits(GPIOB,GPIO_Pin_1);//关闭个位数码管
186.        GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|
187.
188.GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);
189.
190.        GPIO_SetBits(GPIOB,GPIO_Pin_15);//打开十位数码管
191.        Num(z/10);
192.        delay_ms(5);
193.        GPIO_ResetBits(GPIOB,GPIO_Pin_15);//关闭十位
194.        GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|
195.
196.GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14);
197.
198.        }
199.    }
200.    void input_ASK()
201.{
202.    char j;
203.    func(rx_buff,rx_buff_count);
204.    rx_buff_count=0;
205.    for (j=0;j 206.    {rx_buff[j]='\0';}
207.   // USART_SendStr("\n>");
208.}
209.
210.int main()
211.{
212.        RCC_Configuration();
213.      GPIO_INIT();
214.        USART_int(9600);
215.       // USART_SendStr("Please input like: data=\r\n");
216.        //USART_SendStr("\n>");
217.        while(1){
218.                }
219.}
220.
221.void USART1_IRQHandler(void)  //声明接收中断函数
222.{
223.  while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET)  //等待接收完毕
224.  {
225.  }
226.    if(USART_ReceiveData(USART1)==0x0d)     //如果接收到回车，结束输入
227.    {input_ASK();}          //执行input_ASK()
228.    else
229.    {
230.    USART_SendData(USART1,USART_ReceiveData(USART1));      //将数据回送至超级终端
231.    rx_buff[rx_buff_count]= USART_ReceiveData(USART1);
232.        rx_buff_count++;
233.    }
234.  USART_ClearFlag(USART1, USART_FLAG_RXNE); //发送数据
235.
236.}
237.}

sfr IAP_DATA     = 0xE2;
sfr IAP_ADDRH     = 0xE3;
sfr IAP_ADDRL     = 0xE4;
sfr IAP_CMD      = 0xE5;
sfr IAP_TRIG     = 0xE6;
sfr IAP_CONTR     = 0xE7;

#define           CMD_IDLE  0
#define           CMD_READ   1
#define           CMD_PROGRAM   2
#define           CMD_ERASE   3     /*¶¨ÒåFlash²Ù×÷µÈ´ýʱ¼ä¼°ÔÊÐ

íIAP/ISP/EEPROM²Ù×÷µÄ³£ÊÊý*/

#define     ENABLE_IAP0x80 //ϵͳ¹¤×÷ʱÖÓ<5Mhzʱ£¬¶ÔIAP_CONTR¼Ä´

æÆ÷ÉèÖôËÖµ
#define     ENABLE_IAP0x81 //ϵͳ¹¤×÷ʱÖÓ<10Mhzʱ£¬¶ÔIAP_CONTR¼Ä´

æÆ÷ÉèÖôËÖµ
#define     ENABLE_IAP0x82 //ϵͳ¹¤×÷ʱÖÓ<20Mhzʱ£¬¶ÔIAP_CONTR¼Ä´

æÆ÷ÉèÖôËÖµ
#define     ENABLE_IAP0x83 //ϵͳ¹¤×÷ʱÖÓ<40Mhzʱ£¬¶ÔIAP_CONTR¼Ä´

æÆ÷ÉèÖôËÖµ

IAP_ADDRESS    0x2000    //STC90C52ϵÁÐEEPROM²âÊÔÆðʼµØÖ·

void IapIdle(void)
{
IAP_CONTR=0;
IAP_CMD =0;
IAP_TRIG =0;
IAP_ADDRH=0x80;
IAP_ADDRL =0;

}

unsigned char IapReadByte(unsigned int addt)
{
unsigned char dat;
IAP_CONTR=ENABLE_IAP;
IAP_CMD =CMD_READ;
IAP_ADDRL=addr;
IAP_ADDRL=addr>>8
IAP_TRIG =0x46;
IAP_TRIG =0xb9;
dat = IAP_DATA;
IapIdle();

return dat;

}

void Iap ProgramByte(unsigned int addr,unsigned char dat )
{
IAP_CONTR=ENABLE_IAP;
IAP_CMD =CMD_REOGRAM;
IAP_ADDRL=addr;
IAP_ADDRH=addr>>8
IAP_DATA=date;
IAP_TRIG =0x46;
IAP_TRIG =0xb9;

IapIdle();
}

void Iap EraseSector(unsigned int addr )
{
IAP_CONTR=ENABLE_IAP;
IAP_CMD =CMD_ERASE;
IAP_ADDRL=addr;
IAP_ADDRH=addr>>8
IAP_TRIG =0x46;
IAP_TRIG =0xb9;

IapIdle();
}
unsigned char Num=0;
void main(void)
{
unsigned long i=0;
Num = Iap ReadByte(IAP_ADDRESS+20);
Num++;
Iap EraseSector(IAP_ADDRESS);
Iap ProgramByte(IAP_ADDRESS+20,Num);
for(i=0;i {
LED0=0;
DelayMs(100);
LED0=1;
DelayMs(100);
}
while(1);
}

view plaincopy to clipboardprint?

1. #include "stdio.h"
2. #include "stm32f10x.h"
3. int fputc(int ch,FILE *f);
5. /********************RCC配置*********************/
6. void RCC_Configuration(void)
7. {
9. GPIO_InitTypeDef  GPIO_InitStructure;
10. ErrorStatus HSEStartUpStatus;
11. RCC_DeInit();
12. RCC_HSEConfig(RCC_HSE_ON);
13. HSEStartUpStatus = RCC_WaitForHSEStartUp();
14. if(HSEStartUpStatus==SUCCESS)
15. {
16. RCC_HCLKConfig(RCC_SYSCLK_Div1);
17. RCC_PCLK1Config(RCC_HCLK_Div2);
18. RCC_PCLK2Config(RCC_HCLK_Div1);
19. RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);//*设置PLL输入时钟源8x9=72M
20. RCC_PLLCmd(ENABLE);//*打开PLL：
21. while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);//*等待PLL工作：
22. RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//*设置系统时钟
23. while(RCC_GetSYSCLKSource() != 0x08);
24. }
26. GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);
28. /**蜂鸣器*/
29. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);
30. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
31. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //#管脚号  关闭蜂鸣器
32. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //#输出速度
33. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //#输入输出模式（推挽输出）
34. GPIO_Init(GPIOD, &GPIO_InitStructure); //#初始化
35. GPIO_ResetBits(GPIOD,GPIO_Pin_2);
37. }
39. void delay_us(u32 n) //延时函数
40. {
41. u8 j;
42. while(n--)
43. for(j=0;j<10;j++);
44. }
45. void delay_ms(u32 n) //延时函数
46. {
47. while(n--)
48. delay_us(1000);
49. }
53. /*****************************GPIO初始********************************/
54. void GPIO_Inits(void)
55. { /*结构体初始化及开启外设时钟*/
56. GPIO_InitTypeDef  GPIO_InitStructure;
57. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
58. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
59. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
60. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
61. /*GPIOA--RGB初始化*/
62. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
63. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
64. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
65. GPIO_Init(GPIOA,&GPIO_InitStructure);
66. GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3)
68. }
70. /**************************DS18B20**********************/
72. uint8_t DS18B20_Init(void)
73. {
74. GPIO_InitTypeDef GPIO_InitStructure;
75. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
76. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
77. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
78. GPIO_Init(GPIOC, &GPIO_InitStructure);
79. Set_B20();
81. DS18B20_Rst();
82. return DS18B20_Presence ();
83. }
85. static void DS18B20_Mode_IPU(void)
86. {
87. GPIO_InitTypeDef GPIO_InitStructure;
88. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
89. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
90. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
91. GPIO_Init(GPIOC, &GPIO_InitStructure);
92. }
94. static void DS18B20_Mode_Out_PP(void)
95. {
96. GPIO_InitTypeDef GPIO_InitStructure;
97. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
98. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
99. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
100. GPIO_Init(GPIOC, &GPIO_InitStructure);
101. }
105. static void DS18B20_Rst(void)
106. {
107. /* 主机设置为输出 */
108. DS18B20_Mode_Out_PP();
109. Reset_B20() ;
110. delay_us(700);
111. Set_B20()   ;
112. delay_us(15);
113. }
117. static uint8_t DS18B20_Presence(void)
118. {
119. uint8_t pulse_time = 0;
121. /* 主机设置为上拉输入 */
122. DS18B20_Mode_IPU();
125. while( Read_B20() && pulse_time<100 )
126. {
127. pulse_time++;
128. delay_us(1);
129. }
130. /* 经过100us后，存在脉冲都还没有到来*/
131. if( pulse_time >=100 )
132. return 1;
133. else
134. pulse_time = 0;
136. /* 存在脉冲到来，且存在的时间不能超过240us */
137. while( !Read_B20() && pulse_time<240 )
138. {
139. pulse_time++;
140. delay_us(1);
141. }
142. if( pulse_time >=240 )
143. return 1;
144. else
145. return 0;
146. }
149. static uint8_t DS18B20_ReadBit(void)
150. {
151. uint8_t dat;
153. /* 读0和读1的时间至少要大于60us */
154. DS18B20_Mode_Out_PP();
155. Reset_B20();
156. delay_us(10);
157. DS18B20_Mode_IPU();
158. //Delay_us(2);
160. if( Read_B20() == SET )
161. dat = 1;
162. else
163. dat = 0;
165. delay_us(45);
167. return dat;
168. }
171. static uint8_t DS18B20_ReadByte(void)
172. {
173. uint8_t i, j, dat = 0;
175. for(i=0; i<8; i++)
176. {
177. j = DS18B20_ReadBit();
178. dat = (dat) | (j<
179. }
181. return dat;
182. }
186. static void DS18B20_WriteByte(uint8_t dat)
187. {
188. uint8_t i, testb;
189. DS18B20_Mode_Out_PP();
191. for( i=0; i<8; i++ )
192. {
193. testb = dat&0x01;
194. dat = dat>>1;
195. /* 写0和写1的时间至少要大于60us */
196. if (testb)
197. {
198. Reset_B20();
199. /* 1us < 这个延时 < 15us */
200. delay_us(8);
202. Set_B20();
203. delay_us(58);
204. }
205. else
206. {
207. Reset_B20();
208. /* 60us < Tx 0 < 120us */
209. delay_us(70);
211. Set_B20();
212. delay_us(2);
213. }
214. }
215. }
219. static void DS18B20_SkipRom ( void )
220. {
221. DS18B20_Rst();
223. DS18B20_Presence();
225. DS18B20_WriteByte(0XCC); /* 跳过 ROM */
227. }
230. static void DS18B20_MatchRom ( void )
231. {
232. DS18B20_Rst();
234. DS18B20_Presence();
236. DS18B20_WriteByte(0X55); /* 匹配 ROM */
238. }
240. float DS18B20_GetTemp_SkipRom ( void )
241. {
242. uint8_t tpmsb, tplsb;
243. short s_tem;
244. float f_tem;
247. DS18B20_SkipRom ();
248. DS18B20_WriteByte(0X44); /* 开始转换 */
251. DS18B20_SkipRom ();
252. DS18B20_WriteByte(0XBE); /* 读温度值 */
254. tplsb = DS18B20_ReadByte();
255. tpmsb = DS18B20_ReadByte();
258. s_tem = tpmsb<<8;
259. s_tem = s_tem | tplsb;
261. if( s_tem < 0 ) /* 负温度 */
262. f_tem = (~s_tem+1) * 0.0625;
263. else
264. f_tem = s_tem * 0.0625;
266. return f_tem;
269. }
273. void DS18B20_ReadId ( uint8_t * ds18b20_id )
274. {
275. uint8_t uc;
278. DS18B20_WriteByte(0x33); //读取序列号
280. for ( uc = 0; uc < 8; uc ++ )
281. ds18b20_id [ uc ] = DS18B20_ReadByte();
283. }
286. float DS18B20_GetTemp_MatchRom ( uint8_t * ds18b20_id )
287. {
288. uint8_t tpmsb, tplsb, i;
289. short s_tem;
290. float f_tem;
293. DS18B20_MatchRom (); //匹配ROM
295. for(i=0;i<8;i++)
296. DS18B20_WriteByte ( ds18b20_id [ i ] );
298. DS18B20_WriteByte(0X44); /* 开始转换 */
301. DS18B20_MatchRom (); //匹配ROM
303. for(i=0;i<8;i++)
304. DS18B20_WriteByte ( ds18b20_id [ i ] );
306. DS18B20_WriteByte(0XBE); /* 读温度值 */
308. tplsb = DS18B20_ReadByte();
309. tpmsb = DS18B20_ReadByte();
312. s_tem = tpmsb<<8;
313. s_tem = s_tem | tplsb;
315. if( s_tem < 0 ) /* 负温度 */
316. f_tem = (~s_tem+1) * 0.0625;
317. else
318. f_tem = s_tem * 0.0625;
320. return f_tem;
323. }
329. int main()
330. {
331. uint8_t uc, ucDs18b20Id [ 8 ];
332. RCC_Configuration();
333. GPIO_Inits();
334. USART_int(9600);
335. while( DS18B20_Init() )
336. printf("\r\n no ds18b20 exit \r\n");
338. printf("\r\n Yes ds18b20 \r\n");
340. DS18B20_ReadId ( ucDs18b20Id  ); // 读取 DS18B20 的序列号
342. printf("\r\nDS18B20的序列号是： 0x");
344. for ( uc = 0; uc < 8; uc ++ ) // 打印 DS18B20 的序列号
345. printf ( "%.2x", ucDs18b20Id [ uc ] );
348. for(;;)
349. {
350. static unsigned int i=0;
351. float a,b;
352. if(i==10)
353. {
354. printf ( "\r\n第10秒：温度： %.1f\r\n", DS18B20_GetTemp_MatchRom ( ucDs18b20Id ) ); // 打印通过 DS18B20 序列号获取的温度值
355. a=DS18B20_GetTemp_MatchRom ( ucDs18b20Id );
356. delay_ms(1000); /* 1s 读取一次温度值 */
357. i++;
358. }
359. else{}
360. if(i<10)
361. {
362. printf ( "\r\n温度： %.1f\r\n", DS18B20_GetTemp_MatchRom ( ucDs18b20Id ) ); // 打印通过 DS18B20 序列号获取的温度值
363. delay_ms(1000); /* 1s 读取一次温度值 */
364. i++;
365. }
366. if(i>10)
367. {
368. printf ( "\r\n10秒后：温度： %.1f\r\n", DS18B20_GetTemp_MatchRom ( ucDs18b20Id ) ); // 打印通过 DS18B20 序列号获取的温度值
369. b=DS18B20_GetTemp_MatchRom ( ucDs18b20Id );
370. delay_ms(1000); /* 1s 读取一次温度值 */
371. i++;
372. if((b-a)>0.9)
373. {GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
375. }
376. else{}
377. if((b-a)<0.9)
378. {
379. GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
382. }
383. else{}
385. }
386. else{}
388. }
389. }
390. int fputc(int ch,FILE *f)
391. {
392. USART_SendData(USART1, (uint8_t) ch);
393. while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
394. {}
395. return ch;
396. }