MPU9250 SD

 while(1) {
  
  // If intPin goes high, all data registers have new data//
  if(mpu9250.readByte(MPU9250_ADDRESS, INT_STATUS) & 0x01) {  // On interrupt, check if data ready interrupt

    mpu9250.readAccelData(accelCount);  // Read the x/y/z adc values   
    // Now we'll calculate the accleration value into actual g's
    ax = (float)accelCount[0]*aRes - accelBias[0];  // get actual g value, this depends on scale being set
    ay = (float)accelCount[1]*aRes - accelBias[1];   
    az = (float)accelCount[2]*aRes - accelBias[2];  
   
    mpu9250.readGyroData(gyroCount);  // Read the x/y/z adc values
    // Calculate the gyro value into actual degrees per second
    gx = (float)gyroCount[0]*gRes - gyroBias[0];  // get actual gyro value, this depends on scale being set
    gy = (float)gyroCount[1]*gRes - gyroBias[1];  
    gz = (float)gyroCount[2]*gRes - gyroBias[2];   
  
    mpu9250.readMagData(magCount);  // Read the x/y/z adc values   
    // Calculate the magnetometer values in milliGauss
    // Include factory calibration per data sheet and user environmental corrections
    mx = (float)magCount[0]*mRes*magCalibration[0] - magbias[0];  // get actual magnetometer value, this depends on scale being set
    my = (float)magCount[1]*mRes*magCalibration[1] - magbias[1];  
    mz = (float)magCount[2]*mRes*magCalibration[2] - magbias[2];   
  }
   
    Now = t.read_us();
    lastUpdate = Now;
    
    sumCount++;
    
    fprintf(fp, "%d %d %f %f %f %f %f %f %f %f %f \r\n",Now, sumCount, ax, ay, az, gx, gy, gz, mx, my, mz);
    
    if (sumCount > 100){
         pc.printf("Done");
        break;
        }
}

// the size of the buffers to use, you may need to make this larger if you have the RAM.
const int bufferSize = 100;

// it makes life a lot easier to define a structure to hold the data from each sample
typedef struct adcData_s {
    float ax,ay,az;
    float gx,gy,gz;
    float mx,my,mz;
    uint32_t time;
} adcData_t;

// two buffers to store the data in, we rotate between them.
adcData_t buffer1[bufferSize];
adcData_t buffer2[bufferSize];

// set which buffer is being used.
adcData_t *activeBuffer = buffer1;

volatile int dataInBuffer = 0;

// call this when you know that there is date ready either from a ticker that checks the status register or a data ready interrupt input.
void onDataReady(void)
{

// basically your code but writing to the next empty entry in the active buffer.
    adcData_t *dataPointer = activeBuffer + dataInBuffer;

    mpu9250.readAccelData(accelCount);  // Read the x/y/z adc values
    // Now we'll calculate the accleration value into actual g's
    dataPointer->ax = (float)accelCount[0]*aRes - accelBias[0];  // get actual g value, this depends on scale being set
    dataPointer->ay = (float)accelCount[1]*aRes - accelBias[1];
    dataPointer->az = (float)accelCount[2]*aRes - accelBias[2];

    mpu9250.readGyroData(gyroCount);  // Read the x/y/z adc values
    // Calculate the gyro value into actual degrees per second
    dataPointer->gx = (float)gyroCount[0]*gRes - gyroBias[0];  // get actual gyro value, this depends on scale being set
    dataPointer->gy = (float)gyroCount[1]*gRes - gyroBias[1];
    dataPointer->gz = (float)gyroCount[2]*gRes - gyroBias[2];

    mpu9250.readMagData(magCount);  // Read the x/y/z adc values
    // Calculate the magnetometer values in milliGauss
    // Include factory calibration per data sheet and user environmental corrections
    dataPointer->mx = (float)magCount[0]*mRes*magCalibration[0] - magbias[0];  // get actual magnetometer value, this depends on scale being set
    dataPointer->my = (float)magCount[1]*mRes*magCalibration[1] - magbias[1];
    dataPointer->mz = (float)magCount[2]*mRes*magCalibration[2] - magbias[2];

    dataPointer->time = t.read_us();
    dataInBuffer++;
    if (dataInBuffer == bufferSize) {
        // ERROR - buffer overflow. You may want to turn an LED on or output an error message.
        // Increase the buffer size until this never happens and then add some extra just to be safe
    }
}

// writes a set of data to the sd card.
// assumes that the file pointer is global, if not pass it as a parameter.
void saveData(adcData_t *dataBuffer, int recordsToWrite, int recordNumber)
{
    adcData_t *dataPointer;
    // write each entry in turn...
    for (int count = 0; count<recordsToWrite; count++) {
        dataPointer = dataBuffer + count;
        fprintf(fp,  "%d %d %f %f %f %f %f %f %f %f %f \r\n",
                dataPointer->time, recordNumber+count,
                dataPointer->ax,dataPointer->ay,dataPointer->az,
                dataPointer->gx,dataPointer->gy,dataPointer->gz,
                dataPointer->mx,dataPointer->my,dataPointer->mz);
    }
}

void main (void)
{
    ...
// setup code
    ...
    int sumCount = 0;
    while (1) {
        if (dataInBuffer > 0) { // some data is ready to write
            __disable_irq();     // disable interrupts while we swap buffers
            int recordsToWrite = dataInBuffer; // note how many entries there are.
            adcData_t *saveBuffer = activeBuffer;             // get a pointer to the buffer we need to write
            if (activeBuffer == buffer1)             // set the active buffer to the other buffer.
                activeBuffer = buffer2;
            else
                activeBuffer = buffer1;
            dataInBuffer = 0;               // mark the active buffer as empty
            __enable_irq();                 // re-enable interrupts
            saveData(saveBuffer,recordsToWrite, sumCount);  //save the data to the card.
            sumCount += recordsToWrite;
            if (sumCount > 100) {
                pc.printf("Done");
                break;
            }
        }
    }
}

simpler onDataReady

void onDataReady(void)
{
// basically your code but writing to the next empty entry in the active buffer.
    adcData_t *dataPointer = activeBuffer + dataInBuffer;
 

    // Now we'll calculate the accleration value into actual g's
    dataPointer->ax = 1;  // get actual g value, this depends on scale being set
    dataPointer->ay = 1;

         ...
 
    dataPointer->time = t.read_us();
    dataInBuffer = dataInBuffer + 1;
    if (dataInBuffer == bufferSize) {
            printf("Error  ");

        // ERROR - buffer overflow. You may want to turn an LED on or output an error message.
        // Increase the buffer size until this never happens and then add some extra just to be safe
    }
}