To embed a binary in esp-idf I believe you need something like:

    create_resources(${CMAKE_CURRENT_LIST_DIR}/../../binaries/RAM_APP ${CMAKE_BINARY_DIR}/binaries.c)
    set_property(SOURCE ${CMAKE_BINARY_DIR}/binaries.c PROPERTY GENERATED 1)

Or using `EMBED_FILES`

I just happened to be looking at this very thing today that had to do this: https://github.com/espressif/esp-serial-flasher/blob/master/...

Go for the SPI version, which is the same chip but just s different breakout board.

Many ESP32's can only do 400kHz I2C, whereas their SPI peripheral can often do 80 MHz or more (although you wouldn't want to go that fast here). 400kHz sort of works, but if you also want to handle other I2C devices it can easily become a problem.

I really love the SSD1306 for its educational value. If you've bought a sensor kit for Arduino or ESP32 or Pico or whatever, chances are decent that you already have an SSD1306 lying around. There's so much example code for it. And the datasheet was pretty easy to grok IMO. My first exposure to it was in the pico-examples repo: https://github.com/raspberrypi/pico-examples/tree/master/i2c...

There's a few Rust libraries for it, too. And it's supported in Wokwi! https://wokwi.com/projects/425067706980448257

I really love the u8g2 library, but unfortunately I love my SSD1327 OLED even more. It supports 16-tone greyscale (which u8g2 cannot do) allowing 80s/90s video game style image dithering.

Getting up and running with lvgl was honestly kind of brutal, but now that it's done, I am generally happy with it. As you determined, it's much more of a UI toolkit than u8g2; the sort of thing designed with fancy thermostats and smart watches in mind. u8g2 has a menu toolkit but it is pretty narrow in scope.

I am planning on releasing a bare bones IDF-SDK v5.4 + lvgl 9.x + SSD1327 starter project soon so that I can hopefully save future travelers some pain.

It’s generally quite easy to use these over I2C without a driver. You can crib the sequence of initialization commands from the example code supplied by the manufacturer (or loads of examples on GitHub), and then the commands to draw to the screen are pretty straightforward. The chip has its own display RAM, so you don’t need to worry about redrawing every time the display refreshes or anything as low-level as that.

Here's a rust version i made with bitmapped fonts for both i2c and SPI https://github.com/scopenews/minimalSSD1306driver/ I was running this on my pi as a demo.

I normally work with C++ on esp32 for these little displays, and in there I use a screen buffer for partial refreshes which makes them very fast !!

This display is the modern 16x2 display for hardware hackers: cheap and versatile.

One of my favorite hacks is running this display over HDMI [0].

Note that it’s possible to refresh it at higher rates by using partial refreshes. Or even higher to 150 fps [1].

[0] https://hackaday.com/2022/04/01/making-your-own-technically-...

[1] https://hackaday.com/2018/05/08/push-it-to-the-limit-ssd1306...

I’m actually working on code for esp-idf / SSD1309 right now, a little bigger than the 1306. I went through a similar arc as OP.

I was actually surprised / disappointed by the poor quality of the drivers out there. If you instrument and log the bytes u8g2 sends to the device and how the buffer is sent, you see it’s pretty messy, inefficient and hacky. Seems like everyone copy+pasting everyone else’s code, without understanding fully.

So in the end I just decided to draw into a local buffer and then send that buffer in one single transaction to the display.

Once you figure out the data sheet it’s actually very easy to program these displays. For example, to test any SSDxxxx display, you need to send all of two bytes: 0xaf (display on), 0xa5 (all pixels on)

I am now looking at SSD1322, which is both grayscale and has enough internal RAM for two buffers for even smoother drawing (write into a non-displayed region of the RAM and then change the display offset)

It's worth noting that the controllers for these small displays and their instruction sets have a common lineage that goes back to the 90s --- the SSD1306's looks very much like the Epson S1D15300 series, for example. From a quick search, other controllers with a similar instruction set are ST7565 and UC1601.

There is also https://github.com/pioarduino/platform-espressif32 which allows one to use Arduino > 3.2 and IDF > 5.4. If you use PlatformIO put this into your platformio.ini

  [espressif32] ; PLATFORM
  platform = espressif32
  board_build.embed_txtfiles = folder/file.ext ; embed null-terminated file(s)

Also have a look at https://docs.platformio.org/en/latest/platforms/espressif32.....

I love this. Once you go to the esp-idf you never want to go back.

I do like lvgl when I get it going, but the way it forces a structure on the code is not to my linking. Every time I start a new project I get annoyed until I get it working.

LVGL works better on slow displays with internal video memory if you minimize the vertical height of widgets. That allows the library to update smaller strips of the display as widgets are redrawn.

Related post from few days ago https://diy-synths.snnkv.com/

The SH1106 (1.3 inch) is a better option now. You can get them for 1.50$ on aliexpress sometimes

That's one of the biggest shaving the yak tangents I've seen.

Love it.