LibDriver INA226  1.0.0
INA226 full-featured driver
driver_ina226_alert.c
Go to the documentation of this file.
1 
37 #include "driver_ina226_alert.h"
38 
39 static ina226_handle_t gs_handle;
48 uint8_t ina226_alert_irq_handler(void)
49 {
50  if (ina226_irq_handler(&gs_handle) != 0)
51  {
52  return 1;
53  }
54 
55  return 0;
56 }
57 
70 uint8_t ina226_alert_init(ina226_address_t addr_pin, double r, ina226_mask_t mask, float threshold, void (*callback)(uint8_t type))
71 {
72  uint8_t res;
73  uint16_t reg;
74  uint16_t calibration;
75 
76  /* link interface function */
77  DRIVER_INA226_LINK_INIT(&gs_handle, ina226_handle_t);
78  DRIVER_INA226_LINK_IIC_INIT(&gs_handle, ina226_interface_iic_init);
79  DRIVER_INA226_LINK_IIC_DEINIT(&gs_handle, ina226_interface_iic_deinit);
80  DRIVER_INA226_LINK_IIC_READ(&gs_handle, ina226_interface_iic_read);
81  DRIVER_INA226_LINK_IIC_WRITE(&gs_handle, ina226_interface_iic_write);
82  DRIVER_INA226_LINK_DELAY_MS(&gs_handle, ina226_interface_delay_ms);
83  DRIVER_INA226_LINK_DEBUG_PRINT(&gs_handle, ina226_interface_debug_print);
84  DRIVER_INA226_LINK_RECEIVE_CALLBACK(&gs_handle, callback);
85 
86  /* set addr pin */
87  res = ina226_set_addr_pin(&gs_handle, addr_pin);
88  if (res != 0)
89  {
90  ina226_interface_debug_print("ina226: set addr pin failed.\n");
91 
92  return 1;
93  }
94 
95  /* set the r */
96  res = ina226_set_resistance(&gs_handle, r);
97  if (res != 0)
98  {
99  ina226_interface_debug_print("ina226: set resistance failed.\n");
100 
101  return 1;
102  }
103 
104  /* init */
105  res = ina226_init(&gs_handle);
106  if (res != 0)
107  {
108  ina226_interface_debug_print("ina226: init failed.\n");
109 
110  return 1;
111  }
112 
113  /* set default average mode */
114  res = ina226_set_average_mode(&gs_handle, INA226_ALERT_DEFAULT_AVG_MODE);
115  if (res != 0)
116  {
117  ina226_interface_debug_print("ina226: set average mode failed.\n");
118  (void)ina226_deinit(&gs_handle);
119 
120  return 1;
121  }
122 
123  /* set default bus voltage conversion time */
124  res = ina226_set_bus_voltage_conversion_time(&gs_handle, INA226_ALERT_DEFAULT_BUS_VOLTAGE_CONVERSION_TIME);
125  if (res != 0)
126  {
127  ina226_interface_debug_print("ina226: set bus voltage conversion time failed.\n");
128  (void)ina226_deinit(&gs_handle);
129 
130  return 1;
131  }
132 
133  /* set default shunt voltage conversion time */
134  res = ina226_set_shunt_voltage_conversion_time(&gs_handle, INA226_ALERT_DEFAULT_SHUNT_VOLTAGE_CONVERSION_TIME);
135  if (res != 0)
136  {
137  ina226_interface_debug_print("ina226: set shunt voltage conversion time failed.\n");
138  (void)ina226_deinit(&gs_handle);
139 
140  return 1;
141  }
142 
143  /* calculate calibration */
144  res = ina226_calculate_calibration(&gs_handle, (uint16_t *)&calibration);
145  if (res != 0)
146  {
147  ina226_interface_debug_print("ina226: calculate calibration failed.\n");
148  (void)ina226_deinit(&gs_handle);
149 
150  return 1;
151  }
152  res = ina226_set_calibration(&gs_handle, calibration);
153  if (res != 0)
154  {
155  ina226_interface_debug_print("ina226: set calibration failed.\n");
156  (void)ina226_deinit(&gs_handle);
157 
158  return 1;
159  }
160 
161  /* set default conversion ready alert pin */
162  res = ina226_set_conversion_ready_alert_pin(&gs_handle, INA226_ALERT_DEFAULT_READY_ALERT_PIN);
163  if (res != 0)
164  {
165  ina226_interface_debug_print("ina226: set conversion ready alert pin failed.\n");
166  (void)ina226_deinit(&gs_handle);
167 
168  return 1;
169  }
170 
171  /* set default alert polarity pin */
172  res = ina226_set_alert_polarity_pin(&gs_handle, INA226_ALERT_DEFAULT_ALERT_POLARITY_NORMAL);
173  if (res != 0)
174  {
175  ina226_interface_debug_print("ina226: set alert polarity pin failed.\n");
176  (void)ina226_deinit(&gs_handle);
177 
178  return 1;
179  }
180 
181  /* set default alert latch */
182  res = ina226_set_alert_latch(&gs_handle, INA226_ALERT_DEFAULT_ALERT_LATCH);
183  if (res != 0)
184  {
185  ina226_interface_debug_print("ina226: set alert latch failed.\n");
186  (void)ina226_deinit(&gs_handle);
187 
188  return 1;
189  }
190 
191  /* set shunt bus voltage continuous */
192  res = ina226_set_mode(&gs_handle, INA226_MODE_SHUNT_BUS_VOLTAGE_CONTINUOUS);
193  if (res != 0)
194  {
195  ina226_interface_debug_print("ina226: set mode failed.\n");
196  (void)ina226_deinit(&gs_handle);
197 
198  return 1;
199  }
200 
201  /* set mask */
202  if (mask == INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE)
203  {
204  /* shunt voltage convert to register */
205  res = ina226_shunt_voltage_convert_to_register(&gs_handle, threshold, &reg);
206  if (res != 0)
207  {
208  ina226_interface_debug_print("ina226: shunt voltage convert to register failed.\n");
209  (void)ina226_deinit(&gs_handle);
210 
211  return 1;
212  }
213 
214  /* set alert limit */
215  res = ina226_set_alert_limit(&gs_handle, reg);
216  if (res != 0)
217  {
218  ina226_interface_debug_print("ina226: set alert limit failed.\n");
219  (void)ina226_deinit(&gs_handle);
220 
221  return 1;
222  }
223 
224  /* enable */
225  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_TRUE);
226  if (res != 0)
227  {
228  ina226_interface_debug_print("ina226: set mask failed.\n");
229  (void)ina226_deinit(&gs_handle);
230 
231  return 1;
232  }
233 
234  /* disable */
235  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
236  if (res != 0)
237  {
238  ina226_interface_debug_print("ina226: set mask failed.\n");
239  (void)ina226_deinit(&gs_handle);
240 
241  return 1;
242  }
243 
244  /* disable */
245  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
246  if (res != 0)
247  {
248  ina226_interface_debug_print("ina226: set mask failed.\n");
249  (void)ina226_deinit(&gs_handle);
250 
251  return 1;
252  }
253 
254  /* disable */
255  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
256  if (res != 0)
257  {
258  ina226_interface_debug_print("ina226: set mask failed.\n");
259  (void)ina226_deinit(&gs_handle);
260 
261  return 1;
262  }
263 
264  /* disable */
265  res = ina226_set_mask(&gs_handle, INA226_MASK_POWER_OVER_LIMIT, INA226_BOOL_FALSE);
266  if (res != 0)
267  {
268  ina226_interface_debug_print("ina226: set mask failed.\n");
269  (void)ina226_deinit(&gs_handle);
270 
271  return 1;
272  }
273  }
274  else if (mask == INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE)
275  {
276  /* shunt voltage convert to register */
277  res = ina226_shunt_voltage_convert_to_register(&gs_handle, threshold, &reg);
278  if (res != 0)
279  {
280  ina226_interface_debug_print("ina226: shunt voltage convert to register failed.\n");
281  (void)ina226_deinit(&gs_handle);
282 
283  return 1;
284  }
285 
286  /* set alert limit */
287  res = ina226_set_alert_limit(&gs_handle, reg);
288  if (res != 0)
289  {
290  ina226_interface_debug_print("ina226: set alert limit failed.\n");
291  (void)ina226_deinit(&gs_handle);
292 
293  return 1;
294  }
295 
296  /* disable */
297  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
298  if (res != 0)
299  {
300  ina226_interface_debug_print("ina226: set mask failed.\n");
301  (void)ina226_deinit(&gs_handle);
302 
303  return 1;
304  }
305 
306  /* enable */
307  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_TRUE);
308  if (res != 0)
309  {
310  ina226_interface_debug_print("ina226: set mask failed.\n");
311  (void)ina226_deinit(&gs_handle);
312 
313  return 1;
314  }
315 
316  /* disable */
317  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
318  if (res != 0)
319  {
320  ina226_interface_debug_print("ina226: set mask failed.\n");
321  (void)ina226_deinit(&gs_handle);
322 
323  return 1;
324  }
325 
326  /* disable */
327  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
328  if (res != 0)
329  {
330  ina226_interface_debug_print("ina226: set mask failed.\n");
331  (void)ina226_deinit(&gs_handle);
332 
333  return 1;
334  }
335 
336  /* disable */
337  res = ina226_set_mask(&gs_handle, INA226_MASK_POWER_OVER_LIMIT, INA226_BOOL_FALSE);
338  if (res != 0)
339  {
340  ina226_interface_debug_print("ina226: set mask failed.\n");
341  (void)ina226_deinit(&gs_handle);
342 
343  return 1;
344  }
345  }
346  else if (mask == INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE)
347  {
348  /* bus voltage convert to register */
349  res = ina226_bus_voltage_convert_to_register(&gs_handle, threshold, &reg);
350  if (res != 0)
351  {
352  ina226_interface_debug_print("ina226: shunt voltage convert to register failed.\n");
353  (void)ina226_deinit(&gs_handle);
354 
355  return 1;
356  }
357 
358  /* set alert limit */
359  res = ina226_set_alert_limit(&gs_handle, reg);
360  if (res != 0)
361  {
362  ina226_interface_debug_print("ina226: set alert limit failed.\n");
363  (void)ina226_deinit(&gs_handle);
364 
365  return 1;
366  }
367 
368  /* disable */
369  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
370  if (res != 0)
371  {
372  ina226_interface_debug_print("ina226: set mask failed.\n");
373  (void)ina226_deinit(&gs_handle);
374 
375  return 1;
376  }
377 
378  /* disable */
379  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
380  if (res != 0)
381  {
382  ina226_interface_debug_print("ina226: set mask failed.\n");
383  (void)ina226_deinit(&gs_handle);
384 
385  return 1;
386  }
387 
388  /* enable */
389  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_TRUE);
390  if (res != 0)
391  {
392  ina226_interface_debug_print("ina226: set mask failed.\n");
393  (void)ina226_deinit(&gs_handle);
394 
395  return 1;
396  }
397 
398  /* disable */
399  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
400  if (res != 0)
401  {
402  ina226_interface_debug_print("ina226: set mask failed.\n");
403  (void)ina226_deinit(&gs_handle);
404 
405  return 1;
406  }
407 
408  /* disable */
409  res = ina226_set_mask(&gs_handle, INA226_MASK_POWER_OVER_LIMIT, INA226_BOOL_FALSE);
410  if (res != 0)
411  {
412  ina226_interface_debug_print("ina226: set mask failed.\n");
413  (void)ina226_deinit(&gs_handle);
414 
415  return 1;
416  }
417  }
418  else if (mask == INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE)
419  {
420  /* bus voltage convert to register */
421  res = ina226_bus_voltage_convert_to_register(&gs_handle, threshold, &reg);
422  if (res != 0)
423  {
424  ina226_interface_debug_print("ina226: shunt voltage convert to register failed.\n");
425  (void)ina226_deinit(&gs_handle);
426 
427  return 1;
428  }
429 
430  /* set alert limit */
431  res = ina226_set_alert_limit(&gs_handle, reg);
432  if (res != 0)
433  {
434  ina226_interface_debug_print("ina226: set alert limit failed.\n");
435  (void)ina226_deinit(&gs_handle);
436 
437  return 1;
438  }
439 
440  /* disable */
441  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
442  if (res != 0)
443  {
444  ina226_interface_debug_print("ina226: set mask failed.\n");
445  (void)ina226_deinit(&gs_handle);
446 
447  return 1;
448  }
449 
450  /* disable */
451  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
452  if (res != 0)
453  {
454  ina226_interface_debug_print("ina226: set mask failed.\n");
455  (void)ina226_deinit(&gs_handle);
456 
457  return 1;
458  }
459 
460  /* disable */
461  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
462  if (res != 0)
463  {
464  ina226_interface_debug_print("ina226: set mask failed.\n");
465  (void)ina226_deinit(&gs_handle);
466 
467  return 1;
468  }
469 
470  /* enable */
471  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_TRUE);
472  if (res != 0)
473  {
474  ina226_interface_debug_print("ina226: set mask failed.\n");
475  (void)ina226_deinit(&gs_handle);
476 
477  return 1;
478  }
479 
480  /* disable */
481  res = ina226_set_mask(&gs_handle, INA226_MASK_POWER_OVER_LIMIT, INA226_BOOL_FALSE);
482  if (res != 0)
483  {
484  ina226_interface_debug_print("ina226: set mask failed.\n");
485  (void)ina226_deinit(&gs_handle);
486 
487  return 1;
488  }
489  }
490  else
491  {
492  /* power convert to register */
493  res = ina226_power_convert_to_register(&gs_handle, threshold, &reg);
494  if (res != 0)
495  {
496  ina226_interface_debug_print("ina226: shunt voltage convert to register failed.\n");
497  (void)ina226_deinit(&gs_handle);
498 
499  return 1;
500  }
501 
502  /* set alert limit */
503  res = ina226_set_alert_limit(&gs_handle, reg);
504  if (res != 0)
505  {
506  ina226_interface_debug_print("ina226: set alert limit failed.\n");
507  (void)ina226_deinit(&gs_handle);
508 
509  return 1;
510  }
511 
512  /* disable */
513  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
514  if (res != 0)
515  {
516  ina226_interface_debug_print("ina226: set mask failed.\n");
517  (void)ina226_deinit(&gs_handle);
518 
519  return 1;
520  }
521 
522  /* disable */
523  res = ina226_set_mask(&gs_handle, INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
524  if (res != 0)
525  {
526  ina226_interface_debug_print("ina226: set mask failed.\n");
527  (void)ina226_deinit(&gs_handle);
528 
529  return 1;
530  }
531 
532  /* disable */
533  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE, INA226_BOOL_FALSE);
534  if (res != 0)
535  {
536  ina226_interface_debug_print("ina226: set mask failed.\n");
537  (void)ina226_deinit(&gs_handle);
538 
539  return 1;
540  }
541 
542  /* disable */
543  res = ina226_set_mask(&gs_handle, INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE, INA226_BOOL_FALSE);
544  if (res != 0)
545  {
546  ina226_interface_debug_print("ina226: set mask failed.\n");
547  (void)ina226_deinit(&gs_handle);
548 
549  return 1;
550  }
551 
552  /* enable */
553  res = ina226_set_mask(&gs_handle, INA226_MASK_POWER_OVER_LIMIT, INA226_BOOL_TRUE);
554  if (res != 0)
555  {
556  ina226_interface_debug_print("ina226: set mask failed.\n");
557  (void)ina226_deinit(&gs_handle);
558 
559  return 1;
560  }
561  }
562 
563  return 0;
564 }
565 
576 uint8_t ina226_alert_read(float *mV, float *mA, float *mW)
577 {
578  uint8_t res;
579  int16_t s_raw;
580  uint16_t u_raw;
581 
582  /* read bus voltage */
583  res = ina226_read_bus_voltage(&gs_handle, (uint16_t *)&u_raw, mV);
584  if (res != 0)
585  {
586  return 1;
587  }
588 
589  /* read current */
590  res = ina226_read_current(&gs_handle, (int16_t *)&s_raw, mA);
591  if (res != 0)
592  {
593  return 1;
594  }
595 
596  /* read power */
597  res = ina226_read_power(&gs_handle, (uint16_t *)&u_raw, mW);
598  if (res != 0)
599  {
600  return 1;
601  }
602 
603  return 0;
604 }
605 
613 uint8_t ina226_alert_deinit(void)
614 {
615  uint8_t res;
616 
617  res = ina226_deinit(&gs_handle);
618  if (res != 0)
619  {
620  return 1;
621  }
622 
623  return 0;
624 }
driver_ina226_alert.h
ina226_calculate_calibration
uint8_t ina226_calculate_calibration(ina226_handle_t *handle, uint16_t *calibration)
calculate the calibration
Definition: driver_ina226.c:1003
ina226_set_bus_voltage_conversion_time
uint8_t ina226_set_bus_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t t)
set bus voltage conversion time
Definition: driver_ina226.c:326
ina226_mask_t
ina226_mask_t
ina226 mask enumeration definition
Definition: driver_ina226.h:156
ina226_bus_voltage_convert_to_register
uint8_t ina226_bus_voltage_convert_to_register(ina226_handle_t *handle, float mV, uint16_t *reg)
convert the bus voltage to the register raw data
Definition: driver_ina226.c:1529
ina226_read_current
uint8_t ina226_read_current(ina226_handle_t *handle, int16_t *raw, float *mA)
read the current
Definition: driver_ina226.c:790
ina226_deinit
uint8_t ina226_deinit(ina226_handle_t *handle)
close the chip
Definition: driver_ina226.c:1836
ina226_set_conversion_ready_alert_pin
uint8_t ina226_set_conversion_ready_alert_pin(ina226_handle_t *handle, ina226_bool_t enable)
enable or disable conversion ready alert pin
Definition: driver_ina226.c:1159
ina226_set_mode
uint8_t ina226_set_mode(ina226_handle_t *handle, ina226_mode_t mode)
set the mode
Definition: driver_ina226.c:476
ina226_set_alert_polarity_pin
uint8_t ina226_set_alert_polarity_pin(ina226_handle_t *handle, ina226_alert_polarity_t pin)
set alert polarity pin
Definition: driver_ina226.c:1241
ina226_shunt_voltage_convert_to_register
uint8_t ina226_shunt_voltage_convert_to_register(ina226_handle_t *handle, float mV, uint16_t *reg)
convert the shunt voltage to the register raw data
Definition: driver_ina226.c:1475
ina226_set_mask
uint8_t ina226_set_mask(ina226_handle_t *handle, ina226_mask_t mask, ina226_bool_t enable)
enable or disable mask
Definition: driver_ina226.c:1076
ina226_set_addr_pin
uint8_t ina226_set_addr_pin(ina226_handle_t *handle, ina226_address_t addr_pin)
set the iic address pin
Definition: driver_ina226.c:170
ina226_set_alert_latch
uint8_t ina226_set_alert_latch(ina226_handle_t *handle, ina226_bool_t enable)
enable or disable alert latch
Definition: driver_ina226.c:1323
ina226_read_power
uint8_t ina226_read_power(ina226_handle_t *handle, uint16_t *raw, float *mW)
read the power
Definition: driver_ina226.c:883
ina226_set_average_mode
uint8_t ina226_set_average_mode(ina226_handle_t *handle, ina226_avg_t mode)
set average mode
Definition: driver_ina226.c:251
ina226_address_t
ina226_address_t
ina226 address enumeration definition
Definition: driver_ina226.h:70
ina226_irq_handler
uint8_t ina226_irq_handler(ina226_handle_t *handle)
irq handler
Definition: driver_ina226.c:1636
ina226_init
uint8_t ina226_init(ina226_handle_t *handle)
initialize the chip
Definition: driver_ina226.c:1715
ina226_set_shunt_voltage_conversion_time
uint8_t ina226_set_shunt_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t t)
set shunt voltage conversion time
Definition: driver_ina226.c:401
ina226_set_alert_limit
uint8_t ina226_set_alert_limit(ina226_handle_t *handle, uint16_t reg)
set alert limit
Definition: driver_ina226.c:1405
ina226_set_calibration
uint8_t ina226_set_calibration(ina226_handle_t *handle, uint16_t data)
set the calibration
Definition: driver_ina226.c:1040
ina226_set_resistance
uint8_t ina226_set_resistance(ina226_handle_t *handle, double resistance)
set the resistance
Definition: driver_ina226.c:128
ina226_power_convert_to_register
uint8_t ina226_power_convert_to_register(ina226_handle_t *handle, float mW, uint16_t *reg)
convert the power to the register raw data
Definition: driver_ina226.c:1583
ina226_read_bus_voltage
uint8_t ina226_read_bus_voltage(ina226_handle_t *handle, uint16_t *raw, float *mV)
read the bus voltage
Definition: driver_ina226.c:703
INA226_MASK_POWER_OVER_LIMIT
@ INA226_MASK_POWER_OVER_LIMIT
Definition: driver_ina226.h:161
INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE
@ INA226_MASK_SHUNT_VOLTAGE_UNDER_VOLTAGE
Definition: driver_ina226.h:158
INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE
@ INA226_MASK_SHUNT_VOLTAGE_OVER_VOLTAGE
Definition: driver_ina226.h:157
INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE
@ INA226_MASK_BUS_VOLTAGE_OVER_VOLTAGE
Definition: driver_ina226.h:159
INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE
@ INA226_MASK_BUS_VOLTAGE_UNDER_VOLTAGE
Definition: driver_ina226.h:160
INA226_MODE_SHUNT_BUS_VOLTAGE_CONTINUOUS
@ INA226_MODE_SHUNT_BUS_VOLTAGE_CONTINUOUS
Definition: driver_ina226.h:137
INA226_BOOL_TRUE
@ INA226_BOOL_TRUE
Definition: driver_ina226.h:95
INA226_BOOL_FALSE
@ INA226_BOOL_FALSE
Definition: driver_ina226.h:94
ina226_alert_init
uint8_t ina226_alert_init(ina226_address_t addr_pin, double r, ina226_mask_t mask, float threshold, void(*callback)(uint8_t type))
alert example init
Definition: driver_ina226_alert.c:70
ina226_alert_deinit
uint8_t ina226_alert_deinit(void)
alert example deinit
Definition: driver_ina226_alert.c:613
INA226_ALERT_DEFAULT_ALERT_POLARITY_NORMAL
#define INA226_ALERT_DEFAULT_ALERT_POLARITY_NORMAL
Definition: driver_ina226_alert.h:58
ina226_alert_irq_handler
uint8_t ina226_alert_irq_handler(void)
alert irq handler
Definition: driver_ina226_alert.c:48
INA226_ALERT_DEFAULT_SHUNT_VOLTAGE_CONVERSION_TIME
#define INA226_ALERT_DEFAULT_SHUNT_VOLTAGE_CONVERSION_TIME
Definition: driver_ina226_alert.h:56
INA226_ALERT_DEFAULT_READY_ALERT_PIN
#define INA226_ALERT_DEFAULT_READY_ALERT_PIN
Definition: driver_ina226_alert.h:57
INA226_ALERT_DEFAULT_BUS_VOLTAGE_CONVERSION_TIME
#define INA226_ALERT_DEFAULT_BUS_VOLTAGE_CONVERSION_TIME
Definition: driver_ina226_alert.h:55
ina226_alert_read
uint8_t ina226_alert_read(float *mV, float *mA, float *mW)
alert example read
Definition: driver_ina226_alert.c:576
INA226_ALERT_DEFAULT_AVG_MODE
#define INA226_ALERT_DEFAULT_AVG_MODE
ina226 alert example default definition
Definition: driver_ina226_alert.h:54
INA226_ALERT_DEFAULT_ALERT_LATCH
#define INA226_ALERT_DEFAULT_ALERT_LATCH
Definition: driver_ina226_alert.h:59
ina226_interface_iic_deinit
uint8_t ina226_interface_iic_deinit(void)
interface iic bus deinit
Definition: driver_ina226_interface_template.c:58
ina226_interface_iic_init
uint8_t ina226_interface_iic_init(void)
interface iic bus init
Definition: driver_ina226_interface_template.c:46
ina226_interface_delay_ms
void ina226_interface_delay_ms(uint32_t ms)
interface delay ms
Definition: driver_ina226_interface_template.c:100
ina226_interface_iic_write
uint8_t ina226_interface_iic_write(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
interface iic bus write
Definition: driver_ina226_interface_template.c:90
ina226_interface_debug_print
void ina226_interface_debug_print(const char *const fmt,...)
interface print format data
Definition: driver_ina226_interface_template.c:110
ina226_interface_iic_read
uint8_t ina226_interface_iic_read(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
interface iic bus read
Definition: driver_ina226_interface_template.c:74
DRIVER_INA226_LINK_INIT
#define DRIVER_INA226_LINK_INIT(HANDLE, STRUCTURE)
initialize ina226_handle_t structure
Definition: driver_ina226.h:225
DRIVER_INA226_LINK_DEBUG_PRINT
#define DRIVER_INA226_LINK_DEBUG_PRINT(HANDLE, FUC)
link debug_print function
Definition: driver_ina226.h:273
DRIVER_INA226_LINK_RECEIVE_CALLBACK
#define DRIVER_INA226_LINK_RECEIVE_CALLBACK(HANDLE, FUC)
link receive_callback function
Definition: driver_ina226.h:281
DRIVER_INA226_LINK_IIC_READ
#define DRIVER_INA226_LINK_IIC_READ(HANDLE, FUC)
link iic_read function
Definition: driver_ina226.h:249
DRIVER_INA226_LINK_DELAY_MS
#define DRIVER_INA226_LINK_DELAY_MS(HANDLE, FUC)
link delay_ms function
Definition: driver_ina226.h:265
DRIVER_INA226_LINK_IIC_DEINIT
#define DRIVER_INA226_LINK_IIC_DEINIT(HANDLE, FUC)
link iic_deinit function
Definition: driver_ina226.h:241
DRIVER_INA226_LINK_IIC_INIT
#define DRIVER_INA226_LINK_IIC_INIT(HANDLE, FUC)
link iic_init function
Definition: driver_ina226.h:233
DRIVER_INA226_LINK_IIC_WRITE
#define DRIVER_INA226_LINK_IIC_WRITE(HANDLE, FUC)
link iic_write function
Definition: driver_ina226.h:257
ina226_handle_s
ina226 handle structure definition
Definition: driver_ina226.h:177