LibDriver INA226
Loading...
Searching...
No Matches
driver_ina226.c
Go to the documentation of this file.
1
36
37#include "driver_ina226.h"
38#include <math.h>
39
43#define CHIP_NAME "Texas Instruments INA226"
44#define MANUFACTURER_NAME "Texas Instruments"
45#define SUPPLY_VOLTAGE_MIN 2.7f
46#define SUPPLY_VOLTAGE_MAX 5.5f
47#define MAX_CURRENT 0.33f
48#define TEMPERATURE_MIN -40.0f
49#define TEMPERATURE_MAX 125.0f
50#define DRIVER_VERSION 1000
51
55#define INA226_REG_CONF 0x00
56#define INA226_REG_SHUNT_VOLTAGE 0x01
57#define INA226_REG_BUS_VOLTAGE 0x02
58#define INA226_REG_POWER 0x03
59#define INA226_REG_CURRENT 0x04
60#define INA226_REG_CALIBRATION 0x05
61#define INA226_REG_MASK 0x06
62#define INA226_REG_ALERT_LIMIT 0x07
63#define INA226_REG_MANUFACTURER 0xFE
64#define INA226_REG_DIE 0xFF
65
76static uint8_t a_ina226_iic_read(ina226_handle_t *handle, uint8_t reg, uint16_t *data)
77{
78 uint8_t buf[2];
79
80 memset(buf, 0, sizeof(uint8_t) * 2); /* clear the buffer */
81 if (handle->iic_read(handle->iic_addr, reg, (uint8_t *)buf, 2) != 0) /* read data */
82 {
83 return 1; /* return error */
84 }
85 else
86 {
87 *data = (uint16_t)buf[0] << 8 | buf[1]; /* get data */
88
89 return 0; /* success return 0 */
90 }
91}
92
103static uint8_t a_ina226_iic_write(ina226_handle_t *handle, uint8_t reg, uint16_t data)
104{
105 uint8_t buf[2];
106
107 buf[0] = (uint8_t)((data >> 8) & 0xFF); /* get MSB */
108 buf[1] = (uint8_t)((data >> 0) & 0xFF); /* get LSB */
109 if (handle->iic_write(handle->iic_addr, reg, (uint8_t *)buf, 2) != 0) /* write data */
110 {
111 return 1; /* return error */
112 }
113 else
114 {
115 return 0; /* success return 0 */
116 }
117}
118
128uint8_t ina226_set_resistance(ina226_handle_t *handle, double resistance)
129{
130 if (handle == NULL) /* check handle */
131 {
132 return 2; /* return error */
133 }
134
135 handle->r = resistance; /* set resistance */
136
137 return 0; /* success return 0 */
138}
139
149uint8_t ina226_get_resistance(ina226_handle_t *handle, double *resistance)
150{
151 if (handle == NULL) /* check handle */
152 {
153 return 2; /* return error */
154 }
155
156 *resistance = handle->r; /* get resistance */
157
158 return 0; /* success return 0 */
159}
160
170uint8_t ina226_set_addr_pin(ina226_handle_t *handle, ina226_address_t addr_pin)
171{
172 if (handle == NULL) /* check handle */
173 {
174 return 2; /* return error */
175 }
176
177 handle->iic_addr = (uint8_t)addr_pin; /* set pin */
178
179 return 0; /* success return 0 */
180}
181
191uint8_t ina226_get_addr_pin(ina226_handle_t *handle, ina226_address_t *addr_pin)
192{
193 if (handle == NULL) /* check handle */
194 {
195 return 2; /* return error */
196 }
197
198 *addr_pin = (ina226_address_t)(handle->iic_addr); /* get pin */
199
200 return 0; /* success return 0 */
201}
202
213uint8_t ina226_soft_reset(ina226_handle_t *handle)
214{
215 uint8_t res;
216 uint16_t prev;
217
218 if (handle == NULL) /* check handle */
219 {
220 return 2; /* return error */
221 }
222 if (handle->inited != 1) /* check handle initialization */
223 {
224 return 3; /* return error */
225 }
226
227 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
228 if (res != 0) /* check result */
229 {
230 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
231
232 return 1; /* return error */
233 }
234 prev &= ~(1 << 15); /* clear soft reset */
235 prev |= 1 << 15; /* set soft reset */
236
237 return a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
238}
239
251uint8_t ina226_set_average_mode(ina226_handle_t *handle, ina226_avg_t mode)
252{
253 uint8_t res;
254 uint16_t prev;
255
256 if (handle == NULL) /* check handle */
257 {
258 return 2; /* return error */
259 }
260 if (handle->inited != 1) /* check handle initialization */
261 {
262 return 3; /* return error */
263 }
264
265 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
266 if (res != 0) /* check result */
267 {
268 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
269
270 return 1; /* return error */
271 }
272 prev &= ~(0x7 << 9); /* clear mode bits */
273 prev |= mode << 9; /* set mode bits */
274
275 return a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
276}
277
289uint8_t ina226_get_average_mode(ina226_handle_t *handle, ina226_avg_t *mode)
290{
291 uint8_t res;
292 uint16_t prev;
293
294 if (handle == NULL) /* check handle */
295 {
296 return 2; /* return error */
297 }
298 if (handle->inited != 1) /* check handle initialization */
299 {
300 return 3; /* return error */
301 }
302
303 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
304 if (res != 0) /* check result */
305 {
306 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
307
308 return 1; /* return error */
309 }
310 *mode = (ina226_avg_t)((prev >> 9) & 0x07); /* get mode */
311
312 return 0; /* success return 0 */
313}
314
326uint8_t ina226_set_bus_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t t)
327{
328 uint8_t res;
329 uint16_t prev;
330
331 if (handle == NULL) /* check handle */
332 {
333 return 2; /* return error */
334 }
335 if (handle->inited != 1) /* check handle initialization */
336 {
337 return 3; /* return error */
338 }
339
340 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
341 if (res != 0) /* check result */
342 {
343 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
344
345 return 1; /* return error */
346 }
347 prev &= ~(7 << 6); /* clear time bits */
348 prev |= t << 6; /* set time bits */
349
350 return a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
351}
352
364uint8_t ina226_get_bus_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t *t)
365{
366 uint8_t res;
367 uint16_t prev;
368
369 if (handle == NULL) /* check handle */
370 {
371 return 2; /* return error */
372 }
373 if (handle->inited != 1) /* check handle initialization */
374 {
375 return 3; /* return error */
376 }
377
378 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
379 if (res != 0) /* check result */
380 {
381 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
382
383 return 1; /* return error */
384 }
385 *t = (ina226_conversion_time_t)((prev >> 6) & 0x07); /* get time */
386
387 return 0; /* success return 0 */
388}
389
401uint8_t ina226_set_shunt_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t t)
402{
403 uint8_t res;
404 uint16_t prev;
405
406 if (handle == NULL) /* check handle */
407 {
408 return 2; /* return error */
409 }
410 if (handle->inited != 1) /* check handle initialization */
411 {
412 return 3; /* return error */
413 }
414
415 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
416 if (res != 0) /* check result */
417 {
418 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
419
420 return 1; /* return error */
421 }
422 prev &= ~(7 << 3); /* clear time bits */
423 prev |= t << 3; /* set time bits */
424
425 return a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
426}
427
439uint8_t ina226_get_shunt_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t *t)
440{
441 uint8_t res;
442 uint16_t prev;
443
444 if (handle == NULL) /* check handle */
445 {
446 return 2; /* return error */
447 }
448 if (handle->inited != 1) /* check handle initialization */
449 {
450 return 3; /* return error */
451 }
452
453 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
454 if (res != 0) /* check result */
455 {
456 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
457
458 return 1; /* return error */
459 }
460 *t = (ina226_conversion_time_t)((prev >> 3) & 0x07); /* get time */
461
462 return 0; /* success return 0 */
463}
464
476uint8_t ina226_set_mode(ina226_handle_t *handle, ina226_mode_t mode)
477{
478 uint8_t res;
479 uint16_t prev;
480
481 if (handle == NULL) /* check handle */
482 {
483 return 2; /* return error */
484 }
485 if (handle->inited != 1) /* check handle initialization */
486 {
487 return 3; /* return error */
488 }
489
490 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
491 if (res != 0) /* check result */
492 {
493 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
494
495 return 1; /* return error */
496 }
497 prev &= ~(0x7 << 0); /* clear mode bit */
498 prev |= mode << 0; /* set mode bit */
499 res = a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
500 if (res != 0) /* check result */
501 {
502 handle->debug_print("ina226: write conf register failed.\n"); /* write conf register failed */
503
504 return 1; /* return error */
505 }
506 if ((mode == INA226_MODE_SHUNT_VOLTAGE_TRIGGERED) ||
507 (mode == INA226_MODE_BUS_VOLTAGE_TRIGGERED) ||
508 (mode == INA226_MODE_SHUNT_BUS_VOLTAGE_TRIGGERED)) /* check triggered mode */
509 {
510 handle->trigger = 1; /* set 1 */
511 }
512 else
513 {
514 handle->trigger = 0; /* set 0 */
515 }
516
517 return 0; /* success return 0 */
518}
519
531uint8_t ina226_get_mode(ina226_handle_t *handle, ina226_mode_t *mode)
532{
533 uint8_t res;
534 uint16_t prev;
535
536 if (handle == NULL) /* check handle */
537 {
538 return 2; /* return error */
539 }
540 if (handle->inited != 1) /* check handle initialization */
541 {
542 return 3; /* return error */
543 }
544
545 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
546 if (res != 0) /* check result */
547 {
548 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
549
550 return 1; /* return error */
551 }
552 *mode = (ina226_mode_t)((prev >> 0) & 0x7); /* get mode */
553
554 return 0; /* success return 0 */
555}
556
569uint8_t ina226_get_die_id(ina226_handle_t *handle, uint16_t *device_id, uint8_t *die_revision_id)
570{
571 uint8_t res;
572 uint16_t prev;
573
574 if (handle == NULL) /* check handle */
575 {
576 return 2; /* return error */
577 }
578 if (handle->inited != 1) /* check handle initialization */
579 {
580 return 3; /* return error */
581 }
582
583 res = a_ina226_iic_read(handle, INA226_REG_DIE, (uint16_t *)&prev); /* read config */
584 if (res != 0) /* check result */
585 {
586 handle->debug_print("ina226: read die register failed.\n"); /* read die register failed */
587
588 return 1; /* return error */
589 }
590 *device_id = (prev >> 4) & 0xFFF; /* get device id */
591 *die_revision_id = prev & 0xF; /* get die revision id */
592
593 return 0; /* success return 0 */
594}
595
610uint8_t ina226_read_shunt_voltage(ina226_handle_t *handle, int16_t *raw, float *mV)
611{
612 uint8_t res;
613 union
614 {
615 uint16_t u;
616 int16_t s;
617 } u;
618 uint16_t prev;
619
620 if (handle == NULL) /* check handle */
621 {
622 return 2; /* return error */
623 }
624 if (handle->inited != 1) /* check handle initialization */
625 {
626 return 3; /* return error */
627 }
628
629 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
630 if (res != 0) /* check result */
631 {
632 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
633
634 return 1; /* return error */
635 }
636 if ((prev & (1 << 2)) != 0) /* check math overflow */
637 {
638 handle->debug_print("ina226: math overflow.\n"); /* math overflow */
639
640 return 4; /* return error */
641 }
642 if (handle->trigger != 0) /* trigger mode */
643 {
644 uint16_t i;
645 uint16_t timeout;
646
647 if ((prev & (1 << 3)) == 0) /* check last mask conversion ready flag */
648 {
649 timeout = INA226_READ_TIMEOUT; /* set timeout */
650 for (i = 0; i< timeout; i++) /* loop all */
651 {
652 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
653 if (res != 0) /* check result */
654 {
655 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
656
657 return 1; /* return error */
658 }
659 if ((prev & (1 << 3)) != 0) /* check conversion ready flag */
660 {
661 break; /* break */
662 }
663 handle->delay_ms(1); /* delay 1ms */
664 timeout--; /* timeout-- */
665 }
666 if (timeout == 0) /* check timeout */
667 {
668 handle->debug_print("ina226: read timeout.\n"); /* timeout */
669
670 return 5; /* return error */
671 }
672 }
673 handle->trigger = 0; /* set 0 */
674 }
675
676 res = a_ina226_iic_read(handle, INA226_REG_SHUNT_VOLTAGE, (uint16_t *)&u.u); /* read shunt voltage */
677 if (res != 0) /* check result */
678 {
679 handle->debug_print("ina226: read shunt voltage register failed.\n"); /* read shunt voltage register failed */
680
681 return 1; /* return error */
682 }
683 *raw = u.s; /* set the raw */
684 *mV = (float)(*raw) / 400.0f; /* set the converted data */
685
686 return 0; /* success return 0 */
687}
688
703uint8_t ina226_read_bus_voltage(ina226_handle_t *handle, uint16_t *raw, float *mV)
704{
705 uint8_t res;
706 uint16_t prev;
707
708 if (handle == NULL) /* check handle */
709 {
710 return 2; /* return error */
711 }
712 if (handle->inited != 1) /* check handle initialization */
713 {
714 return 3; /* return error */
715 }
716
717 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
718 if (res != 0) /* check result */
719 {
720 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
721
722 return 1; /* return error */
723 }
724 if ((prev & (1 << 2)) != 0) /* check math overflow */
725 {
726 handle->debug_print("ina226: math overflow.\n"); /* math overflow */
727
728 return 4; /* return error */
729 }
730 if (handle->trigger != 0) /* trigger mode */
731 {
732 uint16_t i;
733 uint16_t timeout;
734
735 if ((prev & (1 << 3)) == 0) /* check last mask conversion ready flag */
736 {
737 timeout = INA226_READ_TIMEOUT; /* set timeout */
738 for (i = 0; i< timeout; i++) /* loop all */
739 {
740 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
741 if (res != 0) /* check result */
742 {
743 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
744
745 return 1; /* return error */
746 }
747 if ((prev & (1 << 3)) != 0) /* check conversion ready flag */
748 {
749 break; /* break */
750 }
751 handle->delay_ms(1); /* delay 1ms */
752 timeout--; /* timeout-- */
753 }
754 if (timeout == 0) /* check timeout */
755 {
756 handle->debug_print("ina226: read timeout.\n"); /* timeout */
757
758 return 5; /* return error */
759 }
760 }
761 handle->trigger = 0; /* set 0 */
762 }
763
764 res = a_ina226_iic_read(handle, INA226_REG_BUS_VOLTAGE, (uint16_t *)raw); /* read bus voltage */
765 if (res != 0) /* check result */
766 {
767 handle->debug_print("ina226: read bus voltage register failed.\n"); /* read bus voltage register failed */
768
769 return 1; /* return error */
770 }
771 *mV = (float)(*raw) * 1.25f; /* set the converted data */
772
773 return 0; /* success return 0 */
774}
775
790uint8_t ina226_read_current(ina226_handle_t *handle, int16_t *raw, float *mA)
791{
792 uint8_t res;
793 union
794 {
795 uint16_t u;
796 int16_t s;
797 } u;
798 uint16_t prev;
799
800 if (handle == NULL) /* check handle */
801 {
802 return 2; /* return error */
803 }
804 if (handle->inited != 1) /* check handle initialization */
805 {
806 return 3; /* return error */
807 }
808
809 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
810 if (res != 0) /* check result */
811 {
812 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
813
814 return 1; /* return error */
815 }
816 if ((prev & (1 << 2)) != 0) /* check math overflow */
817 {
818 handle->debug_print("ina226: math overflow.\n"); /* math overflow */
819
820 return 4; /* return error */
821 }
822 if (handle->trigger != 0) /* trigger mode */
823 {
824 uint16_t i;
825 uint16_t timeout;
826
827 if ((prev & (1 << 3)) == 0) /* check last mask conversion ready flag */
828 {
829 timeout = INA226_READ_TIMEOUT; /* set timeout */
830 for (i = 0; i< timeout; i++) /* loop all */
831 {
832 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
833 if (res != 0) /* check result */
834 {
835 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
836
837 return 1; /* return error */
838 }
839 if ((prev & (1 << 3)) != 0) /* check conversion ready flag */
840 {
841 break; /* break */
842 }
843 handle->delay_ms(1); /* delay 1ms */
844 timeout--; /* timeout-- */
845 }
846 if (timeout == 0) /* check timeout */
847 {
848 handle->debug_print("ina226: read timeout.\n"); /* timeout */
849
850 return 5; /* return error */
851 }
852 }
853 handle->trigger = 0; /* set 0 */
854 }
855
856 res = a_ina226_iic_read(handle, INA226_REG_CURRENT, (uint16_t *)&u.u); /* read current */
857 if (res != 0) /* check result */
858 {
859 handle->debug_print("ina226: read current register failed.\n"); /* read current register failed */
860
861 return 1; /* return error */
862 }
863 *raw = u.s; /* set the raw */
864 *mA = (float)((double)(*raw) * handle->current_lsb * 1000); /* set the converted data */
865
866 return 0; /* success return 0 */
867}
868
883uint8_t ina226_read_power(ina226_handle_t *handle, uint16_t *raw, float *mW)
884{
885 uint8_t res;
886 uint16_t prev;
887
888 if (handle == NULL) /* check handle */
889 {
890 return 2; /* return error */
891 }
892 if (handle->inited != 1) /* check handle initialization */
893 {
894 return 3; /* return error */
895 }
896
897 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
898 if (res != 0) /* check result */
899 {
900 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
901
902 return 1; /* return error */
903 }
904 if ((prev & (1 << 2)) != 0) /* check math overflow */
905 {
906 handle->debug_print("ina226: math overflow.\n"); /* math overflow */
907
908 return 4; /* return error */
909 }
910 if (handle->trigger != 0) /* trigger mode */
911 {
912 uint16_t i;
913 uint16_t timeout;
914
915 if ((prev & (1 << 3)) == 0) /* check last mask conversion ready flag */
916 {
917 timeout = INA226_READ_TIMEOUT; /* set timeout */
918 for (i = 0; i< timeout; i++) /* loop all */
919 {
920 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
921 if (res != 0) /* check result */
922 {
923 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
924
925 return 1; /* return error */
926 }
927 if ((prev & (1 << 3)) != 0) /* check conversion ready flag */
928 {
929 break; /* break */
930 }
931 handle->delay_ms(1); /* delay 1ms */
932 timeout--; /* timeout-- */
933 }
934 if (timeout == 0) /* check timeout */
935 {
936 handle->debug_print("ina226: read timeout.\n"); /* timeout */
937
938 return 5; /* return error */
939 }
940 }
941 handle->trigger = 0; /* set 0 */
942 }
943
944 res = a_ina226_iic_read(handle, INA226_REG_POWER, (uint16_t *)raw); /* read power */
945 if (res != 0) /* check result */
946 {
947 handle->debug_print("ina226: read power register failed.\n"); /* read power register failed */
948
949 return 1; /* return error */
950 }
951 *mW = (float)((double)(*raw) * handle->current_lsb * 25.0 * 1000.0); /* set the converted data */
952
953 return 0; /* success return 0 */
954}
955
967uint8_t ina226_get_calibration(ina226_handle_t *handle, uint16_t *data)
968{
969 uint8_t res;
970
971 if (handle == NULL) /* check handle */
972 {
973 return 2; /* return error */
974 }
975 if (handle->inited != 1) /* check handle initialization */
976 {
977 return 3; /* return error */
978 }
979
980 res = a_ina226_iic_read(handle, INA226_REG_CALIBRATION, (uint16_t *)data); /* read calibration */
981 if (res != 0) /* check result */
982 {
983 handle->debug_print("ina226: read calibration register failed.\n"); /* read calibration register failed */
984
985 return 1; /* return error */
986 }
987
988 return 0; /* success return 0 */
989}
990
1003uint8_t ina226_calculate_calibration(ina226_handle_t *handle, uint16_t *calibration)
1004{
1005 double v;
1006
1007 if (handle == NULL) /* check handle */
1008 {
1009 return 2; /* return error */
1010 }
1011 if (handle->inited != 1) /* check handle initialization */
1012 {
1013 return 3; /* return error */
1014 }
1015 if ((handle->r >= -0.000001f) && (handle->r <= 0.000001f)) /* check the r */
1016 {
1017 handle->debug_print("ina226: r can't be zero.\n"); /* r can't be zero */
1018
1019 return 4; /* return error */
1020 }
1021
1022 v = 0.08192; /* set max range */
1023 handle->current_lsb = v / handle->r / pow(2.0, 15.0); /* current lsb */
1024 *calibration = (uint16_t)(0.00512 / (v / pow(2.0, 15.0))); /* set calibration */
1025
1026 return 0; /* success return 0 */
1027}
1028
1040uint8_t ina226_set_calibration(ina226_handle_t *handle, uint16_t data)
1041{
1042 uint8_t res;
1043
1044 if (handle == NULL) /* check handle */
1045 {
1046 return 2; /* return error */
1047 }
1048 if (handle->inited != 1) /* check handle initialization */
1049 {
1050 return 3; /* return error */
1051 }
1052
1053 res = a_ina226_iic_write(handle, INA226_REG_CALIBRATION, data); /* write calibration */
1054 if (res != 0) /* check result */
1055 {
1056 handle->debug_print("ina226: write calibration register failed.\n"); /* write calibration register failed */
1057
1058 return 1; /* return error */
1059 }
1060
1061 return 0; /* success return 0 */
1062}
1063
1076uint8_t ina226_set_mask(ina226_handle_t *handle, ina226_mask_t mask, ina226_bool_t enable)
1077{
1078 uint8_t res;
1079 uint16_t prev;
1080
1081 if (handle == NULL) /* check handle */
1082 {
1083 return 2; /* return error */
1084 }
1085 if (handle->inited != 1) /* check handle initialization */
1086 {
1087 return 3; /* return error */
1088 }
1089
1090 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1091 if (res != 0) /* check result */
1092 {
1093 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1094
1095 return 1; /* return error */
1096 }
1097 prev &= ~(1 << mask); /* clear settings */
1098 prev |= (enable << mask); /* set mask */
1099 res = a_ina226_iic_write(handle, INA226_REG_MASK, prev); /* write mask */
1100 if (res != 0) /* check result */
1101 {
1102 handle->debug_print("ina226: write mask register failed.\n"); /* write mask register failed */
1103
1104 return 1; /* return error */
1105 }
1106
1107 return 0; /* success return 0 */
1108}
1109
1122uint8_t ina226_get_mask(ina226_handle_t *handle, ina226_mask_t mask, ina226_bool_t *enable)
1123{
1124 uint8_t res;
1125 uint16_t prev;
1126
1127 if (handle == NULL) /* check handle */
1128 {
1129 return 2; /* return error */
1130 }
1131 if (handle->inited != 1) /* check handle initialization */
1132 {
1133 return 3; /* return error */
1134 }
1135
1136 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1137 if (res != 0) /* check result */
1138 {
1139 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1140
1141 return 1; /* return error */
1142 }
1143 *enable = (ina226_bool_t)((prev >> mask) & 0x01); /* get bool */
1144
1145 return 0; /* success return 0 */
1146}
1147
1159uint8_t ina226_set_conversion_ready_alert_pin(ina226_handle_t *handle, ina226_bool_t enable)
1160{
1161 uint8_t res;
1162 uint16_t prev;
1163
1164 if (handle == NULL) /* check handle */
1165 {
1166 return 2; /* return error */
1167 }
1168 if (handle->inited != 1) /* check handle initialization */
1169 {
1170 return 3; /* return error */
1171 }
1172
1173 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1174 if (res != 0) /* check result */
1175 {
1176 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1177
1178 return 1; /* return error */
1179 }
1180 prev &= ~(1 << 10); /* clear settings */
1181 prev |= (enable << 10); /* set mask */
1182 res = a_ina226_iic_write(handle, INA226_REG_MASK, prev); /* write mask */
1183 if (res != 0) /* check result */
1184 {
1185 handle->debug_print("ina226: write mask register failed.\n"); /* write mask register failed */
1186
1187 return 1; /* return error */
1188 }
1189
1190 return 0; /* success return 0 */
1191}
1192
1204uint8_t ina226_get_conversion_ready_alert_pin(ina226_handle_t *handle, ina226_bool_t *enable)
1205{
1206 uint8_t res;
1207 uint16_t prev;
1208
1209 if (handle == NULL) /* check handle */
1210 {
1211 return 2; /* return error */
1212 }
1213 if (handle->inited != 1) /* check handle initialization */
1214 {
1215 return 3; /* return error */
1216 }
1217
1218 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1219 if (res != 0) /* check result */
1220 {
1221 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1222
1223 return 1; /* return error */
1224 }
1225 *enable = (ina226_bool_t)((prev >> 10) & 0x01); /* get bool */
1226
1227 return 0; /* success return 0 */
1228}
1229
1241uint8_t ina226_set_alert_polarity_pin(ina226_handle_t *handle, ina226_alert_polarity_t pin)
1242{
1243 uint8_t res;
1244 uint16_t prev;
1245
1246 if (handle == NULL) /* check handle */
1247 {
1248 return 2; /* return error */
1249 }
1250 if (handle->inited != 1) /* check handle initialization */
1251 {
1252 return 3; /* return error */
1253 }
1254
1255 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1256 if (res != 0) /* check result */
1257 {
1258 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1259
1260 return 1; /* return error */
1261 }
1262 prev &= ~(1 << 1); /* clear settings */
1263 prev |= (pin << 1); /* set mask */
1264 res = a_ina226_iic_write(handle, INA226_REG_MASK, prev); /* write mask */
1265 if (res != 0) /* check result */
1266 {
1267 handle->debug_print("ina226: write mask register failed.\n"); /* write mask register failed */
1268
1269 return 1; /* return error */
1270 }
1271
1272 return 0; /* success return 0 */
1273}
1274
1286uint8_t ina226_get_alert_polarity_pin(ina226_handle_t *handle, ina226_alert_polarity_t *pin)
1287{
1288 uint8_t res;
1289 uint16_t prev;
1290
1291 if (handle == NULL) /* check handle */
1292 {
1293 return 2; /* return error */
1294 }
1295 if (handle->inited != 1) /* check handle initialization */
1296 {
1297 return 3; /* return error */
1298 }
1299
1300 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1301 if (res != 0) /* check result */
1302 {
1303 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1304
1305 return 1; /* return error */
1306 }
1307 *pin = (ina226_alert_polarity_t)((prev >> 1) & 0x01); /* get alert polarity pin */
1308
1309 return 0; /* success return 0 */
1310}
1311
1323uint8_t ina226_set_alert_latch(ina226_handle_t *handle, ina226_bool_t enable)
1324{
1325 uint8_t res;
1326 uint16_t prev;
1327
1328 if (handle == NULL) /* check handle */
1329 {
1330 return 2; /* return error */
1331 }
1332 if (handle->inited != 1) /* check handle initialization */
1333 {
1334 return 3; /* return error */
1335 }
1336
1337 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1338 if (res != 0) /* check result */
1339 {
1340 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1341
1342 return 1; /* return error */
1343 }
1344 prev &= ~(1 << 0); /* clear settings */
1345 prev |= (enable << 0); /* set mask */
1346 res = a_ina226_iic_write(handle, INA226_REG_MASK, prev); /* write mask */
1347 if (res != 0) /* check result */
1348 {
1349 handle->debug_print("ina226: write mask register failed.\n"); /* write mask register failed */
1350
1351 return 1; /* return error */
1352 }
1353
1354 return 0; /* success return 0 */
1355}
1356
1368uint8_t ina226_get_alert_latch(ina226_handle_t *handle, ina226_bool_t *enable)
1369{
1370 uint8_t res;
1371 uint16_t prev;
1372
1373 if (handle == NULL) /* check handle */
1374 {
1375 return 2; /* return error */
1376 }
1377 if (handle->inited != 1) /* check handle initialization */
1378 {
1379 return 3; /* return error */
1380 }
1381
1382 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1383 if (res != 0) /* check result */
1384 {
1385 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1386
1387 return 1; /* return error */
1388 }
1389 *enable = (ina226_bool_t)((prev >> 0) & 0x01); /* get bool */
1390
1391 return 0; /* success return 0 */
1392}
1393
1405uint8_t ina226_set_alert_limit(ina226_handle_t *handle, uint16_t reg)
1406{
1407 uint8_t res;
1408
1409 if (handle == NULL) /* check handle */
1410 {
1411 return 2; /* return error */
1412 }
1413 if (handle->inited != 1) /* check handle initialization */
1414 {
1415 return 3; /* return error */
1416 }
1417
1418 res = a_ina226_iic_write(handle, INA226_REG_ALERT_LIMIT, reg); /* write config */
1419 if (res != 0) /* check result */
1420 {
1421 handle->debug_print("ina226: write alert limit register failed.\n"); /* write alert limit register failed */
1422
1423 return 1; /* return error */
1424 }
1425
1426 return 0; /* success return 0 */
1427}
1428
1440uint8_t ina226_get_alert_limit(ina226_handle_t *handle, uint16_t *reg)
1441{
1442 uint8_t res;
1443
1444 if (handle == NULL) /* check handle */
1445 {
1446 return 2; /* return error */
1447 }
1448 if (handle->inited != 1) /* check handle initialization */
1449 {
1450 return 3; /* return error */
1451 }
1452
1453 res = a_ina226_iic_read(handle, INA226_REG_ALERT_LIMIT, reg); /* read config */
1454 if (res != 0) /* check result */
1455 {
1456 handle->debug_print("ina226: read alert limit register failed.\n"); /* read alert limit register failed */
1457
1458 return 1; /* return error */
1459 }
1460
1461 return 0; /* success return 0 */
1462}
1463
1475uint8_t ina226_shunt_voltage_convert_to_register(ina226_handle_t *handle, float mV, uint16_t *reg)
1476{
1477 if (handle == NULL) /* check handle */
1478 {
1479 return 2; /* return error */
1480 }
1481 if (handle->inited != 1) /* check handle initialization */
1482 {
1483 return 3; /* return error */
1484 }
1485
1486 *reg = (uint16_t)(mV * 400.0f); /* convert real data to register data */
1487
1488 return 0; /* success return 0 */
1489}
1490
1502uint8_t ina226_shunt_voltage_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mV)
1503{
1504 if (handle == NULL) /* check handle */
1505 {
1506 return 2; /* return error */
1507 }
1508 if (handle->inited != 1) /* check handle initialization */
1509 {
1510 return 3; /* return error */
1511 }
1512
1513 *mV = (float)(reg) / 400.0f; /* convert real data to register data */
1514
1515 return 0; /* success return 0 */
1516}
1517
1529uint8_t ina226_bus_voltage_convert_to_register(ina226_handle_t *handle, float mV, uint16_t *reg)
1530{
1531 if (handle == NULL) /* check handle */
1532 {
1533 return 2; /* return error */
1534 }
1535 if (handle->inited != 1) /* check handle initialization */
1536 {
1537 return 3; /* return error */
1538 }
1539
1540 *reg = (uint16_t)(mV / 1.25f); /* convert real data to register data */
1541
1542 return 0; /* success return 0 */
1543}
1544
1556uint8_t ina226_bus_voltage_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mV)
1557{
1558 if (handle == NULL) /* check handle */
1559 {
1560 return 2; /* return error */
1561 }
1562 if (handle->inited != 1) /* check handle initialization */
1563 {
1564 return 3; /* return error */
1565 }
1566
1567 *mV = (float)(reg) * 1.25f; /* convert real data to register data */
1568
1569 return 0; /* success return 0 */
1570}
1571
1583uint8_t ina226_power_convert_to_register(ina226_handle_t *handle, float mW, uint16_t *reg)
1584{
1585 if (handle == NULL) /* check handle */
1586 {
1587 return 2; /* return error */
1588 }
1589 if (handle->inited != 1) /* check handle initialization */
1590 {
1591 return 3; /* return error */
1592 }
1593
1594 *reg = (uint16_t)((double)(mW) / (handle->current_lsb * 25.0 * 1000.0)); /* set the converted data */
1595
1596 return 0; /* success return 0 */
1597}
1598
1610uint8_t ina226_power_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mW)
1611{
1612 if (handle == NULL) /* check handle */
1613 {
1614 return 2; /* return error */
1615 }
1616 if (handle->inited != 1) /* check handle initialization */
1617 {
1618 return 3; /* return error */
1619 }
1620
1621 *mW = (float)((double)(reg) * handle->current_lsb * 25.0 * 1000.0); /* set the converted data */
1622
1623 return 0; /* success return 0 */
1624}
1625
1636uint8_t ina226_irq_handler(ina226_handle_t *handle)
1637{
1638 uint8_t res;
1639 uint16_t prev;
1640
1641 if (handle == NULL) /* check handle */
1642 {
1643 return 2; /* return error */
1644 }
1645 if (handle->inited != 1) /* check handle initialization */
1646 {
1647 return 3; /* return error */
1648 }
1649
1650 res = a_ina226_iic_read(handle, INA226_REG_MASK, (uint16_t *)&prev); /* read mask */
1651 if (res != 0) /* check result */
1652 {
1653 handle->debug_print("ina226: read mask register failed.\n"); /* read mask register failed */
1654
1655 return 1; /* return error */
1656 }
1657 if ((prev & (1 << 4)) != 0) /* check alert flag */
1658 {
1659 if ((prev & (1 << 15)) != 0) /* shunt voltage over voltage */
1660 {
1661 if (handle->receive_callback != NULL) /* check not null */
1662 {
1663 handle->receive_callback(INA226_STATUS_SHUNT_VOLTAGE_OVER_VOLTAGE); /* run callback */
1664 }
1665 }
1666 else if ((prev & (1 << 14)) != 0) /* shunt voltage under voltage */
1667 {
1668 if (handle->receive_callback != NULL) /* check not null */
1669 {
1670 handle->receive_callback(INA226_STATUS_SHUNT_VOLTAGE_UNDER_VOLTAGE); /* run callback */
1671 }
1672 }
1673 else if ((prev & (1 << 13)) != 0) /* bus voltage over voltage */
1674 {
1675 if (handle->receive_callback != NULL) /* check not null */
1676 {
1677 handle->receive_callback(INA226_STATUS_BUS_VOLTAGE_OVER_VOLTAGE); /* run callback */
1678 }
1679 }
1680 else if ((prev & (1 << 12)) != 0) /* bus voltage under voltage */
1681 {
1682 if (handle->receive_callback != NULL) /* check not null */
1683 {
1684 handle->receive_callback(INA226_STATUS_BUS_VOLTAGE_UNDER_VOLTAGE); /* run callback */
1685 }
1686 }
1687 else if ((prev & (1 << 11)) != 0) /* power over limit */
1688 {
1689 if (handle->receive_callback != NULL) /* check not null */
1690 {
1691 handle->receive_callback(INA226_STATUS_POWER_OVER_LIMIT); /* run callback */
1692 }
1693 }
1694 else
1695 {
1696 /* do nothing */
1697 }
1698 }
1699
1700 return 0; /* success return 0 */
1701}
1702
1715uint8_t ina226_init(ina226_handle_t *handle)
1716{
1717 uint8_t res;
1718 uint16_t prev;
1719
1720 if (handle == NULL) /* check handle */
1721 {
1722 return 2; /* return error */
1723 }
1724 if (handle->debug_print == NULL) /* check debug_print */
1725 {
1726 return 3; /* return error */
1727 }
1728 if (handle->iic_init == NULL) /* check iic_init */
1729 {
1730 handle->debug_print("ina226: iic_init is null.\n"); /* iic_init is null */
1731
1732 return 3; /* return error */
1733 }
1734 if (handle->iic_deinit == NULL) /* check iic_deinit */
1735 {
1736 handle->debug_print("ina226: iic_deinit is null.\n"); /* iic_deinit is null */
1737
1738 return 3; /* return error */
1739 }
1740 if (handle->iic_read == NULL) /* check iic_read */
1741 {
1742 handle->debug_print("ina226: iic_read is null.\n"); /* iic_read is null */
1743
1744 return 3; /* return error */
1745 }
1746 if (handle->iic_write == NULL) /* check iic_write */
1747 {
1748 handle->debug_print("ina226: iic_write is null.\n"); /* iic_write is null */
1749
1750 return 3; /* return error */
1751 }
1752 if (handle->delay_ms == NULL) /* check delay_ms */
1753 {
1754 handle->debug_print("ina226: delay_ms is null.\n"); /* delay_ms is null */
1755
1756 return 3; /* return error */
1757 }
1758 if (handle->receive_callback == NULL) /* check receive_callback */
1759 {
1760 handle->debug_print("ina226: receive_callback is null.\n"); /* receive_callback is null */
1761
1762 return 3; /* return error */
1763 }
1764
1765 if (handle->iic_init() != 0) /* iic init */
1766 {
1767 handle->debug_print("ina226: iic init failed.\n"); /* iic init failed */
1768
1769 return 1; /* return error */
1770 }
1771 res = a_ina226_iic_read(handle, INA226_REG_MANUFACTURER, (uint16_t *)&prev); /* read manufacturer */
1772 if (res != 0) /* check result */
1773 {
1774 handle->debug_print("ina226: read manufacturer failed.\n"); /* read manufacturer failed */
1775 (void)handle->iic_deinit(); /* iic deinit */
1776
1777 return 4; /* return error */
1778 }
1779 if (prev != 0x5449) /* check id */
1780 {
1781 handle->debug_print("ina226: id is invalid.\n"); /* id is invalid */
1782 (void)handle->iic_deinit(); /* iic deinit */
1783
1784 return 4; /* return error */
1785 }
1786 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read conf */
1787 if (res != 0) /* check result */
1788 {
1789 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
1790 (void)handle->iic_deinit(); /* iic deinit */
1791
1792 return 5; /* return error */
1793 }
1794 prev |= 1 << 15; /* set bit */
1795 res = a_ina226_iic_write(handle, INA226_REG_CONF, prev); /* write conf */
1796 if (res != 0) /* check result */
1797 {
1798 handle->debug_print("ina226: write conf register failed.\n"); /* write conf register failed */
1799 (void)handle->iic_deinit(); /* iic deinit */
1800
1801 return 5; /* return error */
1802 }
1803 handle->delay_ms(10); /* delay 10 ms */
1804 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read conf */
1805 if (res != 0) /* check result */
1806 {
1807 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
1808 (void)handle->iic_deinit(); /* iic deinit */
1809
1810 return 5; /* return error */
1811 }
1812 if ((prev & (1 << 15)) != 0) /* check the result */
1813 {
1814 handle->debug_print("ina226: soft reset failed.\n"); /* soft reset failed */
1815 (void)handle->iic_deinit(); /* iic deinit */
1816
1817 return 5; /* return error */
1818 }
1819 handle->trigger = 0; /* none */
1820 handle->inited = 1; /* flag inited */
1821
1822 return 0; /* success return 0 */
1823}
1824
1836uint8_t ina226_deinit(ina226_handle_t *handle)
1837{
1838 uint8_t res;
1839 uint16_t prev;
1840
1841 if (handle == NULL) /* check handle */
1842 {
1843 return 2; /* return error */
1844 }
1845 if (handle->inited != 1) /* check handle initialization */
1846 {
1847 return 3; /* return error */
1848 }
1849
1850 res = a_ina226_iic_read(handle, INA226_REG_CONF, (uint16_t *)&prev); /* read config */
1851 if (res != 0) /* check result */
1852 {
1853 handle->debug_print("ina226: read conf register failed.\n"); /* read conf register failed */
1854
1855 return 4; /* return error */
1856 }
1857 prev &= ~(0x07); /* clear mode */
1858 res = a_ina226_iic_write(handle, INA226_REG_CONF, (uint16_t )prev); /* write config */
1859 if (res != 0) /* check result */
1860 {
1861 handle->debug_print("ina226: write conf register failed.\n"); /* write conf register failed */
1862
1863 return 4; /* return error */
1864 }
1865 res = handle->iic_deinit(); /* iic deinit */
1866 if (res != 0) /* check result */
1867 {
1868 handle->debug_print("ina226: iic deinit failed.\n"); /* iic deinit failed */
1869
1870 return 1; /* return error */
1871 }
1872
1873 return 0; /* success return 0 */
1874}
1875
1888uint8_t ina226_set_reg(ina226_handle_t *handle, uint8_t reg, uint16_t data)
1889{
1890 if (handle == NULL) /* check handle */
1891 {
1892 return 2; /* return error */
1893 }
1894 if (handle->inited != 1) /* check handle initialization */
1895 {
1896 return 3; /* return error */
1897 }
1898
1899 return a_ina226_iic_write(handle, reg, data); /* write data */
1900}
1901
1914uint8_t ina226_get_reg(ina226_handle_t *handle, uint8_t reg, uint16_t *data)
1915{
1916 if (handle == NULL) /* check handle */
1917 {
1918 return 2; /* return error */
1919 }
1920 if (handle->inited != 1) /* check handle initialization */
1921 {
1922 return 3; /* return error */
1923 }
1924
1925 return a_ina226_iic_read(handle, reg, data); /* read data */
1926}
1927
1936uint8_t ina226_info(ina226_info_t *info)
1937{
1938 if (info == NULL) /* check handle */
1939 {
1940 return 2; /* return error */
1941 }
1942
1943 memset(info, 0, sizeof(ina226_info_t)); /* initialize ina226 info structure */
1944 strncpy(info->chip_name, CHIP_NAME, 32); /* copy chip name */
1945 strncpy(info->manufacturer_name, MANUFACTURER_NAME, 32); /* copy manufacturer name */
1946 strncpy(info->interface, "IIC", 8); /* copy interface name */
1947 info->supply_voltage_min_v = SUPPLY_VOLTAGE_MIN; /* set minimal supply voltage */
1948 info->supply_voltage_max_v = SUPPLY_VOLTAGE_MAX; /* set maximum supply voltage */
1949 info->max_current_ma = MAX_CURRENT; /* set maximum current */
1950 info->temperature_max = TEMPERATURE_MAX; /* set minimal temperature */
1951 info->temperature_min = TEMPERATURE_MIN; /* set maximum temperature */
1952 info->driver_version = DRIVER_VERSION; /* set driver version */
1953
1954 return 0; /* success return 0 */
1955}
INA226_REG_DIE
#define INA226_REG_DIE
Definition driver_ina226.c:64
MAX_CURRENT
#define MAX_CURRENT
Definition driver_ina226.c:47
INA226_REG_POWER
#define INA226_REG_POWER
Definition driver_ina226.c:58
INA226_REG_MANUFACTURER
#define INA226_REG_MANUFACTURER
Definition driver_ina226.c:63
SUPPLY_VOLTAGE_MAX
#define SUPPLY_VOLTAGE_MAX
Definition driver_ina226.c:46
INA226_REG_SHUNT_VOLTAGE
#define INA226_REG_SHUNT_VOLTAGE
Definition driver_ina226.c:56
TEMPERATURE_MAX
#define TEMPERATURE_MAX
Definition driver_ina226.c:49
MANUFACTURER_NAME
#define MANUFACTURER_NAME
Definition driver_ina226.c:44
INA226_REG_ALERT_LIMIT
#define INA226_REG_ALERT_LIMIT
Definition driver_ina226.c:62
TEMPERATURE_MIN
#define TEMPERATURE_MIN
Definition driver_ina226.c:48
SUPPLY_VOLTAGE_MIN
#define SUPPLY_VOLTAGE_MIN
Definition driver_ina226.c:45
INA226_REG_CALIBRATION
#define INA226_REG_CALIBRATION
Definition driver_ina226.c:60
INA226_REG_BUS_VOLTAGE
#define INA226_REG_BUS_VOLTAGE
Definition driver_ina226.c:57
INA226_REG_MASK
#define INA226_REG_MASK
Definition driver_ina226.c:61
INA226_REG_CONF
#define INA226_REG_CONF
chip register definition
Definition driver_ina226.c:55
CHIP_NAME
#define CHIP_NAME
chip information definition
Definition driver_ina226.c:43
DRIVER_VERSION
#define DRIVER_VERSION
Definition driver_ina226.c:50
INA226_REG_CURRENT
#define INA226_REG_CURRENT
Definition driver_ina226.c:59
driver_ina226.h
driver ina226 header file
ina226_calculate_calibration
uint8_t ina226_calculate_calibration(ina226_handle_t *handle, uint16_t *calibration)
calculate the calibration
Definition driver_ina226.c:1003
ina226_get_addr_pin
uint8_t ina226_get_addr_pin(ina226_handle_t *handle, ina226_address_t *addr_pin)
get the iic address pin
Definition driver_ina226.c:191
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_info
uint8_t ina226_info(ina226_info_t *info)
get chip's information
Definition driver_ina226.c:1936
ina226_bus_voltage_convert_to_data
uint8_t ina226_bus_voltage_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mV)
convert the register raw data to the bus voltage
Definition driver_ina226.c:1556
ina226_power_convert_to_data
uint8_t ina226_power_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mW)
convert the register raw data to the power
Definition driver_ina226.c:1610
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_get_alert_latch
uint8_t ina226_get_alert_latch(ina226_handle_t *handle, ina226_bool_t *enable)
get alert latch status
Definition driver_ina226.c:1368
ina226_get_bus_voltage_conversion_time
uint8_t ina226_get_bus_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t *t)
get bus voltage conversion time
Definition driver_ina226.c:364
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_READ_TIMEOUT
#define INA226_READ_TIMEOUT
ina226 read timeout definition
Definition driver_ina226.h:63
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_get_conversion_ready_alert_pin
uint8_t ina226_get_conversion_ready_alert_pin(ina226_handle_t *handle, ina226_bool_t *enable)
get conversion ready alert pin status
Definition driver_ina226.c:1204
ina226_get_alert_limit
uint8_t ina226_get_alert_limit(ina226_handle_t *handle, uint16_t *reg)
get alert limit
Definition driver_ina226.c:1440
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_get_shunt_voltage_conversion_time
uint8_t ina226_get_shunt_voltage_conversion_time(ina226_handle_t *handle, ina226_conversion_time_t *t)
get shunt voltage conversion time
Definition driver_ina226.c:439
ina226_get_calibration
uint8_t ina226_get_calibration(ina226_handle_t *handle, uint16_t *data)
get the calibration
Definition driver_ina226.c:967
ina226_get_mode
uint8_t ina226_get_mode(ina226_handle_t *handle, ina226_mode_t *mode)
get the mode
Definition driver_ina226.c:531
ina226_address_t
ina226_address_t
ina226 address enumeration definition
Definition driver_ina226.h:70
ina226_handle_t
struct ina226_handle_s ina226_handle_t
ina226 handle structure definition
ina226_soft_reset
uint8_t ina226_soft_reset(ina226_handle_t *handle)
soft reset the chip
Definition driver_ina226.c:213
ina226_get_mask
uint8_t ina226_get_mask(ina226_handle_t *handle, ina226_mask_t mask, ina226_bool_t *enable)
get mask
Definition driver_ina226.c:1122
ina226_irq_handler
uint8_t ina226_irq_handler(ina226_handle_t *handle)
irq handler
Definition driver_ina226.c:1636
ina226_get_alert_polarity_pin
uint8_t ina226_get_alert_polarity_pin(ina226_handle_t *handle, ina226_alert_polarity_t *pin)
get alert polarity pin
Definition driver_ina226.c:1286
ina226_mode_t
ina226_mode_t
ina226 mode enumeration definition
Definition driver_ina226.h:129
ina226_read_shunt_voltage
uint8_t ina226_read_shunt_voltage(ina226_handle_t *handle, int16_t *raw, float *mV)
read the shunt voltage
Definition driver_ina226.c:610
ina226_get_average_mode
uint8_t ina226_get_average_mode(ina226_handle_t *handle, ina226_avg_t *mode)
get average mode
Definition driver_ina226.c:289
ina226_init
uint8_t ina226_init(ina226_handle_t *handle)
initialize the chip
Definition driver_ina226.c:1715
ina226_get_resistance
uint8_t ina226_get_resistance(ina226_handle_t *handle, double *resistance)
get the resistance
Definition driver_ina226.c:149
ina226_bool_t
ina226_bool_t
ina226 bool enumeration definition
Definition driver_ina226.h:93
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_conversion_time_t
ina226_conversion_time_t
Definition driver_ina226.h:114
ina226_set_calibration
uint8_t ina226_set_calibration(ina226_handle_t *handle, uint16_t data)
set the calibration
Definition driver_ina226.c:1040
ina226_shunt_voltage_convert_to_data
uint8_t ina226_shunt_voltage_convert_to_data(ina226_handle_t *handle, uint16_t reg, float *mV)
convert the register raw data to the shunt voltage
Definition driver_ina226.c:1502
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_avg_t
ina226_avg_t
ina226 average enumeration definition
Definition driver_ina226.h:102
ina226_alert_polarity_t
ina226_alert_polarity_t
ina226 alert polarity enumeration definition
Definition driver_ina226.h:168
ina226_get_die_id
uint8_t ina226_get_die_id(ina226_handle_t *handle, uint16_t *device_id, uint8_t *die_revision_id)
get the die id
Definition driver_ina226.c:569
ina226_info_t
struct ina226_info_s ina226_info_t
ina226 information structure definition
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_STATUS_BUS_VOLTAGE_OVER_VOLTAGE
@ INA226_STATUS_BUS_VOLTAGE_OVER_VOLTAGE
Definition driver_ina226.h:147
INA226_STATUS_POWER_OVER_LIMIT
@ INA226_STATUS_POWER_OVER_LIMIT
Definition driver_ina226.h:149
INA226_STATUS_SHUNT_VOLTAGE_UNDER_VOLTAGE
@ INA226_STATUS_SHUNT_VOLTAGE_UNDER_VOLTAGE
Definition driver_ina226.h:146
INA226_STATUS_BUS_VOLTAGE_UNDER_VOLTAGE
@ INA226_STATUS_BUS_VOLTAGE_UNDER_VOLTAGE
Definition driver_ina226.h:148
INA226_STATUS_SHUNT_VOLTAGE_OVER_VOLTAGE
@ INA226_STATUS_SHUNT_VOLTAGE_OVER_VOLTAGE
Definition driver_ina226.h:145
INA226_MODE_BUS_VOLTAGE_TRIGGERED
@ INA226_MODE_BUS_VOLTAGE_TRIGGERED
Definition driver_ina226.h:132
INA226_MODE_SHUNT_BUS_VOLTAGE_TRIGGERED
@ INA226_MODE_SHUNT_BUS_VOLTAGE_TRIGGERED
Definition driver_ina226.h:133
INA226_MODE_SHUNT_VOLTAGE_TRIGGERED
@ INA226_MODE_SHUNT_VOLTAGE_TRIGGERED
Definition driver_ina226.h:131
ina226_set_reg
uint8_t ina226_set_reg(ina226_handle_t *handle, uint8_t reg, uint16_t data)
set the chip register
Definition driver_ina226.c:1888
ina226_get_reg
uint8_t ina226_get_reg(ina226_handle_t *handle, uint8_t reg, uint16_t *data)
get the chip register
Definition driver_ina226.c:1914
ina226_handle_s::inited
uint8_t inited
Definition driver_ina226.h:188
ina226_handle_s::delay_ms
void(* delay_ms)(uint32_t ms)
Definition driver_ina226.h:183
ina226_handle_s::receive_callback
void(* receive_callback)(uint8_t type)
Definition driver_ina226.h:185
ina226_handle_s::debug_print
void(* debug_print)(const char *const fmt,...)
Definition driver_ina226.h:184
ina226_handle_s::r
double r
Definition driver_ina226.h:186
ina226_handle_s::iic_init
uint8_t(* iic_init)(void)
Definition driver_ina226.h:179
ina226_handle_s::current_lsb
double current_lsb
Definition driver_ina226.h:187
ina226_handle_s::trigger
uint8_t trigger
Definition driver_ina226.h:189
ina226_handle_s::iic_write
uint8_t(* iic_write)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
Definition driver_ina226.h:182
ina226_handle_s::iic_addr
uint8_t iic_addr
Definition driver_ina226.h:178
ina226_handle_s::iic_read
uint8_t(* iic_read)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
Definition driver_ina226.h:181
ina226_handle_s::iic_deinit
uint8_t(* iic_deinit)(void)
Definition driver_ina226.h:180
ina226_info_s::temperature_max
float temperature_max
Definition driver_ina226.h:204
ina226_info_s::supply_voltage_max_v
float supply_voltage_max_v
Definition driver_ina226.h:201
ina226_info_s::driver_version
uint32_t driver_version
Definition driver_ina226.h:205
ina226_info_s::temperature_min
float temperature_min
Definition driver_ina226.h:203
ina226_info_s::max_current_ma
float max_current_ma
Definition driver_ina226.h:202
ina226_info_s::manufacturer_name
char manufacturer_name[32]
Definition driver_ina226.h:198
ina226_info_s::supply_voltage_min_v
float supply_voltage_min_v
Definition driver_ina226.h:200
ina226_info_s::interface
char interface[8]
Definition driver_ina226.h:199
ina226_info_s::chip_name
char chip_name[32]
Definition driver_ina226.h:197