clang-tidy libs

ravinrabbid · ravinrabbid · commit 93eb1c6ae8c6 · 2025-09-28T14:04:25.000+02:00
diff --git a/libs/cap1188/src/Cap1188.cpp b/libs/cap1188/src/Cap1188.cpp
@@ -1,5 +1,8 @@
 #include "Cap1188.h"
 
+#include <algorithm>
+#include <array>
+
 Cap1188::Cap1188(uint8_t address, i2c_inst *i2c, uint8_t threshold, Sensitivity sensitivity, Gain gain)
     : m_i2c(i2c), m_address(address) {
 
@@ -50,7 +53,7 @@ bool Cap1188::getTouched(uint8_t input) {
         return false;
     }
 
-    return getTouched() & (1 << input);
+    return (getTouched() & (1 << input)) != 0;
 }
 
 void Cap1188::setGain(Gain gain) {
@@ -70,19 +73,17 @@ void Cap1188::setSensitivity(Cap1188::Sensitivity sensitivity) {
 
 void Cap1188::setThreshold(uint8_t threshold) {
     // By default writing SENSOR_INPUT_1_THRESHOLD will set all inputs
-    if (threshold > 127) {
-        threshold = 127;
-    }
+    threshold = std::min(threshold, (uint8_t)127);
 
     writeRegister(Register::SENSOR_INPUT_1_THRESHOLD, threshold);
 }
 
 int8_t Cap1188::getDeltaCount(uint8_t input) {
     if (input > 7) {
-        return false;
+        return 0;
     }
 
-    return readRegister(Register::SENSOR_INPUT_1_DELTA_COUNT, input);
+    return static_cast<int8_t>(readRegister(Register::SENSOR_INPUT_1_DELTA_COUNT, input));
 }
 
 void Cap1188::clearInterrupt() {
@@ -92,7 +93,7 @@ void Cap1188::clearInterrupt() {
 }
 
 uint8_t Cap1188::readRegister(Cap1188::Register reg, uint8_t offset) {
-    uint8_t result;
+    uint8_t result = 0;
     const uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
 
     i2c_write_blocking(m_i2c, m_address, &reg_addr, 1, true);
@@ -103,7 +104,7 @@ uint8_t Cap1188::readRegister(Cap1188::Register reg, uint8_t offset) {
 
 void Cap1188::writeRegister(Cap1188::Register reg, uint8_t value, uint8_t offset) {
     const uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
-    const uint8_t data[] = {reg_addr, value};
+    const std::array data = {reg_addr, value};
 
-    i2c_write_blocking(m_i2c, m_address, data, 2, false);
+    i2c_write_blocking(m_i2c, m_address, data.data(), 2, false);
 }
diff --git a/libs/is31se5117a/include/is31se5117a/Is31se5117a.h b/libs/is31se5117a/include/is31se5117a/Is31se5117a.h
@@ -300,7 +300,7 @@ class Is31se5117a {
     i2c_inst *m_i2c;
     uint8_t m_address;
 
-    RegisterPage m_current_page;
+    RegisterPage m_current_page{RegisterPage::Page0};
 
   public:
     Is31se5117a(uint8_t address, i2c_inst *i2c, uint8_t threshold, uint8_t hysteresis);
@@ -327,6 +327,8 @@ class Is31se5117a {
     uint8_t readRegister8(Register reg, uint8_t offset = 0);
     uint16_t readRegister16(Register reg, uint8_t offset = 0);
     void writeRegister(Register reg, uint8_t value, uint8_t offset = 0);
+
+    void doWriteRegister(uint8_t addr, uint8_t value);
 };
 
 #endif // IS31SE5117A_IS31SE5117A_H_
diff --git a/libs/is31se5117a/src/is31se5117a.cpp b/libs/is31se5117a/src/is31se5117a.cpp
@@ -2,12 +2,14 @@
 
 #include "pico/time.h"
 
+#include <array>
+
 namespace {
-static constexpr uint8_t KEY_COUNT = 16;
+constexpr uint8_t KEY_COUNT = 16;
 } // namespace
 
 Is31se5117a::Is31se5117a(uint8_t address, i2c_inst *i2c, uint8_t threshold, uint8_t hysteresis)
-    : m_i2c(i2c), m_address(address), m_current_page(RegisterPage::Page0) {
+    : m_i2c(i2c), m_address(address) {
 
     // Reset
     writeRegister(Register::MAIN_CONTROL, 0x80);
@@ -82,7 +84,7 @@ Is31se5117a::Is31se5117a(uint8_t address, i2c_inst *i2c, uint8_t threshold, uint
 }
 
 uint16_t Is31se5117a::getTouched() {
-    uint16_t touched = readRegister16(Register::KEY_STATUS_1);
+    const uint16_t touched = readRegister16(Register::KEY_STATUS_1);
 
     return touched;
 }
@@ -91,7 +93,7 @@ bool Is31se5117a::getTouched(uint8_t input) {
         return false;
     }
 
-    return getTouched() & (1 << input);
+    return (getTouched() & (1 << input)) != 0;
 }
 
 void Is31se5117a::setFingerThresholds(uint8_t threshold) {
@@ -163,21 +165,22 @@ uint16_t Is31se5117a::getBaseline(uint8_t input) {
 void Is31se5117a::setRegisterPage(uint16_t address) {
     if (address > 0x0009) {
         if (address > 0x00FF && m_current_page != RegisterPage::Page1) {
-            writeRegister(Register::SWITCH_PAGE, 0x01);
+            doWriteRegister(static_cast<uint8_t>(Register::SWITCH_PAGE), 0x01);
             m_current_page = RegisterPage::Page1;
         } else if (address < 0x0100 && m_current_page != RegisterPage::Page0) {
-            writeRegister(Register::SWITCH_PAGE, 0x00);
+            doWriteRegister(static_cast<uint8_t>(Register::SWITCH_PAGE), 0x00);
             m_current_page = RegisterPage::Page0;
         }
     }
 }
 
 uint8_t Is31se5117a::readRegister8(Is31se5117a::Register reg, uint8_t offset) {
-    uint8_t result;
-    uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
+    uint8_t result = 0;
+
+    const uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
+    const auto reg_addr = static_cast<uint8_t>(offset_addr & 0x00FF);
 
     setRegisterPage(offset_addr);
-    uint8_t reg_addr = static_cast<uint8_t>(offset_addr & 0x00FF);
 
     i2c_write_blocking(m_i2c, m_address, &reg_addr, 1, true);
     i2c_read_blocking(m_i2c, m_address, &result, 1, false);
@@ -186,24 +189,28 @@ uint8_t Is31se5117a::readRegister8(Is31se5117a::Register reg, uint8_t offset) {
 }
 
 uint16_t Is31se5117a::readRegister16(Is31se5117a::Register reg, uint8_t offset) {
-    uint8_t result[2];
-    uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
+    std::array<uint8_t, 2> result = {};
+
+    const uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
+    const auto reg_addr = static_cast<uint8_t>(offset_addr & 0x00FF);
 
     setRegisterPage(offset_addr);
-    uint8_t reg_addr = static_cast<uint8_t>(offset_addr & 0x00FF);
 
     i2c_write_blocking(m_i2c, m_address, &reg_addr, 1, true);
-    i2c_read_blocking(m_i2c, m_address, result, 2, false);
+    i2c_read_blocking(m_i2c, m_address, result.data(), 2, false);
 
     // High byte comes first for 16bit values
     return static_cast<uint16_t>(result[0]) << 8 | static_cast<uint16_t>(result[1]);
 }
 
 void Is31se5117a::writeRegister(Is31se5117a::Register reg, uint8_t value, uint8_t offset) {
-    uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
+    const uint16_t offset_addr = static_cast<uint16_t>(reg) + offset;
 
     setRegisterPage(offset_addr);
+    doWriteRegister(static_cast<uint8_t>(offset_addr & 0x00FF), value);
+}
 
-    uint8_t data[] = {static_cast<uint8_t>(offset_addr & 0x00FF), value};
-    i2c_write_blocking(m_i2c, m_address, data, 2, false);
+void Is31se5117a::doWriteRegister(uint8_t addr, uint8_t value) {
+    std::array data = {addr, value};
+    i2c_write_blocking(m_i2c, m_address, data.data(), 2, false);
 }
diff --git a/libs/mpr121/src/Mpr121.cpp b/libs/mpr121/src/Mpr121.cpp
@@ -2,6 +2,8 @@
 
 #include "pico/time.h"
 
+#include <array>
+
 Mpr121::Mpr121(uint8_t address, i2c_inst *i2c, uint8_t touch_threshold, uint8_t release_threshold, bool autoconfig)
     : m_i2c(i2c), m_address(address) {
 
@@ -47,7 +49,7 @@ Mpr121::Mpr121(uint8_t address, i2c_inst *i2c, uint8_t touch_threshold, uint8_t
 }
 
 uint16_t Mpr121::getTouched() {
-    uint16_t touched = readRegister16(Register::TOUCHSTATUS_L);
+    const uint16_t touched = readRegister16(Register::TOUCHSTATUS_L);
 
     return touched & 0x0FFF;
 }
@@ -56,7 +58,7 @@ bool Mpr121::getTouched(uint8_t input) {
         return false;
     }
 
-    return getTouched() & (1 << input);
+    return (getTouched() & (1 << input)) != 0;
 }
 
 void Mpr121::setThresholds(uint8_t touch_threshold, uint8_t release_threshold) {
@@ -86,40 +88,40 @@ uint16_t Mpr121::getFilteredData(uint8_t input) {
 }
 
 uint8_t Mpr121::readRegister8(Mpr121::Register reg, uint8_t offset) {
-    uint8_t result;
+    uint8_t result = 0;
 
-    uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
+    const uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
     i2c_write_blocking(m_i2c, m_address, &reg_addr, 1, true);
     i2c_read_blocking(m_i2c, m_address, &result, 1, false);
 
     return result;
 }
 
 uint16_t Mpr121::readRegister16(Mpr121::Register reg, uint8_t offset) {
-    uint8_t result[2];
+    std::array<uint8_t, 2> result = {};
 
-    uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
+    const uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
     i2c_write_blocking(m_i2c, m_address, &reg_addr, 1, true);
-    i2c_read_blocking(m_i2c, m_address, result, 2, false);
+    i2c_read_blocking(m_i2c, m_address, result.data(), 2, false);
 
     return static_cast<uint16_t>(result[1]) << 8 | static_cast<uint16_t>(result[0]);
 }
 
 void Mpr121::writeRegister(Mpr121::Register reg, uint8_t value, uint8_t offset) {
     // Only ECR and GPIO related registers can be written in 'Run' mode.
-    bool need_stop = (reg != Register::ECR) && (reg != Register::GPIODIR) && (reg != Register::GPIOEN) &&
-                     (reg != Register::GPIOSET) && (reg != Register::GPIOCLR) && (reg != Register::GPIOTOGGLE);
+    const bool need_stop = (reg != Register::ECR) && (reg != Register::GPIODIR) && (reg != Register::GPIOEN) &&
+                           (reg != Register::GPIOSET) && (reg != Register::GPIOCLR) && (reg != Register::GPIOTOGGLE);
 
     auto do_write_register = [&](Mpr121::Register reg, uint8_t value, uint8_t offset = 0) {
-        uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
-        uint8_t data[] = {reg_addr, value};
+        const uint8_t reg_addr = static_cast<uint8_t>(reg) + offset;
+        std::array data = {reg_addr, value};
 
-        i2c_write_blocking(m_i2c, m_address, data, 2, false);
+        i2c_write_blocking(m_i2c, m_address, data.data(), 2, false);
     };
 
     if (need_stop) {
         // Backup ECR
-        uint8_t ecr = readRegister8(Register::ECR);
+        const uint8_t ecr = readRegister8(Register::ECR);
 
         // Issue stop
         do_write_register(Register::ECR, 0x00);
