feat(drv2605): Add support for calibration and other modes / controls (#456)

* feat(drv2605): Add support for calibration and other modes / controls

* update readme and finalize impl some more

* readme: update

Author: finger563

components/drv2605/example/README.md

@@ -6,6 +6,17 @@ eccentric rotating mass (ERM) haptic motors.
 
 ![image](https://user-images.githubusercontent.com/213467/225453151-eeba4c4f-7070-4e87-9aa6-741f8a2400ca.png)
 
+<!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-refresh-toc -->
+**Table of Contents**
+
+- [Drv2605 Example](#drv2605-example)
+  - [How to use example](#how-to-use-example)
+    - [Hardware Required](#hardware-required)
+    - [Build and Flash](#build-and-flash)
+    - [Output](#output)
+
+<!-- markdown-toc end -->
+
 ## How to use example
 
 ### Hardware Required
@@ -17,6 +28,8 @@ The sample has code for both ERM and LRA, but make sure to update the call to
 `drv2605.select_library(...)` depending on which type of motor you have (ERM is
 1-5, LRA is 6).
 
+This sample also shows how to configure and run motor calibration.
+
 ### Build and Flash
 
 Build the project and flash it to the board, then run monitor tool to view serial output:
@@ -31,3 +44,7 @@ idf.py -p PORT flash monitor
 
 See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
 
+### Output
+
+![CleanShot 2025-06-12 at 11 16 22](https://github.com/user-attachments/assets/cc996d12-fa8e-4c20-8267-b3f1b912c1fe)
+

components/drv2605/example/main/drv2605_example.cpp

@@ -13,49 +13,64 @@ extern "C" void app_main(void) {
   static espp::Logger logger({.tag = "drv2605 example", .level = espp::Logger::Verbosity::INFO});
   // This example shows using the i2c haptic motor driver (drv2605)
   {
-    logger.info("Running i2c adc example!");
+    logger.info("Starting!");
     //! [drv2605 example]
     // make the I2C that we'll use to communicate
     espp::I2c i2c({
         .port = I2C_NUM_1,
         .sda_io_num = (gpio_num_t)CONFIG_EXAMPLE_I2C_SDA_GPIO,
         .scl_io_num = (gpio_num_t)CONFIG_EXAMPLE_I2C_SCL_GPIO,
     });
+
+    using Driver = espp::Drv2605;
+
     // make the actual drv2605 class
-    espp::Drv2605 drv2605(espp::Drv2605::Config{
-        .device_address = espp::Drv2605::DEFAULT_ADDRESS,
+    Driver drv2605(Driver::Config{
+        .device_address = Driver::DEFAULT_ADDRESS,
         .write = std::bind(&espp::I2c::write, &i2c, std::placeholders::_1, std::placeholders::_2,
                            std::placeholders::_3),
         .read_register =
             std::bind(&espp::I2c::read_at_register, &i2c, std::placeholders::_1,
                       std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
-        .motor_type = espp::Drv2605::MotorType::LRA});
+        .motor_type = Driver::MotorType::LRA,
+        .log_level = espp::Logger::Verbosity::INFO,
+    });
     std::error_code ec;
     // we're using an ERM motor, so select an ERM library (1-5).
     // drv2605.select_library(1, ec);
     // we're using an LRA motor, so select an LRA library (6).
-    drv2605.select_library(espp::Drv2605::Library::LRA, ec);
+    drv2605.select_library(Driver::Library::LRA, ec);
     if (ec) {
       logger.error("select library failed: {}", ec.message());
     }
+
+    // do the calibration for the LRA motor
+    Driver::LraCalibrationSettings lra_calibration_settings{};
+    lra_calibration_settings.rated_voltage = 255;
+    lra_calibration_settings.overdrive_clamp = 255;
+    lra_calibration_settings.drive_time = Driver::lra_freq_to_drive_time(200.0f);
+    Driver::CalibratedData calibrated_data;
+    if (!drv2605.calibrate(lra_calibration_settings, calibrated_data, ec)) {
+      logger.error("calibration failed: {}", ec.message());
+      return;
+    }
+    logger.info("calibration complete: {}", calibrated_data);
+
     // make the task which will cycle through all the waveforms
     auto task_fn = [&drv2605](std::mutex &m, std::condition_variable &cv) {
-      static auto start = std::chrono::high_resolution_clock::now();
-      auto now = std::chrono::high_resolution_clock::now();
-      auto elapsed = std::chrono::duration<float>(now - start).count();
       static uint8_t waveform = 0;
       std::error_code ec;
       drv2605.stop(ec);
       if (ec) {
         logger.error("stop failed: {}", ec.message());
         return false;
       }
-      drv2605.set_waveform(0, (espp::Drv2605::Waveform)waveform, ec);
+      drv2605.set_waveform(0, (Driver::Waveform)waveform, ec);
       if (ec) {
         logger.error("set waveform failed: {}", ec.message());
         return false;
       }
-      drv2605.set_waveform(1, espp::Drv2605::Waveform::END, ec);
+      drv2605.set_waveform(1, Driver::Waveform::END, ec);
       if (ec) {
         logger.error("set waveform failed: {}", ec.message());
         return false;
@@ -66,10 +81,10 @@ extern "C" void app_main(void) {
         return false;
       }
       waveform++;
-      if (waveform > (uint8_t)espp::Drv2605::Waveform::MAX) {
+      if (waveform > (uint8_t)Driver::Waveform::MAX) {
         waveform = 0;
       }
-      logger.info("{:.3f}, {}", elapsed, waveform);
+      logger.info("{}", waveform);
       // NOTE: sleeping in this way allows the sleep to exit early when the
       // task is being stopped / destroyed
       {