dominic/Tactiliest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: dominic:9e6c60bc145ff503263aeb66d69f81a740bae34c
Branches Tags
dominic:main
dominic:radio
dominic:pager
dominic:pager-wip
..
compare: dominic:3dfc27e93ee75c935ab200d1d346aacf1c815a79
Branches Tags
dominic:radio
dominic:main
dominic:pager
dominic:pager-wip

No commits in common. "9e6c60bc145ff503263aeb66d69f81a740bae34c" and "3dfc27e93ee75c935ab200d1d346aacf1c815a79" have entirely different histories.
9e6c60bc14 ... 3dfc27e93e

87 changed files with 73 additions and 4688 deletions
Show Stats Expand all files Collapse all files

2
.github/actions/build-firmware/action.yml vendored
View File

@ -18,7 +18,7 @@ runs:
shell: bash
run: cp sdkconfig.board.${{ inputs.board_id }} sdkconfig
- name: 'Build'
uses: espressif/esp-idf-ci-action@v1
uses: espressif/esp-idf-ci-action@main
with:
esp_idf_version: v5.4
target: ${{ inputs.arch }}

8
.github/actions/build-sdk/action.yml vendored
View File

@ -18,18 +18,14 @@ runs:
shell: bash
run: cp sdkconfig.board.${{ inputs.board_id }} sdkconfig
- name: 'Build'
uses: espressif/esp-idf-ci-action@v1
uses: espressif/esp-idf-ci-action@main
with:
# NOTE: Update with ESP-IDF!
esp_idf_version: v5.4
target: ${{ inputs.arch }}
path: './'
- name: 'Release'
shell: bash
env:
# NOTE: Update with ESP-IDF!
ESP_IDF_VERSION: '5.4'
run: Buildscripts/release-sdk.sh release/TactilitySDK
run: Buildscripts/release-sdk.sh release/TactilitySDK
- name: 'Upload Artifact'
uses: actions/upload-artifact@v4
with:

2
App/Kconfig
View File

@ -37,8 +37,6 @@ menu "Tactility App"
bool "Elecrow CrowPanel Basic 5.0"
config TT_BOARD_LILYGO_TDECK
bool "LilyGo T-Deck"
config TT_BOARD_LILYGO_TLORA_PAGER
bool "LilyGo T-Lora Pager"
config TT_BOARD_M5STACK_CORE2
bool "M5Stack Core2"
config TT_BOARD_M5STACK_CORES3

5
App/Source/Boards.h
View File

@ -8,9 +8,6 @@
#if defined(CONFIG_TT_BOARD_LILYGO_TDECK)
#include "LilygoTdeck.h"
#define TT_BOARD_HARDWARE &lilygo_tdeck
#elif defined(CONFIG_TT_BOARD_LILYGO_TLORA_PAGER)
#include "LilygoTloraPager.h"
#define TT_BOARD_HARDWARE &lilygo_tlora_pager
#elif defined(CONFIG_TT_BOARD_CYD_2432S024C)
#include "CYD2432S024C.h"
#define TT_BOARD_HARDWARE &cyd_2432s024c_config
@ -71,4 +68,4 @@
extern tt::hal::Configuration hardware;
#define TT_BOARD_HARDWARE &hardware
#endif // ESP_PLATFORM
#endif // ESP_PLATFORM

7
Boards/LilygoTLoraPager/CMakeLists.txt
View File

@ -1,7 +0,0 @@
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Source"
REQUIRES Tactility esp_lvgl_port esp_lcd ST7796 BQ27220 TCA8418 PwmBacklight driver esp_adc
)

80
Boards/LilygoTLoraPager/Source/Init.cpp
View File

@ -1,80 +0,0 @@
#include "PwmBacklight.h"
#include "Tactility/kernel/SystemEvents.h"
#include "Tactility/service/gps/GpsService.h"
#include <Tactility/TactilityCore.h>
#include <Tactility/hal/gps/GpsConfiguration.h>
#include <driver/gpio.h>
#include <Bq27220.h>
#include <Tca8418.h>
#define TAG "tpager"
// Power on
#define TDECK_POWERON_GPIO GPIO_NUM_10
std::shared_ptr<Bq27220> bq27220;
std::shared_ptr<Tca8418> tca8418;
static bool powerOn() {
/*
gpio_config_t device_power_signal_config = {
.pin_bit_mask = BIT64(TDECK_POWERON_GPIO),
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
if (gpio_config(&device_power_signal_config) != ESP_OK) {
return false;
}
if (gpio_set_level(TDECK_POWERON_GPIO, 1) != ESP_OK) {
return false;
}
*/
return true;
}
bool tdeckInit() {
ESP_LOGI(TAG, LOG_MESSAGE_POWER_ON_START);
if (!powerOn()) {
TT_LOG_E(TAG, LOG_MESSAGE_POWER_ON_FAILED);
return false;
}
/* 32 Khz and higher gives an issue where the screen starts dimming again above 80% brightness
* 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)) {
TT_LOG_E(TAG, "Backlight init failed");
return false;
}
bq27220 = std::make_shared<Bq27220>(I2C_NUM_0);
tt::hal::registerDevice(bq27220);
tca8418 = std::make_shared<Tca8418>(I2C_NUM_0);
tt::hal::registerDevice(tca8418);
tt::kernel::subscribeSystemEvent(tt::kernel::SystemEvent::BootSplash, [](tt::kernel::SystemEvent event) {
bq27220->configureCapacity(1500, 1500);
auto gps_service = tt::service::gps::findGpsService();
if (gps_service != nullptr) {
std::vector<tt::hal::gps::GpsConfiguration> gps_configurations;
gps_service->getGpsConfigurations(gps_configurations);
if (gps_configurations.empty()) {
if (gps_service->addGpsConfiguration(tt::hal::gps::GpsConfiguration {.uartName = "Grove", .baudRate = 38400, .model = tt::hal::gps::GpsModel::UBLOX10})) {
TT_LOG_I(TAG, "Configured internal GPS");
} else {
TT_LOG_E(TAG, "Failed to configure internal GPS");
}
}
}
});
return true;
}

91
Boards/LilygoTLoraPager/Source/LilygoTloraPager.cpp
View File

@ -1,91 +0,0 @@
#include "Tactility/lvgl/LvglSync.h"
#include "hal/TpagerDisplay.h"
#include "hal/TpagerDisplayConstants.h"
#include "hal/TpagerKeyboard.h"
#include "hal/TpagerPower.h"
#include "hal/TpagerSdCard.h"
#include <Tactility/hal/Configuration.h>
#define TDECK_SPI_TRANSFER_SIZE_LIMIT (TDECK_LCD_HORIZONTAL_RESOLUTION * TDECK_LCD_SPI_TRANSFER_HEIGHT * (LV_COLOR_DEPTH / 8))
bool tdeckInit();
using namespace tt::hal;
extern const Configuration lilygo_tlora_pager = {
.initBoot = tdeckInit,
.createDisplay = createDisplay,
.createKeyboard = createKeyboard,
.sdcard = createTpagerSdCard(),
.power = tpager_get_power,
.i2c = {
i2c::Configuration {
.name = "Internal",
.port = I2C_NUM_0,
.initMode = i2c::InitMode::ByTactility,
.isMutable = true,
.config = (i2c_config_t) {
.mode = I2C_MODE_MASTER,
.sda_io_num = GPIO_NUM_3,
.scl_io_num = GPIO_NUM_2,
.sda_pullup_en = false,
.scl_pullup_en = false,
.master = {
.clk_speed = 100'000
},
.clk_flags = 0
}
}
},
.spi {
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_34,
.miso_io_num = GPIO_NUM_33,
.sclk_io_num = GPIO_NUM_35,
.quadwp_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.quadhd_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.data4_io_num = GPIO_NUM_NC,
.data5_io_num = GPIO_NUM_NC,
.data6_io_num = GPIO_NUM_NC,
.data7_io_num = GPIO_NUM_NC,
.data_io_default_level = false,
.max_transfer_sz = TDECK_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
}
},
.uart {
uart::Configuration {
.name = "Grove",
.port = UART_NUM_1,
.rxPin = GPIO_NUM_4,
.txPin = GPIO_NUM_12,
.rtsPin = GPIO_NUM_NC,
.ctsPin = GPIO_NUM_NC,
.rxBufferSize = 1024,
.txBufferSize = 1024,
.config = {
.baud_rate = 38400,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.rx_flow_ctrl_thresh = 0,
.source_clk = UART_SCLK_DEFAULT,
.flags = {
.allow_pd = 0,
.backup_before_sleep = 0,
}
}
}
}
};

5
Boards/LilygoTLoraPager/Source/LilygoTloraPager.h
View File

@ -1,5 +0,0 @@
#pragma once
#include <Tactility/hal/Configuration.h>
extern const tt::hal::Configuration lilygo_tlora_pager;

41
Boards/LilygoTLoraPager/Source/hal/TpagerDisplay.cpp
View File

@ -1,41 +0,0 @@
#include "TpagerDisplay.h"
#include "TpagerDisplayConstants.h"
#include <St7796Display.h>
#include <PwmBacklight.h>
#include <driver/spi_master.h>
#define TAG "tdeck_display"
std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
/*auto configuration = std::make_unique<St7796Display::Configuration>(
TDECK_LCD_SPI_HOST,
TDECK_LCD_PIN_CS,
TDECK_LCD_PIN_DC,
480,
222,
nullptr,
true, //swapXY
true, //mirrorX
true, //mirrorY
true //invertColor
);*/
auto configuration = std::make_unique<St7796Display::Configuration>(
TDECK_LCD_SPI_HOST,
TDECK_LCD_PIN_CS,
TDECK_LCD_PIN_DC,
480, // w
222, // h
nullptr,
true, //swapXY
true, //mirrorX
true, //mirrorY
true //invertColor
);
configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
return std::make_shared<St7796Display>(std::move(configuration));
}

40
Boards/LilygoTLoraPager/Source/hal/TpagerDisplay.h
View File

@ -1,40 +0,0 @@
#pragma once
#include "Tactility/hal/display/DisplayDevice.h"
#include <esp_lcd_types.h>
#include <lvgl.h>
class TpagerDisplay : public tt::hal::display::DisplayDevice {
private:
esp_lcd_panel_io_handle_t ioHandle = nullptr;
esp_lcd_panel_handle_t panelHandle = nullptr;
lv_display_t* displayHandle = nullptr;
bool poweredOn = false;
public:
std::string getName() const final { return "ST7796"; }
std::string getDescription() const final { return "SPI display"; }
bool start() override;
bool stop() override;
void setPowerOn(bool turnOn) override;
bool isPoweredOn() const override { return poweredOn; };
bool supportsPowerControl() const override { return true; }
std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
void setBacklightDuty(uint8_t backlightDuty) override;
bool supportsBacklightDuty() const override { return true; }
void setGammaCurve(uint8_t index) override;
uint8_t getGammaCurveCount() const override { return 4; };
lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
};
std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

8
Boards/LilygoTLoraPager/Source/hal/TpagerDisplayConstants.h
View File

@ -1,8 +0,0 @@
#pragma once
#define TDECK_LCD_SPI_HOST SPI2_HOST
#define TDECK_LCD_PIN_CS GPIO_NUM_38
#define TDECK_LCD_PIN_DC GPIO_NUM_37 // RS
#define TDECK_LCD_HORIZONTAL_RESOLUTION 222
#define TDECK_LCD_VERTICAL_RESOLUTION 480
#define TDECK_LCD_SPI_TRANSFER_HEIGHT (TDECK_LCD_VERTICAL_RESOLUTION / 10)

336
Boards/LilygoTLoraPager/Source/hal/TpagerKeyboard.cpp
View File

@ -1,336 +0,0 @@
#include "TpagerKeyboard.h"
#include <Tactility/hal/i2c/I2c.h>
#include <driver/i2c.h>
#include "freertos/queue.h"
#include "driver/gpio.h"
#include <Tactility/Log.h>
#define TAG "tpager_keyboard"
#define ENCODER_A GPIO_NUM_40
#define ENCODER_B GPIO_NUM_41
#define ENCODER_ENTER GPIO_NUM_7
#define BACKLIGHT GPIO_NUM_46
#define KB_ROWS 4
#define KB_COLS 11
// Lowercase Keymap
static constexpr char keymap_lc[KB_ROWS][KB_COLS] = {
{'\0', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'},
{'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '\n', '\0'},
{'z', 'x', 'c', 'v', 'b', 'n', 'm', '\0', LV_KEY_BACKSPACE, ' ', '\0'},
{'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}
};
// Uppercase Keymap
static constexpr char keymap_uc[KB_ROWS][KB_COLS] = {
{'\0', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P'},
{'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', '\n', '\0'},
{'Z', 'X', 'C', 'V', 'B', 'N', 'M', '\0', LV_KEY_BACKSPACE, ' ', '\0'},
{'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}
};
// Symbol Keymap
static constexpr char keymap_sy[KB_ROWS][KB_COLS] = {
{'\0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'},
{'.', '/', '+', '-', '=', ':', '\'', '"', '@', '\t', '\0'},
{'_', '$', ';', '?', '!', ',', '.', '\0', LV_KEY_BACKSPACE, ' ', '\0'},
{'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}
};
static QueueHandle_t keyboardMsg;
static void keyboard_read_callback(lv_indev_t* indev, lv_indev_data_t* data) {
TpagerKeyboard* kb = (TpagerKeyboard*)lv_indev_get_user_data(indev);
static bool enter_prev = false;
char keypress = 0;
// Defaults
data->key = 0;
data->state = LV_INDEV_STATE_RELEASED;
if (xQueueReceive(keyboardMsg, &keypress, pdMS_TO_TICKS(50)) == pdPASS) {
data->key = keypress;
data->state = LV_INDEV_STATE_PRESSED;
}
}
static void encoder_read_callback(lv_indev_t* indev, lv_indev_data_t* data) {
TpagerKeyboard* kb = (TpagerKeyboard*)lv_indev_get_user_data(indev);
const int enter_filter_threshold = 2;
static int enter_filter = 0;
const int pulses_click = 4;
static int pulses_prev = 0;
bool anyinput = false;
// Defaults
data->enc_diff = 0;
data->state = LV_INDEV_STATE_RELEASED;
int pulses = kb->getEncoderPulses();
int pulse_diff = (pulses - pulses_prev);
if ((pulse_diff > pulses_click) || (pulse_diff < -pulses_click)) {
data->enc_diff = pulse_diff / pulses_click;
pulses_prev = pulses;
anyinput = true;
}
bool enter = !gpio_get_level(ENCODER_ENTER);
if (enter && (enter_filter < enter_filter_threshold)) {
enter_filter++;
}
if (!enter && (enter_filter > 0)) {
enter_filter--;
}
if (enter_filter == enter_filter_threshold) {
data->state = LV_INDEV_STATE_PRESSED;
anyinput = true;
}
if (anyinput) {
kb->makeBacklightImpulse();
}
}
void TpagerKeyboard::processKeyboard() {
static bool shift_pressed = false;
static bool sym_pressed = false;
static bool cap_toggle = false;
static bool cap_toggle_armed = true;
bool anykey_pressed = false;
if (keypad->update()) {
anykey_pressed = (keypad->pressed_key_count > 0);
for (int i=0; i < keypad->pressed_key_count; i++) {
auto row = keypad->pressed_list[i].row;
auto col = keypad->pressed_list[i].col;
auto hold = keypad->pressed_list[i].hold_time;
if ((row == 1) && (col == 10)) {
sym_pressed = true;
}
if ((row == 2) && (col == 7)) {
shift_pressed = true;
}
}
if ((sym_pressed && shift_pressed) && cap_toggle_armed) {
cap_toggle = !cap_toggle;
cap_toggle_armed = false;
}
for (int i=0; i < keypad->pressed_key_count; i++) {
auto row = keypad->pressed_list[i].row;
auto col = keypad->pressed_list[i].col;
auto hold = keypad->pressed_list[i].hold_time;
char chr = '\0';
if (sym_pressed) {
chr = keymap_sy[row][col];
} else if (shift_pressed || cap_toggle) {
chr = keymap_uc[row][col];
} else {
chr = keymap_lc[row][col];
}
if (chr != '\0') xQueueSend(keyboardMsg, (void *)&chr, portMAX_DELAY);
}
for (int i=0; i < keypad->released_key_count; i++) {
auto row = keypad->released_list[i].row;
auto col = keypad->released_list[i].col;
if ((row == 1) && (col == 10)) {
sym_pressed = false;
}
if ((row == 2) && (col == 7)) {
shift_pressed = false;
}
}
if ((!sym_pressed && !shift_pressed) && !cap_toggle_armed) {
cap_toggle_armed = true;
}
if (anykey_pressed) {
makeBacklightImpulse();
}
}
}
bool TpagerKeyboard::start(lv_display_t* display) {
backlightOkay = initBacklight(BACKLIGHT, 30000, LEDC_TIMER_0, LEDC_CHANNEL_1);
initEncoder();
keypad->init(KB_ROWS, KB_COLS);
gpio_input_enable(ENCODER_ENTER);
assert(inputTimer == nullptr);
inputTimer = std::make_unique<tt::Timer>(tt::Timer::Type::Periodic, [this] {
processKeyboard();
});
assert(backlightImpulseTimer == nullptr);
backlightImpulseTimer = std::make_unique<tt::Timer>(tt::Timer::Type::Periodic, [this] {
processBacklightImpuse();
});
kbHandle = lv_indev_create();
lv_indev_set_type(kbHandle, LV_INDEV_TYPE_KEYPAD);
lv_indev_set_read_cb(kbHandle, &keyboard_read_callback);
lv_indev_set_display(kbHandle, display);
lv_indev_set_user_data(kbHandle, this);
encHandle = lv_indev_create();
lv_indev_set_type(encHandle, LV_INDEV_TYPE_ENCODER);
lv_indev_set_read_cb(encHandle, &encoder_read_callback);
lv_indev_set_display(encHandle, display);
lv_indev_set_user_data(encHandle, this);
inputTimer->start(20 / portTICK_PERIOD_MS);
backlightImpulseTimer->start(50 / portTICK_PERIOD_MS);
return true;
}
bool TpagerKeyboard::stop() {
assert(inputTimer);
inputTimer->stop();
inputTimer = nullptr;
assert(backlightImpulseTimer);
backlightImpulseTimer->stop();
backlightImpulseTimer = nullptr;
lv_indev_delete(kbHandle);
kbHandle = nullptr;
lv_indev_delete(encHandle);
encHandle = nullptr;
return true;
}
bool TpagerKeyboard::isAttached() const {
return tt::hal::i2c::masterHasDeviceAtAddress(keypad->getPort(), keypad->getAddress(), 100);
}
void TpagerKeyboard::initEncoder(void) {
const int low_limit = -127;
const int high_limit = 126;
// Accum. count makes it that over- and underflows are automatically compensated.
// Prerequisite: watchpoints at low and high limit
pcnt_unit_config_t unit_config = {
.low_limit = low_limit,
.high_limit = high_limit,
.flags = { .accum_count = 1 },
};
ESP_ERROR_CHECK(pcnt_new_unit(&unit_config, &encPcntUnit));
pcnt_glitch_filter_config_t filter_config = {
.max_glitch_ns = 1000,
};
ESP_ERROR_CHECK(pcnt_unit_set_glitch_filter(encPcntUnit, &filter_config));
pcnt_chan_config_t chan_a_config = {
.edge_gpio_num = ENCODER_A,
.level_gpio_num = ENCODER_B,
};
pcnt_channel_handle_t pcnt_chan_a = NULL;
ESP_ERROR_CHECK(pcnt_new_channel(encPcntUnit, &chan_a_config, &pcnt_chan_a));
pcnt_chan_config_t chan_b_config = {
.edge_gpio_num = ENCODER_B,
.level_gpio_num = ENCODER_A,
};
pcnt_channel_handle_t pcnt_chan_b = NULL;
ESP_ERROR_CHECK(pcnt_new_channel(encPcntUnit, &chan_b_config, &pcnt_chan_b));
ESP_ERROR_CHECK(pcnt_channel_set_edge_action(pcnt_chan_a, PCNT_CHANNEL_EDGE_ACTION_DECREASE, PCNT_CHANNEL_EDGE_ACTION_INCREASE));
ESP_ERROR_CHECK(pcnt_channel_set_level_action(pcnt_chan_a, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
ESP_ERROR_CHECK(pcnt_channel_set_edge_action(pcnt_chan_b, PCNT_CHANNEL_EDGE_ACTION_INCREASE, PCNT_CHANNEL_EDGE_ACTION_DECREASE));
ESP_ERROR_CHECK(pcnt_channel_set_level_action(pcnt_chan_b, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
ESP_ERROR_CHECK(pcnt_unit_add_watch_point(encPcntUnit, low_limit));
ESP_ERROR_CHECK(pcnt_unit_add_watch_point(encPcntUnit, high_limit));
ESP_ERROR_CHECK(pcnt_unit_enable(encPcntUnit));
ESP_ERROR_CHECK(pcnt_unit_clear_count(encPcntUnit));
ESP_ERROR_CHECK(pcnt_unit_start(encPcntUnit));
}
int TpagerKeyboard::getEncoderPulses() {
int pulses = 0;
pcnt_unit_get_count(encPcntUnit, &pulses);
return pulses;
}
bool TpagerKeyboard::initBacklight(gpio_num_t pin, uint32_t frequencyHz, ledc_timer_t timer, ledc_channel_t channel) {
backlightPin = pin;
backlightTimer = timer;
backlightChannel = channel;
ledc_timer_config_t ledc_timer = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.duty_resolution = LEDC_TIMER_8_BIT,
.timer_num = backlightTimer,
.freq_hz = frequencyHz,
.clk_cfg = LEDC_AUTO_CLK,
.deconfigure = false
};
if (ledc_timer_config(&ledc_timer) != ESP_OK) {
TT_LOG_E(TAG, "Backlight timer config failed");
return false;
}
ledc_channel_config_t ledc_channel = {
.gpio_num = backlightPin,
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = backlightChannel,
.intr_type = LEDC_INTR_DISABLE,
.timer_sel = backlightTimer,
.duty = 0,
.hpoint = 0,
.sleep_mode = LEDC_SLEEP_MODE_NO_ALIVE_NO_PD,
.flags = {
.output_invert = 0
}
};
if (ledc_channel_config(&ledc_channel) != ESP_OK) {
TT_LOG_E(TAG, "Backlight channel config failed");
}
return true;
}
bool TpagerKeyboard::setBacklightDuty(uint8_t duty) {
if (!backlightOkay) {
TT_LOG_E(TAG, "Backlight not ready");
return false;
}
return (ledc_set_duty(LEDC_LOW_SPEED_MODE, backlightChannel, duty) == ESP_OK) &&
(ledc_update_duty(LEDC_LOW_SPEED_MODE, backlightChannel) == ESP_OK);
}
void TpagerKeyboard::makeBacklightImpulse() {
backlightImpulseDuty = 255;
setBacklightDuty(backlightImpulseDuty);
}
void TpagerKeyboard::processBacklightImpuse() {
if (backlightImpulseDuty > 64) {
backlightImpulseDuty--;
setBacklightDuty(backlightImpulseDuty);
}
}
extern std::shared_ptr<Tca8418> tca8418;
std::shared_ptr<tt::hal::keyboard::KeyboardDevice> createKeyboard() {
keyboardMsg = xQueueCreate(20, sizeof(char));
return std::make_shared<TpagerKeyboard>(tca8418);
}

52
Boards/LilygoTLoraPager/Source/hal/TpagerKeyboard.h
View File

@ -1,52 +0,0 @@
#pragma once
#include <Tactility/hal/keyboard/KeyboardDevice.h>
#include <Tactility/TactilityCore.h>
#include <Tca8418.h>
#include <driver/pulse_cnt.h>
#include <driver/ledc.h>
#include <driver/gpio.h>
#include <Tactility/Timer.h>
class TpagerKeyboard : public tt::hal::keyboard::KeyboardDevice {
private:
lv_indev_t* _Nullable kbHandle = nullptr;
lv_indev_t* _Nullable encHandle = nullptr;
pcnt_unit_handle_t encPcntUnit = nullptr;
gpio_num_t backlightPin = GPIO_NUM_NC;
ledc_timer_t backlightTimer;
ledc_channel_t backlightChannel;
bool backlightOkay = false;
int backlightImpulseDuty = 0;
std::shared_ptr<Tca8418> keypad;
std::unique_ptr<tt::Timer> inputTimer;
std::unique_ptr<tt::Timer> backlightImpulseTimer;
void initEncoder(void);
bool initBacklight(gpio_num_t pin, uint32_t frequencyHz, ledc_timer_t timer, ledc_channel_t channel);
void processKeyboard();
void processBacklightImpuse();
public:
TpagerKeyboard(std::shared_ptr<Tca8418> tca) : keypad(std::move(tca)) {}
~TpagerKeyboard() {}
std::string getName() const final { return "T-Lora Pager Keyboard"; }
std::string getDescription() const final { return "I2C keyboard with encoder"; }
bool start(lv_display_t* display) override;
bool stop() override;
bool isAttached() const override;
lv_indev_t* _Nullable getLvglIndev() override { return kbHandle; }
int getEncoderPulses();
bool setBacklightDuty(uint8_t duty);
void makeBacklightImpulse();
};
std::shared_ptr<tt::hal::keyboard::KeyboardDevice> createKeyboard();

91
Boards/LilygoTLoraPager/Source/hal/TpagerPower.cpp
View File

@ -1,91 +0,0 @@
#include "TpagerPower.h"
#include <Tactility/Log.h>
#define TAG "power"
#define TPAGER_GAUGE_I2C_BUS_HANDLE I2C_NUM_0
/*
TpagerPower::TpagerPower() : gauge(TPAGER_GAUGE_I2C_BUS_HANDLE) {
gauge->configureCapacity(1500, 1500);
}*/
TpagerPower::~TpagerPower() {}
bool TpagerPower::supportsMetric(MetricType type) const {
switch (type) {
using enum MetricType;
case IsCharging:
case Current:
case BatteryVoltage:
case ChargeLevel:
return true;
default:
return false;
}
return false; // Safety guard for when new enum values are introduced
}
bool TpagerPower::getMetric(MetricType type, MetricData& data) {
/* IsCharging, // bool
Current, // int32_t, mAh - battery current: either during charging (positive value) or discharging (negative value)
BatteryVoltage, // uint32_t, mV
ChargeLevel, // uint8_t [0, 100]
*/
uint16_t u16 = 0;
int16_t s16 = 0;
switch (type) {
using enum MetricType;
case IsCharging:
Bq27220::BatteryStatus status;
if(gauge->getBatteryStatus(status)) {
data.valueAsBool = !status.reg.DSG;
return true;
}
return false;
break;
case Current:
if (gauge->getCurrent(s16)) {
data.valueAsInt32 = s16;
return true;
} else {
return false;
}
break;
case BatteryVoltage:
if (gauge->getVoltage(u16)) {
data.valueAsUint32 = u16;
return true;
} else {
return false;
}
break;
case ChargeLevel:
if (gauge->getStateOfCharge(u16)) {
data.valueAsUint8 = u16;
return true;
} else {
return false;
}
break;
default:
return false;
break;
}
return false; // Safety guard for when new enum values are introduced
}
static std::shared_ptr<PowerDevice> power;
extern std::shared_ptr<Bq27220> bq27220;
std::shared_ptr<PowerDevice> tpager_get_power() {
if (power == nullptr) {
power = std::make_shared<TpagerPower>(bq27220);
}
return power;
}

25
Boards/LilygoTLoraPager/Source/hal/TpagerPower.h
View File

@ -1,25 +0,0 @@
#pragma once
#include "Tactility/hal/power/PowerDevice.h"
#include <Bq27220.h>
#include <memory>
using tt::hal::power::PowerDevice;
class TpagerPower : public PowerDevice {
std::shared_ptr<Bq27220> gauge;
public:
TpagerPower(std::shared_ptr<Bq27220> bq) : gauge(std::move(bq)) {}
~TpagerPower();
std::string getName() const final { return "T-LoRa Pager Power measument"; }
std::string getDescription() const final { return "Power measurement interface via I2C fuel gauge"; }
bool supportsMetric(MetricType type) const override;
bool getMetric(MetricType type, MetricData& data) override;
private:
};
std::shared_ptr<PowerDevice> tpager_get_power();

33
Boards/LilygoTLoraPager/Source/hal/TpagerSdCard.cpp
View File

@ -1,33 +0,0 @@
#include "TpagerSdCard.h"
#include <Tactility/lvgl/LvglSync.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <esp_vfs_fat.h>
using tt::hal::sdcard::SpiSdCardDevice;
#define TDECK_SDCARD_PIN_CS GPIO_NUM_21
#define TDECK_LCD_PIN_CS GPIO_NUM_38
#define TDECK_RADIO_PIN_CS GPIO_NUM_36
std::shared_ptr<SdCardDevice> createTpagerSdCard() {
auto* configuration = new SpiSdCardDevice::Config(
TDECK_SDCARD_PIN_CS,
GPIO_NUM_NC,
GPIO_NUM_NC,
GPIO_NUM_NC,
SdCardDevice::MountBehaviour::AtBoot,
tt::lvgl::getSyncLock(),
{
TDECK_RADIO_PIN_CS,
TDECK_LCD_PIN_CS
}
);
auto* sdcard = (SdCardDevice*) new SpiSdCardDevice(
std::unique_ptr<SpiSdCardDevice::Config>(configuration)
);
return std::shared_ptr<SdCardDevice>(sdcard);
}

7
Boards/LilygoTLoraPager/Source/hal/TpagerSdCard.h
View File

@ -1,7 +0,0 @@
#pragma once
#include "Tactility/hal/sdcard/SdCardDevice.h"
using tt::hal::sdcard::SdCardDevice;
std::shared_ptr<SdCardDevice> createTpagerSdCard();

6
Buildscripts/board.cmake
View File

@ -19,7 +19,7 @@ function(INIT_TACTILITY_GLOBALS SDKCONFIG_FILE)
set(id_length 0)
math(EXPR id_length "${sdkconfig_board_id_length} - 21")
string(SUBSTRING ${sdkconfig_board_id} 20 ${id_length} board_id)
message("Board name: ${Cyan}${board_id}${ColorReset}")
message("Building board: ${Cyan}${board_id}${ColorReset}")
if (board_id STREQUAL "cyd-2432s024c")
set(TACTILITY_BOARD_PROJECT CYD-2432S024C)
@ -47,8 +47,6 @@ function(INIT_TACTILITY_GLOBALS SDKCONFIG_FILE)
set(TACTILITY_BOARD_PROJECT ElecrowCrowpanelBasic50)
elseif (board_id STREQUAL "lilygo-tdeck")
set(TACTILITY_BOARD_PROJECT LilygoTdeck)
elseif (board_id STREQUAL "lilygo-tlora-pager")
set(TACTILITY_BOARD_PROJECT LilygoTLoraPager)
elseif (board_id STREQUAL "m5stack-core2")
set(TACTILITY_BOARD_PROJECT M5stackCore2)
elseif (board_id STREQUAL "m5stack-cores3")
@ -64,7 +62,7 @@ function(INIT_TACTILITY_GLOBALS SDKCONFIG_FILE)
if (TACTILITY_BOARD_PROJECT STREQUAL "")
message(FATAL_ERROR "No subproject mapped to \"${TACTILITY_BOARD_ID}\" in root Buildscripts/board.cmake")
else ()
message("Board path: ${Cyan}Boards/${TACTILITY_BOARD_PROJECT}${ColorReset}\n")
message("Board project: ${Cyan}Boards/${TACTILITY_BOARD_PROJECT}${ColorReset}\n")
set_property(GLOBAL PROPERTY TACTILITY_BOARD_PROJECT ${TACTILITY_BOARD_PROJECT})
set_property(GLOBAL PROPERTY TACTILITY_BOARD_ID ${board_id})
endif ()

5
Buildscripts/build.sh
View File

@ -27,13 +27,12 @@ fi
echoNewPhase "Cleaning build folder"
#rm -rf build
rm -rf build
echoNewPhase "Building $sdkconfig_file"
cp $sdkconfig_file sdkconfig
idf.py build
if [[ $? != 0 ]]; then
if not idf.py build; then
fatalError "Failed to build esp32s3 SDK"
fi

3
CMakeLists.txt
View File

@ -21,7 +21,7 @@ file(READ version.txt TACTILITY_VERSION)
add_compile_definitions(TT_VERSION="${TACTILITY_VERSION}")
if (DEFINED ENV{ESP_IDF_VERSION})
message("Using ESP-IDF ${Cyan}v$ENV{ESP_IDF_VERSION}${ColorReset}")
message("Building with ESP-IDF ${Cyan}v$ENV{ESP_IDF_VERSION}${ColorReset}")
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
include("Buildscripts/board.cmake")
@ -38,7 +38,6 @@ if (DEFINED ENV{ESP_IDF_VERSION})
"TactilityC"
"TactilityCore"
"Libraries/esp_lvgl_port"
"Libraries/esp_lcd_st7796"
"Libraries/elf_loader"
"Libraries/lvgl"
"Libraries/lv_screenshot"

14
Data/system_sources/app/Launcher/apps.svg
View File

@ -7,9 +7,9 @@
version="1.1"
id="svg1"
sodipodi:docname="apps.svg"
inkscape:export-filename="icon_apps.png"
inkscape:export-xdpi="160"
inkscape:export-ydpi="160"
inkscape:export-filename="apps.png"
inkscape:export-xdpi="192"
inkscape:export-ydpi="192"
inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
@ -27,10 +27,10 @@
inkscape:pagecheckerboard="0"
inkscape:deskcolor="#d1d1d1"
inkscape:zoom="17.088414"
inkscape:cx="14.600536"
inkscape:cy="18.960215"
inkscape:window-width="1503"
inkscape:window-height="933"
inkscape:cx="14.629795"
inkscape:cy="18.901696"
inkscape:window-width="2560"
inkscape:window-height="1371"
inkscape:window-x="0"
inkscape:window-y="0"
inkscape:window-maximized="1"

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.8 KiB

After

Width:  |  Height:  |  Size: 3.8 KiB

12
Data/system_sources/app/Launcher/folder.svg
View File

@ -7,9 +7,9 @@
version="1.1"
id="svg1"
sodipodi:docname="folder.svg"
inkscape:export-filename="icon_files.png"
inkscape:export-xdpi="160"
inkscape:export-ydpi="160"
inkscape:export-filename="folder.png"
inkscape:export-xdpi="192"
inkscape:export-ydpi="192"
inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
@ -27,10 +27,10 @@
inkscape:pagecheckerboard="0"
inkscape:deskcolor="#d1d1d1"
inkscape:zoom="48.333333"
inkscape:cx="11.989655"
inkscape:cx="12"
inkscape:cy="12"
inkscape:window-width="1503"
inkscape:window-height="933"
inkscape:window-width="2560"
inkscape:window-height="1371"
inkscape:window-x="0"
inkscape:window-y="0"
inkscape:window-maximized="1"

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.7 KiB

After

Width:  |  Height:  |  Size: 1.7 KiB

18
Data/system_sources/app/Launcher/settings.svg
View File

@ -7,9 +7,9 @@
version="1.1"
id="svg1"
sodipodi:docname="settings.svg"
inkscape:export-filename="icon_settings.png"
inkscape:export-xdpi="160"
inkscape:export-ydpi="160"
inkscape:export-filename="settings.png"
inkscape:export-xdpi="192"
inkscape:export-ydpi="192"
inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
@ -27,13 +27,13 @@
inkscape:pagecheckerboard="0"
inkscape:deskcolor="#d1d1d1"
inkscape:zoom="48.333333"
inkscape:cx="11.989655"
inkscape:cx="12"
inkscape:cy="12"
inkscape:window-width="1503"
inkscape:window-height="933"
inkscape:window-x="0"
inkscape:window-y="0"
inkscape:window-maximized="1"
inkscape:window-width="1898"
inkscape:window-height="1269"
inkscape:window-x="26"
inkscape:window-y="23"
inkscape:window-maximized="0"
inkscape:current-layer="svg1" />
<path
d="M 347.80751,0.69994853 328.57952,-153.12403 q -15.62275,-6.00875 -29.44288,-14.421 -13.82012,-8.41225 -27.03937,-18.02625 L 129.08904,-125.48379 -3.1034483,-353.81626 120.67679,-447.55275 q -1.20175,-8.41225 -1.20175,-16.22363 v -32.44724 q 0,-7.81138 1.20175,-16.22363 L -3.1034483,-606.18374 129.08904,-834.51621 l 143.00823,60.08749 q 13.21925,-9.614 27.64025,-18.02625 14.421,-8.41225 28.842,-14.421 l 19.22799,-153.82398 h 264.38498 l 19.22799,153.82398 q 15.62275,6.00875 29.44288,14.421 13.82012,8.41225 27.03937,18.02625 l 143.00823,-60.08749 132.19249,228.33247 -123.78024,93.73649 q 1.20175,8.41225 1.20175,16.22363 v 32.44724 q 0,7.81138 -2.4035,16.22363 l 123.78024,93.73649 -132.19249,228.33247 -141.80648,-60.08749 q -13.21925,9.614 -27.64025,18.02625 -14.421,8.41225 -28.842,14.421 L 612.19249,0.69994853 Z m 84.1225,-96.13998953 h 94.93823 l 16.8245,-127.385489 q 37.25425,-9.614 69.10062,-28.24112 31.84637,-18.62712 58.28487,-45.06562 l 118.97324,49.27175 46.86824,-81.719 -103.35049,-78.11374 q 6.00875,-16.8245 8.41225,-35.45162 2.4035,-18.62712 2.4035,-37.85512 0,-19.228 -2.4035,-37.85512 -2.4035,-18.62712 -8.41225,-35.45162 l 103.35049,-78.11374 -46.86824,-81.719 -118.97324,50.4735 q -26.4385,-27.64025 -58.28487,-46.26737 -31.84637,-18.62712 -69.10062,-28.24112 l -15.62275,-127.38549 h -94.93823 l -16.8245,127.38549 q -37.25425,9.614 -69.10062,28.24112 -31.84637,18.62712 -58.28487,45.06562 l -118.97324,-49.27175 -46.86824,81.719 103.35049,76.91199 q -6.00875,18.02625 -8.41225,36.05249 -2.4035,18.02625 -2.4035,38.456 0,19.228 2.4035,37.25425 2.4035,18.02624 8.41225,36.05249 l -103.35049,78.11374 46.86824,81.719 118.97324,-50.4735 q 26.4385,27.64025 58.28487,46.26737 31.84637,18.62712 69.10062,28.24112 z M 482.4035,-311.75502 q 69.70149,0 118.97324,-49.27174 49.27174,-49.27175 49.27174,-118.97324 0,-69.70149 -49.27174,-118.97324 -49.27175,-49.27174 -118.97324,-49.27174 -70.90324,0 -119.57411,49.27174 -48.67087,49.27175 -48.67087,118.97324 0,69.70149 48.67087,118.97324 48.67087,49.27174 119.57411,49.27174 z M 480,-480 Z"

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.2 KiB

After

Width:  |  Height:  |  Size: 3.2 KiB

BIN
Documentation/pics/screenshot-AppList.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 4.1 KiB

After

Width:  |  Height:  |  Size: 4.1 KiB

BIN
Documentation/pics/screenshot-Desktop.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.8 KiB

BIN
Documentation/pics/screenshot-Files.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.5 KiB

BIN
Documentation/pics/screenshot-HelloWorld.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.1 KiB

BIN
Documentation/pics/screenshot-Launcher.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.0 KiB

BIN
Documentation/pics/screenshot-Settings.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.8 KiB

After

Width:  |  Height:  |  Size: 3.6 KiB

BIN
Documentation/pics/screenshot-WifiManage.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.9 KiB

28
Documentation/releasing.md
View File

@ -1,28 +0,0 @@
# Releasing Tactility
1. Test the latest version on several devices
2. Build the SDK locally and test it with `ExternalApps/HelloWorld`
3. Test the latest SDK build from GitHub with the CDN:
1. Download it from the [main branch](https://github.com/ByteWelder/Tactility/actions/workflows/build-sdk.yml)
2. Upload it to the [CDN](https://dash.cloudflare.com)
3. Update `sdk.json` from [TactilityTool](https://github.com/ByteWelder/TactilityTool) and upload it to [CDN](https://dash.cloudflare.com)
4. Test it with `ExternalApps/HelloWorld` (clear all its cache and update the SDK version)
4. Download the latest firmwares [main branch](https://github.com/ByteWelder/Tactility/actions/workflows/build-firmware.yml)
5. Prepare a new version of [TactilityWebInstaller](https://github.com/ByteWelder/TactilityWebInstaller) locally:
1. Copy the GitHub firmwares into `scripts/` in the `TactilityWebInstaller` project
2. Run `python release-all.py`
3. Copy the unpacked files to `/rom/(device)/(version)/` and copy in `manifest.json` from existing release
1. **WARNING** If the partitions have changed, update the json!
4. Update the version in `manifest.json`
5. Update `version.json` for the device
6. Test the firmwares on all devices with the local web installer
7. If all went well: release the web installer
8. Test web installer in production (use popular devices)
9. Make a new version of the docs available at [TactilityDocs](https://github.com/ByteWelder/TactilityDocs)
10. Make a new [GitHub release](https://github.com/ByteWelder/Tactility/releases/new)
### Post-release
1. Mention on Discord
2. Consider notifying vendors/stakeholders
3. Remove dev versions in `sdk.json`from [TactilityTool](https://github.com/ByteWelder/TactilityTool) and upload it to [CDN](https://dash.cloudflare.com)

5
Drivers/BQ27220/CMakeLists.txt
View File

@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "Source"
INCLUDE_DIRS "Source"
REQUIRES Tactility
)

5
Drivers/BQ27220/README.md
View File

@ -1,5 +0,0 @@
# BQ24295
Power management: I2C-controlled 3A single cell USB charger with narrow VDC 4.5-5.5V adjustable voltage at 1.5A synchronous boost operation.
[Datasheet](https://www.ti.com/lit/ds/symlink/bq24295.pdf)

372
Drivers/BQ27220/Source/Bq27220.cpp
View File

@ -1,372 +0,0 @@
#include "Bq27220.h"
#include <Tactility/Log.h>
#include "esp_sleep.h"
#define TAG "bq27220"
#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
uint8_t highByte(const uint16_t word) { return (word >> 8) & 0xFF; }
uint8_t lowByte(const uint16_t word) { return word & 0xFF; }
void swapEndianess(uint16_t &word) { word = (lowByte(word) << 8) | highByte(word); }
namespace registers {
static const uint16_t SUBCMD_CTRL_STATUS = 0x0000U;
static const uint16_t SUBCMD_DEVICE_NUMBER = 0x0001U;
static const uint16_t SUBCMD_FW_VERSION = 0x0002U;
static const uint16_t SUBCMD_HW_VERSION = 0x0003U;
static const uint16_t SUBCMD_BOARD_OFFSET = 0x0009U;
static const uint16_t SUBCMD_CC_OFFSET = 0x000AU;
static const uint16_t SUBCMD_CC_OFFSET_SAVE = 0x000BU;
static const uint16_t SUBCMD_OCV_CMD = 0x000CU;
static const uint16_t SUBCMD_BAT_INSERT = 0x000DU;
static const uint16_t SUBCMD_BAT_REMOVE = 0x000EU;
static const uint16_t SUBCMD_SET_SNOOZE = 0x0013U;
static const uint16_t SUBCMD_CLEAR_SNOOZE = 0x0014U;
static const uint16_t SUBCMD_SET_PROFILE_1 = 0x0015U;
static const uint16_t SUBCMD_SET_PROFILE_2 = 0x0016U;
static const uint16_t SUBCMD_SET_PROFILE_3 = 0x0017U;
static const uint16_t SUBCMD_SET_PROFILE_4 = 0x0018U;
static const uint16_t SUBCMD_SET_PROFILE_5 = 0x0019U;
static const uint16_t SUBCMD_SET_PROFILE_6 = 0x001AU;
static const uint16_t SUBCMD_CAL_TOGGLE = 0x002DU;
static const uint16_t SUBCMD_SEALED = 0x0030U;
static const uint16_t SUBCMD_RESET = 0x0041U;
static const uint16_t SUBCMD_EXIT_CAL = 0x0080U;
static const uint16_t SUBCMD_ENTER_CAL = 0x0081U;
static const uint16_t SUBCMD_ENTER_CFG_UPDATE = 0x0090U;
static const uint16_t SUBCMD_EXIT_CFG_UPDATE_REINIT = 0x0091U;
static const uint16_t SUBCMD_EXIT_CFG_UPDATE = 0x0092U;
static const uint16_t SUBCMD_RETURN_TO_ROM = 0x0F00U;
static const uint8_t CMD_CONTROL = 0x00U;
static const uint8_t CMD_AT_RATE = 0x02U;
static const uint8_t CMD_AT_RATE_TIME_TO_EMPTY = 0x04U;
static const uint8_t CMD_TEMPERATURE = 0x06U;
static const uint8_t CMD_VOLTAGE = 0x08U;
static const uint8_t CMD_BATTERY_STATUS = 0x0AU;
static const uint8_t CMD_CURRENT = 0x0CU;
static const uint8_t CMD_REMAINING_CAPACITY = 0x10U;
static const uint8_t CMD_FULL_CHARGE_CAPACITY = 0x12U;
static const uint8_t CMD_AVG_CURRENT = 0x14U;
static const uint8_t CMD_TIME_TO_EMPTY = 0x16U;
static const uint8_t CMD_TIME_TO_FULL = 0x18U;
static const uint8_t CMD_STANDBY_CURRENT = 0x1AU;
static const uint8_t CMD_STANDBY_TIME_TO_EMPTY = 0x1CU;
static const uint8_t CMD_MAX_LOAD_CURRENT = 0x1EU;
static const uint8_t CMD_MAX_LOAD_TIME_TO_EMPTY = 0x20U;
static const uint8_t CMD_RAW_COULOMB_COUNT = 0x22U;
static const uint8_t CMD_AVG_POWER = 0x24U;
static const uint8_t CMD_INTERNAL_TEMPERATURE = 0x28U;
static const uint8_t CMD_CYCLE_COUNT = 0x2AU;
static const uint8_t CMD_STATE_OF_CHARGE = 0x2CU;
static const uint8_t CMD_STATE_OF_HEALTH = 0x2EU;
static const uint8_t CMD_CHARGE_VOLTAGE = 0x30U;
static const uint8_t CMD_CHARGE_CURRENT = 0x32U;
static const uint8_t CMD_BTP_DISCHARGE_SET = 0x34U;
static const uint8_t CMD_BTP_CHARGE_SET = 0x36U;
static const uint8_t CMD_OPERATION_STATUS = 0x3AU;
static const uint8_t CMD_DESIGN_CAPACITY = 0x3CU;
static const uint8_t CMD_SELECT_SUBCLASS = 0x3EU;
static const uint8_t CMD_MAC_DATA = 0x40U;
static const uint8_t CMD_MAC_DATA_SUM = 0x60U;
static const uint8_t CMD_MAC_DATA_LEN = 0x61U;
static const uint8_t CMD_ANALOG_COUNT = 0x79U;
static const uint8_t CMD_RAW_CURRENT = 0x7AU;
static const uint8_t CMD_RAW_VOLTAGE = 0x7CU;
static const uint8_t CMD_RAW_INTERNAL_TEMPERATURE = 0x7EU;
static const uint8_t MAC_BUFFER_START = 0x40U;
static const uint8_t MAC_BUFFER_END = 0x5FU;
static const uint8_t MAC_DATA_SUM = 0x60U;
static const uint8_t MAC_DATA_LEN = 0x61U;
static const uint8_t ROM_START = 0x3EU;
static const uint16_t ROM_FULL_CHARGE_CAPACITY = 0x929DU;
static const uint16_t ROM_DESIGN_CAPACITY = 0x929FU;
static const uint16_t ROM_OPERATION_CONFIG_A = 0x9206U;
static const uint16_t ROM_OPERATION_CONFIG_B = 0x9208U;
} // namespace registers
bool Bq27220::configureCapacity(uint16_t designCapacity, uint16_t fullChargeCapacity) {
return performConfigUpdate([this, designCapacity, fullChargeCapacity]() {
// Set the design capacity
if (!writeConfig16(registers::ROM_DESIGN_CAPACITY, designCapacity)) {
TT_LOG_E(TAG, "Failed to set design capacity!");
return false;
}
vTaskDelay(10 / portTICK_PERIOD_MS);
// Set full charge capacity
if (!writeConfig16(registers::ROM_FULL_CHARGE_CAPACITY, fullChargeCapacity)) {
TT_LOG_E(TAG, "Failed to set full charge capacity!");
return false;
}
vTaskDelay(10 / portTICK_PERIOD_MS);
return true;
});
}
bool Bq27220::getVoltage(uint16_t &value) {
if (readRegister16(registers::CMD_VOLTAGE, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getCurrent(int16_t &value) {
uint16_t u16 = 0;
if (readRegister16(registers::CMD_CURRENT, u16)) {
swapEndianess(u16);
value = (int16_t)u16;
return true;
}
return false;
}
bool Bq27220::getBatteryStatus(Bq27220::BatteryStatus &batt_sta) {
if (readRegister16(registers::CMD_BATTERY_STATUS, batt_sta.full)) {
swapEndianess(batt_sta.full);
return true;
}
return false;
}
bool Bq27220::getOperationStatus(OperationStatus &oper_sta) {
if (readRegister16(registers::CMD_OPERATION_STATUS, oper_sta.full)) {
swapEndianess(oper_sta.full);
return true;
}
return false;
}
bool Bq27220::getTemperature(uint16_t &value) {
if (readRegister16(registers::CMD_TEMPERATURE, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getFullChargeCapacity(uint16_t &value) {
if (readRegister16(registers::CMD_FULL_CHARGE_CAPACITY, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getDesignCapacity(uint16_t &value) {
if (readRegister16(registers::CMD_DESIGN_CAPACITY, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getRemainingCapacity(uint16_t &value) {
if (readRegister16(registers::CMD_REMAINING_CAPACITY, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getStateOfCharge(uint16_t &value) {
if (readRegister16(registers::CMD_STATE_OF_CHARGE, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getStateOfHealth(uint16_t &value) {
if (readRegister16(registers::CMD_STATE_OF_HEALTH, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::getChargeVoltageMax(uint16_t &value) {
if (readRegister16(registers::CMD_CHARGE_VOLTAGE, value)) {
swapEndianess(value);
return true;
}
return false;
}
bool Bq27220::unsealDevice() {
uint8_t cmd1[] = {0x00, 0x14, 0x04};
if (!write(cmd1, ARRAYSIZE(cmd1))) {
return false;
}
vTaskDelay(50 / portTICK_PERIOD_MS);
uint8_t cmd2[] = {0x00, 0x72, 0x36};
if (!write(cmd2, ARRAYSIZE(cmd2))) {
return false;
}
vTaskDelay(50 / portTICK_PERIOD_MS);
return true;
}
bool Bq27220::unsealFullAccess()
{
uint8_t buffer[3];
buffer[0] = 0x00;
buffer[1] = lowByte((accessKey >> 24));
buffer[2] = lowByte((accessKey >> 16));
if (!write(buffer, ARRAYSIZE(buffer))) {
return false;
}
vTaskDelay(50 / portTICK_PERIOD_MS);
buffer[1] = lowByte((accessKey >> 8));
buffer[2] = lowByte((accessKey));
if (!write(buffer, ARRAYSIZE(buffer))) {
return false;
}
vTaskDelay(50 / portTICK_PERIOD_MS);
return true;
}
bool Bq27220::exitSealMode() {
return sendSubCommand(registers::SUBCMD_SEALED);
}
bool Bq27220::sendSubCommand(uint16_t subCmd, bool waitConfirm)
{
uint8_t buffer[3];
buffer[0] = 0x00;
buffer[1] = lowByte(subCmd);
buffer[2] = highByte(subCmd);
if (!write(buffer, ARRAYSIZE(buffer))) {
return false;
}
if (!waitConfirm) {
vTaskDelay(10 / portTICK_PERIOD_MS);
return true;
}
constexpr uint8_t statusReg = 0x00;
int waitCount = 20;
vTaskDelay(10 / portTICK_PERIOD_MS);
while (waitCount--) {
writeRead(&statusReg, 1, buffer, 2);
uint16_t *value = reinterpret_cast<uint16_t *>(buffer);
if (*value == 0xFFA5) {
return true;
}
vTaskDelay(100 / portTICK_PERIOD_MS);
}
TT_LOG_E(TAG, "Subcommand x%X failed!", subCmd);
return false;
}
bool Bq27220::writeConfig16(uint16_t address, uint16_t value) {
constexpr uint8_t fixedDataLength = 0x06;
const uint8_t msbAccessValue = highByte(address);
const uint8_t lsbAccessValue = lowByte(address);
// Write to access the MSB of Capacity
writeRegister8(registers::ROM_START, msbAccessValue);
// Write to access the LSB of Capacity
writeRegister8(registers::ROM_START + 1, lsbAccessValue);
// Write two Capacity bytes starting from 0x40
uint8_t valueMsb = highByte(value);
uint8_t valueLsb = lowByte(value);
uint8_t configRaw[] = {valueMsb, valueLsb};
writeRegister(registers::MAC_BUFFER_START, configRaw, 2);
// Calculate new checksum
uint8_t checksum = 0xFF - ((msbAccessValue + lsbAccessValue + valueMsb + valueLsb) & 0xFF);
// Write new checksum (0x60)
writeRegister8(registers::MAC_DATA_SUM, checksum);
// Write the block length
writeRegister8(registers::MAC_DATA_LEN, fixedDataLength);
return true;
}
bool Bq27220::configPreamble(bool &isSealed) {
int timeout = 0;
OperationStatus status;
// Check access settings
if(!getOperationStatus(status)) {
TT_LOG_E(TAG, "Cannot read initial operation status!");
return false;
}
if (status.reg.SEC == OperationStatusSecSealed) {
isSealed = true;
if (!unsealDevice()) {
TT_LOG_E(TAG, "Unsealing device failure!");
return false;
}
}
if (status.reg.SEC != OperationStatusSecFull) {
if (!unsealFullAccess()) {
TT_LOG_E(TAG, "Unsealing full access failure!");
return false;
} else {
TT_LOG_I(TAG, "Full access theoretically.");
}
}
// Send ENTER_CFG_UPDATE command (0x0090)
if (!sendSubCommand(registers::SUBCMD_ENTER_CFG_UPDATE)) {
TT_LOG_E(TAG, "Config Update Subcommand failure!");
}
// Confirm CFUPDATE mode by polling the OperationStatus() register until Bit 2 is set.
bool isConfigUpdate = false;
for (timeout = 30; timeout; --timeout) {
getOperationStatus(status);
if (status.reg.CFGUPDATE) {
isConfigUpdate = true;
break;
}
vTaskDelay(100 / portTICK_PERIOD_MS);
}
if (!isConfigUpdate) {
TT_LOG_E(TAG, "Update Mode timeout, maybe the access key for full permissions is invalid!");
return false;
}
return true;
}
bool Bq27220::configEpilouge(const bool isSealed) {
int timeout = 0;
OperationStatus status;
// Exit CFUPDATE mode by sending the EXIT_CFG_UPDATE_REINIT (0x0091) or EXIT_CFG_UPDATE (0x0092) command
sendSubCommand(registers::SUBCMD_EXIT_CFG_UPDATE_REINIT);
vTaskDelay(10 / portTICK_PERIOD_MS);
// Confirm that CFUPDATE mode has been exited by polling the OperationStatus() register until bit 2 is cleared
for (timeout = 60; timeout; --timeout) {
getOperationStatus(status);
if (!status.reg.CFGUPDATE) {
break;
}
vTaskDelay(100 / portTICK_PERIOD_MS);
}
if (timeout == 0) {
TT_LOG_E(TAG, "Timed out waiting to exit update mode.");
return false;
}
// If the device was previously in SEALED state, return to SEALED mode by sending the Control(0x0030) subcommand
if (isSealed) {
TT_LOG_D(TAG, "Restore Safe Mode!");
exitSealMode();
}
return true;
}

103
Drivers/BQ27220/Source/Bq27220.h
View File

@ -1,103 +0,0 @@
#pragma once
#include <Tactility/hal/i2c/I2cDevice.h>
#define BQ27220_ADDRESS 0x55
class Bq27220 final : public tt::hal::i2c::I2cDevice {
private:
uint32_t accessKey;
bool unsealDevice();
bool unsealFullAccess();
bool exitSealMode();
bool sendSubCommand(uint16_t subCmd, bool waitConfirm = false);
bool writeConfig16(uint16_t address, uint16_t value);
bool configPreamble(bool &isSealed);
bool configEpilouge(const bool isSealed);
template<typename T>
bool performConfigUpdate(T configUpdateFunc)
{
bool isSealed = false;
if (!configPreamble(isSealed)) {
return false;
}
bool result = configUpdateFunc();
configEpilouge(isSealed);
return result;
}
public:
union BatteryStatus {
struct
{
// Low byte, Low bit first
uint16_t DSG : 1; /**< The device is in DISCHARGE */
uint16_t SYSDWN : 1; /**< System down bit indicating the system should shut down */
uint16_t TDA : 1; /**< Terminate Discharge Alarm */
uint16_t BATTPRES : 1; /**< Battery Present detected */
uint16_t AUTH_GD : 1; /**< Detect inserted battery */
uint16_t OCVGD : 1; /**< Good OCV measurement taken */
uint16_t TCA : 1; /**< Terminate Charge Alarm */
uint16_t RSVD : 1; /**< Reserved */
// High byte, Low bit first
uint16_t CHGING : 1; /**< Charge inhibit */
uint16_t FC : 1; /**< Full-charged is detected */
uint16_t OTD : 1; /**< Overtemperature in discharge condition is detected */
uint16_t OTC : 1; /**< Overtemperature in charge condition is detected */
uint16_t SLEEP : 1; /**< Device is operating in SLEEP mode when set */
uint16_t OCVFALL : 1; /**< Status bit indicating that the OCV reading failed due to current */
uint16_t OCVCOMP : 1; /**< An OCV measurement update is complete */
uint16_t FD : 1; /**< Full-discharge is detected */
} reg;
uint16_t full;
};
enum OperationStatusSec {
OperationStatusSecSealed = 0b11,
OperationStatusSecUnsealed = 0b10,
OperationStatusSecFull = 0b01,
};
union OperationStatus {
struct
{
// Low byte, Low bit first
bool CALMD : 1; /**< Calibration mode enabled */
uint8_t SEC : 2; /**< Current security access */
bool EDV2 : 1; /**< EDV2 threshold exceeded */
bool VDQ : 1; /**< Indicates if Current discharge cycle is NOT qualified or qualified for an FCC updated */
bool INITCOMP : 1; /**< gauge initialization is complete */
bool SMTH : 1; /**< RemainingCapacity is scaled by smooth engine */
bool BTPINT : 1; /**< BTP threshold has been crossed */
// High byte, Low bit first
uint8_t RSVD1 : 2; /**< Reserved */
bool CFGUPDATE : 1; /**< Gauge is in CONFIG UPDATE mode */
uint8_t RSVD0 : 5; /**< Reserved */
} reg;
uint16_t full;
};
std::string getName() const final { return "BQ27220"; }
std::string getDescription() const final { return "I2C-controlled CEDV battery fuel gauge"; }
explicit Bq27220(i2c_port_t port) : I2cDevice(port, BQ27220_ADDRESS), accessKey(0xFFFFFFFF) {}
bool configureCapacity(uint16_t designCapacity, uint16_t fullChargeCapacity);
bool getVoltage(uint16_t &value);
bool getCurrent(int16_t &value);
bool getBatteryStatus(BatteryStatus &batt_sta);
bool getOperationStatus(OperationStatus &oper_sta);
bool getTemperature(uint16_t &value);
bool getFullChargeCapacity(uint16_t &value);
bool getDesignCapacity(uint16_t &value);
bool getRemainingCapacity(uint16_t &value);
bool getStateOfCharge(uint16_t &value);
bool getStateOfHealth(uint16_t &value);
bool getChargeVoltageMax(uint16_t &value);
};

5
Drivers/ST7796/CMakeLists.txt
View File

@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "Source"
INCLUDE_DIRS "Source"
REQUIRES Tactility esp_lvgl_port esp_lcd_st7796 driver
)

3
Drivers/ST7796/README.md
View File

@ -1,3 +0,0 @@
# ST7789
A basic ESP32 LVGL driver for ST7789 displays.

217
Drivers/ST7796/Source/St7796Display.cpp
View File

@ -1,217 +0,0 @@
#include "St7796Display.h"
#include <Tactility/Log.h>
#include <esp_lcd_panel_commands.h>
#include <esp_lcd_panel_dev.h>
#include <esp_lcd_st7796.h>
#include <esp_lvgl_port.h>
#define TAG "st7796"
bool St7796Display::start() {
TT_LOG_I(TAG, "Starting");
const esp_lcd_panel_io_spi_config_t panel_io_config = {
.cs_gpio_num = configuration->csPin,
.dc_gpio_num = configuration->dcPin,
.spi_mode = 0,
.pclk_hz = configuration->pixelClockFrequency,
.trans_queue_depth = configuration->transactionQueueDepth,
.on_color_trans_done = nullptr,
.user_ctx = nullptr,
.lcd_cmd_bits = 8,
.lcd_param_bits = 8,
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.flags = {
.dc_high_on_cmd = 0,
.dc_low_on_data = 0,
.dc_low_on_param = 0,
.octal_mode = 0,
.quad_mode = 0,
.sio_mode = 0,
.lsb_first = 0,
.cs_high_active = 0
}
};
if (esp_lcd_new_panel_io_spi(configuration->spiBusHandle, &panel_io_config, &ioHandle) != ESP_OK) {
TT_LOG_E(TAG, "Failed to create panel");
return false;
}
static const st7796_lcd_init_cmd_t lcd_init_cmds[] = {
{0x01, (uint8_t []){0x00}, 0, 120},
{0x11, (uint8_t []){0x00}, 0, 120},
{0xF0, (uint8_t []){0xC3}, 1, 0},
{0xF0, (uint8_t []){0xC3}, 1, 0},
{0xF0, (uint8_t []){0x96}, 1, 0},
{0x36, (uint8_t []){0x58}, 1, 0},
{0x3A, (uint8_t []){0x55}, 1, 0},
{0xB4, (uint8_t []){0x01}, 1, 0},
{0xB6, (uint8_t []){0x80, 0x02, 0x3B}, 3, 0},
{0xE8, (uint8_t []){0x40, 0x8A, 0x00, 0x00, 0x29, 0x19, 0xA5, 0x33}, 8, 0},
{0xC1, (uint8_t []){0x06}, 1, 0},
{0xC2, (uint8_t []){0xA7}, 1, 0},
{0xC5, (uint8_t []){0x18}, 1, 0},
{0xE0, (uint8_t []){0xF0, 0x09, 0x0b, 0x06, 0x04, 0x15, 0x2F, 0x54, 0x42, 0x3C, 0x17, 0x14, 0x18, 0x1B}, 15, 0},
{0xE1, (uint8_t []){0xE0, 0x09, 0x0b, 0x06, 0x04, 0x03, 0x2B, 0x43, 0x42, 0x3B, 0x16, 0x14, 0x17, 0x1B}, 15, 120},
{0xF0, (uint8_t []){0x3C}, 1, 0},
{0xF0, (uint8_t []){0x69}, 1, 0},
{0x21, (uint8_t []){0x00}, 1, 0},
{0x29, (uint8_t []){0x00}, 1, 0},
};
st7796_vendor_config_t vendor_config = { // Uncomment these lines if use custom initialization commands
.init_cmds = lcd_init_cmds,
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(st7796_lcd_init_cmd_t),
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = configuration->resetPin, // Set to -1 if not use
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
.color_space = ESP_LCD_COLOR_SPACE_RGB,
#else
.color_space = LCD_RGB_ELEMENT_ORDER_RGB,
.data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
#endif
.bits_per_pixel = 16,
.vendor_config = &vendor_config
};
/*
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = configuration->resetPin,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
.bits_per_pixel = 16,
.flags = {
.reset_active_high = false
},
.vendor_config = nullptr
};
*/
if (esp_lcd_new_panel_st7796(ioHandle, &panel_config, &panelHandle) != ESP_OK) {
TT_LOG_E(TAG, "Failed to create panel");
return false;
}
if (esp_lcd_panel_reset(panelHandle) != ESP_OK) {
TT_LOG_E(TAG, "Failed to reset panel");
return false;
}
if (esp_lcd_panel_init(panelHandle) != ESP_OK) {
TT_LOG_E(TAG, "Failed to init panel");
return false;
}
if (esp_lcd_panel_invert_color(panelHandle, configuration->invertColor) != ESP_OK) {
TT_LOG_E(TAG, "Failed to set panel to invert");
return false;
}
if (esp_lcd_panel_swap_xy(panelHandle, configuration->swapXY) != ESP_OK) {
TT_LOG_E(TAG, "Failed to swap XY ");
return false;
}
if (esp_lcd_panel_mirror(panelHandle, configuration->mirrorX, configuration->mirrorY) != ESP_OK) {
TT_LOG_E(TAG, "Failed to set panel to mirror");
return false;
}
if (esp_lcd_panel_set_gap(panelHandle, 0, 49) != ESP_OK) {
TT_LOG_E(TAG, "Failed to set panel gap");
return false;
}
if (esp_lcd_panel_disp_on_off(panelHandle, true) != ESP_OK) {
TT_LOG_E(TAG, "Failed to turn display on");
return false;
}
uint32_t buffer_size;
if (configuration->bufferSize == 0) {
buffer_size = configuration->horizontalResolution * configuration->verticalResolution / 10;
} else {
buffer_size = configuration->bufferSize;
}
const lvgl_port_display_cfg_t disp_cfg = {
.io_handle = ioHandle,
.panel_handle = panelHandle,
.control_handle = nullptr,
.buffer_size = buffer_size,
.double_buffer = false,
.trans_size = 0,
.hres = configuration->horizontalResolution,
.vres = configuration->verticalResolution,
.monochrome = false,
.rotation = {
.swap_xy = configuration->swapXY,
.mirror_x = configuration->mirrorX,
.mirror_y = configuration->mirrorY,
},
.color_format = LV_COLOR_FORMAT_NATIVE,
.flags = {
.buff_dma = true,
.buff_spiram = false,
.sw_rotate = false,
.swap_bytes = true,
.full_refresh = false,
.direct_mode = false
}
};
displayHandle = lvgl_port_add_disp(&disp_cfg);
TT_LOG_I(TAG, "Finished");
return displayHandle != nullptr;
}
bool St7796Display::stop() {
assert(displayHandle != nullptr);
lvgl_port_remove_disp(displayHandle);
if (esp_lcd_panel_del(panelHandle) != ESP_OK) {
return false;
}
if (esp_lcd_panel_io_del(ioHandle) != ESP_OK) {
return false;
}
displayHandle = nullptr;
return true;
}
void St7796Display::setGammaCurve(uint8_t index) {
uint8_t gamma_curve;
switch (index) {
case 0:
gamma_curve = 0x01;
break;
case 1:
gamma_curve = 0x04;
break;
case 2:
gamma_curve = 0x02;
break;
case 3:
gamma_curve = 0x08;
break;
default:
return;
}
const uint8_t param[] = {
gamma_curve
};
/*if (esp_lcd_panel_io_tx_param(ioHandle , LCD_CMD_GAMSET, param, 1) != ESP_OK) {
TT_LOG_E(TAG, "Failed to set gamma");
}*/
}

98
Drivers/ST7796/Source/St7796Display.h
View File

@ -1,98 +0,0 @@
#pragma once
#include "Tactility/hal/display/DisplayDevice.h"
#include <driver/spi_common.h>
#include <driver/gpio.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_types.h>
#include <functional>
#include <lvgl.h>
class St7796Display final : public tt::hal::display::DisplayDevice {
public:
class Configuration {
public:
Configuration(
esp_lcd_spi_bus_handle_t spi_bus_handle,
gpio_num_t csPin,
gpio_num_t dcPin,
unsigned int horizontalResolution,
unsigned int verticalResolution,
std::shared_ptr<tt::hal::touch::TouchDevice> touch,
bool swapXY = false,
bool mirrorX = false,
bool mirrorY = false,
bool invertColor = false,
uint32_t bufferSize = 0 // Size in pixel count. 0 means default, which is 1/10 of the screen size
) : spiBusHandle(spi_bus_handle),
csPin(csPin),
dcPin(dcPin),
horizontalResolution(horizontalResolution),
verticalResolution(verticalResolution),
swapXY(swapXY),
mirrorX(mirrorX),
mirrorY(mirrorY),
invertColor(invertColor),
bufferSize(bufferSize),
touch(std::move(touch))
{}
esp_lcd_spi_bus_handle_t spiBusHandle;
gpio_num_t csPin;
gpio_num_t dcPin;
gpio_num_t resetPin = GPIO_NUM_NC;
unsigned int pixelClockFrequency = 80'000'000; // Hertz
size_t transactionQueueDepth = 2;
unsigned int horizontalResolution;
unsigned int verticalResolution;
bool swapXY = false;
bool mirrorX = false;
bool mirrorY = false;
bool invertColor = false;
uint32_t bufferSize = 0; // Size in pixel count. 0 means default, which is 1/10 of the screen size
std::shared_ptr<tt::hal::touch::TouchDevice> touch;
std::function<void(uint8_t)> _Nullable backlightDutyFunction = nullptr;
};
private:
std::unique_ptr<Configuration> configuration;
esp_lcd_panel_io_handle_t ioHandle = nullptr;
esp_lcd_panel_handle_t panelHandle = nullptr;
lv_display_t* displayHandle = nullptr;
public:
explicit St7796Display(std::unique_ptr<Configuration> inConfiguration) : configuration(std::move(inConfiguration)) {
assert(configuration != nullptr);
}
std::string getName() const final { return "ST7796"; }
std::string getDescription() const final { return "ST7796 display"; }
bool start() final;
bool stop() final;
std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() final { return configuration->touch; }
void setBacklightDuty(uint8_t backlightDuty) final {
if (configuration->backlightDutyFunction != nullptr) {
configuration->backlightDutyFunction(backlightDuty);
}
}
void setGammaCurve(uint8_t index) final;
uint8_t getGammaCurveCount() const final { return 4; };
bool supportsBacklightDuty() const final { return configuration->backlightDutyFunction != nullptr; }
lv_display_t* _Nullable getLvglDisplay() const final { return displayHandle; }
};
std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

5
Drivers/TCA8418/CMakeLists.txt
View File

@ -1,5 +0,0 @@
idf_component_register(
SRC_DIRS "Source"
INCLUDE_DIRS "Source"
REQUIRES Tactility
)

5
Drivers/TCA8418/README.md
View File

@ -1,5 +0,0 @@
# BQ24295
Power management: I2C-controlled 3A single cell USB charger with narrow VDC 4.5-5.5V adjustable voltage at 1.5A synchronous boost operation.
[Datasheet](https://www.ti.com/lit/ds/symlink/bq24295.pdf)

203
Drivers/TCA8418/Source/Tca8418.cpp
View File

@ -1,203 +0,0 @@
#include "Tca8418.h"
#include <Tactility/Log.h>
#define TAG "tca8418"
namespace registers {
static const uint8_t CFG = 0x01U;
static const uint8_t KP_GPIO1 = 0x1DU;
static const uint8_t KP_GPIO2 = 0x1EU;
static const uint8_t KP_GPIO3 = 0x1FU;
static const uint8_t KEY_EVENT_A = 0x04U;
static const uint8_t KEY_EVENT_B = 0x05U;
static const uint8_t KEY_EVENT_C = 0x06U;
static const uint8_t KEY_EVENT_D = 0x07U;
static const uint8_t KEY_EVENT_E = 0x08U;
static const uint8_t KEY_EVENT_F = 0x09U;
static const uint8_t KEY_EVENT_G = 0x0AU;
static const uint8_t KEY_EVENT_H = 0x0BU;
static const uint8_t KEY_EVENT_I = 0x0CU;
static const uint8_t KEY_EVENT_J = 0x0DU;
} // namespace registers
void Tca8418::init(uint8_t numrows, uint8_t numcols) {
/*
* | ADDRESS | REGISTER NAME | REGISTER DESCRIPTION | BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1 | BIT0 |
* |---------+---------------+----------------------+------+------+------+------+------+------+------+------|
* | 0x1D | KP_GPIO1 | Keypad/GPIO Select 1 | ROW7 | ROW6 | ROW5 | ROW4 | ROW3 | ROW2 | ROW1 | ROW0 |
* | 0x1E | KP_GPIO2 | Keypad/GPIO Select 2 | COL7 | COL6 | COL5 | COL4 | COL3 | COL2 | COL1 | COL0 |
* | 0x1F | KP_GPIO3 | Keypad/GPIO Select 3 | N/A | N/A | N/A | N/A | N/A | N/A | COL9 | COL8 |
*/
num_rows = numrows;
num_cols = numcols;
// everything enabled in key scan mode
uint8_t enabled_rows = 0x3F;
uint16_t enabled_cols = 0x3FF;
writeRegister8(registers::KP_GPIO1, enabled_rows);
writeRegister8(registers::KP_GPIO2, (uint8_t)(0xFF & enabled_cols));
writeRegister8(registers::KP_GPIO3, (uint8_t)(0x03 & (enabled_cols >> 8)));
/*
* BIT: NAME
*
* 7: AI
* Auto-increment for read and write operations; See below table for more information
* 0 = disabled
* 1 = enabled
*
* 6: GPI_E_CFG
* GPI event mode configuration
* 0 = GPI events are tracked when keypad is locked
* 1 = GPI events are not tracked when keypad is locked
*
* 5: OVR_FLOW_M
* Overflow mode
* 0 = disabled; Overflow data is lost
* 1 = enabled; Overflow data shifts with last event pushing first event out
*
* 4: INT_CFG
* Interrupt configuration
* 0 = processor interrupt remains asserted (or low) if host tries to clear interrupt while there is
* still a pending key press, key release or GPI interrupt
* 1 = processor interrupt is deasserted for 50 μs and reassert with pending interrupts
*
* 3: OVR_FLOW_IEN
* Overflow interrupt enable
* 0 = disabled; INT is not asserted if the FIFO overflows
* 1 = enabled; INT becomes asserted if the FIFO overflows
*
* 2: K_LCK_IEN
* Keypad lock interrupt enable
* 0 = disabled; INT is not asserted after a correct unlock key sequence
* 1 = enabled; INT becomes asserted after a correct unlock key sequence
*
* 1: GPI_IEN
* GPI interrupt enable to host processor
* 0 = disabled; INT is not asserted for a change on a GPI
* 1 = enabled; INT becomes asserted for a change on a GPI
*
* 0: KE_IEN
* Key events interrupt enable to host processor
* 0 = disabled; INT is not asserted when a key event occurs
* 1 = enabled; INT becomes asserted when a key event occurs
*/
// 10111001 xB9 -- fifo overflow enabled
// 10011001 x99 -- fifo overflow disabled
writeRegister8(registers::CFG, 0x99);
clear_released_list();
clear_pressed_list();
}
bool Tca8418::update() {
last_update_micros = this_update_micros;
uint8_t key_code, key_down, key_event, key_row, key_col;
key_event = get_key_event();
// TODO: read gpio R7/R6 status? 0x14 bits 7&6
// read(0x14, &new_keycode)
// TODO: use tick function to get an update delta time
this_update_micros = 0;
delta_micros = this_update_micros - last_update_micros;
if (key_event > 0) {
key_code = key_event & 0x7F;
key_down = (key_event & 0x80) >> 7;
key_row = key_code / num_cols;
key_col = key_code % num_cols;
// always clear the released list
clear_released_list();
if (key_down) {
add_pressed_key(key_row, key_col);
// TODO reject ghosts (assume multiple key presses with the same hold time are ghosts.)
}
else {
add_released_key(key_row, key_col);
remove_pressed_key(key_row, key_col);
}
return true;
}
// Increment hold times for pressed keys
for (int i=0; i<pressed_key_count; i++) {
pressed_list[i].hold_time += delta_micros;
}
return false;
}
void Tca8418::add_pressed_key(uint8_t row, uint8_t col) {
if (pressed_key_count >= KEY_EVENT_LIST_SIZE)
return;
pressed_list[pressed_key_count].row = row;
pressed_list[pressed_key_count].col = col;
pressed_list[pressed_key_count].hold_time = 0;
pressed_key_count++;
}
void Tca8418::add_released_key(uint8_t row, uint8_t col) {
if (released_key_count >= KEY_EVENT_LIST_SIZE)
return;
released_key_count++;
released_list[0].row = row;
released_list[0].col = col;
}
void Tca8418::remove_pressed_key(uint8_t row, uint8_t col) {
if (pressed_key_count == 0)
return;
// delete the pressed key
for (int i=0; i<pressed_key_count; i++) {
if (pressed_list[i].row == row &&
pressed_list[i].col == col) {
// shift remaining keys left one index
for (int j=i; i<pressed_key_count; j++) {
if (j == KEY_EVENT_LIST_SIZE - 1)
break;
pressed_list[j].row = pressed_list[j+1].row;
pressed_list[j].col = pressed_list[j+1].col;
pressed_list[j].hold_time = pressed_list[j+1].hold_time;
}
break;
}
}
pressed_key_count--;
}
void Tca8418::clear_pressed_list() {
for (int i=0; i<KEY_EVENT_LIST_SIZE; i++) {
pressed_list[i].row = 255;
pressed_list[i].col = 255;
}
pressed_key_count = 0;
}
void Tca8418::clear_released_list() {
for (int i=0; i<KEY_EVENT_LIST_SIZE; i++) {
released_list[i].row = 255;
released_list[i].col = 255;
}
released_key_count = 0;
}
uint8_t Tca8418::get_key_event() {
uint8_t new_keycode = 0;
readRegister8(registers::KEY_EVENT_A, new_keycode);
return new_keycode;
}

67
Drivers/TCA8418/Source/Tca8418.h
View File

@ -1,67 +0,0 @@
#pragma once
#include <array>
#include <Tactility/hal/i2c/I2cDevice.h>
#define TCA8418_ADDRESS 0x34U
#define KEY_EVENT_LIST_SIZE 10
class Tca8418 final : public tt::hal::i2c::I2cDevice {
private:
uint8_t tca8418_address;
uint32_t last_update_micros;
uint32_t this_update_micros;
uint8_t new_pressed_keys_count;
void clear_released_list();
void clear_pressed_list();
void add_pressed_key(uint8_t row, uint8_t col);
void add_released_key(uint8_t row, uint8_t col);
void remove_pressed_key(uint8_t row, uint8_t col);
void write(uint8_t register_address, uint8_t data);
bool read(uint8_t register_address, uint8_t *data);
public:
struct PressedKey {
uint8_t row;
uint8_t col;
uint32_t hold_time;
};
struct ReleasedKey {
uint8_t row;
uint8_t col;
};
std::string getName() const final { return "TCA8418"; }
std::string getDescription() const final { return "I2C-controlled keyboard scan IC"; }
explicit Tca8418(i2c_port_t port) : I2cDevice(port, TCA8418_ADDRESS) {
delta_micros = 0;
last_update_micros = 0;
this_update_micros = 0;
}
~Tca8418() {}
uint8_t num_rows;
uint8_t num_cols;
uint32_t delta_micros;
std::array<PressedKey, KEY_EVENT_LIST_SIZE> pressed_list;
std::array<ReleasedKey, KEY_EVENT_LIST_SIZE> released_list;
uint8_t pressed_key_count;
uint8_t released_key_count;
void init(uint8_t numrows, uint8_t numcols);
bool update();
uint8_t get_key_event();
bool button_pressed(uint8_t row, uint8_t button_bit_position);
bool button_released(uint8_t row, uint8_t button_bit_position);
bool button_held(uint8_t row, uint8_t button_bit_position);
};

2
ExternalApps/HelloWorld/.gitignore vendored
View File

@ -1,2 +0,0 @@
build*/
.tactility/

6
ExternalApps/HelloWorld/build.sh Executable file
View File

@ -0,0 +1,6 @@
rm sdkconfig
cp ../../sdkconfig sdkconfig
cat sdkconfig.override >> sdkconfig
# First we must run "build" because otherwise "idf.py elf" is not a valid command
idf.py build
idf.py elf

2
ExternalApps/HelloWorld/sdkconfig.override Normal file
View File

@ -0,0 +1,2 @@
CONFIG_PARTITION_TABLE_SINGLE_APP=y
CONFIG_ESP_SYSTEM_MEMPROT_FEATURE_LOCK=n

2
ExternalApps/HelloWorld/tactility.properties
View File

@ -1,2 +0,0 @@
[sdk]
version = 0.4.0

410
ExternalApps/HelloWorld/tactility.py
View File

@ -1,410 +0,0 @@
import configparser
import json
import os
import re
import shutil
import sys
import subprocess
import time
import urllib.request
import zipfile
# Targetable platforms that represent a specific hardware target
platform_targets = ["esp32", "esp32s3"]
# All valid platform commandline arguments
platform_arguments = platform_targets.copy()
platform_arguments.append("all")
ttbuild_path = ".tactility"
ttbuild_version = "1.0.0"
ttbuild_properties_file = "tactility.properties"
ttbuild_cdn = "https://cdn.tactility.one"
ttbuild_sdk_json_validity = 3600 # seconds
verbose = False
use_local_sdk = False
spinner_pattern = [
"⠋",
"⠙",
"⠹",
"⠸",
"⠼",
"⠴",
"⠦",
"⠧",
"⠇",
"⠏"
]
if sys.platform == "win32":
shell_color_red = ""
shell_color_orange = ""
shell_color_green = ""
shell_color_purple = ""
shell_color_cyan = ""
shell_color_reset = ""
else:
shell_color_red = "\033[91m"
shell_color_orange = "\033[93m"
shell_color_green = "\033[32m"
shell_color_purple = "\033[35m"
shell_color_cyan = "\033[36m"
shell_color_reset = "\033[m"
def print_help():
print("Usage: python tactility.py [action] [options]")
print("")
print("Actions:")
print(" build [esp32,esp32s3,all,local] Build the app for the specified platform")
print(" esp32: ESP32")
print(" esp32s3: ESP32 S3")
print(" all: all supported ESP platforms")
print(" clean Clean the build folders")
print(" clearcache Clear the SDK cache")
print(" updateself Update this tool")
print("")
print("Options:")
print(" --help Show this commandline info")
print(" --local-sdk Use SDK specifiedc by environment variable TACTILITY_SDK_PATH")
print(" --skip-build Run everything except the idf.py/CMake commands")
print(" --verbose Show extra console output")
def download_file(url, filepath):
global verbose
if verbose:
print(f"Downloading from {url} to {filepath}")
request = urllib.request.Request(
url,
data=None,
headers={
"User-Agent": f"Tactility Build Tool {ttbuild_version}"
}
)
try:
response = urllib.request.urlopen(request)
file = open(filepath, mode="wb")
file.write(response.read())
file.close()
return True
except OSError as error:
if verbose:
print_error(f"Failed to fetch URL {url}\n{error}")
return False
def print_warning(message):
print(f"{shell_color_orange}WARNING: {message}{shell_color_reset}")
def print_error(message):
print(f"{shell_color_red}ERROR: {message}{shell_color_reset}")
def exit_with_error(message):
print_error(message)
sys.exit(1)
def is_valid_platform_name(name):
global platform_arguments
return name in platform_arguments
def validate_environment():
global ttbuild_properties_file, use_local_sdk
if os.environ.get("IDF_PATH") is None:
exit_with_error("Cannot find the Espressif IDF SDK. Ensure it is installed and that it is activated via $PATH_TO_IDF_SDK/export.sh")
if not os.path.exists(ttbuild_properties_file):
exit_with_error(f"{ttbuild_properties_file} file not found")
if use_local_sdk == False and os.environ.get("TACTILITY_SDK_PATH") is not None:
print_warning("TACTILITY_SDK_PATH is set, but will be ignored by this command.")
print_warning("If you want to use it, use the 'build local' parameters.")
elif use_local_sdk == True and os.environ.get("TACTILITY_SDK_PATH") is None:
exit_with_error("local build was requested, but TACTILITY_SDK_PATH environment variable is not set.")
def setup_environment():
global ttbuild_path
os.makedirs(ttbuild_path, exist_ok=True)
def get_sdk_dir(version, platform):
global use_local_sdk
if use_local_sdk:
return os.environ.get("TACTILITY_SDK_PATH")
else:
global ttbuild_cdn
return os.path.join(ttbuild_path, f"{version}-{platform}", "TactilitySDK")
def get_sdk_version():
global ttbuild_properties_file
parser = configparser.RawConfigParser()
parser.read(ttbuild_properties_file)
sdk_dict = dict(parser.items("sdk"))
if not "version" in sdk_dict:
exit_with_error(f"Could not find 'version' in [sdk] section in {ttbuild_properties_file}")
return sdk_dict["version"]
def get_sdk_root_dir(version, platform):
global ttbuild_cdn
return os.path.join(ttbuild_path, f"{version}-{platform}")
def get_sdk_url(version, platform):
global ttbuild_cdn
return f"{ttbuild_cdn}/TactilitySDK-{version}-{platform}.zip"
def sdk_exists(version, platform):
sdk_dir = get_sdk_dir(version, platform)
return os.path.isdir(sdk_dir)
def should_update_sdk_json():
global ttbuild_cdn
json_filepath = os.path.join(ttbuild_path, "sdk.json")
if os.path.exists(json_filepath):
json_modification_time = os.path.getmtime(json_filepath)
now = time.time()
global ttbuild_sdk_json_validity
minimum_seconds_difference = ttbuild_sdk_json_validity
return (now - json_modification_time) > minimum_seconds_difference
else:
return True
def update_sdk_json():
global ttbuild_cdn, ttbuild_path
json_url = f"{ttbuild_cdn}/sdk.json"
json_filepath = os.path.join(ttbuild_path, "sdk.json")
return download_file(json_url, json_filepath)
def should_fetch_sdkconfig_files():
for platform in platform_targets:
sdkconfig_filename = f"sdkconfig.app.{platform}"
if not os.path.exists(os.path.join(ttbuild_path, sdkconfig_filename)):
return True
return False
def fetch_sdkconfig_files():
for platform in platform_targets:
sdkconfig_filename = f"sdkconfig.app.{platform}"
target_path = os.path.join(ttbuild_path, sdkconfig_filename)
if not download_file(f"{ttbuild_cdn}/{sdkconfig_filename}", target_path):
exit_with_error(f"Failed to download sdkconfig file for {platform}")
def validate_version_and_platforms(sdk_json, sdk_version, platforms_to_build):
version_map = sdk_json["versions"]
if not sdk_version in version_map:
exit_with_error(f"Version not found: {sdk_version}")
version_data = version_map[sdk_version]
available_platforms = version_data["platforms"]
for desired_platform in platforms_to_build:
if not desired_platform in available_platforms:
exit_with_error(f"Platform {desired_platform} is not available. Available ones: {available_platforms}")
def validate_self(sdk_json):
if not "toolVersion" in sdk_json:
exit_with_error("Server returned invalid SDK data format (toolVersion not found)")
if not "toolCompatibility" in sdk_json:
exit_with_error("Server returned invalid SDK data format (toolCompatibility not found)")
if not "toolDownloadUrl" in sdk_json:
exit_with_error("Server returned invalid SDK data format (toolDownloadUrl not found)")
tool_version = sdk_json["toolVersion"]
tool_compatibility = sdk_json["toolCompatibility"]
if tool_version != ttbuild_version:
print_warning(f"New version available: {tool_version} (currently using {ttbuild_version})")
print_warning(f"Run 'tactility.py updateself' to update.")
if re.search(tool_compatibility, ttbuild_version) is None:
print_error("The tool is not compatible anymore.")
print_error("Run 'tactility.py updateself' to update.")
sys.exit(1)
def sdk_download(version, platform):
sdk_root_dir = get_sdk_root_dir(version, platform)
os.makedirs(sdk_root_dir, exist_ok=True)
sdk_url = get_sdk_url(version, platform)
filepath = os.path.join(sdk_root_dir, f"{version}-{platform}.zip")
print(f"Downloading SDK version {version} for {platform}")
if download_file(sdk_url, filepath):
with zipfile.ZipFile(filepath, "r") as zip_ref:
zip_ref.extractall(os.path.join(sdk_root_dir, "TactilitySDK"))
return True
else:
return False
def sdk_download_all(version, platforms):
for platform in platforms:
if not sdk_exists(version, platform):
if not sdk_download(version, platform):
return False
else:
if verbose:
print(f"Using cached download for SDK version {version} and platform {platform}")
return True
def find_elf_file(platform):
build_dir = f"build-{platform}"
if os.path.exists(build_dir):
for file in os.listdir(build_dir):
if file.endswith(".app.elf"):
return os.path.join(build_dir, file)
return None
def build_all(version, platforms, skip_build):
for platform in platforms:
# First build command must be "idf.py build", otherwise it fails to execute "idf.py elf"
# We check if the ELF file exists and run the correct command
# This can lead to code caching issues, so sometimes a clean build is required
if find_elf_file(platform) is None:
if not build_first(version, platform, skip_build):
break
else:
if not build_consecutively(version, platform, skip_build):
break
def wait_for_build(process, platform):
buffer = []
os.set_blocking(process.stdout.fileno(), False)
while process.poll() is None:
for i in spinner_pattern:
time.sleep(0.1)
progress_text = f"Building for {platform} {shell_color_cyan}" + str(i) + shell_color_reset
sys.stdout.write(progress_text + "\r")
while True:
line = process.stdout.readline()
decoded_line = line.decode("UTF-8")
if decoded_line != "":
buffer.append(decoded_line)
else:
break
return buffer
# The first build must call "idf.py build" and consecutive builds must call "idf.py elf" as it finishes faster.
# The problem is that the "idf.py build" always results in an error, even though the elf file is created.
# The solution is to suppress the error if we find that the elf file was created.
def build_first(version, platform, skip_build):
sdk_dir = get_sdk_dir(version, platform)
if verbose:
print(f"Using SDK at {sdk_dir}")
os.environ["TACTILITY_SDK_PATH"] = sdk_dir
sdkconfig_path = os.path.join(ttbuild_path, f"sdkconfig.app.{platform}")
os.system(f"cp {sdkconfig_path} sdkconfig")
elf_path = find_elf_file(platform)
# Remove previous elf file: re-creation of the file is used to measure if the build succeeded,
# as the actual build job will always fail due to technical issues with the elf cmake script
if elf_path is not None:
os.remove(elf_path)
if skip_build:
return True
print("Building first build")
with subprocess.Popen(["idf.py", "-B", f"build-{platform}", "build"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
build_output = wait_for_build(process, platform)
# The return code is never expected to be 0 due to a bug in the elf cmake script, but we keep it just in case
if process.returncode == 0:
print(f"{shell_color_green}Building for {platform} ✅{shell_color_reset}")
return True
else:
if find_elf_file(platform) is None:
for line in build_output:
print(line, end="")
print(f"{shell_color_red}Building for {platform} failed ❌{shell_color_reset}")
return False
else:
print(f"{shell_color_green}Building for {platform} ✅{shell_color_reset}")
return True
def build_consecutively(version, platform, skip_build):
sdk_dir = get_sdk_dir(version, platform)
if verbose:
print(f"Using SDK at {sdk_dir}")
os.environ["TACTILITY_SDK_PATH"] = sdk_dir
sdkconfig_path = os.path.join(ttbuild_path, f"sdkconfig.app.{platform}")
os.system(f"cp {sdkconfig_path} sdkconfig")
if skip_build:
return True
with subprocess.Popen(["idf.py", "-B", f"build-{platform}", "elf"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
build_output = wait_for_build(process, platform)
if process.returncode == 0:
print(f"{shell_color_green}Building for {platform} ✅{shell_color_reset}")
return True
else:
for line in build_output:
print(line, end="")
print(f"{shell_color_red}Building for {platform} failed ❌{shell_color_reset}")
return False
def read_sdk_json():
json_file_path = os.path.join(ttbuild_path, "sdk.json")
json_file = open(json_file_path)
return json.load(json_file)
def build_action(platform_arg):
# Environment validation
validate_environment()
# Environment setup
setup_environment()
platforms_to_build = platform_targets if platform_arg == "all" else [platform_arg]
if not is_valid_platform_name(platform_arg):
print_help()
exit_with_error("Invalid platform name")
if not use_local_sdk:
if should_fetch_sdkconfig_files():
fetch_sdkconfig_files()
# Update SDK cache
if should_update_sdk_json() and not update_sdk_json():
exit_with_error("Failed to retrieve SDK info")
sdk_json = read_sdk_json()
validate_self(sdk_json)
if not "versions" in sdk_json:
exit_with_error("Version data not found in sdk.json")
# Build
sdk_version = get_sdk_version()
if not use_local_sdk:
validate_version_and_platforms(sdk_json, sdk_version, platforms_to_build)
if not sdk_download_all(sdk_version, platforms_to_build):
exit_with_error("Failed to download one or more SDKs")
build_all(sdk_version, platforms_to_build, skip_build) # Environment validation
def clean_action():
count = 0
for path in os.listdir("."):
if path.startswith("build-"):
print(f"Removing {path}/")
shutil.rmtree(path)
count = count + 1
if count == 0:
print("Nothing to clean")
def clear_cache_action():
if os.path.exists(ttbuild_path):
print(f"Removing {ttbuild_path}/")
shutil.rmtree(ttbuild_path)
else:
print("Nothing to clear")
def update_self_action():
sdk_json = read_sdk_json()
tool_download_url = sdk_json["toolDownloadUrl"]
if download_file(tool_download_url, "tactility.py"):
print("Updated")
else:
exit_with_error("Update failed")
if __name__ == "__main__":
print(f"Tactility Build System v{ttbuild_version}")
if "--help" in sys.argv:
print_help()
sys.exit()
# Argument validation
if len(sys.argv) == 1:
print_help()
sys.exit()
action_arg = sys.argv[1]
verbose = "--verbose" in sys.argv
skip_build = "--skip-build" in sys.argv
use_local_sdk = "--local-sdk" in sys.argv
# Actions
if action_arg == "build":
if len(sys.argv) < 3:
print_help()
exit_with_error("Commandline parameter missing")
build_action(sys.argv[2])
elif action_arg == "clean":
clean_action()
elif action_arg == "clearcache":
clear_cache_action()
elif action_arg == "updateself":
update_self_action()
else:
print_help()
exit_with_error("Unknown commandline parameter")

14
Libraries/esp_lcd_st7796/CMakeLists.txt
View File

@ -1,14 +0,0 @@
set(srcs "esp_lcd_st7796.c"
"esp_lcd_st7796_general.c")
if(CONFIG_SOC_MIPI_DSI_SUPPORTED)
list(APPEND srcs "esp_lcd_st7796_mipi.c")
endif()
idf_component_register(SRCS ${srcs}
INCLUDE_DIRS "include"
PRIV_INCLUDE_DIRS "priv_include"
REQUIRES "esp_lcd"
PRIV_REQUIRES "driver")
include(package_manager)
cu_pkg_define_version(${CMAKE_CURRENT_LIST_DIR})

133
Libraries/esp_lcd_st7796/README.md
View File

@ -1,133 +0,0 @@
# ESP LCD ST7796
[![Component Registry](https://components.espressif.com/components/espressif/esp_lcd_st7796/badge.svg)](https://components.espressif.com/components/espressif/esp_lcd_st7796)
Implementation of the ST7796 LCD controller with esp_lcd component.
| LCD controller | Communication interface | Component name | Link to datasheet |
| :------------: | :---------------------: | :------------: | :---------------: |
| ST7796 | SPI/I80/MIPI-DSI | esp_lcd_st7796 | [Specification](https://www.displayfuture.com/Display/datasheet/controller/ST7796s.pdf) |
## Add to project
Packages from this repository are uploaded to [Espressif's component service](https://components.espressif.com/).
You can add them to your project via `idf.py add-dependency`, e.g.
```bash
compote manifest add-dependency espressif/esp_lcd_st7796==1.0.0
```
Alternatively, you can create `idf_component.yml`. More is in [Espressif's documentation](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-component-manager.html).
## Initialization Code
### I80 interface
```c
ESP_LOGI(TAG, "Initialize Intel 8080 bus");
esp_lcd_i80_bus_handle_t i80_bus = NULL;
esp_lcd_i80_bus_config_t bus_config = ST7796_PANEL_BUS_I80_CONFIG(
EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES * EXAMPLE_LCD_BIT_PER_PIXEL / 8, EXAMPLE_LCD_DATA_WIDTH,
EXAMPLE_PIN_NUM_LCD_DC, EXAMPLE_PIN_NUM_LCD_WR,
EXAMPLE_PIN_NUM_LCD_DATA0, EXAMPLE_PIN_NUM_LCD_DATA1, EXAMPLE_PIN_NUM_LCD_DATA2, EXAMPLE_PIN_NUM_LCD_DATA3,
EXAMPLE_PIN_NUM_LCD_DATA4, EXAMPLE_PIN_NUM_LCD_DATA5, EXAMPLE_PIN_NUM_LCD_DATA6, EXAMPLE_PIN_NUM_LCD_DATA7,
EXAMPLE_PIN_NUM_LCD_DATA8, EXAMPLE_PIN_NUM_LCD_DATA9, EXAMPLE_PIN_NUM_LCD_DATA10, EXAMPLE_PIN_NUM_LCD_DATA11,
EXAMPLE_PIN_NUM_LCD_DATA12, EXAMPLE_PIN_NUM_LCD_DATA13, EXAMPLE_PIN_NUM_LCD_DATA14, EXAMPLE_PIN_NUM_LCD_DATA15);
ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&bus_config, &i80_bus));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
esp_lcd_panel_io_i80_config_t io_config = ST7796_PANEL_IO_I80_CONFIG(EXAMPLE_PIN_NUM_LCD_CS, example_callback, &example_callback_ctx);
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, &io_handle));
/**
* Uncomment these lines if use custom initialization commands.
* The array should be declared as "static const" and positioned outside the function.
*/
// static const st7796_lcd_init_cmd_t lcd_init_cmds[] = {
// // {cmd, { data }, data_size, delay_ms}
// {0xf0, (uint8_t []){0xc3}, 1, 0},
// {0xf0, (uint8_t []){0x96}, 1, 0},
// {0xb4, (uint8_t []){0x01}, 1, 0},
// ...
// };
ESP_LOGI(TAG, "Install ST7796 panel driver");
esp_lcd_panel_handle_t panel_handle = NULL;
// st7796_vendor_config_t vendor_config = { // Uncomment these lines if use custom initialization commands
// .init_cmds = lcd_init_cmds,
// .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(st7796_lcd_init_cmd_t),
// };
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST, // Set to -1 if not use
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0) // Implemented by LCD command `36h`
.color_space = ESP_LCD_COLOR_SPACE_RGB,
#else
.rgb_endian = LCD_RGB_ENDIAN_RGB,
#endif
.bits_per_pixel = EXAMPLE_LCD_BIT_PER_PIXEL, // Implemented by LCD command `3Ah` (16/18/24)
// .vendor_config = &vendor_config, // Uncomment this line if use custom initialization commands
};
ESP_ERROR_CHECK(esp_lcd_new_panel_st7796(io_handle, &panel_config, &panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
ESP_ERROR_CHECK(esp_lcd_panel_disp_off(panel_handle, false));
#else
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
#endif
```
### MIPI Interface
```c
/**
* Uncomment these line if use custom initialization commands.
* The array should be declared as static const and positioned outside the function.
*/
// static const st7796_lcd_init_cmd_t lcd_init_cmds[] = {
// // cmd data data_size delay_ms
// {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x13}, 5, 0},
// {0xEF, (uint8_t []){0x08}, 1, 0},
// {0xFF, (uint8_t []){0x77, 0x01, 0x00, 0x00, 0x10}, 5, 0},
// {0xC0, (uint8_t []){0x3B, 0x00}, 2, 0},
// ...
// };
ESP_LOGI(TAG, "MIPI DSI PHY Powered on");
esp_ldo_channel_config_t ldo_mipi_phy_config = {
.chan_id = EXAMPLE_MIPI_DSI_PHY_PWR_LDO_CHAN,
.voltage_mv = EXAMPLE_MIPI_DSI_PHY_PWR_LDO_VOLTAGE_MV,
};
ESP_ERROR_CHECK(esp_ldo_acquire_channel(&ldo_mipi_phy_config, &ldo_mipi_phy));
ESP_LOGI(TAG, "Initialize MIPI DSI bus");
esp_lcd_dsi_bus_config_t bus_config = ST7796_PANEL_BUS_DSI_1CH_CONFIG();
ESP_ERROR_CHECK(esp_lcd_new_dsi_bus(&bus_config, &mipi_dsi_bus));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_dbi_io_config_t dbi_config = ST7796_PANEL_IO_DBI_CONFIG();
ESP_ERROR_CHECK(esp_lcd_new_panel_io_dbi(mipi_dsi_bus, &dbi_config, &mipi_dbi_io));
ESP_LOGI(TAG, "Install LCD driver of st7796");
esp_lcd_panel_handle_t panel_handle = NULL;
esp_lcd_dpi_panel_config_t dpi_config = ST7796_320_480_PANEL_60HZ_DPI_CONFIG(EXAMPLE_MIPI_DPI_PX_FORMAT);
st7796_vendor_config_t vendor_config = {
// .init_cmds = lcd_init_cmds, // Uncomment these line if use custom initialization commands
// .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(st7796_lcd_init_cmd_t),
.flags.use_mipi_interface = 1,
.mipi_config = {
.dsi_bus = mipi_dsi_bus,
.dpi_config = &dpi_config,
},
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = EXAMPLE_LCD_BIT_PER_PIXEL,
.vendor_config = &vendor_config,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_st7796(mipi_dbi_io, &panel_config, &panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
```

36
Libraries/esp_lcd_st7796/esp_lcd_st7796.c
View File

@ -1,36 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#include "esp_check.h"
#include "esp_lcd_types.h"
#include "esp_lcd_st7796.h"
#include "esp_lcd_st7796_interface.h"
static const char *TAG = "st7796";
esp_err_t esp_lcd_new_panel_st7796(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel)
{
ESP_LOGI(TAG, "version: %d.%d.%d", ESP_LCD_ST7796_VER_MAJOR, ESP_LCD_ST7796_VER_MINOR, ESP_LCD_ST7796_VER_PATCH);
ESP_RETURN_ON_FALSE(panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "Invalid arguments");
st7796_vendor_config_t *vendor_config = (st7796_vendor_config_t *)panel_dev_config->vendor_config;
esp_err_t ret = ESP_ERR_NOT_SUPPORTED;
if (vendor_config && vendor_config->flags.use_mipi_interface) {
#if SOC_MIPI_DSI_SUPPORTED
ret = esp_lcd_new_panel_st7796_mipi(io, panel_dev_config, ret_panel);
#else
ESP_LOGE(TAG, "The chip does not support MIPI-DSI interface");
#endif
} else {
ret = esp_lcd_new_panel_st7796_general(io, panel_dev_config, ret_panel);
}
return ret;
}

354
Libraries/esp_lcd_st7796/esp_lcd_st7796_general.c
View File

@ -1,354 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <sys/cdefs.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_commands.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_st7796.h"
#include "esp_lcd_st7796_interface.h"
static const char *TAG = "st7796_general";
static esp_err_t panel_st7796_del(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_init(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data);
static esp_err_t panel_st7796_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_st7796_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_st7796_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
static esp_err_t panel_st7796_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap);
static esp_err_t panel_st7796_disp_on_off(esp_lcd_panel_t *panel, bool off);
typedef struct {
esp_lcd_panel_t base;
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
bool reset_level;
int x_gap;
int y_gap;
uint8_t fb_bits_per_pixel;
uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
uint8_t colmod_val; // save current value of LCD_CMD_COLMOD register
const st7796_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
} st7796_panel_t;
esp_err_t esp_lcd_new_panel_st7796_general(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel)
{
esp_err_t ret = ESP_OK;
st7796_panel_t *st7796 = NULL;
gpio_config_t io_conf = { 0 };
ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
st7796 = (st7796_panel_t *)calloc(1, sizeof(st7796_panel_t));
ESP_GOTO_ON_FALSE(st7796, ESP_ERR_NO_MEM, err, TAG, "no mem for st7796 panel");
if (panel_dev_config->reset_gpio_num >= 0) {
io_conf.mode = GPIO_MODE_OUTPUT;
io_conf.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num;
ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
}
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
switch (panel_dev_config->color_space) {
case ESP_LCD_COLOR_SPACE_RGB:
st7796->madctl_val = 0;
break;
case ESP_LCD_COLOR_SPACE_BGR:
st7796->madctl_val |= LCD_CMD_BGR_BIT;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported color space");
break;
}
#else
switch (panel_dev_config->rgb_endian) {
case LCD_RGB_ENDIAN_RGB:
st7796->madctl_val = 0;
break;
case LCD_RGB_ENDIAN_BGR:
st7796->madctl_val |= LCD_CMD_BGR_BIT;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported rgb endian");
break;
}
#endif
switch (panel_dev_config->bits_per_pixel) {
case 16: // RGB565
st7796->colmod_val = 0x05;
st7796->fb_bits_per_pixel = 16;
break;
case 18: // RGB666
st7796->colmod_val = 0x06;
// each color component (R/G/B) should occupy the 6 high bits of a byte, which means 3 full bytes are required for a pixel
st7796->fb_bits_per_pixel = 24;
break;
case 24: // RGB888
st7796->colmod_val = 0x07;
st7796->fb_bits_per_pixel = 24;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width");
break;
}
st7796->io = io;
st7796->reset_gpio_num = panel_dev_config->reset_gpio_num;
st7796->reset_level = panel_dev_config->flags.reset_active_high;
if (panel_dev_config->vendor_config) {
st7796->init_cmds = ((st7796_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds;
st7796->init_cmds_size = ((st7796_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds_size;
}
st7796->base.del = panel_st7796_del;
st7796->base.reset = panel_st7796_reset;
st7796->base.init = panel_st7796_init;
st7796->base.draw_bitmap = panel_st7796_draw_bitmap;
st7796->base.invert_color = panel_st7796_invert_color;
st7796->base.set_gap = panel_st7796_set_gap;
st7796->base.mirror = panel_st7796_mirror;
st7796->base.swap_xy = panel_st7796_swap_xy;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
st7796->base.disp_off = panel_st7796_disp_on_off;
#else
st7796->base.disp_on_off = panel_st7796_disp_on_off;
#endif
*ret_panel = &(st7796->base);
ESP_LOGD(TAG, "new st7796 panel @%p", st7796);
ESP_LOGI(TAG, "LCD panel create success, version: %d.%d.%d", ESP_LCD_ST7796_VER_MAJOR, ESP_LCD_ST7796_VER_MINOR,
ESP_LCD_ST7796_VER_PATCH);
return ESP_OK;
err:
if (st7796) {
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
free(st7796);
}
return ret;
}
static esp_err_t panel_st7796_del(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
if (st7796->reset_gpio_num >= 0) {
gpio_reset_pin(st7796->reset_gpio_num);
}
ESP_LOGD(TAG, "del st7796 panel @%p", st7796);
free(st7796);
return ESP_OK;
}
static esp_err_t panel_st7796_reset(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
// perform hardware reset
if (st7796->reset_gpio_num >= 0) {
gpio_set_level(st7796->reset_gpio_num, st7796->reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(st7796->reset_gpio_num, !st7796->reset_level);
vTaskDelay(pdMS_TO_TICKS(120));
} else { // perform software reset
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(120)); // spec, wait at least 5ms before sending new command
}
return ESP_OK;
}
static const st7796_lcd_init_cmd_t vendor_specific_init_default[] = {
// {cmd, { data }, data_size, delay_ms}
{0xf0, (uint8_t []){0xc3}, 1, 0},
{0xf0, (uint8_t []){0x96}, 1, 0},
{0xb4, (uint8_t []){0x01}, 1, 0},
{0xb7, (uint8_t []){0xc6}, 1, 0},
{0xe8, (uint8_t []){0x40, 0x8a, 0x00, 0x00, 0x29, 0x19, 0xa5, 0x33}, 8, 0},
{0xc1, (uint8_t []){0x06}, 1, 0},
{0xc2, (uint8_t []){0xa7}, 1, 0},
{0xc5, (uint8_t []){0x18}, 1, 0},
{0xe0, (uint8_t []){0xf0, 0x09, 0x0b, 0x06, 0x04, 0x15, 0x2f, 0x54, 0x42, 0x3c, 0x17, 0x14, 0x18, 0x1b}, 14, 0},
{0xe1, (uint8_t []){0xf0, 0x09, 0x0b, 0x06, 0x04, 0x03, 0x2d, 0x43, 0x42, 0x3b, 0x16, 0x14, 0x17, 0x1b}, 14, 0},
{0xf0, (uint8_t []){0x3c}, 1, 0},
{0xf0, (uint8_t []){0x69}, 1, 0},
};
static esp_err_t panel_st7796_init(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
// LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(100));
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7796->madctl_val,
}, 1), TAG, "send command failed");
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) {
st7796->colmod_val,
}, 1), TAG, "send command failed");
const st7796_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
if (st7796->init_cmds) {
init_cmds = st7796->init_cmds;
init_cmds_size = st7796->init_cmds_size;
} else {
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(st7796_lcd_init_cmd_t);
}
bool is_cmd_overwritten = false;
for (int i = 0; i < init_cmds_size; i++) {
// Check if the command has been used or conflicts with the internal
switch (init_cmds[i].cmd) {
case LCD_CMD_MADCTL:
is_cmd_overwritten = true;
st7796->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
break;
case LCD_CMD_COLMOD:
is_cmd_overwritten = true;
st7796->colmod_val = ((uint8_t *)init_cmds[i].data)[0];
break;
default:
is_cmd_overwritten = false;
break;
}
if (is_cmd_overwritten) {
ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence", init_cmds[i].cmd);
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));
}
ESP_LOGD(TAG, "send init commands success");
return ESP_OK;
}
static esp_err_t panel_st7796_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position");
esp_lcd_panel_io_handle_t io = st7796->io;
x_start += st7796->x_gap;
x_end += st7796->x_gap;
y_start += st7796->y_gap;
y_end += st7796->y_gap;
// define an area of frame memory where MCU can access
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_CASET, (uint8_t[]) {
(x_start >> 8) & 0xFF,
x_start & 0xFF,
((x_end - 1) >> 8) & 0xFF,
(x_end - 1) & 0xFF,
}, 4), TAG, "send command failed");
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_RASET, (uint8_t[]) {
(y_start >> 8) & 0xFF,
y_start & 0xFF,
((y_end - 1) >> 8) & 0xFF,
(y_end - 1) & 0xFF,
}, 4), TAG, "send command failed");
// transfer frame buffer
size_t len = (x_end - x_start) * (y_end - y_start) * st7796->fb_bits_per_pixel / 8;
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, len), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_st7796_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
int command = 0;
if (invert_color_data) {
command = LCD_CMD_INVON;
} else {
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_st7796_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
if (mirror_x) {
st7796->madctl_val |= LCD_CMD_MX_BIT;
} else {
st7796->madctl_val &= ~LCD_CMD_MX_BIT;
}
if (mirror_y) {
st7796->madctl_val |= LCD_CMD_MY_BIT;
} else {
st7796->madctl_val &= ~LCD_CMD_MY_BIT;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7796->madctl_val
}, 1), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_st7796_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
if (swap_axes) {
st7796->madctl_val |= LCD_CMD_MV_BIT;
} else {
st7796->madctl_val &= ~LCD_CMD_MV_BIT;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7796->madctl_val
}, 1), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_st7796_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
st7796->x_gap = x_gap;
st7796->y_gap = y_gap;
return ESP_OK;
}
static esp_err_t panel_st7796_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
st7796_panel_t *st7796 = __containerof(panel, st7796_panel_t, base);
esp_lcd_panel_io_handle_t io = st7796->io;
int command = 0;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
on_off = !on_off;
#endif
if (on_off) {
command = LCD_CMD_DISPON;
} else {
command = LCD_CMD_DISPOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}

296
Libraries/esp_lcd_st7796/esp_lcd_st7796_mipi.c
View File

@ -1,296 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "esp_check.h"
#include "esp_log.h"
#include "esp_lcd_panel_commands.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_mipi_dsi.h"
#include "esp_lcd_panel_vendor.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_lcd_st7796.h"
#include "esp_lcd_st7796_interface.h"
typedef struct {
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
uint8_t colmod_val; // save surrent value of LCD_CMD_COLMOD register
const st7796_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
struct {
unsigned int reset_level: 1;
} flags;
// To save the original functions of MIPI DPI panel
esp_err_t (*del)(esp_lcd_panel_t *panel);
esp_err_t (*init)(esp_lcd_panel_t *panel);
} st7796_panel_t;
static const char *TAG = "st7796_mipi";
static esp_err_t panel_st7796_del(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_init(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_st7796_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_st7796_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_st7796_disp_on_off(esp_lcd_panel_t *panel, bool on_off);
esp_err_t esp_lcd_new_panel_st7796_mipi(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel)
{
ESP_RETURN_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
st7796_vendor_config_t *vendor_config = (st7796_vendor_config_t *)panel_dev_config->vendor_config;
ESP_RETURN_ON_FALSE(vendor_config && vendor_config->mipi_config.dpi_config && vendor_config->mipi_config.dsi_bus, ESP_ERR_INVALID_ARG, TAG,
"invalid vendor config");
esp_err_t ret = ESP_OK;
st7796_panel_t *st7796 = (st7796_panel_t *)calloc(1, sizeof(st7796_panel_t));
ESP_RETURN_ON_FALSE(st7796, ESP_ERR_NO_MEM, TAG, "no mem for st7796 panel");
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_config_t io_conf = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num,
};
ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
}
switch (panel_dev_config->color_space) {
case LCD_RGB_ELEMENT_ORDER_RGB:
st7796->madctl_val = 0;
break;
case LCD_RGB_ELEMENT_ORDER_BGR:
st7796->madctl_val |= LCD_CMD_BGR_BIT;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported color space");
break;
}
switch (panel_dev_config->bits_per_pixel) {
case 16: // RGB565
st7796->colmod_val = 0x55;
break;
case 18: // RGB666
st7796->colmod_val = 0x66;
break;
case 24: // RGB888
st7796->colmod_val = 0x77;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width");
break;
}
st7796->io = io;
st7796->init_cmds = vendor_config->init_cmds;
st7796->init_cmds_size = vendor_config->init_cmds_size;
st7796->reset_gpio_num = panel_dev_config->reset_gpio_num;
st7796->flags.reset_level = panel_dev_config->flags.reset_active_high;
// Create MIPI DPI panel
esp_lcd_panel_handle_t panel_handle = NULL;
ESP_GOTO_ON_ERROR(esp_lcd_new_panel_dpi(vendor_config->mipi_config.dsi_bus, vendor_config->mipi_config.dpi_config, &panel_handle), err, TAG,
"create MIPI DPI panel failed");
ESP_LOGD(TAG, "new MIPI DPI panel @%p", panel_handle);
// Save the original functions of MIPI DPI panel
st7796->del = panel_handle->del;
st7796->init = panel_handle->init;
// Overwrite the functions of MIPI DPI panel
panel_handle->del = panel_st7796_del;
panel_handle->init = panel_st7796_init;
panel_handle->reset = panel_st7796_reset;
panel_handle->mirror = panel_st7796_mirror;
panel_handle->invert_color = panel_st7796_invert_color;
panel_handle->disp_on_off = panel_st7796_disp_on_off;
panel_handle->user_data = st7796;
*ret_panel = panel_handle;
ESP_LOGD(TAG, "new st7796 panel @%p", st7796);
ESP_LOGI(TAG, "LCD panel create success, version: %d.%d.%d", ESP_LCD_ST7796_VER_MAJOR, ESP_LCD_ST7796_VER_MINOR,
ESP_LCD_ST7796_VER_PATCH);
return ESP_OK;
err:
if (st7796) {
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
free(st7796);
}
return ret;
}
static const st7796_lcd_init_cmd_t vendor_specific_init_default[] = {
// {cmd, { data }, data_size, delay_ms}
{0x11, (uint8_t []){0x00}, 0, 120},
{0x36, (uint8_t []){0x48}, 1, 0},
{0x3A, (uint8_t []){0x77}, 1, 0},
{0xF0, (uint8_t []){0xC3}, 1, 0},
{0xF0, (uint8_t []){0x96}, 1, 0},
{0xB4, (uint8_t []){0x02}, 1, 0},
{0xB7, (uint8_t []){0xC6}, 1, 0},
{0xB6, (uint8_t []){0x2F}, 1, 0},
{0x11, (uint8_t []){0xC0, 0xF0, 0x35}, 3, 0},
{0xC1, (uint8_t []){0x15}, 1, 0},
{0xC2, (uint8_t []){0xAF}, 1, 0},
{0xC3, (uint8_t []){0x09}, 1, 0},
{0xC5, (uint8_t []){0x22}, 1, 0},
{0xC6, (uint8_t []){0x00}, 1, 0},
{0x11, (uint8_t []){0xE8, 0x40, 0x8A, 0x00, 0x00, 0x29, 0x19, 0xA5, 0x33}, 9, 0},
{0x11, (uint8_t []){0xE0, 0x70, 0x00, 0x05, 0x03, 0x02, 0x20, 0x29, 0x01, 0x45, 0x30, 0x09, 0x07, 0x22, 0x29}, 15, 0},
{0x11, (uint8_t []){0xE1, 0x70, 0x0C, 0x10, 0x0F, 0x0E, 0x09, 0x35, 0x64, 0x48, 0x3A, 0x14, 0x13, 0x2E, 0x30}, 15, 0},
{0x11, (uint8_t []){0xE0, 0x70, 0x04, 0x0A, 0x0B, 0x0A, 0x27, 0x31, 0x55, 0x47, 0x29, 0x13, 0x13, 0x29, 0x2D}, 15, 0},
{0x11, (uint8_t []){0xE1, 0x70, 0x08, 0x0E, 0x09, 0x08, 0x04, 0x33, 0x32, 0x49, 0x36, 0x14, 0x14, 0x2A, 0x2F}, 15, 0},
{0x21, (uint8_t []){0x00}, 0, 0},
{0xF0, (uint8_t []){0xC3}, 1, 0},
{0xF0, (uint8_t []){0x96}, 1, 120},
{0xF0, (uint8_t []){0xC3}, 1, 0},
{0x29, (uint8_t []){0x00}, 0, 0},
{0x2C, (uint8_t []){0x00}, 0, 0},
//============ Gamma END===========
};
static esp_err_t panel_st7796_del(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
if (st7796->reset_gpio_num >= 0) {
gpio_reset_pin(st7796->reset_gpio_num);
}
// Delete MIPI DPI panel
st7796->del(panel);
ESP_LOGD(TAG, "del st7796 panel @%p", st7796);
free(st7796);
return ESP_OK;
}
static esp_err_t panel_st7796_init(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = st7796->io;
const st7796_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7796->madctl_val,
}, 1), TAG, "send command failed");
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) {
st7796->colmod_val,
}, 1), TAG, "send command failed");
// vendor specific initialization, it can be different between manufacturers
// should consult the LCD supplier for initialization sequence code
if (st7796->init_cmds) {
init_cmds = st7796->init_cmds;
init_cmds_size = st7796->init_cmds_size;
} else {
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(st7796_lcd_init_cmd_t);
}
for (int i = 0; i < init_cmds_size; i++) {
// Send command
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));
}
ESP_LOGD(TAG, "send init commands success");
ESP_RETURN_ON_ERROR(st7796->init(panel), TAG, "init MIPI DPI panel failed");
return ESP_OK;
}
static esp_err_t panel_st7796_reset(esp_lcd_panel_t *panel)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = st7796->io;
// Perform hardware reset
if (st7796->reset_gpio_num >= 0) {
gpio_set_level(st7796->reset_gpio_num, st7796->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(st7796->reset_gpio_num, !st7796->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(120));
} else if (io) { // Perform software reset
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(120));
}
return ESP_OK;
}
static esp_err_t panel_st7796_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = st7796->io;
uint8_t command = 0;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
if (invert_color_data) {
command = LCD_CMD_INVON;
} else {
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_st7796_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = st7796->io;
uint8_t madctl_val = st7796->madctl_val;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
// Control mirror through LCD command
if (mirror_x) {
madctl_val |= LCD_CMD_MX_BIT;
} else {
madctl_val &= ~LCD_CMD_MX_BIT;
}
if (mirror_y) {
madctl_val |= LCD_CMD_MY_BIT;
} else {
madctl_val &= ~LCD_CMD_MY_BIT;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t []) {
madctl_val
}, 1), TAG, "send command failed");
st7796->madctl_val = madctl_val;
return ESP_OK;
}
static esp_err_t panel_st7796_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
st7796_panel_t *st7796 = (st7796_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = st7796->io;
int command = 0;
if (on_off) {
command = LCD_CMD_DISPON;
} else {
command = LCD_CMD_DISPOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
#endif

15
Libraries/esp_lcd_st7796/idf_component.yml
View File

@ -1,15 +0,0 @@
dependencies:
cmake_utilities: 0.*
idf: '>=4.4'
description: ESP LCD ST7796 driver (SPI && I80 && MIPI DSI)
repository: git://github.com/espressif/esp-bsp.git
repository_info:
commit_sha: 7e5759a5dcae75624e0c7abb8d8aef6b95e33b1f
path: components/lcd/esp_lcd_st7796
targets:
- esp32
- esp32s2
- esp32s3
- esp32p4
url: https://github.com/espressif/esp-bsp/tree/master/components/lcd/esp_lcd_st7796
version: 1.3.2

206
Libraries/esp_lcd_st7796/include/esp_lcd_st7796.h
View File

@ -1,206 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ESP LCD: ST7796
*/
#pragma once
#include "hal/lcd_types.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_idf_version.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "esp_lcd_mipi_dsi.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief LCD panel initialization commands.
*
*/
typedef struct {
int cmd; /*<! The specific LCD command */
const void *data; /*<! Buffer that holds the command specific data */
size_t data_bytes; /*<! Size of `data` in memory, in bytes */
unsigned int delay_ms; /*<! Delay in milliseconds after this command */
} st7796_lcd_init_cmd_t;
/**
* @brief LCD panel vendor configuration.
*
* @note This structure needs to be passed to the `vendor_config` field in `esp_lcd_panel_dev_config_t`.
*
*/
typedef struct {
const st7796_lcd_init_cmd_t *init_cmds; /*!< Pointer to initialization commands array. Set to NULL if using default commands.
* The array should be declared as `static const` and positioned outside the function.
* Please refer to `vendor_specific_init_default` in source file.
*/
uint16_t init_cmds_size; /*<! Number of commands in above array */
#if SOC_MIPI_DSI_SUPPORTED
struct {
esp_lcd_dsi_bus_handle_t dsi_bus; /*!< MIPI-DSI bus configuration */
const esp_lcd_dpi_panel_config_t *dpi_config; /*!< MIPI-DPI panel configuration */
} mipi_config;
#endif
struct {
unsigned int use_mipi_interface: 1; /*<! Set to 1 if using MIPI interface, default is SPI/I80 interface */
} flags;
} st7796_vendor_config_t;
/**
* @brief Create LCD panel for model ST7796
*
* @note Vendor specific initialization can be different between manufacturers, should consult the LCD supplier for initialization sequence code.
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config general panel device configuration
* @param[out] ret_panel Returned LCD panel handle
* @return
* - ESP_ERR_INVALID_ARG if parameter is invalid
* - ESP_ERR_NO_MEM if out of memory
* - ESP_OK on success
*/
esp_err_t esp_lcd_new_panel_st7796(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// Default Configuration Macros for I80 Interface /////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @brief LCD panel bus configuration structure
*
* @param[in] max_trans_bytes Maximum bytes of data to be transferred in one transaction. Normally set to the size of one frame bytes.
* @param[in] data_width Data bus width
* @param[in] dc I80 data/command pin number
* @param[in] wr I80 write clock pin number
* @param[in] d[0:15] I80 data pin number 0 ~ 15. Set to -1 if not used.
*
*/
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 4, 1)
#define ST7796_PANEL_BUS_I80_CONFIG(max_trans_bytes, data_width, dc, wr, d0, d1, d2, d3, d4, \
d5, d6, d7, d8 , d9, d10, d11, d12, d13, d14, d15) \
{ \
.clk_src = LCD_CLK_SRC_PLL160M, \
.dc_gpio_num = dc, \
.wr_gpio_num = wr, \
.data_gpio_nums = { \
d0, d1, d2, d3, d4, d5, d6, d7, d8 , d9, d10, d11, d12, d13, d14, d15 \
}, \
.bus_width = data_width, \
.max_transfer_bytes = max_trans_bytes, \
}
#else
#define ST7796_PANEL_BUS_I80_CONFIG(max_trans_bytes, data_width, dc, wr, d0, d1, d2, d3, d4, \
d5, d6, d7, d8 , d9, d10, d11, d12, d13, d14, d15) \
{ \
.clk_src = LCD_CLK_SRC_PLL160M, \
.dc_gpio_num = dc, \
.wr_gpio_num = wr, \
.data_gpio_nums = { \
d0, d1, d2, d3, d4, d5, d6, d7, d8 , d9, d10, d11, d12, d13, d14, d15 \
}, \
.bus_width = data_width, \
.max_transfer_bytes = max_trans_bytes, \
.psram_trans_align = 64, \
.sram_trans_align = 4, \
}
#endif
/**
* @brief LCD panel IO configuration structure
*
* @param[in] cs I80 chip select pin number
* @param[in] cb Callback function when data transfer is done
* @param[in] cb_ctx Callback function context
*
*/
#define ST7796_PANEL_IO_I80_CONFIG(cs, cb, cb_ctx) \
{ \
.cs_gpio_num = cs, \
.pclk_hz = 10 * 1000 * 1000, \
.trans_queue_depth = 10, \
.dc_levels = { \
.dc_idle_level = 0, \
.dc_cmd_level = 0, \
.dc_dummy_level = 0, \
.dc_data_level = 1, \
}, \
.flags = { \
.swap_color_bytes = 1, \
}, \
.on_color_trans_done = cb, \
.user_ctx = cb_ctx, \
.lcd_cmd_bits = 8, \
.lcd_param_bits = 8, \
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// Default Configuration Macros for MIPI-DSI Interface //////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @brief MIPI-DSI bus configuration structure
*
* @param[in] lane_num Number of data lanes
* @param[in] lane_mbps Lane bit rate in Mbps
*
*/
#define ST7796_PANEL_BUS_DSI_1CH_CONFIG() \
{ \
.bus_id = 0, \
.num_data_lanes = 1, \
.phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT, \
.lane_bit_rate_mbps = 480, \
}
/**
* @brief MIPI-DBI panel IO configuration structure
*
*/
#define ST7796_PANEL_IO_DBI_CONFIG() \
{ \
.virtual_channel = 0, \
.lcd_cmd_bits = 8, \
.lcd_param_bits = 8, \
}
/**
* @brief MIPI DPI configuration structure
*
* @note refresh_rate = (dpi_clock_freq_mhz * 1000000) / (h_res + hsync_pulse_width + hsync_back_porch + hsync_front_porch)
* / (v_res + vsync_pulse_width + vsync_back_porch + vsync_front_porch)
*
* @param[in] px_format Pixel format of the panel
*
*/
#define ST7796_320_480_PANEL_60HZ_DPI_CONFIG(px_format) \
{ \
.dpi_clk_src = MIPI_DSI_DPI_CLK_SRC_DEFAULT, \
.dpi_clock_freq_mhz = 10, \
.virtual_channel = 0, \
.pixel_format = px_format, \
.num_fbs = 1, \
.video_timing = { \
.h_size = 320, \
.v_size = 480, \
.hsync_back_porch = 10, \
.hsync_pulse_width = 10, \
.hsync_front_porch = 20, \
.vsync_back_porch = 10, \
.vsync_pulse_width = 10, \
.vsync_front_porch = 10, \
}, \
.flags.use_dma2d = true, \
}
#ifdef __cplusplus
}
#endif

202
Libraries/esp_lcd_st7796/license.txt
View File

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

45
Libraries/esp_lcd_st7796/priv_include/esp_lcd_st7796_interface.h
View File

@ -1,45 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "esp_err.h"
#include "esp_lcd_types.h"
#include "esp_lcd_panel_vendor.h"
#include "soc/soc_caps.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize ST7796 LCD panel with SPI/I80 interface
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config LCD panel device configuration
* @param[out] ret_panel LCD panel handle
* @return
* - ESP_OK: Success
* - Otherwise: Fail
*/
esp_err_t esp_lcd_new_panel_st7796_general(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel);
#if SOC_MIPI_DSI_SUPPORTED
/**
* @brief Initialize ST7796 LCD panel with MIPI interface
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config LCD panel device configuration
* @param[out] ret_panel LCD panel handle
* @return
* - ESP_OK: Success
* - Otherwise: Fail
*/
esp_err_t esp_lcd_new_panel_st7796_mipi(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel);
#endif
#ifdef __cplusplus
}
#endif

6
Libraries/esp_lcd_st7796/test_apps/CMakeLists.txt
View File

@ -1,6 +0,0 @@
# The following lines of boilerplate have to be in your project's CMakeLists
# in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS "$ENV{IDF_PATH}/tools/unit-test-app/components")
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(test_esp_lcd_st7796)

BIN
Libraries/esp_lcd_st7796/test_apps/main/.test_esp_lcd_st7796_general.c.kate-swp
View File

Binary file not shown.

3
Libraries/esp_lcd_st7796/test_apps/main/CMakeLists.txt
View File

@ -1,3 +0,0 @@
idf_component_register(SRC_DIRS "."
INCLUDE_DIRS "."
WHOLE_ARCHIVE)

6
Libraries/esp_lcd_st7796/test_apps/main/idf_component.yml
View File

@ -1,6 +0,0 @@
## IDF Component Manager Manifest File
dependencies:
idf: ">=4.4"
esp_lcd_st7796:
version: "*"
override_path: "../../../esp_lcd_st7796"

47
Libraries/esp_lcd_st7796/test_apps/main/test_app_main.c
View File

@ -1,47 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "unity.h"
#include "unity_test_runner.h"
#include "unity_test_utils_memory.h"
#include "esp_heap_caps.h"
// Some resources are lazy allocated in the LCD driver, the threadhold is left for that case
#define TEST_MEMORY_LEAK_THRESHOLD (300)
static size_t before_free_8bit;
static size_t before_free_32bit;
void setUp(void)
{
before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
}
void tearDown(void)
{
size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
unity_utils_check_leak(before_free_8bit, after_free_8bit, "8BIT", TEST_MEMORY_LEAK_THRESHOLD);
unity_utils_check_leak(before_free_32bit, after_free_32bit, "32BIT", TEST_MEMORY_LEAK_THRESHOLD);
}
void app_main(void)
{
/**
* __ _____ _____ _____ ___ __
* / _\/__ \___ |___ / _ \ / /_
* \ \ / /\/ / / / / (_) | '_ \
* _\ \ / / / / / / \__, | (_) |
* \__/ \/ /_/ /_/ /_/ \___/
*/
printf(" __ _____ _____ _____ ___ __\r\n");
printf("/ _\\/__ \\___ |___ / _ \\ / /_\r\n");
printf("\\ \\ / /\\/ / / / / (_) | '_ \\\r\n");
printf("_\\ \\ / / / / / / \\__, | (_) |\r\n");
printf("\\__/ \\/ /_/ /_/ /_/ \\___/\r\n");
unity_run_menu();
}

135
Libraries/esp_lcd_st7796/test_apps/main/test_esp_lcd_st7796_general.c
View File

@ -1,135 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#if SOC_LCD_I80_SUPPORTED
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "soc/soc_caps.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_io.h"
#include "unity.h"
#include "unity_test_runner.h"
#include "esp_lcd_st7796.h"
#define TEST_LCD_H_RES (320)
#define TEST_LCD_V_RES (480)
#define TEST_LCD_BIT_PER_PIXEL (16)
#define TEST_LCD_DATA_WIDTH (8)
#define TEST_PIN_NUM_LCD_CS (GPIO_NUM_17)
#define TEST_PIN_NUM_LCD_DC (GPIO_NUM_46)
#define TEST_PIN_NUM_LCD_WR (GPIO_NUM_3)
#define TEST_PIN_NUM_LCD_DATA0 (GPIO_NUM_9)
#define TEST_PIN_NUM_LCD_DATA1 (GPIO_NUM_12)
#define TEST_PIN_NUM_LCD_DATA2 (GPIO_NUM_11)
#define TEST_PIN_NUM_LCD_DATA3 (GPIO_NUM_14)
#define TEST_PIN_NUM_LCD_DATA4 (GPIO_NUM_13)
#if CONFIG_IDF_TARGET_ESP32S2
#define TEST_PIN_NUM_LCD_DATA5 (GPIO_NUM_8)
#else
#define TEST_PIN_NUM_LCD_DATA5 (GPIO_NUM_47)
#endif
#define TEST_PIN_NUM_LCD_DATA6 (GPIO_NUM_21)
#define TEST_PIN_NUM_LCD_DATA7 (GPIO_NUM_45)
#define TEST_PIN_NUM_LCD_DATA8 (-1)
#define TEST_PIN_NUM_LCD_DATA9 (-1)
#define TEST_PIN_NUM_LCD_DATA10 (-1)
#define TEST_PIN_NUM_LCD_DATA11 (-1)
#define TEST_PIN_NUM_LCD_DATA12 (-1)
#define TEST_PIN_NUM_LCD_DATA13 (-1)
#define TEST_PIN_NUM_LCD_DATA14 (-1)
#define TEST_PIN_NUM_LCD_DATA15 (-1)
#define TEST_PIN_NUM_LCD_RST (GPIO_NUM_NC)
#define TEST_DELAY_TIME_MS (3000)
static char *TAG = "st7796_test";
static SemaphoreHandle_t refresh_finish = NULL;
IRAM_ATTR static bool test_notify_refresh_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
{
BaseType_t need_yield = pdFALSE;
xSemaphoreGiveFromISR(refresh_finish, &need_yield);
return (need_yield == pdTRUE);
}
static void test_draw_bitmap(esp_lcd_panel_handle_t panel_handle)
{
refresh_finish = xSemaphoreCreateBinary();
TEST_ASSERT_NOT_NULL(refresh_finish);
uint16_t row_line = TEST_LCD_V_RES / TEST_LCD_BIT_PER_PIXEL;
uint8_t byte_per_pixel = TEST_LCD_BIT_PER_PIXEL / 8;
uint8_t *color = (uint8_t *)heap_caps_calloc(1, row_line * TEST_LCD_H_RES * byte_per_pixel, MALLOC_CAP_DMA);
TEST_ASSERT_NOT_NULL(color);
for (int j = 0; j < TEST_LCD_BIT_PER_PIXEL; j++) {
for (int i = 0; i < row_line * TEST_LCD_H_RES; i++) {
for (int k = 0; k < byte_per_pixel; k++) {
color[i * byte_per_pixel + k] = (BIT(j) >> (k * 8)) & 0xff;
}
}
TEST_ESP_OK(esp_lcd_panel_draw_bitmap(panel_handle, 0, j * row_line, TEST_LCD_H_RES, (j + 1) * row_line, color));
xSemaphoreTake(refresh_finish, portMAX_DELAY);
}
free(color);
}
TEST_CASE("test st7796 to draw color bar with I80 interface", "[st7796][i80]")
{
ESP_LOGI(TAG, "Initialize Intel 8080 bus");
esp_lcd_i80_bus_handle_t i80_bus = NULL;
esp_lcd_i80_bus_config_t bus_config = ST7796_PANEL_BUS_I80_CONFIG(
TEST_LCD_H_RES * TEST_LCD_V_RES * TEST_LCD_BIT_PER_PIXEL / 8, TEST_LCD_DATA_WIDTH,
TEST_PIN_NUM_LCD_DC, TEST_PIN_NUM_LCD_WR,
TEST_PIN_NUM_LCD_DATA0, TEST_PIN_NUM_LCD_DATA1, TEST_PIN_NUM_LCD_DATA2, TEST_PIN_NUM_LCD_DATA3,
TEST_PIN_NUM_LCD_DATA4, TEST_PIN_NUM_LCD_DATA5, TEST_PIN_NUM_LCD_DATA6, TEST_PIN_NUM_LCD_DATA7,
TEST_PIN_NUM_LCD_DATA8, TEST_PIN_NUM_LCD_DATA9, TEST_PIN_NUM_LCD_DATA10, TEST_PIN_NUM_LCD_DATA11,
TEST_PIN_NUM_LCD_DATA12, TEST_PIN_NUM_LCD_DATA13, TEST_PIN_NUM_LCD_DATA14, TEST_PIN_NUM_LCD_DATA15);
TEST_ESP_OK(esp_lcd_new_i80_bus(&bus_config, &i80_bus));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
esp_lcd_panel_io_i80_config_t io_config = ST7796_PANEL_IO_I80_CONFIG(TEST_PIN_NUM_LCD_CS, test_notify_refresh_ready, NULL);
TEST_ESP_OK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, &io_handle));
ESP_LOGI(TAG, "Install ST7796 panel driver");
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = TEST_PIN_NUM_LCD_RST,
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
.color_space = ESP_LCD_COLOR_SPACE_BGR,
#else
.rgb_endian = LCD_RGB_ENDIAN_BGR,
#endif
.bits_per_pixel = TEST_LCD_BIT_PER_PIXEL,
};
esp_lcd_panel_handle_t panel_handle = NULL;
TEST_ESP_OK(esp_lcd_new_panel_st7796(io_handle, &panel_config, &panel_handle));
TEST_ESP_OK(esp_lcd_panel_reset(panel_handle));
TEST_ESP_OK(esp_lcd_panel_init(panel_handle));
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
TEST_ESP_OK(esp_lcd_panel_disp_off(panel_handle, false));
#else
TEST_ESP_OK(esp_lcd_panel_disp_on_off(panel_handle, true));
#endif
test_draw_bitmap(panel_handle);
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_TIME_MS));
TEST_ESP_OK(esp_lcd_panel_del(panel_handle));
TEST_ESP_OK(esp_lcd_panel_io_del(io_handle));
TEST_ESP_OK(esp_lcd_del_i80_bus(i80_bus));
}
#endif

225
Libraries/esp_lcd_st7796/test_apps/main/test_esp_lcd_st7796_mipi.c
View File

@ -1,225 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2c.h"
#include "driver/spi_master.h"
#include "driver/gpio.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_io.h"
#include "esp_ldo_regulator.h"
#include "esp_dma_utils.h"
#include "unity.h"
#include "unity_test_runner.h"
#include "unity_test_utils_memory.h"
#include "esp_lcd_mipi_dsi.h"
#include "esp_lcd_st7796.h"
#define TEST_LCD_H_RES (320)
#define TEST_LCD_V_RES (480)
#define TEST_LCD_BIT_PER_PIXEL (24)
#define TEST_PIN_NUM_LCD_RST (-1)
#define TEST_PIN_NUM_BK_LIGHT (-1) // set to -1 if not used
#define TEST_LCD_BK_LIGHT_ON_LEVEL (1)
#define TEST_LCD_BK_LIGHT_OFF_LEVEL !TEST_LCD_BK_LIGHT_ON_LEVEL
#if TEST_LCD_BIT_PER_PIXEL == 24
#define TEST_MIPI_DPI_PX_FORMAT (LCD_COLOR_PIXEL_FORMAT_RGB888)
#elif TEST_LCD_BIT_PER_PIXEL == 18
#define TEST_MIPI_DPI_PX_FORMAT (LCD_COLOR_PIXEL_FORMAT_RGB666)
#elif TEST_LCD_BIT_PER_PIXEL == 16
#define TEST_MIPI_DPI_PX_FORMAT (LCD_COLOR_PIXEL_FORMAT_RGB565)
#endif
#define TEST_DELAY_TIME_MS (3000)
#define TEST_MIPI_DSI_PHY_PWR_LDO_CHAN (3)
#define TEST_MIPI_DSI_PHY_PWR_LDO_VOLTAGE_MV (2500)
static char *TAG = "st7796_test";
static esp_ldo_channel_handle_t ldo_mipi_phy = NULL;
static esp_lcd_panel_handle_t panel_handle = NULL;
static esp_lcd_dsi_bus_handle_t mipi_dsi_bus = NULL;
static esp_lcd_panel_io_handle_t mipi_dbi_io = NULL;
static SemaphoreHandle_t refresh_finish = NULL;
IRAM_ATTR static bool test_notify_refresh_ready(esp_lcd_panel_handle_t panel, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx)
{
SemaphoreHandle_t refresh_finish = (SemaphoreHandle_t)user_ctx;
BaseType_t need_yield = pdFALSE;
xSemaphoreGiveFromISR(refresh_finish, &need_yield);
return (need_yield == pdTRUE);
}
static void test_init_lcd(void)
{
#if TEST_PIN_NUM_BK_LIGHT >= 0
ESP_LOGI(TAG, "Turn on LCD backlight");
gpio_config_t bk_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << TEST_PIN_NUM_BK_LIGHT
};
TEST_ESP_OK(gpio_config(&bk_gpio_config));
TEST_ESP_OK(gpio_set_level(TEST_PIN_NUM_BK_LIGHT, TEST_LCD_BK_LIGHT_ON_LEVEL));
#endif
// Turn on the power for MIPI DSI PHY, so it can go from "No Power" state to "Shutdown" state
#ifdef TEST_MIPI_DSI_PHY_PWR_LDO_CHAN
ESP_LOGI(TAG, "MIPI DSI PHY Powered on");
esp_ldo_channel_config_t ldo_mipi_phy_config = {
.chan_id = TEST_MIPI_DSI_PHY_PWR_LDO_CHAN,
.voltage_mv = TEST_MIPI_DSI_PHY_PWR_LDO_VOLTAGE_MV,
};
TEST_ESP_OK(esp_ldo_acquire_channel(&ldo_mipi_phy_config, &ldo_mipi_phy));
#endif
ESP_LOGI(TAG, "Initialize MIPI DSI bus");
esp_lcd_dsi_bus_config_t bus_config = ST7796_PANEL_BUS_DSI_1CH_CONFIG();
TEST_ESP_OK(esp_lcd_new_dsi_bus(&bus_config, &mipi_dsi_bus));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_dbi_io_config_t dbi_config = ST7796_PANEL_IO_DBI_CONFIG();
TEST_ESP_OK(esp_lcd_new_panel_io_dbi(mipi_dsi_bus, &dbi_config, &mipi_dbi_io));
ESP_LOGI(TAG, "Install LCD driver of st7796");
esp_lcd_dpi_panel_config_t dpi_config = ST7796_320_480_PANEL_60HZ_DPI_CONFIG(TEST_MIPI_DPI_PX_FORMAT);
st7796_vendor_config_t vendor_config = {
.flags.use_mipi_interface = 1,
.mipi_config.dsi_bus = mipi_dsi_bus,
.mipi_config.dpi_config = &dpi_config,
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = TEST_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = TEST_LCD_BIT_PER_PIXEL,
.vendor_config = &vendor_config,
};
TEST_ESP_OK(esp_lcd_new_panel_st7796(mipi_dbi_io, &panel_config, &panel_handle));
TEST_ESP_OK(esp_lcd_panel_reset(panel_handle));
TEST_ESP_OK(esp_lcd_panel_init(panel_handle));
TEST_ESP_OK(esp_lcd_panel_disp_on_off(panel_handle, true));
refresh_finish = xSemaphoreCreateBinary();
TEST_ASSERT_NOT_NULL(refresh_finish);
esp_lcd_dpi_panel_event_callbacks_t cbs = {
.on_color_trans_done = test_notify_refresh_ready,
};
TEST_ESP_OK(esp_lcd_dpi_panel_register_event_callbacks(panel_handle, &cbs, refresh_finish));
}
static void test_deinit_lcd(void)
{
TEST_ESP_OK(esp_lcd_panel_del(panel_handle));
TEST_ESP_OK(esp_lcd_panel_io_del(mipi_dbi_io));
TEST_ESP_OK(esp_lcd_del_dsi_bus(mipi_dsi_bus));
panel_handle = NULL;
mipi_dbi_io = NULL;
mipi_dsi_bus = NULL;
if (ldo_mipi_phy) {
TEST_ESP_OK(esp_ldo_release_channel(ldo_mipi_phy));
ldo_mipi_phy = NULL;
}
vSemaphoreDelete(refresh_finish);
refresh_finish = NULL;
#if TEST_PIN_NUM_BK_LIGHT >= 0
TEST_ESP_OK(gpio_reset_pin(TEST_PIN_NUM_BK_LIGHT));
TEST_ESP_OK(gpio_reset_pin(TEST_PIN_NUM_POWER));
#endif
}
static void test_draw_color_bar(esp_lcd_panel_handle_t panel_handle, uint16_t h_res, uint16_t v_res)
{
uint8_t byte_per_pixel = (TEST_LCD_BIT_PER_PIXEL + 7) / 8;
uint16_t row_line = v_res / byte_per_pixel / 8;
uint8_t *color = (uint8_t *)heap_caps_calloc(1, row_line * h_res * byte_per_pixel, MALLOC_CAP_DMA);
for (int j = 0; j < byte_per_pixel * 8; j++) {
for (int i = 0; i < row_line * h_res; i++) {
for (int k = 0; k < byte_per_pixel; k++) {
color[i * byte_per_pixel + k] = (BIT(j) >> (k * 8)) & 0xff;
}
}
TEST_ESP_OK(esp_lcd_panel_draw_bitmap(panel_handle, 0, j * row_line, h_res, (j + 1) * row_line, color));
xSemaphoreTake(refresh_finish, portMAX_DELAY);
}
uint16_t color_line = row_line * byte_per_pixel * 8;
uint16_t res_line = v_res - color_line;
if (res_line) {
for (int i = 0; i < res_line * h_res; i++) {
for (int k = 0; k < byte_per_pixel; k++) {
color[i * byte_per_pixel + k] = 0xff;
}
}
TEST_ESP_OK(esp_lcd_panel_draw_bitmap(panel_handle, 0, color_line, h_res, v_res, color));
xSemaphoreTake(refresh_finish, portMAX_DELAY);
}
free(color);
}
TEST_CASE("test st7796 to draw pattern with MIPI interface", "[st7796][draw_pattern]")
{
ESP_LOGI(TAG, "Initialize LCD device");
test_init_lcd();
ESP_LOGI(TAG, "Show color bar pattern drawn by hardware");
TEST_ESP_OK(esp_lcd_dpi_panel_set_pattern(panel_handle, MIPI_DSI_PATTERN_BAR_VERTICAL));
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_TIME_MS));
TEST_ESP_OK(esp_lcd_dpi_panel_set_pattern(panel_handle, MIPI_DSI_PATTERN_BAR_HORIZONTAL));
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_TIME_MS));
TEST_ESP_OK(esp_lcd_dpi_panel_set_pattern(panel_handle, MIPI_DSI_PATTERN_NONE));
ESP_LOGI(TAG, "Deinitialize LCD device");
test_deinit_lcd();
}
TEST_CASE("test st7796 to draw color bar with MIPI interface", "[st7796][draw_color_bar]")
{
ESP_LOGI(TAG, "Initialize LCD device");
test_init_lcd();
ESP_LOGI(TAG, "Show color bar drawn by software");
test_draw_color_bar(panel_handle, TEST_LCD_H_RES, TEST_LCD_V_RES);
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_TIME_MS));
ESP_LOGI(TAG, "Deinitialize LCD device");
test_deinit_lcd();
}
TEST_CASE("test st7796 to rotate with MIPI interface", "[st7796][rotate]")
{
ESP_LOGI(TAG, "Initialize LCD device");
test_init_lcd();
ESP_LOGI(TAG, "Mirror the screen");
for (size_t i = 0; i < 4; i++) {
TEST_ASSERT_NOT_EQUAL(esp_lcd_panel_mirror(panel_handle, i & 2, i & 1), ESP_FAIL);
ESP_LOGI(TAG, "Mirror: %d", i);
test_draw_color_bar(panel_handle, TEST_LCD_H_RES, TEST_LCD_V_RES);
vTaskDelay(pdMS_TO_TICKS(1000));
}
ESP_LOGI(TAG, "Deinitialize LCD device");
test_deinit_lcd();
}
#endif

12
Libraries/esp_lcd_st7796/test_apps/sdkconfig.defaults
View File

@ -1,12 +0,0 @@
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
CONFIG_COMPILER_OPTIMIZATION_PERF=y
CONFIG_SPIRAM=y
CONFIG_SPIRAM_MODE_OCT=y
CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y
CONFIG_SPIRAM_RODATA=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
CONFIG_ESP_TASK_WDT_EN=n
CONFIG_FREERTOS_HZ=1000
CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=4096

10
README.md
View File

@ -4,11 +4,15 @@ Tactility is an operating system that focuses on the ESP32 microcontroller famil
See [https://tactility.one](https://tactility.one) for more information.
![photo of devices running Tactility](Documentation/pics/tactility-devices.webp)&nbsp;&nbsp;![screenshot of launcher app](Documentation/pics/screenshot-Launcher.png)
![photo of devices running Tactility](Documentation/pics/tactility-devices.webp)&nbsp;&nbsp;![screenshot of desktop app](Documentation/pics/screenshot-Desktop.png)
You can run built-in apps or start them from an SD card. It's easy to manage system settings:
You can run built-in apps or start them from an SD card:
![screenshot off app list app](Documentation/pics/screenshot-AppList.png)&nbsp;&nbsp;![screenshot of settings app](Documentation/pics/screenshot-Settings.png)
![screenshot off app list app](Documentation/pics/screenshot-AppList.png)&nbsp;&nbsp;![screenshot of files app](Documentation/pics/screenshot-Files.png)
It's easy to manage system settings:
![screenshot of settings app](Documentation/pics/screenshot-Settings.png)&nbsp;&nbsp;![screenshot of wifi management app](Documentation/pics/screenshot-WifiManage.png)
## License

6
Tactility/Include/Tactility/Preferences.h
View File

@ -8,13 +8,9 @@ namespace tt {
/**
* Settings that persist on NVS flash for ESP32.
* On simulator, the settings are only in-memory.
*
* Note that on ESP32, there are limitations:
* - namespace name is limited by NVS_NS_NAME_MAX_SIZE (generally 16 characters)
* - key is limited by NVS_KEY_NAME_MAX_SIZE (generally 16 characters)
*/
class Preferences {
private:
const char* namespace_;
public:

4
Tactility/Include/Tactility/hal/i2c/I2cDevice.h
View File

@ -20,11 +20,7 @@ protected:
static constexpr TickType_t DEFAULT_TIMEOUT = 1000 / portTICK_PERIOD_MS;
bool read(uint8_t* data, size_t dataSize, TickType_t timeout = DEFAULT_TIMEOUT);
bool write(const uint8_t* data, uint16_t dataSize, TickType_t timeout = DEFAULT_TIMEOUT);
bool writeRead(const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout = DEFAULT_TIMEOUT);
bool readRegister8(uint8_t reg, uint8_t& result) const;
bool writeRegister(uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout = DEFAULT_TIMEOUT);
bool writeRegister8(uint8_t reg, uint8_t value) const;
bool readRegister12(uint8_t reg, float& out) const;
bool readRegister14(uint8_t reg, float& out) const;

4
Tactility/Source/app/gpssettings/GpsSettings.cpp
View File

@ -24,6 +24,8 @@ extern const AppManifest manifest;
class GpsSettingsApp final : public App {
private:
std::unique_ptr<Timer> timer;
std::shared_ptr<GpsSettingsApp*> appReference = std::make_shared<GpsSettingsApp*>(this);
lv_obj_t* statusWrapper = nullptr;
@ -94,7 +96,7 @@ class GpsSettingsApp final : public App {
memcpy(&index, &index_as_voidptr, sizeof(int));
std::vector<tt::hal::gps::GpsConfiguration> configurations;
auto gps_service = service::gps::findGpsService();
auto gps_service = tt::service::gps::findGpsService();
if (gps_service && gps_service->getGpsConfigurations(configurations)) {
TT_LOG_I(TAG, "Found service and configs %d %d", index, configurations.size());
if (index <= configurations.size()) {

16
Tactility/Source/hal/i2c/I2cDevice.cpp
View File

@ -4,22 +4,6 @@
namespace tt::hal::i2c {
bool I2cDevice::read(uint8_t* data, size_t dataSize, TickType_t timeout) {
return tt::hal::i2c::masterRead(port, address, data, dataSize, timeout);
}
bool I2cDevice::write(const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
return tt::hal::i2c::masterWrite(port, address, data, dataSize, timeout);
}
bool I2cDevice::writeRead(const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout) {
return masterWriteRead(port, address, writeData, writeDataSize, readData, readDataSize, timeout);
}
bool I2cDevice::writeRegister(uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
return masterWriteRegister(port, address, reg, data, dataSize, timeout);
}
bool I2cDevice::readRegister12(uint8_t reg, float& out) const {
std::uint8_t data[2] = {0};
if (tt::hal::i2c::masterReadRegister(port, address, reg, data, 2, DEFAULT_TIMEOUT)) {

11
Tactility/Source/service/gui/GuiDraw.cpp
View File

@ -39,17 +39,6 @@ void redraw(Gui* gui) {
if (gui->appToRender != nullptr) {
// Create a default group which adds all objects automatically,
// and assign all indevs to it.
// This enables navigation with limited input, such as encoder wheels.
lv_group_t *group = lv_group_create();
auto* indev = lv_indev_get_next(nullptr);
while(indev) {
lv_indev_set_group(indev, group);
indev = lv_indev_get_next(indev);
}
lv_group_set_default(group);
app::Flags flags = std::static_pointer_cast<app::AppInstance>(gui->appToRender)->getFlags();
if (flags.showStatusbar) {
lv_obj_remove_flag(gui->statusbarWidget, LV_OBJ_FLAG_HIDDEN);

2
TactilityC/Include/tt_app.h
View File

@ -18,7 +18,7 @@ BundleHandle _Nullable tt_app_get_parameters(AppHandle handle);
* @param[in] result the result state to set
* @param[in] bundle the result bundle to set
*/
void tt_app_set_result(AppHandle handle, AppResult result, BundleHandle _Nullable bundle);
void tt_app_set_result(AppHandle handle, Result result, BundleHandle _Nullable bundle);
/** @return true if a result was set for this app context */
bool tt_app_has_result(AppHandle handle);

12
TactilityC/Include/tt_app_manifest.h
View File

@ -9,14 +9,14 @@ extern "C" {
/** Important: These values must map to tt::app::Result values exactly */
typedef enum {
APP_RESULT_OK = 0,
APP_RESULT_CANCELLED = 1,
APP_RESULT_ERROR = 2
} AppResult;
AppResultOk = 0,
AppResultCancelled = 1,
AppResultError = 2
} Result;
typedef void* AppHandle;
typedef unsigned int AppLaunchId;
typedef unsigned int LaunchId;
/** Important: These function types must map to t::app types exactly */
typedef void* (*AppCreateData)();
@ -25,7 +25,7 @@ typedef void (*AppOnCreate)(AppHandle app, void* _Nullable data);
typedef void (*AppOnDestroy)(AppHandle app, void* _Nullable data);
typedef void (*AppOnShow)(AppHandle app, void* _Nullable data, lv_obj_t* parent);
typedef void (*AppOnHide)(AppHandle app, void* _Nullable data);
typedef void (*AppOnResult)(AppHandle app, void* _Nullable data, AppLaunchId launchId, AppResult result, BundleHandle resultData);
typedef void (*AppOnResult)(AppHandle app, void* _Nullable data, LaunchId launchId, Result result, BundleHandle resultData);
typedef struct {
/** The application's human-readable name */

21
TactilityC/Include/tt_gps.h
View File

@ -1,21 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
bool tt_gps_has_coordinates();
bool tt_gps_get_coordinates(
float* longitude,
float* latitude,
float* speed,
float* course,
int* day,
int* month,
int* year
);
#ifdef __cplusplus
}
#endif

83
TactilityC/Include/tt_preferences.h
View File

@ -1,83 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
/**
* Note that on ESP32, there are limitations:
* - namespace name is limited by NVS_NS_NAME_MAX_SIZE (generally 16 characters)
* - key is limited by NVS_KEY_NAME_MAX_SIZE (generally 16 characters)
*/
/** The handle that represents a Preferences instance */
typedef void* PreferencesHandle;
/**
* @param[in] identifier the name of the preferences. This determines the NVS namespace on ESP.
* @return a new preferences instance
*/
PreferencesHandle tt_preferences_alloc(const char* identifier);
/** Dealloc an existing preferences instance */
void tt_preferences_free(PreferencesHandle handle);
/**
* Try to get a boolean value
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[out] out the output value (only set when return value is set to true)
* @return true if "out" was set
*/
bool tt_preferences_opt_bool(PreferencesHandle handle, const char* key, bool* out);
/**
* Try to get an int32_t value
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[out] out the output value (only set when return value is set to true)
* @return true if "out" was set
*/
bool tt_preferences_opt_int32(PreferencesHandle handle, const char* key, int32_t* out);
/**
* Try to get a string
* @warning outSize must be large enough to include null terminator. This means that your string has to be the expected text length + 1 extra character.
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[out] out the buffer to store the string in
* @param[in] outSize the size of the buffer
* @return true if "out" was set
*/
bool tt_preferences_opt_string(PreferencesHandle handle, const char* key, char* out, uint32_t outSize);
/**
* Store a boolean value
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[in] value the value to store
*/
void tt_preferences_put_bool(PreferencesHandle handle, const char* key, bool value);
/**
* Store an int32_t value
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[in] value the value to store
*/
void tt_preferences_put_int32(PreferencesHandle handle, const char* key, int32_t value);
/**
* Store a string value
* @param[in] handle the handle that represents the preferences
* @param[in] key the identifier that represents the stored value (~variable name)
* @param[in] value the value to store
*/
void tt_preferences_put_string(PreferencesHandle handle, const char* key, const char* value);
#ifdef __cplusplus
}
#endif

42
TactilityC/Include/tt_time.h
View File

@ -1,42 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <stddef.h>
#define TT_TIMEZONE_NAME_BUFFER_LENGTH 32
#define TT_TIMEZONE_CODE_BUFFER_LENGTH 48
/**
* Set the timezone
* @param[in] name human-readable name
* @param[in] code the technical code (from timezones.csv)
*/
void tt_timezone_set(const char* name, const char* code);
/**
* Get the name of the timezone
* @param[out] buffer the output buffer which will include a null terminator (should be TT_TIMEZONE_NAME_BUFFER_LENGTH)
* @param[in] bufferSize the size of the output buffer
*/
bool tt_timezone_get_name(char* buffer, size_t bufferSize);
/**
* Get the code of the timezone (see timezones.csv)
*/
bool tt_timezone_get_code(char* buffer, size_t bufferSize);
/** @return true when clocks should be shown as a 24 hours one instead of 12 hours */
bool tt_timezone_is_format_24_hour();
/** Set whether clocks should be shown as a 24 hours instead of 12 hours
* @param[in] show24Hour
*/
void tt_timezone_set_format_24_hour(bool show24Hour);
#ifdef __cplusplus
}
#endif

74
TactilityC/Include/tt_wifi.h
View File

@ -1,74 +0,0 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
#define TT_WIFI_SSID_LIMIT 32 // 32 characters/octets, according to IEEE 802.11-2020 spec
#define TT_WIFI_CREDENTIALS_PASSWORD_LIMIT 64 // 64 characters/octets, according to IEEE 802.11-2020 spec
#ifdef __cplusplus
extern "C" {
#endif
/** Important: These values must map to tt::service::wifi::RadioState values exactly */
typedef enum {
WIFI_RADIO_STATE_ON_PENDING,
WIFI_RADIO_STATE_ON,
WIFI_RADIO_STATE_CONNECTION_PENDING,
WIFI_RADIO_STATE_CONNECTION_ACTIVE,
WIFI_RADIO_STATE_OFF_PENDING,
WIFI_RADIO_STATE_OFF,
} WifiRadioState;
/** @return the state of the WiFi radio */
WifiRadioState tt_wifi_get_radio_state();
/** @return a textual representation of the WiFi radio state */
const char* tt_wifi_radio_state_to_string(WifiRadioState state);
/** Start scanning */
void tt_wifi_scan();
/** @return true if a scan is active/pending */
bool tt_wifi_is_scanning();
/**
* Return the WiFi SSID that the system tries to connect to, or is connected to.
* @param[out] buffer an allocated string buffer. Its size must be (WIFI_SSID_LIMIT + 1).
*/
void tt_wifi_get_connection_target(char* buffer);
/**
* @brief Enable/disable the radio. Ignores input if desired state matches current state.
* @param[in] enabled
*/
void tt_wifi_set_enabled(bool enabled);
/**
*
* @param ssid The access point identifier - maximal 32 characters/octets
* @param password the password - maximum 64 characters/octets
* @param channel 0 means "any"
* @param autoConnect whether we want to automatically reconnect if a disconnect occurs
* @param remember whether the record should be stored permanently on the device (it is only stored if this connection attempt succeeds)
*/
void tt_wifi_connect(const char* ssid, const char* password, int32_t channel, bool autoConnect, bool remember);
/**
* If WiFi is connected, this disconnects it.
*/
void tt_wifi_disconnect();
/**
* @return true if WiFi is active and encrypted
*/
bool tt_wifi_is_connnection_secure();
/**
* @return the current radio connection link quality
*/
int tt_wifi_get_rssi();
#ifdef __cplusplus
}
#endif

8
TactilityC/Source/tt_app.cpp
View File

@ -10,9 +10,9 @@ BundleHandle _Nullable tt_app_get_parameters(AppHandle handle) {
return (BundleHandle)HANDLE_AS_APP_CONTEXT(handle)->getParameters().get();
}
void tt_app_set_result(AppHandle handle, AppResult result, BundleHandle _Nullable bundle) {
auto shared_bundle = std::unique_ptr<tt::Bundle>(static_cast<tt::Bundle*>(bundle));
HANDLE_AS_APP_CONTEXT(handle)->getApp()->setResult(static_cast<tt::app::Result>(result), std::move(shared_bundle));
void tt_app_set_result(AppHandle handle, Result result, BundleHandle _Nullable bundle) {
auto shared_bundle = std::unique_ptr<tt::Bundle>((tt::Bundle*)bundle);
HANDLE_AS_APP_CONTEXT(handle)->getApp()->setResult((tt::app::Result)result, std::move(shared_bundle));
}
bool tt_app_has_result(AppHandle handle) {
@ -24,7 +24,7 @@ void tt_app_start(const char* appId) {
}
void tt_app_start_with_bundle(const char* appId, BundleHandle parameters) {
tt::app::start(appId, std::shared_ptr<tt::Bundle>(static_cast<tt::Bundle*>(parameters)));
tt::app::start(appId, std::shared_ptr<tt::Bundle>((tt::Bundle*)parameters));
}
void tt_app_stop() {

20
TactilityC/Source/tt_bundle.cpp
View File

@ -23,19 +23,17 @@ bool tt_bundle_opt_int32(BundleHandle handle, const char* key, int32_t* out) {
}
bool tt_bundle_opt_string(BundleHandle handle, const char* key, char* out, uint32_t outSize) {
std::string out_string;
if (!HANDLE_AS_BUNDLE(handle)->optString(key, out_string)) {
if (HANDLE_AS_BUNDLE(handle)->optString(key, out_string)) {
if (out_string.length() < outSize) { // Need 1 byte to add 0 at the end
memcpy(out, out_string.c_str(), out_string.length());
out[out_string.length()] = 0x00;
return true;
} else {
return false;
}
} else {
return false;
}
if (out_string.length() >= outSize) {
// Need 1 byte to add 0 at the end
return false;
}
memcpy(out, out_string.c_str(), out_string.length());
out[out_string.length()] = 0x00;
return true;
}
void tt_bundle_put_bool(BundleHandle handle, const char* key, bool value) {

45
TactilityC/Source/tt_gps.cpp
View File

@ -1,45 +0,0 @@
#include "tt_gps.h"
#include <Tactility/service/gps/GpsService.h>
using namespace tt::service;
extern "C" {
bool tt_gps_has_coordinates() {
auto service = gps::findGpsService();
return service != nullptr && service->hasCoordinates();
}
bool tt_gps_get_coordinates(
float* longitude,
float* latitude,
float* speed,
float* course,
int* day,
int* month,
int* year
) {
auto service = gps::findGpsService();
if (service == nullptr) {
return false;
}
minmea_sentence_rmc rmc;
if (!service->getCoordinates(rmc)) {
return false;
}
*longitude = minmea_tocoord(&rmc.longitude);
*latitude = minmea_tocoord(&rmc.latitude);
*speed = minmea_tocoord(&rmc.speed);
*course = minmea_tocoord(&rmc.course);
*day = rmc.date.day;
*month = rmc.date.month;
*year = rmc.date.year;
return true;
}
}

29
TactilityC/Source/tt_init.cpp
View File

@ -5,19 +5,15 @@
#include "tt_app_manifest.h"
#include "tt_app_selectiondialog.h"
#include "tt_bundle.h"
#include "tt_gps.h"
#include "tt_hal_i2c.h"
#include "tt_lvgl_keyboard.h"
#include "tt_lvgl_spinner.h"
#include "tt_lvgl_toolbar.h"
#include "tt_message_queue.h"
#include "tt_mutex.h"
#include "tt_preferences.h"
#include "tt_semaphore.h"
#include "tt_thread.h"
#include "tt_time.h"
#include "tt_timer.h"
#include "tt_wifi.h"
#include <private/elf_symbol.h>
@ -43,8 +39,6 @@ const struct esp_elfsym elf_symbols[] {
ESP_ELFSYM_EXPORT(tt_bundle_put_bool),
ESP_ELFSYM_EXPORT(tt_bundle_put_int32),
ESP_ELFSYM_EXPORT(tt_bundle_put_string),
ESP_ELFSYM_EXPORT(tt_gps_has_coordinates),
ESP_ELFSYM_EXPORT(tt_gps_get_coordinates),
ESP_ELFSYM_EXPORT(tt_hal_i2c_start),
ESP_ELFSYM_EXPORT(tt_hal_i2c_stop),
ESP_ELFSYM_EXPORT(tt_hal_i2c_is_started),
@ -78,14 +72,6 @@ const struct esp_elfsym elf_symbols[] {
ESP_ELFSYM_EXPORT(tt_mutex_free),
ESP_ELFSYM_EXPORT(tt_mutex_lock),
ESP_ELFSYM_EXPORT(tt_mutex_unlock),
ESP_ELFSYM_EXPORT(tt_preferences_alloc),
ESP_ELFSYM_EXPORT(tt_preferences_free),
ESP_ELFSYM_EXPORT(tt_preferences_opt_bool),
ESP_ELFSYM_EXPORT(tt_preferences_opt_int32),
ESP_ELFSYM_EXPORT(tt_preferences_opt_string),
ESP_ELFSYM_EXPORT(tt_preferences_put_bool),
ESP_ELFSYM_EXPORT(tt_preferences_put_int32),
ESP_ELFSYM_EXPORT(tt_preferences_put_string),
ESP_ELFSYM_EXPORT(tt_semaphore_alloc),
ESP_ELFSYM_EXPORT(tt_semaphore_free),
ESP_ELFSYM_EXPORT(tt_semaphore_acquire),
@ -113,21 +99,6 @@ const struct esp_elfsym elf_symbols[] {
ESP_ELFSYM_EXPORT(tt_timer_get_expire_time),
ESP_ELFSYM_EXPORT(tt_timer_set_pending_callback),
ESP_ELFSYM_EXPORT(tt_timer_set_thread_priority),
ESP_ELFSYM_EXPORT(tt_timezone_set),
ESP_ELFSYM_EXPORT(tt_timezone_get_name),
ESP_ELFSYM_EXPORT(tt_timezone_get_code),
ESP_ELFSYM_EXPORT(tt_timezone_is_format_24_hour),
ESP_ELFSYM_EXPORT(tt_timezone_set_format_24_hour),
ESP_ELFSYM_EXPORT(tt_wifi_get_radio_state),
ESP_ELFSYM_EXPORT(tt_wifi_radio_state_to_string),
ESP_ELFSYM_EXPORT(tt_wifi_scan),
ESP_ELFSYM_EXPORT(tt_wifi_is_scanning),
ESP_ELFSYM_EXPORT(tt_wifi_get_connection_target),
ESP_ELFSYM_EXPORT(tt_wifi_set_enabled),
ESP_ELFSYM_EXPORT(tt_wifi_connect),
ESP_ELFSYM_EXPORT(tt_wifi_disconnect),
ESP_ELFSYM_EXPORT(tt_wifi_is_connnection_secure),
ESP_ELFSYM_EXPORT(tt_wifi_get_rssi),
// tt::lvgl
ESP_ELFSYM_EXPORT(tt_lvgl_spinner_create),
// lv_event

53
TactilityC/Source/tt_preferences.cpp
View File

@ -1,53 +0,0 @@
#include "tt_preferences.h"
#include <Tactility/Preferences.h>
#include <cstring>
#define HANDLE_AS_PREFERENCES(handle) ((tt::Preferences*)(handle))
extern "C" {
PreferencesHandle tt_preferences_alloc(const char* identifier) {
return new tt::Preferences(identifier);
}
void tt_preferences_free(PreferencesHandle handle) {
delete HANDLE_AS_PREFERENCES(handle);
}
bool tt_preferences_opt_bool(PreferencesHandle handle, const char* key, bool* out) {
return HANDLE_AS_PREFERENCES(handle)->optBool(key, *out);
}
bool tt_preferences_opt_int32(PreferencesHandle handle, const char* key, int32_t* out) {
return HANDLE_AS_PREFERENCES(handle)->optInt32(key, *out);
}
bool tt_preferences_opt_string(PreferencesHandle handle, const char* key, char* out, uint32_t outSize) {
std::string out_string;
if (!HANDLE_AS_PREFERENCES(handle)->optString(key, out_string)) {
return false;
}
if (out_string.length() >= outSize) {
// Need 1 byte to add 0 at the end
return false;
}
memcpy(out, out_string.c_str(), out_string.length());
out[out_string.length()] = 0x00;
return true;
}
void tt_preferences_put_bool(PreferencesHandle handle, const char* key, bool value) {
HANDLE_AS_PREFERENCES(handle)->putBool(key, value);
}
void tt_preferences_put_int32(PreferencesHandle handle, const char* key, int32_t value) {
HANDLE_AS_PREFERENCES(handle)->putInt32(key, value);
}
void tt_preferences_put_string(PreferencesHandle handle, const char* key, const char* value) {
HANDLE_AS_PREFERENCES(handle)->putString(key, value);
}
}

42
TactilityC/Source/tt_time.cpp
View File

@ -1,42 +0,0 @@
#include "tt_time.h"
#include <Tactility/time/Time.h>
#include <cstring>
using namespace tt;
extern "C" {
void tt_timezone_set(const char* name, const char* code) {
time::setTimeZone(name, code);
}
bool tt_timezone_get_name(char* buffer, size_t bufferSize) {
auto name = time::getTimeZoneName();
if (bufferSize < (name.length() + 1)) {
return false;
} else {
strcpy(buffer, name.c_str());
return true;
}
}
bool tt_timezone_get_code(char* buffer, size_t bufferSize) {
auto code = time::getTimeZoneCode();
if (bufferSize < (code.length() + 1)) {
return false;
} else {
strcpy(buffer, code.c_str());
return true;
}
}
bool tt_timezone_is_format_24_hour() {
return time::isTimeFormat24Hour();
}
void tt_timezone_set_format_24_hour(bool show24Hour) {
return time::setTimeFormat24Hour(show24Hour);
}
}

2
TactilityC/Source/tt_timer.cpp
View File

@ -7,6 +7,7 @@ struct TimerWrapper {
extern "C" {
TimerHandle tt_timer_alloc(TimerType type, TimerCallback callback, void* callbackContext) {
auto wrapper = std::make_shared<TimerWrapper>();
wrapper->timer = std::make_unique<tt::Timer>((tt::Timer::Type)type, [callback, callbackContext](){ callback(callbackContext); });
@ -53,3 +54,4 @@ void tt_timer_set_thread_priority(TimerHandle handle, ThreadPriority priority) {
}
}

55
TactilityC/Source/tt_wifi.cpp
View File

@ -1,55 +0,0 @@
#include "tt_wifi.h"
#include <cstring>
#include <Tactility/service/wifi/Wifi.h>
#include <Tactility/service/wifi/WifiSettings.h>
using namespace tt::service;
extern "C" {
WifiRadioState tt_wifi_get_radio_state() {
return static_cast<WifiRadioState>(wifi::getRadioState());
}
const char* tt_wifi_radio_state_to_string(WifiRadioState state) {
return wifi::radioStateToString(static_cast<wifi::RadioState>(state));
}
void tt_wifi_scan() {
wifi::scan();
}
bool tt_wifi_is_scanning() {
return wifi::isScanning();
}
void tt_wifi_get_connection_target(char* buffer) {
auto target = wifi::getConnectionTarget();
strcpy(buffer, target.c_str());
}
void tt_wifi_set_enabled(bool enabled) {
wifi::setEnabled(enabled);
}
void tt_wifi_connect(const char* ssid, const char* password, int32_t channel, bool autoConnect, bool remember) {
wifi::settings::WifiApSettings settings;
strcpy(settings.ssid, ssid);
strcpy(settings.password, password);
settings.channel = channel;
settings.auto_connect = autoConnect;
}
void tt_wifi_disconnect() {
wifi::disconnect();
}
bool tt_wifi_is_connnection_secure() {
return wifi::isConnectionSecure();
}
int tt_wifi_get_rssi() {
return wifi::getRssi();
}
}

56
sdkconfig.board.lilygo-tlora-pager
View File

@ -1,56 +0,0 @@
# Software defaults
# Increase stack size for WiFi (fixes crash after scan)
CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=3072
CONFIG_LV_FONT_MONTSERRAT_14=y
CONFIG_LV_FONT_MONTSERRAT_18=y
CONFIG_LV_USE_USER_DATA=y
CONFIG_LV_USE_FS_STDIO=y
CONFIG_LV_FS_STDIO_LETTER=65
CONFIG_LV_FS_STDIO_PATH=""
CONFIG_LV_FS_STDIO_CACHE_SIZE=4096
CONFIG_LV_USE_LODEPNG=y
CONFIG_LV_USE_BUILTIN_MALLOC=n
CONFIG_LV_USE_CLIB_MALLOC=y
CONFIG_LV_USE_MSGBOX=n
CONFIG_LV_USE_SPINNER=n
CONFIG_LV_USE_WIN=n
CONFIG_LV_USE_SNAPSHOT=y
CONFIG_FREERTOS_HZ=1000
CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=2
CONFIG_FREERTOS_SMP=n
CONFIG_FREERTOS_UNICORE=n
CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=4096
CONFIG_FREERTOS_USE_TRACE_FACILITY=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"
CONFIG_FATFS_LFN_HEAP=y
CONFIG_FATFS_VOLUME_COUNT=3
# Hardware: Main
CONFIG_TT_BOARD_LILYGO_TLORA_PAGER=y
CONFIG_TT_BOARD_NAME="LilyGo T-Lora Pager"
CONFIG_TT_BOARD_ID="lilygo-tlora-pager"
CONFIG_IDF_EXPERIMENTAL_FEATURES=y
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y
CONFIG_FLASHMODE_DIO=y
# Hardware: SPI RAM
CONFIG_ESP32S3_SPIRAM_SUPPORT=y
#CONFIG_SPIRAM_MODE_OCT=y
CONFIG_SPIRAM_TYPE_AUTO=y
CONFIG_SPIRAM_SPEED_120M=y
#CONFIG_SPIRAM_BOOT_INIT=y
CONFIG_SPIRAM_USE_MALLOC=y
CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y
# SPI Flash (can set back to 80MHz after ESP-IDF bug is resolved)
CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
# LVGL
CONFIG_LV_DPI_DEF=90
CONFIG_LV_DISP_DEF_REFR_PERIOD=10
CONFIG_LV_THEME_DEFAULT_DARK=y
# USB
CONFIG_TINYUSB_MSC_ENABLED=y
CONFIG_TINYUSB_MSC_MOUNT_PATH="/sdcard"

2
version.txt
View File

@ -1 +1 @@
0.5.0
0.4.0