LibDriver PCA9685
Loading...
Searching...
No Matches
driver_pca9685.c
Go to the documentation of this file.
1
36
37#include "driver_pca9685.h"
38#include <float.h>
39#include <math.h>
40
44#define CHIP_NAME "NXP PCA9685"
45#define MANUFACTURER_NAME "NXP"
46#define SUPPLY_VOLTAGE_MIN 2.3f
47#define SUPPLY_VOLTAGE_MAX 5.5f
48#define MAX_CURRENT 400.0f
49#define TEMPERATURE_MIN -40.0f
50#define TEMPERATURE_MAX 85.0f
51#define DRIVER_VERSION 1000
52
56#define PCA9685_REG_MODE1 0x00
57#define PCA9685_REG_MODE2 0x01
58#define PCA9685_REG_SUBADR1 0x02
59#define PCA9685_REG_SUBADR2 0x03
60#define PCA9685_REG_SUBADR3 0x04
61#define PCA9685_REG_ALLCALLADR 0x05
62#define PCA9685_REG_LED0_ON_L 0x06
63#define PCA9685_REG_LED0_ON_H 0x07
64#define PCA9685_REG_LED0_OFF_L 0x08
65#define PCA9685_REG_LED0_OFF_H 0x09
66#define PCA9685_REG_ALL_LED_ON_L 0xFA
67#define PCA9685_REG_ALL_LED_ON_H 0xFB
68#define PCA9685_REG_ALL_LED_OFF_L 0xFC
69#define PCA9685_REG_ALL_LED_OFF_H 0xFD
70#define PCA9685_REG_PRE_SCALE 0xFE
71
81uint8_t pca9685_set_addr_pin(pca9685_handle_t *handle, pca9685_address_t addr_pin)
82{
83 if (handle == NULL) /* check handle */
84 {
85 return 2; /* return error */
86 }
87
88 handle->iic_addr = 0x80; /* set 0x80*/
89 handle->iic_addr |= addr_pin << 1; /* set iic addr */
90
91 return 0; /* success return 0 */
92}
93
103uint8_t pca9685_get_addr_pin(pca9685_handle_t *handle, pca9685_address_t *addr_pin)
104{
105 if (handle == NULL) /* check handle */
106 {
107 return 2; /* return error */
108 }
109
110 *addr_pin = (pca9685_address_t)((handle->iic_addr & (~0x80)) >> 1); /*get iic address */
111
112 return 0; /* success return 0 */
113}
114
124uint8_t pca9685_set_addr(pca9685_handle_t *handle, uint8_t addr)
125{
126 if (handle == NULL) /* check handle */
127 {
128 return 2; /* return error */
129 }
130
131 handle->iic_addr = addr; /* set iic addr */
132
133 return 0; /* success return 0 */
134}
135
145uint8_t pca9685_get_addr(pca9685_handle_t *handle, uint8_t *addr)
146{
147 if (handle == NULL) /* check handle */
148 {
149 return 2; /* return error */
150 }
151
152 *addr = handle->iic_addr; /* get iic addr */
153
154 return 0; /* success return 0 */
155}
156
168uint8_t pca9685_set_active(pca9685_handle_t *handle, pca9685_bool_t enable)
169{
170 if (handle == NULL) /* check handle */
171 {
172 return 2; /* return error */
173 }
174 if (handle->inited != 1) /* check handle initialization */
175 {
176 return 3; /* return error */
177 }
178
179 if (handle->oe_gpio_write(!enable) != 0) /* gpio write */
180 {
181 handle->debug_print("pca9685: gpio write failed.\n"); /* gpio writer failed */
182
183 return 1; /* return error */
184 }
185
186 return 0; /* success return 0 */
187}
188
200uint8_t pca9685_set_restart(pca9685_handle_t *handle, pca9685_bool_t enable)
201{
202 uint8_t res;
203 uint8_t prev;
204
205 if (handle == NULL) /* check handle */
206 {
207 return 2; /* return error */
208 }
209 if (handle->inited != 1) /* check handle initialization */
210 {
211 return 3; /* return error */
212 }
213
214 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
215 if (res != 0) /* check result */
216 {
217 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
218
219 return 1; /* return error */
220 }
221 prev &= ~(1 << 7); /* clear conf */
222 prev |= enable << 7; /* set conf */
223 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
224 if (res != 0) /* check result */
225 {
226 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
227
228 return 1; /* return error */
229 }
230
231 return 0; /* success return 0 */
232}
233
245uint8_t pca9685_get_restart(pca9685_handle_t *handle, pca9685_bool_t *enable)
246{
247 uint8_t res;
248 uint8_t prev;
249
250 if (handle == NULL) /* check handle */
251 {
252 return 2; /* return error */
253 }
254 if (handle->inited != 1) /* check handle initialization */
255 {
256 return 3; /* return error */
257 }
258
259 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
260 if (res != 0) /* check result */
261 {
262 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
263
264 return 1; /* return error */
265 }
266 *enable = (pca9685_bool_t)((prev >> 7) & 0x01); /* get bool */
267
268 return 0; /* success return 0 */
269}
270
282uint8_t pca9685_set_external_clock_pin(pca9685_handle_t *handle, pca9685_bool_t enable)
283{
284 uint8_t res;
285 uint8_t prev;
286
287 if (handle == NULL) /* check handle */
288 {
289 return 2; /* return error */
290 }
291 if (handle->inited != 1) /* check handle initialization */
292 {
293 return 3; /* return error */
294 }
295
296 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
297 if (res != 0) /* check result */
298 {
299 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
300
301 return 1; /* return error */
302 }
303 prev &= ~(1 << 6); /* clear conf */
304 prev |= enable << 6; /* set conf */
305 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
306 if (res != 0) /* check result */
307 {
308 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
309
310 return 1; /* return error */
311 }
312
313 return 0; /* success return 0 */
314}
315
327uint8_t pca9685_get_external_clock_pin(pca9685_handle_t *handle, pca9685_bool_t *enable)
328{
329 uint8_t res;
330 uint8_t prev;
331
332 if (handle == NULL) /* check handle */
333 {
334 return 2; /* return error */
335 }
336 if (handle->inited != 1) /* check handle initialization */
337 {
338 return 3; /* return error */
339 }
340
341 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
342 if (res != 0) /* check result */
343 {
344 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
345
346 return 1; /* return error */
347 }
348 *enable = (pca9685_bool_t)((prev >> 6) & 0x01); /* get bool */
349
350 return 0; /* success return 0 */
351}
352
364uint8_t pca9685_set_register_auto_increment(pca9685_handle_t *handle, pca9685_bool_t enable)
365{
366 uint8_t res;
367 uint8_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 = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
379 if (res != 0) /* check result */
380 {
381 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
382
383 return 1; /* return error */
384 }
385 prev &= ~(1 << 5); /* clear conf */
386 prev |= enable << 5; /* set conf */
387 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
388 if (res != 0) /* check result */
389 {
390 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
391
392 return 1; /* return error */
393 }
394
395 return 0; /* success return 0 */
396}
397
409uint8_t pca9685_get_register_auto_increment(pca9685_handle_t *handle, pca9685_bool_t *enable)
410{
411 uint8_t res;
412 uint8_t prev;
413
414 if (handle == NULL) /* check handle */
415 {
416 return 2; /* return error */
417 }
418 if (handle->inited != 1) /* check handle initialization */
419 {
420 return 3; /* return error */
421 }
422
423 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
424 if (res != 0) /* check result */
425 {
426 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
427
428 return 1; /* return error */
429 }
430 *enable = (pca9685_bool_t)((prev >> 5) & 0x01); /* get bool */
431
432 return 0; /* success return 0 */
433}
434
446uint8_t pca9685_set_sleep_mode(pca9685_handle_t *handle, pca9685_bool_t enable)
447{
448 uint8_t res;
449 uint8_t prev;
450
451 if (handle == NULL) /* check handle */
452 {
453 return 2; /* return error */
454 }
455 if (handle->inited != 1) /* check handle initialization */
456 {
457 return 3; /* return error */
458 }
459
460 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
461 if (res != 0) /* check result */
462 {
463 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
464
465 return 1; /* return error */
466 }
467 prev &= ~(1 << 4); /* clear conf */
468 prev |= enable << 4; /* set conf */
469 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
470 if (res != 0) /* check result */
471 {
472 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
473
474 return 1; /* return error */
475 }
476
477 return 0; /* success return 0 */
478}
479
491uint8_t pca9685_get_sleep_mode(pca9685_handle_t *handle, pca9685_bool_t *enable)
492{
493 uint8_t res;
494 uint8_t prev;
495
496 if (handle == NULL) /* check handle */
497 {
498 return 2; /* return error */
499 }
500 if (handle->inited != 1) /* check handle initialization */
501 {
502 return 3; /* return error */
503 }
504
505 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
506 if (res != 0) /* check result */
507 {
508 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
509
510 return 1; /* return error */
511 }
512 *enable = (pca9685_bool_t)((prev >> 4) & 0x01); /* get bool */
513
514 return 0; /* success return 0 */
515}
516
528uint8_t pca9685_set_respond_subaddress_1(pca9685_handle_t *handle, pca9685_bool_t enable)
529{
530 uint8_t res;
531 uint8_t prev;
532
533 if (handle == NULL) /* check handle */
534 {
535 return 2; /* return error */
536 }
537 if (handle->inited != 1) /* check handle initialization */
538 {
539 return 3; /* return error */
540 }
541
542 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
543 if (res != 0) /* check result */
544 {
545 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
546
547 return 1; /* return error */
548 }
549 prev &= ~(1 << 3); /* clear conf */
550 prev |= enable << 3; /* set conf */
551 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
552 if (res != 0) /* check result */
553 {
554 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
555
556 return 1; /* return error */
557 }
558
559 return 0; /* success return 0 */
560}
561
573uint8_t pca9685_get_respond_subaddress_1(pca9685_handle_t *handle, pca9685_bool_t *enable)
574{
575 uint8_t res;
576 uint8_t prev;
577
578 if (handle == NULL) /* check handle */
579 {
580 return 2; /* return error */
581 }
582 if (handle->inited != 1) /* check handle initialization */
583 {
584 return 3; /* return error */
585 }
586
587 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
588 if (res != 0) /* check result */
589 {
590 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
591
592 return 1; /* return error */
593 }
594 *enable = (pca9685_bool_t)((prev >> 3) & 0x01); /* get bool */
595
596 return 0; /* success return 0 */
597}
598
610uint8_t pca9685_set_respond_subaddress_2(pca9685_handle_t *handle, pca9685_bool_t enable)
611{
612 uint8_t res;
613 uint8_t prev;
614
615 if (handle == NULL) /* check handle */
616 {
617 return 2; /* return error */
618 }
619 if (handle->inited != 1) /* check handle initialization */
620 {
621 return 3; /* return error */
622 }
623
624 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
625 if (res != 0) /* check result */
626 {
627 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
628
629 return 1; /* return error */
630 }
631 prev &= ~(1 << 2); /* clear conf */
632 prev |= enable << 2; /* set conf */
633 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
634 if (res != 0) /* check result */
635 {
636 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
637
638 return 1; /* return error */
639 }
640
641 return 0; /* success return 0 */
642}
643
655uint8_t pca9685_get_respond_subaddress_2(pca9685_handle_t *handle, pca9685_bool_t *enable)
656{
657 uint8_t res;
658 uint8_t prev;
659
660 if (handle == NULL) /* check handle */
661 {
662 return 2; /* return error */
663 }
664 if (handle->inited != 1) /* check handle initialization */
665 {
666 return 3; /* return error */
667 }
668
669 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
670 if (res != 0) /* check result */
671 {
672 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
673
674 return 1; /* return error */
675 }
676 *enable = (pca9685_bool_t)((prev >> 2) & 0x01); /* get bool */
677
678 return 0; /* success return 0 */
679}
680
692uint8_t pca9685_set_respond_subaddress_3(pca9685_handle_t *handle, pca9685_bool_t enable)
693{
694 uint8_t res;
695 uint8_t prev;
696
697 if (handle == NULL) /* check handle */
698 {
699 return 2; /* return error */
700 }
701 if (handle->inited != 1) /* check handle initialization */
702 {
703 return 3; /* return error */
704 }
705
706 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
707 if (res != 0) /* check result */
708 {
709 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
710
711 return 1; /* return error */
712 }
713 prev &= ~(1 << 1); /* clear conf */
714 prev |= enable << 1; /* set conf */
715 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
716 if (res != 0) /* check result */
717 {
718 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
719
720 return 1; /* return error */
721 }
722
723 return 0; /* success return 0 */
724}
725
737uint8_t pca9685_get_respond_subaddress_3(pca9685_handle_t *handle, pca9685_bool_t *enable)
738{
739 uint8_t res;
740 uint8_t prev;
741
742 if (handle == NULL) /* check handle */
743 {
744 return 2; /* return error */
745 }
746 if (handle->inited != 1) /* check handle initialization */
747 {
748 return 3; /* return error */
749 }
750
751 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
752 if (res != 0) /* check result */
753 {
754 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
755
756 return 1; /* return error */
757 }
758 *enable = (pca9685_bool_t)((prev >> 1) & 0x01); /* get bool */
759
760 return 0; /* success return 0 */
761}
762
774uint8_t pca9685_set_respond_all_call(pca9685_handle_t *handle, pca9685_bool_t enable)
775{
776 uint8_t res;
777 uint8_t prev;
778
779 if (handle == NULL) /* check handle */
780 {
781 return 2; /* return error */
782 }
783 if (handle->inited != 1) /* check handle initialization */
784 {
785 return 3; /* return error */
786 }
787
788 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
789 if (res != 0) /* check result */
790 {
791 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
792
793 return 1; /* return error */
794 }
795 prev &= ~(1 << 0); /* clear conf */
796 prev |= enable << 0; /* set conf */
797 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
798 if (res != 0) /* check result */
799 {
800 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
801
802 return 1; /* return error */
803 }
804
805 return 0; /* success return 0 */
806}
807
819uint8_t pca9685_get_respond_all_call(pca9685_handle_t *handle, pca9685_bool_t *enable)
820{
821 uint8_t res;
822 uint8_t prev;
823
824 if (handle == NULL) /* check handle */
825 {
826 return 2; /* return error */
827 }
828 if (handle->inited != 1) /* check handle initialization */
829 {
830 return 3; /* return error */
831 }
832
833 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
834 if (res != 0) /* check result */
835 {
836 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
837
838 return 1; /* return error */
839 }
840 *enable = (pca9685_bool_t)((prev >> 0) & 0x01); /* get bool */
841
842 return 0; /* success return 0 */
843}
844
856uint8_t pca9685_set_output_invert(pca9685_handle_t *handle, pca9685_bool_t enable)
857{
858 uint8_t res;
859 uint8_t prev;
860
861 if (handle == NULL) /* check handle */
862 {
863 return 2; /* return error */
864 }
865 if (handle->inited != 1) /* check handle initialization */
866 {
867 return 3; /* return error */
868 }
869
870 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
871 if (res != 0) /* check result */
872 {
873 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
874
875 return 1; /* return error */
876 }
877 prev &= ~(1 << 4); /* clear conf */
878 prev |= enable << 4; /* set conf */
879 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* write mode 2 register */
880 if (res != 0) /* check result */
881 {
882 handle->debug_print("pca9685: write mode 2 register failed.\n"); /* write mode 2 register failed */
883
884 return 1; /* return error */
885 }
886
887 return 0; /* success return 0 */
888}
889
901uint8_t pca9685_get_output_invert(pca9685_handle_t *handle, pca9685_bool_t *enable)
902{
903 uint8_t res;
904 uint8_t prev;
905
906 if (handle == NULL) /* check handle */
907 {
908 return 2; /* return error */
909 }
910 if (handle->inited != 1) /* check handle initialization */
911 {
912 return 3; /* return error */
913 }
914
915 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
916 if (res != 0) /* check result */
917 {
918 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
919
920 return 1; /* return error */
921 }
922 *enable = (pca9685_bool_t)((prev >> 4) & 0x01); /* get bool */
923
924 return 0; /* success return 0 */
925}
926
938uint8_t pca9685_set_output_change(pca9685_handle_t *handle, pca9685_output_change_t change)
939{
940 uint8_t res;
941 uint8_t prev;
942
943 if (handle == NULL) /* check handle */
944 {
945 return 2; /* return error */
946 }
947 if (handle->inited != 1) /* check handle initialization */
948 {
949 return 3; /* return error */
950 }
951
952 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
953 if (res != 0) /* check result */
954 {
955 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
956
957 return 1; /* return error */
958 }
959 prev &= ~(1 << 3); /* clear conf */
960 prev |= change << 3; /* set conf */
961 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* write mode 2 register */
962 if (res != 0) /* check result */
963 {
964 handle->debug_print("pca9685: write mode 2 register failed.\n"); /* write mode 2 register failed */
965
966 return 1; /* return error */
967 }
968
969 return 0; /* success return 0 */
970}
971
983uint8_t pca9685_get_output_change(pca9685_handle_t *handle, pca9685_output_change_t *change)
984{
985 uint8_t res;
986 uint8_t prev;
987
988 if (handle == NULL) /* check handle */
989 {
990 return 2; /* return error */
991 }
992 if (handle->inited != 1) /* check handle initialization */
993 {
994 return 3; /* return error */
995 }
996
997 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
998 if (res != 0) /* check result */
999 {
1000 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
1001
1002 return 1; /* return error */
1003 }
1004 *change = (pca9685_output_change_t)((prev >> 3) & 0x01); /* get change */
1005
1006 return 0; /* success return 0 */
1007}
1008
1020uint8_t pca9685_set_output_driver(pca9685_handle_t *handle, pca9685_output_driver_t driver)
1021{
1022 uint8_t res;
1023 uint8_t prev;
1024
1025 if (handle == NULL) /* check handle */
1026 {
1027 return 2; /* return error */
1028 }
1029 if (handle->inited != 1) /* check handle initialization */
1030 {
1031 return 3; /* return error */
1032 }
1033
1034 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
1035 if (res != 0) /* check result */
1036 {
1037 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
1038
1039 return 1; /* return error */
1040 }
1041 prev &= ~(1 << 2); /* clear conf */
1042 prev |= driver << 2; /* set conf */
1043 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* write mode 2 register */
1044 if (res != 0) /* check result */
1045 {
1046 handle->debug_print("pca9685: write mode 2 register failed.\n"); /* write mode 2 register failed */
1047
1048 return 1; /* return error */
1049 }
1050
1051 return 0; /* success return 0 */
1052}
1053
1065uint8_t pca9685_get_output_driver(pca9685_handle_t *handle, pca9685_output_driver_t *driver)
1066{
1067 uint8_t res;
1068 uint8_t prev;
1069
1070 if (handle == NULL) /* check handle */
1071 {
1072 return 2; /* return error */
1073 }
1074 if (handle->inited != 1) /* check handle initialization */
1075 {
1076 return 3; /* return error */
1077 }
1078
1079 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
1080 if (res != 0) /* check result */
1081 {
1082 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
1083
1084 return 1; /* return error */
1085 }
1086 *driver = (pca9685_output_driver_t)((prev >> 2) & 0x01); /* get change */
1087
1088 return 0; /* success return 0 */
1089}
1090
1102uint8_t pca9685_set_output_disable_type(pca9685_handle_t *handle, pca9685_output_disable_type_t type)
1103{
1104 uint8_t res;
1105 uint8_t prev;
1106
1107 if (handle == NULL) /* check handle */
1108 {
1109 return 2; /* return error */
1110 }
1111 if (handle->inited != 1) /* check handle initialization */
1112 {
1113 return 3; /* return error */
1114 }
1115
1116 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
1117 if (res != 0) /* check result */
1118 {
1119 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
1120
1121 return 1; /* return error */
1122 }
1123 prev &= ~(3 << 0); /* clear conf */
1124 prev |= type << 0; /* set conf */
1125 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* write mode 2 register */
1126 if (res != 0) /* check result */
1127 {
1128 handle->debug_print("pca9685: write mode 2 register failed.\n"); /* write mode 2 register failed */
1129
1130 return 1; /* return error */
1131 }
1132
1133 return 0; /* success return 0 */
1134}
1135
1147uint8_t pca9685_get_output_disable_type(pca9685_handle_t *handle, pca9685_output_disable_type_t *type)
1148{
1149 uint8_t res;
1150 uint8_t prev;
1151
1152 if (handle == NULL) /* check handle */
1153 {
1154 return 2; /* return error */
1155 }
1156 if (handle->inited != 1) /* check handle initialization */
1157 {
1158 return 3; /* return error */
1159 }
1160
1161 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE2, (uint8_t *)&prev, 1); /* read mode 2 register */
1162 if (res != 0) /* check result */
1163 {
1164 handle->debug_print("pca9685: read mode 2 register failed.\n"); /* read mode 2 register failed */
1165
1166 return 1; /* return error */
1167 }
1168 *type = (pca9685_output_disable_type_t)((prev >> 0) & (0x3)); /* get type */
1169
1170 return 0; /* success return 0 */
1171}
1172
1184uint8_t pca9685_set_subaddress_1(pca9685_handle_t *handle, uint8_t addr)
1185{
1186 uint8_t res;
1187
1188 if (handle == NULL) /* check handle */
1189 {
1190 return 2; /* return error */
1191 }
1192 if (handle->inited != 1) /* check handle initialization */
1193 {
1194 return 3; /* return error */
1195 }
1196
1197 res = handle->iic_write(handle->iic_addr, PCA9685_REG_SUBADR1, (uint8_t *)&addr, 1); /* write sub address 1 register */
1198 if (res != 0) /* check result */
1199 {
1200 handle->debug_print("pca9685: write sub address 1 register failed.\n"); /* write sub address 1 register failed */
1201
1202 return 1; /* return error */
1203 }
1204
1205 return 0; /* success return 0 */
1206}
1207
1219uint8_t pca9685_get_subaddress_1(pca9685_handle_t *handle, uint8_t *addr)
1220{
1221 uint8_t res;
1222
1223 if (handle == NULL) /* check handle */
1224 {
1225 return 2; /* return error */
1226 }
1227 if (handle->inited != 1) /* check handle initialization */
1228 {
1229 return 3; /* return error */
1230 }
1231
1232 res = handle->iic_read(handle->iic_addr, PCA9685_REG_SUBADR1, (uint8_t *)addr, 1); /* read sub address 1 register */
1233 if (res != 0) /* check result */
1234 {
1235 handle->debug_print("pca9685: read sub address 1 register failed.\n"); /* read sub address 1 register failed */
1236
1237 return 1; /* return error */
1238 }
1239
1240 return 0; /* success return 0 */
1241}
1242
1254uint8_t pca9685_set_subaddress_2(pca9685_handle_t *handle, uint8_t addr)
1255{
1256 uint8_t res;
1257
1258 if (handle == NULL) /* check handle */
1259 {
1260 return 2; /* return error */
1261 }
1262 if (handle->inited != 1) /* check handle initialization */
1263 {
1264 return 3; /* return error */
1265 }
1266
1267 res = handle->iic_write(handle->iic_addr, PCA9685_REG_SUBADR2, (uint8_t *)&addr, 1); /* write sub address 2 register */
1268 if (res != 0) /* check result */
1269 {
1270 handle->debug_print("pca9685: write sub address 2 register failed.\n"); /* write sub address 2 register failed */
1271
1272 return 1; /* return error */
1273 }
1274
1275 return 0; /* success return 0 */
1276}
1277
1289uint8_t pca9685_get_subaddress_2(pca9685_handle_t *handle, uint8_t *addr)
1290{
1291 uint8_t res;
1292
1293 if (handle == NULL) /* check handle */
1294 {
1295 return 2; /* return error */
1296 }
1297 if (handle->inited != 1) /* check handle initialization */
1298 {
1299 return 3; /* return error */
1300 }
1301
1302 res = handle->iic_read(handle->iic_addr, PCA9685_REG_SUBADR2, (uint8_t *)addr, 1); /* read sub address 2 register */
1303 if (res != 0) /* check result */
1304 {
1305 handle->debug_print("pca9685: read sub address 2 register failed.\n"); /* read sub address 2 register failed */
1306
1307 return 1; /* return error */
1308 }
1309
1310 return 0; /* success return 0 */
1311}
1312
1324uint8_t pca9685_set_subaddress_3(pca9685_handle_t *handle, uint8_t addr)
1325{
1326 uint8_t res;
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 = handle->iic_write(handle->iic_addr, PCA9685_REG_SUBADR3, (uint8_t *)&addr, 1); /* write sub address 3 register */
1338 if (res != 0) /* check result */
1339 {
1340 handle->debug_print("pca9685: write sub address 3 register failed.\n"); /* write sub address 3 register failed */
1341
1342 return 1; /* return error */
1343 }
1344
1345 return 0; /* success return 0 */
1346}
1347
1359uint8_t pca9685_get_subaddress_3(pca9685_handle_t *handle, uint8_t *addr)
1360{
1361 uint8_t res;
1362
1363 if (handle == NULL) /* check handle */
1364 {
1365 return 2; /* return error */
1366 }
1367 if (handle->inited != 1) /* check handle initialization */
1368 {
1369 return 3; /* return error */
1370 }
1371
1372 res = handle->iic_read(handle->iic_addr, PCA9685_REG_SUBADR3, (uint8_t *)addr, 1); /* read sub address 3 register */
1373 if (res != 0) /* check result */
1374 {
1375 handle->debug_print("pca9685: read sub address 3 register failed.\n"); /* read sub address 3 register failed */
1376
1377 return 1; /* return error */
1378 }
1379
1380 return 0; /* success return 0 */
1381}
1382
1394uint8_t pca9685_set_all_call_address(pca9685_handle_t *handle, uint8_t addr)
1395{
1396 uint8_t res;
1397
1398 if (handle == NULL) /* check handle */
1399 {
1400 return 2; /* return error */
1401 }
1402 if (handle->inited != 1) /* check handle initialization */
1403 {
1404 return 3; /* return error */
1405 }
1406
1407 res = handle->iic_write(handle->iic_addr, PCA9685_REG_ALLCALLADR, (uint8_t *)&addr, 1); /* write all call address register */
1408 if (res != 0) /* check result */
1409 {
1410 handle->debug_print("pca9685: write all call address register failed.\n"); /* write all call address register failed */
1411
1412 return 1; /* return error */
1413 }
1414
1415 return 0; /* success return 0 */
1416}
1417
1429uint8_t pca9685_get_all_call_address(pca9685_handle_t *handle, uint8_t *addr)
1430{
1431 uint8_t res;
1432
1433 if (handle == NULL) /* check handle */
1434 {
1435 return 2; /* return error */
1436 }
1437 if (handle->inited != 1) /* check handle initialization */
1438 {
1439 return 3; /* return error */
1440 }
1441
1442 res = handle->iic_read(handle->iic_addr, PCA9685_REG_ALLCALLADR, (uint8_t *)addr, 1); /* read all call address register */
1443 if (res != 0) /* check result */
1444 {
1445 handle->debug_print("pca9685: read all call address register failed.\n"); /* read all call address register failed */
1446
1447 return 1; /* return error */
1448 }
1449
1450 return 0; /* success return 0 */
1451}
1452
1467uint8_t pca9685_write_channel(pca9685_handle_t *handle, pca9685_channel_t channel, uint16_t on_count, uint16_t off_count)
1468{
1469 uint8_t res;
1470 uint8_t buf[4];
1471
1472 if (handle == NULL) /* check handle */
1473 {
1474 return 2; /* return error */
1475 }
1476 if (handle->inited != 1) /* check handle initialization */
1477 {
1478 return 3; /* return error */
1479 }
1480 if ((on_count > 4096) || (off_count > 4096)) /* check result */
1481 {
1482 handle->debug_print("pca9685: on_count or off_count is over 4096.\n"); /* on_count or off_count is over 4096 */
1483
1484 return 4; /* return error */
1485 }
1486
1487 buf[0] = (on_count >> 0) & 0xFF; /* set off count lsb */
1488 buf[1] = (on_count >> 8) & 0x1F; /* set on count msb */
1489 buf[2] = (off_count >> 0) & 0xFF; /* set off count lsb */
1490 buf[3] = (off_count >> 8) & 0x1F; /* set off count msb */
1491 res = handle->iic_write(handle->iic_addr, (uint8_t)(PCA9685_REG_LED0_ON_L + channel * 4),
1492 (uint8_t *)buf, 4); /* write led register */
1493 if (res != 0) /* check result */
1494 {
1495 handle->debug_print("pca9685: write led register failed.\n"); /* write led register failed */
1496
1497 return 1; /* return error */
1498 }
1499
1500 return 0; /* success return 0 */
1501}
1502
1516uint8_t pca9685_read_channel(pca9685_handle_t *handle, pca9685_channel_t channel, uint16_t *on_count, uint16_t *off_count)
1517{
1518 uint8_t res;
1519 uint8_t buf[4];
1520
1521 if (handle == NULL) /* check handle */
1522 {
1523 return 2; /* return error */
1524 }
1525 if (handle->inited != 1) /* check handle initialization */
1526 {
1527 return 3; /* return error */
1528 }
1529
1530 memset(buf, 0, sizeof(uint8_t) * 4); /* clear the buffer */
1531 res = handle->iic_read(handle->iic_addr, (uint8_t)(PCA9685_REG_LED0_ON_L + channel * 4),
1532 (uint8_t *)buf, 4); /* read led register */
1533 if (res != 0) /* check result */
1534 {
1535 handle->debug_print("pca9685: read led register failed.\n"); /* read led register failed */
1536
1537 return 1; /* return error */
1538 }
1539 *on_count = ((uint16_t)(buf[1]) & 0x1F) << 8 | buf[0]; /* set on count */
1540 *off_count = ((uint16_t)(buf[3]) & 0x1F) << 8 | buf[2]; /* set off count */
1541
1542 return 0; /* success return 0 */
1543}
1544
1558uint8_t pca9685_write_all_channel(pca9685_handle_t *handle, uint16_t on_count, uint16_t off_count)
1559{
1560 uint8_t res;
1561 uint8_t buf[4];
1562
1563 if (handle == NULL) /* check handle */
1564 {
1565 return 2; /* return error */
1566 }
1567 if (handle->inited != 1) /* check handle initialization */
1568 {
1569 return 3; /* return error */
1570 }
1571 if ((on_count > 4096) || (off_count > 4096)) /* check result */
1572 {
1573 handle->debug_print("pca9685: on_count or off_count is over 4096.\n"); /* on_count or off_count is over 4096 */
1574
1575 return 4; /* return error */
1576 }
1577
1578 buf[0] = (on_count >> 0) & 0xFF; /* set off count lsb */
1579 buf[1] = (on_count >> 8) & 0x1F; /* set on count msb */
1580 buf[2] = (off_count >> 0) & 0xFF; /* set off count lsb */
1581 buf[3] = (off_count >> 8) & 0x1F; /* set off count msb */
1582 res = handle->iic_write(handle->iic_addr, PCA9685_REG_ALL_LED_ON_L, (uint8_t *)buf, 4); /* write all led register */
1583 if (res != 0) /* check result */
1584 {
1585 handle->debug_print("pca9685: write all led register failed.\n"); /* write all led register failed */
1586
1587 return 1; /* return error */
1588 }
1589
1590 return 0; /* success return 0 */
1591}
1592
1605uint8_t pca9685_set_prescaler(pca9685_handle_t *handle, uint8_t prescaler)
1606{
1607 uint8_t res;
1608
1609 if (handle == NULL) /* check handle */
1610 {
1611 return 2; /* return error */
1612 }
1613 if (handle->inited != 1) /* check handle initialization */
1614 {
1615 return 3; /* return error */
1616 }
1617 if (prescaler < 3) /* check result */
1618 {
1619 handle->debug_print("pca9685: pre scale must be >= 3.\n"); /* pre scale must be >= 3 */
1620
1621 return 4; /* return error */
1622 }
1623
1624 res = handle->iic_write(handle->iic_addr, PCA9685_REG_PRE_SCALE, (uint8_t *)&prescaler, 1); /* write pre scale register */
1625 if (res != 0) /* check result */
1626 {
1627 handle->debug_print("pca9685: write pre scale register failed.\n"); /* write pre scale register failed */
1628
1629 return 1; /* return error */
1630 }
1631
1632 return 0; /* success return 0 */
1633}
1634
1646uint8_t pca9685_get_prescaler(pca9685_handle_t *handle, uint8_t *prescaler)
1647{
1648 uint8_t res;
1649
1650 if (handle == NULL) /* check handle */
1651 {
1652 return 2; /* return error */
1653 }
1654 if (handle->inited != 1) /* check handle initialization */
1655 {
1656 return 3; /* return error */
1657 }
1658
1659 res = handle->iic_read(handle->iic_addr, PCA9685_REG_PRE_SCALE, (uint8_t *)prescaler, 1); /* read pre scale register */
1660 if (res != 0) /* check result */
1661 {
1662 handle->debug_print("pca9685: read pre scale register failed.\n"); /* read pre scale register failed */
1663
1664 return 1; /* return error */
1665 }
1666
1667 return 0; /* success return 0 */
1668}
1669
1682uint8_t pca9685_output_frequency_convert_to_register(pca9685_handle_t *handle, uint32_t oscillator, uint16_t output_freq, uint8_t *reg)
1683{
1684 if (handle == NULL) /* check handle */
1685 {
1686 return 2; /* return error */
1687 }
1688 if (handle->inited != 1) /* check handle initialization */
1689 {
1690 return 3; /* return error */
1691 }
1692
1693 *reg = (uint8_t)(round((double)oscillator / ((double)output_freq * 4096.0))) - 1; /* convert real data to register data */
1694
1695 return 0; /* success return 0 */
1696}
1697
1710uint8_t pca9685_output_frequency_convert_to_data(pca9685_handle_t *handle, uint32_t oscillator, uint8_t reg, uint16_t *output_freq)
1711{
1712 if (handle == NULL) /* check handle */
1713 {
1714 return 2; /* return error */
1715 }
1716 if (handle->inited != 1) /* check handle initialization */
1717 {
1718 return 3; /* return error */
1719 }
1720
1721 *output_freq = (uint16_t)(round((double)oscillator / ((reg + 1) * 4096.0))); /* convert raw data to real data */
1722
1723 return 0; /* success return 0 */
1724}
1725
1742uint8_t pca9685_pwm_convert_to_register(pca9685_handle_t *handle, float delay_percent, float high_duty_cycle_percent,
1743 uint16_t *on_count, uint16_t *off_count)
1744{
1745 if (handle == NULL) /* check handle */
1746 {
1747 return 2; /* return error */
1748 }
1749 if (handle->inited != 1) /* check handle initialization */
1750 {
1751 return 3; /* return error */
1752 }
1753 if (delay_percent + high_duty_cycle_percent > 100.0f) /* check result */
1754 {
1755 handle->debug_print("pca9685: delay_percent + high_duty_cycle_percent can't be over 100.0.\n"); /* delay_percent + high_duty_cycle_percent can't be over 100.0 */
1756
1757 return 4; /* return error */
1758 }
1759
1760 if (delay_percent < FLT_MIN) /* 0.0 */
1761 {
1762 *on_count = 0; /* set 0 */
1763 }
1764 else
1765 {
1766 *on_count = (uint16_t)(roundf(delay_percent / 100.0f * 4096.0f)) - 1; /* set on count */
1767 }
1768 if (high_duty_cycle_percent < FLT_MIN) /* 0.0 */
1769 {
1770 *off_count = 0; /* set 0*/
1771 }
1772 else
1773 {
1774 *off_count = (uint16_t)(roundf((delay_percent + high_duty_cycle_percent) / 100.0f * 4096.0f)) - 1; /* set off count */
1775 }
1776
1777 return 0; /* success return 0 */
1778}
1779
1794uint8_t pca9685_pwm_convert_to_data(pca9685_handle_t *handle, uint16_t on_count, uint16_t off_count,
1795 float *delay_percent, float *high_duty_cycle_percent)
1796{
1797 if (handle == NULL) /* check handle */
1798 {
1799 return 2; /* return error */
1800 }
1801 if (handle->inited != 1) /* check handle initialization */
1802 {
1803 return 3; /* return error */
1804 }
1805 if ((on_count > 4096) || (off_count > 4096)) /* check result */
1806 {
1807 handle->debug_print("pca9685: on_count or off_count is over 4096.\n"); /* on_count or off_count is over 4096 */
1808
1809 return 4; /* return error */
1810 }
1811
1812 if (on_count != 0) /* not 0 */
1813 {
1814 *delay_percent = (float)(on_count + 1) / 4096.0f * 100.0f; /* set the delay_percent */
1815 }
1816 else /* 0 */
1817 {
1818 *delay_percent = 0.0f; /* set 0.0 */
1819 }
1820 if (off_count != 0) /* not 0 */
1821 {
1822 *high_duty_cycle_percent = (float)(off_count - on_count) / 4096.0f * 100.0f; /* set the high_duty_cycle_percent */
1823 }
1824 else /* 0 */
1825 {
1826 *high_duty_cycle_percent = 0.0f; /* set 0.0 */
1827 }
1828
1829 return 0; /* success return 0 */
1830}
1831
1843uint8_t pca9685_init(pca9685_handle_t *handle)
1844{
1845 uint8_t res, prev;
1846
1847 if (handle == NULL) /* check handle */
1848 {
1849 return 2; /* return error */
1850 }
1851 if (handle->debug_print == NULL) /* check debug_print */
1852 {
1853 return 3; /* return error */
1854 }
1855 if (handle->iic_init == NULL) /* check iic_init */
1856 {
1857 handle->debug_print("pca9685: iic_init is null.\n"); /* iic_init is null */
1858
1859 return 3; /* return error */
1860 }
1861 if (handle->iic_deinit == NULL) /* check iic_deinit */
1862 {
1863 handle->debug_print("pca9685: iic_deinit is null.\n"); /* iic_deinit is null */
1864
1865 return 3; /* return error */
1866 }
1867 if (handle->iic_read == NULL) /* check iic_read */
1868 {
1869 handle->debug_print("pca9685: iic_read is null.\n"); /* iic_read is null */
1870
1871 return 3; /* return error */
1872 }
1873 if (handle->iic_write == NULL) /* check iic_write */
1874 {
1875 handle->debug_print("pca9685: iic_write is null.\n"); /* iic_write is null */
1876
1877 return 3; /* return error */
1878 }
1879 if (handle->oe_gpio_init == NULL) /* check oe_gpio_init */
1880 {
1881 handle->debug_print("pca9685: oe_gpio_init is null.\n"); /* oe_gpio_init is null */
1882
1883 return 3; /* return error */
1884 }
1885 if (handle->oe_gpio_deinit == NULL) /* check oe_gpio_deinit */
1886 {
1887 handle->debug_print("pca9685: oe_gpio_deinit is null.\n"); /* oe_gpio_deinit is null */
1888
1889 return 3; /* return error */
1890 }
1891 if (handle->oe_gpio_write == NULL) /* check oe_gpio_write */
1892 {
1893 handle->debug_print("pca9685: oe_gpio_write is null.\n"); /* oe_gpio_write is null */
1894
1895 return 3; /* return error */
1896 }
1897
1898 if (handle->iic_init() != 0) /* iic init */
1899 {
1900 handle->debug_print("pca9685: iic init failed.\n"); /* iic init failed */
1901
1902 return 1; /* return error */
1903 }
1904 if (handle->oe_gpio_init() != 0) /* oe gpio init */
1905 {
1906 handle->debug_print("pca9685: oe gpio init failed.\n"); /* oe gpio init failed */
1907 (void)handle->iic_deinit(); /* iic deinit */
1908
1909 return 1; /* return error */
1910 }
1911
1912 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
1913 if (res != 0) /* check result */
1914 {
1915 handle->debug_print("pca9685: read mode 1 register failed.\n"); /* read mode 1 register failed */
1916 (void)handle->oe_gpio_deinit(); /* oe gpio deinit */
1917 (void)handle->iic_deinit(); /* iic deinit */
1918
1919 return 4; /* return error */
1920 }
1921 if ((prev & 0x80) != 0) /* check reset bit */
1922 {
1923 prev &= ~(1 << 4); /* clear sleep bit */
1924 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
1925 if (res != 0) /* check result */
1926 {
1927 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
1928 (void)handle->oe_gpio_deinit(); /* oe gpio deinit */
1929 (void)handle->iic_deinit(); /* iic deinit */
1930
1931 return 4; /* return error */
1932 }
1933 handle->delay_ms(2); /* delay 2 ms */
1934 }
1935 prev |= (1 << 7); /* set reset bit */
1936 prev |= (1 << 5); /* enable auto increment */
1937 prev &= ~(1 << 6); /* clear extern clock bit */
1938 prev &= ~(1 << 4); /* clear sleep bit */
1939 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
1940 if (res != 0) /* check result */
1941 {
1942 handle->debug_print("pca9685: write mode 1 register failed.\n"); /* write mode 1 register failed */
1943 (void)handle->oe_gpio_deinit(); /* oe gpio deinit */
1944 (void)handle->iic_deinit(); /* iic deinit */
1945
1946 return 4; /* return error */
1947 }
1948 handle->delay_ms(2); /* delay 2 ms */
1949 handle->inited = 1; /* flag finish initialization */
1950
1951 return 0; /* success return 0 */
1952}
1953
1965uint8_t pca9685_deinit(pca9685_handle_t *handle)
1966{
1967 uint8_t res, prev;
1968
1969 if (handle == NULL) /* check handle */
1970 {
1971 return 2; /* return error */
1972 }
1973 if (handle->inited != 1) /* check handle initialization */
1974 {
1975 return 3; /* return error */
1976 }
1977
1978 res = handle->iic_read(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* read mode 1 register */
1979 if (res != 0) /* check result */
1980 {
1981 handle->debug_print("pca9685: power down failed failed.\n"); /* power down failed */
1982
1983 return 1; /* return error */
1984 }
1985 prev |= (1 << 4); /* set sleep bit */
1986 res = handle->iic_write(handle->iic_addr, PCA9685_REG_MODE1, (uint8_t *)&prev, 1); /* write mode 1 register */
1987 if (res != 0) /* check result */
1988 {
1989 handle->debug_print("pca9685: power down failed failed.\n"); /* power down failed */
1990
1991 return 1; /* return error */
1992 }
1993 if (handle->oe_gpio_deinit() != 0) /* oe gpio deinit */
1994 {
1995 handle->debug_print("pca9685: oe gpio deinit failed.\n"); /* oe gpio deinit failed */
1996
1997 return 4; /* return error */
1998 }
1999 if (handle->iic_deinit() != 0) /* iic deinit */
2000 {
2001 handle->debug_print("pca9685: iic deinit failed.\n"); /* iic deinit failed */
2002
2003 return 4; /* return error */
2004 }
2005 handle->inited = 0; /* set closed flag */
2006
2007 return 0; /* success return 0 */
2008}
2009
2023uint8_t pca9685_set_reg(pca9685_handle_t *handle, uint8_t reg, uint8_t *buf, uint16_t len)
2024{
2025 if (handle == NULL) /* check handle */
2026 {
2027 return 2; /* return error */
2028 }
2029 if (handle->inited != 1) /* check handle initialization */
2030 {
2031 return 3; /* return error */
2032 }
2033
2034 if (handle->iic_write(handle->iic_addr, reg, buf, len) != 0) /* write data */
2035 {
2036 return 1; /* return error */
2037 }
2038 else
2039 {
2040 return 0; /* success return 0 */
2041 }
2042}
2043
2057uint8_t pca9685_get_reg(pca9685_handle_t *handle, uint8_t reg, uint8_t *buf, uint16_t len)
2058{
2059 if (handle == NULL) /* check handle */
2060 {
2061 return 2; /* return error */
2062 }
2063 if (handle->inited != 1) /* check handle initialization */
2064 {
2065 return 3; /* return error */
2066 }
2067
2068 if (handle->iic_read(handle->iic_addr, reg, buf, len) != 0) /* read data */
2069 {
2070 return 1; /* return error */
2071 }
2072 else
2073 {
2074 return 0; /* success return 0 */
2075 }
2076}
2077
2086uint8_t pca9685_info(pca9685_info_t *info)
2087{
2088 if (info == NULL) /* check handle */
2089 {
2090 return 2; /* return error */
2091 }
2092
2093 memset(info, 0, sizeof(pca9685_info_t)); /* initialize pca9685 info structure */
2094 strncpy(info->chip_name, CHIP_NAME, 32); /* copy chip name */
2095 strncpy(info->manufacturer_name, MANUFACTURER_NAME, 32); /* copy manufacturer name */
2096 strncpy(info->interface, "IIC", 8); /* copy interface name */
2097 info->supply_voltage_min_v = SUPPLY_VOLTAGE_MIN; /* set minimal supply voltage */
2098 info->supply_voltage_max_v = SUPPLY_VOLTAGE_MAX; /* set maximum supply voltage */
2099 info->max_current_ma = MAX_CURRENT; /* set maximum current */
2100 info->temperature_max = TEMPERATURE_MAX; /* set minimal temperature */
2101 info->temperature_min = TEMPERATURE_MIN; /* set maximum temperature */
2102 info->driver_version = DRIVER_VERSION; /* set driver version */
2103
2104 return 0; /* success return 0 */
2105}
PCA9685_REG_SUBADR3
#define PCA9685_REG_SUBADR3
Definition driver_pca9685.c:60
MAX_CURRENT
#define MAX_CURRENT
Definition driver_pca9685.c:48
PCA9685_REG_ALL_LED_ON_L
#define PCA9685_REG_ALL_LED_ON_L
Definition driver_pca9685.c:66
SUPPLY_VOLTAGE_MAX
#define SUPPLY_VOLTAGE_MAX
Definition driver_pca9685.c:47
PCA9685_REG_MODE2
#define PCA9685_REG_MODE2
Definition driver_pca9685.c:57
PCA9685_REG_SUBADR1
#define PCA9685_REG_SUBADR1
Definition driver_pca9685.c:58
PCA9685_REG_MODE1
#define PCA9685_REG_MODE1
chip register definition
Definition driver_pca9685.c:56
TEMPERATURE_MAX
#define TEMPERATURE_MAX
Definition driver_pca9685.c:50
PCA9685_REG_SUBADR2
#define PCA9685_REG_SUBADR2
Definition driver_pca9685.c:59
PCA9685_REG_PRE_SCALE
#define PCA9685_REG_PRE_SCALE
Definition driver_pca9685.c:70
MANUFACTURER_NAME
#define MANUFACTURER_NAME
Definition driver_pca9685.c:45
TEMPERATURE_MIN
#define TEMPERATURE_MIN
Definition driver_pca9685.c:49
SUPPLY_VOLTAGE_MIN
#define SUPPLY_VOLTAGE_MIN
Definition driver_pca9685.c:46
PCA9685_REG_LED0_ON_L
#define PCA9685_REG_LED0_ON_L
Definition driver_pca9685.c:62
CHIP_NAME
#define CHIP_NAME
chip information definition
Definition driver_pca9685.c:44
DRIVER_VERSION
#define DRIVER_VERSION
Definition driver_pca9685.c:51
PCA9685_REG_ALLCALLADR
#define PCA9685_REG_ALLCALLADR
Definition driver_pca9685.c:61
driver_pca9685.h
driver pca9685 header file
pca9685_pwm_convert_to_register
uint8_t pca9685_pwm_convert_to_register(pca9685_handle_t *handle, float delay_percent, float high_duty_cycle_percent, uint16_t *on_count, uint16_t *off_count)
convert the pwm to the register raw data
Definition driver_pca9685.c:1742
pca9685_set_prescaler
uint8_t pca9685_set_prescaler(pca9685_handle_t *handle, uint8_t prescaler)
set the clock pres cale
Definition driver_pca9685.c:1605
pca9685_write_channel
uint8_t pca9685_write_channel(pca9685_handle_t *handle, pca9685_channel_t channel, uint16_t on_count, uint16_t off_count)
write led channels
Definition driver_pca9685.c:1467
pca9685_bool_t
pca9685_bool_t
pca9685 bool enumeration definition
Definition driver_pca9685.h:141
pca9685_get_subaddress_1
uint8_t pca9685_get_subaddress_1(pca9685_handle_t *handle, uint8_t *addr)
get the sub address 1
Definition driver_pca9685.c:1219
pca9685_write_all_channel
uint8_t pca9685_write_all_channel(pca9685_handle_t *handle, uint16_t on_count, uint16_t off_count)
write all led channels
Definition driver_pca9685.c:1558
pca9685_address_t
pca9685_address_t
pca9685 address enumeration definition
Definition driver_pca9685.h:70
pca9685_get_addr_pin
uint8_t pca9685_get_addr_pin(pca9685_handle_t *handle, pca9685_address_t *addr_pin)
get the address pin
Definition driver_pca9685.c:103
pca9685_set_addr
uint8_t pca9685_set_addr(pca9685_handle_t *handle, uint8_t addr)
set the address
Definition driver_pca9685.c:124
pca9685_get_respond_all_call
uint8_t pca9685_get_respond_all_call(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the respond all call status
Definition driver_pca9685.c:819
pca9685_handle_t
struct pca9685_handle_s pca9685_handle_t
pca9685 handle structure definition
pca9685_set_respond_all_call
uint8_t pca9685_set_respond_all_call(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable respond all call
Definition driver_pca9685.c:774
pca9685_init
uint8_t pca9685_init(pca9685_handle_t *handle)
initialize the chip
Definition driver_pca9685.c:1843
pca9685_set_active
uint8_t pca9685_set_active(pca9685_handle_t *handle, pca9685_bool_t enable)
set the chip active
Definition driver_pca9685.c:168
pca9685_get_output_change
uint8_t pca9685_get_output_change(pca9685_handle_t *handle, pca9685_output_change_t *change)
get the output change type
Definition driver_pca9685.c:983
pca9685_get_all_call_address
uint8_t pca9685_get_all_call_address(pca9685_handle_t *handle, uint8_t *addr)
get the all call address
Definition driver_pca9685.c:1429
pca9685_set_addr_pin
uint8_t pca9685_set_addr_pin(pca9685_handle_t *handle, pca9685_address_t addr_pin)
set the address pin
Definition driver_pca9685.c:81
pca9685_get_external_clock_pin
uint8_t pca9685_get_external_clock_pin(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the external clock pin status
Definition driver_pca9685.c:327
pca9685_output_disable_type_t
pca9685_output_disable_type_t
pca9685 output disable type enumeration definition
Definition driver_pca9685.h:168
pca9685_get_restart
uint8_t pca9685_get_restart(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the restart status
Definition driver_pca9685.c:245
pca9685_set_output_driver
uint8_t pca9685_set_output_driver(pca9685_handle_t *handle, pca9685_output_driver_t driver)
set the output driver type
Definition driver_pca9685.c:1020
pca9685_set_respond_subaddress_2
uint8_t pca9685_set_respond_subaddress_2(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable respond sub address 2
Definition driver_pca9685.c:610
pca9685_get_prescaler
uint8_t pca9685_get_prescaler(pca9685_handle_t *handle, uint8_t *prescaler)
get the clock pre scale
Definition driver_pca9685.c:1646
pca9685_get_addr
uint8_t pca9685_get_addr(pca9685_handle_t *handle, uint8_t *addr)
get the address
Definition driver_pca9685.c:145
pca9685_get_sleep_mode
uint8_t pca9685_get_sleep_mode(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the sleep mode status
Definition driver_pca9685.c:491
pca9685_set_output_disable_type
uint8_t pca9685_set_output_disable_type(pca9685_handle_t *handle, pca9685_output_disable_type_t type)
set the output disable type
Definition driver_pca9685.c:1102
pca9685_get_subaddress_3
uint8_t pca9685_get_subaddress_3(pca9685_handle_t *handle, uint8_t *addr)
get the sub address 3
Definition driver_pca9685.c:1359
pca9685_read_channel
uint8_t pca9685_read_channel(pca9685_handle_t *handle, pca9685_channel_t channel, uint16_t *on_count, uint16_t *off_count)
read led channels
Definition driver_pca9685.c:1516
pca9685_get_output_driver
uint8_t pca9685_get_output_driver(pca9685_handle_t *handle, pca9685_output_driver_t *driver)
get the output driver type
Definition driver_pca9685.c:1065
pca9685_set_subaddress_2
uint8_t pca9685_set_subaddress_2(pca9685_handle_t *handle, uint8_t addr)
set the sub address 2
Definition driver_pca9685.c:1254
pca9685_output_frequency_convert_to_register
uint8_t pca9685_output_frequency_convert_to_register(pca9685_handle_t *handle, uint32_t oscillator, uint16_t output_freq, uint8_t *reg)
convert the output frequency to the register raw data
Definition driver_pca9685.c:1682
pca9685_set_register_auto_increment
uint8_t pca9685_set_register_auto_increment(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable the register auto increment
Definition driver_pca9685.c:364
pca9685_set_respond_subaddress_3
uint8_t pca9685_set_respond_subaddress_3(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable respond sub address 3
Definition driver_pca9685.c:692
pca9685_info
uint8_t pca9685_info(pca9685_info_t *info)
get chip's information
Definition driver_pca9685.c:2086
pca9685_set_output_invert
uint8_t pca9685_set_output_invert(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable output invert
Definition driver_pca9685.c:856
pca9685_get_respond_subaddress_2
uint8_t pca9685_get_respond_subaddress_2(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the respond sub address 2 status
Definition driver_pca9685.c:655
pca9685_get_subaddress_2
uint8_t pca9685_get_subaddress_2(pca9685_handle_t *handle, uint8_t *addr)
get the sub address 2
Definition driver_pca9685.c:1289
pca9685_channel_t
pca9685_channel_t
pca9685 channel enumeration definition
Definition driver_pca9685.h:179
pca9685_get_output_disable_type
uint8_t pca9685_get_output_disable_type(pca9685_handle_t *handle, pca9685_output_disable_type_t *type)
get the output disable type
Definition driver_pca9685.c:1147
pca9685_set_subaddress_1
uint8_t pca9685_set_subaddress_1(pca9685_handle_t *handle, uint8_t addr)
set the sub address 1
Definition driver_pca9685.c:1184
pca9685_set_restart
uint8_t pca9685_set_restart(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable restart
Definition driver_pca9685.c:200
pca9685_output_frequency_convert_to_data
uint8_t pca9685_output_frequency_convert_to_data(pca9685_handle_t *handle, uint32_t oscillator, uint8_t reg, uint16_t *output_freq)
convert the register raw data to the output frequency
Definition driver_pca9685.c:1710
pca9685_output_driver_t
pca9685_output_driver_t
pca9685 output driver enumeration definition
Definition driver_pca9685.h:159
pca9685_pwm_convert_to_data
uint8_t pca9685_pwm_convert_to_data(pca9685_handle_t *handle, uint16_t on_count, uint16_t off_count, float *delay_percent, float *high_duty_cycle_percent)
convert the register raw data to the pwm
Definition driver_pca9685.c:1794
pca9685_set_sleep_mode
uint8_t pca9685_set_sleep_mode(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable the sleep mode
Definition driver_pca9685.c:446
pca9685_info_t
struct pca9685_info_s pca9685_info_t
pca9685 information structure definition
pca9685_get_respond_subaddress_1
uint8_t pca9685_get_respond_subaddress_1(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the respond sub address 1 status
Definition driver_pca9685.c:573
pca9685_get_output_invert
uint8_t pca9685_get_output_invert(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the output invert status
Definition driver_pca9685.c:901
pca9685_set_external_clock_pin
uint8_t pca9685_set_external_clock_pin(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable the external clock pin
Definition driver_pca9685.c:282
pca9685_output_change_t
pca9685_output_change_t
pca9685 output change enumeration definition
Definition driver_pca9685.h:150
pca9685_deinit
uint8_t pca9685_deinit(pca9685_handle_t *handle)
close the chip
Definition driver_pca9685.c:1965
pca9685_get_respond_subaddress_3
uint8_t pca9685_get_respond_subaddress_3(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the respond sub address 3 status
Definition driver_pca9685.c:737
pca9685_set_respond_subaddress_1
uint8_t pca9685_set_respond_subaddress_1(pca9685_handle_t *handle, pca9685_bool_t enable)
enable or disable respond sub address 1
Definition driver_pca9685.c:528
pca9685_set_subaddress_3
uint8_t pca9685_set_subaddress_3(pca9685_handle_t *handle, uint8_t addr)
set the sub address 3
Definition driver_pca9685.c:1324
pca9685_set_all_call_address
uint8_t pca9685_set_all_call_address(pca9685_handle_t *handle, uint8_t addr)
set the all call address
Definition driver_pca9685.c:1394
pca9685_set_output_change
uint8_t pca9685_set_output_change(pca9685_handle_t *handle, pca9685_output_change_t change)
set the output change type
Definition driver_pca9685.c:938
pca9685_get_register_auto_increment
uint8_t pca9685_get_register_auto_increment(pca9685_handle_t *handle, pca9685_bool_t *enable)
get the register auto increment status
Definition driver_pca9685.c:409
pca9685_set_reg
uint8_t pca9685_set_reg(pca9685_handle_t *handle, uint8_t reg, uint8_t *buf, uint16_t len)
set the chip register
Definition driver_pca9685.c:2023
pca9685_get_reg
uint8_t pca9685_get_reg(pca9685_handle_t *handle, uint8_t reg, uint8_t *buf, uint16_t len)
get the chip register
Definition driver_pca9685.c:2057
pca9685_handle_s::inited
uint8_t inited
Definition driver_pca9685.h:213
pca9685_handle_s::delay_ms
void(* delay_ms)(uint32_t ms)
Definition driver_pca9685.h:211
pca9685_handle_s::oe_gpio_init
uint8_t(* oe_gpio_init)(void)
Definition driver_pca9685.h:208
pca9685_handle_s::debug_print
void(* debug_print)(const char *const fmt,...)
Definition driver_pca9685.h:212
pca9685_handle_s::iic_init
uint8_t(* iic_init)(void)
Definition driver_pca9685.h:204
pca9685_handle_s::oe_gpio_deinit
uint8_t(* oe_gpio_deinit)(void)
Definition driver_pca9685.h:209
pca9685_handle_s::oe_gpio_write
uint8_t(* oe_gpio_write)(uint8_t value)
Definition driver_pca9685.h:210
pca9685_handle_s::iic_write
uint8_t(* iic_write)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
Definition driver_pca9685.h:207
pca9685_handle_s::iic_addr
uint8_t iic_addr
Definition driver_pca9685.h:203
pca9685_handle_s::iic_read
uint8_t(* iic_read)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len)
Definition driver_pca9685.h:206
pca9685_handle_s::iic_deinit
uint8_t(* iic_deinit)(void)
Definition driver_pca9685.h:205
pca9685_info_s::temperature_max
float temperature_max
Definition driver_pca9685.h:228
pca9685_info_s::supply_voltage_max_v
float supply_voltage_max_v
Definition driver_pca9685.h:225
pca9685_info_s::driver_version
uint32_t driver_version
Definition driver_pca9685.h:229
pca9685_info_s::temperature_min
float temperature_min
Definition driver_pca9685.h:227
pca9685_info_s::max_current_ma
float max_current_ma
Definition driver_pca9685.h:226
pca9685_info_s::manufacturer_name
char manufacturer_name[32]
Definition driver_pca9685.h:222
pca9685_info_s::supply_voltage_min_v
float supply_voltage_min_v
Definition driver_pca9685.h:224
pca9685_info_s::interface
char interface[8]
Definition driver_pca9685.h:223
pca9685_info_s::chip_name
char chip_name[32]
Definition driver_pca9685.h:221