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

Trackball rewrite (#600)

Browse Source 
- Implement generic trackball settings
- Refactor T-Deck trackball driver into generic driver at `Drivers/gpio-trackball-module`
- Automatically bind/unbind trackball devices with LVGL
- Automatically load settings for trackball devices on boot
This commit is contained in:
Ken Van Hoeylandt
2026-07-30 13:38:19 +02:00
committed by GitHub
parent de6fc3b346
commit c729e8340f
39 changed files with 1194 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/Tactility.cpp
+13 -5
View File
@@ -12,8 +12,8 @@
#include <Tactility/app/AppManifestParsing.h>
#include <Tactility/app/AppRegistration.h>
#include <Tactility/file/File.h>
#include <Tactility/file/FileLock.h>
#include <Tactility/LogMessages.h>
#include <Tactility/lvgl/TrackballInit.h>
#include <Tactility/hal/SdCard.h>
#include <Tactility/network/NtpPrivate.h>
#include <Tactility/Paths.h>
@@ -34,11 +34,13 @@
#include <lvgl/widgets/toolbar.h>
#include <tactility/concurrent/thread.h>
#include <tactility/device.h>
#include <tactility/drivers/audio_stream.h>
#include <tactility/drivers/display.h>
#include <tactility/drivers/grove.h>
#include <tactility/drivers/power_supply.h>
#include <tactility/drivers/rtc.h>
#include <tactility/drivers/trackball.h>
#include <tactility/drivers/uart_controller.h>
#include <tactility/filesystem/file_mutex.h>
#include <tactility/filesystem/file_system.h>
@@ -154,9 +156,10 @@ namespace app {
namespace webserversettings { extern const AppManifest manifest; }
#if CONFIG_TT_TDECK_WORKAROUND == 1
namespace keyboardsettings { extern const AppManifest manifest; } // T-Deck only for now
#endif
#endif
namespace trackballsettings { extern const AppManifest manifest; } // T-Deck only for now
#endif
#endif
#if TT_FEATURE_SCREENSHOT_ENABLED
namespace screenshot { extern const AppManifest manifest; }
@@ -216,9 +219,12 @@ static void registerInternalApps() {
addAppManifest(app::development::manifest);
#if defined(CONFIG_TT_TDECK_WORKAROUND)
addAppManifest(app::keyboardsettings::manifest);
#endif
#endif
if (device_exists_of_type(&TRACKBALL_TYPE)) {
addAppManifest(app::trackballsettings::manifest);
#endif
#endif
}
#if defined(CONFIG_TINYUSB_MSC_ENABLED) && CONFIG_TINYUSB_MSC_ENABLED
addAppManifest(app::usbsettings::manifest);
@@ -373,6 +379,8 @@ static void onLvglStarted() {
addService(service::screenshot::manifest);
#endif
lvgl::initTrackball();
memory_print_stats();
}
Tactility/Source/app/trackball/TrackballSettings.cpp
+81 -45
View File
@@ -1,59 +1,61 @@
#ifdef ESP_PLATFORM
#include <lvgl.h>
#include <lvgl/devices/device_context.h>
#include <lvgl/devices/trackball.h>
#include <lvgl/icons/shared.h>
#include <lvgl/lvgl.h>
#include <Tactility/Tactility.h>
#include <tactility/drivers/trackball.h>
#include <Tactility/Assets.h>
#include <Tactility/settings/TrackballSettings.h>
#include <Tactility/lvgl/Toolbar.h>
// Forward declare driver functions
namespace trackball {
void setEnabled(bool enabled);
enum class Mode { Encoder, Pointer };
void setMode(Mode mode);
void setEncoderSensitivity(uint8_t sensitivity);
void setPointerSensitivity(uint8_t sensitivity);
}
#include <Tactility/Tactility.h>
namespace tt::app::trackballsettings {
constexpr auto* TAG = "TrackballSettings";
static trackball::Mode toDriverMode(settings::trackball::TrackballMode mode) {
// Convert mode to dropdown index (dropdown order: Encoder=0, Pointer=1)
static uint32_t modeToDropdownIndex(LvglTrackballMode mode) {
switch (mode) {
case settings::trackball::TrackballMode::Encoder: return trackball::Mode::Encoder;
case settings::trackball::TrackballMode::Pointer: return trackball::Mode::Pointer;
}
return trackball::Mode::Encoder; // default
}
// Convert settings enum to dropdown index (dropdown order: Encoder=0, Pointer=1)
static uint32_t modeToDropdownIndex(settings::trackball::TrackballMode mode) {
switch (mode) {
case settings::trackball::TrackballMode::Encoder: return 0;
case settings::trackball::TrackballMode::Pointer: return 1;
case LVGL_TRACKBALL_MODE_ENCODER: return 0;
case LVGL_TRACKBALL_MODE_POINTER: return 1;
}
return 0; // default to Encoder
}
class TrackballSettingsApp final : public App {
settings::trackball::TrackballSettings tbSettings;
LvglTrackballSettings tbSettings;
bool updated = false;
// The trackball indev currently bound by lvgl_devices_attach() at LVGL startup, if any -
// there's at most one at a time (see devices.c), so "first active trackball device" reduces
// to whatever is already attached.
lv_indev_t* trackballIndev = nullptr;
lv_obj_t* switchTrackball = nullptr;
lv_obj_t* trackballModeDropdown = nullptr;
lv_obj_t* encoderSensitivitySlider = nullptr;
lv_obj_t* pointerSensitivitySlider = nullptr;
void applyLive() {
if (trackballIndev == nullptr) {
return;
}
lvgl_lock();
lvgl_trackball_set_settings(trackballIndev, &tbSettings);
if (tbSettings.mode == LVGL_TRACKBALL_MODE_POINTER) {
lvgl_trackball_set_cursor_image(trackballIndev, TT_ASSETS_UI_CURSOR);
}
lvgl_unlock();
}
static void onTrackballSwitch(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
bool enabled = lv_obj_has_state(app->switchTrackball, LV_STATE_CHECKED);
app->tbSettings.trackballEnabled = enabled;
app->tbSettings.enabled = enabled;
app->updated = true;
trackball::setEnabled(enabled);
app->applyLive();
// Enable/disable controls based on trackball state
if (enabled) {
@@ -72,38 +74,57 @@ class TrackballSettingsApp final : public App {
uint32_t selected = lv_dropdown_get_selected(app->trackballModeDropdown);
// Validate selection matches expected enum values (dropdown order: Encoder=0, Pointer=1)
settings::trackball::TrackballMode mode;
LvglTrackballMode mode;
switch (selected) {
case 0: mode = settings::trackball::TrackballMode::Encoder; break;
case 1: mode = settings::trackball::TrackballMode::Pointer; break;
case 0: mode = LVGL_TRACKBALL_MODE_ENCODER; break;
case 1: mode = LVGL_TRACKBALL_MODE_POINTER; break;
default: return; // Invalid selection, ignore
}
app->tbSettings.trackballMode = mode;
app->tbSettings.mode = mode;
app->updated = true;
// Apply mode change immediately
trackball::setMode(toDriverMode(mode));
app->applyLive();
}
static void onEncoderSensitivityChanged(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
int32_t value = lv_slider_get_value(app->encoderSensitivitySlider);
app->tbSettings.encoderSensitivity = static_cast<uint8_t>(value);
app->tbSettings.encoder_sensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setEncoderSensitivity(static_cast<uint8_t>(value));
app->applyLive();
}
static void onPointerSensitivityChanged(lv_event_t* e) {
auto* app = static_cast<TrackballSettingsApp*>(lv_event_get_user_data(e));
int32_t value = lv_slider_get_value(app->pointerSensitivitySlider);
app->tbSettings.pointerSensitivity = static_cast<uint8_t>(value);
app->tbSettings.pointer_sensitivity = static_cast<uint8_t>(value);
app->updated = true;
// Apply immediately
trackball::setPointerSensitivity(static_cast<uint8_t>(value));
app->applyLive();
}
static lv_indev_t* findFirstTrackballIndev() {
lv_indev_t* indev = lv_indev_get_next(nullptr);
while (indev != nullptr) {
void* driver_data = lv_indev_get_driver_data(indev);
if (driver_data) {
LvglDeviceContext* context = static_cast<LvglDeviceContext*>(driver_data);
if (context->device) {
const DeviceType* device_type = device_get_type(context->device);
if (device_type == &TRACKBALL_TYPE) {
return indev;
}
}
}
indev = lv_indev_get_next(indev);
}
return nullptr;
}
public:
@@ -111,15 +132,32 @@ public:
tbSettings = settings::trackball::loadOrGetDefault();
auto ui_density = lvgl_get_ui_density();
updated = false;
trackballIndev = findFirstTrackballIndev();
lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(parent, 0, LV_STATE_DEFAULT);
lv_obj_t* toolbar = lvgl::toolbar_create(parent, app);
if (trackballIndev == nullptr) {
auto* wrapper = lv_obj_create(parent);
lv_obj_set_width(wrapper, LV_PCT(100));
lv_obj_set_flex_grow(wrapper, 1);
lv_obj_set_flex_flow(wrapper, LV_FLEX_FLOW_COLUMN);
lv_obj_set_flex_align(wrapper, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
auto* label = lv_label_create(wrapper);
lv_label_set_text(label, "No trackball device found");
return;
}
// The live indev may still be running with lvgl_trackball_settings_get_default() (it's
// bound at LVGL startup before persisted settings are known) - bring it in line with what
// this screen is about to display.
applyLive();
switchTrackball = lvgl_toolbar_add_switch_action(toolbar);
lv_obj_add_event_cb(switchTrackball, onTrackballSwitch, LV_EVENT_VALUE_CHANGED, this);
if (tbSettings.trackballEnabled) lv_obj_add_state(switchTrackball, LV_STATE_CHECKED);
if (tbSettings.enabled) lv_obj_add_state(switchTrackball, LV_STATE_CHECKED);
auto* main_wrapper = lv_obj_create(parent);
lv_obj_set_flex_flow(main_wrapper, LV_FLEX_FLOW_COLUMN);
@@ -139,11 +177,11 @@ public:
trackballModeDropdown = lv_dropdown_create(tb_mode_wrapper);
lv_dropdown_set_options(trackballModeDropdown, "Encoder\nPointer");
lv_obj_align(trackballModeDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
lv_dropdown_set_selected(trackballModeDropdown, modeToDropdownIndex(tbSettings.trackballMode));
lv_dropdown_set_selected(trackballModeDropdown, modeToDropdownIndex(tbSettings.mode));
lv_obj_add_event_cb(trackballModeDropdown, onTrackballModeChanged, LV_EVENT_VALUE_CHANGED, this);
// Disable dropdown if trackball is disabled
if (!tbSettings.trackballEnabled) {
if (!tbSettings.enabled) {
lv_obj_add_state(trackballModeDropdown, LV_STATE_DISABLED);
}
@@ -162,12 +200,12 @@ public:
encoderSensitivitySlider = lv_slider_create(enc_sens_wrapper);
lv_slider_set_range(encoderSensitivitySlider, 1, 10);
lv_slider_set_value(encoderSensitivitySlider, tbSettings.encoderSensitivity, LV_ANIM_OFF);
lv_slider_set_value(encoderSensitivitySlider, tbSettings.encoder_sensitivity, LV_ANIM_OFF);
lv_obj_set_width(encoderSensitivitySlider, LV_PCT(50));
lv_obj_align(encoderSensitivitySlider, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(encoderSensitivitySlider, onEncoderSensitivityChanged, LV_EVENT_VALUE_CHANGED, this);
if (!tbSettings.trackballEnabled) {
if (!tbSettings.enabled) {
lv_obj_add_state(encoderSensitivitySlider, LV_STATE_DISABLED);
}
@@ -186,12 +224,12 @@ public:
pointerSensitivitySlider = lv_slider_create(ptr_sens_wrapper);
lv_slider_set_range(pointerSensitivitySlider, 1, 10);
lv_slider_set_value(pointerSensitivitySlider, tbSettings.pointerSensitivity, LV_ANIM_OFF);
lv_slider_set_value(pointerSensitivitySlider, tbSettings.pointer_sensitivity, LV_ANIM_OFF);
lv_obj_set_width(pointerSensitivitySlider, LV_PCT(50));
lv_obj_align(pointerSensitivitySlider, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(pointerSensitivitySlider, onPointerSensitivityChanged, LV_EVENT_VALUE_CHANGED, this);
if (!tbSettings.trackballEnabled) {
if (!tbSettings.enabled) {
lv_obj_add_state(pointerSensitivitySlider, LV_STATE_DISABLED);
}
}
@@ -214,5 +252,3 @@ extern const AppManifest manifest = {
};
}
#endif
Tactility/Source/lvgl/TrackballInit.cpp
+45
View File
@@ -0,0 +1,45 @@
#include <lvgl/devices/trackball.h>
#include <lvgl/devices/device_context.h>
#include <lvgl/lvgl.h>
#include <tactility/device.h>
#include <tactility/drivers/trackball.h>
#include <Tactility/Assets.h>
#include <Tactility/settings/TrackballSettings.h>
namespace tt::lvgl {
static void initTrackball(lv_indev_t* indev, LvglTrackballSettings& settings) {
lv_indev_type_t type = lv_indev_get_type(indev);
void* driver_data = lv_indev_get_driver_data(indev);
if (!driver_data) {
return;
}
LvglDeviceContext* context = static_cast<LvglDeviceContext*>(driver_data);
if (!context->device) {
return;
}
const DeviceType* device_type = device_get_type(context->device);
if (device_type != &TRACKBALL_TYPE) {
return;
}
lvgl_trackball_set_settings(indev, &settings);
if (settings.mode == LVGL_TRACKBALL_MODE_POINTER) {
lvgl_trackball_set_cursor_image(indev, TT_ASSETS_UI_CURSOR);
}
}
void initTrackball() {
auto trackball_settings = settings::trackball::loadOrGetDefault();
lv_indev_t* indev = lv_indev_get_next(nullptr);
while (indev != nullptr) {
initTrackball(indev, trackball_settings);
indev = lv_indev_get_next(indev);
}
}
}
Tactility/Source/settings/TrackballSettings.cpp
+17 -21
View File
@@ -23,7 +23,7 @@ constexpr uint8_t MAX_ENCODER_SENSITIVITY = 10;
constexpr uint8_t MIN_POINTER_SENSITIVITY = 1;
constexpr uint8_t MAX_POINTER_SENSITIVITY = 10;
bool load(TrackballSettings& settings) {
bool load(LvglTrackballSettings& settings) {
auto settings_path = getSettingsFilePath();
if (!file::isFile(settings_path)) {
return false;
@@ -55,41 +55,37 @@ bool load(TrackballSettings& settings) {
auto isTrueValue = [](const std::string& s) {
return s == "1" || s == "true" || s == "True" || s == "TRUE";
};
settings.trackballEnabled = (tb_enabled != map.end()) ? isTrueValue(tb_enabled->second) : true;
settings.trackballMode = (tb_mode != map.end() && tb_mode->second == "1") ? TrackballMode::Pointer : TrackballMode::Encoder;
settings.encoderSensitivity = (enc_sens != map.end()) ? safeParseUint8(enc_sens->second, MIN_ENCODER_SENSITIVITY) : MIN_ENCODER_SENSITIVITY;
settings.pointerSensitivity = (ptr_sens != map.end()) ? safeParseUint8(ptr_sens->second, MAX_POINTER_SENSITIVITY) : MAX_POINTER_SENSITIVITY;
settings.enabled = (tb_enabled != map.end()) ? isTrueValue(tb_enabled->second) : true;
settings.mode = (tb_mode != map.end() && tb_mode->second == "1") ? LVGL_TRACKBALL_MODE_POINTER : LVGL_TRACKBALL_MODE_ENCODER;
auto default_settings = lvgl_trackball_settings_get_default();
settings.encoder_sensitivity = (enc_sens != map.end()) ? safeParseUint8(enc_sens->second, default_settings.encoder_sensitivity) : default_settings.encoder_sensitivity;
settings.pointer_sensitivity = (ptr_sens != map.end()) ? safeParseUint8(ptr_sens->second, default_settings.pointer_sensitivity) : default_settings.pointer_sensitivity;
// Clamp values to valid ranges
settings.encoderSensitivity = std::clamp(settings.encoderSensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY);
settings.pointerSensitivity = std::clamp(settings.pointerSensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY);
settings.encoder_sensitivity = std::clamp(settings.encoder_sensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY);
settings.pointer_sensitivity = std::clamp(settings.pointer_sensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY);
return true;
}
TrackballSettings getDefault() {
return TrackballSettings{
.trackballEnabled = true,
.trackballMode = TrackballMode::Encoder,
.encoderSensitivity = MIN_ENCODER_SENSITIVITY,
.pointerSensitivity = MAX_POINTER_SENSITIVITY
};
LvglTrackballSettings getDefault() {
return lvgl_trackball_settings_get_default();
}
TrackballSettings loadOrGetDefault() {
TrackballSettings s;
LvglTrackballSettings loadOrGetDefault() {
LvglTrackballSettings s;
if (!load(s)) {
s = getDefault();
}
return s;
}
bool save(const TrackballSettings& settings) {
bool save(const LvglTrackballSettings& settings) {
std::map<std::string, std::string> map;
map[KEY_TRACKBALL_ENABLED] = settings.trackballEnabled ? "1" : "0";
map[KEY_TRACKBALL_MODE] = (settings.trackballMode == TrackballMode::Pointer) ? "1" : "0";
map[KEY_ENCODER_SENSITIVITY] = std::to_string(std::clamp(settings.encoderSensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY));
map[KEY_POINTER_SENSITIVITY] = std::to_string(std::clamp(settings.pointerSensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY));
map[KEY_TRACKBALL_ENABLED] = settings.enabled ? "1" : "0";
map[KEY_TRACKBALL_MODE] = (settings.mode == LVGL_TRACKBALL_MODE_POINTER) ? "1" : "0";
map[KEY_ENCODER_SENSITIVITY] = std::to_string(std::clamp(settings.encoder_sensitivity, MIN_ENCODER_SENSITIVITY, MAX_ENCODER_SENSITIVITY));
map[KEY_POINTER_SENSITIVITY] = std::to_string(std::clamp(settings.pointer_sensitivity, MIN_POINTER_SENSITIVITY, MAX_POINTER_SENSITIVITY));
auto settings_path = getSettingsFilePath();
if (!file::findOrCreateParentDirectory(settings_path, 0755)) {
return false;