File content as of revision 3:12cb106044f9:

#include "mbed.h"
#include "x_nucleo_53l0a1.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

/* 
 * This VL53L0X Expansion board sample application performs range measurements using 
 * range_continuous_interrupt mode to generate a hardware interrupt each time a new 
 * measurement is ready to be read.
 * The application supports the centre, on-board, sensor and up two satellites.
 *
 * *** NOTE : Hard-links U11 and U18, on the underside of the X-NUCELO-53L0A1
 *            expansion board must be made/ON to allow interrupts to be received
 *            from the satellite boards. ***
 *   
 * The measured range data is displayed on the on-board 4-digit LED display, and sent
 * to the COM port.
 *
 * The User Blue button switches between the currently selected sensor to display range 
 * results from.
 *
 * The Black Reset button is used to restart the program. 
 */


#define VL53L0_I2C_SDA   D14 
#define VL53L0_I2C_SCL   D15 

#define CENTER_BIT  0
#define LEFT_BIT    1
#define RIGHT_BIT   2


static X_NUCLEO_53L0A1 *board=NULL;
VL53L0X_RangingMeasurementData_t data_sensor;
OperatingMode operating_mode;
    
/* interrupt requests */
volatile int upadtedSensors = 0;

/* Current sensor number*/
volatile int currentSensor = 0;
/* Installed sensors count */ 
int sensorCnt = 0; 

struct Sensor
{
    char prefix;
    int sensorBit;
    VL53L0X *sensorPtr;
} installedSensors[3];


/* ISR callback function of the sensor_centre */
void SensorCenterIRQ(void)
{
   upadtedSensors |= (1 << CENTER_BIT); 
   board->sensor_centre->DisableInterruptMeasureDetectionIRQ();
}   

void SensorLeftIRQ(void)
{
   upadtedSensors |= (1 << LEFT_BIT); 
   board->sensor_left->DisableInterruptMeasureDetectionIRQ();
} 

void SensorRightIRQ(void)
{      
   upadtedSensors |= (1 << RIGHT_BIT); 
   board->sensor_right->DisableInterruptMeasureDetectionIRQ();
} 

/* ISR callback function of the user blue button to switch measuring sensor. */
void SwitchMeasuringSensorIRQ(void)
{
    ++currentSensor;
    if (currentSensor == sensorCnt)
        currentSensor = 0;
    printf("Sensor changed to %c\r\n",installedSensors[currentSensor].prefix);
}

/* On board 4 digit local display refresh */
void DisplayRefresh(OperatingMode op_mode)
{   
    int status;
    char str[4];
    Sensor *current;
    for (int t=0; t < sensorCnt; t++)
    {
        current = &installedSensors[t];
        if (upadtedSensors & current->sensorBit)
        {
            status = current->sensorPtr->HandleIRQ(op_mode, &data_sensor);
            upadtedSensors &= ~(current->sensorBit) ;
            if (!status)
            {
                if (data_sensor.RangeStatus == 0) // we have a valid range.
                {
                    printf("%c %4d; ", current->prefix,data_sensor.RangeMilliMeter);
                    if (currentSensor == t)
                    {
                        sprintf(str,"%c%3d", current->prefix ,data_sensor.RangeMilliMeter);
                    }
                }
                else
                {
                    if (currentSensor == t)
                    {
                        sprintf(str,"%c%s", current->prefix, "---");
                    }   
                }       
            }
        }
    }
    board->display->DisplayString(str);
}

int InitSensorsArray()
{
    int status = 1;
    sensorCnt = 0;
    /* start the measure on the center sensor */
    if (NULL != board->sensor_centre)
    {
        installedSensors[sensorCnt].prefix = 'C';
        installedSensors[sensorCnt].sensorBit |= (1 << CENTER_BIT);
        installedSensors[sensorCnt].sensorPtr = board->sensor_centre; 
        status=board->sensor_centre->StopMeasurement(operating_mode);
        status=board->sensor_centre->StartMeasurement(operating_mode, &SensorCenterIRQ); 
        ++sensorCnt;
    }
    /* start the measure on the left sensor */
    if (NULL != board->sensor_left)
    {
        installedSensors[sensorCnt].prefix = 'L';
        installedSensors[sensorCnt].sensorBit |= (1 << LEFT_BIT);
        installedSensors[sensorCnt].sensorPtr = board->sensor_left; 
        status=board->sensor_left->StopMeasurement(operating_mode);
        status=board->sensor_left->StartMeasurement(operating_mode, &SensorLeftIRQ);
        ++sensorCnt;
    }
    /* start the measure on the right sensor */    
    if (NULL != board->sensor_right)
    {
        installedSensors[sensorCnt].prefix = 'R';
        installedSensors[sensorCnt].sensorBit |= (1 << RIGHT_BIT);
        installedSensors[sensorCnt].sensorPtr = board->sensor_right; 
        status=board->sensor_right->StopMeasurement(operating_mode);
        status=board->sensor_right->StartMeasurement(operating_mode, &SensorRightIRQ);
        ++sensorCnt;
    }
    currentSensor = 0;
    return status;
}

void RangeMeasure(DevI2C *device_i2c) {
   int status;

   /* creates the 53L0A1 expansion board singleton obj */
   board=X_NUCLEO_53L0A1::Instance(device_i2c, A2, D8, D2);
    
   board->display->DisplayString("53L0");
   
   operating_mode=range_continuous_interrupt;
   
   /* init the 53L0A1 expansion board with default values */
   status=board->InitBoard();
   
   if(status)
   {
        printf("Failed to init board!\n\r");   
   }
   else 
   {
        status = InitSensorsArray();
   }
   
   if(!status)
   {
     printf ("\r\nEntering loop mode\r\n");
     while (true)
     { 
        DisplayRefresh(operating_mode);
     }
   }
   delete board;        
}    

/*=================================== Main ==================================
 Press the blue user button to switch the displayed sensor.       
=============================================================================*/
int main()
{   
#if USER_BUTTON==PC_13  // we are cross compiling for Nucleo-f401 
   InterruptIn stop_button (USER_BUTTON);
   stop_button.rise (&SwitchMeasuringSensorIRQ);  
#endif   
   DevI2C *device_i2c =new DevI2C(VL53L0_I2C_SDA, VL53L0_I2C_SCL);        
   RangeMeasure(device_i2c);  // start continuous measures
}