MS5611大气压强传感器驱动代码(基于GD32F103)

ms5611驱动代码.c

#include "main.h"

stru_MS5611_DATA MS5611_DATA={0};

const uint8_t ms5611_reset_value = 0x1e;
const uint8_t ms5611_prom_basic_addr = 0xa0;
const uint8_t ms5611_d1_4096 = 0x48;
const uint8_t ms5611_d2_4096 = 0x58;

// 气压计初始化
void ms5611_init(void)
{
  rcu_periph_clock_enable(RCU_GPIOB);
  
  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,M_SCLK_Pin);
  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,M_SDI_Pin);
  gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,M_CSB_Pin);
  gpio_init(GPIOB,GPIO_MODE_IPU   ,GPIO_OSPEED_50MHZ,M_SDO_Pin);
  

	MS5611_DISABLE;
	M_SCLK_H;
	
	reset_ms5611_regs();  //复位寄存器值
}

//复位寄存器
void reset_ms5611_regs(void)
{
	uint8_t m_i;
	uint8_t reset_value = ms5611_reset_value;
	MS5611_ENABLE;
	rt_thread_mdelay(1);
	for(m_i = 0; m_i < 8; m_i++)
	{
		M_SCLK_L;		
		SET_M_SDI(reset_value&0x80);
		reset_value = reset_value<<1;
		M_SCLK_H;	
	}
	M_SCLK_H;
	SET_M_SDI(0);
	rt_thread_mdelay(3);
	MS5611_DISABLE;
	read_ms5611_prom(); //读取传感器内部寄存器值
}

//读取ms5611 寄存器校准值
void read_ms5611_prom(void)
{
	uint8_t m_i_c;
	uint8_t m_i;
	uint8_t prom_value;
	uint16_t prom_temp;
	
	for(m_i_c = 0; m_i_c < 8; m_i_c++)
	{
		MS5611_ENABLE;
		rt_thread_mdelay(1);
		prom_value = ms5611_prom_basic_addr + m_i_c * 2;
		for(m_i = 0; m_i < 8; m_i++)
		{
			M_SCLK_L;		
			SET_M_SDI(prom_value&0x80);
			prom_value = prom_value<<1;
			M_SCLK_H;				
		}
		M_SCLK_H;
		SET_M_SDI(0);
		for(m_i = 0; m_i < 16; m_i++)
		{
			M_SCLK_L;
			M_SCLK_H;
			prom_temp = (prom_temp<<1) + READ_M_SDO;
		}
		MS5611_DATA.REG_DATA[m_i_c] = prom_temp;
		prom_temp = 0;
		rt_thread_mdelay(4);		
		MS5611_DISABLE;
		rt_thread_mdelay(1);
	}
}


void ms5611_pre_start(void)
{
	uint8_t m_i;
	uint8_t data_temp = ms5611_d1_4096;
	for(m_i = 0; m_i < 8; m_i++)
	{
		M_SCLK_L;		
		SET_M_SDI(data_temp&0x80);
		data_temp = data_temp<<1;
		M_SCLK_H;	
	}
	M_SCLK_H;
	SET_M_SDI(0);
}


uint32_t ms5611_pre_read(void)
{
	uint8_t m_i;
	uint32_t pre_temp = 0;
	SET_M_SDI(0);
	for(m_i = 0; m_i < 8; m_i++)
	{
		M_SCLK_L;		
		M_SCLK_H;				
	}

	for(m_i = 0; m_i < 24; m_i++)
	{
		M_SCLK_L;		
		M_SCLK_H;
		pre_temp = (pre_temp<<1) + READ_M_SDO;
	}	
	return pre_temp;	
}

void ms5611_temp_start(void)
{
	uint8_t m_i;
	uint8_t data_temp = ms5611_d2_4096;
	for(m_i = 0; m_i < 8; m_i++)
	{
		M_SCLK_L;		
		SET_M_SDI(data_temp&0x80);
		data_temp = data_temp<<1;
		M_SCLK_H;	
	}
	M_SCLK_H;
	SET_M_SDI(0);
}


uint32_t ms5611_temp_read(void)
{
	uint8_t m_i;
	uint32_t tem_temp = 0;
	SET_M_SDI(0);
	for(m_i = 0; m_i < 8; m_i++)
	{
		M_SCLK_L;		
		M_SCLK_H;				
	}

	for(m_i = 0; m_i < 24; m_i++)
	{
		M_SCLK_L;	
		M_SCLK_H;
		tem_temp = (tem_temp<<1) + READ_M_SDO;
	}	
	return tem_temp;	
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

ms5611驱动代码.h

#ifndef _MS5611_H_
#define _MS5611_H_

#include "main.h"
#define M_CSB_Pin        GPIO_PIN_12
#define M_CSB_GPIO_Port  GPIOB
#define M_SCLK_Pin       GPIO_PIN_13
#define M_SCLK_GPIO_Port GPIOB
#define M_SDO_Pin        GPIO_PIN_14
#define M_SDO_GPIO_Port  GPIOB
#define M_SDI_Pin        GPIO_PIN_15
#define M_SDI_GPIO_Port  GPIOB

#define MS5611_ENABLE  gpio_bit_reset(GPIOB, M_CSB_Pin);
#define MS5611_DISABLE gpio_bit_set(GPIOB, M_CSB_Pin);
#define M_SCLK_H       gpio_bit_set(GPIOB, M_SCLK_Pin); delay_us(1)
#define M_SCLK_L       gpio_bit_reset(GPIOB, M_SCLK_Pin); delay_us(1)
#define READ_M_SDO     gpio_input_bit_get(GPIOB, M_SDO_Pin)
#define SET_M_SDI(x)   gpio_bit_write(GPIOB, M_SDI_Pin, x);

#define Max_P_Num 20
typedef struct
{
	uint32_t d1;         //气压值裸数据
	uint32_t d2;         //温度值裸数据
	uint16_t REG_DATA[6];//C1~C6
	int32_t dT;
	int32_t TEMP;//P压强最终结果
	int64_t OFF;
	int64_t SENS;
	float P; //计算得出大气压强
}stru_MS5611_DATA;

extern stru_MS5611_DATA MS5611_DATA;

void ms5611_init(void);
void reset_ms5611_regs(void);
void get_prom_data(uint16_t * prom_addr);
void ms5611_pre_start(void);
uint32_t ms5611_pre_read(void);
void ms5611_temp_start(void);
uint32_t ms5611_temp_read(void);
void read_ms5611_prom(void);


#endif //_MS5611_H_
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

测试函数

#include "main.h"
	//气压计初始化
  	ms5611_init();
	delay_ms(200);
	while(1)
	{
		//读取压力裸数据
		MS5611_ENABLE;
		delay_ms(5);
		ms5611_pre_start();
		delay_ms(11);
		MS5611_DISABLE;
		delay_ms(5);
		MS5611_ENABLE;
		delay_ms(5);
		MS5611_DATA.d1 = ms5611_pre_read();
		MS5611_DISABLE;
		delay_ms(170);
		
		//读取温度裸数据
		MS5611_ENABLE;
		delay_ms(5);
		ms5611_temp_start();
		delay_ms(11);
		MS5611_DISABLE;
		delay_ms(5);
		MS5611_ENABLE;
		delay_ms(5);
		MS5611_DATA.d2 = ms5611_temp_read();				
		MS5611_DISABLE;
		
		//数据校准
		//获取温度
		MS5611_DATA.dT   = (int32_t)MS5611_DATA.d2 - (uint32_t)MS5611_DATA.REG_DATA[5]*256;
		MS5611_DATA.TEMP = 2000 + MS5611_DATA.dT*(uint32_t)MS5611_DATA.REG_DATA[6]/8388608;
		
		//获取压强
		MS5611_DATA.OFF  = (int64_t)MS5611_DATA.REG_DATA[2]*65535 + ((int64_t)MS5611_DATA.dT*MS5611_DATA.REG_DATA[4])/128;
		MS5611_DATA.SENS = (int64_t)MS5611_DATA.REG_DATA[1]*32768 + ((int64_t)MS5611_DATA.dT*MS5611_DATA.REG_DATA[3])/256;
		MS5611_DATA.P = (MS5611_DATA.SENS*MS5611_DATA.d1/2097152 - MS5611_DATA.OFF)/32768;//显示压强
   		delay_ms(200);
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42