adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced Logger usage with LOG_x (#548)

Browse Source
This commit is contained in:
Ken Van Hoeylandt
2026-07-04 23:49:19 +02:00
committed by GitHub
parent ecad2248d9
commit 9d5993930d
162 changed files with 1776 additions and 1842 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Devices/lilygo-tdeck/Source/Init.cpp
+13 -13
View File
@@ -5,11 +5,11 @@
#include <Tactility/hal/gps/GpsConfiguration.h>
#include <Tactility/kernel/Kernel.h>
#include <Tactility/kernel/SystemEvents.h>
#include <Tactility/Logger.h>
#include <Tactility/LogMessages.h>
#include <Tactility/service/gps/GpsService.h>
#include <tactility/log.h>
static const auto LOGGER = tt::Logger("T-Deck");
constexpr auto* TAG = "T-Deck";
constexpr auto TDECK_POWERON_GPIO = GPIO_NUM_10;
@@ -37,9 +37,9 @@ static bool powerOn() {
}
bool initBoot() {
LOGGER.info(LOG_MESSAGE_POWER_ON_START);
LOG_I(TAG, LOG_MESSAGE_POWER_ON_START);
if (!powerOn()) {
LOGGER.error(LOG_MESSAGE_POWER_ON_FAILED);
LOG_E(TAG, LOG_MESSAGE_POWER_ON_FAILED);
return false;
}
@@ -47,7 +47,7 @@ bool initBoot() {
* when moving the brightness slider rapidly from a lower setting to 100%.
* This is not a slider bug (data was debug-traced) */
if (!driver::pwmbacklight::init(GPIO_NUM_42, 30000)) {
LOGGER.error("Backlight init failed");
LOG_E(TAG, "Backlight init failed");
return false;
}
@@ -58,9 +58,9 @@ bool initBoot() {
gps_service->getGpsConfigurations(gps_configurations);
if (gps_configurations.empty()) {
if (gps_service->addGpsConfiguration(tt::hal::gps::GpsConfiguration {.uartName = "uart0", .baudRate = 38400, .model = tt::hal::gps::GpsModel::UBLOX10})) {
LOGGER.info("Configured internal GPS");
LOG_I(TAG, "Configured internal GPS");
} else {
LOGGER.error("Failed to configure internal GPS");
LOG_E(TAG, "Failed to configure internal GPS");
}
}
}
@@ -69,23 +69,23 @@ bool initBoot() {
tt::kernel::subscribeSystemEvent(tt::kernel::SystemEvent::BootSplash, [](tt::kernel::SystemEvent event) {
auto kbBacklight = tt::hal::findDevice("Keyboard Backlight");
if (kbBacklight != nullptr) {
LOGGER.info("{} starting", kbBacklight->getName());
LOG_I(TAG, "%s starting", kbBacklight->getName().c_str());
auto kbDevice = std::static_pointer_cast<KeyboardBacklightDevice>(kbBacklight);
if (kbDevice->start()) {
LOGGER.info("{} started", kbBacklight->getName());
LOG_I(TAG, "%s started", kbBacklight->getName().c_str());
} else {
LOGGER.error("{} start failed", kbBacklight->getName());
LOG_E(TAG, "%s start failed", kbBacklight->getName().c_str());
}
}
auto trackball = tt::hal::findDevice("Trackball");
if (trackball != nullptr) {
LOGGER.info("{} starting", trackball->getName());
LOG_I(TAG, "%s starting", trackball->getName().c_str());
auto tbDevice = std::static_pointer_cast<TrackballDevice>(trackball);
if (tbDevice->start()) {
LOGGER.info("{} started", trackball->getName());
LOG_I(TAG, "%s started", trackball->getName().c_str());
} else {
LOGGER.error("{} start failed", trackball->getName());
LOG_E(TAG, "%s start failed", trackball->getName().c_str());
}
}
});
Devices/lilygo-tdeck/Source/KeyboardBacklight/KeyboardBacklight.cpp
+17 -18
View File
@@ -1,11 +1,10 @@
#include "KeyboardBacklight.h"
#include <Tactility/Logger.h>
#include <cstring>
#include <esp_log.h>
#include <tactility/log.h>
static const auto LOGGER = tt::Logger("KeyboardBacklight");
constexpr auto* TAG = "KeyboardBacklight";
namespace keyboardbacklight {
@@ -21,16 +20,16 @@ bool init(i2c_port_t i2cPort, uint8_t slaveAddress) {
g_i2cPort = i2cPort;
g_slaveAddress = slaveAddress;
LOGGER.info("Initialized on I2C port {}, address 0x{:02X}", static_cast<int>(g_i2cPort), g_slaveAddress);
LOG_I(TAG, "Initialized on I2C port %d, address 0x%02X", static_cast<int>(g_i2cPort), (unsigned)g_slaveAddress);
// Set a reasonable default brightness
if (!setDefaultBrightness(127)) {
LOGGER.error("Failed to set default brightness");
LOG_E(TAG, "Failed to set default brightness");
return false;
}
if (!setBrightness(127)) {
LOGGER.error("Failed to set brightness");
LOG_E(TAG, "Failed to set brightness");
return false;
}
@@ -39,16 +38,16 @@ bool init(i2c_port_t i2cPort, uint8_t slaveAddress) {
bool setBrightness(uint8_t brightness) {
if (g_i2cPort >= I2C_NUM_MAX) {
LOGGER.error("Not initialized");
LOG_E(TAG, "Not initialized");
return false;
}
// Skip if brightness is already at target value (avoid I2C spam on every keypress)
if (brightness == g_currentBrightness) {
return true;
}
LOGGER.info("Setting brightness to {} on I2C port {}, address 0x{:02X}", brightness, static_cast<int>(g_i2cPort), g_slaveAddress);
LOG_I(TAG, "Setting brightness to %d on I2C port %d, address 0x%02X", brightness, static_cast<int>(g_i2cPort), (unsigned)g_slaveAddress);
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
@@ -62,20 +61,20 @@ bool setBrightness(uint8_t brightness) {
if (ret == ESP_OK) {
g_currentBrightness = brightness;
LOGGER.info("Successfully set brightness to {}", brightness);
LOG_I(TAG, "Successfully set brightness to %d", brightness);
return true;
} else {
LOGGER.error("Failed to set brightness: {} (0x{:02X})", esp_err_to_name(ret), ret);
LOG_E(TAG, "Failed to set brightness: %s (0x%02X)", esp_err_to_name(ret), (unsigned)ret);
return false;
}
}
bool setDefaultBrightness(uint8_t brightness) {
if (g_i2cPort >= I2C_NUM_MAX) {
LOGGER.error("Not initialized");
LOG_E(TAG, "Not initialized");
return false;
}
// Clamp to valid range for default brightness
if (brightness < 30) {
brightness = 30;
@@ -92,17 +91,17 @@ bool setDefaultBrightness(uint8_t brightness) {
i2c_cmd_link_delete(cmd);
if (ret == ESP_OK) {
LOGGER.debug("Set default brightness to {}", brightness);
LOG_D(TAG, "Set default brightness to %d", brightness);
return true;
} else {
LOGGER.error("Failed to set default brightness: {}", esp_err_to_name(ret));
LOG_E(TAG, "Failed to set default brightness: %s", esp_err_to_name(ret));
return false;
}
}
uint8_t getBrightness() {
if (g_i2cPort >= I2C_NUM_MAX) {
LOGGER.error("Not initialized");
LOG_E(TAG, "Not initialized");
return 0;
}
Devices/lilygo-tdeck/Source/Trackball/Trackball.cpp
+19 -19
View File
@@ -1,10 +1,10 @@
#include "Trackball.h"
#include <Tactility/Assets.h>
#include <Tactility/Logger.h>
#include <atomic>
#include <tactility/log.h>
static const auto LOGGER = tt::Logger("Trackball");
constexpr auto* TAG = "Trackball";
namespace trackball {
@@ -133,7 +133,7 @@ static void read_cb(lv_indev_t* indev, lv_indev_data_t* data) {
lv_indev_t* init(const TrackballConfig& config) {
if (g_initialized.load(std::memory_order_relaxed)) {
LOGGER.warn("Already initialized");
LOG_W(TAG, "Already initialized");
return g_indev;
}
@@ -177,7 +177,7 @@ lv_indev_t* init(const TrackballConfig& config) {
// ESP_ERR_INVALID_STATE means already installed, which is fine
isr_service_installed = true;
} else {
LOGGER.error("Failed to install GPIO ISR service: {}", esp_err_to_name(err));
LOG_E(TAG, "Failed to install GPIO ISR service: %s", esp_err_to_name(err));
return nullptr;
}
}
@@ -190,7 +190,7 @@ lv_indev_t* init(const TrackballConfig& config) {
io_conf.pin_bit_mask = (1ULL << dirPins[i]);
esp_err_t err = gpio_config(&io_conf);
if (err != ESP_OK) {
LOGGER.error("Failed to configure GPIO {}: {}", static_cast<int>(dirPins[i]), esp_err_to_name(err));
LOG_E(TAG, "Failed to configure GPIO %d: %s", static_cast<int>(dirPins[i]), esp_err_to_name(err));
// Cleanup previously added handlers
for (int j = 0; j < handlersAdded; j++) {
gpio_isr_handler_remove(dirPins[j]);
@@ -200,7 +200,7 @@ lv_indev_t* init(const TrackballConfig& config) {
err = gpio_isr_handler_add(dirPins[i], trackball_isr_handler, reinterpret_cast<void*>(static_cast<intptr_t>(dirPins[i])));
if (err != ESP_OK) {
LOGGER.error("Failed to add ISR for GPIO {}: {}", static_cast<int>(dirPins[i]), esp_err_to_name(err));
LOG_E(TAG, "Failed to add ISR for GPIO %d: %s", static_cast<int>(dirPins[i]), esp_err_to_name(err));
// Cleanup previously added handlers
for (int j = 0; j < handlersAdded; j++) {
gpio_isr_handler_remove(dirPins[j]);
@@ -215,7 +215,7 @@ lv_indev_t* init(const TrackballConfig& config) {
io_conf.pin_bit_mask = (1ULL << config.pinClick);
esp_err_t err = gpio_config(&io_conf);
if (err != ESP_OK) {
LOGGER.error("Failed to configure button GPIO {}: {}", static_cast<int>(config.pinClick), esp_err_to_name(err));
LOG_E(TAG, "Failed to configure button GPIO %d: %s", static_cast<int>(config.pinClick), esp_err_to_name(err));
// Cleanup direction handlers
for (int i = 0; i < 4; i++) {
gpio_isr_handler_remove(dirPins[i]);
@@ -225,7 +225,7 @@ lv_indev_t* init(const TrackballConfig& config) {
err = gpio_isr_handler_add(config.pinClick, button_isr_handler, nullptr);
if (err != ESP_OK) {
LOGGER.error("Failed to add button ISR: {}", esp_err_to_name(err));
LOG_E(TAG, "Failed to add button ISR: %s", esp_err_to_name(err));
// Cleanup direction handlers
for (int i = 0; i < 4; i++) {
gpio_isr_handler_remove(dirPins[i]);
@@ -239,7 +239,7 @@ lv_indev_t* init(const TrackballConfig& config) {
// Register as LVGL encoder input device for group navigation (default mode)
g_indev = lv_indev_create();
if (g_indev == nullptr) {
LOGGER.error("Failed to register LVGL input device");
LOG_E(TAG, "Failed to register LVGL input device");
// Cleanup ISR handlers on failure
const gpio_num_t pins[5] = {
config.pinRight, config.pinUp, config.pinLeft,
@@ -255,7 +255,7 @@ lv_indev_t* init(const TrackballConfig& config) {
lv_indev_set_type(g_indev, LV_INDEV_TYPE_ENCODER);
lv_indev_set_read_cb(g_indev, read_cb);
g_initialized.store(true, std::memory_order_relaxed);
LOGGER.info("Initialized with interrupts (R:{} U:{} L:{} D:{} Click:{})",
LOG_I(TAG, "Initialized with interrupts (R:%d U:%d L:%d D:%d Click:%d)",
static_cast<int>(config.pinRight),
static_cast<int>(config.pinUp),
static_cast<int>(config.pinLeft),
@@ -276,7 +276,7 @@ static void createCursor() {
// Set cursor image
lv_image_set_src(g_cursor, TT_ASSETS_UI_CURSOR);
lv_indev_set_cursor(g_indev, g_cursor);
LOGGER.debug("Cursor created");
LOG_D(TAG, "Cursor created");
}
}
@@ -287,7 +287,7 @@ static void destroyCursor() {
// Delete the cursor object - this automatically detaches it from the indev
lv_obj_delete(g_cursor);
g_cursor = nullptr;
LOGGER.debug("Cursor destroyed");
LOG_D(TAG, "Cursor destroyed");
}
void deinit() {
@@ -317,14 +317,14 @@ void deinit() {
g_initialized.store(false, std::memory_order_relaxed);
g_mode.store(Mode::Encoder, std::memory_order_relaxed);
g_enabled.store(true, std::memory_order_relaxed);
LOGGER.info("Deinitialized");
LOG_I(TAG, "Deinitialized");
}
void setEncoderSensitivity(uint8_t sensitivity) {
if (sensitivity > 0) {
// Only update the atomic - ISR reads from atomic, not g_config
g_encoderSensitivity.store(sensitivity, std::memory_order_relaxed);
LOGGER.debug("Encoder sensitivity set to {}", sensitivity);
LOG_D(TAG, "Encoder sensitivity set to %d", sensitivity);
}
}
@@ -332,7 +332,7 @@ void setPointerSensitivity(uint8_t sensitivity) {
if (sensitivity > 0) {
// Only update the atomic - ISR reads from atomic, not g_config
g_pointerSensitivity.store(sensitivity, std::memory_order_relaxed);
LOGGER.debug("Pointer sensitivity set to {}", sensitivity);
LOG_D(TAG, "Pointer sensitivity set to %d", sensitivity);
}
}
@@ -355,13 +355,13 @@ void setEnabled(bool enabled) {
}
}
LOGGER.info("{}", enabled ? "Enabled" : "Disabled");
LOG_I(TAG, "%s", enabled ? "Enabled" : "Disabled");
}
void setMode(Mode mode) {
// Note: Must be called from LVGL thread (main thread) for thread safety
if (!g_initialized.load(std::memory_order_relaxed) || g_indev == nullptr) {
LOGGER.warn("Cannot set mode - not initialized");
LOG_W(TAG, "Cannot set mode - not initialized");
return;
}
@@ -381,13 +381,13 @@ void setMode(Mode mode) {
// Reset cursor to center when switching modes
g_cursorX.store(SCREEN_WIDTH / 2, std::memory_order_relaxed);
g_cursorY.store(SCREEN_HEIGHT / 2, std::memory_order_relaxed);
LOGGER.info("Switched to Pointer mode");
LOG_I(TAG, "Switched to Pointer mode");
} else {
// Switch to encoder mode
destroyCursor();
lv_indev_set_type(g_indev, LV_INDEV_TYPE_ENCODER);
g_encoderDiff.store(0, std::memory_order_relaxed); // Reset encoder diff
LOGGER.info("Switched to Encoder mode");
LOG_I(TAG, "Switched to Encoder mode");
}
}
Devices/lilygo-tdeck/Source/devices/TdeckKeyboard.cpp
+4 -8
View File
@@ -1,16 +1,16 @@
#include "TdeckKeyboard.h"
#include <KeyboardBacklight/KeyboardBacklight.h>
#include <Tactility/Logger.h>
#include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/settings/DisplaySettings.h>
#include <Tactility/settings/KeyboardSettings.h>
#include <lvgl.h>
#include <tactility/drivers/i2c_controller.h>
#include <tactility/log.h>
using tt::hal::findFirstDevice;
static const auto LOGGER = tt::Logger("TdeckKeyboard");
constexpr auto* TAG = "TdeckKeyboard";
constexpr uint8_t TDECK_KEYBOARD_SLAVE_ADDRESS = 0x55;
@@ -34,15 +34,11 @@ static void keyboard_read_callback(lv_indev_t* indev, lv_indev_data_t* data) {
auto* keyboard = static_cast<TdeckKeyboard*>(lv_indev_get_user_data(indev));
if (i2c_controller_read(keyboard->getI2cController(), TDECK_KEYBOARD_SLAVE_ADDRESS, &read_buffer, 1, 100 / portTICK_PERIOD_MS) == ERROR_NONE) {
if (read_buffer == 0 && read_buffer != last_buffer) {
if (LOGGER.isLoggingDebug()) {
LOGGER.debug("Released {}", last_buffer);
}
LOG_D(TAG, "Released %d", last_buffer);
data->key = last_buffer;
data->state = LV_INDEV_STATE_RELEASED;
} else if (read_buffer != 0) {
if (LOGGER.isLoggingDebug()) {
LOGGER.debug("Pressed {}", read_buffer);
}
LOG_D(TAG, "Pressed %d", read_buffer);
data->key = read_buffer;
data->state = LV_INDEV_STATE_PRESSED;
// TODO: Avoid performance hit by calling loadOrGetDefault() on each key press
Devices/lilygo-tdeck/Source/devices/TrackballDevice.cpp
+3 -3
View File
@@ -1,10 +1,10 @@
#include "TrackballDevice.h"
#include <Trackball/Trackball.h> // Driver
#include <Tactility/Logger.h>
#include <Tactility/lvgl/LvglSync.h>
#include <Tactility/settings/TrackballSettings.h>
#include <tactility/log.h>
static const auto LOGGER = tt::Logger("TrackballDevice");
constexpr auto* TAG = "TrackballDevice";
bool TrackballDevice::start() {
if (initialized) {
@@ -40,7 +40,7 @@ bool TrackballDevice::start() {
trackball::setEnabled(tbSettings.trackballEnabled);
tt::lvgl::unlock();
} else {
LOGGER.warn("Failed to acquire LVGL lock for trackball settings");
LOG_W(TAG, "Failed to acquire LVGL lock for trackball settings");
}
return true;