Compilation guidance for Lilygo T-Display S3

[scruss]

A couple of days ago, Lilygo announced they had released MicroPython support for their T-Display-S3. They linked to a repo, but with no instructions what to do with it: lilygo-micropython/target/esp32s3/boards/LILYGO_T-DisplayS3 at master · Xinyuan-LilyGO/lilygo-micropython

Is this supposed to go under ports/esp32/boards? I've never built anything for ESP32, so I suspect I have some huge development platform to download and configure too.

[russhughes]

Clone the entire repo, copy the config_T-DisplayS3 to the config file then type make. It will download the development environment(s) and build the firmware.

[scruss]

make -j1 issues are particularly troubling for new/naïve users (I'm definitely one of the latter) because they sometimes mysteriously disappear if you type make again

[robert-hh]

Not mysteriously: at the second run the missing generated files exist, unless you had a make clean in between. But it's something which needs to be fixed.

[scruss]

very mysteriously if you don't understand make: it's counterintuitive that repeating the same command that failed the first time will work the second time

[scruss]

@russhughes looks like they're used your library but stripped out most useful things. I can't get fonts and colour selection to work at all

[russhughes]

I think the developers' repo is https://github.com/liangyingy/lcd_binding_micropython. It looks like it's a work in progress. The last time I checked, https://github.com/russhughes/st7789s3_mpy, was a bit faster.

I'm trying to get a DMA version working.

[OlivierLenoir]

Did you try using Docker?
The following image exists micropython/build-micropython-esp32 Build environment for the MicroPython ESP32 … and may have all necessary requirement for build.
But I've never built anything for ESP32.
@jimmo, can you guide us and who know the micropython docker image?

[russhughes]

There is a pull request with a docker build environment Xinyuan-LilyGO/lilygo-micropython#7 that I haven’t tried.

[scruss]

I haven't used Docker. It seems to be a means to use disk space and make computers run slowly. But people used to say that about Unix ☺

[mattytrentini]

The following image exists micropython/build-micropython-esp32 Build environment for the MicroPython ESP32 …

I maintain the micropython/* docker images and have been using them for some time for builds. I have a PR in-the-making to update the various port README's to explain how to build with them. However, the build-micropython-esp32 image is defunct since Espressif started maintaining official IDF images.

For example, to build for the LOLIN_S2_MINI, take a clone of micropython, cd to the root of the repository and run:

> docker run -ti --rm -v $(pwd):/code -w /code espressif/idf:release-v4.4 bash -c "make -C mpy-cross && make -C ports/esp32 submodules all -j4 BOARD=LOLIN_S2_MINI"

To change the IDF version, simply modify the release-v4.4 tag. You may want to update -j4 depending on the number of cores in your system.

On many systems (including mine: Win10/WSL2) builds take roughly the same time as building on the host. As a general rule, I don't install any development environments on my host these days! Docker solves that problem very neatly.

[sosi-deadeye]

I use on Arch Linux a chroot with Arch Linux for development.
This is also an isolation from the rest of the system.

The whole chroot lives in an RAW-Image, which I attach as a block device with losetup, then mounting the file system and then chroot into it.

It's also good to use git and make to learn the possible occurring problems.
I made a little Python-Script which I used once to create the chroot-env.

Maybe it's useful for you. No guarantee that everything is right.

#!/usr/bin/env python3
 
"""
The target was to create an independent build environment
for micropython-esp32 (master branch) on Arch-Linux.

- create image-file:
  # no sudo
  truncate -- size 16G image.img
  # user still owns the image.img
- sudo mount image-file as block device: losetup -f -P --show image.img
- create a new partition:
  sudo sfdisk /dev/loopXX <<EOF
  2048
  EOF
- create a fs on new created partition:
  mkfs.ext4 /dev/loopXXp1
- sudo mount /dev/loopXXp1 /somewhere...
- run chroot:
  sudo arch-chroot /somewhere... <<EOF
  # shell commands to execute in chroot
  EOF
- Download micropython and esp32-idf with git
  https://github.com/micropython/micropython/blob/master/ports/esp32/README.md
- compile it in new environment
 
ToDO:
- flash esp32
- catch all exceptions
"""

import subprocess
from pathlib import Path
from textwrap import dedent


ARCH_PACKAGES = (
    "base",
    "linux",
    "base-devel",
    "arm-none-eabi-gcc",
    "arm-none-eabi-newlib",
    "cmake",
    "python",
    "python-pip",
    "python-virtualenv",
    "wget",
    "git",
    "libusb",
)


def mkimg(image: str | Path, size: str):
    command = ["truncate", "--size", size, image]
    subprocess.run(command, check=True)


def mkpart(image: str | Path) -> str:
    losetup = ["sudo", "losetup", "-f", "-P", "--show", image]
    loop_dev = subprocess.run(
        losetup, encoding="ascii", check=True, capture_output=True
    ).stdout.strip()

    sfdisk_input = "2048\n"
    sfdisk = ["sudo", "sfdisk", loop_dev]
    subprocess.run(sfdisk, input=sfdisk_input, check=True, encoding="ascii")
    return f"{loop_dev}p1"


def mkfs(partition: str | Path):
    mkfs = ["sudo", "mkfs.ext4", partition]
    subprocess.run(mkfs, check=True)


def mount(src, dst):
    command = ["sudo", "mount", src, dst]
    subprocess.run(command, check=True)


def pacstrap(root: str | Path):
    if not root.is_absolute():
        raise RuntimeError("The supplied path is not an absolute path.")
    command = ["sudo", "pacstrap", root, *ARCH_PACKAGES]
    subprocess.run(command, check=True)


def chroot(root: str | Path, script: str):
    command = ["sudo", "arch-chroot", root]
    subprocess.run(command, encoding="utf8", check=True, input=script)


if __name__ == "__main__":
    SCRIPT = dedent("""
    #!/bin/bash
    useradd -m build
    usermod -a -G uucp build
    cat > /home/build/compile.sh <<EOF
    #!/bin/bash

    set -e

    git clone --depth 1 https://github.com/micropython/micropython.git
    git clone --depth 1 -b v4.4 --recursive https://github.com/espressif/esp-idf.git
    pushd esp-idf
    git checkout v4.4
    git submodule update --depth 1 --init --recursive
    ./install.sh
    source export.sh
    popd

    cd micropython
    make -C mpy-cross
    cd ports/esp32
    make submodules
    make
    EOF

    chmod +x /home/build/compile.sh
    su - build /home/build/compile.sh
    """)

    ROOT = Path("/home/deadeye/Downloads/rootfs")
    IMAGE = Path("/home/deadeye/Downloads/TEST.img")
    IMAGE_SIZE = "16G"
    mkimg(IMAGE, IMAGE_SIZE)
    partition = mkpart(IMAGE)
    mkfs(partition)
    mount(partition, ROOT)
    pacstrap(ROOT)
    chroot(ROOT, SCRIPT)


# OUTPUT
# (seems to work)

# Project build complete. To flash, run this command:
# /home/build/.espressif/python_env/idf4.4_py3.10_env/bin/python ../../../esp-idf/components/esptool_py/esptool/esptool.py -p (PORT) -b 460800 --before default_reset --after hard_reset --chip esp32  write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x1000 build-GENERIC/bootloader/bootloader.bin 0x8000 build-GENERIC/partition_table/partition-table.bin 0x10000 build-GENERIC/micropython.bin
# or run 'idf.py -p (PORT) flash'
# bootloader  @0x001000    21584  (    7088 remaining)
# partitions  @0x008000     3072  (    1024 remaining)
# application @0x010000  1466208  (  565408 remaining)
# total                  1531744