Rev 454 | Rev 469 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 454 | Rev 465 | ||
---|---|---|---|
Line 57... | Line 57... | ||
57 | #include <stdio.h> |
57 | #include <stdio.h> |
58 | #include <string.h> |
58 | #include <string.h> |
59 | #include "91x_lib.h" |
59 | #include "91x_lib.h" |
60 | #include "ncmag.h" |
60 | #include "ncmag.h" |
61 | #include "i2c.h" |
61 | #include "i2c.h" |
- | 62 | #include "i2c0.h" |
|
- | 63 | ||
62 | #include "timer1.h" |
64 | #include "timer1.h" |
63 | #include "led.h" |
65 | #include "led.h" |
64 | #include "uart1.h" |
66 | #include "uart1.h" |
65 | #include "eeprom.h" |
67 | #include "eeprom.h" |
66 | #include "mymath.h" |
68 | #include "mymath.h" |
Line 68... | Line 70... | ||
68 | #include "spi_slave.h" |
70 | #include "spi_slave.h" |
Line 69... | Line 71... | ||
69 | 71 | ||
70 | u8 NCMAG_Present = 0; |
72 | u8 NCMAG_Present = 0; |
Line -... | Line 73... | ||
- | 73 | u8 NCMAG_IsCalibrated = 0; |
|
- | 74 | ||
- | 75 | u8 *I2C_BufferPnt; |
|
- | 76 | u8 *I2C_ErrorPnt; |
|
- | 77 | I2C_TransmissionFunc_t I2C_TransmissionFunc; |
|
- | 78 | I2C_LockBufferFunc_t I2C_LockBufferFunc; |
|
- | 79 | I2C_WaitForEndOfTransmissionFunc_t I2C_WaitForEndOfTransmissionFunc; |
|
71 | u8 NCMAG_IsCalibrated = 0; |
80 | |
72 | 81 | ||
73 | // supported magnetic sensor types |
82 | // supported magnetic sensor types |
74 | #define TYPE_NONE 0 |
83 | #define TYPE_NONE 0 |
75 | #define TYPE_HMC5843 1 |
84 | #define TYPE_HMC5843 1 |
Line 218... | Line 227... | ||
218 | } __attribute__((packed)) MagConfig_t; |
227 | } __attribute__((packed)) MagConfig_t; |
Line 219... | Line 228... | ||
219 | 228 | ||
Line -... | Line 229... | ||
- | 229 | volatile MagConfig_t MagConfig; |
|
- | 230 | ||
- | 231 | ||
220 | volatile MagConfig_t MagConfig; |
232 | |
221 | 233 | ||
222 | 234 | ||
223 | // self test value |
235 | // self test value |
224 | #define LSM303DLH_TEST_XSCALE 495 |
236 | #define LSM303DLH_TEST_XSCALE 495 |
Line 543... | Line 555... | ||
543 | // --------------------------------------------------------------------- |
555 | // --------------------------------------------------------------------- |
544 | u8 NCMAG_SetMagConfig(void) |
556 | u8 NCMAG_SetMagConfig(void) |
545 | { |
557 | { |
546 | u8 retval = 0; |
558 | u8 retval = 0; |
547 | // try to catch the i2c buffer within 100 ms timeout |
559 | // try to catch the i2c buffer within 100 ms timeout |
548 | if(I2C_LockBuffer(100)) |
560 | if(I2C_LockBufferFunc(100)) |
549 | { |
561 | { |
550 | u8 TxBytes = 0; |
562 | u8 TxBytes = 0; |
551 | I2C_Buffer[TxBytes++] = REG_MAG_CRA; |
563 | I2C_BufferPnt[TxBytes++] = REG_MAG_CRA; |
552 | memcpy((u8*)(&I2C_Buffer[TxBytes]), (u8*)&MagConfig, sizeof(MagConfig)); |
564 | memcpy((u8*)(&I2C_BufferPnt[TxBytes]), (u8*)&MagConfig, sizeof(MagConfig)); |
553 | TxBytes += sizeof(MagConfig); |
565 | TxBytes += sizeof(MagConfig); |
554 | if(I2C_Transmission(MAG_SLAVE_ADDRESS, TxBytes, 0, 0)) |
566 | if(I2C_TransmissionFunc(MAG_SLAVE_ADDRESS, TxBytes, 0, 0)) |
555 | { |
567 | { |
556 | if(I2C_WaitForEndOfTransmission(100)) |
568 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
557 | { |
569 | { |
558 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
570 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
559 | } |
571 | } |
560 | } |
572 | } |
561 | } |
573 | } |
562 | return(retval); |
574 | return(retval); |
563 | } |
575 | } |
Line 565... | Line 577... | ||
565 | // ---------------------------------------------------------------------------------------- |
577 | // ---------------------------------------------------------------------------------------- |
566 | u8 NCMAG_GetMagConfig(void) |
578 | u8 NCMAG_GetMagConfig(void) |
567 | { |
579 | { |
568 | u8 retval = 0; |
580 | u8 retval = 0; |
569 | // try to catch the i2c buffer within 100 ms timeout |
581 | // try to catch the i2c buffer within 100 ms timeout |
570 | if(I2C_LockBuffer(100)) |
582 | if(I2C_LockBufferFunc(100)) |
571 | { |
583 | { |
572 | u8 TxBytes = 0; |
584 | u8 TxBytes = 0; |
573 | I2C_Buffer[TxBytes++] = REG_MAG_CRA; |
585 | I2C_BufferPnt[TxBytes++] = REG_MAG_CRA; |
574 | if(I2C_Transmission(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateMagConfig, sizeof(MagConfig))) |
586 | if(I2C_TransmissionFunc(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateMagConfig, sizeof(MagConfig))) |
575 | { |
587 | { |
576 | if(I2C_WaitForEndOfTransmission(100)) |
588 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
577 | { |
589 | { |
578 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
590 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
579 | } |
591 | } |
580 | } |
592 | } |
581 | } |
593 | } |
582 | return(retval); |
594 | return(retval); |
583 | } |
595 | } |
Line 585... | Line 597... | ||
585 | // ---------------------------------------------------------------------------------------- |
597 | // ---------------------------------------------------------------------------------------- |
586 | u8 NCMAG_SetAccConfig(void) |
598 | u8 NCMAG_SetAccConfig(void) |
587 | { |
599 | { |
588 | u8 retval = 0; |
600 | u8 retval = 0; |
589 | // try to catch the i2c buffer within 100 ms timeout |
601 | // try to catch the i2c buffer within 100 ms timeout |
590 | if(I2C_LockBuffer(100)) |
602 | if(I2C_LockBufferFunc(100)) |
591 | { |
603 | { |
592 | u8 TxBytes = 0; |
604 | u8 TxBytes = 0; |
593 | I2C_Buffer[TxBytes++] = REG_ACC_CTRL1|REG_ACC_MASK_AUTOINCREMENT; |
605 | I2C_BufferPnt[TxBytes++] = REG_ACC_CTRL1|REG_ACC_MASK_AUTOINCREMENT; |
594 | memcpy((u8*)(&I2C_Buffer[TxBytes]), (u8*)&AccConfig, sizeof(AccConfig)); |
606 | memcpy((u8*)(&I2C_BufferPnt[TxBytes]), (u8*)&AccConfig, sizeof(AccConfig)); |
595 | TxBytes += sizeof(AccConfig); |
607 | TxBytes += sizeof(AccConfig); |
596 | if(I2C_Transmission(ACC_SLAVE_ADDRESS, TxBytes, 0, 0)) |
608 | if(I2C_TransmissionFunc(ACC_SLAVE_ADDRESS, TxBytes, 0, 0)) |
597 | { |
609 | { |
598 | if(I2C_WaitForEndOfTransmission(100)) |
610 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
599 | { |
611 | { |
600 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
612 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
601 | } |
613 | } |
602 | } |
614 | } |
603 | } |
615 | } |
604 | return(retval); |
616 | return(retval); |
605 | } |
617 | } |
Line 607... | Line 619... | ||
607 | // ---------------------------------------------------------------------------------------- |
619 | // ---------------------------------------------------------------------------------------- |
608 | u8 NCMAG_GetAccConfig(void) |
620 | u8 NCMAG_GetAccConfig(void) |
609 | { |
621 | { |
610 | u8 retval = 0; |
622 | u8 retval = 0; |
611 | // try to catch the i2c buffer within 100 ms timeout |
623 | // try to catch the i2c buffer within 100 ms timeout |
612 | if(I2C_LockBuffer(100)) |
624 | if(I2C_LockBufferFunc(100)) |
613 | { |
625 | { |
614 | u8 TxBytes = 0; |
626 | u8 TxBytes = 0; |
615 | I2C_Buffer[TxBytes++] = REG_ACC_CTRL1|REG_ACC_MASK_AUTOINCREMENT; |
627 | I2C_BufferPnt[TxBytes++] = REG_ACC_CTRL1|REG_ACC_MASK_AUTOINCREMENT; |
616 | if(I2C_Transmission(ACC_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateAccConfig, sizeof(AccConfig))) |
628 | if(I2C_TransmissionFunc(ACC_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateAccConfig, sizeof(AccConfig))) |
617 | { |
629 | { |
618 | if(I2C_WaitForEndOfTransmission(100)) |
630 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
619 | { |
631 | { |
620 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
632 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
621 | } |
633 | } |
622 | } |
634 | } |
623 | } |
635 | } |
624 | return(retval); |
636 | return(retval); |
625 | } |
637 | } |
Line 627... | Line 639... | ||
627 | // ---------------------------------------------------------------------------------------- |
639 | // ---------------------------------------------------------------------------------------- |
628 | u8 NCMAG_GetIdentification(void) |
640 | u8 NCMAG_GetIdentification(void) |
629 | { |
641 | { |
630 | u8 retval = 0; |
642 | u8 retval = 0; |
631 | // try to catch the i2c buffer within 100 ms timeout |
643 | // try to catch the i2c buffer within 100 ms timeout |
632 | if(I2C_LockBuffer(100)) |
644 | if(I2C_LockBufferFunc(100)) |
633 | { |
645 | { |
634 | u16 TxBytes = 0; |
646 | u16 TxBytes = 0; |
635 | NCMAG_Identification.A = 0xFF; |
647 | NCMAG_Identification.A = 0xFF; |
636 | NCMAG_Identification.B = 0xFF; |
648 | NCMAG_Identification.B = 0xFF; |
637 | NCMAG_Identification.C = 0xFF; |
649 | NCMAG_Identification.C = 0xFF; |
638 | I2C_Buffer[TxBytes++] = REG_MAG_IDA; |
650 | I2C_BufferPnt[TxBytes++] = REG_MAG_IDA; |
639 | // initiate transmission |
651 | // initiate transmission |
640 | if(I2C_Transmission(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateIdentification, sizeof(NCMAG_Identification))) |
652 | if(I2C_TransmissionFunc(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateIdentification, sizeof(NCMAG_Identification))) |
641 | { |
653 | { |
642 | if(I2C_WaitForEndOfTransmission(100)) |
654 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
643 | { |
655 | { |
644 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
656 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
645 | } |
657 | } |
646 | } |
658 | } |
647 | } |
659 | } |
648 | return(retval); |
660 | return(retval); |
649 | } |
661 | } |
Line 650... | Line 662... | ||
650 | 662 | ||
651 | u8 NCMAG_GetIdentification_Sub(void) |
663 | u8 NCMAG_GetIdentification_Sub(void) |
652 | { |
664 | { |
653 | u8 retval = 0; |
665 | u8 retval = 0; |
654 | // try to catch the i2c buffer within 100 ms timeout |
666 | // try to catch the i2c buffer within 100 ms timeout |
655 | if(I2C_LockBuffer(100)) |
667 | if(I2C_LockBufferFunc(100)) |
656 | { |
668 | { |
657 | u16 TxBytes = 0; |
669 | u16 TxBytes = 0; |
658 | NCMAG_Identification2.Sub = 0xFF; |
670 | NCMAG_Identification2.Sub = 0xFF; |
659 | I2C_Buffer[TxBytes++] = REG_MAG_IDF; |
671 | I2C_BufferPnt[TxBytes++] = REG_MAG_IDF; |
660 | // initiate transmission |
672 | // initiate transmission |
661 | if(I2C_Transmission(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateIdentification_Sub, sizeof(NCMAG_Identification2))) |
673 | if(I2C_TransmissionFunc(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateIdentification_Sub, sizeof(NCMAG_Identification2))) |
662 | { |
674 | { |
663 | if(I2C_WaitForEndOfTransmission(100)) |
675 | if(I2C_WaitForEndOfTransmissionFunc(100)) |
664 | { |
676 | { |
665 | if(I2C_Error == I2C_ERROR_NONE) retval = 1; |
677 | if(*I2C_ErrorPnt == I2C_ERROR_NONE) retval = 1; |
666 | } |
678 | } |
667 | } |
679 | } |
668 | } |
680 | } |
669 | return(retval); |
681 | return(retval); |
Line 672... | Line 684... | ||
672 | 684 | ||
673 | // ---------------------------------------------------------------------------------------- |
685 | // ---------------------------------------------------------------------------------------- |
674 | void NCMAG_GetMagVector(void) |
686 | void NCMAG_GetMagVector(void) |
675 | { |
687 | { |
676 | // try to catch the I2C buffer within 0 ms |
688 | // try to catch the I2C buffer within 0 ms |
677 | if(I2C_LockBuffer(0)) |
689 | if(I2C_LockBufferFunc(0)) |
678 | { |
690 | { |
679 | u16 TxBytes = 0; |
691 | u16 TxBytes = 0; |
680 | // set register pointer |
692 | // set register pointer |
681 | I2C_Buffer[TxBytes++] = REG_MAG_DATAX_MSB; |
693 | I2C_BufferPnt[TxBytes++] = REG_MAG_DATAX_MSB; |
682 | // initiate transmission |
694 | // initiate transmission |
683 | I2C_Transmission(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateMagVector, sizeof(MagVector)); |
695 | I2C_TransmissionFunc(MAG_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateMagVector, sizeof(MagVector)); |
684 | } |
696 | } |
Line 685... | Line 697... | ||
685 | } |
697 | } |
686 | 698 | ||
687 | //---------------------------------------------------------------- |
699 | //---------------------------------------------------------------- |
688 | void NCMAG_GetAccVector(void) |
700 | void NCMAG_GetAccVector(void) |
689 | { |
701 | { |
690 | // try to catch the I2C buffer within 0 ms |
702 | // try to catch the I2C buffer within 0 ms |
691 | if(I2C_LockBuffer(0)) |
703 | if(I2C_LockBufferFunc(0)) |
692 | { |
704 | { |
693 | u16 TxBytes = 0; |
705 | u16 TxBytes = 0; |
694 | // set register pointer |
706 | // set register pointer |
695 | I2C_Buffer[TxBytes++] = REG_ACC_X_LSB|REG_ACC_MASK_AUTOINCREMENT; |
707 | I2C_BufferPnt[TxBytes++] = REG_ACC_X_LSB|REG_ACC_MASK_AUTOINCREMENT; |
696 | // initiate transmission |
708 | // initiate transmission |
697 | I2C_Transmission(ACC_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateAccVector, sizeof(AccRawVector)); |
709 | I2C_TransmissionFunc(ACC_SLAVE_ADDRESS, TxBytes, &NCMAG_UpdateAccVector, sizeof(AccRawVector)); |
Line 698... | Line 710... | ||
698 | } |
710 | } |
699 | } |
711 | } |
Line 902... | Line 914... | ||
902 | return(retval); |
914 | return(retval); |
903 | } |
915 | } |
Line 904... | Line 916... | ||
904 | 916 | ||
- | 917 | ||
- | 918 | //---------------------------------------------------------------- |
|
- | 919 | void NCMAG_SelectI2CBus(u8 busno) |
|
- | 920 | { |
|
- | 921 | if (busno == 0) |
|
- | 922 | { |
|
- | 923 | I2C_WaitForEndOfTransmissionFunc = &I2C0_WaitForEndOfTransmission; |
|
- | 924 | I2C_LockBufferFunc = &I2C0_LockBuffer; |
|
- | 925 | I2C_TransmissionFunc = &I2C0_Transmission; |
|
- | 926 | I2C_BufferPnt = I2C0_Buffer; |
|
- | 927 | I2C_ErrorPnt = &I2C0_Error; |
|
- | 928 | } |
|
- | 929 | else |
|
- | 930 | { |
|
- | 931 | I2C_WaitForEndOfTransmissionFunc = &I2C_WaitForEndOfTransmission; |
|
- | 932 | I2C_LockBufferFunc = &I2C_LockBuffer; |
|
- | 933 | I2C_TransmissionFunc = &I2C_Transmission; |
|
- | 934 | I2C_BufferPnt = I2C_Buffer; |
|
- | 935 | I2C_ErrorPnt = &I2C_Error; |
|
- | 936 | } |
|
- | 937 | } |
|
905 | 938 | ||
906 | //---------------------------------------------------------------- |
939 | //---------------------------------------------------------------- |
907 | u8 NCMAG_Init(void) |
940 | u8 NCMAG_Init(void) |
908 | { |
941 | { |
909 | u8 msg[64]; |
942 | u8 msg[64]; |
Line -... | Line 943... | ||
- | 943 | u8 retval = 0; |
|
- | 944 | u8 repeat; |
|
910 | u8 retval = 0; |
945 | |
911 | u8 repeat; |
946 | NCMAG_SelectI2CBus(0); |
912 | 947 | ||
913 | NCMAG_Present = 0; |
948 | NCMAG_Present = 0; |
914 | NCMAG_SensorType = TYPE_HMC5843; // assuming having an HMC5843 |
949 | NCMAG_SensorType = TYPE_HMC5843; // assuming having an HMC5843 |
915 | // polling for LSM302DLH/DLM option by ACC address ack |
950 | // polling for LSM302DLH/DLM option by ACC address ack |
916 | repeat = 0; |
951 | repeat = 0; |
917 | do |
952 | do |
918 | { |
953 | { |
919 | retval = NCMAG_GetAccConfig(); |
954 | retval = NCMAG_GetAccConfig(); |
920 | if(retval) break; // break loop on success |
955 | if(retval) break; // break loop on success |
921 | UART1_PutString("."); |
956 | UART1_PutString("*"); |
922 | repeat++; |
957 | repeat++; |
923 | }while(repeat < 3); |
958 | }while(repeat < 3); |
Line 945... | Line 980... | ||
945 | retval = 0; |
980 | retval = 0; |
946 | do |
981 | do |
947 | { |
982 | { |
948 | retval = NCMAG_GetIdentification(); |
983 | retval = NCMAG_GetIdentification(); |
949 | if(retval) break; // break loop on success |
984 | if(retval) break; // break loop on success |
950 | UART1_PutString("."); |
985 | UART1_PutString("#"); |
951 | repeat++; |
986 | repeat++; |
952 | }while(repeat < 12); |
987 | }while(repeat < 12); |
Line 953... | Line 988... | ||
953 | 988 | ||
954 | // if we got an answer to id request |
989 | // if we got an answer to id request |