[GS] Fix clang-tidy issues

Author: stojadin2701

.github/workflows/merge-criteria.yml

@@ -73,7 +73,7 @@ jobs:
     name: Build + Lint
     # We are running this on windows because the users get binaries compiled on windows.
     # The code should also be tested in a linux build.
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     strategy:
       fail-fast: false

ground_station/platformio.ini

@@ -109,6 +109,7 @@ debug_load_mode = always
 
 extra_scripts = 
   pre:pre_config.py
+  post:post_config.py
   upload_script.py
 
 upload_protocol = custom
@@ -129,4 +130,4 @@ check_src_filters =
   +<src/>
 # TODO: check_skip_packages should be removed once the clang-tidy command length is reduced.
 # Because of this flag clang-tidy complains it can't find library files such as "Arduino.h"
-check_skip_packages = yes
+; check_skip_packages = yes

ground_station/post_config.py

@@ -0,0 +1,10 @@
+Import("projenv")
+
+include_flags = []
+for path in projenv["CPPPATH"]:
+    if path != projenv["PROJECT_INCLUDE_DIR"]:
+        include_flags.append(["-isystem", path])
+
+projenv.Append(
+    CXXFLAGS = include_flags
+)

ground_station/pre_config.py

@@ -62,6 +62,8 @@ def src_file_config(env, node):
             "-Wformat-truncation=2",
             "-Wformat-overflow",
             "-Wformat-signedness",
+            "-Wattributes",
+            "-Wextra",
 
             "-Werror",
             ]

ground_station/src/USB.cpp

@@ -51,67 +51,72 @@
 #define USB_WEBUSB_ENABLED false
 #endif
 #ifndef USB_WEBUSB_URL
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define USB_WEBUSB_URL "https://espressif.github.io/arduino-esp32/webusb.html"
 #endif
 
 #if CFG_TUD_DFU_RUNTIME
 static uint16_t load_dfu_descriptor(uint8_t *dst, uint8_t *itf) {
 #define DFU_ATTRS (DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_CAN_UPLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
 
-  uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
+  const uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
   uint8_t descriptor[TUD_DFU_RT_DESC_LEN] = {
       // Interface number, string index, attributes, detach timeout, transfer size */
-      TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700, 64)};
+      // NOLINTNEXTLINE(hicpp-signed-bitwise)
+      TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700U, 64U)};
   *itf += 1;
   memcpy(dst, descriptor, TUD_DFU_RT_DESC_LEN);
   return TUD_DFU_RT_DESC_LEN;
 }
 // Invoked on DFU_DETACH request to reboot to the bootloader
-void tud_dfu_runtime_reboot_to_dfu_cb(void) {
+void tud_dfu_runtime_reboot_to_dfu_cb() {
   // MODIFICATION: If DFU Detach request gets received, UF2-Bootloader instead of ROM-Bootloader gets launched!
 
   // usb_persist_restart(RESTART_BOOTLOADER_DFU);
   const uint16_t APP_REQUEST_UF2_RESET_HINT = 0x11F2;
   esp_reset_reason();
-  esp_reset_reason_set_hint((esp_reset_reason_t)APP_REQUEST_UF2_RESET_HINT);
+  esp_reset_reason_set_hint(static_cast<esp_reset_reason_t>(APP_REQUEST_UF2_RESET_HINT));
   esp_restart();
 }
 #endif /* CFG_TUD_DFU_RUNTIME */
 
+// NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables)
 ESP_EVENT_DEFINE_BASE(ARDUINO_USB_EVENTS);
-
-static esp_event_loop_handle_t arduino_usb_event_loop_handle = NULL;
+static esp_event_loop_handle_t arduino_usb_event_loop_handle = nullptr;
+// NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables)
 
 esp_err_t arduino_usb_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data,
                                  size_t event_data_size, TickType_t ticks_to_wait) {
-  if (arduino_usb_event_loop_handle == NULL) {
+  if (arduino_usb_event_loop_handle == nullptr) {
     return ESP_FAIL;
   }
   return esp_event_post_to(arduino_usb_event_loop_handle, event_base, event_id, event_data, event_data_size,
                            ticks_to_wait);
 }
 esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id,
                                                   esp_event_handler_t event_handler, void *event_handler_arg) {
-  if (arduino_usb_event_loop_handle == NULL) {
+  if (arduino_usb_event_loop_handle == nullptr) {
     return ESP_FAIL;
   }
   return esp_event_handler_register_with(arduino_usb_event_loop_handle, event_base, event_id, event_handler,
                                          event_handler_arg);
 }
 
+// NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables)
 static bool tinyusb_device_mounted = false;
 static bool tinyusb_device_suspended = false;
+// NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables)
 
 // Invoked when device is mounted (configured)
-void tud_mount_cb(void) {
+void tud_mount_cb() {
   tinyusb_device_mounted = true;
   arduino_usb_event_data_t p;
   arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STARTED_EVENT, &p, sizeof(arduino_usb_event_data_t),
                          portMAX_DELAY);
 }
 
 // Invoked when device is unmounted
-void tud_umount_cb(void) {
+void tud_umount_cb() {
   tinyusb_device_mounted = false;
   arduino_usb_event_data_t p;
   arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, &p, sizeof(arduino_usb_event_data_t),
@@ -129,7 +134,7 @@ void tud_suspend_cb(bool remote_wakeup_en) {
 }
 
 // Invoked when usb bus is resumed
-void tud_resume_cb(void) {
+void tud_resume_cb() {
   tinyusb_device_suspended = false;
   arduino_usb_event_data_t p;
   arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_RESUME_EVENT, &p, sizeof(arduino_usb_event_data_t),
@@ -155,22 +160,22 @@ ESPUSB::ESPUSB(size_t task_stack_size, uint8_t event_task_priority)
       _started(false),
       _task_stack_size(task_stack_size),
       _event_task_priority(event_task_priority) {
-  if (!arduino_usb_event_loop_handle) {
-    esp_event_loop_args_t event_task_args = {.queue_size = 5,
-                                             .task_name = "arduino_usb_events",
-                                             .task_priority = _event_task_priority,
-                                             .task_stack_size = _task_stack_size,
-                                             .task_core_id = tskNO_AFFINITY};
+  if (arduino_usb_event_loop_handle == nullptr) {
+    const esp_event_loop_args_t event_task_args = {.queue_size = 5,
+                                                   .task_name = "arduino_usb_events",
+                                                   .task_priority = _event_task_priority,
+                                                   .task_stack_size = _task_stack_size,
+                                                   .task_core_id = tskNO_AFFINITY};
     if (esp_event_loop_create(&event_task_args, &arduino_usb_event_loop_handle) != ESP_OK) {
       log_e("esp_event_loop_create failed");
     }
   }
 }
 
 ESPUSB::~ESPUSB() {
-  if (arduino_usb_event_loop_handle) {
+  if (arduino_usb_event_loop_handle != nullptr) {
     esp_event_loop_delete(arduino_usb_event_loop_handle);
-    arduino_usb_event_loop_handle = NULL;
+    arduino_usb_event_loop_handle = nullptr;
   }
 }
 
@@ -202,6 +207,7 @@ void ESPUSB::onEvent(arduino_usb_event_t event, esp_event_handler_t callback) {
 
 ESPUSB::operator bool() const { return _started && tinyusb_device_mounted; }
 
+// NOLINTBEGIN(readability-convert-member-functions-to-static,readability-make-member-function-const)
 bool ESPUSB::enableDFU() {
 #if CFG_TUD_DFU_RUNTIME
   return tinyusb_enable_interface(USB_INTERFACE_DFU, TUD_DFU_RT_DESC_LEN, load_dfu_descriptor) == ESP_OK;
@@ -215,71 +221,71 @@ bool ESPUSB::VID(uint16_t v) {
   }
   return !_started;
 }
-uint16_t ESPUSB::VID(void) { return vid; }
+uint16_t ESPUSB::VID() { return vid; }
 
 bool ESPUSB::PID(uint16_t p) {
   if (!_started) {
     pid = p;
   }
   return !_started;
 }
-uint16_t ESPUSB::PID(void) { return pid; }
+uint16_t ESPUSB::PID() { return pid; }
 
 bool ESPUSB::firmwareVersion(uint16_t version) {
   if (!_started) {
     fw_version = version;
   }
   return !_started;
 }
-uint16_t ESPUSB::firmwareVersion(void) { return fw_version; }
+uint16_t ESPUSB::firmwareVersion() { return fw_version; }
 
 bool ESPUSB::usbVersion(uint16_t version) {
   if (!_started) {
     usb_version = version;
   }
   return !_started;
 }
-uint16_t ESPUSB::usbVersion(void) { return usb_version; }
+uint16_t ESPUSB::usbVersion() { return usb_version; }
 
 bool ESPUSB::usbPower(uint16_t mA) {
   if (!_started) {
     usb_power_ma = mA;
   }
   return !_started;
 }
-uint16_t ESPUSB::usbPower(void) { return usb_power_ma; }
+uint16_t ESPUSB::usbPower() { return usb_power_ma; }
 
 bool ESPUSB::usbClass(uint8_t _class) {
   if (!_started) {
     usb_class = _class;
   }
   return !_started;
 }
-uint8_t ESPUSB::usbClass(void) { return usb_class; }
+uint8_t ESPUSB::usbClass() { return usb_class; }
 
 bool ESPUSB::usbSubClass(uint8_t subClass) {
   if (!_started) {
     usb_subclass = subClass;
   }
   return !_started;
 }
-uint8_t ESPUSB::usbSubClass(void) { return usb_subclass; }
+uint8_t ESPUSB::usbSubClass() { return usb_subclass; }
 
 bool ESPUSB::usbProtocol(uint8_t protocol) {
   if (!_started) {
     usb_protocol = protocol;
   }
   return !_started;
 }
-uint8_t ESPUSB::usbProtocol(void) { return usb_protocol; }
+uint8_t ESPUSB::usbProtocol() { return usb_protocol; }
 
 bool ESPUSB::usbAttributes(uint8_t attr) {
   if (!_started) {
     usb_attributes = attr;
   }
   return !_started;
 }
-uint8_t ESPUSB::usbAttributes(void) { return usb_attributes; }
+uint8_t ESPUSB::usbAttributes() { return usb_attributes; }
 
 bool ESPUSB::webUSB(bool enabled) {
   if (!_started) {
@@ -290,40 +296,43 @@ bool ESPUSB::webUSB(bool enabled) {
   }
   return !_started;
 }
-bool ESPUSB::webUSB(void) { return webusb_enabled; }
+bool ESPUSB::webUSB() { return webusb_enabled; }
 
 bool ESPUSB::productName(const char *name) {
   if (!_started) {
     product_name = name;
   }
   return !_started;
 }
-const char *ESPUSB::productName(void) { return product_name.c_str(); }
+const char *ESPUSB::productName() { return product_name.c_str(); }
 
 bool ESPUSB::manufacturerName(const char *name) {
   if (!_started) {
     manufacturer_name = name;
   }
   return !_started;
 }
-const char *ESPUSB::manufacturerName(void) { return manufacturer_name.c_str(); }
+const char *ESPUSB::manufacturerName() { return manufacturer_name.c_str(); }
 
 bool ESPUSB::serialNumber(const char *name) {
   if (!_started) {
     serial_number = name;
   }
   return !_started;
 }
-const char *ESPUSB::serialNumber(void) { return serial_number.c_str(); }
+const char *ESPUSB::serialNumber() { return serial_number.c_str(); }
 
 bool ESPUSB::webUSBURL(const char *name) {
   if (!_started) {
     webusb_url = name;
   }
   return !_started;
 }
-const char *ESPUSB::webUSBURL(void) { return webusb_url.c_str(); }
+const char *ESPUSB::webUSBURL() { return webusb_url.c_str(); }
+
+// NOLINTEND(readability-convert-member-functions-to-static,readability-make-member-function-const)
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 ESPUSB USB;
 
 #endif /* CONFIG_TINYUSB_ENABLED */