fix up touchpad timeouts, make it less chatty

src/drivers/i2c.cpp

@@ -40,7 +40,6 @@ esp_err_t init_i2c(void) {
     return err;
   }
 
-
   // TODO: INT line
 
   return ESP_OK;

src/drivers/include/touchwheel.hpp

@@ -1,8 +1,7 @@
 #pragma once
 
-
-#include <functional>
 #include <stdint.h>
+#include <functional>
 
 #include "esp_err.h"
 #include "result.hpp"
@@ -18,14 +17,7 @@ struct TouchWheelData {
 
 class TouchWheel {
  public:
-  enum Error {
-    FAILED_TO_BOOT,
-    FAILED_TO_CONFIGURE,
-  };
-  static auto create(GpioExpander* expander)
-      -> cpp::result<std::unique_ptr<TouchWheel>, Error>;
-
-  TouchWheel(GpioExpander* gpio);
+  TouchWheel();
   ~TouchWheel();
 
   // Not copyable or movable.
@@ -36,25 +28,22 @@ class TouchWheel {
   auto GetTouchWheelData() const -> TouchWheelData;
 
  private:
-  GpioExpander* gpio_;
   TouchWheelData data_;
 
   enum Register {
     FIRMWARE_VERSION = 0x1,
     DETECTION_STATUS = 0x2,
-    KEY_STATUS_A     = 0x3,
-    KEY_STATUS_B     = 0x4,
-    SLIDER_POSITION  = 0x5,
-    CALIBRATE        = 0x6,
-    RESET            = 0x7,
-    LOW_POWER        = 0x8,
-    SLIDER_OPTIONS   = 0x14,
+    KEY_STATUS_A = 0x3,
+    KEY_STATUS_B = 0x4,
+    SLIDER_POSITION = 0x5,
+    CALIBRATE = 0x6,
+    RESET = 0x7,
+    LOW_POWER = 0x8,
+    SLIDER_OPTIONS = 0x14,
   };
 
-
   void WriteRegister(uint8_t reg, uint8_t val);
-  void ReadRegister(uint8_t reg, uint8_t* data, uint8_t count);
-
+  uint8_t ReadRegister(uint8_t reg);
 };
 
 }  // namespace drivers

src/drivers/touchwheel.cpp

@@ -1,11 +1,15 @@
 #include "touchwheel.hpp"
+#include <stdint.h>
 
 #include <cstdint>
 
 #include "assert.h"
+#include "driver/gpio.h"
 #include "driver/i2c.h"
 #include "esp_err.h"
 #include "esp_log.h"
+#include "freertos/projdefs.h"
+#include "hal/gpio_types.h"
 #include "hal/i2c_types.h"
 
 #include "i2c.hpp"
@@ -15,34 +19,18 @@ namespace drivers {
 static const char* kTag = "TOUCHWHEEL";
 static const uint8_t kTouchWheelAddress = 0x1C;
 
-static const uint8_t kWriteMask = 0x80;
-static const uint8_t kReadMask = 0xA0;
+TouchWheel::TouchWheel() {
+  gpio_set_direction(GPIO_NUM_25, GPIO_MODE_INPUT);
+  gpio_set_pull_mode(GPIO_NUM_25, GPIO_PULLUP_ONLY);
 
-double normalise(uint16_t min, uint16_t max, uint16_t value) {
-  if (value >= max) {
-    return 1.0;
-  }
-  if (value <= min) {
-    return 0.0;
-  }
-  uint16_t range = max - min;
-  return (double)(value - min) / range;
-}
-
-
-auto TouchWheel::create(GpioExpander* expander)
-    -> cpp::result<std::unique_ptr<TouchWheel>, Error> {
-  std::unique_ptr<TouchWheel> wheel = std::make_unique<TouchWheel>(expander);
-  wheel->WriteRegister(Register::SLIDER_OPTIONS, 0xC0);
-  return wheel;
+  WriteRegister(Register::RESET, 1);
+  // TODO(daniel): do we need this? how long does reset take?
+  vTaskDelay(pdMS_TO_TICKS(1));
+  WriteRegister(Register::SLIDER_OPTIONS, 0b11000000);
+  WriteRegister(Register::CALIBRATE, 1);
 }
 
-TouchWheel::TouchWheel(GpioExpander* gpio) {
-  this->gpio_ = gpio;
-};
-
-TouchWheel::~TouchWheel(){
-};
+TouchWheel::~TouchWheel() {}
 
 void TouchWheel::WriteRegister(uint8_t reg, uint8_t val) {
   // uint8_t maskedReg = reg | kWriteMask;
@@ -55,38 +43,43 @@ void TouchWheel::WriteRegister(uint8_t reg, uint8_t val) {
   ESP_ERROR_CHECK(transaction.Execute());
 }
 
-void TouchWheel::ReadRegister(uint8_t reg, uint8_t* data, uint8_t count) {
-  // uint8_t maskedReg = reg | kReadMask;
-  uint8_t maskedReg = reg;
-
-  if (count <= 0) {
-    return;
-  }
-
+uint8_t TouchWheel::ReadRegister(uint8_t reg) {
+  uint8_t res;
   I2CTransaction transaction;
   transaction.start()
       .write_addr(kTouchWheelAddress, I2C_MASTER_WRITE)
-      .write_ack(maskedReg)
-      .stop()
+      .write_ack(reg)
       .start()
       .write_addr(kTouchWheelAddress, I2C_MASTER_READ)
-      .read(data, I2C_MASTER_NACK)
+      .read(&res, I2C_MASTER_NACK)
       .stop();
-
-  // TODO: Handle errors here.
   ESP_ERROR_CHECK(transaction.Execute());
+  return res;
 }
 
 void TouchWheel::Update() {
-    // Read data from device into member struct
-    uint8_t position;
-    this->ReadRegister(Register::SLIDER_POSITION, &position, 1);
-    data_.wheel_position = position;
+  // Read data from device into member struct
+  bool has_data = !gpio_get_level(GPIO_NUM_25);
+  if (!has_data) {
+    return;
+  }
+  uint8_t status = ReadRegister(Register::DETECTION_STATUS);
+  if (status & 0b10000000) {
+    // Still calibrating.
+    return;
+  }
+  if (status & 0b10) {
+    // Slider detect.
+    data_.wheel_position = ReadRegister(Register::SLIDER_POSITION);
+  }
+  if (status & 0b1) {
+    // Key detect.
+    // TODO(daniel): implement me
+  }
 }
 
 TouchWheelData TouchWheel::GetTouchWheelData() const {
   return data_;
 }
 
-
 }  // namespace drivers

src/main/main.cpp

@@ -1,4 +1,5 @@
 #include <dirent.h>
+#include <stdint.h>
 #include <stdio.h>
 
 #include <cstddef>
@@ -121,16 +122,9 @@ extern "C" void app_main(void) {
     storage = std::move(storage_res.value());
   }
 
-  /*
   ESP_LOGI(TAG, "Init touch wheel");
-  auto touchwheel_res = drivers::TouchWheel::create(expander);
-  std::shared_ptr<drivers::TouchWheel> touchwheel;
-  if (touchwheel_res.has_error()) {
-    ESP_LOGE(TAG, "Failed!");
-  } else {
-    touchwheel = std::move(touchwheel_res.value());
-  }
-  */
+  std::unique_ptr<drivers::TouchWheel> touchwheel =
+      std::make_unique<drivers::TouchWheel>();
 
   LvglArgs* lvglArgs = (LvglArgs*)calloc(1, sizeof(LvglArgs));
   lvglArgs->gpio_expander = expander;
@@ -156,9 +150,14 @@ extern "C" void app_main(void) {
   console::AppConsole console(playback.get());
   console.Launch();
 
+  uint8_t prev_position = 0;
   while (1) {
-    //touchwheel->Update();
-    //ESP_LOGI(TAG, "Touch wheel pos: %d", touchwheel->GetTouchWheelData().wheel_position);
+    touchwheel->Update();
+    auto wheel_data = touchwheel->GetTouchWheelData();
+    if (wheel_data.wheel_position != prev_position) {
+      prev_position = wheel_data.wheel_position;
+      ESP_LOGI(TAG, "Touch wheel pos: %u", prev_position);
+    }
     vTaskDelay(pdMS_TO_TICKS(100));
   }
 }