LVGL 8.2 How can I rotate text label 90 degrees?

time_label = lv_label_create(lv_scr_act());
lv_obj_align(time_label, DIGITAL_CLOCK_ALIGN, DIGITAL_CLOCK_OFSET_X, DIGITAL_CLOCK_OFSET_Y);
char time_str[10];
sprintf(time_str, “%02d:%02d”, hour, minute);
lv_label_set_text(time_label, time_str);

maybe this example can help you

hi glory man.
Why does the system reset when I install canvas?

what is your system ?

Visual Studio Code, LVGL 8.2 version.
I am uploading the sample code without changing anything

maybe problem in memory - exmaple allocates static array static lv_color_t cbuf_tmp[CANVAS_WIDTH * CANVAS_HEIGHT]; - this 200x150=30000 items (1 item of lv_color_t = 1, 2 or 4 bytes depending on your lvgl conf). does your HW have enough data?

I will try again by reducing the areas

ESP-IDF Partition Table

Name, Type, SubType, Offset, Size, Flags

nvs, data, nvs, 0x9000, 0x6000,
phy_init, data, phy, 0xf000, 0x1000,
factory, app, factory, 0x10000, 3M,

/lvgl init******************************/
static lv_disp_draw_buf_t disp_buf; // contains internal graphic buffer(s) called draw buffer(s)

static lv_disp_drv_t disp_drv;      // contains callback functions
ESP_LOGI(TAG, "Initialize Intel 8080 bus");
esp_lcd_i80_bus_handle_t i80_bus = NULL;
esp_lcd_i80_bus_config_t bus_config = {
    .clk_src = SOC_MOD_CLK_PLL_D2,
    .dc_gpio_num = PIN_NUM_DC,
    .wr_gpio_num = PIN_NUM_PCLK,
    .data_gpio_nums = {
        PIN_NUM_DATA0,
        PIN_NUM_DATA1,
        PIN_NUM_DATA2,
        PIN_NUM_DATA3,
        PIN_NUM_DATA4,
        PIN_NUM_DATA5,
        PIN_NUM_DATA6,
        PIN_NUM_DATA7,
    },
    .bus_width = CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH,
    .max_transfer_bytes =  LCD_H_RES * LCD_V_RES * sizeof(uint16_t),
    .psram_trans_align = 64,
    .sram_trans_align = 4,
    

    
};
ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&bus_config, &i80_bus));
esp_lcd_panel_io_handle_t io_handle = NULL;

esp_lcd_panel_io_i80_config_t io_config = {
    .cs_gpio_num = PIN_NUM_CS,
    .pclk_hz = LCD_PIXEL_CLOCK_HZ,
    .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 = !LV_COLOR_16_SWAP, // Swap can be done in LvGL (default) or DMA
    
    },
    .on_color_trans_done = notify_lvgl_flush_ready,
    .user_ctx = &disp_drv,
    .lcd_cmd_bits = LCD_CMD_BITS,
    .lcd_param_bits = LCD_PARAM_BITS,
    
    
};
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, &io_handle));

esp_lcd_panel_handle_t panel_handle = NULL;

ESP_LOGI(TAG, "Install LCD driver of st7789");
esp_lcd_panel_dev_config_t panel_config = {
    .reset_gpio_num = PIN_NUM_RST,
    .rgb_endian = LCD_RGB_ENDIAN_RGB,
    .bits_per_pixel = 16,
    
    
    
};
ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle));

esp_lcd_panel_reset(panel_handle);
esp_lcd_panel_init(panel_handle);
// Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec
// the gap is LCD panel specific, even panels with the same driver IC, can have different gap value
esp_lcd_panel_invert_color(panel_handle, true);
esp_lcd_panel_set_gap(panel_handle, 0, 0);

// user can flush pre-defined pattern to the screen before we turn on the screen or backlight

/*esp_lcd_panel_mirror(panel_handle, true,false);
esp_lcd_panel_swap_xy(panel_handle, true);*/

ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));

ESP_LOGI(TAG, "Initialize LVGL library");
lv_init();
//lv_disp_set_rotation(disp, LV_DISP_ROT_90);
// alloc draw buffers used by LVGL
// it's recommended to choose the size of the draw buffer(s) to be at least 1/10 screen sized

lv_color_t *buf1 = NULL;
lv_color_t *buf2 = NULL;

// static lv_color_t buf1[655 * 100];
// static lv_color_t buf2[655 * 100];

buf1 = heap_caps_malloc(LCD_H_RES * LCD_V_RES * sizeof(lv_color_t), MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);

//
//assert(buf1);
//
buf2 = heap_caps_malloc(LCD_H_RES * LCD_V_RES * sizeof(lv_color_t), MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
//
assert(buf2);
ESP_LOGI(TAG, “buf1@%p, buf2@%p”, buf1, buf2);
// initialize LVGL draw buffers
lv_disp_draw_buf_init(&disp_buf, buf1, buf2,LCD_H_RES * LCD_V_RES);

ESP_LOGI(TAG, "Register display driver to LVGL");
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = LCD_H_RES;
disp_drv.ver_res = LCD_V_RES;
disp_drv.flush_cb = lvgl_flush_cb;
disp_drv.draw_buf = &disp_buf;
disp_drv.user_data = panel_handle;

//disp_drv.rotated = LV_DISP_ROT_270;
// drv_disp.rotated = LV_DISP_ROT_90;
disp = lv_disp_drv_register(&disp_drv);

ESP_LOGI(TAG, "Install LVGL tick timer");
// Tick interface for LVGL (using esp_timer to generate 2ms periodic event)
const esp_timer_create_args_t lvgl_tick_timer_args = {
    .callback = &increase_lvgl_tick,
    .name = "lvgl_tick"
};
esp_timer_handle_t lvgl_tick_timer = NULL;
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, LVGL_TICK_PERIOD_MS * 1000));
/*****************************************************************************************************************/

#define CANVAS_WIDTH 200
#define CANVAS_HEIGHT 150

void lv_example_canvas_1(void)
{
lv_draw_rect_dsc_t rect_dsc;
lv_draw_rect_dsc_init(&rect_dsc);
rect_dsc.radius = 10;
rect_dsc.bg_opa = LV_OPA_COVER;
rect_dsc.bg_grad.dir = LV_GRAD_DIR_HOR;
rect_dsc.bg_grad.stops[0].color = lv_palette_main(LV_PALETTE_RED);
rect_dsc.bg_grad.stops[1].color = lv_palette_main(LV_PALETTE_BLUE);
rect_dsc.border_width = 2;
rect_dsc.border_opa = LV_OPA_90;
rect_dsc.border_color = lv_color_white();
rect_dsc.shadow_width = 5;
rect_dsc.shadow_ofs_x = 5;
rect_dsc.shadow_ofs_y = 5;

lv_draw_label_dsc_t label_dsc;
lv_draw_label_dsc_init(&label_dsc);
label_dsc.color = lv_palette_main(LV_PALETTE_ORANGE);

static lv_color_t cbuf[LV_CANVAS_BUF_SIZE_TRUE_COLOR(CANVAS_WIDTH, CANVAS_HEIGHT)];

lv_obj_t * canvas = lv_canvas_create(lv_scr_act());
lv_canvas_set_buffer(canvas, cbuf, CANVAS_WIDTH, CANVAS_HEIGHT, LV_IMG_CF_TRUE_COLOR);
lv_obj_center(canvas);
lv_canvas_fill_bg(canvas, lv_palette_lighten(LV_PALETTE_GREY, 3), LV_OPA_COVER);

lv_canvas_draw_rect(canvas, 70, 60, 100, 70, &rect_dsc);

lv_canvas_draw_text(canvas, 40, 20, 100, &label_dsc, "Some text on text canvas");

/*Test the rotation. It requires another buffer where the original image is stored.
 *So copy the current image to buffer and rotate it to the canvas*/
static lv_color_t cbuf_tmp[CANVAS_WIDTH * CANVAS_HEIGHT];
memcpy(cbuf_tmp, cbuf, sizeof(cbuf_tmp));
lv_img_dsc_t img;
img.data = (void *)cbuf_tmp;
img.header.cf = LV_IMG_CF_TRUE_COLOR;
img.header.w = CANVAS_WIDTH;
img.header.h = CANVAS_HEIGHT;

lv_canvas_fill_bg(canvas, lv_palette_lighten(LV_PALETTE_GREY, 3), LV_OPA_COVER);
lv_canvas_transform(canvas, &img, 120, LV_IMG_ZOOM_NONE, 0, 0, CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2, true);

}