Skip to content

Commit d68bb33

Browse files
author
piclaw
committed
Fix clang-format CI: add .clang-format, update workflow, format code
1 parent 23dc309 commit d68bb33

21 files changed

+1136
-1177
lines changed

‎.clang-format‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
Language: Cpp
2+
BasedOnStyle: Google
3+
IndentWidth: 2
4+
ColumnLimit: 80
5+
AllowShortFunctionsOnASingleLine: Empty
6+
AllowShortIfStatementsOnASingleLine: false
7+
AllowShortLoopsOnASingleLine: false
8+
BinPackArguments: true
9+
BinPackParameters: true
10+
BreakBeforeBraces: Attach
11+
DerivePointerAlignment: false
12+
PointerAlignment: Left
13+
SpacesBeforeTrailingComments: 1

‎.github/workflows/githubci.yml‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,28 @@ name: Arduino Library CI
33
on: [pull_request, push, repository_dispatch]
44

55
jobs:
6+
clang-format:
7+
runs-on: ubuntu-latest
8+
9+
steps:
10+
- uses: actions/setup-python@v4
11+
with:
12+
python-version: '3.x'
13+
- uses: actions/checkout@v3
14+
- uses: actions/checkout@v3
15+
with:
16+
repository: adafruit/ci-arduino
17+
path: ci
18+
19+
- name: pre-install
20+
run: bash ci/actions_install.sh
21+
22+
- name: clang
23+
run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r .
24+
625
build:
726
runs-on: ubuntu-latest
27+
needs: clang-format
828

929
steps:
1030
- uses: actions/setup-python@v4

‎src/Adafruit_VL53L0X.cpp‎

Lines changed: 91 additions & 93 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@
3333
*/
3434

3535
#include "Adafruit_VL53L0X.h"
36+
3637
#include "vl53l0x_api_core.h"
3738

3839
#define VERSION_REQUIRED_MAJOR 1 ///< Required sensor major version
@@ -54,7 +55,7 @@
5455
@returns True if device is set up, false on any failure
5556
*/
5657
/**************************************************************************/
57-
boolean Adafruit_VL53L0X::begin(uint8_t i2c_addr, boolean debug, TwoWire *i2c,
58+
boolean Adafruit_VL53L0X::begin(uint8_t i2c_addr, boolean debug, TwoWire* i2c,
5859
VL53L0X_Sense_config_t vl_config) {
5960
uint32_t refSpadCount;
6061
uint8_t isApertureSpads;
@@ -237,79 +238,81 @@ boolean Adafruit_VL53L0X::configSensor(VL53L0X_Sense_config_t vl_config) {
237238
return false;
238239

239240
switch (vl_config) {
240-
case VL53L0X_SENSE_DEFAULT:
241-
// Taken directly from SDK vl5310x_SingleRanging_example.c
242-
// Maybe should convert to helper functions but...
243-
// Serial.println(" VL53L0X_SENSE_DEFAULT");
244-
if (Status == VL53L0X_ERROR_NONE) {
245-
Status = VL53L0X_SetLimitCheckEnable(
246-
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 1);
247-
}
241+
case VL53L0X_SENSE_DEFAULT:
242+
// Taken directly from SDK vl5310x_SingleRanging_example.c
243+
// Maybe should convert to helper functions but...
244+
// Serial.println(" VL53L0X_SENSE_DEFAULT");
245+
if (Status == VL53L0X_ERROR_NONE) {
246+
Status = VL53L0X_SetLimitCheckEnable(
247+
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 1);
248+
}
248249

249-
if (Status == VL53L0X_ERROR_NONE) {
250+
if (Status == VL53L0X_ERROR_NONE) {
251+
Status = VL53L0X_SetLimitCheckValue(
252+
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
253+
(FixPoint1616_t)(1.5 * 0.023 * 65536));
254+
}
255+
break;
256+
case VL53L0X_SENSE_LONG_RANGE:
257+
Serial.println(" VL53L0X_SENSE_LONG_RANGE");
250258
Status = VL53L0X_SetLimitCheckValue(
251-
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
252-
(FixPoint1616_t)(1.5 * 0.023 * 65536));
253-
}
254-
break;
255-
case VL53L0X_SENSE_LONG_RANGE:
256-
Serial.println(" VL53L0X_SENSE_LONG_RANGE");
257-
Status = VL53L0X_SetLimitCheckValue(
258-
pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
259-
(FixPoint1616_t)(0.1 * 65536));
260-
if (Status == VL53L0X_ERROR_NONE) {
261-
Status = VL53L0X_SetLimitCheckValue(pMyDevice,
262-
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
263-
(FixPoint1616_t)(60 * 65536));
264-
}
265-
if (Status == VL53L0X_ERROR_NONE) {
266-
Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 33000);
267-
}
259+
pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
260+
(FixPoint1616_t)(0.1 * 65536));
261+
if (Status == VL53L0X_ERROR_NONE) {
262+
Status = VL53L0X_SetLimitCheckValue(
263+
pMyDevice, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
264+
(FixPoint1616_t)(60 * 65536));
265+
}
266+
if (Status == VL53L0X_ERROR_NONE) {
267+
Status =
268+
VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 33000);
269+
}
268270

269-
if (Status == VL53L0X_ERROR_NONE) {
270-
Status = VL53L0X_SetVcselPulsePeriod(pMyDevice,
271-
VL53L0X_VCSEL_PERIOD_PRE_RANGE, 18);
272-
}
273-
if (Status == VL53L0X_ERROR_NONE) {
274-
Status = VL53L0X_SetVcselPulsePeriod(
275-
pMyDevice, VL53L0X_VCSEL_PERIOD_FINAL_RANGE, 14);
276-
}
277-
break;
278-
case VL53L0X_SENSE_HIGH_SPEED:
279-
// Serial.println(" VL53L0X_SENSE_HIGH_SPEED");
280-
Status = VL53L0X_SetLimitCheckValue(
281-
pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
282-
(FixPoint1616_t)(0.25 * 65536));
283-
if (Status == VL53L0X_ERROR_NONE) {
284-
Status = VL53L0X_SetLimitCheckValue(pMyDevice,
285-
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
286-
(FixPoint1616_t)(32 * 65536));
287-
}
288-
if (Status == VL53L0X_ERROR_NONE) {
289-
Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 30000);
290-
}
291-
break;
292-
case VL53L0X_SENSE_HIGH_ACCURACY:
293-
// increase timing budget to 200 ms
271+
if (Status == VL53L0X_ERROR_NONE) {
272+
Status = VL53L0X_SetVcselPulsePeriod(
273+
pMyDevice, VL53L0X_VCSEL_PERIOD_PRE_RANGE, 18);
274+
}
275+
if (Status == VL53L0X_ERROR_NONE) {
276+
Status = VL53L0X_SetVcselPulsePeriod(
277+
pMyDevice, VL53L0X_VCSEL_PERIOD_FINAL_RANGE, 14);
278+
}
279+
break;
280+
case VL53L0X_SENSE_HIGH_SPEED:
281+
// Serial.println(" VL53L0X_SENSE_HIGH_SPEED");
282+
Status = VL53L0X_SetLimitCheckValue(
283+
pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
284+
(FixPoint1616_t)(0.25 * 65536));
285+
if (Status == VL53L0X_ERROR_NONE) {
286+
Status = VL53L0X_SetLimitCheckValue(
287+
pMyDevice, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
288+
(FixPoint1616_t)(32 * 65536));
289+
}
290+
if (Status == VL53L0X_ERROR_NONE) {
291+
Status =
292+
VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 30000);
293+
}
294+
break;
295+
case VL53L0X_SENSE_HIGH_ACCURACY:
296+
// increase timing budget to 200 ms
294297

295-
if (Status == VL53L0X_ERROR_NONE) {
296-
setLimitCheckValue(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
297-
(FixPoint1616_t)(0.25 * 65536));
298-
}
299-
if (Status == VL53L0X_ERROR_NONE) {
300-
setLimitCheckValue(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
301-
(FixPoint1616_t)(18 * 65536));
302-
}
303-
if (Status == VL53L0X_ERROR_NONE) {
304-
setMeasurementTimingBudgetMicroSeconds(200000);
305-
}
306-
// Not sure about ignore threshold, try turnning it off...
307-
if (Status == VL53L0X_ERROR_NONE) {
308-
Status = VL53L0X_SetLimitCheckEnable(
309-
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
310-
}
298+
if (Status == VL53L0X_ERROR_NONE) {
299+
setLimitCheckValue(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
300+
(FixPoint1616_t)(0.25 * 65536));
301+
}
302+
if (Status == VL53L0X_ERROR_NONE) {
303+
setLimitCheckValue(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
304+
(FixPoint1616_t)(18 * 65536));
305+
}
306+
if (Status == VL53L0X_ERROR_NONE) {
307+
setMeasurementTimingBudgetMicroSeconds(200000);
308+
}
309+
// Not sure about ignore threshold, try turnning it off...
310+
if (Status == VL53L0X_ERROR_NONE) {
311+
Status = VL53L0X_SetLimitCheckEnable(
312+
pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
313+
}
311314

312-
break;
315+
break;
313316
}
314317

315318
return (Status == VL53L0X_ERROR_NONE);
@@ -326,7 +329,7 @@ boolean Adafruit_VL53L0X::configSensor(VL53L0X_Sense_config_t vl_config) {
326329
*/
327330
/**************************************************************************/
328331
VL53L0X_Error Adafruit_VL53L0X::getSingleRangingMeasurement(
329-
VL53L0X_RangingMeasurementData_t *RangingMeasurementData, boolean debug) {
332+
VL53L0X_RangingMeasurementData_t* RangingMeasurementData, boolean debug) {
330333
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
331334
FixPoint1616_t LimitCheckCurrent;
332335

@@ -413,7 +416,7 @@ VL53L0X_Error Adafruit_VL53L0X::stopMeasurement(boolean debug) {
413416
*/
414417
/**************************************************************************/
415418
VL53L0X_Error Adafruit_VL53L0X::getLimitCheckCurrent(
416-
uint8_t LimitCheckId, FixPoint1616_t *pLimitCheckCurrent, boolean debug) {
419+
uint8_t LimitCheckId, FixPoint1616_t* pLimitCheckCurrent, boolean debug) {
417420
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
418421
uint16_t intLimitCheckId = LimitCheckId;
419422

@@ -496,10 +499,9 @@ VL53L0X_Error Adafruit_VL53L0X::setInterruptThresholds(
496499
@returns status code
497500
*/
498501
/**************************************************************************/
499-
VL53L0X_Error
500-
Adafruit_VL53L0X::getInterruptThresholds(FixPoint1616_t *pThresholdLow,
501-
FixPoint1616_t *pThresholdHigh,
502-
boolean debug) {
502+
VL53L0X_Error Adafruit_VL53L0X::getInterruptThresholds(
503+
FixPoint1616_t* pThresholdLow, FixPoint1616_t* pThresholdHigh,
504+
boolean debug) {
503505
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
504506
if (Status == VL53L0X_ERROR_NONE) {
505507
if (debug) {
@@ -525,7 +527,7 @@ Adafruit_VL53L0X::getInterruptThresholds(FixPoint1616_t *pThresholdLow,
525527
@returns status code
526528
*/
527529
/**************************************************************************/
528-
VL53L0X_Error Adafruit_VL53L0X::getDeviceMode(VL53L0X_DeviceModes *pDeviceMode,
530+
VL53L0X_Error Adafruit_VL53L0X::getDeviceMode(VL53L0X_DeviceModes* pDeviceMode,
529531
boolean debug) {
530532
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
531533
if (Status == VL53L0X_ERROR_NONE) {
@@ -598,8 +600,8 @@ VL53L0X_Error Adafruit_VL53L0X::setGpioConfig(
598600
*/
599601
/**************************************************************************/
600602
VL53L0X_Error Adafruit_VL53L0X::getGpioConfig(
601-
VL53L0X_DeviceModes *pDeviceMode, VL53L0X_GpioFunctionality *pFunctionality,
602-
VL53L0X_InterruptPolarity *pPolarity, boolean debug) {
603+
VL53L0X_DeviceModes* pDeviceMode, VL53L0X_GpioFunctionality* pFunctionality,
604+
VL53L0X_InterruptPolarity* pPolarity, boolean debug) {
603605
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
604606
if (Status == VL53L0X_ERROR_NONE) {
605607
if (debug) {
@@ -626,7 +628,7 @@ VL53L0X_Error Adafruit_VL53L0X::getGpioConfig(
626628
*/
627629
/**************************************************************************/
628630
VL53L0X_Error Adafruit_VL53L0X::getRangingMeasurement(
629-
VL53L0X_RangingMeasurementData_t *RangingMeasurementData, boolean debug) {
631+
VL53L0X_RangingMeasurementData_t* RangingMeasurementData, boolean debug) {
630632
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
631633
FixPoint1616_t LimitCheckCurrent;
632634

@@ -665,7 +667,7 @@ VL53L0X_Error Adafruit_VL53L0X::getRangingMeasurement(
665667
*/
666668
/**************************************************************************/
667669
void Adafruit_VL53L0X::printRangeStatus(
668-
VL53L0X_RangingMeasurementData_t *pRangingMeasurementData) {
670+
VL53L0X_RangingMeasurementData_t* pRangingMeasurementData) {
669671
char buf[VL53L0X_MAX_STRING_LENGTH];
670672
uint8_t RangeStatus;
671673

@@ -711,7 +713,9 @@ uint16_t Adafruit_VL53L0X::readRange(void) {
711713
*/
712714
/**************************************************************************/
713715

714-
uint8_t Adafruit_VL53L0X::readRangeStatus(void) { return _rangeStatus; }
716+
uint8_t Adafruit_VL53L0X::readRangeStatus(void) {
717+
return _rangeStatus;
718+
}
715719

716720
/**************************************************************************/
717721
/*!
@@ -721,7 +725,6 @@ uint8_t Adafruit_VL53L0X::readRangeStatus(void) { return _rangeStatus; }
721725
/**************************************************************************/
722726

723727
boolean Adafruit_VL53L0X::startRange(void) {
724-
725728
/* This function will do a complete single ranging
726729
* Here we fix the mode! */
727730
// first lets set the device in SINGLE_Ranging mode
@@ -813,7 +816,6 @@ boolean Adafruit_VL53L0X::startRangeContinuous(uint16_t period_ms) {
813816
*/
814817
/**************************************************************************/
815818
void Adafruit_VL53L0X::stopRangeContinuous(void) {
816-
817819
Status = VL53L0X_StopMeasurement(pMyDevice);
818820

819821
// lets wait until that completes.
@@ -852,8 +854,8 @@ void Adafruit_VL53L0X::stopRangeContinuous(void) {
852854
@returns True if success
853855
*/
854856
/**************************************************************************/
855-
boolean
856-
Adafruit_VL53L0X::setMeasurementTimingBudgetMicroSeconds(uint32_t budget_us) {
857+
boolean Adafruit_VL53L0X::setMeasurementTimingBudgetMicroSeconds(
858+
uint32_t budget_us) {
857859
Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, budget_us);
858860
return (Status == VL53L0X_ERROR_NONE);
859861
}
@@ -881,9 +883,8 @@ uint32_t Adafruit_VL53L0X::getMeasurementTimingBudgetMicroSeconds() {
881883
@returns True if success
882884
*/
883885
/**************************************************************************/
884-
boolean
885-
Adafruit_VL53L0X::setVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType,
886-
uint8_t VCSELPulsePeriod) {
886+
boolean Adafruit_VL53L0X::setVcselPulsePeriod(
887+
VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriod) {
887888
Status =
888889
VL53L0X_SetVcselPulsePeriod(pMyDevice, VcselPeriodType, VCSELPulsePeriod);
889890
return (Status == VL53L0X_ERROR_NONE);
@@ -897,8 +898,8 @@ Adafruit_VL53L0X::setVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType,
897898
@returns the current pulse peried for the given type.
898899
*/
899900
/**************************************************************************/
900-
uint8_t
901-
Adafruit_VL53L0X::getVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType) {
901+
uint8_t Adafruit_VL53L0X::getVcselPulsePeriod(
902+
VL53L0X_VcselPeriod VcselPeriodType) {
902903
uint8_t cur_period;
903904
Status = VL53L0X_GetVcselPulsePeriod(pMyDevice, VcselPeriodType, &cur_period);
904905
return (cur_period);
@@ -933,7 +934,6 @@ boolean Adafruit_VL53L0X::setLimitCheckEnable(uint16_t LimitCheckId,
933934
*/
934935
/**************************************************************************/
935936
uint8_t Adafruit_VL53L0X::getLimitCheckEnable(uint16_t LimitCheckId) {
936-
937937
uint8_t cur_limit;
938938
Status = VL53L0X_GetLimitCheckEnable(pMyDevice, LimitCheckId, &cur_limit);
939939
return (cur_limit);
@@ -952,7 +952,6 @@ uint8_t Adafruit_VL53L0X::getLimitCheckEnable(uint16_t LimitCheckId) {
952952

953953
boolean Adafruit_VL53L0X::setLimitCheckValue(uint16_t LimitCheckId,
954954
FixPoint1616_t LimitCheckValue) {
955-
956955
Status = VL53L0X_SetLimitCheckValue(pMyDevice, LimitCheckId, LimitCheckValue);
957956
return (Status == VL53L0X_ERROR_NONE);
958957
}
@@ -966,7 +965,6 @@ boolean Adafruit_VL53L0X::setLimitCheckValue(uint16_t LimitCheckId,
966965
*/
967966
/**************************************************************************/
968967
FixPoint1616_t Adafruit_VL53L0X::getLimitCheckValue(uint16_t LimitCheckId) {
969-
970968
FixPoint1616_t LimitCheckValue;
971969
Status =
972970
VL53L0X_GetLimitCheckValue(pMyDevice, LimitCheckId, &LimitCheckValue);

0 commit comments

Comments
 (0)