电压电流功率检测器INA226使用教程

一路上

INA226是一路电压电流功率检测器，可以检测线电压，分流电阻的电压和分流电阻电流。

具体实现要看INA226数据手册。

INA226.c:

1. #include "INA226.h"
   
2. 
   
3. 
   
4. INA226 INA226_data;
   
5. 
   
6. static void delay_nns(uint16_t D)  //30纳秒ns  根据手册要用到IIC的HS高速模式
   
7. {
   
8.     while(--D);
   
9. }
   
10. 
    
11. void delay_nms(uint16_t ms)  //毫秒
    
12. {
    
13.     uint16_t i;
    
14.     uint32_t M = 0;//720W
    
15.     for(i = 0;i < ms; i++)
    
16.     for(M=12000;M > 0;M--);
    
17. }
    
18. 
    
19. void delay_nus(uint16_t us)//微秒
    
20. {
    
21.     uint16_t i;
    
22.     uint16_t M = 0;//720W
    
23.     for(i = 0;i < us; i++)
    
24.     for(M=72;M > 0;M--);
    
25. }
    
26. 
    
27. /****************IIC***************************/
    
28. void INA226_IIC_Init(void)
    
29. {
    
30.     GPIO_InitTypeDef GPIO_Initure;
    
31.     __HAL_RCC_GPIOB_CLK_ENABLE();   //使能GPIOB时钟
    
32.    
    
33.      //PC11,12初始化设置
    
34.     GPIO_Initure.Pin=GPIO_PIN_10|GPIO_PIN_11;//PB10SCL PB11SDA
    
35.     GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
    
36.     GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
    
37.     GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;     //高速
    
38.     HAL_GPIO_Init(GPIOB,&GPIO_Initure);
    
39.    
    
40.     IIC_SDA_H;
    
41.     IIC_SCL_H;  
    
42.         delay_nms(5);
    
43. }
    
44.    
    
45. void INA226_IIC_Start(void)
    
46. {
    
47.     IIC_SDA_H;            
    
48.     IIC_SCL_H;
    
49.     delay_nns(5);
    
50.      IIC_SDA_L;//START:when CLK is high,DATA change form high to low
    
51.     delay_nns(5);
    
52.     IIC_SCL_L;//钳住I2C总线，准备发送或接收数据
    
53.     delay_nns(5);
    
54. }   
    
55. 
    
56. void INA226_IIC_Stop(void)
    
57. {
    
58.     IIC_SDA_L;//STOP:when CLK is high DATA change form low to high
    
59.      delay_nns(5);
    
60.     IIC_SCL_H;
    
61.         delay_nns(5);
    
62.     IIC_SDA_H;//发送I2C总线结束信号
    
63.     delay_nns(5);                                   
    
64. }
    
65. 
    
66. void INA226_IIC_Ack(void)
    
67. {
    
68.     IIC_SDA_L;
    
69.     delay_nns(5);
    
70.     IIC_SCL_H;
    
71.     delay_nns(5);
    
72.     IIC_SCL_L;
    
73.         delay_nns(5);
    
74.     IIC_SDA_H;
    
75. }
    
76. 
    
77. void INA226_IIC_NAck(void)
    
78. {
    
79.     IIC_SDA_H;
    
80.     delay_nns(5);
    
81.     IIC_SCL_H;
    
82. delay_nns(5);
    
83.     IIC_SCL_L;
    
84.     delay_nns(5);
    
85.     IIC_SDA_L;
    
86. }        
    
87. 
    
88. uint8_t INA226_IIC_Wait_Ack(void)
    
89. {
    
90.     uint8_t ucErrTime=0;
    
91.     //SDA_IN();      //SDA设置为输入  
    
92.     IIC_SDA_H;
    
93.     delay_nns(5);      
    
94.     IIC_SCL_H;
    
95.     delay_nns(5);         
    
96.    
    
97.     while(READ_SDA)
    
98.     {
    
99.         ucErrTime++;
    
100.         if(ucErrTime>250)
     
101.         {
     
102.             INA226_IIC_Stop();
     
103.             return 1;
     
104.         }
     
105.     }
     
106.     IIC_SCL_L;//时钟输出0        
     
107.     return 0;  
     
108. }
     
109. 
     
110. void INA226_IIC_Send_Byte(uint8_t txd)
     
111. {                              
     
112.    IIC_SCL_L;//拉低时钟开始数据传输
     
113.    for(uint8_t i = 0;i < 8;i++)
     
114.     {              
     
115.         if(txd&0x80)
     
116.                     IIC_SDA_H;
     
117.                 else
     
118.                     IIC_SDA_L;               
     
119.         txd<<=1;      
     
120.                
     
121.         IIC_SCL_H;
     
122.         delay_nns(5);
     
123.         IIC_SCL_L;
     
124.         delay_nns(5);
     
125.     }            
     
126.     //    IIC_SDA_H;
     
127.     //    IIC_SCL_H;            //当去掉wait_ack时的时候添加
     
128.     //    delay_nns(5);
     
129.         //IIC_SCL_L;
     
130. }
     
131. 
     
132. uint8_t INA226_IIC_Read_Byte(unsigned char ack)
     
133. {
     
134.       uint8_t TData=0,i;
     
135.     for(i=0;i<8;i++)
     
136.     {
     
137.         IIC_SCL_H;
     
138.         delay_nns(5);
     
139.         TData=TData<<1;
     
140.         //if(GPIOB->IDR& GPIO_IDR_IDR7)        //判断SDA是否为高
     
141.             if(SDA_READ)
     
142.         {
     
143.             TData|=0x01;
     
144.         }
     
145.         IIC_SCL_L;
     
146.         delay_nns(5);
     
147.     }
     
148.         if(!ack)
     
149.             INA226_IIC_NAck();
     
150.         else
     
151.             INA226_IIC_Ack();
     
152. //    IIC_SCL_L;
     
153. //    delay_nns(5);
     
154. //    IIC_SDA_L;
     
155. //    delay_nns(5);                //ACK
     
156. //    IIC_SCL_H;
     
157. //    delay_nns(5);
     
158. //    IIC_SCL_L;
     
159. //    delay_nns(5);
     
160. //    IIC_SDA_H;
     
161.     return TData;
     
162. }
     
163. 
     
164. /**********************IIC_END*************************/
     
165. 
     
166. void INA226_Init(void)
     
167. {
     
168.     INA226_IIC_Init();
     
169.     HAL_Delay(10);
     
170.     //    INA226_SendData(INA226_ADDR1,CFG_REG,0xC000);
     
171. 
     
172. //    HAL_Delay(10);
     
173.     //uint16_t cfg_reg_value = 0x4000|(3<<9)|(4<<6)|(4<<3)|7;
     
174. //    INA226_SendData(INA226_ADDR1,CFG_REG,0x484f);
     
175. //    INA226_SendData(INA226_ADDR1,CAL_REG,0x0012);
     
176.     INA226_SendData(INA226_ADDR1,0x00,0x4727);
     
177.     INA226_SendData(INA226_ADDR1,0x05,0x800);//A00
     
178. }
     
179. 
     
180. void INA226_SendData(uint8_t addr,uint8_t reg,uint16_t data)
     
181. {
     
182.     uint8_t temp = 0;
     
183.     INA226_IIC_Start();
     
184.     INA226_IIC_Send_Byte(addr);
     
185.     INA226_IIC_Wait_Ack();
     
186. 
     
187.     INA226_IIC_Send_Byte(reg);
     
188.     INA226_IIC_Wait_Ack();
     
189.    
     
190.     temp = (uint8_t)(data>>8);
     
191.     INA226_IIC_Send_Byte(temp);
     
192.     INA226_IIC_Wait_Ack();
     
193. 
     
194.     temp = (uint8_t)(data&0x00FF);
     
195.     INA226_IIC_Send_Byte(temp);
     
196.     INA226_IIC_Wait_Ack();
     
197.    
     
198.     INA226_IIC_Stop();
     
199. }
     
200. 
     
201. 
     
202. void INA226_SetRegPointer(uint8_t addr,uint8_t reg)
     
203. {
     
204.     INA226_IIC_Start();
     
205. 
     
206.     INA226_IIC_Send_Byte(addr);
     
207.     INA226_IIC_Wait_Ack();
     
208. 
     
209.     INA226_IIC_Send_Byte(reg);
     
210.     INA226_IIC_Wait_Ack();
     
211. 
     
212.     INA226_IIC_Stop();
     
213. }
     
214. 
     
215. 
     
216. uint16_t INA226_ReadData(uint8_t addr)
     
217. {
     
218.     uint16_t temp=0;
     
219.     INA226_IIC_Start();
     
220. 
     
221.     INA226_IIC_Send_Byte(addr+1);
     
222.     INA226_IIC_Wait_Ack();
     
223.    
     
224.     temp = INA226_IIC_Read_Byte(1);
     
225.     temp<<=8;   
     
226.     temp |= INA226_IIC_Read_Byte(0);
     
227.    
     
228.     INA226_IIC_Stop();
     
229.     return temp;
     
230. }
     
231. 
     
232. 
     
233. long INA226_GetShunt_Current(uint8_t addr)
     
234. {
     
235.     long temp=0;   
     
236.     INA226_SetRegPointer(addr,CUR_REG);
     
237.     temp = INA226_ReadData(addr);
     
238.     if(temp&0x8000)   
     
239.     {
     
240.         temp = ~(temp - 1);   
     
241.             temp = (uint16_t)temp - 2 * (uint16_t)temp;
     
242.     }
     
243.         return temp;
     
244. }
     
245. 
     
246. //获取 id
     
247. uint16_t  INA226_Get_ID(uint8_t addr)
     
248. {
     
249.     uint32_t temp=0;
     
250.     INA226_SetRegPointer(addr,INA226_GET_ADDR);
     
251.     temp = INA226_ReadData(addr);
     
252.     return (uint16_t)temp;
     
253. }
     
254. 
     
255. //获取校准值
     
256. uint16_t INA226_GET_CAL_REG(uint8_t addr)
     
257. {   
     
258.     uint32_t temp=0;
     
259.     INA226_SetRegPointer(addr,CAL_REG);
     
260.     temp = INA226_ReadData(addr);
     
261.     return (uint16_t)temp;
     
262. }
     
263. 
     
264. //1.25mV/bit
     
265. uint32_t INA226_GetVoltage(uint8_t addr)
     
266. {
     
267.     uint32_t temp=0;
     
268.     INA226_SetRegPointer(addr,BV_REG);
     
269.     temp = INA226_ReadData(addr);
     
270.     return (uint32_t)temp;   
     
271. }
     
272. 
     
273. 
     
274. 
     
275. //2.5uV/bit,感觉这个值是测不准的，所以下面改成2.2了
     
276. uint32_t INA226_GetShuntVoltage(uint8_t addr)
     
277. {
     
278.     uint32_t temp=0;
     
279.     INA226_SetRegPointer(addr,SV_REG);
     
280.     temp = INA226_ReadData(addr);
     
281.     if(temp&0x8000)    temp = ~(temp - 1);   
     
282.     return (uint32_t)temp;   
     
283. }
     
284. 
     
285. 
     
286. uint16_t INA226_Get_Power(uint8_t addr)
     
287. {
     
288.     int16_t temp=0;
     
289.     INA226_SetRegPointer(addr,PWR_REG);
     
290.     temp = INA226_ReadData(addr);
     
291.     return (uint16_t)temp;
     
292. }
     
293. 
     
294. 
     
295. void GetVoltage(float *Voltage)//mV
     
296. {
     
297.     Voltage[0] = INA226_GetVoltage(INA226_ADDR1)*1.25f;
     
298.     printf("ina226 v = %.2f\r\n", Voltage[0]);
     
299. }
     
300. 
     
301. 
     
302. void Get_Shunt_voltage(float *Voltage)//uV
     
303. {
     
304.     Voltage[0] = (INA226_GetShuntVoltage(INA226_ADDR1)*2.2);//这里原来乘的系数是2.5
     
305.    
     
306. }
     
307. 
     
308. 
     
309. void Get_Shunt_Current(float *Current)//mA
     
310. {
     
311.     Current[0] = (INA226_GetShunt_Current(INA226_ADDR1)* 2.5f);
     
312. }
     
313. 
     
314. 
     
315. void GetPower()//W
     
316. {
     
317.     GetVoltage(&INA226_data.voltageVal);            //mV
     
318.     Get_Shunt_voltage(&INA226_data.Shunt_voltage);    //uV
     
319.     Get_Shunt_Current(&INA226_data.Shunt_Current);    //mA
     
320.     INA226_data.powerVal=INA226_data.voltageVal*0.001f * INA226_data.Shunt_Current*0.001f;
     
321. }
     
322. uint16_t read_dat;
     
323. float read_vol;
     
324. float GetV(void)
     
325. {
     
326.     //电压采样
     
327.     INA226_IIC_Start();
     
328.     INA226_IIC_Send_Byte(0x80);
     
329.     INA226_IIC_Wait_Ack();
     
330.   INA226_IIC_Send_Byte(0x00);
     
331.   INA226_IIC_Wait_Ack();
     
332.      INA226_IIC_Send_Byte(0x47);
     
333.   INA226_IIC_Wait_Ack();
     
334.      INA226_IIC_Send_Byte(0x27);
     
335.   INA226_IIC_Wait_Ack();
     
336.   INA226_IIC_Stop();
     
337.     HAL_Delay(1);   
     
338.         
     
339.   INA226_IIC_Start();
     
340.     INA226_IIC_Send_Byte(0x81);
     
341.     INA226_IIC_Wait_Ack();
     
342.     read_dat = INA226_IIC_Read_Byte(1)<<8;
     
343.     //IIC_Wait_Ack();
     
344.     read_dat = read_dat + INA226_IIC_Read_Byte(0);
     
345.     read_vol = 0.00125*read_dat;   
     
346.     INA226_IIC_Stop();
     
347.     return read_vol;
     
348. }

复制代码

INA226.h:

1. #ifndef _INA226_H
   
2. #define _INA226_H
   
3. 
   
4. 
   
5. #include "main.h"
   
6. 
   
7. 
   
8. #define     CFG_REG             0x00        //
   
9. #define     SV_REG             0x01        //分流电压， 此处分流电阻为 0.1欧
   
10. #define     BV_REG             0x02        //总线电压
    
11. #define     PWR_REG         0x03        //电源功率
    
12. #define     CUR_REG         0x04        //电流
    
13. #define     CAL_REG         0x05        //校准，设定满量程范围以及电流和功率测数的
    
14. //#define     ONFF_REG         0x06        //屏蔽 使能 警报配置和转换准备就绪
    
15. //#define     AL_REG             0x07        //包含与所选警报功能相比较的限定值
    
16. #define     INA226_GET_ADDR 0XFF        //包含唯一的芯片标识号
    
17. #define       INA226_ADDR1    0x80
    
18. 
    
19. 
    
20. 
    
21. //IO操作
    
22. #define IIC_SCL_H   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_SET) //SCL H
    
23. #define IIC_SCL_L   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_RESET) //SCL H
    
24. #define IIC_SDA_H    HAL_GPIO_WritePin(GPIOB,GPIO_PIN_11,GPIO_PIN_SET) //SDA_H
    
25. #define IIC_SDA_L      HAL_GPIO_WritePin(GPIOB,GPIO_PIN_11,GPIO_PIN_RESET) //SDA_L
    
26. #define READ_SDA      HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_11)  //输入SDA
    
27. #define SDA_READ   GPIOB->IDR& GPIO_IDR_IDR11
    
28. 
    
29. 
    
30. typedef struct
    
31. {
    
32.     float voltageVal;            //mV
    
33.     float Shunt_voltage;        //uV
    
34.     float Shunt_Current;        //mA
    
35.     float powerVal;
    
36. }INA226;
    
37. 
    
38. static void delay_nns(uint16_t D);
    
39. void delay_nms(uint16_t ms);
    
40. void delay_nus(uint16_t us);
    
41. void INA226_IIC_Init(void);
    
42. void INA226_IIC_Start(void);
    
43. void INA226_IIC_Stop(void);
    
44. void INA226_IIC_Ack(void);
    
45. void INA226_IIC_NAck(void);
    
46. uint8_t INA226_IIC_Wait_Ack(void);
    
47. void INA226_IIC_Send_Byte(uint8_t txd);
    
48. uint8_t INA226_IIC_Read_Byte(unsigned char ack);
    
49. void INA226_Init(void);
    
50. void INA226_SendData(uint8_t addr,uint8_t reg,uint16_t data);
    
51. void INA226_SetRegPointer(uint8_t addr,uint8_t reg);
    
52. uint16_t INA226_ReadData(uint8_t addr);
    
53. long INA226_GetShunt_Current(uint8_t addr);
    
54. uint16_t  INA226_Get_ID(uint8_t addr);
    
55. uint16_t INA226_GET_CAL_REG(uint8_t addr);
    
56. uint32_t INA226_GetVoltage(uint8_t addr);
    
57. uint32_t INA226_GetShuntVoltage(uint8_t addr);
    
58. uint16_t INA226_Get_Power(uint8_t addr);
    
59. void GetVoltage(float *Voltage);
    
60. void Get_Shunt_voltage(float *Voltage);
    
61. void Get_Shunt_Current(float *Current);
    
62. void GetPower();
    
63. extern INA226 INA226_data;
    
64. float GetV(void);
    
65. #endif

复制代码

由于这个电路参考电压是负值，所以在计算电压时需要减去这个负值，所以以后用的时候最好是接地。

参考电路接法：

cwhok163

下不了啊

一路上

cwhok163 发表于 2022-9-1 20:35
下不了啊

我试了可以呀