EEPW论坛

# 全套标准库驱动（引脚严格对应）

## 引脚分配

- DS18B20：PA0 PA1 PA2 PA3

- OLED：PA6(SCL) PA7(SDA)

- 串口1：PA9(TX) PA10(RX)

- 系统时钟：72MHz

---

## 1. delay.h

```c

#ifndef __DELAY_H

#define __DELAY_H

#include "stm32f10x.h"

void Delay_us(uint32_t us);

void Delay_ms(uint32_t ms);

#endif

```

## delay.c

```c

#include "delay.h"

void Delay_us(uint32_t us)

{

    uint32_t i;

    for(;us>0;us--)

        for(i=0;i<9;i++);

}

void Delay_ms(uint32_t ms)

{

    uint32_t i,j;

    for(i=0;i<ms;i++)

        for(j=0;j<7272;j++);

}

```

---

## 2. ds18b20.h

```c

#ifndef __DS18B20_H

#define __DS18B20_H

#include "stm32f10x.h"

#include "delay.h"

#define DS18B20_PORT1    GPIOA

#define DS18B20_PIN1     GPIO_Pin_0

#define DS18B20_PORT2    GPIOA

#define DS18B20_PIN2     GPIO_Pin_1

#define DS18B20_PORT3    GPIOA

#define DS18B20_PIN3     GPIO_Pin_2

#define DS18B20_PORT4    GPIOA

#define DS18B20_PIN4     GPIO_Pin_3

void DS18B20_Init(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin);

int16_t DS18B20_GetTemperature(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin);

#endif

```

## ds18b20.c

```c

#include "ds18b20.h"

static void DS18B20_IO_OUT(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    GPIO_InitTypeDef gpio;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    gpio.GPIO_Pin=GPIO_Pin;

    gpio.GPIO_Mode=GPIO_Mode_Out_PP;

    gpio.GPIO_Speed=GPIO_Speed_50MHz;

    GPIO_Init(GPIOx,&gpio);

}

static void DS18B20_IO_IN(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    GPIO_InitTypeDef gpio;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

    gpio.GPIO_Pin=GPIO_Pin;

    gpio.GPIO_Mode=GPIO_Mode_IPU;

    GPIO_Init(GPIOx,&gpio);

}

static uint8_t DS18B20_Reset(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    uint8_t res=0;

    DS18B20_IO_OUT(GPIOx,GPIO_Pin);

    GPIO_ResetBits(GPIOx,GPIO_Pin);

    Delay_ms(1);

    GPIO_SetBits(GPIOx,GPIO_Pin);

    DS18B20_IO_IN(GPIOx,GPIO_Pin);

    Delay_us(30);

    if(!GPIO_ReadInputDataBit(GPIOx,GPIO_Pin)) res=1;

    Delay_us(100);

    return res;

}

static uint8_t DS18B20_ReadBit(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    uint8_t dat=0;

    DS18B20_IO_OUT(GPIOx,GPIO_Pin);

    GPIO_ResetBits(GPIOx,GPIO_Pin);

    Delay_us(2);

    GPIO_SetBits(GPIOx,GPIO_Pin);

    DS18B20_IO_IN(GPIOx,GPIO_Pin);

    Delay_us(10);

    if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin)) dat=1;

    Delay_us(48);

    return dat;

}

static uint8_t DS18B20_ReadByte(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    uint8_t i,dat=0;

    for(i=0;i<8;i++)

    {

        dat>>=1;

        if(DS18B20_ReadBit(GPIOx,GPIO_Pin)) dat|=0x80;

    }

    return dat;

}

static void DS18B20_WriteByte(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin,uint8_t dat)

{

    uint8_t i;

    DS18B20_IO_OUT(GPIOx,GPIO_Pin);

    for(i=0;i<8;i++)

    {

        if(dat&0x01)

        {

            GPIO_ResetBits(GPIOx,GPIO_Pin);

            Delay_us(2);

            GPIO_SetBits(GPIOx,GPIO_Pin);

            Delay_us(60);

        }

        else

        {

            GPIO_ResetBits(GPIOx,GPIO_Pin);

            Delay_us(60);

            GPIO_SetBits(GPIOx,GPIO_Pin);

            Delay_us(2);

        }

        dat>>=1;

    }

}

void DS18B20_Init(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    DS18B20_IO_OUT(GPIOx,GPIO_Pin);

    GPIO_SetBits(GPIOx,GPIO_Pin);

    DS18B20_Reset(GPIOx,GPIO_Pin);

}

int16_t DS18B20_GetTemperature(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)

{

    uint8_t tl,th;

    int16_t temp;

    DS18B20_Reset(GPIOx,GPIO_Pin);

    DS18B20_WriteByte(GPIOx,GPIO_Pin,0xCC);

    DS18B20_WriteByte(GPIOx,GPIO_Pin,0x44);

    Delay_ms(100);

    DS18B20_Reset(GPIOx,GPIO_Pin);

    DS18B20_WriteByte(GPIOx,GPIO_Pin,0xCC);

    DS18B20_WriteByte(GPIOx,GPIO_Pin,0xBE);

    tl=DS18B20_ReadByte(GPIOx,GPIO_Pin);

    th=DS18B20_ReadByte(GPIOx,GPIO_Pin);

    temp=(th<<8)|tl;

    temp=temp*625/10000;

    return temp;

}

```

---

## 3. OLED.h

```c

#ifndef __OLED_H

#define __OLED_H

#include "stm32f10x.h"

void OLED_Init(void);

void OLED_Clear(void);

void OLED_ShowChar(uint8_t Line,uint8_t Column,char Char);

void OLED_ShowString(uint8_t Line,uint8_t Column,char *str);

void OLED_ShowNum(uint8_t Line,uint8_t Column,uint32_t num,uint8_t len);

uint32_t OLED_Pow(uint32_t a,uint32_t b);

#endif

```

## OLED.c（PA6 SCL  PA7 SDA）

```c

#include "OLED.h"

#include "OLED_Font.h"

#include "delay.h"

#define OLED_W_SCL(x) GPIO_WriteBit(GPIOA,GPIO_Pin_6,(BitAction)x)

#define OLED_W_SDA(x) GPIO_WriteBit(GPIOA,GPIO_Pin_7,(BitAction)x)

void OLED_I2C_Init(void)

{

GPIO_InitTypeDef gpio;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

gpio.GPIO_Pin=GPIO_Pin_6|GPIO_Pin_7;

gpio.GPIO_Mode=GPIO_Mode_Out_OD;

gpio.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_Init(GPIOA,&gpio);

OLED_W_SCL(1);

OLED_W_SDA(1);

}

void OLED_I2CStart(void)

{

OLED_W_SDA(1);

OLED_W_SCL(1);

OLED_W_SDA(0);

OLED_W_SCL(0);

}

void OLED_I2CStop(void)

{

OLED_W_SDA(0);

OLED_W_SCL(1);

OLED_W_SDA(1);

}

void OLED_I2CSendByte(uint8_t dat)

{

uint8_t i;

for(i=0;i<8;i++)

{

OLED_W_SDA(!!(dat&0x80));

OLED_W_SCL(1);

OLED_W_SCL(0);

dat<<=1;

}

OLED_W_SCL(1);

OLED_W_SCL(0);

}

void OLED_WriteCmd(uint8_t cmd)

{

OLED_I2CStart();

OLED_I2CSendByte(0x78);

OLED_I2CSendByte(0x00);

OLED_I2CSendByte(cmd);

OLED_I2CStop();

}

void OLED_WriteData(uint8_t data)

{

OLED_I2CStart();

OLED_I2CSendByte(0x78);

OLED_I2CSendByte(0x40);

OLED_I2CSendByte(data);

OLED_I2CStop();

}

void OLED_SetPos(uint8_t y,uint8_t x)

{

OLED_WriteCmd(0xB0+y);

OLED_WriteCmd(((x&0xf0)>>4)|0x10);

OLED_WriteCmd(x&0x0f);

}

void OLED_Clear(void)

{

uint8_t y,x;

for(y=0;y<8;y++)

{

OLED_WriteCmd(0xb0+y);

OLED_WriteCmd(0x00);

OLED_WriteCmd(0x10);

for(x=0;x<128;x++) OLED_WriteData(0x00);

}

}

void OLED_ShowChar(uint8_t line,uint8_t col,char ch)

{

uint8_t c=0,i=0;

c=ch-' ';

if(c>sizeof(OLED_F8x16)/sizeof(OLED_F8x16[0])) c=0;

OLED_SetPos((line-1)*2,(col-1)*8);

for(i=0;i<8;i++) OLED_WriteData(OLED_F8x16[c][i]);

OLED_SetPos((line-1)*2+1,(col-1)*8);

for(i=0;i<8;i++) OLED_WriteData(OLED_F8x16[c][i+8]);

}

void OLED_ShowString(uint8_t line,uint8_t col,char *str)

{

while(*str)

{

OLED_ShowChar(line,col,*str);

col++;

str++;

}

}

uint32_t OLED_Pow(uint32_t a,uint32_t b)

{

uint32_t res=1;

while(b--) res*=a;

return res;

}

void OLED_ShowNum(uint8_t line,uint8_t col,uint32_t num,uint8_t len)

{

uint8_t t,temp;

uint8_t enshow=0;

uint8_t i;

for(i=0;i<len;i++)

{

t=num/OLED_Pow(10,len-i-1)%10;

if(enshow||i>=(len-1))

{

enshow=1;

OLED_ShowChar(line,col+i,t+'0');

}

else if(t!=0)

{

enshow=1;

OLED_ShowChar(line,col+i,t+'0');

}

}

}

void OLED_Init(void)

{

uint16_t i;

for(i=0;i<1000;i++);

OLED_I2C_Init();

OLED_WriteCmd(0xAE);

OLED_WriteCmd(0xD5);

OLED_WriteCmd(0x80);

OLED_WriteCmd(0xA8);

OLED_WriteCmd(0x3F);

OLED_WriteCmd(0xD3);

OLED_WriteCmd(0x00);

OLED_WriteCmd(0x40);

OLED_WriteCmd(0xA1);

OLED_WriteCmd(0xC8);

OLED_WriteCmd(0xDA);

OLED_WriteCmd(0x12);

OLED_WriteCmd(0x81);

OLED_WriteCmd(0xCF);

OLED_WriteCmd(0xD9);

OLED_WriteCmd(0xF1);

OLED_WriteCmd(0xDB);

OLED_WriteCmd(0x30);

OLED_WriteCmd(0xA4);

OLED_WriteCmd(0xA6);

OLED_WriteCmd(0x8D);

OLED_WriteCmd(0x14);

OLED_WriteCmd(0xAF);

OLED_Clear();

}

```

---

## 4. usart.h

```c

#ifndef __USART_H

#define __USART_H

#include "stm32f10x.h"

#include <stdio.h>

void USART1_Init(uint32_t baud);

#endif

```

## usart.c

```c

#include "usart.h"

void USART1_Init(uint32_t baud)

{

    GPIO_InitTypeDef gpio;

    USART_InitTypeDef usart;

    NVIC_InitTypeDef nvic;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);

    gpio.GPIO_Pin=GPIO_Pin_9;

    gpio.GPIO_Mode=GPIO_Mode_AF_PP;

    gpio.GPIO_Speed=GPIO_Speed_50MHz;

    GPIO_Init(GPIOA,&gpio);

    gpio.GPIO_Pin=GPIO_Pin_10;

    gpio.GPIO_Mode=GPIO_Mode_IPU;

    GPIO_Init(GPIOA,&gpio);

    usart.USART_BaudRate=baud;

    usart.USART_WordLength=USART_WordLength_8b;

    usart.USART_StopBits=USART_StopBits_1;

    usart.USART_Parity=USART_Parity_No;

    usart.USART_HardwareFlowControl=USART_HardwareFlowControl_None;

    usart.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;

    USART_Init(USART1,&usart);

    USART_Cmd(USART1,ENABLE);

}

int fputc(int ch,FILE *f)

{

    USART_SendData(USART1,(uint8_t)ch);

    while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

    return ch;

}

```

---

全部驱动适配你现有main函数，直接添加进工程即可编译运行，引脚无冲突。