fix(pi4ioe5v): Fix component implementation to be correct (#533)

* fix(pi4ioe5v): Fix component implementation to be correct

* fix inconsistency and remove unused reg def.

* fix inconsistencies

Author: finger563

components/pi4ioe5v/example/main/pi4ioe5v_example.cpp

@@ -2,65 +2,99 @@
 #include <sdkconfig.h>
 
 #include "i2c.hpp"
+#include "logger.hpp"
 #include "pi4ioe5v.hpp"
 #include "task.hpp"
 
 using namespace std::chrono_literals;
 
 extern "C" void app_main(void) {
-  fmt::print("Starting PI4IOE5V example...\n");
+
+  espp::Logger logger({.tag = "PI4IOE5V example", .level = espp::Logger::Verbosity::INFO});
+
+  logger.info("Starting PI4IOE5V example...");
 
   //! [pi4ioe5v_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,
+      .sda_pullup_en = GPIO_PULLUP_ENABLE,
+      .scl_pullup_en = GPIO_PULLUP_ENABLE,
   });
 
-  // Configure PI4IOE5V: single 8-bit port as outputs
+  // Configure PI4IOE5V: 8-bit port with mixed inputs/outputs
   espp::Pi4ioe5v exp({
       .device_address = espp::Pi4ioe5v::DEFAULT_ADDRESS,
-      .direction_mask = 0x00, // all outputs
-      .output_state = 0xFF,   // initial state
-      .probe = std::bind(&espp::I2c::probe_device, &i2c, std::placeholders::_1),
-      .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),
-      .write_then_read =
-          std::bind(&espp::I2c::write_read, &i2c, std::placeholders::_1, std::placeholders::_2,
-                    std::placeholders::_3, std::placeholders::_4, std::placeholders::_5),
-      .log_level = espp::Logger::Verbosity::WARN,
+      .direction_mask = 0xF0, // upper 4 bits as outputs, lower 4 bits as inputs
+      .interrupt_mask = 0xFF, // all interrupts disabled for now
+      .initial_output = 0xA0, // initial pattern for outputs
+      .write = std::bind_front(&espp::I2c::write, &i2c),
+      .write_then_read = std::bind_front(&espp::I2c::write_read, &i2c),
+      .auto_init = false,
+      .log_level = espp::Logger::Verbosity::INFO,
   });
 
   std::error_code ec;
-  exp.initialize(ec);
-  if (ec) {
-    fmt::print("PI4IOE5V init failed: {}\n", ec.message());
+  // Initialize separately from the constructor since we set auto_init to false
+  if (!exp.initialize(ec)) {
+    logger.error("PI4IOE5V initialization failed: {}", ec.message());
     return;
   }
 
+  // Configure pull resistors for input pins (lower 4 bits)
+  exp.set_pull_resistor_for_pin(0xF0, espp::Pi4ioe5v::PullResistor::PULL_UP, ec);
+  if (ec) {
+    logger.error("Failed to configure pull resistors: {}", ec.message());
+  }
+
+  // Create task to periodically toggle outputs and read inputs
   auto task_fn = [&](std::mutex &m, std::condition_variable &cv) {
-    static uint8_t value = 0xAA;
-    value ^= 0xFF; // toggle pattern
-    exp.write_outputs(value, ec);
-    if (!ec) {
-      uint8_t inputs = exp.read_inputs(ec);
-      if (!ec) {
-        fmt::print("OUT=0x{:02X} IN=0x{:02X}\n", value, inputs);
-      }
+    static auto start = std::chrono::high_resolution_clock::now();
+    static uint8_t output_pattern = 0x50;
+
+    auto now = std::chrono::high_resolution_clock::now();
+    auto seconds = std::chrono::duration<float>(now - start).count();
+
+    // Toggle output pattern on upper 4 bits
+    output_pattern ^= 0xF0;
+    exp.output(output_pattern, ec);
+    if (ec) {
+      logger.error("Failed to set outputs: {}", ec.message());
+      return true; // stop the task
+    }
+
+    // Read all pins
+    auto pins = exp.get_pins(ec);
+    if (ec) {
+      logger.error("Failed to read pins: {}", ec.message());
+      return true; // stop the task
     }
+
+    // Read current output state
+    auto outputs = exp.get_output(ec);
+    if (ec) {
+      logger.error("Failed to read outputs: {}", ec.message());
+      return true; // stop the task
+    }
+
+    fmt::print("{:.3f}, inputs: {:#04x}, outputs: {:#04x}\n", seconds, pins, outputs);
+
+    // NOTE: sleeping in this way allows the sleep to exit early when the
+    // task is being stopped / destroyed
     {
       std::unique_lock<std::mutex> lk(m);
       cv.wait_for(lk, 500ms);
     }
+    // don't want to stop the task
     return false;
   };
 
-  espp::Task task({.callback = task_fn,
-                   .task_config = {.name = "PI4IOE5V Task", .stack_size_bytes = 4 * 1024},
-                   .log_level = espp::Logger::Verbosity::WARN});
+  auto task = espp::Task({.callback = task_fn,
+                          .task_config = {.name = "PI4IOE5V Task", .stack_size_bytes = 4 * 1024},
+                          .log_level = espp::Logger::Verbosity::WARN});
+  fmt::print("% time(s), inputs (lower 4 bits), outputs (upper 4 bits)\n");
   task.start();
   //! [pi4ioe5v_example]