Implementierung eines I2C-Puffers in C

Ich habe keine Erfahrung mit PIC, aber das Problem scheint allgemein genug zu sein. Ich würde ein einfaches Array mit zwei unabhängigen Zeigern in das Array erstellen: einen Lesezeiger und einen Schreibzeiger. Immer wenn Sie ein Byte empfangen, erhöhen Sie den Schreibzeiger und schreiben an der neuen Position; In Ihrer Hauptschleife könnten Sie dann überprüfen, ob der Lesezeiger und der Schreibzeiger gleich sind. Wenn nicht, lesen und verarbeiten Sie einfach aus dem Puffer und erhöhen den Lesezeiger für jedes Byte, bis dies der Fall ist.

Sie können dann entweder die Zeiger auf den Anfang des Arrays zurücksetzen oder sie zum Anfang "überfließen" lassen, wodurch im Wesentlichen ein Ringpuffer entsteht. Dies ist am einfachsten, wenn die Größe des Arrays ein Faktor von 2 ist, da Sie dann einfach beide Zeiger nach ihren Inkrementen bitmaskieren können.

Ein Beispiel (Pseudo-)Code:

volatile unsigned int readPointer= 0;
volatile unsigned int writePointer=0;
volatile char theBuffer[32];
...
//in your ISR
writePointer = (writePointer+1) & 0x1F;
theBuffer[writePointer] = ReadI2C(); // assuming this is the easiest way to do it
                                     // I would probably just read the register directly
...
//in main
while (readPointer != writePointer) {
  readPointer = (readPointer+1) & 0x1F;
  nextByte = theBuffer[readPointer];
  // do whatever necessary with nextByte
}

Wenn Sie dies richtig machen möchten, ist die beste Lösung, eine Art Ringpuffer zu implementieren .
Beachten Sie jedoch, dass die Implementierung "unterbrechungssicher" sein muss. Dies ist erforderlich, da während der Pufferinhalte in der Hauptschleife verarbeitet werden, jederzeit weitere Daten in Ihrem SPI ISR eintreffen können!
Daher müssen Sie sich möglicherweise mit den Operationen using und "ATOMIC" befassen, volatilewenn Sie damit nicht vertraut sind.

Aus dem Pseudocode der Antwort von fm_andreas habe ich einen funktionierenden C18-Code erstellt:

#define bufferSize 0x20
static volatile unsigned char buffer[bufferSize] = {0}; // This is the actual buffer
static volatile unsigned char readPointer = 0;          // The pointer to read data
static volatile unsigned char writePointer = 0;         // The pointer to write data
static volatile unsigned bufferOverflow = 0;            // Indicates a buffer overflow

// In the ISR...
if (buffer[writePointer] == 0x00) {                     // If there is no data at the pointer
    buffer[writePointer] = SSPBUF;                      // Put the data in the buffer
    writePointer = (writePointer+1)%bufferSize;         // Increase the pointer, reset if >32
} else {                                                // If there is data...
    bufferOverflow = 1;                                 // Set the overflow flag
}

// In the main loop...
while (1) {
    // Do some other stuff
    if (readPointer != writePointer) {                  // If there is a new byte
        putc(buffer[readPointer], stdout);              // Do something with the data
        buffer[readPointer] = 0x00;                     // Reset the data
        readPointer = (readPointer+1)%bufferSize;       // Increase the pointer, reset if >32
    }
}

Das Schöne an diesem Code ist, dass es sich um einen Ringpuffer handelt :

Es ist daher weniger wahrscheinlich, dass es überläuft, wenn große Datenmengen auf einmal gesendet werden. Dies wird in den Kommentaren zu Nick Alexeevs Antwort diskutiert .

@fm-andreas ist mir da zuvorgekommen. Ich wollte dasselbe vorschlagen: Burst-Puffer mit Lese- und Schreibpositionen. (Dies ist kein Ringpuffer. Es ist einfacher. Es läuft nicht herum.) Ein Burst-Puffer kann einen Burst von Daten speichern. Das System sollte so ausgelegt sein, dass zwischen den Bursts genügend Zeit bleibt, um die Daten zu verarbeiten.

Hier ist meine Version (Pseudocode):

const unsigned char g_BUFF_LEN = 16;
unsigned char   g_dataBuff[BUFF_LEN];       // buffer
unsigned char   g_g_iWriteOffset, g_g_iReadOffset;      // write and read offsets
unsigned char   g_iFlags;


void main()
{
    resetBuffer();      // initialize the burst buffer

    // process the contents buffer
    while (1)
    {
        // other code that lives in the main loop

        while (g_iWriteOffset > g_iReadOffset)      // inner loop for processing the received data
        {
            doSomething(g_dataBuff[g_iReadOffset]);     

            // disable the receiveISR.  If the ISR occurs in this block, it can corrupr the buffer.
            ++g_iReadOffset;        // advance the read offset
            if (g_iReadOffset == g_iWriteOffset)    // is there remaining unprocessed data in the buffer?
            {
                resetBuffer();
            }
            // re-enable the receive ISR
        }
    }
}


void resetBuffer()
{
    g_iWriteOffset = 0;
    g_iReadOffset = 0;
}


void receiveISR()
{
    /*  Receive the byte.
        Specific code for keeping the hardware happy goes here.
        Keelan, you've already posted it in the O.P.  I'll save some time and not repeat it.  */

    g_dataBuff[g_iWriteOffset] = newByte;

    ++g_iWriteOffset;       // advance the write offset
    if (g_iWriteOffset >= g_BUFF_LEN)   // have we got a buffer overflow?
    {
        g_iFlags |= COMM_BUFF_OVERFLOW;
        /*  Handling of errors (such as this overflow) is an interesting topic.
            However, is depends on the nature of the instrument.
            It's somewhat outside the sope of the question. */
    }
}

PS
Sehen Sie sich in einem ähnlichen Zusammenhang die Ping-Pong-Puffer an. Dies ist praktisch, wenn Sie Multi-Byte-Pakete (oder Befehle) haben und das gesamte Paket empfangen müssen, bevor Sie mit der Verarbeitung beginnen können.

2x identische Puffer (oder mehr als 2x). ISR füllt einen Puffer, bis es das Ende des Befehls erkennt. Währenddessen verarbeitet die main()-Schleife den anderen Puffer. Wenn die ISR den nächsten vollständigen Befehl erhalten hat und main() mit der Verarbeitung des vorherigen Befehls fertig ist, werden die Pufferzeiger vertauscht.