File content as of revision 59:1ef9ce8622cd:

#include <mbed.h>

// GNSS and Compass test programm for Mateksys GNSS&Compass M9N-5883

// #include "Eigen/Dense.h"
#include "QMC5883L.h"
#include "LinearCharacteristics.h"
#include "NEOM9N.h"
#include "AvgFilter.h"

// logical variable main task
bool do_execute_main_task = true;  // this variable will be toggled via the user button (blue button) to or not to execute the main task

// user button on nucleo board
Timer user_button_timer;            // create Timer object which we use to check if user button was pressed for a certain time (robust against signal bouncing)
InterruptIn user_button(PC_13);     // create InterruptIn interface object to evaluate user button falling and rising edge (no blocking code in ISR)
void user_button_pressed_fcn();     // custom functions which gets executed when user button gets pressed and released, definition below
void user_button_released_fcn();

int main()
{
    // while loop gets executed every main_task_period_ms milliseconds
    const int main_task_period_ms = 40;  // define main task period time in ms e.g. 50 ms -> main task runns 20 times per second
    Timer main_task_timer;               // create Timer object which we use to run the main task every main task period time in ms
    main_task_timer.start();
    
    Timer run_timer;
    run_timer.start();

    // led on nucleo board
    DigitalOut user_led(LED1);      // create DigitalOut object to command user led

    // create QMC5883L compass object
    I2C i2c(PB_9, PB_8); // I2C1
    QMC5883L mag(i2c);
    LinearCharacteristics raw_mx2mx, raw_my2my, raw_mz2mz;
    raw_mx2mx.setup(0.9991f, 0.0088f);
    raw_my2my.setup(0.9982f, 0.2092f);
    raw_mz2mz.setup(1.0027f, -0.0903f);
    float mag_val[3] = {0.0f, 0.0f, 0.0f};
    
    // create object for GNSS Sensor NEO-M9N
    NEOM9N neom9n(PA_9, PA_10); // UART1
    bool isGNSSInit = false;

    /*
    bool is_first_readout = true;
    uint8_t Navg = 25;
    AvgFilter* pos_ecef_avg[3];
    pos_ecef_avg[0] = new AvgFilter(Navg);
    pos_ecef_avg[1] = new AvgFilter(Navg);
    pos_ecef_avg[2] = new AvgFilter(Navg);
    */

    // attach button fall and rise functions to user button object
    user_button.fall(&user_button_pressed_fcn);
    user_button.rise(&user_button_released_fcn);   

    while (true) { // this loop will run forever

        main_task_timer.reset();

        //run_timer.reset(); // remove this for time measurement

        // update magnetometer
        mag.readMag(); // this needs approx 2450 mus
        mag_val[0] = raw_mx2mx.evaluate( mag.magX() );
        mag_val[1] = raw_my2my.evaluate( mag.magY() );
        mag_val[2] = raw_mz2mz.evaluate( mag.magZ() );

        // update GNSS
        neom9n.update();

        if (!isGNSSInit && std::chrono::duration_cast<std::chrono::milliseconds>(run_timer.elapsed_time()).count() >= 1000) {
            neom9n.init();
            isGNSSInit = true;
        }

        /*
        if (is_first_readout) {
            is_first_readout = false;
            pos_ecef_avg[0]->reset()
        }
        */

        if (do_execute_main_task) {

        } else {

        }

        user_led = !user_led;

        // do only output via serial what's really necessary (this makes your code slow)
        printf("%0.3f, %0.3f, %0.3f, ",        //  1: 3
            mag_val[0], mag_val[1], mag_val[2]);
        printf("%0.3f, %0.3f, %0.3f, %0.3f, ", //  4: 7
            neom9n.getGroundSpeed(), neom9n.getSpeedAcc(), neom9n.getHeading(), neom9n.getHeadAcc());
        printf("%d, %d, %d, %d, ",             //  8:11 see manual for scaling information
            neom9n.m_actualPVT.lon, neom9n.m_actualPVT.lat, neom9n.m_actualPVT.height, neom9n.m_actualPVT.heightMSL);
        printf("%0.3f, %d, ",                  // 12:13
            neom9n.getSatTime(), neom9n.getNumSat());
        Eigen::Vector3f pos_ecef = neom9n.getPosECEF();
        printf("%0.3f, %0.3f, %0.3f, ",        // 14:16
            pos_ecef.x(), pos_ecef.y(), pos_ecef.z());
        Eigen::Vector3f pos_enu = neom9n.getPosENU();
        printf("%0.3f, %0.3f, %0.3f, ",        // 17:19
            pos_enu.x(), pos_enu.y(), pos_enu.z());
        Eigen::Vector3f vel_enu = neom9n.getVelENU();
        printf("%0.3f, %0.3f, %0.3f, ",        // 20:22
            vel_enu.x(), vel_enu.y(), vel_enu.z());

        int run_elapsed_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(run_timer.elapsed_time()).count();
        printf("%d\r\n", run_elapsed_time_ms);

        // read timer and make the main thread sleep for the remaining time span (non blocking)
        int main_task_elapsed_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(main_task_timer.elapsed_time()).count();
                
        thread_sleep_for(main_task_period_ms - main_task_elapsed_time_ms);
    }
}

void user_button_pressed_fcn()
{
    user_button_timer.start();
    user_button_timer.reset();
}

void user_button_released_fcn()
{
    // read timer and toggle do_execute_main_task if the button was pressed longer than the below specified time
    int user_button_elapsed_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(user_button_timer.elapsed_time()).count();
    user_button_timer.stop();
    if (user_button_elapsed_time_ms > 200) {
        do_execute_main_task = !do_execute_main_task;
    }
}