chore: Update components to support ESP-IDF v6.0

components/adc/include/adc_types.hpp

@@ -12,7 +12,7 @@ struct AdcConfig {
   adc_unit_t unit;       /**< Which adc unit is this channel associated with, e.g. ADC_UNIT_1. */
   adc_channel_t channel; /**< The actual channel, e.g. ADC_CHANNEL_2. */
   adc_atten_t
-      attenuation; /**< The attenuation associated with this channel, e.g. ADC_ATTEN_DB_11. */
+      attenuation; /**< The attenuation associated with this channel, e.g. ADC_ATTEN_DB_12. */
 };
 
 static bool operator!=(const AdcConfig &lhs, const AdcConfig &rhs) {

components/ads7138/example/main/ads7138_example.cpp

@@ -67,8 +67,9 @@ using namespace std::chrono_literals;
 // change the digital output value by pressing the button on the joystick.
 static QueueHandle_t gpio_evt_queue;
 
+// cppcheck-suppress constParameterCallback
 static void gpio_isr_handler(void *arg) {
-  uint32_t gpio_num = (uint32_t)arg;
+  uint32_t gpio_num = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(arg));
   xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
 }
 
@@ -129,7 +130,8 @@ extern "C" void app_main(void) {
 
     // install gpio isr service
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(ALERT_PIN, gpio_isr_handler, (void *)ALERT_PIN);
+    gpio_isr_handler_add(ALERT_PIN, gpio_isr_handler,
+                         reinterpret_cast<void *>(static_cast<uintptr_t>(ALERT_PIN)));
 
     // start the gpio task
     auto alert_task = espp::Task::make_unique({

components/ads7138/include/ads7138.hpp

@@ -1510,7 +1510,7 @@ class Ads7138 : public BasePeripheral<> {
   }
 
   void write_two_(Register reg, uint16_t value, std::error_code &ec) {
-    write_block_(reg, (uint8_t *)&value, 2, ec);
+    write_block_(reg, reinterpret_cast<uint8_t *>(&value), 2, ec);
   }
 
   void write_block_(Register reg, const uint8_t *data, uint8_t len, std::error_code &ec) {

components/bldc_driver/CMakeLists.txt

@@ -1,4 +1,4 @@
 idf_component_register(
   INCLUDE_DIRS "include"
   SRC_DIRS "src"
-  REQUIRES base_component driver)
+  REQUIRES base_component driver esp_driver_gpio esp_driver_mcpwm)

components/bldc_driver/include/bldc_driver.hpp

@@ -6,6 +6,14 @@
 
 #include "driver/gpio.h"
 #include "driver/mcpwm_prelude.h"
+#include "esp_idf_version.h"
+#ifndef ESP_IDF_VERSION_VAL
+#define ESP_IDF_VERSION_VAL(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#endif
+#ifndef ESP_IDF_VERSION
+#define ESP_IDF_VERSION ESP_IDF_VERSION_VAL(0, 0, 0)
+#endif
+#include "soc/soc_caps.h"
 
 #include "base_component.hpp"
 
@@ -260,10 +268,12 @@ class BldcDriver : public BaseComponent {
   static int GROUP_ID;
 
   void init(const Config &config) {
+#if defined(SOC_MCPWM_GROUPS)
     if (GROUP_ID >= SOC_MCPWM_GROUPS) {
       GROUP_ID = 0;
       logger_.error("Exceeded max number of MCPWM groups ({}), resetting to 0", SOC_MCPWM_GROUPS);
     }
+#endif
     configure_enable_gpio();
     configure_timer();
     configure_operators();
@@ -324,8 +334,10 @@ class BldcDriver : public BaseComponent {
     gpio_fault_config.gpio_num = (gpio_num_t)gpio_fault_;
     gpio_fault_config.group_id = GROUP_ID;
     gpio_fault_config.flags.active_level = 1; // high level means fault, refer to TMC6300 datasheet
-    gpio_fault_config.flags.pull_down = true; // internally pull down
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)
+    gpio_fault_config.flags.pull_down = true;    // internally pull down
     gpio_fault_config.flags.io_loop_back = true; // enable loop back to GPIO input
+#endif
     ESP_ERROR_CHECK(mcpwm_new_gpio_fault(&gpio_fault_config, &fault_handle_));
 
     logger_.info("Set brake mode on the fault event");

components/chsc6x/example/main/chsc6x_example.cpp

@@ -50,10 +50,6 @@ extern "C" void app_main(void) {
       uint8_t num_touch_points = 0;
       uint16_t x = 0, y = 0;
       chsc6x.get_touch_point(&num_touch_points, &x, &y);
-      if (ec) {
-        fmt::print("Could not get touch point\n");
-        return false;
-      }
       fmt::print("num_touch_points: {}, x: {}, y: {}\n", num_touch_points, x, y);
       // NOTE: sleeping in this way allows the sleep to exit early when the
       // task is being stopped / destroyed

components/cli/CMakeLists.txt

@@ -1,4 +1,14 @@
+include($ENV{IDF_PATH}/tools/cmake/version.cmake)
+
+set(cli_requires driver esp_driver_uart esp_driver_usb_serial_jtag vfs logger)
+
+if(IDF_VERSION_MAJOR GREATER_EQUAL 6)
+  list(APPEND cli_requires esp_stdio esp_usb_cdc_rom_console)
+else()
+  list(APPEND cli_requires esp_vfs_console)
+endif()
+
 idf_component_register(
   INCLUDE_DIRS "include" "detail/cli/include"
   SRC_DIRS "src"
-  REQUIRES driver esp_driver_uart esp_driver_usb_serial_jtag vfs esp_vfs_console logger)
+  REQUIRES ${cli_requires})

components/cli/include/cli.hpp

@@ -15,7 +15,17 @@
 
 #include "esp_vfs_cdcacm.h"
 #include "esp_vfs_dev.h"
+
+#include "esp_idf_version.h"
+#ifndef ESP_IDF_VERSION_VAL
+#define ESP_IDF_VERSION_VAL(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#endif
+#ifndef ESP_IDF_VERSION
+#define ESP_IDF_VERSION ESP_IDF_VERSION_VAL(0, 0, 0)
+#endif
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)
 #include "esp_vfs_usb_serial_jtag.h"
+#endif
 
 #include "line_input.hpp"
 

components/cst816/example/main/cst816_example.cpp

@@ -53,10 +53,6 @@ extern "C" void app_main(void) {
       uint8_t num_touch_points = 0;
       uint16_t x = 0, y = 0;
       cst816.get_touch_point(&num_touch_points, &x, &y);
-      if (ec) {
-        fmt::print("Could not get touch point\n");
-        return false;
-      }
       fmt::print("num_touch_points: {}, x: {}, y: {}\n", num_touch_points, x, y);
       // NOTE: sleeping in this way allows the sleep to exit early when the
       // task is being stopped / destroyed

components/cst816/include/cst816.hpp

@@ -44,7 +44,8 @@ class Cst816 : public BasePeripheral<std::uint8_t> {
   bool update(std::error_code &ec) {
     bool new_data = false;
     Data data{};
-    read_many_from_register((uint8_t)Registers::DATA_START, (uint8_t *)&data, sizeof(data), ec);
+    read_many_from_register(static_cast<uint8_t>(Registers::DATA_START),
+                            reinterpret_cast<uint8_t *>(&data), sizeof(data), ec);
     if (ec)
       return false;
 

components/encoder/CMakeLists.txt

@@ -1,3 +1,3 @@
 idf_component_register(
   INCLUDE_DIRS "include"
-  REQUIRES base_component driver)
+  REQUIRES base_component driver esp_driver_pcnt)

components/esp-box/CMakeLists.txt

@@ -1,6 +1,6 @@
 idf_component_register(
   INCLUDE_DIRS "include"
   SRC_DIRS "src"
-  REQUIRES driver base_component codec display display_drivers i2c input_drivers interrupt gt911 task tt21100 icm42607
+  REQUIRES driver esp_driver_i2s base_component codec display display_drivers i2c input_drivers interrupt gt911 task tt21100 icm42607
   REQUIRED_IDF_TARGETS "esp32s3"
   )

components/esp-box/example/main/esp_box_example.cpp

@@ -390,9 +390,7 @@ static bool load_audio(size_t &out_size, size_t &out_sample_rate) {
 
   // load the audio data. these are configured in the CMakeLists.txt file
 
-  // cppcheck-suppress syntaxError
   extern const uint8_t click_wav_start[] asm("_binary_click_wav_start");
-  // cppcheck-suppress syntaxError
   extern const uint8_t click_wav_end[] asm("_binary_click_wav_end");
   audio_bytes = std::vector<uint8_t>(click_wav_start, click_wav_end);
   // ensure we have at least a wav header

components/esp32-timer-cam/CMakeLists.txt

@@ -1,6 +1,6 @@
 idf_component_register(
   INCLUDE_DIRS "include"
   SRC_DIRS "src"
-  REQUIRES driver adc base_component bm8563 i2c interrupt led math task
+  REQUIRES driver esp_driver_i2s esp_driver_spi adc base_component bm8563 i2c interrupt led math task
   REQUIRED_IDF_TARGETS "esp32"
   )

components/file_system/example/main/file_system_example.cpp

@@ -3,6 +3,14 @@
 #include <thread>
 #include <vector>
 
+#include "esp_idf_version.h"
+#ifndef ESP_IDF_VERSION_VAL
+#define ESP_IDF_VERSION_VAL(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#endif
+#ifndef ESP_IDF_VERSION
+#define ESP_IDF_VERSION ESP_IDF_VERSION_VAL(0, 0, 0)
+#endif
+
 #include "logger.hpp"
 
 #include "file_system.hpp"

components/format/include/format.hpp

@@ -11,3 +11,13 @@
 #include <fmt/ostream.h>
 #include <fmt/ranges.h>
 #include <fmt/std.h>
+
+#if !FMT_USE_INT128
+namespace fmt {
+inline namespace v12 {
+namespace detail {
+constexpr auto operator~(const uint128 &value) -> uint128 { return {~value.high(), ~value.low()}; }
+} // namespace detail
+} // namespace v12
+} // namespace fmt
+#endif

components/ftp/include/ftp_client_session.hpp

@@ -383,7 +383,7 @@ class FtpClientSession : public BaseComponent {
   }
 
   bool parse_ftp_command(std::string_view request, std::string_view &command,
-                         std::string_view &arguments) {
+                         std::string_view &arguments) const {
     // parses the command from the FTP client's request. The command is the
     // first word in the request. The command is case insensitive.
     // The command is followed by a space and then the arguments.

components/gfps_service/src/nearby_ble.cpp

@@ -98,12 +98,12 @@ int espp::gfps::ble_gap_event_handler(ble_gap_event *event, void *arg) {
     if (pairing_succeeded) {
       logger.info("Pairing succeeded with {}", addr.toString());
       if (g_bt_interface) {
-        g_bt_interface->on_paired(uint64_t(addr));
+        g_bt_interface->on_paired(static_cast<uint64_t>(addr));
       }
     } else {
       logger.error("Pairing failed with {}", addr.toString());
       if (g_bt_interface) {
-        g_bt_interface->on_pairing_failed(uint64_t(addr));
+        g_bt_interface->on_pairing_failed(static_cast<uint64_t>(addr));
       }
     }
     // set the IO capability of the device (GFPS uses the passkey through a
@@ -129,7 +129,7 @@ uint64_t nearby_platform_GetBleAddress() {
   // explicitly get the random address here, since the GetPublicAddress function
   // will call NimBLEDevice::getAddress() which will return the public address
   uint64_t address = 0;
-  auto rc = ble_hs_id_copy_addr(BLE_ADDR_RANDOM, (uint8_t *)&address, nullptr);
+  auto rc = ble_hs_id_copy_addr(BLE_ADDR_RANDOM, reinterpret_cast<uint8_t *>(&address), nullptr);
   if (rc != 0) {
     logger.error("Failed to get ble address");
     return 0;
@@ -205,7 +205,7 @@ nearby_platform_status nearby_platform_GattNotify(uint64_t peer_address,
 // interval - Advertising interval code.
 nearby_platform_status nearby_platform_SetAdvertisement(const uint8_t *payload, size_t length,
                                                         nearby_fp_AvertisementInterval interval) {
-  logger.info("Setting advertisement, interval code: {}", (int)interval);
+  logger.info("Setting advertisement, interval code: {}", static_cast<int>(interval));
 
   // For information of the contents of the payload, see:
   // https://btprodspecificationrefs.blob.core.windows.net/assigned-numbers/Assigned%20Number%20Types/Assigned_Numbers.pdf
@@ -246,7 +246,7 @@ uint64_t nearby_platform_GetPublicAddress() {
 #if CONFIG_BT_NIMBLE_ENABLED
   auto address = NimBLEDevice::getAddress();
   logger.info("GetPublicAddress: {}", address.toString());
-  return uint64_t(address);
+  return static_cast<uint64_t>(address);
 #else
   return 0;
 #endif // CONFIG_BT_NIMBLE_ENABLED

components/gt911/example/main/gt911_example.cpp

@@ -57,10 +57,6 @@ extern "C" void app_main(void) {
       uint8_t num_touch_points = 0;
       uint16_t x = 0, y = 0;
       gt911.get_touch_point(&num_touch_points, &x, &y);
-      if (ec) {
-        fmt::print("Could not get touch point\n");
-        return false;
-      }
       fmt::print("num_touch_points: {}, x: {}, y: {}\n", num_touch_points, x, y);
       // NOTE: sleeping in this way allows the sleep to exit early when the
       // task is being stopped / destroyed

components/gt911/include/gt911.hpp

@@ -71,7 +71,7 @@ class Gt911 : public BasePeripheral<std::uint16_t> {
         if (ec)
           return false;
         // convert the data pointer to a GTPoint*
-        const GTPoint *point = (GTPoint *)&data[0];
+        const auto *point = reinterpret_cast<const GTPoint *>(&data[0]);
         x_ = point->x;
         y_ = point->y;
         logger_.debug("Touch at ({}, {})", x_, y_);

components/hid-rp/include/hid-rp-gamepad.hpp

@@ -59,7 +59,7 @@ class GamepadInputReport : public hid::report::base<hid::report::type::INPUT, RE
   using Hat = espp::gamepad::Hat;
 
   /// Construct a new Gamepad Input Report object
-  constexpr GamepadInputReport() = default;
+  constexpr GamepadInputReport() { reset(); }
 
   /// Reset the gamepad inputs
   constexpr void reset() {

components/hid-rp/include/hid-rp-playstation.hpp

@@ -775,8 +775,8 @@ class PlaystationDualsenseBLEComplexInputReport
     std::fill(trigger_axes.begin(), trigger_axes.end(), trigger_center);
     std::fill(buttons.raw.begin(), buttons.raw.end(), 0);
     std::fill(vendor_defined.raw.begin(), vendor_defined.raw.end(), 0);
-    timestamp = prev_timestamp; // cppcheck-suppress redundantAssignment
-    counter = prev_counter;     // cppcheck-suppress redundantAssignment
+    timestamp = prev_timestamp;
+    counter = prev_counter;
     vendor_defined.coarse_timestamp = prev_coarse_timestamp;
     vendor_defined.fine_timestamp1 = prev_fine_timestamp1;
     vendor_defined.fine_timestamp2 = prev_fine_timestamp2;

components/hid-rp/include/hid-rp-switch-pro.hpp

@@ -183,15 +183,18 @@ class SwitchProGamepadInputReport : public hid::report::base<hid::report::type::
 
 public:
   /// Construct a new Gamepad Input Report object
-  constexpr SwitchProGamepadInputReport() = default;
+  constexpr SwitchProGamepadInputReport()
+      : raw_report{} {
+    reset();
+  }
 
   /// Reset the gamepad inputs
   constexpr void reset() {
     uint8_t prev_counter = counter;
     // fill all 0s
     std::fill(raw_report, raw_report + sizeof(raw_report), 0);
     // now set the counter to the previous value
-    counter = prev_counter; // cppcheck-suppress redundantAssignment
+    counter = prev_counter;
     // set the joysticks to 0 since their config may not put them at 0
     set_left_joystick(0, 0);
     set_right_joystick(0, 0);

components/hid-rp/include/hid-rp-xbox.hpp

@@ -152,7 +152,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
   static constexpr std::size_t num_data_bytes = sizeof(XboxRumbleOutputReport);
 
   /// Construct a new Xbox Rumble Output Report object
-  constexpr XboxRumbleOutputReport() = default;
+  constexpr XboxRumbleOutputReport() { reset(); }
 
   /// Reset the rumble effect
   constexpr void reset() {
@@ -165,7 +165,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
 
   /// Get the enabled mask for the rumble motors
   /// \return The enabled mask for the rumble motors
-  constexpr auto get_enabled() { return enabled; }
+  constexpr auto get_enabled() const { return enabled; }
 
   /// Set the enabled mask for the rumble motors
   /// \param new_enabled The enabled mask for the rumble motors
@@ -174,7 +174,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
   /// Get the magnitude of the rumble effect for the specified motor
   /// \param motor The motor for which you want to get the magnitude.
   /// \return The magnitude of the rumble effect for the specified motor.
-  constexpr auto get_magnitude(std::size_t motor) { return magnitude[motor]; }
+  constexpr auto get_magnitude(std::size_t motor) const { return magnitude[motor]; }
 
   /// Set the magnitude of the rumble effect for the specified motor
   /// \param motor The motor for which you want to set the magnitude.
@@ -192,7 +192,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
 
   /// Get the duration of the rumble effect
   /// \return The duration of the rumble effect
-  constexpr auto get_duration() { return duration; }
+  constexpr auto get_duration() const { return duration; }
 
   /// Set the duration of the rumble effect
   /// \param value The duration of the rumble effect.
@@ -201,7 +201,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
 
   /// Get the start delay of the rumble effect
   /// \return The start delay of the rumble effect
-  constexpr auto get_start_delay() { return start_delay; }
+  constexpr auto get_start_delay() const { return start_delay; }
 
   /// Set the start delay of the rumble effect
   /// \param value The start delay of the rumble effect.
@@ -210,7 +210,7 @@ class XboxRumbleOutputReport : public hid::report::base<hid::report::type::OUTPU
 
   /// Get the loop count of the rumble effect
   /// \return The loop count of the rumble effect
-  constexpr auto get_loop_count() { return loop_count; }
+  constexpr auto get_loop_count() const { return loop_count; }
 
   /// Set the loop count of the rumble effect
   /// \param value The loop count of the rumble effect.