[参考译文] MSP430FR5994：未触发中断。

您不能除以非整数值、因此实际除数为2。 500kHz 时钟可能会也可能不会扰乱目标器件。

由于 I2C 时钟与 MCLK 非常相似、因此在处理接收到的数据时必须非常快。 现在、如果您没有注释将 MCLK 设置为16MHz 的代码、您将获得两个好处。 第一个是可实现精确的400kHz I2C 时钟、第二个是 MCLK 比 I2C 时钟快得多。 放松时间。

编辑器中有一个用于插入代码的菜单项。 使用它。

感谢您的回答、我对这一行进行了注释。 我将 MCLK 设置为16MHz。 我还在示波器中进行了测试。 现在、我在示波器中检查了 i2c 时钟、得到的频率为1kHz。 但我需要400kHz 或100kHz。 请查找代码和示波器图像。

// Clock Setup
   FRCTL0 = FRCTLPW | NWAITS_1;
   // Clock System Setup
   CSCTL0_H = CSKEY_H;                    // Unlock CS registers
   CSCTL1 = DCOFSEL_0;                     // Set DCO to 1MHz
   CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK; // Set SMCLK = MCLK = DCO,
   CSCTL3 = DIVA__4 | DIVS__4 | DIVM__4;   // Set all corresponding clk sources to divide by 4 for errata
   CSCTL1 = DCOFSEL_4 | DCORSEL;             // Set DCO to 16MHz
   // Delay by ~10us to let DCO settle. 60 cycles = 20 cycles buffer + (10us / (1/4MHz))
   __delay_cycles(60);
   CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;     // Set all dividers
   CSCTL0_H = 0;

// i2c Configuration. 
	UCB2CTLW0 = UCSWRST;        // Reset I2C interface for config
    UCB2CTLW0 =                 /* USCI - B2 configuration register */
                    UCMST         | // Master mode
                    UCSYNC        | // Synchronous mode
                    UCMODE_3      | // I2C mode
                    UCSSEL__SMCLK | // Select SMCLK
                    UCTR          | // Transmitter mode
                    UCSWRST       | // Don't release reset (yet)
                    0;
        UCB2CTLW1 =
                    UCCLTO_1      | // Clock low time-out select (28ms)
                    UCASTP_2      | // Automatic STOP condition generation (enabled)
                    UCGLIT_0      | // Deglitch time (50ns)
                    0;
        UCB2TBCNT = stop_count;
        UCB2BRW = 40;               // Bit clock divider 1M/2.5 = 400kHz
        UCB2CTLW0 &= ~UCSWRST;      // Clear reset bit to start operation
        UCB2IE = UCNACKIE         | // Enable Nack interrupt
                 UCTXIE           | // Enable TX interrupt
                 UCRXIE           | // Enable RX interrupt
                 UCCLTOIE         | // Enable clock low time-out interrupt
                 0;

void transmit(uint16_t *field, uint8_t count){
    i2cConfig(count);
    UCB2I2CSA = BMP280_ADDRESS;             // Set slave address
    txCount = count;
    txBuffer = field;
    UCB2CTLW0 |= UCTR | UCTXSTT;            // Start request as transmitter
}

这会启动(Tx)事务、但不会等待它完成。 对于 read()，它接下来将重置 I2C 单元(在 i2cConfig 中)，该单元将终止事务。 这可能发生在第一个中断之前、也可能不会发生、但它肯定会在传输完成之前发生。 receive()执行类似的操作。

处理这一问题的一种常见方法是进入 LPM0、并在得出结论认为事务已完成时让 ISR 执行 LPM0_EXIT。 (我建议还具有某种"I2C_Status"标志、因为唤醒可能会模糊不清。)

好的、明白了。 但我这样做是因为我需要设置计数、即 UCB2TBCNT 这将针对 TX 和 Rx 进行更改。 我将再次启动。 然后、如果我在启用中断时使用 LPM0。 IE 位于此行 _bis_SR_register (LPM0 | GIE)中；类似这样。 代码在此行中停止。  

我使用此链接作为开发参考 github.com/.../accelerometer.c。

谢谢、

重置 I2C 单元是可以的(几乎是 UCASTTP 所需的)、您只需等待事务完成即可。

该操作的正确形式是 "_bis_SR_register (LPM0_bits | GIE)；"。 您在上面输入的内容将会编译、但会出现故障。

GitHub 代码显示为正确完成。 请特别注意 ISR 中策略性放置的"__BIC_SR_REGISTER_ON_EXIT (CPUOFF)；"运算--这些是完成唤醒。

好的、我将在传输后监控 UCASTP 状态。

是的、正确的形式是_ bis_SR_register (LPM0_bits + GIE)；。 正如我在前面的 msg 执行中告诉您的那样、该行中会停止执行。

现在该怎么办？

到目前为止、您有哪些产品？ 您是否到达 ISR？ 是否达到 WAKEUP 语句？

是的、我使用__ENABLE_INTERRUPT ()到达 ISR；根据您的建议，我没有使用__bis_SR_register (LPM0_Bits + GIE)； 按照建议、我使用此行 while (UCB2CTLW0 & UCTXSTP)监视事务状态； 我在 ISR 中放置了__BIC_SR_REGISTER_ON_EXIT (CPUOFF)；。 不过、有时 Tx 和 Rx 中断不会触发。

很抱歉、我在进行这种设置时遇到了困难。

1) 1)设置  UCTXSTT 后、应使用" _bis_SR_register (LPM0_bits | GIE)；"等待。 GitHub 代码就是这样做的。

2) 2)当 ISR 决定事务完成(Rx 或 Tx 字节计数器= 0或 NACK)时、它应使用"__BIC_SR_REGISTER_ON_EXIT (LPM0_Bits)"唤醒 main；这就是 GitHub 代码执行该操作的方式。

在 UCTXSTP 上旋转对于检测(完整)事务的完成不起作用、因为它仅在其中的一小部分开启。 在开始新事务之前、这种方法非常有用(额外的保险)、可确保 I2C 完全空闲。

这里的情况也是如此、这会使问题发生。 正在等待使用这些行_bis_SR_register (LPM0_bits | GIE)；我们还应该等待多长时间？ 我等了1分钟 仍然会得到相同的误差。 我将再次附加经修改的完整代码。 请帮我解决这个问题。

void i2cConfig(uint8_t stop_count)
{
    UCB2CTLW0 = UCSWRST;        // Reset I2C interface for config
    UCB2CTLW0 =                 /* USCI - B2 configuration register */
                    UCMST         | // Master mode
                    UCSYNC        | // Synchronous mode
                    UCMODE_3      | // I2C mode
                    UCSSEL__SMCLK | // Select SMCLK
                    UCSWRST       | // Don't release reset (yet)
                    0;
        UCB2CTLW1 =
                    UCCLTO_1      | // Clock low time-out select (28ms)
//                    UCASTP_2      | // Automatic STOP condition generation (enabled)
                    UCGLIT_0      | // Deglitch time (50ns)
                    0;
        UCB2TBCNT = stop_count;
        UCB2BRW = 260;               // Bit clock divider 1M/200 = 100kHz
        UCB2CTLW0 &= ~UCSWRST;      // Clear reset bit to start operation
        UCB2IE = UCNACKIE         | // Enable Nack interrupt
                 UCTXIE           | // Enable TX interrupt
                 UCRXIE           | // Enable RX interrupt
//                 UCCLTOIE         | // Enable clock low time-out interrupt
                 0;
}


void transmit(uint16_t *field, uint8_t count){
    i2cConfig(count);
    UCB2I2CSA = BMP280_ADDRESS;             // Set slave address
    txCount = count;
    txBuffer = field;
    UCB2IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
    while (UCB2CTLW0 & UCTXSTP);
    UCB2CTLW0 |= UCTR | UCTXSTT;            // Start request as transmitter
    __bis_SR_register(CPUOFF + GIE);
//    __enable_interrupt();

}
void receive(uint16_t *field, uint8_t count){
    i2cConfig(count);
    UCB2I2CSA = BMP280_ADDRESS;             // Set slave address
    rxCount = count;
//    rxBuffer = field;
    UCB2IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
    while (UCB2CTLW0 & UCTXSTP);
    UCB2CTLW0 &= ~UCTR;                     // Put I2C bus in receive mode
    UCB2CTLW0 |= UCTXSTT;                   // Start request as a receiver
    __bis_SR_register(CPUOFF + GIE);
//    __enable_interrupt();
}
void write(uint8_t reg, uint8_t data){
   while (UCB2CTLW0 & UCTXSTP);
   mBuffer[0] = reg;
   mBuffer[1] = data;
   transmit(mBuffer,2);
}
void read(uint16_t reg, uint8_t size){
    while (UCB2CTLW0 & UCTXSTP);
    transmit(&reg,1);
    while (UCB2CTLW0 & UCTXSTP);
    receive(mBuffer,size);
}

#pragma vector=USCI_B2_VECTOR
__interrupt void USCIB2_ISR(void)
{
    uint8_t rx_val = 0;
    switch(__even_in_range(UCB2IV, USCI_I2C_UCBIT9IFG))
  {
        case USCI_NONE:             // No interrupts break;
            break;
        case USCI_I2C_UCALIFG:      // Arbitration lost
            break;
        case USCI_I2C_UCNACKIFG:    // NAK received (master only)
            nack_received = 1;
            UCB2CTLW0 |= UCTXSTP;   // when an acknowledge is missing the slave gets a stop condition
            UCB2IFG   &= ~UCTXIFG;
            P1OUT^= BIT0;           //Red LED
            break;
        case USCI_I2C_UCRXIFG0:     // RXIFG0
            P1OUT^= BIT1;           //Green LED
            rx_val = UCB2RXBUF;
            if (rxCount)
            {
                rxBuffer[Index] = rx_val;      // Get RX data
                Index++;
                rxCount--;
            }
            else
            {
//                UCB2CTLW0 |= UCTXSTP;
                UCB2IE &= ~UCRXIE;
                __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
//                __disable_interrupt();
            }
            rece = 1;
            break;
        case USCI_I2C_UCTXIFG0:     // TXIFG0
            if (txCount)                        // Check TX byte counter
              {
                UCB2TXBUF = *txBuffer++;          // Load TX buffer
                txCount--;                        // Decrement TX byte counter
                trans = 1;
              }
            else
              {
                UCB2CTLW0 |= UCTXSTP;                    // I2C stop condition
                UCB2IFG &= ~UCTXIFG;                     // Clear USCI_B0 TX int flag
                __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
//                __disable_interrupt();
              }
            break;
        case USCI_I2C_UCCLTOIFG:    // Clock low timeout - clock held low too long
            clock_timeout = 1;
            UCB2IFG &= ~UCTXIFG;
            __bic_SR_register_on_exit(CPUOFF);
//            __disable_interrupt();
            break;
        default:
            break;
  }
}

power_cycle(); // Power Cycling
    write(0x2D,0x08); //power control
    if (trans == success)
    {
        UART_Transmit("Working\n\r",12);
        write(0x2C,0x10); // data rate
        write(0x31,0x03); // data format
        trans = 0;
    }
    else
    {
        power_cycle();
        UART_Transmit("Power_Cycle\n\r",16);
        write(0x2D,0x08); //power control
        write(0x2C,0x10); // data rate
        write(0x31,0x03); // data format
    }
    while (1)
    {
        read(0x32,2); // Data x
        if (nack_received == 1)
        {
            nack_received = 0;
            power_cycle();
            write(0x2D,0x08); // power control
            write(0x2C,0x10); // data rate
            write(0x31,0x03); // data format
            read(0x32,2); // Data x
            x1 = ((rxBuffer[1]) << 8) | rxBuffer[0];
            read(0x34,2); // Data y
            y1 = ((rxBuffer[3]) << 8) | rxBuffer[2];
            read(0x36,2); // Data z
            z1 = ((rxBuffer[5]) << 8) | rxBuffer[4];



        }
        else if(rece == 1 && nack_received==0)
        {
            rece = 0;
            x1 = ((rxBuffer[1]) << 8) | rxBuffer[0];
            read(0x34,2); // Data y
            y1 = ((rxBuffer[3]) << 8) | rxBuffer[2];
            read(0x36,2); // Data z
            z1 = ((rxBuffer[5]) << 8) | rxBuffer[4];
        }
        else
        {
            power_cycle();
            write(0x2D,0x08); // power control
            write(0x2C,0x10); // data rate
            write(0x31,0x03); // data format
            read(0x32,2); // Data x
            x1 = ((rxBuffer[1]) << 8) | rxBuffer[0];
            read(0x34,2); // Data y
            y1 = ((rxBuffer[3]) << 8) | rxBuffer[2];
            read(0x36,2); // Data z
            z1 = ((rxBuffer[5]) << 8) | rxBuffer[4];
        }

> UCB2IE &=~UCRXIE；

这是 RXIFG 情况。 RXIE 将保持关闭状态、因为没有其他任何东西会再次打开它。 合理的做法是：

> UCB2IFG &=~UCRXIFG；

您好、Bruce、

我更改了这个值、但现在在发送了 ox32之后从从从器件 IE X 值接收到第一个数据。 接下来、它不会进入中断例程。 这里会出现什么问题？

谢谢你

您好、Bruce、

TX 和 RX IE 都在开头设置。  例如 UCRXIE 和 UCTXIE = 1。

发送：

• 在 TX 中断被使能后、TXIFG 被置位。
• 然后、在将数据放入(UCB2TXBUF) TX 缓冲区之前、TXIFG 被清零。
• 在将数据放入 UCB2TXBUF 缓冲区后、TXIFG 被置位、即 TXIFG = 1。

接收：

• 在启用 RX 中断后、RXIFG 被置位。
• 然后、RXIFG 在从(UCB2RXBUF) RX 缓冲器中获取数据之前被清零。
• 在从 UCB2RXBUF 缓冲器中获取数据后、RXIFG 被置位、即 RXIFG = 1。

RXIE 和 TXIE 都保持不变。

根据 IE 和 IFG 寄存器的实际内容(以及 SR 中的 GIE)，我试图回到第一原则。 了解"是"与了解"应该是"有何不同。

如果、例如 RXIFG=1、RXIE=1、和 GIE=1、我们预计 ISR 将被调用。 (与 Tx 类似。)  

如果这些条件为 true (并且未调用 ISR)、则指向一个方向。 如果其中一个位= 0、则该位指向不同的方向。

在1K 时、信号设置时间似乎有点长。 当 SCL 和 SDA 的速度高达400k 时、您能帮助捕获波形吗？