This is the web page a fully functioning ESP32-S3 developer board presents now.


The view the web page presents is dynamic. Here's what that means:

1. If the OLED display isn't present, then the `Toggle OLED` button is not shown.

2. If the ESP32-S3 fails to connect with the MQTT broker then the `MQTT Report` button is not shown.

3. If the ESP32-S3 developer board does not have a configured `vfs2` FLASH section, then the text at the bottom showing `vfs2 size` is not shown.

This startup output is captured from Thonny's REPL window.

If the board fails to connect to the MQTT broker, this is the last part of the output:

Once the firmware is operational on the ESP32-S3 developer board, then upload all the Python files, and only the Python files, to the developer board.

You will need to create `settings.py` file that contains the following two lines:

1. `AP_SSID = "your-wifi-SSID"` and

2. `AP_PASSWORD = "your-wifi-password"`,

$ sudo apt install mosquitto mosquitto-clients -y

Once installed, add the following lines (at a minimum) to `/etc/mosquitto/conf.d/default.conf`:

Once installed make check if the Mosquitto broker is up and running:

$ systemctl status mosquitto

● mosquitto.service - Mosquitto MQTT Broker

Jun 14 00:50:10 pi05-01 systemd[1]: Reloading mosquitto.service - Mosquitto MQTT Broker...

Jun 14 00:50:10 pi05-01 systemd[1]: Reloaded mosquitto.service - Mosquitto MQTT Broker.

In the example above Mosquitto is loaded and active (running). If it is and you've edited the `default.conf` file, then type `sudo systemctl stop mosquitto` followed by `sudo systemctl start mosquitto` to read the configuration file. `systemctl` has a `restart` command, but I prefer a hard stop then a start to make sure everything is properly initialized.

Once the broker is up, open a terminal and type the following:

All ESP32-S3 minified JSON messages:

The `PWRON` message is sent every time the board successfully starts up and immediately after opening a connection to the MQTT broker.

The `PING` message is sent every 120 seconds/two minutes.

The `NEOP` messages are generated from the web page buttons toggling the color NeoPixel. They tell which color is chosen and if it's state is on or off.

The `REPORT` message is sent via the `MQTT Report` web page button. It sends if the OLED (`OLED`) display was found and enabled (None if not), if the alphanumeric (`ANLED`) 14-segment LEDs were found and enabled (None if not), MicroPython version, the version of the ESP-IDF toolset that was used to build that MicroPython version and the date it was last built.

Every message contains the SSID that sent the message.

Every message time stamp is ISO 8601 UTC.

* Stepped up to ESP-IDF 5.4.2 to build the latest MicroPython sources.

* Added drivers and hardware for HT16K33/YT16K33 14-segment LED displays. The LEDs display a 24 hour clock.

The drivers are from **HT16K33 Drivers 4.2.0** (https://github.com/smittytone/HT16K33-Python) and are in the `lib` folder.

* Cleaned up the code and web page to better align everything.

After re-reading a specific MicroPython check-in, I re-ran `idf.py fullclean`, then `idf.py set-target esp32s3 menuconfig` to set the maximum amount of flash to 32 GiB. The latest checkins fixed the bug with the ESP32-S3 boards with more than 8 GiB of FLASH; those boards will now report the correct amount of FLASH.

import machine

import ssd1306

import display_tools

import ht16k33_tools as htools

print( " Boot: START")

print(f" Memory: {gc.mem_free():,} bytes")

# Check if there is an SSD1306 display attached.

#

if ssd1306.OLED_ADDR in i2c_scanned:

#

# Create instance of SSD1306 class to control the

# display. Initialize it by clearing everything.

#

DISPLAY = ssd1306.SSD1306_I2C(ssd1306.OLED_WIDTH, ssd1306.OLED_HEIGHT, SOFT_I2C)

DISPLAY.fill(0)

print(" I2C: SSD1306 OLED Initialized")

if htools.LED1_ADDR in i2c_scanned and htools.LED2_ADDR in i2c_scanned:

htools.init(SOFT_I2C)

print(" I2C: HT16K33 LEDs Initialized")

print(" Boot: END")

import time

import mqtt_tools as mqtt

display = None

ssid = None

ip = None

def do_graphics(_display, _ssid, _ip):

global display, ssid, ip

display = _display

ssid = _ssid

ip = _ip

#

# Display the official MicroPython logo

#

display.text(platform.platform().split('-')[1], 72, 0, 1)

if mqtt.mqttClient is not None:

display.text(f"MQTT {mqtt.mqtt_msg_count}", 40, 10, 1)

display.text(ssid, 0, 36, 1)

display.text(str(ip), 0, 46, 1)

now = time.localtime(time.time() + (-4 * 3600))

year = now[0]

_show_display = True

def timer_callback(t):

global display, _show_display

_show_display = False

display.fill(0)

display.show()

def setup_display_blank_timer():

timer = Timer(2)

timer.init(period=60000, mode=Timer.ONE_SHOT, callback=timer_callback)

def toggle_display_on_off():

global display, ssid, ip, _show_display

if display is None:

return

_show_display = not _show_display

if _show_display:

do_graphics(display, ssid, ip)

setup_display_blank_timer()

else:

display.fill(0)

display.show()

from machine import Timer

import time

from ht16k33 import HT16K33Segment14

LED1_ADDR = const(0x70)

LED2_ADDR = const(0x71)

LED3_ADDR = const(0x72)

LED4_ADDR = const(0x73)

i2c = None

led1 = None

led2 = None

def clock_display_callback(timer_object):

# Time calculation is hard-coded for EST/EDT (New York America).

now = time.localtime(time.time() + (-4 * 3600))

hours = now[3]

minutes = now[4]

seconds = now[5]

atime = f"{hours:2d}{minutes:02d}{seconds:02d}"

led1.set_character(atime[0], 0).set_character(atime[1], 1).set_glyph(0x0009, 2).set_character(atime[2], 3).draw()

led2.set_character(atime[3], 0).set_glyph(0x0009, 1).set_character(atime[4], 2).set_character(atime[5], 3).draw()

def init(_i2c):

global i2c, led1, led2

i2c = _i2c

led1 = HT16K33Segment14(i2c, board=HT16K33Segment14.ECBUYING_054)

led1.set_brightness(2)

led1.clear().draw()

led2 = HT16K33Segment14(i2c, i2c_address=0x71, board=HT16K33Segment14.ECBUYING_054)

led2.set_brightness(2)

led2.clear().draw()

def start_clock():

if i2c is None:

return

timer = Timer(1)

timer.init(period=1000, mode=Timer.PERIODIC, callback=clock_display_callback)

__author__ = 'Tony Smith'

__credits__ = ['Tony Smith', 'Ubi de Feo', 'akbiocca']

__license__ = "MIT"

__version__ = "4.2.0"

__maintainer__ = "Tony Smith"

from .ht16k33 import *

from .ht16k33bar import *

from .ht16k33matrix import *

from .ht16k33matrixcolour import *

from .ht16k33matrixfeatherwing import *

from .ht16k33matrixmulti import *

from .ht16k33segment import *

from .ht16k33segment14 import *

from .ht16k33segmentbig import *

from .ht16k33segmentgen import *