John Alexander / Mbed OS VL53L3CX_Shield_1Sensor_Interrupt_MbOS6x

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   X_NUCLEO_53L3A2

main.cpp@7:bd1ddfbee3ef, 2021-05-10 (annotated)

Committer:
johnAlexander
Date:
Mon May 10 12:48:51 2021 +0000
Revision:
7:bd1ddfbee3ef
Parent:
6:4bc839979c55 
Code tidy up & reformatting.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
charlesmn 0:c77591fc308d 1 /*
johnAlexander 4:360dc34c3769 2 * This VL53L3 Expansion board test application performs range measurements
johnAlexander 6:4bc839979c55 3 * using the onboard embedded centre sensor, in interrupt mode.
johnAlexander 4:360dc34c3769 4 * Measured ranges are ouput on the Serial Port, running at 115200 baud.
johnAlexander 4:360dc34c3769 5 *
johnAlexander 4:360dc34c3769 6 * The User Blue button stops the current measurement and entire program,
johnAlexander 4:360dc34c3769 7 * releasing all resources.
charlesmn 0:c77591fc308d 8 *
johnAlexander 4:360dc34c3769 9 * The Reset button can be used to restart the program.
charlesmn 0:c77591fc308d 10 *
johnAlexander 5:92a861d48253 11 * *** Note :
johnAlexander 4:360dc34c3769 12 * Default Mbed build system settings disable print floating-point support.
johnAlexander 4:360dc34c3769 13 * Offline builds can enable this, again.
johnAlexander 4:360dc34c3769 14 * https://github.com/ARMmbed/mbed-os/blob/master/platform/source/minimal-printf/README.md
johnAlexander 4:360dc34c3769 15 * .\mbed-os\platform\mbed_lib.json
johnAlexander 4:360dc34c3769 16 *
charlesmn 0:c77591fc308d 17 */
johnAlexander 5:92a861d48253 18
charlesmn 0:c77591fc308d 19 #include <stdio.h>
johnAlexander 3:42c96c9c627b 20 #include <time.h>
charlesmn 0:c77591fc308d 21
charlesmn 0:c77591fc308d 22 #include "mbed.h"
johnAlexander 4:360dc34c3769 23
johnAlexander 3:42c96c9c627b 24 #include "XNucleo53L3A2.h"
charlesmn 2:86876e590f28 25 #include "vl53L3_I2c.h"
charlesmn 0:c77591fc308d 26
charlesmn 0:c77591fc308d 27
johnAlexander 5:92a861d48253 28 #define I2C_SDA D14
johnAlexander 5:92a861d48253 29 #define I2C_SCL D15
charlesmn 0:c77591fc308d 30
johnAlexander 7:bd1ddfbee3ef 31 #define MEASUREMENTTIMING 40 //55
charlesmn 0:c77591fc308d 32
johnAlexander 3:42c96c9c627b 33 static XNucleo53L3A2 *board=NULL;
johnAlexander 3:42c96c9c627b 34 #if (MBED_VERSION > 60300)
johnAlexander 5:92a861d48253 35 UnbufferedSerial pc(USBTX, USBRX);
johnAlexander 5:92a861d48253 36 extern "C" void wait_ms(int ms);
johnAlexander 3:42c96c9c627b 37 #else
johnAlexander 5:92a861d48253 38 Serial pc(SERIAL_TX, SERIAL_RX);
johnAlexander 3:42c96c9c627b 39 #endif
charlesmn 0:c77591fc308d 40
charlesmn 0:c77591fc308d 41 static int int_centre_result = 0;
charlesmn 0:c77591fc308d 42 static int int_left_result = 0;
charlesmn 0:c77591fc308d 43 static int int_right_result = 0;
charlesmn 0:c77591fc308d 44
charlesmn 0:c77591fc308d 45
johnAlexander 5:92a861d48253 46 class WaitForMeasurement
johnAlexander 5:92a861d48253 47 {
johnAlexander 5:92a861d48253 48
charlesmn 0:c77591fc308d 49 public:
charlesmn 0:c77591fc308d 50
charlesmn 0:c77591fc308d 51
charlesmn 0:c77591fc308d 52 // this class services the interrupts from the ToF sensors.
charlesmn 0:c77591fc308d 53 // There is a limited amount you can do in an interrupt routine; printfs,mutexes break them among other things.
charlesmn 0:c77591fc308d 54 // We keep things simple by only raising a flag so all the real work is done outside the interrupt.
charlesmn 0:c77591fc308d 55 // This is designed around MBED V2 which doesn't have the RTOS features that would make this work nicely e.g. semaphores/queues.
johnAlexander 5:92a861d48253 56 WaitForMeasurement(): _interrupt(A1)
johnAlexander 5:92a861d48253 57 {
johnAlexander 5:92a861d48253 58 }
charlesmn 0:c77591fc308d 59
charlesmn 0:c77591fc308d 60
johnAlexander 7:bd1ddfbee3ef 61 // constructor
charlesmn 0:c77591fc308d 62 WaitForMeasurement(PinName pin,VL53LX_DEV Dev) : _interrupt(pin) // create the InterruptIn on the pin specified to Counter
charlesmn 0:c77591fc308d 63 {
johnAlexander 5:92a861d48253 64 Devlocal = Dev;
charlesmn 0:c77591fc308d 65 _interrupt.rise(callback(this, &WaitForMeasurement::got_interrupt)); // attach increment function of this counter instance
johnAlexander 5:92a861d48253 66
charlesmn 0:c77591fc308d 67 }
johnAlexander 5:92a861d48253 68
charlesmn 0:c77591fc308d 69 void process_right_interrupt()
charlesmn 0:c77591fc308d 70 {
johnAlexander 5:92a861d48253 71 printf("processing right interrupt\n");
charlesmn 0:c77591fc308d 72 }
charlesmn 0:c77591fc308d 73
johnAlexander 5:92a861d48253 74 // function is called every time an interupt is seen. A flag is raised which allows the main routine to service the interupt.
charlesmn 0:c77591fc308d 75 void got_interrupt()
charlesmn 0:c77591fc308d 76 {
charlesmn 0:c77591fc308d 77 _count++;
charlesmn 0:c77591fc308d 78
charlesmn 0:c77591fc308d 79 if (Devlocal->I2cDevAddr == NEW_SENSOR_CENTRE_ADDRESS)
charlesmn 0:c77591fc308d 80 int_centre_result = 1; //flag to main that interrupt happened
charlesmn 0:c77591fc308d 81 if (Devlocal->I2cDevAddr == NEW_SENSOR_LEFT_ADDRESS)
charlesmn 0:c77591fc308d 82 int_left_result = 1; //flag to main that interrupt happened
charlesmn 0:c77591fc308d 83 if (Devlocal->I2cDevAddr == NEW_SENSOR_RIGHT_ADDRESS)
charlesmn 0:c77591fc308d 84 int_right_result = 1; //flag to main that interrupt happened
charlesmn 0:c77591fc308d 85 }
charlesmn 0:c77591fc308d 86
johnAlexander 5:92a861d48253 87
charlesmn 0:c77591fc308d 88 //destructor
charlesmn 0:c77591fc308d 89 ~WaitForMeasurement()
charlesmn 0:c77591fc308d 90 {
charlesmn 0:c77591fc308d 91 printf("destruction \n");
charlesmn 0:c77591fc308d 92 }
charlesmn 0:c77591fc308d 93
charlesmn 0:c77591fc308d 94 private:
johnAlexander 4:360dc34c3769 95
charlesmn 0:c77591fc308d 96 InterruptIn _interrupt;
charlesmn 0:c77591fc308d 97 volatile int _count;
charlesmn 0:c77591fc308d 98 VL53LX_DEV Devlocal;
johnAlexander 5:92a861d48253 99 int status;
charlesmn 0:c77591fc308d 100 };
charlesmn 0:c77591fc308d 101
charlesmn 0:c77591fc308d 102
charlesmn 0:c77591fc308d 103
johnAlexander 6:4bc839979c55 104 VL53LX_Dev_t devCentre;
johnAlexander 7:bd1ddfbee3ef 105 //VL53LX_Dev_t devLeft;
johnAlexander 7:bd1ddfbee3ef 106 //VL53LX_Dev_t devRight;
johnAlexander 6:4bc839979c55 107 VL53LX_DEV Dev = &devCentre;
charlesmn 0:c77591fc308d 108
charlesmn 0:c77591fc308d 109
charlesmn 0:c77591fc308d 110
charlesmn 0:c77591fc308d 111
johnAlexander 5:92a861d48253 112
charlesmn 0:c77591fc308d 113 /*=================================== Main ==================================
charlesmn 0:c77591fc308d 114 =============================================================================*/
charlesmn 0:c77591fc308d 115 int main()
johnAlexander 5:92a861d48253 116 {
charlesmn 0:c77591fc308d 117 int status;
johnAlexander 7:bd1ddfbee3ef 118 VL53L3 *Sensor;
johnAlexander 7:bd1ddfbee3ef 119 WaitForMeasurement *int1;
johnAlexander 5:92a861d48253 120
johnAlexander 7:bd1ddfbee3ef 121 vl53L3_DevI2C *dev_I2C = new vl53L3_DevI2C(I2C_SDA, I2C_SCL);
johnAlexander 7:bd1ddfbee3ef 122 /* creates the 53L1A1 expansion board singleton obj */
johnAlexander 7:bd1ddfbee3ef 123 board = XNucleo53L3A2::instance(dev_I2C, A2, D8, D2);
johnAlexander 7:bd1ddfbee3ef 124
johnAlexander 7:bd1ddfbee3ef 125 printf("board created!\r\n");
charlesmn 0:c77591fc308d 126
charlesmn 0:c77591fc308d 127 pc.baud(115200); // baud rate is important as printf statements take a lot of time
charlesmn 0:c77591fc308d 128
charlesmn 0:c77591fc308d 129 /* init the 53L1A1 expansion board with default values */
charlesmn 0:c77591fc308d 130 status = board->init_board();
charlesmn 0:c77591fc308d 131 if (status) {
charlesmn 0:c77591fc308d 132 printf("Failed to init board!\r\n");
charlesmn 0:c77591fc308d 133 return 0;
charlesmn 0:c77591fc308d 134 }
johnAlexander 5:92a861d48253 135
charlesmn 0:c77591fc308d 136 printf("board initiated! - %d\r\n", status);
johnAlexander 5:92a861d48253 137
johnAlexander 7:bd1ddfbee3ef 138 Dev = &devCentre;
johnAlexander 7:bd1ddfbee3ef 139 Dev->I2cDevAddr = NEW_SENSOR_CENTRE_ADDRESS;
johnAlexander 7:bd1ddfbee3ef 140 Dev->comms_speed_khz = 400;
johnAlexander 7:bd1ddfbee3ef 141 Dev->comms_type = 1;
johnAlexander 7:bd1ddfbee3ef 142
johnAlexander 7:bd1ddfbee3ef 143 Sensor = board->sensor_centre;
johnAlexander 7:bd1ddfbee3ef 144
johnAlexander 7:bd1ddfbee3ef 145 printf("configuring centre channel \n");
johnAlexander 5:92a861d48253 146
johnAlexander 7:bd1ddfbee3ef 147 /* Device Initialization and setting */
johnAlexander 7:bd1ddfbee3ef 148 status = Sensor->VL53LX_DataInit();
johnAlexander 7:bd1ddfbee3ef 149 status = Sensor->VL53LX_SetDistanceMode(VL53LX_DISTANCEMODE_LONG);
johnAlexander 7:bd1ddfbee3ef 150 status = Sensor->VL53LX_SetMeasurementTimingBudgetMicroSeconds( MEASUREMENTTIMING * 1000);
johnAlexander 7:bd1ddfbee3ef 151 status = Sensor->VL53LX_SmudgeCorrectionEnable(VL53LX_SMUDGE_CORRECTION_SINGLE);
johnAlexander 7:bd1ddfbee3ef 152 status = Sensor->VL53LX_SetXTalkCompensationEnable(1);
johnAlexander 5:92a861d48253 153
johnAlexander 5:92a861d48253 154 if (board->sensor_centre!= NULL ) {
johnAlexander 5:92a861d48253 155 printf("starting interrupt centre\n");
johnAlexander 7:bd1ddfbee3ef 156 int1 = new WaitForMeasurement(A2, &devCentre);
johnAlexander 7:bd1ddfbee3ef 157
johnAlexander 5:92a861d48253 158 status = Sensor->VL53LX_StartMeasurement();
johnAlexander 5:92a861d48253 159 printf("VL53L1_StartMeasurement %d \n",status);
johnAlexander 7:bd1ddfbee3ef 160 status = Sensor->VL53LX_ClearInterruptAndStartMeasurement();
johnAlexander 5:92a861d48253 161 }
johnAlexander 5:92a861d48253 162
johnAlexander 7:bd1ddfbee3ef 163
johnAlexander 7:bd1ddfbee3ef 164 VL53LX_MultiRangingData_t MultiRangingData;
johnAlexander 7:bd1ddfbee3ef 165 VL53LX_MultiRangingData_t *pMultiRangingData;
johnAlexander 7:bd1ddfbee3ef 166
johnAlexander 7:bd1ddfbee3ef 167 // infinite loop, waiting for interrupts to happen.
johnAlexander 7:bd1ddfbee3ef 168 // an interrupt being received is signaled by int_centre_result being non zero.
johnAlexander 7:bd1ddfbee3ef 169 // int_centre_result is set back to zero when interrupt processing is completed
johnAlexander 5:92a861d48253 170 while (1) {
johnAlexander 5:92a861d48253 171
johnAlexander 7:bd1ddfbee3ef 172 pMultiRangingData = &MultiRangingData;
johnAlexander 5:92a861d48253 173
johnAlexander 5:92a861d48253 174 wait_ms(10);
johnAlexander 5:92a861d48253 175
johnAlexander 5:92a861d48253 176 if (int_centre_result != 0) {
johnAlexander 7:bd1ddfbee3ef 177 status = Sensor->VL53LX_GetMultiRangingData( pMultiRangingData);
johnAlexander 7:bd1ddfbee3ef 178 int no_of_object_found = pMultiRangingData->NumberOfObjectsFound;
johnAlexander 5:92a861d48253 179 if (( no_of_object_found < 10 ) && ( no_of_object_found != 0 )) {
johnAlexander 7:bd1ddfbee3ef 180 for(int j = 0; j < no_of_object_found; j++) {
johnAlexander 5:92a861d48253 181 if (pMultiRangingData->RangeData[j].RangeStatus == 0) {
johnAlexander 5:92a861d48253 182 printf("centre\t status=%d, \t D=%5dmm, \t Signal=%2.2f Mcps, \t Ambient=%2.2f Mcps \n",
johnAlexander 5:92a861d48253 183 pMultiRangingData->RangeData[j].RangeStatus,
johnAlexander 5:92a861d48253 184 pMultiRangingData->RangeData[j].RangeMilliMeter,
johnAlexander 5:92a861d48253 185 (pMultiRangingData->RangeData[j].SignalRateRtnMegaCps/65535.0),
johnAlexander 5:92a861d48253 186 (pMultiRangingData->RangeData[j].AmbientRateRtnMegaCps/65535.0));
johnAlexander 5:92a861d48253 187 }
johnAlexander 5:92a861d48253 188 }
johnAlexander 5:92a861d48253 189 }
johnAlexander 5:92a861d48253 190 int_centre_result = 0;
johnAlexander 5:92a861d48253 191 wait_ms( MEASUREMENTTIMING );
johnAlexander 7:bd1ddfbee3ef 192 status = Sensor->VL53LX_ClearInterruptAndStartMeasurement();
charlesmn 0:c77591fc308d 193 }
johnAlexander 7:bd1ddfbee3ef 194 }
johnAlexander 5:92a861d48253 195
johnAlexander 7:bd1ddfbee3ef 196 printf("terminated");
johnAlexander 5:92a861d48253 197 }
charlesmn 0:c77591fc308d 198
johnAlexander 3:42c96c9c627b 199 #if (MBED_VERSION > 60300)
johnAlexander 7:bd1ddfbee3ef 200 extern "C" void wait_ms(int ms)
johnAlexander 7:bd1ddfbee3ef 201 {
johnAlexander 7:bd1ddfbee3ef 202 thread_sleep_for(ms);
johnAlexander 7:bd1ddfbee3ef 203 }
johnAlexander 3:42c96c9c627b 204 #endif