C语言 如何通过Microchip PIC24F微控制器的SPI增强缓冲模式正确接收数据

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;
    }
}

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

通信的工作方式如下：

• 1字节：R/W位+长度
• 1字节：地址
• 1-127字节：数据

因此，当我从从芯片读取 1 个字节时，这意味着发送 3 个字节（rw+len、地址、虚拟字节），我在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。先进先出中真的有什么东西吗？ SPI1STATbits.SRXMPT必须是 1，甚至不尝试清空。如果不是，则软件中的某个地方存在错误。您还有其他使用 SPI 的代码吗？