Question

我正在使用外部RF芯片编程SPI通信。微控制器是Microchip的PIC24FJ64GA102型号。

我想使用SPI的增强缓冲模式。

问题：从接收缓冲区中获取接收到的字节。

使用SPI功能：

void SPI1_get(uint8_t* data, uint16_t length) {
    uint16_t i = 0, l = length;
    uint8_t dummy;
    while (length > 0) {
        while (SPI1STATbits.SPITBF || SPI1STATbits.SPIRBF) {
            dummy = SPI1STAT;
        }
        do {
            SPI1BUF = 0xff;
        } while (SPI1STATbits.SPIRBF == 0 && --length > 0);
        do {
            while (SPI1STATbits.SRMPT == 0) {
            }
            data[i] = SPI1BUF;
            ++i;
        } while (i < l && SPI1STATbits.SRXMPT != 1);
    }
}

这里是电话：

uint8_t cmd[2]; cmd[0] = length; cmd[1] = address;
SPI1_put(cmd,2); // e.g: 0x02, 0x01
SPI1_get(buf,2); // e.g: 0x05, 0x01 (received data)

通信很好，用示波器和SPI解码模块检查。 SPI总线上的数据与上面的注释类似：发送0x02 0x01 0xff 0xff，收到0x00 0x00 0x05 0x01，但上述函数无法正确地从接收缓冲区中检索数据。我已经测试了很多检查标志和中断的星座，但最终我得到的最好结果是：0x00 0x01（只有最后一个字节是正确的）。

还检查了勘误表，其中提到了两个不会（不应该）影响我的代码的SPI问题。

我到底做错了什么？！

这里要求SPI1_put（）函数：

void SPI1_put(uint8_t* data, uint16_t length) {
    uint16_t i = 0;
    uint8_t dummy;
    for (; i < length; ++i) {
        while (SPI1STATbits.SPITBF)
            ; // maybe change to (_SPI1BEC == 7) ?
        SPI1BUF = data[i];
        dummy = SPI1BUF; //dummy read
    }
}

[最新修改：2015-02-05]

所以今天我能够在这个特定的问题上花更多的时间，并想出了一个ElderBug的建议端口，同时也处理了勘误表中提到的错误：

uint8_t out_buf[128];
uint8_t in_buf[128];

void SPI1_com(uint8_t* out, uint8_t* in, uint16_t out_len, uint16_t in_len) {
    uint16_t len = out_len + in_len;
    uint16_t sent = 0, recv = 0, i = 0;
//  while (!SPI1STATbits.SRXMPT)
    sent = SPI1BUF; // empty buffer
    sent = SPI1BUF; // empty buffer
    sent = 0;
    if (out != out_buf && out != 0)
        memcpy(out_buf, out, out_len);
    while (sent < len && recv < len) {
        if (SPI1STATbits.SPIBEC != 7 && sent < len) {
            SPI1BUF = out_buf[sent++];
        }
        if (!SPI1STATbits.SRXMPT && recv < len) {
            in_buf[recv] = SPI1BUF, recv++;
        }
    }
    if (in != 0) {
        for (i = 0; i < in_len; ++i) {
            in[i] = in_buf[out_len + i];
        }
//      memcpy(in, in_buf + out_len, in_len);
    }
    for (i = 0; i < len; ++i) {
        out_buf[i] = 0xff;
        in_buf[i] = 0xff;
    }
}

此代码基本上有效。除了我无法解决的例外：

通讯的工作原理如下：

1byte：r / w-bit + length
1byte：地址
1-127byte：data

因此，当我从从芯片读取1个字节时，意味着发送3个字节（rw + len，address，dummybyte），我在in_buf缓冲区中的数据是0xFF。现在有点奇怪：当我再读一个字节时，没有改变任何东西（总线上只有一个虚拟字节），我的in_buf的第一个字节得到了正确的数据。但这似乎总是不起作用，因为我的程序仍然停留在某些方面。

我离开这里时带着很多问号。

奇怪的是第二个：读取8个字节，数据在我的缓冲区中正确，直到最后一个字节，最后一个字节是0xFF，应该是0x00。跆拳道？

PS：已经在Microchip提交了一张票，以获得本期的支持。

Answer 1

您的SPI1_put存在问题。

在SPI1_put功能中，您在开始传输后立即阅读SPI1BUF，因此您在传输未完成时阅读（如果我错了，请更正我，但在FIFO为空，不阻塞，只返回前一个字节）。该功能应该是这样的：

void SPI1_put(uint8_t* data, uint16_t length) {
    uint16_t sent = 0;
    uint16_t rec = 0;
    uint8_t dummy;
    while(1)
    {
        if( !SPI1STATbits.SPITBF && sent < length )
            SPI1BUF = data[sent++];
        if( !SPI1STATbits.SRXMPT && rec < length )
            dummy = SPI1BUF, rec++;
        if( sent == length && rec == length )
            break;
    }
}

关于SPI1_get，我觉得很好，但我不确定。问题是，它看起来应该与SPI1_put非常相似，因为SPI在工作方式上确实是对称的：

void SPI1_get(uint8_t* data, uint16_t length) {
    uint16_t sent = 0;
    uint16_t rec = 0;
    while(1)
    {
        if( !SPI1STATbits.SPITBF && sent < length )
            SPI1BUF = 0xff, sent++;
        if( !SPI1STATbits.SRXMPT && rec < length )
            data[rec++] = SPI1BUF;
        if( sent == length && rec == length )
            break;
    }
}

总的来说，由于您只进行同步调用，因此增强缓冲区并不实用。只需执行“发送，等待，接收”即可获得更简单的功能和相同的结果。对于每个字节。

更新后

编辑：

您的新代码看起来是正确的，但while中您错误的情况除外。以下是更正后的代码，其中包含一些可能改进的修改（删除了缓冲区副本）：

// No additional buffers

void SPI1_com(uint8_t* out, uint8_t* in, uint16_t out_len, uint16_t in_len) {
    uint16_t len = out_len + in_len;
    uint16_t sent = 0, recv = 0, i;
    uint16_t dummy;


    // After the call, SPI comms should have ended and RX FIFO should be empty.
    // If SPI1STATbits.SRXMPT is not 1 here,
    // it means there is a problem in the code. Report it somehow for debug ?
    // if( !SPI1STATbits.SRXMPT )
    //     error!

    // This loop is harmless but shouldnt be needed
    //while (!SPI1STATbits.SRXMPT)
        //dummy = SPI1BUF; // empty buffer

    i = 0;
    while (sent < len || recv < len) {
        if (SPI1STATbits.SPIBEC != 7 && sent < len) {
            // Here we are out of the buffer when sent>=out_len,
            // but it's ok because random bytes are fine here
            SPI1BUF = out[sent++];
        }
        if (!SPI1STATbits.SRXMPT && recv < len) {
            if( recv < out_len )
                // Before out_len, discard the data
                dummy = SPI1BUF;
            else
                // After out_len, store the data in in[]
                in[i++] = SPI1BUF;
            recv++;
        }
    }

}

这是否可以纠正任何错误？此外，这可能听起来很愚蠢，但你正确地说这个吗？我不知道你做了什么，但对于你的1字节读取，它应该是SPI1_com(two_byte_buffer,one_byte_buffer,2,1);。

还有一点：看起来你总是试图在开始时清空RX FIFO。 FIFO中确实存在某些东西吗？ SPI1STATbits.SRXMPT必须是1，甚至没有尝试清空。如果不是，那么软件中就会出现一个错误。你有使用SPI的其他代码吗？

如何通过Microchip PIC24F单片机的SPI增强缓冲模式正确接收数据？

1 个答案: