MicroSD-Raw-Schreib-/Lesemodus. Nachdem der Sektor einmal geschrieben wurde, können keine weiteren Sektoren geschrieben und immer 0 gelesen werden

Ich mache zum ersten Mal die Schnittstelle zwischen einem Mikrocontroller (PIC32MX) und einer microSD-Karte über SPI. Die von mir verwendeten Karten werden korrekt initialisiert. Die Sektor-/Blockgröße ist auf 512 Bytes/Sektor festgelegt, da ich nur SDHC- und SDXC-Karten verwenden werde. Ich mache rohes Schreiben/Lesen auf der Karte, weil ich für meine Anwendung kein Dateisystem benötige, es ist ein einfacher Datenlogger. Ich kann den Inhalt der Kartensektoren mit der Software "Hex Workshop Hex Editor" überprüfen. Der SPI-Takt liegt derzeit als Ausgangspunkt bei 200 kHz.

Ich habe eine Funktion, die einen ganzen Sektor schreibt, und eine Funktion, die einen ganzen Sektor liest. Mir ist aufgefallen, dass, wenn ich die Sector_write-Funktion mit CMD24 (WRITE_BLOCK) mindestens einmal verwende (und es funktioniert beim ersten Aufruf, den Sektor korrekt schreiben), die nachfolgenden Sector_write-Aufrufe nicht funktionieren, ich sehe immer 0, die bei Sekunde gespeichert werden Sektor, in den ich schreiben möchte. In diesem Beispiel versuche ich, Sektor 1000 und 1300 mit demselben Inhalt zu füllen, aber nur Sektor 1000 wird mit diesem Inhalt gefüllt, und Sektor 1300 wird mit Nullen gefüllt (eigentlich sein ursprünglicher Inhalt). Außerdem habe ich versucht, die Sektoren 1000 und 1001 in einer Sequenz zu schreiben, und das Ergebnis ist dasselbe (Sektor 1001 füllt sich nicht mit demselben Inhalt wie Sektor 1000).

Das heißt, wenn ich die Funktion sector_write einmal aufrufe , gibt die Lesefunktion Lesevorgänge aus einem Sektor voller 0 (falsch) zurück. Wenn ich alle Aufrufe von write_sector kommentiere, erfolgen die Lesevorgänge korrekt.

Für den folgenden Code wird nur Sektor 1000 geschrieben ... der gesamte Sektor 1300 bleibt auf 0s. Dieser Code wird unmittelbar nach der erfolgreichen Initialisierung der Karte mit den richtigen Kartenantworten angezeigt.

Zur Initialisierung verwende ich: |CMD0|CMD8|CMD58|repeated CMD55+ACMD41|CMD58|. CMD16 verwende ich nicht...

Was kann ich tun, um das zu lösen? Hatte hier schon jemand dieses Problem? Grüße.

if (SD_initialized == true) 
{
    write_reply = SD_write_sector(1000);
    DelayMs(1000);
    write_reply = SD_write_sector(1300);
}

uint8_t SD_command[6];
uint8_t SD_write_buff[512];
uint8_t SD_read_buff[512];

uint8_t n = 0;

for (i=0; i<512; i++) 
{
    SD_write_buff[i] = n;
    n++;
}

if (SD_initialized == true) 
{
    write_reply = SD_write_sector(1000);
    DelayMs(1000);
    write_reply = SD_write_sector(1300);
}

uint8_t SPI_write (uint8_t byte) 
{
    while(SPI1STATbits.SPITBF);
    SPI1BUF = byte;
    while(!SPI1STATbits.SPIRBF);
    return SPI1BUF;
}

uint8_t SD_write_sector (uint32_t sector)   //sector = block number
{
    uint8_t reply;
    uint32_t i;

    do
    {
        reply = SD_send_cmd (24, sector); 
    }
    while (reply != 0); 

    SPI_write(0xFF);                      //Dummy byte
    SPI_write(0xFE);                      //Data start token (0xFE)

    for(i=0; i<512; i++)                  //Data block
    {
        SPI_write(SD_write_buff[i]);
    }

    SPI_write(0xFF);                      //2 bytes of CRC
    SPI_write(0xFF);                   

    reply = SPI_write(0xFF);
    reply &= 0x1F;     // Response of SD: xxx0sss1
                       // sss = 010 ---> Data accepted = 0x05
                       // sss = 101 ---> Data rejected due to CRC error = 0x0B
                       // sss = 110 ---> Data rejected due to writing error = 0x0D

    return reply;
}

uint8_t SD_send_cmd (uint8_t CMD, uint32_t ARG)
{
    SD_command[0] = CMD + 0x40;                 
    SD_command[1] = ARG >> 24;                 
    SD_command[2] = ARG >> 16;                  
    SD_command[3] = ARG >> 8;                   
    SD_command[4] = ARG & 0xFF;                
    SD_command[5] = getCRC7 (SD_command, 5);    

    SPI_write (SD_command[0]);
    SPI_write (SD_command[1]);
    SPI_write (SD_command[2]);
    SPI_write (SD_command[3]);
    SPI_write (SD_command[4]);
    SPI_write (SD_command[5]);

    SD_reply1 = SPI_write(0xFF);                //dummy read
    SD_reply1 = SPI_write(0xFF);                //actual read

    if (CMD == 8 || CMD == 58) 
    {
        SD_reply2 = SPI_write(0xFF);
        SD_reply3 = SPI_write(0xFF);
        SD_reply4 = SPI_write(0xFF);
        SD_reply5 = SPI_write(0xFF);
    }

    return SD_reply1;
}

uint8_t SD_read_sector (uint32_t sector)
{
    uint8_t reply;
    uint32_t i;

    reply = SD_send_cmd (17, sector);
    if (reply != 0) { return reply; }

    while (SPI_write(0xFF) != 0xFE);  //SPI return read byte

    for (i=0;i<512;i++) 
    { 
        SD_read_buff[i] = SPI_write(0xFF);
    }

    SPI_write(0xFF);        //read 16-bit CRC
    SPI_write(0xFF);

    return reply;
}