compass-calibration.c

   1 /*
   2  * Copyright (C) 2014 Intel Corporation.
   3  */
   4
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <math.h>
   8 #include <hardware/sensors.h>
   9 #include <sys/stat.h>
  10 #include <string.h>
  11 #include <utils/Log.h>
  12 #include "calibration.h"
  13 #include "matrix-ops.h"
  14 #include "description.h"
  15
  16 #ifdef DBG_RAW_DATA
  17 #define MAX_RAW_DATA_COUNT 2000
  18 #define RAW_DATA_FULL_PATH "/data/raw_compass_data_full_%d.txt"
  19 #define RAW_DATA_SELECTED_PATH "/data/raw_compass_data_selected_%d.txt"
  20 static FILE *raw_data = NULL;
  21 static FILE *raw_data_selected = NULL;
  22 static int raw_data_count = 0;
  23 int file_no = 0;
  24 #endif
  25
  26 /* compass defines */
  27 #define COMPASS_CALIBRATION_PATH "/data/compass.conf"
  28 #define EPSILON 0.000000001
  29
  30 #define MAGNETIC_LOW 960 /* 31 micro tesla squared */
  31 #define CAL_STEPS 5
  32
  33 /* We'll have multiple calibration levels
  34 *  so that we can provide an estimation as fast as possible
  35 */
  36 static const float min_diffs[CAL_STEPS] =  {0.2,  0.25, 0.4, 0.6, 1.0 };
  37 static const float max_sqr_errs[CAL_STEPS] = {10.0, 10.0, 8.0, 5.0, 3.5 };
  38 static const unsigned int lookback_counts[CAL_STEPS] = {2, 3, 4, 5, 6 };
  39
  40
  41 /* Reset calibration algorithm */
  42 static void reset_sample (compass_cal_t* data)
  43 {
  44     int i,j;
  45     data->sample_count = 0;
  46     for (i = 0; i < MAGN_DS_SIZE; i++)
  47         for (j=0; j < 3; j++)
  48             data->sample[i][j] = 0;
  49
  50     data->average[0] = data->average[1] = data->average[2] = 0;
  51 }
  52
  53
  54 static double calc_square_err (compass_cal_t* data)
  55 {
  56     double err = 0;
  57     double raw[3][1], result[3][1], mat_diff[3][1];
  58     int i;
  59     float stdev[3] = {0,0,0};
  60
  61     for (i = 0; i < MAGN_DS_SIZE; i++) {
  62         raw[0][0] = data->sample[i][0];
  63         raw[1][0] = data->sample[i][1];
  64         raw[2][0] = data->sample[i][2];
  65
  66         stdev[0] += (raw[0][0] - data->average[0]) * (raw[0][0] - data->average[0]);
  67         stdev[1] += (raw[1][0] - data->average[1]) * (raw[1][0] - data->average[1]);
  68         stdev[2] += (raw[2][0] - data->average[2]) * (raw[2][0] - data->average[2]);
  69
  70         substract (3, 1, raw, data->offset, mat_diff);
  71         multiply(3, 3, 1, data->w_invert, mat_diff, result);
  72
  73         double diff = sqrt(result[0][0] * result[0][0] + result[1][0] * result[1][0]
  74              + result[2][0] * result[2][0]) - data->bfield;
  75
  76         err += diff * diff;
  77     }
  78
  79     stdev[0] = sqrt(stdev[0] / MAGN_DS_SIZE);
  80     stdev[1] = sqrt(stdev[1] / MAGN_DS_SIZE);
  81     stdev[2] = sqrt(stdev[2] / MAGN_DS_SIZE);
  82
  83     /*
  84      * A sanity check - if we have too little variation for an axis
  85      * it's best to reject the calibration than risking a wrong calibration.
  86      */
  87     if (stdev[0] <= 1 || stdev[1] <= 1 || stdev[2] <= 1)
  88         return max_sqr_errs[0];
  89
  90     err /= MAGN_DS_SIZE;
  91     return err;
  92 }
  93
  94
  95 /* Given an real symmetric 3x3 matrix A, compute the eigenvalues */
  96 static void compute_eigenvalues (double mat[3][3], double* eig1, double* eig2, double* eig3)
  97 {
  98     double p = mat[0][1] * mat[0][1] + mat[0][2] * mat[0][2] + mat[1][2] * mat[1][2];
  99
 100     if (p < EPSILON) {
 101         *eig1 = mat[0][0];
 102         *eig2 = mat[1][1];
 103         *eig3 = mat[2][2];
 104         return;
 105     }
 106
 107     double q = (mat[0][0] + mat[1][1] + mat[2][2]) / 3;
 108     double temp1 = mat[0][0] - q;
 109     double temp2 = mat[1][1] - q;
 110     double temp3 = mat[2][2] - q;
 111
 112     p = temp1 * temp1 + temp2 * temp2 + temp3 * temp3 + 2 * p;
 113     p = sqrt(p / 6);
 114
 115     double mat2[3][3];
 116     assign(3, 3, mat, mat2);
 117     mat2[0][0] -= q;
 118     mat2[1][1] -= q;
 119     mat2[2][2] -= q;
 120     multiply_scalar_inplace(3, 3, mat2, 1/p);
 121
 122     double r = (mat2[0][0] * mat2[1][1] * mat2[2][2] + mat2[0][1] * mat2[1][2] * mat2[2][0]
 123         + mat2[0][2] * mat2[1][0] * mat2[2][1] - mat2[0][2] * mat2[1][1] * mat2[2][0]
 124         - mat2[0][0] * mat2[1][2] * mat2[2][1] - mat2[0][1] * mat2[1][0] * mat2[2][2]) / 2;
 125
 126     double phi;
 127     if (r <= -1.0)
 128         phi = M_PI/3;
 129     else if (r >= 1.0)
 130         phi = 0;
 131     else
 132         phi = acos(r) / 3;
 133
 134     *eig3 = q + 2 * p * cos(phi);
 135     *eig1 = q + 2 * p * cos(phi + 2 * M_PI / 3);
 136     *eig2 = 3 * q - *eig1 - *eig3;
 137 }
 138
 139
 140 static void calc_evector (double mat[3][3], double eig, double vec[3][1])
 141 {
 142     double h[3][3];
 143     double x_tmp[2][2];
 144     assign(3, 3, mat, h);
 145     h[0][0] -= eig;
 146     h[1][1] -= eig;
 147     h[2][2] -= eig;
 148
 149     double x[2][2];
 150     x[0][0] = h[1][1];
 151     x[0][1] = h[1][2];
 152     x[1][0] = h[2][1];
 153     x[1][1] = h[2][2];
 154     invert(2, x, x_tmp);
 155     assign(2, 2, x_tmp, x);
 156
 157     double temp1 = x[0][0] * (-h[1][0]) + x[0][1] * (-h[2][0]);
 158     double temp2 = x[1][0] * (-h[1][0]) + x[1][1] * (-h[2][0]);
 159     double norm = sqrt(1 + temp1 * temp1 + temp2 * temp2);
 160
 161     vec[0][0] = 1.0 / norm;
 162     vec[1][0] = temp1 / norm;
 163     vec[2][0] = temp2 / norm;
 164 }
 165
 166
 167 static int ellipsoid_fit (mat_input_t m, double offset[3][1], double w_invert[3][3], double* bfield)
 168 {
 169     int i;
 170     double h[MAGN_DS_SIZE][9];
 171     double w[MAGN_DS_SIZE][1];
 172     double h_trans[9][MAGN_DS_SIZE];
 173     double p_temp1[9][9];
 174     double p_temp2[9][MAGN_DS_SIZE];
 175     double temp1[3][3], temp[3][3];
 176     double temp1_inv[3][3];
 177     double temp2[3][1];
 178     double result[9][9];
 179     double p[9][1];
 180     double a[3][3], sqrt_evals[3][3], evecs[3][3], evecs_trans[3][3];
 181     double evec1[3][1], evec2[3][1], evec3[3][1];
 182
 183     for (i = 0; i < MAGN_DS_SIZE; i++) {
 184         w[i][0] = m[i][0] * m[i][0];
 185         h[i][0] = m[i][0];
 186         h[i][1] = m[i][1];
 187         h[i][2] = m[i][2];
 188         h[i][3] = -1 * m[i][0] * m[i][1];
 189         h[i][4] = -1 * m[i][0] * m[i][2];
 190         h[i][5] = -1 * m[i][1] * m[i][2];
 191         h[i][6] = -1 * m[i][1] * m[i][1];
 192         h[i][7] = -1 * m[i][2] * m[i][2];
 193         h[i][8] = 1;
 194     }
 195     transpose (MAGN_DS_SIZE, 9, h, h_trans);
 196     multiply (9, MAGN_DS_SIZE, 9, h_trans, h, result);
 197     invert (9, result, p_temp1);
 198     multiply (9, 9, MAGN_DS_SIZE, p_temp1, h_trans, p_temp2);
 199     multiply (9, MAGN_DS_SIZE, 1, p_temp2, w, p);
 200
 201     temp1[0][0] = 2;
 202     temp1[0][1] = p[3][0];
 203     temp1[0][2] = p[4][0];
 204     temp1[1][0] = p[3][0];
 205     temp1[1][1] = 2 * p[6][0];
 206     temp1[1][2] = p[5][0];
 207     temp1[2][0] = p[4][0];
 208     temp1[2][1] = p[5][0];
 209     temp1[2][2] = 2 * p[7][0];
 210
 211     temp2[0][0] = p[0][0];
 212     temp2[1][0] = p[1][0];
 213     temp2[2][0] = p[2][0];
 214
 215     invert(3, temp1, temp1_inv);
 216     multiply(3, 3, 1, temp1_inv, temp2, offset);
 217     double off_x = offset[0][0];
 218     double off_y = offset[1][0];
 219     double off_z = offset[2][0];
 220
 221
 222     a[0][0] = 1.0 / (p[8][0] + off_x * off_x + p[6][0] * off_y * off_y
 223             + p[7][0] * off_z * off_z + p[3][0] * off_x * off_y
 224             + p[4][0] * off_x * off_z + p[5][0] * off_y * off_z);
 225
 226     a[0][1] = p[3][0] * a[0][0] / 2;
 227     a[0][2] = p[4][0] * a[0][0] / 2;
 228     a[1][2] = p[5][0] * a[0][0] / 2;
 229     a[1][1] = p[6][0] * a[0][0];
 230     a[2][2] = p[7][0] * a[0][0];
 231     a[2][1] = a[1][2];
 232     a[1][0] = a[0][1];
 233     a[2][0] = a[0][2];
 234
 235     double eig1 = 0, eig2 = 0, eig3 = 0;
 236     compute_eigenvalues(a, &eig1, &eig2, &eig3);
 237
 238     if (eig1 <=0 || eig2 <= 0 || eig3 <= 0)
 239         return 0;
 240
 241     sqrt_evals[0][0] = sqrt(eig1);
 242     sqrt_evals[1][0] = 0;
 243     sqrt_evals[2][0] = 0;
 244     sqrt_evals[0][1] = 0;
 245     sqrt_evals[1][1] = sqrt(eig2);
 246     sqrt_evals[2][1] = 0;
 247     sqrt_evals[0][2] = 0;
 248     sqrt_evals[1][2] = 0;
 249     sqrt_evals[2][2] = sqrt(eig3);
 250
 251     calc_evector(a, eig1, evec1);
 252     calc_evector(a, eig2, evec2);
 253     calc_evector(a, eig3, evec3);
 254
 255     evecs[0][0] = evec1[0][0];
 256     evecs[1][0] = evec1[1][0];
 257     evecs[2][0] = evec1[2][0];
 258     evecs[0][1] = evec2[0][0];
 259     evecs[1][1] = evec2[1][0];
 260     evecs[2][1] = evec2[2][0];
 261     evecs[0][2] = evec3[0][0];
 262     evecs[1][2] = evec3[1][0];
 263     evecs[2][2] = evec3[2][0];
 264
 265     multiply (3, 3, 3, evecs, sqrt_evals, temp1);
 266     transpose(3, 3, evecs, evecs_trans);
 267     multiply (3, 3, 3, temp1, evecs_trans, temp);
 268     transpose (3, 3, temp, w_invert);
 269     *bfield = pow(sqrt(1/eig1) * sqrt(1/eig2) * sqrt(1/eig3), 1.0/3.0);
 270
 271     if (*bfield < 0)
 272         return 0;
 273
 274     multiply_scalar_inplace(3, 3, w_invert, *bfield);
 275
 276     return 1;
 277 }
 278
 279
 280 static void compass_cal_init (FILE* data_file, sensor_info_t* info)
 281 {
 282 #ifdef DBG_RAW_DATA
 283     if (raw_data) {
 284         fclose(raw_data);
 285         raw_data = NULL;
 286     }
 287
 288     if (raw_data_selected) {
 289         fclose(raw_data_selected);
 290         raw_data_selected = NULL;
 291     }
 292
 293     char path[64];
 294     snprintf(path, 64, RAW_DATA_FULL_PATH, file_no);
 295     raw_data = fopen(path,"w+");
 296     snprintf(path, 64, RAW_DATA_SELECTED_PATH, file_no);
 297     raw_data_selected = fopen(path,"w+");
 298     file_no++;
 299     raw_data_count = 0;
 300 #endif
 301
 302     compass_cal_t* cal_data = (compass_cal_t*) info->cal_data;
 303     int cal_steps = (info->max_cal_level && info->max_cal_level <= CAL_STEPS) ?
 304         info->max_cal_level : CAL_STEPS;
 305     if (cal_data == NULL)
 306         return;
 307
 308     int data_count = 14;
 309     reset_sample(cal_data);
 310
 311     if (!info->cal_level && data_file != NULL) {
 312        int ret = fscanf(data_file, "%d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
 313             &info->cal_level, &cal_data->offset[0][0], &cal_data->offset[1][0], &cal_data->offset[2][0],
 314             &cal_data->w_invert[0][0], &cal_data->w_invert[0][1], &cal_data->w_invert[0][2],
 315             &cal_data->w_invert[1][0], &cal_data->w_invert[1][1], &cal_data->w_invert[1][2],
 316             &cal_data->w_invert[2][0], &cal_data->w_invert[2][1], &cal_data->w_invert[2][2],
 317             &cal_data->bfield);
 318
 319         if (ret != data_count || info->cal_level >= cal_steps) {
 320             info->cal_level = 0;
 321         }
 322     }
 323
 324     if (info->cal_level) {
 325         ALOGV("CompassCalibration: load old data, caldata: %f %f %f %f %f %f %f %f %f %f %f %f %f",
 326             cal_data->offset[0][0], cal_data->offset[1][0], cal_data->offset[2][0],
 327             cal_data->w_invert[0][0], cal_data->w_invert[0][1], cal_data->w_invert[0][2], cal_data->w_invert[1][0],
 328             cal_data->w_invert[1][1], cal_data->w_invert[1][2], cal_data->w_invert[2][0], cal_data->w_invert[2][1],
 329             cal_data->w_invert[2][2], cal_data->bfield);
 330
 331     } else {
 332         cal_data->offset[0][0] = 0;
 333         cal_data->offset[1][0] = 0;
 334         cal_data->offset[2][0] = 0;
 335
 336         cal_data->w_invert[0][0] = 1;
 337         cal_data->w_invert[1][0] = 0;
 338         cal_data->w_invert[2][0] = 0;
 339         cal_data->w_invert[0][1] = 0;
 340         cal_data->w_invert[1][1] = 1;
 341         cal_data->w_invert[2][1] = 0;
 342         cal_data->w_invert[0][2] = 0;
 343         cal_data->w_invert[1][2] = 0;
 344         cal_data->w_invert[2][2] = 1;
 345
 346         cal_data->bfield = 0;
 347     }
 348 }
 349
 350
 351 static void compass_store_result (FILE* data_file, sensor_info_t* info)
 352 {
 353     compass_cal_t* cal_data = (compass_cal_t*) info->cal_data;
 354
 355     if (data_file == NULL || cal_data == NULL)
 356         return;
 357
 358     int ret = fprintf(data_file, "%d %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
 359         info->cal_level, cal_data->offset[0][0], cal_data->offset[1][0], cal_data->offset[2][0],
 360         cal_data->w_invert[0][0], cal_data->w_invert[0][1], cal_data->w_invert[0][2],
 361         cal_data->w_invert[1][0], cal_data->w_invert[1][1], cal_data->w_invert[1][2],
 362         cal_data->w_invert[2][0], cal_data->w_invert[2][1], cal_data->w_invert[2][2],
 363         cal_data->bfield);
 364
 365     if (ret < 0)
 366         ALOGE ("Compass calibration - store data failed!");
 367 }
 368
 369
 370 static int compass_collect (sensors_event_t* event, sensor_info_t* info)
 371 {
 372     float data[3] = {event->magnetic.x, event->magnetic.y, event->magnetic.z};
 373     unsigned int index,j;
 374     unsigned int lookback_count;
 375     float min_diff;
 376
 377     compass_cal_t* cal_data = (compass_cal_t*) info->cal_data;
 378
 379     if (cal_data == NULL)
 380         return -1;
 381
 382     /* Discard the point if not valid */
 383     if (data[0] == 0 || data[1] == 0 || data[2] == 0)
 384         return -1;
 385
 386 #ifdef DBG_RAW_DATA
 387     if (raw_data && raw_data_count < MAX_RAW_DATA_COUNT) {
 388         fprintf(raw_data, "%f %f %f\n", (double)data[0], (double)data[1],
 389                  (double)data[2]);
 390         raw_data_count++;
 391     }
 392
 393     if (raw_data && raw_data_count >= MAX_RAW_DATA_COUNT) {
 394         fclose(raw_data);
 395         raw_data = NULL;
 396     }
 397 #endif
 398
 399     lookback_count = lookback_counts[info->cal_level];
 400     min_diff = min_diffs[info->cal_level];
 401
 402     /*
 403      * For the current point to be accepted, each x/y/z value must be different
 404      * enough to the last several collected points.
 405      */
 406     if (cal_data->sample_count > 0 && cal_data->sample_count < MAGN_DS_SIZE) {
 407         unsigned int lookback = lookback_count < cal_data->sample_count ? lookback_count : cal_data->sample_count;
 408         for (index = 0; index < lookback; index++)
 409             for (j = 0; j < 3; j++)
 410                 if (fabsf(data[j] - cal_data->sample[cal_data->sample_count-1-index][j]) < min_diff) {
 411                     ALOGV("CompassCalibration:point reject: [%f,%f,%f], selected_count=%d",
 412                        data[0], data[1], data[2], cal_data->sample_count);
 413                        return 0;
 414                 }
 415     }
 416
 417     if (cal_data->sample_count < MAGN_DS_SIZE) {
 418         memcpy(cal_data->sample[cal_data->sample_count], data, sizeof(float) * 3);
 419         cal_data->sample_count++;
 420         cal_data->average[0] += data[0];
 421         cal_data->average[1] += data[1];
 422         cal_data->average[2] += data[2];
 423         ALOGV("CompassCalibration:point collected [%f,%f,%f], selected_count=%d",
 424             (double)data[0], (double)data[1], (double)data[2], cal_data->sample_count);
 425 #ifdef DBG_RAW_DATA
 426         if (raw_data_selected) {
 427             fprintf(raw_data_selected, "%f %f %f\n", (double)data[0], (double)data[1], (double)data[2]);
 428         }
 429 #endif
 430     }
 431     return 1;
 432 }
 433
 434
 435 static void scale_event (sensors_event_t* event)
 436 {
 437     float sqr_norm = 0;
 438     float sanity_norm = 0;
 439     float scale = 1;
 440
 441     sqr_norm = (event->magnetic.x * event->magnetic.x +
 442                 event->magnetic.y * event->magnetic.y +
 443                 event->magnetic.z * event->magnetic.z);
 444
 445     if (sqr_norm < MAGNETIC_LOW)
 446         sanity_norm = MAGNETIC_LOW;
 447
 448     if (sanity_norm && sqr_norm) {
 449         scale = sanity_norm / sqr_norm;
 450         scale = sqrt(scale);
 451         event->magnetic.x = event->magnetic.x * scale;
 452         event->magnetic.y = event->magnetic.y * scale;
 453         event->magnetic.z = event->magnetic.z * scale;
 454     }
 455 }
 456
 457
 458 static void compass_compute_cal (sensors_event_t* event, sensor_info_t* info)
 459 {
 460     compass_cal_t* cal_data = (compass_cal_t*) info->cal_data;
 461     double result[3][1], raw[3][1], diff[3][1];
 462
 463     if (!info->cal_level || cal_data == NULL)
 464         return;
 465
 466     raw[0][0] = event->magnetic.x;
 467     raw[1][0] = event->magnetic.y;
 468     raw[2][0] = event->magnetic.z;
 469
 470     substract(3, 1, raw, cal_data->offset, diff);
 471     multiply (3, 3, 1, cal_data->w_invert, diff, result);
 472
 473     event->magnetic.x = event->data[0] = result[0][0];
 474     event->magnetic.y = event->data[1] = result[1][0];
 475     event->magnetic.z = event->data[2] = result[2][0];
 476
 477     scale_event(event);
 478 }
 479
 480
 481 static int compass_ready (sensor_info_t* info)
 482 {
 483     mat_input_t mat;
 484     int i;
 485     float max_sqr_err;
 486
 487     compass_cal_t* cal_data = (compass_cal_t*) info->cal_data;
 488     compass_cal_t new_cal_data;
 489
 490     /*
 491      *  Some sensors take unrealistically long to calibrate at higher levels.
 492      *  We'll use a max_cal_level if we have such a property setup, or go with
 493      *  the default settings if not.
 494      */
 495     int cal_steps = (info->max_cal_level && info->max_cal_level <= CAL_STEPS) ?
 496         info->max_cal_level : CAL_STEPS;
 497
 498     if (cal_data->sample_count < MAGN_DS_SIZE)
 499         return info->cal_level;
 500
 501     max_sqr_err = max_sqr_errs[info->cal_level];
 502
 503     /* Enough points have been collected, do the ellipsoid calibration */
 504
 505     /* Compute average per axis */
 506     cal_data->average[0] /= MAGN_DS_SIZE;
 507     cal_data->average[1] /= MAGN_DS_SIZE;
 508     cal_data->average[2] /= MAGN_DS_SIZE;
 509
 510     for (i = 0; i < MAGN_DS_SIZE; i++) {
 511        mat[i][0] = cal_data->sample[i][0];
 512        mat[i][1] = cal_data->sample[i][1];
 513        mat[i][2] = cal_data->sample[i][2];
 514     }
 515
 516     /* Check if result is good. The sample data must remain the same */
 517     new_cal_data = *cal_data;
 518
 519     if (ellipsoid_fit(mat, new_cal_data.offset, new_cal_data.w_invert, &new_cal_data.bfield)) {
 520         double new_err = calc_square_err (&new_cal_data);
 521         ALOGI("new err is %f, max sqr err id %f", new_err,max_sqr_err);
 522         if (new_err < max_sqr_err) {
 523             double err = calc_square_err(cal_data);
 524             if (new_err < err) {
 525                 /* New cal data is better, so we switch to the new */
 526                 memcpy(cal_data->offset, new_cal_data.offset, sizeof(cal_data->offset));
 527                 memcpy(cal_data->w_invert, new_cal_data.w_invert, sizeof(cal_data->w_invert));
 528                 cal_data->bfield = new_cal_data.bfield;
 529                 if (info->cal_level < (cal_steps - 1))
 530                     info->cal_level++;
 531                 ALOGV("CompassCalibration: ready check success, caldata: %f %f %f %f %f %f %f %f %f %f %f %f %f, err %f",
 532                     cal_data->offset[0][0], cal_data->offset[1][0], cal_data->offset[2][0], cal_data->w_invert[0][0],
 533                     cal_data->w_invert[0][1], cal_data->w_invert[0][2], cal_data->w_invert[1][0], cal_data->w_invert[1][1],
 534                     cal_data->w_invert[1][2], cal_data->w_invert[2][0], cal_data->w_invert[2][1], cal_data->w_invert[2][2],
 535                     cal_data->bfield, new_err);
 536             }
 537         }
 538     }
 539     reset_sample(cal_data);
 540     return info->cal_level;
 541 }
 542
 543
 544 void calibrate_compass (sensors_event_t* event, sensor_info_t* info)
 545 {
 546     int cal_level;
 547
 548     /* Calibration is continuous */
 549     compass_collect (event, info);
 550
 551     cal_level = compass_ready(info);
 552
 553     switch (cal_level) {
 554         case 0:
 555             scale_event(event);
 556             event->magnetic.status = SENSOR_STATUS_UNRELIABLE;
 557             break;
 558
 559         case 1:
 560             compass_compute_cal (event, info);
 561             event->magnetic.status = SENSOR_STATUS_ACCURACY_LOW;
 562             break;
 563
 564         case 2:
 565             compass_compute_cal (event, info);
 566             event->magnetic.status = SENSOR_STATUS_ACCURACY_MEDIUM;
 567             break;
 568
 569         default:
 570             compass_compute_cal (event, info);
 571             event->magnetic.status = SENSOR_STATUS_ACCURACY_HIGH;
 572             break;
 573     }
 574 }
 575
 576 void compass_read_data (sensor_info_t* info)
 577 {
 578     FILE* data_file = fopen (COMPASS_CALIBRATION_PATH, "r");
 579
 580     compass_cal_init(data_file, info);
 581     if (data_file)
 582         fclose(data_file);
 583 }
 584
 585
 586 void compass_store_data (sensor_info_t* info)
 587 {
 588     FILE* data_file = fopen (COMPASS_CALIBRATION_PATH, "w");
 589
 590     compass_store_result(data_file, info);
 591     if (data_file)
 592         fclose(data_file);
 593 }