ESP32-S3-LCD-1.47 Horizontal

[dcmcshan]

I have a ESP32-S3-LCD-1.47 working, but I would like to use it horizontally. Is there a rotation parameter I can give init?

"""
ESP32-S3 Waveshare Display Module (No Hardware Reset)
Handles display initialization without disconnecting USB
"""

import lvgl as lv
import lcd_bus
import st7789
import machine
import time

# Display configuration - try Arduino's original PORTRAIT mode
WIDTH = 172   # Arduino's original width
HEIGHT = 320  # Arduino's original height
OFFSET_X = 34  # Arduino's original X offset
OFFSET_Y = 0   # Arduino's original Y offset

# SPI Pin Configuration (matching Arduino demo)
SPI_MOSI = 45
SPI_SCK = 40
SPI_MISO = 13  # Not used for display but needed for SPI bus

# Display Pin Configuration (matching Arduino demo)
PIN_DC = 41
PIN_CS = 42
PIN_RESET = 39
PIN_BACKLIGHT = 48

def init_display():
    # Initialize LVGL first (like MCT)
    lv.init()
    
    # Initialize SPI bus using parameters with reset fallback
    try:
        spi_bus = machine.SPI.Bus(
            host=1,
            mosi=SPI_MOSI,
            miso=SPI_MISO,
            sck=SPI_SCK
        )
    except Exception as e:
        print(f"SPI Bus initialization failed: {e}")
        print("Resetting machine...")
        machine.reset()
    
    # Initialize LCD bus using the SPI bus
    display_bus = lcd_bus.SPIBus(
        spi_bus=spi_bus,
        dc=PIN_DC,
        cs=PIN_CS,
        freq=80_000_000  # 80MHz like Arduino
    )
    
    # Allocate framebuffers
    buf_size = WIDTH * HEIGHT * 2 // 10  # Arduino formula: /20 but we use /10 for stability
    fb1 = display_bus.allocate_framebuffer(buf_size, lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
    fb2 = display_bus.allocate_framebuffer(buf_size, lcd_bus.MEMORY_INTERNAL | lcd_bus.MEMORY_DMA)
    
    # Initialize ST7789 display with Arduino-compatible settings
    display = st7789.ST7789(
        data_bus=display_bus,
        display_width=WIDTH,
        display_height=HEIGHT,
        frame_buffer1=fb1,
        frame_buffer2=fb2,
        reset_pin=PIN_RESET,
        reset_state=st7789.STATE_LOW,
        power_on_state=st7789.STATE_HIGH,
        backlight_pin=PIN_BACKLIGHT,
        backlight_on_state=st7789.STATE_HIGH,
        offset_x=OFFSET_X,  # Critical 34-pixel offset from Arduino demo
        offset_y=OFFSET_Y,
        color_space=lv.COLOR_FORMAT.RGB565,
        color_byte_order=st7789.BYTE_ORDER_BGR,  # Keep BGR as it was working
        rgb565_byte_swap=True
    )
    
    # Initialize display (like MCT) - let the driver handle initialization
    display.init()
    display.set_power(True)
    
    # Set up PWM backlight (matching Arduino: 1000Hz)
    backlight_pwm = machine.PWM(machine.Pin(PIN_BACKLIGHT), freq=1000)
    backlight_pwm.duty_u16(int(65535 * 0.9))  # 90% brightness like Arduino
    
    return display

def test_display():
    """Test the display with a simple red screen to fix colors first"""
    print("Initializing display with Arduino-compatible settings...")
    display = init_display()
    
    # Get active screen (like MCT)
    screen = lv.screen_active()
    
    # Make the entire screen PURPLE
    screen.set_style_bg_color(lv.color_make(255, 0, 255), 0)  # Purple (Red + Blue)
    screen.set_style_bg_opa(lv.OPA.COVER, 0)
    
    # Add marker at (0,0) - top-left corner
    marker_0_0 = lv.obj(screen)
    marker_0_0.set_size(20, 20)  # 20x20 pixel marker (bigger)
    marker_0_0.set_pos(0, 0)
    marker_0_0.set_style_bg_color(lv.color_make(255, 255, 0), 0)  # Yellow
    marker_0_0.set_style_bg_opa(lv.OPA.COVER, 0)
    marker_0_0.set_style_border_width(0, 0)
    marker_0_0.set_style_radius(0, 0)
    
    # Add marker at (172-20, 320-20) - bottom-right corner (adjusted for marker size)
    marker_max = lv.obj(screen)
    marker_max.set_size(20, 20)  # 20x20 pixel marker (bigger)
    marker_max.set_pos(WIDTH - 20, HEIGHT - 20)  # Bottom-right corner
    marker_max.set_style_bg_color(lv.color_make(0, 255, 255), 0)  # Cyan
    marker_max.set_style_bg_opa(lv.OPA.COVER, 0)
    marker_max.set_style_border_width(0, 0)
    marker_max.set_style_radius(0, 0)
    
    # Force refresh (like MCT)
    screen.invalidate()
    lv.refr_now(None)
    
    print("Display test loaded - purple screen with corner markers (portrait 172x320)")
    print("Entire screen should be PURPLE with:")
    print("- YELLOW marker (20x20) at (0,0) - top-left corner")
    print("- CYAN marker (20x20) at (152,300) - bottom-right corner")
    print("Settings applied:")
    print("- 80MHz SPI frequency")
    print("- BGR color order with byte swap")
    print("- 1000Hz PWM backlight")
    print(f"- Offset X={OFFSET_X}, Y={OFFSET_Y}")
    print("Press Ctrl+C to exit")
    
    # Keep the display running with LVGL updates
    try:
        while True:
            lv.tick_inc(50)  # 50ms tick increment
            lv.task_handler()  # Process LVGL tasks
            time.sleep_ms(50)
    except KeyboardInterrupt:
        print("\nExiting...")

if __name__ == "__main__":
    test_display() ```

[kdschlosser]

display.set_rotation doesn't work?

[dcmcshan]

I think maybe this display is mirrored. text is backwards. do we have a mirror parameter?

[dcmcshan]

(I am nit working on the touch version of above, which is apparently different still...)

[dcmcshan]

For reference, this Arduino sketch seems to initialize the display correctly (if not the rotation I desire). At least the display isn't mirrored and colors are correct. How do I get this working under micropython?

#define ROTATION 0
#define GFX_BL 46

Arduino_DataBus *bus = new Arduino_ESP32SPI(45 /* DC */, 21 /* CS */, 38 /* SCK */, 39 /* MOSI */);

Arduino_GFX *gfx = new Arduino_ST7789(
  bus, 40 /* RST */, 0 /* rotation */, false /* IPS */,
  172 /* width */, 320 /* height */,
  34 /*col_offset1*/, 0 /*uint8_t row_offset1*/,
  34 /*col_offset2*/, 0 /*row_offset2*/);

void lcd_reg_init(void) {
  static const uint8_t init_operations[] = {
    BEGIN_WRITE,
    WRITE_COMMAND_8, 0x11,  // 2: Out of sleep mode, no args, w/delay
    END_WRITE,
    DELAY, 120,

    BEGIN_WRITE,
    WRITE_C8_D16, 0xDF, 0x98, 0x53,
    WRITE_C8_D8, 0xB2, 0x23, 

    WRITE_COMMAND_8, 0xB7,
    WRITE_BYTES, 4,
    0x00, 0x47, 0x00, 0x6F,

    WRITE_COMMAND_8, 0xBB,
    WRITE_BYTES, 6,
    0x1C, 0x1A, 0x55, 0x73, 0x63, 0xF0,

    WRITE_C8_D16, 0xC0, 0x44, 0xA4,
    WRITE_C8_D8, 0xC1, 0x16, 

    WRITE_COMMAND_8, 0xC3,
    WRITE_BYTES, 8,
    0x7D, 0x07, 0x14, 0x06, 0xCF, 0x71, 0x72, 0x77,

    WRITE_COMMAND_8, 0xC4,
    WRITE_BYTES, 12,
    0x00, 0x00, 0xA0, 0x79, 0x0B, 0x0A, 0x16, 0x79, 0x0B, 0x0A, 0x16, 0x82,

    WRITE_COMMAND_8, 0xC8,
    WRITE_BYTES, 32,
    0x3F, 0x32, 0x29, 0x29, 0x27, 0x2B, 0x27, 0x28, 0x28, 0x26, 0x25, 0x17, 0x12, 0x0D, 0x04, 0x00, 0x3F, 0x32, 0x29, 0x29, 0x27, 0x2B, 0x27, 0x28, 0x28, 0x26, 0x25, 0x17, 0x12, 0x0D, 0x04, 0x00,

    WRITE_COMMAND_8, 0xD0,
    WRITE_BYTES, 5,
    0x04, 0x06, 0x6B, 0x0F, 0x00,

    WRITE_C8_D16, 0xD7, 0x00, 0x30,
    WRITE_C8_D8, 0xE6, 0x14, 
    WRITE_C8_D8, 0xDE, 0x01, 

    WRITE_COMMAND_8, 0xB7,
    WRITE_BYTES, 5,
    0x03, 0x13, 0xEF, 0x35, 0x35,

    WRITE_COMMAND_8, 0xC1,
    WRITE_BYTES, 3,
    0x14, 0x15, 0xC0,

    WRITE_C8_D16, 0xC2, 0x06, 0x3A,
    WRITE_C8_D16, 0xC4, 0x72, 0x12,
    WRITE_C8_D8, 0xBE, 0x00, 
    WRITE_C8_D8, 0xDE, 0x02, 

    WRITE_COMMAND_8, 0xE5,
    WRITE_BYTES, 3,
    0x00, 0x02, 0x00,

    WRITE_COMMAND_8, 0xE5,
    WRITE_BYTES, 3,
    0x01, 0x02, 0x00,

    WRITE_C8_D8, 0xDE, 0x00, 
    WRITE_C8_D8, 0x35, 0x00, 
    WRITE_C8_D8, 0x3A, 0x05, 

    WRITE_COMMAND_8, 0x2A,
    WRITE_BYTES, 4,
    0x00, 0x22, 0x00, 0xCD,

    WRITE_COMMAND_8, 0x2B,
    WRITE_BYTES, 4,
    0x00, 0x00, 0x01, 0x3F,

    WRITE_C8_D8, 0xDE, 0x02, 

    WRITE_COMMAND_8, 0xE5,
    WRITE_BYTES, 3,
    0x00, 0x02, 0x00,
    
    WRITE_C8_D8, 0xDE, 0x00, 
    WRITE_C8_D8, 0x36, 0x00,
    WRITE_COMMAND_8, 0x21,
    END_WRITE,
    
    DELAY, 10,

    BEGIN_WRITE,
    WRITE_COMMAND_8, 0x29,  // 5: Main screen turn on, no args, w/delay
    END_WRITE
  };
  bus->batchOperation(init_operations, sizeof(init_operations));
}

void setup(void) {
  Serial.begin(115200);
  Serial.println("Arduino Color Test Starting...");

  // Init Display
  if (!gfx->begin()) {
    Serial.println("gfx->begin() failed!");
  }

  lcd_reg_init();
  gfx->setRotation(ROTATION);
  gfx->fillScreen(RGB565_BLACK);

  // Setup PWM for backlight
  ledcSetup(0, 1000, 10); // PWM channel 0, 1000Hz, 10-bit resolution
  ledcAttachPin(GFX_BL, 0); // Attach pin 46 to PWM channel 0
  ledcWrite(0, 1023); // Full brightness (100%)
  Serial.println("Backlight PWM initialized");

  Serial.println("Starting color test pattern...");
  
  // Test specific colors to compare with MicroPython
  // Display color blocks with labels
  
  int blockHeight = 40;
  int y = 0;
  
  // BLACK background (already set)
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_WHITE);
  gfx->setTextSize(1);
  gfx->println("BLACK BG");
  y += blockHeight;
  
  // RED block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_RED);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_WHITE);
  gfx->println("RED (255,0,0)");
  Serial.println("RED block displayed");
  y += blockHeight;
  
  // GREEN block  
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_GREEN);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_BLACK);
  gfx->println("GREEN (0,255,0)");
  Serial.println("GREEN block displayed");
  y += blockHeight;
  
  // BLUE block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_BLUE);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_WHITE);
  gfx->println("BLUE (0,0,255)");
  Serial.println("BLUE block displayed");
  y += blockHeight;
  
  // YELLOW block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_YELLOW);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_BLACK);
  gfx->println("YELLOW (255,255,0)");
  Serial.println("YELLOW block displayed");
  y += blockHeight;
  
  // CYAN block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_CYAN);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_BLACK);
  gfx->println("CYAN (0,255,255)");
  Serial.println("CYAN block displayed");
  y += blockHeight;
  
  // MAGENTA block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_MAGENTA);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_WHITE);
  gfx->println("MAGENTA (255,0,255)");
  Serial.println("MAGENTA block displayed");
  y += blockHeight;
  
  // WHITE block
  gfx->fillRect(0, y, gfx->width(), blockHeight, RGB565_WHITE);
  gfx->setCursor(10, y + 15);
  gfx->setTextColor(RGB565_BLACK);
  gfx->println("WHITE (255,255,255)");
  Serial.println("WHITE block displayed");
  
  Serial.println("Color test pattern complete!");
  Serial.println("Compare these colors with your MicroPython version:");
  Serial.println("- Does RED look red?");
  Serial.println("- Does GREEN look green?");
  Serial.println("- Does BLUE look blue?");
  Serial.println("- Does YELLOW look yellow?");
  Serial.println("- Does CYAN look cyan?");
  Serial.println("- Does MAGENTA look magenta?");
}

void loop() {
  // Just keep the pattern displayed
  delay(5000);
  Serial.println("Color test still running...");
} ```

[kdschlosser]

you will need to adjust the orientation table