562 lines
22 KiB
C
562 lines
22 KiB
C
#include "ssd1306.h"
|
|
#include "ssd1306_const.h"
|
|
|
|
|
|
uint8_t ssd1306_logo[8][64] = {
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0F, 0xEF, 0xEF, 0xEF, 0xEF, 0x0F, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x9F, 0x5F, 0x6F, 0xE7, 0xF3, 0xF9, 0xF9, 0xFB,
|
|
0xF7, 0xE7, 0xCF, 0x9F, 0xBF, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x7F, 0x3F, 0x9F, 0xDF,
|
|
0xCF, 0xE7, 0xF3, 0xF9, 0xFD, 0xFE, 0xFE, 0xFF, 0xFF, 0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0xF9, 0xF3, 0xF7, 0x67, 0x0F, 0x1F, 0x3F, 0x7F,
|
|
0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFF, 0x7F, 0x3F, 0x80, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0xFE, 0x3F, 0x1F, 0x1F,
|
|
0x0F, 0x07, 0x07, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
|
|
0x03, 0x03, 0x07, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFB, 0xF9, 0xFC, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF,
|
|
0xFE, 0xFC, 0xF9, 0xF3, 0xF7, 0xEF, 0xCF, 0x9F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0x00, 0xFE, 0x7F, 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0x7F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0xE0, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xE0, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F,
|
|
0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0x7F, 0x7F, 0xFF, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFC, 0xFC, 0xFE, 0xFE, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE,
|
|
0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0x00, 0xFE, 0xFE, 0xFC, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xF8, 0xF0, 0xE0,
|
|
0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xFC, 0x9E, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFE, 0xFC, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
|
|
0x78, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF,
|
|
0xDF, 0xDF, 0xDF, 0xDF, 0xD0, 0xC0, 0xC0, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC0, 0xC0,
|
|
0xD0, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF,
|
|
0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
|
|
};
|
|
|
|
static i2c_ssd1306_handle_t i2c_ssd1306;
|
|
static i2c_master_bus_handle_t i2c_master_bus;
|
|
|
|
/* I2C Master */
|
|
static const i2c_master_bus_config_t i2c_master_bus_config = {
|
|
.i2c_port = I2C_NUM_0,
|
|
.scl_io_num = GPIO_NUM_22,
|
|
.sda_io_num = GPIO_NUM_21,
|
|
.clk_source = I2C_CLK_SRC_DEFAULT,
|
|
.glitch_ignore_cnt = 7,
|
|
.flags.enable_internal_pullup = true};
|
|
|
|
|
|
/* SSD1306 */
|
|
static const i2c_ssd1306_config_t i2c_ssd1306_config = {
|
|
.i2c_device_address = 0x3C,
|
|
.i2c_scl_speed_hz = 400000,
|
|
.width = 128,
|
|
.height = 64,
|
|
.wise = SSD1306_BOTTOM_TO_TOP};
|
|
|
|
|
|
void init_ssd1306(void)
|
|
{
|
|
i2c_new_master_bus(&i2c_master_bus_config, &i2c_master_bus);
|
|
i2c_ssd1306_init(i2c_master_bus, i2c_ssd1306_config, &i2c_ssd1306);
|
|
i2c_ssd1306_buffer_image(&i2c_ssd1306, 32, 0, (const uint8_t *)ssd1306_logo, 64, 64, false);
|
|
i2c_ssd1306_buffer_to_ram(&i2c_ssd1306);
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
i2c_ssd1306_buffer_clear(&i2c_ssd1306);
|
|
}
|
|
|
|
esp_err_t ssd1306_print_str(uint8_t x, uint8_t y, const char *text, bool invert)
|
|
{
|
|
return (i2c_ssd1306_buffer_text(&i2c_ssd1306, x, y, text, invert));
|
|
}
|
|
|
|
esp_err_t ssd1306_display(void)
|
|
{
|
|
return (i2c_ssd1306_buffer_to_ram(&i2c_ssd1306));
|
|
}
|
|
|
|
esp_err_t ssd1306_clear_screen(void)
|
|
{
|
|
return (i2c_ssd1306_buffer_clear(&i2c_ssd1306));
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_init(i2c_master_bus_handle_t i2c_master_bus, i2c_ssd1306_config_t i2c_ssd1306_config, i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
if (i2c_ssd1306_config.i2c_scl_speed_hz > 400000 || i2c_ssd1306_config.width > 128 || i2c_ssd1306_config.height % 8 != 0 || i2c_ssd1306_config.height < 16 || i2c_ssd1306_config.height > 64)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid SSD1306 configuration, 'i2c_scl_speed_hz' must be less than or equal to 400000, 'width' must be less than or equal to 128, 'height' must be between 16 and 64 and multiple of 8");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
ESP_LOGI(SSD1306_TAG, "Initializing I2C SSD1306...");
|
|
esp_err_t ret = i2c_master_probe(i2c_master_bus, i2c_ssd1306_config.i2c_device_address, I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (ret != ESP_OK)
|
|
{
|
|
switch (ret)
|
|
{
|
|
case ESP_ERR_NOT_FOUND:
|
|
ESP_LOGE(SSD1306_TAG, "I2C SSD1306 device not found in address 0x%02X", i2c_ssd1306_config.i2c_device_address);
|
|
break;
|
|
case ESP_ERR_TIMEOUT:
|
|
ESP_LOGE(SSD1306_TAG, "I2C SSD1306 device timeout in address 0x%02X", i2c_ssd1306_config.i2c_device_address);
|
|
break;
|
|
default:
|
|
ESP_LOGE(SSD1306_TAG, "I2C SSD1306 device error in address 0x%02X", i2c_ssd1306_config.i2c_device_address);
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
i2c_device_config_t i2c_device_config = {
|
|
.dev_addr_length = I2C_ADDR_BIT_7,
|
|
.device_address = i2c_ssd1306_config.i2c_device_address,
|
|
.scl_speed_hz = i2c_ssd1306_config.i2c_scl_speed_hz};
|
|
ret = i2c_master_bus_add_device(i2c_master_bus, &i2c_device_config, &i2c_ssd1306->i2c_master_dev);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to add I2C SSD1306 device");
|
|
return ret;
|
|
}
|
|
uint8_t ssd1306_init_cmd[] = {
|
|
OLED_CONTROL_BYTE_CMD,
|
|
OLED_CMD_DISPLAY_OFF,
|
|
OLED_CMD_SET_MUX_RATIO, (i2c_ssd1306_config.height - 1),
|
|
OLED_CMD_SET_VERT_DISPLAY_OFFSET, 0x00,
|
|
OLED_MASK_DISPLAY_START_LINE | 0x00,
|
|
OLED_CMD_COM_SCAN_DIRECTION_NORMAL,
|
|
OLED_CMD_SEGMENT_REMAP_LEFT_TO_RIGHT,
|
|
OLED_CMD_SET_COM_PIN_HARDWARE_MAP, 0x12,
|
|
OLED_CMD_SET_MEMORY_ADDR_MODE, 0x02,
|
|
OLED_CMD_SET_CONTRAST_CONTROL, 0xFF,
|
|
OLED_CMD_SET_DISPLAY_CLK_DIVIDE, 0x80,
|
|
OLED_CMD_ENABLE_DISPLAY_RAM,
|
|
OLED_CMD_NORMAL_DISPLAY,
|
|
OLED_CMD_SET_CHARGE_PUMP, 0x14,
|
|
OLED_CMD_DISPLAY_ON};
|
|
if (i2c_ssd1306_config.wise == SSD1306_BOTTOM_TO_TOP)
|
|
{
|
|
ssd1306_init_cmd[7] = OLED_CMD_COM_SCAN_DIRECTION_REMAP;
|
|
ssd1306_init_cmd[8] = OLED_CMD_SEGMENT_REMAP_RIGHT_TO_LEFT;
|
|
}
|
|
ret = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ssd1306_init_cmd, sizeof(ssd1306_init_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to initialize I2C SSD1306 device");
|
|
return ret;
|
|
}
|
|
|
|
i2c_ssd1306->width = i2c_ssd1306_config.width;
|
|
i2c_ssd1306->height = i2c_ssd1306_config.height;
|
|
i2c_ssd1306->total_pages = i2c_ssd1306_config.height / 8;
|
|
|
|
i2c_ssd1306->page = (ssd1306_page_t *)calloc(i2c_ssd1306->total_pages, sizeof(ssd1306_page_t));
|
|
if (i2c_ssd1306->page == NULL)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to allocate memory for I2C SSD1306 device");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
i2c_ssd1306->page[i].segment = (uint8_t *)calloc(i2c_ssd1306->width, sizeof(uint8_t));
|
|
if (i2c_ssd1306->page[i].segment == NULL)
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
ESP_LOGI(SSD1306_TAG, "I2C SSD1306 initialized successfully");
|
|
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_deinit(i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
ESP_LOGI(SSD1306_TAG, "Deinitializing I2C SSD1306...");
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
free(i2c_ssd1306->page[i].segment);
|
|
}
|
|
free(i2c_ssd1306->page);
|
|
esp_err_t ret = i2c_master_bus_rm_device(i2c_ssd1306->i2c_master_dev);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to remove I2C SSD1306 device");
|
|
return ret;
|
|
}
|
|
ESP_LOGI(SSD1306_TAG, "I2C SSD1306 deinitialized successfully");
|
|
|
|
return ret;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_check(i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
for (uint8_t j = 0; j < i2c_ssd1306->width; j++)
|
|
{
|
|
printf("%02X ", i2c_ssd1306->page[i].segment[j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_clear(i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
memset(i2c_ssd1306->page[i].segment, 0x00, i2c_ssd1306->width);
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_fill(i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
memset(i2c_ssd1306->page[i].segment, 0xFF, i2c_ssd1306->width);
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_fill_pixel(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x, uint8_t y, bool fill)
|
|
{
|
|
if (x >= i2c_ssd1306->width || y >= i2c_ssd1306->height)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid pixel coordinates, 'x' must be between 0 and %d, 'y' must be between 0 and %d", i2c_ssd1306->width - 1, i2c_ssd1306->height - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
uint8_t page = y / 8;
|
|
uint8_t bit = 1 << (y % 8);
|
|
if (fill)
|
|
{
|
|
i2c_ssd1306->page[page].segment[x] |= bit;
|
|
}
|
|
else
|
|
{
|
|
i2c_ssd1306->page[page].segment[x] &= ~bit;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_fill_space(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x1, uint8_t x2, uint8_t y1, uint8_t y2, bool fill)
|
|
{
|
|
if (x1 >= i2c_ssd1306->width || x2 >= i2c_ssd1306->width || y1 >= i2c_ssd1306->height || y2 >= i2c_ssd1306->height || x1 > x2 || y1 > y2)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid space coordinates, 'x1' and 'x2' must be between 0 and %d, 'y1' and 'y2' must be between 0 and %d, 'x1' must be less than 'x2', 'y1' must be less than 'y2'", i2c_ssd1306->width - 1, i2c_ssd1306->height - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t start_page = y1 / 8;
|
|
uint8_t end_page = y2 / 8;
|
|
uint8_t mask;
|
|
uint8_t offset_start = y1 % 8;
|
|
uint8_t offset_end = y2 % 8;
|
|
|
|
for (uint8_t page = start_page; page <= end_page; page++)
|
|
{
|
|
if (start_page == end_page)
|
|
{
|
|
mask = (0xFF << offset_start) & (0xFF >> (7 - offset_end));
|
|
}
|
|
else if (page == start_page)
|
|
{
|
|
mask = 0xFF << offset_start;
|
|
}
|
|
else if (page == end_page)
|
|
{
|
|
mask = 0xFF >> (7 - offset_end);
|
|
}
|
|
else
|
|
{
|
|
mask = 0xFF;
|
|
}
|
|
|
|
for (uint8_t j = x1; j <= x2; j++)
|
|
{
|
|
if (fill)
|
|
i2c_ssd1306->page[page].segment[j] |= mask;
|
|
else
|
|
i2c_ssd1306->page[page].segment[j] &= ~mask;
|
|
}
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_text(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x, uint8_t y, const char *text, bool invert)
|
|
{
|
|
if (x >= i2c_ssd1306->width || y >= i2c_ssd1306->height || !text || strlen(text) == 0)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid text or coordinates: x=%d (max %d), y=%d (max %d)", x, i2c_ssd1306->width - 1, y, i2c_ssd1306->height - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t len = strlen(text);
|
|
uint8_t page = y / 8;
|
|
uint8_t offset = y % 8;
|
|
bool has_next_page = (page + 1) < i2c_ssd1306->total_pages;
|
|
|
|
uint8_t max_chars = (i2c_ssd1306->width - x) / 8;
|
|
if (len > max_chars)
|
|
{
|
|
ESP_LOGW(SSD1306_TAG, "Text truncated: text columns exceed display width, lost %d columns", x + (len * 8) - i2c_ssd1306->width);
|
|
}
|
|
|
|
if (offset != 0 && !has_next_page)
|
|
{
|
|
ESP_LOGW(SSD1306_TAG, "Vertical truncation: text exceeds display height, lost %d rows", offset);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < len && x < i2c_ssd1306->width; i++)
|
|
{
|
|
const uint8_t *char_data = font8x8[(uint8_t)text[i]];
|
|
uint8_t available_columns = i2c_ssd1306->width - x;
|
|
uint8_t columns_to_draw = (available_columns < 8) ? available_columns : 8;
|
|
|
|
for (uint8_t j = 0; j < columns_to_draw; j++)
|
|
{
|
|
uint8_t char_col = char_data[j];
|
|
|
|
if (invert)
|
|
{
|
|
char_col = ~char_col;
|
|
}
|
|
|
|
if (offset == 0)
|
|
{
|
|
i2c_ssd1306->page[page].segment[x + j] |= char_col;
|
|
}
|
|
else
|
|
{
|
|
uint8_t lower_part = char_col << offset;
|
|
uint8_t upper_part = char_col >> (8 - offset);
|
|
|
|
i2c_ssd1306->page[page].segment[x + j] |= lower_part;
|
|
if (has_next_page)
|
|
{
|
|
i2c_ssd1306->page[page + 1].segment[x + j] |= upper_part;
|
|
}
|
|
}
|
|
}
|
|
|
|
x += 8;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_int(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x, uint8_t y, int value, bool invert)
|
|
{
|
|
char text[16];
|
|
sprintf(text, "%d", value);
|
|
|
|
return i2c_ssd1306_buffer_text(i2c_ssd1306, x, y, text, invert);
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_float(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x, uint8_t y, float value, uint8_t decimals, bool invert)
|
|
{
|
|
char text[16];
|
|
sprintf(text, "%.*f", decimals, value);
|
|
|
|
return i2c_ssd1306_buffer_text(i2c_ssd1306, x, y, text, invert);
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_image(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t x, uint8_t y, const uint8_t *image, uint8_t img_width, uint8_t img_height, bool invert)
|
|
{
|
|
if (image == NULL || img_width == 0 || img_height == 0 || x >= i2c_ssd1306->width || y >= i2c_ssd1306->height)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid image or coordinates: x=%d (max %d), y=%d (max %d)", x, i2c_ssd1306->width - 1, y, i2c_ssd1306->height - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t draw_width = (img_width < (i2c_ssd1306->width - x)) ? img_width : (i2c_ssd1306->width - x);
|
|
uint8_t draw_height = (img_height < (i2c_ssd1306->height - y)) ? img_height : (i2c_ssd1306->height - y);
|
|
|
|
uint8_t start_page = y / 8;
|
|
uint8_t vertical_offset = y % 8;
|
|
uint8_t num_pages = i2c_ssd1306->total_pages;
|
|
uint8_t draw_pages = (((draw_height + 7) / 8) < (num_pages - start_page)) ? ((draw_height + 7) / 8) : (num_pages - start_page);
|
|
|
|
if (img_height > draw_height)
|
|
{
|
|
ESP_LOGW(SSD1306_TAG, "Vertical truncation: Lost %d rows", img_height - draw_height);
|
|
}
|
|
if (draw_width < img_width)
|
|
{
|
|
ESP_LOGW(SSD1306_TAG, "Horizontal truncation: Lost %d columns", img_width - draw_width);
|
|
}
|
|
|
|
for (uint8_t col = 0; col < draw_width; col++)
|
|
{
|
|
for (uint8_t page = 0; page < draw_pages; page++)
|
|
{
|
|
uint8_t target_page = start_page + page;
|
|
if (target_page >= num_pages)
|
|
break;
|
|
|
|
uint8_t img_byte = image[page * img_width + col];
|
|
if (invert)
|
|
img_byte = ~img_byte;
|
|
|
|
if (vertical_offset == 0)
|
|
{
|
|
i2c_ssd1306->page[target_page].segment[x + col] |= img_byte;
|
|
}
|
|
else
|
|
{
|
|
uint8_t lower = img_byte << vertical_offset;
|
|
uint8_t upper = img_byte >> (8 - vertical_offset);
|
|
|
|
i2c_ssd1306->page[target_page].segment[x + col] |= lower;
|
|
if (target_page + 1 < num_pages)
|
|
{
|
|
i2c_ssd1306->page[target_page + 1].segment[x + col] |= upper;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_segment_to_ram(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t page, uint8_t segment)
|
|
{
|
|
if (page >= i2c_ssd1306->total_pages || segment >= i2c_ssd1306->width)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid page or segment number, 'page' must be between 0 and %d, 'segment' must be between 0 and %d", i2c_ssd1306->total_pages - 1, i2c_ssd1306->width - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t ram_addr_cmd[] = {
|
|
OLED_CONTROL_BYTE_CMD,
|
|
OLED_MASK_PAGE_ADDR | page,
|
|
OLED_MASK_LSB_NIBBLE_SEG_ADDR | (segment & 0x0F),
|
|
OLED_MASK_HSB_NIBBLE_SEG_ADDR | (segment >> 4 & 0x0F)};
|
|
esp_err_t err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_addr_cmd, sizeof(ram_addr_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to address the segment to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
uint8_t ram_data_cmd[] = {
|
|
OLED_CONTROL_BYTE_DATA,
|
|
i2c_ssd1306->page[page].segment[segment]};
|
|
err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_data_cmd, sizeof(ram_data_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to transfer the segment to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_segments_to_ram(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t page, uint8_t initial_segment, uint8_t final_segment)
|
|
{
|
|
if (page >= i2c_ssd1306->total_pages || initial_segment >= i2c_ssd1306->width || final_segment >= i2c_ssd1306->width || initial_segment > final_segment)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid page or segment range, 'page' must be between 0 and %d, 'initial_segment' and 'final_segment' must be between 0 and %d, 'initial_segment' must be less than or equal to 'final_segment'", i2c_ssd1306->total_pages - 1, i2c_ssd1306->width - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t ram_addr_cmd[] = {
|
|
OLED_CONTROL_BYTE_CMD,
|
|
OLED_MASK_PAGE_ADDR | page,
|
|
OLED_MASK_LSB_NIBBLE_SEG_ADDR | (initial_segment & 0x0F),
|
|
OLED_MASK_HSB_NIBBLE_SEG_ADDR | (initial_segment >> 4 & 0x0F)};
|
|
esp_err_t err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_addr_cmd, sizeof(ram_addr_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to address the initial segment to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
uint8_t ram_data_cmd[final_segment - initial_segment + 2];
|
|
ram_data_cmd[0] = OLED_CONTROL_BYTE_DATA;
|
|
for (uint8_t i = 0; i < final_segment - initial_segment + 1; i++)
|
|
{
|
|
ram_data_cmd[i + 1] = i2c_ssd1306->page[page].segment[initial_segment + i];
|
|
}
|
|
err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_data_cmd, sizeof(ram_data_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to transfer the segments to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_page_to_ram(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t page)
|
|
{
|
|
if (page >= i2c_ssd1306->total_pages)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid page number, must be between 0 and %d", i2c_ssd1306->total_pages - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
uint8_t ram_addr_cmd[] = {
|
|
OLED_CONTROL_BYTE_CMD,
|
|
OLED_MASK_PAGE_ADDR | page,
|
|
OLED_MASK_LSB_NIBBLE_SEG_ADDR | (0x00 & 0x0F),
|
|
OLED_MASK_HSB_NIBBLE_SEG_ADDR | (0x00 >> 4 & 0x0F)};
|
|
esp_err_t err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_addr_cmd, sizeof(ram_addr_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to address the page to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
uint8_t ram_data_cmd[i2c_ssd1306->width + 1];
|
|
ram_data_cmd[0] = OLED_CONTROL_BYTE_DATA;
|
|
for (uint8_t i = 0; i < i2c_ssd1306->width; i++)
|
|
{
|
|
ram_data_cmd[i + 1] = i2c_ssd1306->page[page].segment[i];
|
|
}
|
|
err = i2c_master_transmit(i2c_ssd1306->i2c_master_dev, ram_data_cmd, sizeof(ram_data_cmd), I2C_SSD1306_TIMEOUT_MS / portTICK_PERIOD_MS);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Failed to transfer the page to the RAM of the SSD1306 device");
|
|
return err;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_pages_to_ram(i2c_ssd1306_handle_t *i2c_ssd1306, uint8_t initial_page, uint8_t final_page)
|
|
{
|
|
if (initial_page >= i2c_ssd1306->total_pages || final_page >= i2c_ssd1306->total_pages || initial_page > final_page)
|
|
{
|
|
ESP_LOGE(SSD1306_TAG, "Invalid page range, 'initial_page' and 'final_page' must be between 0 and %d, 'initial_page' must be less than or equal to 'final_page'", i2c_ssd1306->total_pages - 1);
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
esp_err_t err = ESP_OK;
|
|
for (uint8_t i = initial_page; i <= final_page; i++)
|
|
{
|
|
esp_err_t err = i2c_ssd1306_page_to_ram(i2c_ssd1306, i);
|
|
if (err != ESP_OK)
|
|
return err;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
esp_err_t i2c_ssd1306_buffer_to_ram(i2c_ssd1306_handle_t *i2c_ssd1306)
|
|
{
|
|
esp_err_t err = ESP_OK;
|
|
for (uint8_t i = 0; i < i2c_ssd1306->total_pages; i++)
|
|
{
|
|
err = i2c_ssd1306_page_to_ram(i2c_ssd1306, i);
|
|
if (err != ESP_OK)
|
|
return err;
|
|
}
|
|
|
|
return err;
|
|
}
|