MSP430 硬件I2C 中断法始终调不通，求助！！！

2019-03-24 10:19发布

站内问答 / TI MCU
14749 2 1219
MSP430F5x单片机硬件I2C通过中断的方式对AT24C02进行读写
代码如下：
  1. #include "msp430.h"

  3. typedef unsigned char uint8;

  5. uint8 test_buf1[10] = {'H','E','L','L','O','Y','O','U',0,0};
  6. uint8 test_buf2[10] = {0,0,0,0,0,0,0,0,0};
  7. uint8 test_byte1 = 0x0c;
  8. uint8 test_byte2 = 0x00;

  10. //UCB0---I2C
  11. uint8 I2C_Tx_Size = 0;         //left data to be sent
  12. uint8 I2C_Rx_Size = 0;         //left data to be received
  13. uint8 *I2C_Tx_Buffer;         //pointer of data to be sent
  14. uint8 *I2C_Rx_Buffer;         //pointer of data to be received
  15. uint8 I2C_State = 0;         //flag of I2C tranmit or receive state
  16. uint8 I2C_Read_Data_Address = 0;
  17. uint8 I2C_Write_Data_Address = 0;
  18. uint8 UCB0_Rx_Or_Tx = 0; // 0--Receive only; 1--Transmit only; 2--Receive and transmit
  19. uint8 Flag_ACK=1;
  20. uint8 Flag_I2C_Address_Transmitted=0;

  22. #define EEPROM_SCL                        BIT2        //P1.2
  23. #define EEPROM_SDA                        BIT3        //P1.3
  24. #define ADG841_IN1                        BIT7        //P3.7
  25. #define LED                                    BIT1        //P3.1
  26. #define I2C_SLAVE_ADDR                        0x50

  28. //Delay
  29. #define         CPU_F                          ((double)26000000)        //XT2CLK--26MHz
  30. #define         delay_us(x)                  __delay_cycles((long)(CPU_F*(double)x/1000000.0))
  31. #define         delay_ms(x)                  __delay_cycles((long)(CPU_F*(double)x/1000.0))

  33. void UCB0_Interrupt_Sel(uint8);


  36. void CLK_Init()
  37. {
  38.         UCSCTL6 &= ~(XT2OFF+XT1OFF);                      // Enable XT2--26MHz XT1--32.768kHz

  40.         UCSCTL4 = SELA_0 + SELS_5 + SELM_5;

  42.         UCSCTL5 = DIVM_0 | DIVS_0 | DIVA_0;

  44.         do
  45.         {
  46.                   UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG);
  47.                                                         // Clear XT2,DCO fault flags
  48.                   SFRIFG1 &= ~OFIFG;                        // Clear fault flags
  49.         }while (SFRIFG1&OFIFG);                           // Test oscillator fault flag

  51.         UCSCTL4 = SELA_0 + SELS_5 + SELM_5;
  52. }
  53. void GPIO_Init()
  54. {
  55.         P3DIR |= LED + ADG841_IN1;

  57.         P5SEL |= BIT0 + BIT1; //Port select XT1
  58. }

  60. void LED_ON()
  61. {
  62.         P3OUT |= LED;
  63. }

  65. void LED_OFF()
  66. {
  67.         P3OUT &= ~LED;
  68. }

  70. void UCB0_I2C_Init()
  71. {
  72.         P1SEL |= EEPROM_SCL + EEPROM_SDA;
  73.         /* Disable USCI */
  74.         UCB0CTL1 |= UCSWRST;

  76.         //UCB0CTL0 &= ~UCSLA10;////
  77.         UCB0CTL0 = UCMST | UCMODE_3 | UCSYNC; //I2C, Mater mode, Synchronous mode

  79.         UCB0CTL1 = UCSSEL_2 | UCSWRST;

  81.         /* I2C Slave Address Register */
  82.         UCB0I2CSA = I2C_SLAVE_ADDR;

  84.         /* Bit Rate Control Register 0 */
  85.         UCB0BR0 = 4;   //  26MHz/260=100KHz
  86.         UCB0BR1 = 1;
  87.         /* Enable USCI */
  88.         UCB0CTL1 &= ~UCSWRST;

  90.         P3OUT |= ADG841_IN1;
  91. }

  93. uint8 I2C_Write_Page(uint8 Data_Address, uint8 *pBuffer, uint8 size)
  94. {
  95.         if(size==0)
  96.                 return 0;
  97.         if(UCB0STAT & UCBUSY)         //If I2C is busy
  98.                 return 0;

  100.         Flag_I2C_Address_Transmitted=0;

  102.         I2C_Write_Data_Address=Data_Address;
  103.         I2C_Tx_Buffer=pBuffer;
  104.         //I2C_Tx_Size=size-1;
  105.         I2C_Tx_Size=size;

  107.         //_EINT();
  108.         UCB0IFG &= ~UCTXIFG;
  109.         UCB0_Rx_Or_Tx = 1;                                         //transmit interrupt only
  110.         UCB0_Interrupt_Sel(UCB0_Rx_Or_Tx);
  111.         _EINT();

  113.         while( UCB0CTL1& UCTXSTP );
  114.         UCB0CTL1 |= UCTR+UCTXSTT;           //write mode, send start bit

  116.         __bis_SR_register(LPM0_bits);     // Enter LPM0

  118.         return 1;
  119. }

  121. uint8 I2C_Read_Page(uint8 Read_Data_Address, uint8 *pbuffer, uint8 size)
  122. {
  123.         _DINT();
  124.         if(size==0)
  125.                 return 0;
  126.         if(UCB0STAT & UCBUSY)        //If I2C is busy
  127.                 return 0;

  129.         I2C_Read_Data_Address=Read_Data_Address; // set address
  130.         Flag_I2C_Address_Transmitted=0;
  131.         I2C_Tx_Size=0;
  132. /*
  133.         UCB0_Rx_Or_Tx = 1;                //enable transmit interrupt bit only
  134.         _EINT();
  135.         UCB0_Interrupt_Sel(UCB0_Rx_Or_Tx);
  136. */

  138.         while( UCB0CTL1& UCTXSTP );
  139.         UCB0CTL1 |= UCTR;                //write mode
  140.         UCB0CTL1 |= UCTXSTT;    //send start bit
  141.         //UCB0TXBUF = E2PROM_WRITE_CMD;

  143.         if(Flag_I2C_Address_Transmitted==0)
  144.         {
  145.                 Flag_I2C_Address_Transmitted=1;
  146.                 UCB0TXBUF = I2C_Read_Data_Address;           //write data address
  147.         }

  149.         I2C_Rx_Buffer = pbuffer;
  150.         //I2C_Rx_Size = size-1;         //Number of data to be received
  151.         I2C_Rx_Size = size;

  153.         UCB0IFG &= ~UCRXIFG;
  154.         UCB0_Rx_Or_Tx=0;
  155.         UCB0_Interrupt_Sel(UCB0_Rx_Or_Tx);
  156.         _EINT();
  157.         while( UCB0CTL1& UCTXSTP );
  158.         //delay_ms(5);
  159.         UCB0CTL1 &= ~UCTR;                //read mode
  160.         //UCB0IFG &= ~UCRXIFG;                          // clear interrupt flag

  162.         UCB0CTL1 |= UCTXSTT;              //send start bit

  164.         __bis_SR_register(LPM0_bits);     // Enter LPM0, enable interrupts

  166.         return 0;
  167. }

  169. void UCB0_Interrupt_Sel(uint8 onOff)
  170. {

  172.         if(onOff == 0)                 //Only receive interrupt enabled
  173.         {
  174.                 UCB0IE &=~UCTXIE;                         // Disable USCI_B0 TX interrupt
  175.                 UCB0IE |= UCRXIE;                         // Enable USCI_B0 RX interrupt
  176.         }
  177.         else if(onOff==1)        //Only transmit interrupt enabled
  178.         {
  179.                 UCB0IE &=~UCRXIE;                         // Disable USCI_B0 RX interrupt
  180.                 UCB0IE |= UCTXIE;                         // Enable USCI_B0 TX interrupt
  181.         }
  182.         else               //Both receive and transmit interrupt enabled
  183.         {
  184.                 UCB0IE |= UCTXIE;                         // Enable USCI_B0 TX interrupt
  185.                 UCB0IE |= UCRXIE;                         // Enable USCI_B0 RX interrupt
  186.         }
  187. }

  189. void I2C_Write_Byte(uint8 data_addr, uint8 data_value)
  190. {
  191.         while(UCB0STAT & UCBUSY);         //If I2C is busy

  193.         Flag_I2C_Address_Transmitted=0;

  195.         I2C_Write_Data_Address=data_addr;
  196.         I2C_Tx_Buffer=&data_value;

  198.     //UCB0IFG &= ~UCTXIFG;
  199.         UCB0_Rx_Or_Tx = 1;                                         //transmit interrupt only

  201.         while( UCB0CTL1& UCTXSTP );
  202.         UCB0CTL1 |= UCTR+UCTXSTT;           //write mode, send start bit

  204.         UCB0_Interrupt_Sel(UCB0_Rx_Or_Tx);
  205.         _EINT();
  206.         __bis_SR_register(LPM0_bits);     // Enter LPM0
  207. }
  208. void I2C_Read_Byte(uint8 data_addr, uint8 * data_value)
  209. {
  210.     //_DINT();
  211.         I2C_State=1;
  212.         while(UCB0STAT & UCBUSY);        //If I2C is busy

  214.         I2C_Read_Data_Address=data_addr; // set address
  215.         Flag_I2C_Address_Transmitted=0;
  216.         I2C_Rx_Buffer = data_value;

  218.         while( UCB0CTL1& UCTXSTP );
  219.         UCB0CTL1 |= UCTR;                //write mode
  220.         UCB0CTL1 |= UCTXSTT;    //send start bit

  222.         UCB0IE |= UCTXIE;

  224.         UCB0_Rx_Or_Tx=0;
  225.         UCB0_Interrupt_Sel(UCB0_Rx_Or_Tx);
  226. /*
  227.         if(Flag_I2C_Address_Transmitted==0)
  228.         {
  229.                 Flag_I2C_Address_Transmitted=1;
  230.                 UCB0TXBUF = I2C_Read_Data_Address;           //write data address
  231.         }
  232. */
  233.         UCB0IFG &= ~UCTXIFG;

  235.         _EINT();
  236.         while( UCB0CTL1& UCTXSTP );

  238.         UCB0CTL1 &= ~UCTR;                //read mode

  240.         UCB0CTL1 |= UCTXSTT;              //send start bit

  242.         __bis_SR_register(LPM0_bits);     // Enter LPM0, enable interrupts

  244. }

  246. #pragma vector = USCI_B0_VECTOR
  247. __interrupt void USCI_B0_ISR(void)
  248. {
  249.         //_DINT();
  250.         switch(__even_in_range(UCB0IV,12))
  251.         {
  252.                 case 0:                                 // no interrupt
  253.                         break;
  254.                 case 2:                                        // ALIFG
  255.                         break;
  256.                 case 4:                                        // NACKIFG
  257.                         break;
  258.                 case 6:                                        // STTIFG
  259.                         break;
  260.                 case 8:                                        // STPIFG
  261.                         break;
  262.                 case 10:                                // RXIFG

  264.                         UCB0CTL1 |= UCTXSTP;                    // Generate I2C stop condition

  266.                         *I2C_Rx_Buffer = UCB0RXBUF;                 // Move final RX data to PRxData
  267.                         __bic_SR_register_on_exit(LPM0_bits);       // Exit active CPU
  268.                         break;
  269.                 case 12:                                // TXIFG

  271.                         if(Flag_I2C_Address_Transmitted==0)
  272.                         {
  273.                                 UCB0TXBUF = I2C_Write_Data_Address;           //write data address
  274.                                 Flag_I2C_Address_Transmitted=1;
  275.                                 while(!(UCB0IFG & UCTXIFG));
  276.                         }
  277.                         if(I2C_State==0)
  278.                         {
  279.                                 UCB0TXBUF = *I2C_Tx_Buffer;           // Load TX buffer
  280.                                 while(!(UCB0IFG & UCTXIFG));          // wait UCTXIFG=1
  281.                                 UCB0IE &= ~UCTXIE;
  282.                                 UCB0CTL1 |= UCTXSTP;                  // I2C stop condition
  283.                                 __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0
  284.                         }
  285.                         // Clear USCI_B0 TX int flag
  286.                         __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0

  288.                         break;
  289.                 default:
  290.                         break;
  291.         }
  292. }

  294. void main()
  295. {
  296.         uint8 I2C_SUCCESS_FLAG=0;
  297.         WDTCTL = WDTPW | WDTHOLD;        // Stop watchdog timer

  299.         GPIO_Init();

  301.         LED_ON();
  302.         CLK_Init();
  303.         UCB0_I2C_Init();

  305.         delay_ms(20);

  307.         I2C_Write_Byte(0x00,test_byte1);

  309.         I2C_Read_Byte(0x00,&test_byte2);
  310.         if((test_buf1[0]==test_buf2[0])&&(test_buf1[1]==test_buf2[1]))
  311.                 I2C_SUCCESS_FLAG=1;
  312. }
复制代码
等待法已经调试成功了，说明AT24C02没有问题，求助各位帮忙看看这个程序有什么问题，谢谢！ 此帖出自小平头技术问答
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
2条回答
xuchaojiecarl
2019-03-24 13:52
< ：TI_MSP430_内容页_SA7 -->
jqh_111 发表于 2015-4-19 22:01
用示波器截一下信号波形对不对。

单步的时候，发送的波形是正确的，但是接收的波形我没有去截。谢谢

一周热门 更多>

相关问题

    相关文章