8 years, 2 months ago.

Saving it as an array is fairly easy, you do however have to add a check to make sure you haven't run out of space in your array:

const int maxReadings = 100;

float measurmentArray[maxReadings][3];

volatile int readingNumber = 0; // volatile because it's changed in an interrupt

void update() {
 if (readingNumber < maxReadings) {
   measurmentArray[readingNumber][0]=x_in;
   measurmentArray[readingNumber][1]=y_in;
   measurmentArray[readingNumber][2]=z_in;
   readingNumber++;
  }
.....

In your current code you have two potential problems with your file output. Firstly you open it with an access type of "w", that should overwrite any existing files so you'll only have a single point in the file. You should open it with an access type of "a" to append to the existing file. Secondly you never check that the file did open. You should verify that fp is not NULL before tying to use it.

You get 5 values in your file because within your timer you take 6 readings from the sensor, one set for setting the LCD and printing to the serial port 5 times and 5 other sets of data taken as quickly as possible for writing to the file. So the 5 values in your file aren't taken at the sample rate you set, they are taken at some unknown rate determined by the ADC sample time and the file write speed.

As a more general style point you are currently doing everything inside an interrupt, that is not normally a good idea, What you should do is read the values in the interrupt but do everything else in the main loop. e.g.

void update() {
[as above]
}

main () {
  int nextReading = 0;
  in.attach(&update,0.5);
  while (nextReading<maxReadings ) { // run until the array is full
    If (readingNumber > nextReading) { // there is new data
       nextReading = readingNumber-1; // the index of the last value written to the array
       float x,y,z;  // copy values to a local variables to save me doing a search and replace on the code below...
       x=measurmentArray[nextReading][0];
       y=measurmentArray[nextReading][1];
       z=measurmentArray[nextReading][2];
       lcd.cls();
       lcd.locate(0,0);
       lcd.printf("X %5.2f",x);
       lcd.printf(" Y %5.2f",y);
       lcd.printf(" Z %5.2f",y);
       if(x<0.38) { 
         lcd.printf("Stand");
       } else if(x>0.38&&z<0.35) { 
         lcd.printf("Fall");
       }
 
       if(x>0.40&&0.40>z<0.62) { 
         lcd.printf("Sleep");
       }
       if(y<0.47) {
         lcd.printf("BK L");
       } else if(y>0.53) { 
         lcd.printf("BK R");
       }

      pc.printf("X-%5.2f Y-%5.2f Z-%5.2f \n",x, y, z);
      nextReading++;
    } // end while new data to display
  }  // end while the array isn't full.
  
  // now write the whole array to a file in one go
 FILE *fp = fopen("/local/Record.txt", "w");
 if (fp) {
   for (int i=0;i<maxReadings;i++) {
       fprintf(fp, "X- %f Y-%f Z-%f \r\n",measurmentArray[i][0],measurmentArray[i][1],measurmentArray[i][2]);
    }
    fclose(fp);
  } else {
    pc.printf("ERROR. Failed to open output file\r\n");
  }
}

The downside in this array based system is that you can only read as much data as the array can hold but with your current system if you turned the sample rate up the whole thing would fall apart, you wouldn't know how fast it was running. This way the system will always keep up and run at the requested rate, if the screen update code can't keep up with the sample rate then it will skip samples and only ever display the most recent data.

Once the array is full the entire array is written to a text file in one go.

There are ways to make this sort of system run continuously. You use the array as a buffer, the ticker writes data into the array looping back to the start when it gets to the end. The main loop follows as closely behind as it can. This is useful because the time taken to write to a file varies, normally it's quite fast but sometimes it can take a long time. By using an array as a circular buffer if the the file writing takes a long time every now and then the sample rate isn't messed up, the buffer is in effect averaging out the file write times.