bytewelder / tactility Goto Github PK

Tactility is a front-end application platform for ESP32. It is mainly intended for touchscreen devices. It provides an application framework that is based on code from the Flipper Zero project.

Status: Alpha

Tactility features a desktop that can launch apps:

Through the Settings app you can connect to Wi-Fi or change the display settings:

Play with the built-in apps or build your own! Use one of the supported devices or set up the drivers for your own hardware platform.

Noteworthy features:

• Touch UI capabilities (via LVGL) with support for input devices such as on-device trackball or keyboard.
• An application platform that can run apps and services.
• Basic applications to boost productivity, such as a Wi-Fi connectivity app.
• Run Tactility apps on PC to speed up development.

Requirements:

• ESP32 (any?) with a touchscreen
• esp-idf 5.2 or a newer v5.2.x

The app manifest provides basic information like the application name. It also describes the app lifecycle: It tells Tactility which functions need to be called when the app is started/shown/etc.

UI is created with lvgl which has lots of widgets! Creating a touch-capable UI is easy and doesn't require your own render loop!

static void app_show(App app, lv_obj_t* parent) {
    // Default toolbar with app name and close button
    lv_obj_t* toolbar = tt_toolbar_create_for_app(parent, app);
    lv_obj_align(toolbar, LV_ALIGN_TOP_MID, 0, 0);
    
    // Label widget
    lv_obj_t* label = lv_label_create(parent);
    lv_label_set_text(label, "Hello, world!");
    lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
    // Widgets are auto-removed from the parent when the app is closed
}

const AppManifest hello_world_app = {
    .id = "helloworld",    // Used to identify and start an app
    .name = "Hello World", // Shown on the desktop and app's toolbar
    .icon = NULL,
    .type = AppTypeUser,
    .on_start = NULL,
    .on_stop = NULL,
    .on_show = &app_show,  // A minimal setup sets the on_show() function
    .on_hide = NULL
};

Any ESP32 device with a touchscreen should be able to run Tactility, because LVGL is set up in a platform-agnostic manner. Implementing drivers can take some effort, so Tactility provides support for several devices.

Predefined configurations are available for:

• ✅: Capable and implemented
• ⏳: Capable but not yet implemented
• ❌: Not capable

(*) Note: Only the capacitive version is supported. See AliExpress here and here.

Ensure you clone the repository including the submodules! For example:

git clone --recurse-submodules -j8 https://github.com/ByteWelder/Tactility.git

Ensure you have esp-idf 5.2 installed, then select the correct device:

Copy the sdkconfig.board.YOUR_BOARD into sdkconfig. Use sdkconfig.defaults if you are setting up a custom board.

You can run idf.py flash monitor, but there are some helpers available too:

./build.sh - build the ESP-IDF or the PC version of Tactility (*) ./build.sh -p /dev/ttyACM0 - optional: you can pass on extra parameters for esp-idf builds ./run.sh - Does flash and monitor for ESP-IDF and simply builds and starts it for PC

The build scripts will detect if ESP-IDF is available. They will adapter if you ran ${IDF_PATH}/export.sh.

Take a look at the App Lifecycle or the dependency diagram (this uses PlantUML).

Directories explained:

• app-esp: The ESP32 application example
• app-sim: The PC/simulator application example
• boards: Contains ESP modules with drivers
• tactility: The main application platform code (src/)
• tactility-headless: Service framework and default services.
• tactility-core: Core functionality regarding threads, stdlib, etc. (src/)
• libs: Contains a mix of regular libraries and ESP modules

Until there is proper documentation, here are some pointers:

GNU General Public License Version 3