TULX — firmware

Installing firmware

There is nothing to flash on this page. The TULX has no USB port; it carries a recovery system that installs firmware over your network. This page publishes the images and explains how to build your own.

Start the recovery. A new TULX ships without an application and starts in the recovery by itself. Later, hold the button S1 while connecting the KNX bus and keep it held for 5 s — the LED lights up when it has taken. From a running busware application, its web page has a Restart into recovery button.
Connect. Without a known network, and always while no application is installed that starts, the recovery opens the access point TULX32-Recovery-xxxx — without a key as delivered — with its page at http://192.168.4.1/. Scan for your network there and join it; the page then shows the device's new address. Until an application is installed that starts, the access point stays open, so you can go on with the next step on the same page.
Install. Under Install from busware press Check online and pick an image — the device downloads it and checks it itself. Without internet access, download a .bin below and upload it under Install from a file.
Leave. An installed image starts by itself and runs on your network; the recovery page names the address it will most likely have there. Start application returns to the installed one without changing anything; after 15 minutes without activity the recovery does that on its own.

Access-point key and factory reset

The recovery's access point is open as delivered, so the device stays reachable when it has no network. Give it a key under Recovery access point on the recovery page if you want to close it.

Factory reset: while the recovery is running, hold S1 for 10 s until the LED stays on, then release it. This erases the installed application with all its settings (the KNX configuration included), the Wi-Fi settings and the access-point key. The recovery itself stays: the device comes back as delivered, with its access point open, and an application can be installed again.

Images

File	Application	Version	Size	MD5

These are application images, not full flash images. The recovery checks the MD5 from the manifest before it starts what it wrote.

Your own firmware

Any ESP32-C6 application can run on the TULX. It is installed like the images above (Install from a file); an image without the busware marker is installed after you confirm it. Checked with ESP-IDF 5.5 and Arduino-ESP32 3.x.

What the recovery accepts

An ESP32-C6 application image — the .bin your build produces for the app. A merged image (bootloader + partition table + app) is accepted too; only its application part is installed. A bootloader alone is refused.
At most 2 528 KiB (0x278000 bytes), the size of ota_0.
Flash size in the image header at most 4 MB, and a chip-revision range that includes the board (current boards are ESP32-C6 v0.2; the ESP-IDF default minimum v0.0 is fine).
The image has to pass the ESP-IDF image check (checksum and appended SHA-256), as every normal build does.

Partition table and linking

The partition table is fixed on the device. Build against it: partitions_tulx.csv

Name	Offset	Size	Use
`nvs`	`0x9000`	20 KiB	NVS — yours, and where the Wi-Fi driver keeps the network
`otadata`	`0xE000`	8 KiB	start selection
`ota_0`	`0x10000`	2 528 KiB	your application
`storage`	`0x288000`	128 KiB	LittleFS — yours
`actor_db`	`0x2A8000`	32 KiB	NVS used by busware applications
`factory`	`0x2B0000`	1 280 KiB	the recovery — do not touch
`prov`	`0x3F0000`	4 KiB	start pass — do not touch
`rcfg`	`0x3F1000`	4 KiB	access-point key of the recovery — do not touch
`coredump`	`0x3F2000`	56 KiB	core dump

The recovery writes your image to ota_0 at 0x10000. An ESP32 application is not linked to a flash address — the bootloader maps it through the MMU — so a normal build fits as long as it uses this table and stays within 2 528 KiB.
Keep the partition-table offset at its default 0x8000: the application reads the table from there at run time.
Only ota_0 is written. Anything else your build produces — a LittleFS or SPIFFS image, a data partition — never reaches the device. Embed initial content in the application and create the file system in storage on the first start.

PlatformIO (Arduino):

[env:tulx]
platform  = <an Arduino-ESP32 3.x platform, e.g. pioarduino>
board     = esp32-c6-devkitc-1
framework = arduino
board_build.flash_size = 4MB
board_build.partitions = partitions_tulx.csv
; do not add -DARDUINO_USB_CDC_ON_BOOT=1 -- Serial has to stay on UART0

ESP-IDF (sdkconfig.defaults):

CONFIG_IDF_TARGET="esp32c6"
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_tulx.csv"
CONFIG_PARTITION_TABLE_OFFSET=0x8000
CONFIG_ESP_CONSOLE_UART_DEFAULT=y
CONFIG_ESP_CONSOLE_UART_NUM=0

Upload the application image: .pio/build/tulx/firmware.bin (PlatformIO) or build/<project>.bin (ESP-IDF).

Hardware

Part	Connection
MCU	ESP32-C6FH4, 4 MB flash in the package
KNX transceiver	NCN5130 in TP-UART mode: GPIO4 = ESP TX → NCN RXD, GPIO5 = ESP RX ← NCN TXD, 38 400 baud 8E1 (set by the hardware)
LED	GPIO8, active low
Button S1	GPIO14, active low with an external pull-up. At start-up it is the recovery button (5 s).
Console	UART0, on the service connector only — there is no USB

Rules for the TULX

Power. The device lives on the KNX bus. Cap the Wi-Fi transmit power at 18 dBm after every esp_wifi_start() (in Arduino too: after WiFi.begin()):
```
esp_wifi_set_max_tx_power(72);   /* quarter-dBm units: 72 = 18 dBm */
```
At the default 20 dBm the supply collapses under load and the board resets.
No self-update. There is one application slot, and esp_ota_begin() refuses the partition it runs from. Updates go through the recovery.
Offer the way back into the recovery. factory is the only partition a running application can select:
```
#include "esp_ota_ops.h"

const esp_partition_t *f = esp_partition_find_first(
    ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_FACTORY, NULL);
if (f && esp_ota_set_boot_partition(f) == ESP_OK) esp_restart();
```
The recovery makes your application the start image again when it comes up, so a restart without installing anything returns to it.
Use the network set in the recovery. The recovery stores it through the Wi-Fi driver. An Arduino sketch connects to it with WiFi.begin() without arguments; an ESP-IDF application reads it with esp_wifi_get_config() after esp_wifi_init().
No rollback protection. An image without the busware marker is started unconditionally. If yours fails right after start, hold S1 while connecting the bus to get back into the recovery, or use the factory reset.