File content as of revision 2:54e1a301de72:

#include "mbed.h"
#include "rtos.h"
#include <stdio.h>
#include "uLCD_4DGL.h"
#include "XNucleo53L0A1.h"
#include <time.h>

#define VL53L0_I2C_SDA   p28
#define VL53L0_I2C_SCL   p27

// We need this for being able to reset the MBED (similar to watch dogs)
extern "C" void mbed_reset();

// Game Data
volatile int num_points = 0;
volatile int time_left = 0;
int threshold = 300; // mm
volatile bool is_point = false;

// LIDAR
static XNucleo53L0A1* lidar = NULL;
uint32_t dist;
DigitalOut shdn(p26);

// LCD
Mutex lcd_lock;
// **NOTE**: do NOT use p9, p10, p11
// There is a bug in LIDAR system and uLCD system - they can't BOTH BE ON
// I2C! It just so happens, p9 and p10 are I2C, so the systems will get 
// confused, and you'll get weird hangs with the uLCD screen!
uLCD_4DGL uLCD(p13, p14, p15); // serial tx, serial rx, reset pin;

// Speaker
PwmOut speaker(p25);

// LEDs
PwmOut point_led(p21);

// Button
DigitalIn starter(p19);

// Threads
Thread sound_thread;
Thread time_thread;
Thread points_thread;

// Debugging
Serial pc(USBTX, USBRX);
DigitalOut err_led(LED1);

void time(void) {
    while (1) {
        // every second, change LED and update screen
        if (time_left > 0) {
            lcd_lock.lock();
            uLCD.locate(4, 5);
            uLCD.text_height(2);
            uLCD.text_width(2);
            uLCD.color(RED);
            uLCD.printf("%02d", time_left);
            lcd_lock.unlock();
            Thread::wait(1000);
            time_left--;
        } else {
            break;
        }
    }
    
    lcd_lock.lock();
    uLCD.locate(4, 5);
    uLCD.text_height(2);
    uLCD.text_width(2);
    uLCD.color(RED);
    uLCD.printf("00");
    lcd_lock.unlock();
    // We're done - thread will die
}
void sound(void) {
    int is_new = 1;
    speaker.period(1.0 / 900.0);
    while (1) {
        // if we have a point, sound
        // If there's no more time left, die
        if (time_left <= 0) {
            break;
        } else if (is_point && is_new == 1) {
            is_new = 0;
            // sound that
            speaker = 0.5;
            Thread::wait(100);
            speaker = 0;
        } else if (!is_point) {
            // We've engaged, get ready for next
            is_new = 1;
        }
        Thread::wait(10);
    }
}

void points(void) {
    int prev_points = -1;
    while (1) {
        if (time_left <= 0) {
            break;
        } else if (num_points != prev_points) {
            lcd_lock.lock();
            uLCD.locate(4, 2);
            uLCD.text_width(2);
            uLCD.text_height(2);
            uLCD.color(GREEN);
            uLCD.printf("%d", num_points);
            lcd_lock.unlock();
            prev_points = num_points;
        }
        Thread::wait(100);
    }
}

int main() {
    // Tell the user we're spinning up
    uLCD.cls();
    uLCD.text_height(2);
    uLCD.text_width(2);
    uLCD.locate(0, 0);
    uLCD.color(RED);
    uLCD.printf("SPINNING\nUP");
    
    // Initialize
    starter.mode(PullUp);
    
    time_left = 15;
    
    DevI2C* device_i2c = new DevI2C(VL53L0_I2C_SDA, VL53L0_I2C_SCL);
    lidar = XNucleo53L0A1::instance(device_i2c, A2, D8, D2);

    // Reset shdn (?):
    shdn = 0;
    wait(0.1);
    shdn = 1;
    wait(0.1);
    
    int status = lidar->init_board();
    while (status) {
        err_led = 1;
        status = lidar->init_board();
        wait(1);
    }
    err_led = 0;
    
    uLCD.cls();
    uLCD.locate(0, 0);
    uLCD.color(GREEN);
    uLCD.text_height(2);
    uLCD.text_width(2);
    uLCD.printf("Want To\nPlay?");
    
    // Wait for the button
    while (starter != 0);
    
    uLCD.cls();
    uLCD.text_width(2);
    uLCD.text_height(2);
    uLCD.locate(1, 1);
    uLCD.color(GREEN);
    uLCD.printf("POINTS");
    
    uLCD.locate(2, 4);
    uLCD.color(RED);
    uLCD.printf("TIME");
    
    // Start up threads
    time_thread.start(time);
    points_thread.start(points);
    sound_thread.start(sound);

    // Continually measure distance
    while (1) {
        status = lidar->sensor_centre->get_distance(&dist);
        if (status == VL53L0X_ERROR_NONE) {

            // Determine if we've hit the threshold (4 cases):
            // 1. NOT in the threshold, current distance is above
            // 2. NOT in the threshold, current distance is below
            // 3. IN the threshold, current distance is above
            // 4. IN the threshold, current distance is below
            //pc.printf("D=%ld mm\r\n", dist);
            if (!is_point && dist <= threshold) {
                if (time_left == 0)
                    break;
                // increment our points
                ++num_points;
                is_point = true;
                point_led = 1;
            } else if (is_point && dist > threshold) {
                is_point = false;
                point_led = 0;
            }
        } else {
            is_point = false;
            point_led = 0;
        }
    }
    point_led = 1;
    // We have nothing left to do; wait for reset!
    while (starter != 0);
    mbed_reset();
}