Make T114 screen detection the default firmware and picker choice

This commit is contained in:
mikecarper committed 2026-10-18 16:20:27 -07:00
1 parent 864d0cacff
commit 1ce3f0cdd7
22 files changed
+1686 -124

No files matched your search

+225
View File
@@ -0,0 +1,225 @@
#!/usr/bin/env python3
"""Run production Companion button routing and helpers with no display."""
from pathlib import Path
import os
import subprocess
import sys
import tempfile
import unittest
from test_replay_reset_integration import extract_braced
ROOT = Path(__file__).resolve().parents[1]
UI = ROOT / "examples/companion_radio/ui-new/UITask.cpp"
HARNESS = r'''
#include <cassert>
#include <cstdint>
#include <initializer_list>
#include <string>
#define PIN_USER_BTN 7
#define UI_HAS_JOYSTICK 0
#define UI_WIFI_SETUP_HOME_PAGE 0
#define MESH_DEBUG_PRINTLN(...)
constexpr char KEY_ENTER='e', KEY_NEXT='n', KEY_PREV='p', KEY_SELECT='s', KEY_UP='u', KEY_DOWN='d';
constexpr int BUTTON_EVENT_CLICK=1, BUTTON_EVENT_LONG_PRESS=2, BUTTON_EVENT_DOUBLE_CLICK=3;
constexpr int BUTTON_EVENT_TRIPLE_CLICK=4, BUTTON_EVENT_QUADRUPLE_CLICK=5;
uint32_t now_ms=0;
uint32_t millis() { return now_ms; }
bool visual_allowed=false;
unsigned visual_checks=0;
void visual() { assert(visual_allowed && "headless visual path"); ++visual_checks; }
namespace mesh { namespace ui {
enum class DisplayWake { Button };
bool shouldDisplayBluetoothPairingPin(bool enabled, bool connected, uint32_t pin) {
return enabled && !connected && pin;
}
}}
struct Mesh {
unsigned notifications=0, rescues=0;
void notificationButton() { ++notifications; }
void enterCLIRescue() { ++rescues; }
uint32_t getBLEPin() const { return 123456; }
} the_mesh;
struct Button {
int event=0;
int check() { const int result=event; event=0; return result; }
} user_btn;
struct Display {
bool on=true;
unsigned wakes=0, dismissals=0;
bool isOn() const { visual(); return on; }
void wake(mesh::ui::DisplayWake) { visual(); ++wakes; on=true; }
void dismiss() { visual(); ++dismissals; on=false; }
} display;
struct UIScreen {
unsigned inputs=0;
char last=0;
void handleInput(char key) { visual(); ++inputs; last=key; }
};
struct HomeScreen : UIScreen {
bool radio_page=false;
bool isRadioPage() const { visual(); return radio_page; }
void showFirstPage() { visual(); }
};
struct UITask {
Display* _display=nullptr;
HomeScreen home_screen;
UIScreen preview_screen, reader_screen;
UIScreen *home=&home_screen, *msg_preview=&preview_screen, *reader=&reader_screen, *curr=home;
bool _pairing_from_button=false, _startup_complete=false;
uint32_t _pairing_screen_until=0, _next_refresh=0, ui_started_at=0;
unsigned buzzer_changes=0, reader_opens=0, reader_closes=0;
bool isPairingScreenActive() const { return false; }
bool isBluetoothEnabled() const { return false; }
bool hasBluetoothConnection() const { return false; }
void showPairingPin(bool) { visual(); }
bool isReaderActive() const { visual(); return reader && curr==reader; }
void closeReader() { visual(); ++reader_closes; curr=home; }
void showReader() { visual(); ++reader_opens; curr=reader; }
void setCurrScreen(UIScreen* screen) { visual(); curr=screen; }
void toggleBuzzer() { ++buzzer_changes; }
char checkDisplayOn(char);
char handleLongPress(char);
char handleDoubleClick(char);
char handleMultiClick(char, bool);
void pollButtons();
};
@HELPERS@
void UITask::pollButtons() {
@BUTTONS@
}
void event(UITask& ui, int code) { user_btn.event=code; ui.pollButtons(); }
void headless() {
visual_allowed=false;
for (int screen=0; screen<3; ++screen) {
for (int code : {BUTTON_EVENT_CLICK, BUTTON_EVENT_DOUBLE_CLICK,
BUTTON_EVENT_TRIPLE_CLICK, BUTTON_EVENT_QUADRUPLE_CLICK}) {
UITask ui;
ui.curr=screen==0 ? ui.home : screen==1 ? ui.msg_preview : ui.reader;
now_ms=10000; visual_checks=0; the_mesh={};
event(ui, code);
assert(visual_checks==0 && the_mesh.rescues==0);
assert(the_mesh.notifications==1 && "physical notification acknowledgement survives");
assert(ui.buzzer_changes==(code==BUTTON_EVENT_TRIPLE_CLICK || code==BUTTON_EVENT_QUADRUPLE_CLICK));
assert(ui.home_screen.inputs==0 && ui.preview_screen.inputs==0 && ui.reader_screen.inputs==0);
assert(ui.reader_opens==0 && ui.reader_closes==0);
}
// The early physical rescue remains available without consulting screens.
for (bool startup_complete : {false, true}) {
UITask ui;
ui.curr=screen==0 ? ui.home : screen==1 ? ui.msg_preview : ui.reader;
ui._startup_complete=startup_complete;
ui.ui_started_at=UINT32_MAX-4000u;
now_ms=500; the_mesh={}; visual_checks=0;
event(ui, BUTTON_EVENT_LONG_PRESS);
assert(the_mesh.rescues==unsigned(!startup_complete));
assert(visual_checks==0 && the_mesh.notifications==0);
now_ms=5000; the_mesh={};
event(ui, BUTTON_EVENT_LONG_PRESS);
assert(the_mesh.rescues==0 && visual_checks==0);
}
}
}
void visible() {
visual_allowed=true; now_ms=10000;
UITask ui; ui._display=&display; ui._startup_complete=true;
display={}; the_mesh={};
event(ui, BUTTON_EVENT_CLICK);
assert(ui.home_screen.inputs==1 && the_mesh.notifications==1);
#ifdef UI_HAS_NAV_INPUT
assert(ui.home_screen.last==KEY_ENTER);
#else
assert(ui.home_screen.last==KEY_NEXT);
#endif
// A single wake gesture remains consumed by the existing display policy.
display.on=false;
event(ui, BUTTON_EVENT_CLICK);
assert(display.on && ui.home_screen.inputs==1);
ui.curr=ui.msg_preview;
event(ui, BUTTON_EVENT_DOUBLE_CLICK);
#ifdef UI_HAS_NAV_INPUT
assert(ui.preview_screen.last==KEY_SELECT);
#else
assert(ui.preview_screen.last==KEY_PREV);
#endif
event(ui, BUTTON_EVENT_TRIPLE_CLICK);
assert(ui.preview_screen.last==KEY_DOWN && ui.buzzer_changes==0);
event(ui, BUTTON_EVENT_QUADRUPLE_CLICK);
assert(ui.preview_screen.last==KEY_UP && ui.buzzer_changes==0);
ui.curr=ui.home;
event(ui, BUTTON_EVENT_TRIPLE_CLICK);
assert(ui.buzzer_changes==1);
#if COMPANION_FEATURE_READER
ui.curr=ui.reader;
event(ui, BUTTON_EVENT_LONG_PRESS);
assert(ui.reader_closes==1 && ui.curr==ui.home);
ui.home_screen.radio_page=true;
event(ui, BUTTON_EVENT_LONG_PRESS);
assert(ui.reader_opens==1 && ui.curr==ui.reader);
#endif
}
int main(int argc, char** argv) {
assert(argc==2);
if (std::string(argv[1])=="headless") headless(); else visible();
}
'''
def fixture(source):
loop = extract_braced(source, "void UITask::loop()")
buttons = loop[loop.index(" char c = 0;"):loop.index(" userLedHandler();")]
helpers = "\n".join(extract_braced(source, "char UITask::" + name)
for name in ("checkDisplayOn(", "handleLongPress(",
"handleDoubleClick(", "handleMultiClick("))
return HARNESS.replace("@HELPERS@", helpers).replace("@BUTTONS@", buttons)
class CompanionHeadlessButtonTests(unittest.TestCase):
def build(self, directory, source, *, nav=False, reader=True):
cpp, binary = directory / "test.cpp", directory / "test"
directory.mkdir()
cpp.write_text(fixture(source))
sanitizers = (["-fsanitize=address,undefined", "-fno-sanitize-recover=all", "-fno-pie", "-no-pie"]
if sys.platform.startswith("linux") else [])
result = subprocess.run([
os.environ.get("CXX", "g++"), "-std=c++17", "-Wall", "-Wextra", "-Werror",
*sanitizers, "-DCOMPANION_FEATURE_READER=" + str(int(reader)),
*(["-DUI_HAS_NAV_INPUT=1"] if nav else []), str(cpp), "-o", str(binary)
], capture_output=True, text=True, timeout=60)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
return binary
def run_case(self, binary, scenario, *, negative=False):
result = subprocess.run([str(binary), scenario], capture_output=True, text=True, timeout=10)
if negative:
self.assertNotEqual(result.returncode, 0, "old headless navigation unexpectedly survived")
else:
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
def test_actual_button_mapping_and_helpers_with_and_without_display(self):
with tempfile.TemporaryDirectory(prefix="companion-headless-") as directory:
for nav, reader in ((False, False), (False, True), (True, False), (True, True)):
with self.subTest(nav=nav, reader=reader):
binary = self.build(Path(directory) / f"{nav}-{reader}", UI.read_text(),
nav=nav, reader=reader)
self.run_case(binary, "headless")
self.run_case(binary, "visible")
def test_original_null_navigation_is_detected(self):
source = UI.read_text()
helper = extract_braced(source, "char UITask::checkDisplayOn(")
old_helper = helper.replace("return _display != NULL ? c : 0;", "return c;")
self.assertNotEqual(helper, old_helper)
source = source.replace(helper, old_helper)
old_dispatch = "if (c != 0 && curr && _display != NULL)"
self.assertIn(old_dispatch, source)
source = source.replace(old_dispatch, "if (c != 0 && curr)")
with tempfile.TemporaryDirectory(prefix="companion-headless-old-") as directory:
binary = self.build(Path(directory) / "old", source)
self.run_case(binary, "headless", negative=True)
if __name__ == "__main__":
unittest.main()
+144
View File
@@ -0,0 +1,144 @@
#!/usr/bin/env python3
"""Resolve T114 recipe contracts without PlatformIO or firmware builds."""
import shlex
import unittest
from test_upstream_observer_recipes import Recipes
ALIASES = {
"Heltec_t114_without_display_repeater": "Heltec_t114_repeater",
"Heltec_t114_without_display_repeater_bridge_rs232": "Heltec_t114_repeater_bridge_rs232",
"Heltec_t114_without_display_room_server": "Heltec_t114_room_server",
"Heltec_t114_without_display_companion_radio_ble": "Heltec_t114_companion_radio_ble",
"Heltec_t114_without_display_companion_radio_usb": "Heltec_t114_companion_radio_usb",
}
ROLES = {
"Heltec_t114_repeater": "simple_repeater",
"Heltec_t114_repeater_bridge_rs232": "simple_repeater",
"Heltec_t114_repeater_lora_ota_no_external_sensors": "simple_repeater",
"Heltec_t114_room_server": "simple_room_server",
"Heltec_t114_sensor": "simple_sensor",
"Heltec_t114_companion_radio_ble": "companion_radio",
"Heltec_t114_companion_radio_usb": "companion_radio",
}
def defines(flags):
"""Apply ordered compiler -D/-U options, including inherited overrides."""
lexer = shlex.shlex(flags, posix=True)
lexer.whitespace_split = True
lexer.commenters = ";"
words = iter(lexer)
result = {}
for word in words:
if word in ("-D", "-U"):
word += next(words)
if word.startswith("-D"):
name, _, value = word[2:].partition("=")
result[name] = value or "1"
elif word.startswith("-U"):
result.pop(word[2:], None)
return result
class T114AutoDisplayRecipeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.recipes = Recipes()
def flags(self, target):
return defines(self.recipes.value("env:" + target, "build_flags"))
def test_every_ui_role_detects_the_same_optional_display(self):
for target, role in ROLES.items():
section = "env:" + target
with self.subTest(target=target):
flags = self.flags(target)
for macro in ("HELTEC_T114", "HELTEC_T114_WITH_DISPLAY", "ST7789",
"T114_DISPLAY_AUTODETECT"):
self.assertEqual(flags[macro], "1")
self.assertEqual(flags["DISPLAY_CLASS"], "ST7789Display")
for source in ("ST7789Display", "MomentaryButton", "OLEDDisplay", "OLEDDisplayFonts"):
self.assertTrue(self.recipes.includes(section, "helpers/ui/" + source + ".cpp"))
self.assertFalse(self.recipes.includes(section, "helpers/ui/NullDisplayDriver.cpp"))
self.assertIn("Adafruit SSD1306", self.recipes.value(section, "lib_deps"))
for other in set(ROLES.values()):
self.assertEqual(self.recipes.includes(section, "../examples/" + other + "/main.cpp"),
other == role)
def test_legacy_names_are_exact_canonical_aliases(self):
# This also keeps the legacy and canonical USB bases identical for the
# build script's derived Full Companion overlay.
options = ("build_flags", "build_unflags", "build_src_filter", "lib_deps", "board",
"board_build.ldscript", "board_upload.maximum_size", "extra_scripts",
"debug_tool", "upload_protocol")
for legacy, canonical in ALIASES.items():
old, new = "env:" + legacy, "env:" + canonical
with self.subTest(legacy=legacy):
self.assertEqual(dict(self.recipes.config.items(old)), {"extends": new})
for option in options:
self.assertEqual(self.recipes.value(old, option), self.recipes.value(new, option), option)
def test_hardware_identity_pins_and_storage_are_preserved(self):
wiring = {
"P_LORA_DIO_1": "20", "P_LORA_NSS": "24", "P_LORA_RESET": "25",
"P_LORA_BUSY": "17", "P_LORA_SCLK": "19", "P_LORA_MISO": "23",
"P_LORA_MOSI": "22", "SX126X_POWER_EN": "37", "PIN_GPS_RX": "39",
"PIN_GPS_TX": "37", "PIN_GPS_EN": "21", "PIN_GPS_RESET": "38",
}
for target in (*ROLES, *ALIASES, "Heltec_t114_kiss_modem"):
section = "env:" + target
with self.subTest(target=target):
flags = self.flags(target)
self.assertEqual(flags["MOTA_HW_ID"], '"Heltec_t114"')
self.assertEqual(flags["NRF52_POWER_MANAGEMENT"], "1")
self.assertEqual(self.recipes.value(section, "board"), "heltec_t114")
for macro, value in wiring.items():
self.assertEqual(flags[macro], value, macro)
companion = "companion_radio" in target
linker = "boards/nrf52840_s140_v6" + ("_extrafs" if companion else "") + ".ld"
self.assertEqual(self.recipes.value(section, "board_build.ldscript"), linker)
if companion:
self.assertEqual(self.recipes.value(section, "board_upload.maximum_size"), "712704")
self.assertEqual(flags["MAX_CONTACTS"], "350")
self.assertEqual(flags["MAX_GROUP_CHANNELS"], "40")
def test_gps_and_in_place_ota_policy_remain_explicit(self):
for target in ROLES:
with self.subTest(target=target):
self.assertEqual(self.flags(target)["ENV_INCLUDE_GPS"], "1")
for target in ("Heltec_t114_repeater", "Heltec_t114_repeater_bridge_rs232"):
with self.subTest(target=target):
flags = self.flags(target)
self.assertNotIn("ENABLE_OTA", flags)
self.assertEqual(flags["DISABLE_LORA_OTA"], "1")
flags = self.flags("Heltec_t114_repeater_lora_ota_no_external_sensors")
self.assertEqual(flags["ENABLE_OTA"], "1")
self.assertEqual(flags["OTA_FLASH_STORE"], "1")
self.assertNotIn("DISABLE_LORA_OTA", flags)
for sensor in ("AHTX0", "BME280", "BMP280", "SHTC3", "SHT4X", "LPS22HB", "MLX90614",
"VL53L0X", "BME680", "BMP085", "RAK12035", "INA3221", "INA219", "INA226", "INA260"):
self.assertNotIn("ENV_INCLUDE_" + sensor, flags)
def test_transport_roles_and_headless_kiss_stay_distinct(self):
ble = self.flags("Heltec_t114_companion_radio_ble")
usb = self.flags("Heltec_t114_companion_radio_usb")
self.assertEqual(ble["BLE_PIN_CODE"], "123456")
self.assertEqual(ble["OFFLINE_QUEUE_SIZE"], "256")
self.assertNotIn("ENABLE_USB_INTERFACE", ble)
self.assertEqual(usb["ENABLE_USB_INTERFACE"], "1")
self.assertNotIn("BLE_PIN_CODE", usb)
for target in ("Heltec_t114_repeater", "Heltec_t114_repeater_lora_ota_no_external_sensors"):
self.assertEqual(self.flags(target)["RS232_BRIDGE_MERGED"], "1")
self.assertNotIn("RS232_BRIDGE_MERGED", self.flags("Heltec_t114_repeater_bridge_rs232"))
flags = self.flags("Heltec_t114_kiss_modem")
self.assertNotIn("DISPLAY_CLASS", flags)
self.assertNotIn("T114_DISPLAY_AUTODETECT", flags)
self.assertFalse(self.recipes.includes("env:Heltec_t114_kiss_modem", "helpers/ui/ST7789Display.cpp"))
self.assertTrue(self.recipes.includes("env:Heltec_t114_kiss_modem", "../examples/kiss_modem/main.cpp"))
if __name__ == "__main__":
unittest.main()
+332
View File
@@ -0,0 +1,332 @@
"""Exercise the T114 probe and real driver lifecycle without a panel or SPI MISO."""
from pathlib import Path
import os
import subprocess
import sys
import tempfile
import unittest
from test_replay_reset_integration import extract_braced
ROOT = Path(__file__).resolve().parents[1]
UI = ROOT / "src/helpers/ui"
ARDUINO = r'''
#pragma once
#include <cassert>
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
#define LOW 0
#define HIGH 1
#define INPUT 0
#define OUTPUT 1
#define INPUT_PULLUP 2
#define INPUT_PULLDOWN 3
#define PIN_TFT_SCL 40
#define PIN_TFT_SDA 41
#define PIN_TFT_RST 2
#define PIN_TFT_VDD_CTL 3
#define PIN_TFT_LEDA_CTL 15
#define PIN_TFT_CS 11
#define PIN_TFT_DC 12
#define SPI_CLOCK_DIV2 2
#define pgm_read_byte(p) (*(p))
inline int modes[48] = {}, levels[48] = {};
inline uint64_t now_us = 0, reset_high_at = 0, reset_low_at = 0, reset_low_us = 0;
inline unsigned gpio_events = 0, reads = 0, transactions = 0, spi_begins = 0;
inline unsigned init_calls = 0, allocations = 0, draws = 0, resets = 0;
inline unsigned clock_edges = 0, command_bits = 0, data_bits = 0;
inline uint8_t command_value = 0;
inline bool transaction = false, initialized = false, init_ok = true;
inline std::string scenario;
inline std::vector<int> biases;
inline uint32_t read_value = 0;
inline void check_panel_pin(int pin) {
assert((pin == PIN_TFT_CS || pin == PIN_TFT_DC || pin == PIN_TFT_SDA || pin == PIN_TFT_SCL
|| pin == PIN_TFT_RST || pin == PIN_TFT_VDD_CTL || pin == PIN_TFT_LEDA_CTL)
&& "probe must only touch panel pins, not MISO or the radio bus");
}
inline bool automatic() {
#if defined(HELTEC_T114) && defined(T114_DISPLAY_AUTODETECT) && T114_DISPLAY_AUTODETECT
return true;
#else
return false;
#endif
}
inline int backlight_on() {
#ifdef PIN_TFT_LEDA_CTL_ACTIVE
return PIN_TFT_LEDA_CTL_ACTIVE;
#else
return LOW;
#endif
}
inline void pinMode(int pin, int mode) {
check_panel_pin(pin);
++gpio_events; modes[pin] = mode;
if (pin == PIN_TFT_SDA && (mode == INPUT_PULLUP || mode == INPUT_PULLDOWN)) {
assert(transaction && command_bits == 8 && command_value == 0x04);
biases.push_back(mode);
const unsigned within_attempt = (transactions - 1) % 6;
read_value = 0x858552;
if (scenario == "floating") read_value = mode == INPUT_PULLUP ? 0xFFFFFF : 0;
if (scenario == "stuck-high") read_value = 0xFFFFFF;
if (scenario == "stuck-low") read_value = 0;
if (scenario == "biased") read_value = mode == INPUT_PULLUP ? 0x858552 : 0x123456;
if (scenario == "noise") read_value = within_attempt == 2 ? 0x858553 : 0x858552;
if (scenario == "recover" && transactions <= 6) read_value = 0;
// The first read after changing bias can be stale on a real panel.
if (scenario == "prime" && within_attempt % 3 == 0) read_value = 0;
if (scenario == "programmable") read_value = 0x123456;
}
}
inline void digitalWrite(int pin, int value) {
check_panel_pin(pin);
++gpio_events;
if (automatic() && pin == PIN_TFT_LEDA_CTL && value == backlight_on())
assert(initialized && "backlight must stay off until initialization succeeds");
if (pin == PIN_TFT_RST && value == HIGH && levels[pin] == LOW) {
reset_low_us = now_us - reset_low_at;
reset_high_at = now_us; ++resets;
}
if (pin == PIN_TFT_RST && value == LOW && levels[pin] == HIGH) reset_low_at = now_us;
if (pin == PIN_TFT_CS && value == LOW && levels[pin] == HIGH && spi_begins == 0) {
assert(automatic());
assert(now_us - reset_high_at >= 120000 && "probe reset settle");
assert(reset_low_us >= 10000 && "probe reset pulse");
assert(levels[PIN_TFT_VDD_CTL] == LOW);
assert(levels[PIN_TFT_LEDA_CTL] != backlight_on());
transaction = true; ++transactions;
clock_edges = command_bits = data_bits = 0; command_value = 0;
}
if (pin == PIN_TFT_SCL && value == HIGH && transaction) {
++clock_edges;
if (modes[PIN_TFT_SDA] == OUTPUT) {
assert(levels[PIN_TFT_DC] == LOW && command_bits < 8);
command_value = uint8_t((command_value << 1) | levels[PIN_TFT_SDA]);
++command_bits;
}
}
if (pin == PIN_TFT_SCL && value == LOW && transaction && clock_edges == 8)
assert(modes[PIN_TFT_SDA] != OUTPUT && "release SDA before command falling edge");
if (pin == PIN_TFT_CS && value == HIGH && transaction) {
assert(command_bits == 8 && data_bits == 24 && clock_edges == 33);
transaction = false;
}
levels[pin] = value;
}
inline int digitalRead(int pin) {
assert(pin == PIN_TFT_SDA && transaction && levels[PIN_TFT_DC] == HIGH);
assert(modes[pin] == INPUT_PULLUP || modes[pin] == INPUT_PULLDOWN);
assert(clock_edges == 9 + data_bits && data_bits < 24);
assert(levels[PIN_TFT_SCL] == LOW && "sample after dummy/falling edge");
++reads;
return (read_value >> (23 - data_bits++)) & 1;
}
inline void delay(unsigned ms) { now_us += uint64_t(ms) * 1000; }
inline void delayMicroseconds(unsigned us) { now_us += us; }
'''
SPI = r'''
#pragma once
#include <Arduino.h>
struct SPIClass {
void begin() {
++spi_begins;
// The actual SPI1 opener takes SDA/SCK back from bitbang GPIO mode.
modes[PIN_TFT_SDA] = modes[PIN_TFT_SCL] = OUTPUT;
}
void setClockDivider(int) {}
};
inline SPIClass SPI, SPI1;
'''
PANEL = r'''
#pragma once
#include <SPI.h>
enum OLEDDISPLAY_COLOR { BLACK=0, WHITE=1 };
constexpr int GEOMETRY_RAWMODE=0, ST77XX_WHITE=0xffff, ST77XX_BLACK=0;
inline uint8_t ArialMT_Plain_16[1], ArialMT_Plain_24[1];
class ST7789Spi {
uint8_t _rst, _dc, _cs;
int _clk=40, _miso=-1, _mosi=41;
uint16_t displayHeight=135;
uint8_t _buffheight=0;
SPIClass* _spi;
public:
template<class... T> ST7789Spi(SPIClass* spi, uint8_t rst, uint8_t dc, uint8_t cs, T...)
: _rst(rst), _dc(dc), _cs(cs), _spi(spi) {}
@CONNECT@
bool init() {
++init_calls;
assert(connect());
if (automatic()) {
assert(transactions >= 6);
assert(now_us - reset_high_at >= 120000 && "initialization reset settle");
assert(reset_low_us >= 10000);
assert(levels[PIN_TFT_LEDA_CTL] != backlight_on());
}
++allocations;
initialized = init_ok;
return init_ok;
}
void landscapeScreen() { assert(initialized); }
void flipScreenVertically() { assert(initialized); }
void displayOn() { assert(initialized); }
void clear() { assert(initialized); ++draws; }
void display() { assert(initialized); ++draws; }
void setFont(const uint8_t*) { assert(initialized); ++draws; }
void setColor(OLEDDISPLAY_COLOR) { assert(initialized); ++draws; }
void setRGB(uint16_t) { assert(initialized); ++draws; }
void drawString(int,int,const char*) { assert(initialized); ++draws; }
void drawStringMaxWidth(int,int,int,const char*) { assert(initialized); ++draws; }
void fillRect(int,int,int,int) { assert(initialized); ++draws; }
void drawRect(int,int,int,int) { assert(initialized); ++draws; }
uint16_t getStringWidth(const char* s) { assert(initialized); ++draws; return strlen(s)*8; }
};
'''
MAIN = r'''
#include "ST7789Display.h"
void frame(ST7789Display& d) {
const uint8_t bits[] = {0x80};
d.clear(); d.startFrame(); d.setTextSize(1); d.setColor(1); d.setCursor(0,0);
d.print("a"); d.printWordWrap("a",10); d.fillRect(0,0,1,1); d.drawRect(0,0,1,1);
d.drawXbm(0,0,bits,1,1); d.endFrame(); (void)d.getTextWidth("a");
}
int main(int argc, char** argv) {
assert(argc == 2); scenario = argv[1];
ST7789Display d;
if (!automatic()) {
assert(d.begin() && d.isOn()); frame(d);
assert(reads == 0 && transactions == 0);
assert(now_us < 120000 && "legacy/other-board reset timing unchanged");
return 0;
}
d.turnOn(); frame(d);
assert(gpio_events == 0 && init_calls == 0 && allocations == 0 && draws == 0);
const bool invalid = scenario == "floating" || scenario == "stuck-high" || scenario == "stuck-low"
|| scenario == "noise" || scenario == "biased";
if (scenario == "init-fail") init_ok = false;
const bool begun = d.begin();
if (invalid || !init_ok) {
assert(!begun && !d.isOn() && "invalid panel must remain headless");
if (invalid) assert(init_calls == 0 && allocations == 0 && spi_begins == 0);
assert(levels[PIN_TFT_VDD_CTL] == HIGH && levels[PIN_TFT_RST] == LOW);
assert(levels[PIN_TFT_LEDA_CTL] != backlight_on());
for (int pin : {PIN_TFT_CS,PIN_TFT_DC,PIN_TFT_SDA,PIN_TFT_SCL}) assert(modes[pin] == INPUT);
const auto events=gpio_events, init=init_calls, allocated=allocations;
d.turnOn(); d.turnOff(); frame(d); assert(!d.begin());
assert(gpio_events == events && init_calls == init && allocations == allocated && draws == 0);
assert(transactions == (invalid ? 12u : 6u));
assert(now_us < 400000);
return 0;
}
assert(begun && d.isOn() && initialized);
assert(init_calls == 1 && allocations == 1);
assert(levels[PIN_TFT_LEDA_CTL] == backlight_on());
assert(transactions == (scenario == "recover" ? 12u : 6u));
assert(biases.size() == transactions && reads == 24*transactions);
for (unsigned i=0; i<transactions; ++i)
assert(biases[i] == ((i%6)<3 ? INPUT_PULLUP : INPUT_PULLDOWN));
frame(d); assert(draws > 0);
const auto count=transactions, drawn=draws;
d.turnOff(); assert(!d.isOn());
assert(levels[PIN_TFT_VDD_CTL] == HIGH && levels[PIN_TFT_LEDA_CTL] != backlight_on());
frame(d); assert(draws == drawn);
d.turnOn(); assert(d.isOn() && init_calls == 2 && transactions == count);
assert(levels[PIN_TFT_LEDA_CTL] == backlight_on());
frame(d); assert(draws > drawn);
if (scenario == "wake-fail") {
d.turnOff(); init_ok = false; d.turnOn();
assert(!d.isOn() && levels[PIN_TFT_VDD_CTL] == HIGH);
const auto events = gpio_events; frame(d); d.turnOn(); assert(!d.begin());
assert(events == gpio_events);
}
}
'''
class T114DisplayDetectionTest(unittest.TestCase):
def build(self, work, flags=(), *, old_bias=False, old_settle=False, old_turnaround=False):
work.mkdir()
for filename in ("ST7789Display.cpp", "ST7789Display.h", "T114DisplayProbe.h"):
source = (UI / filename).read_text()
if old_bias and filename == "T114DisplayProbe.h":
mutated = source.replace("ids[0] == ids[1]", "true")
self.assertNotEqual(mutated, source)
source = mutated
if old_turnaround and filename == "T114DisplayProbe.h":
mutated = source.replace("if (mask == 1) pinMode(PIN_TFT_SDA, bias);", "")
self.assertNotEqual(mutated, source)
source = mutated.replace(" digitalWrite(PIN_TFT_DC, HIGH);",
" pinMode(PIN_TFT_SDA, bias);\n digitalWrite(PIN_TFT_DC, HIGH);", 1)
(work / filename).write_text(source)
connect = extract_braced((UI / "ST7789Spi.h").read_text(), "bool connect()")
if old_settle:
mutated = connect.replace("delay(120);", "delay(0);")
self.assertNotEqual(mutated, connect)
connect = mutated
for filename, source in {
"Arduino.h": ARDUINO, "SPI.h": SPI, "Wire.h": "#pragma once\nclass TwoWire {};\n",
"Adafruit_GFX.h": "#pragma once\n", "ST7789Spi.h": PANEL.replace("@CONNECT@", connect),
"main.cpp": MAIN}.items():
(work / filename).write_text(source)
sanitizer = (["-fsanitize=address,undefined", "-fno-sanitize-recover=all", "-fno-pie", "-no-pie"]
if sys.platform.startswith("linux") else [])
binary = work / "test"
compiled = subprocess.run([
os.environ.get("CXX", "g++"), "-std=c++17", "-Wall", "-Wextra", "-Werror",
"-Wno-unused-parameter", *sanitizer,
"-DST7789=1", *flags, "-I"+str(work), "-I"+str(UI), "-I"+str(ROOT / "src"),
str(work / "main.cpp"), str(work / "ST7789Display.cpp"), "-o", str(binary)
], capture_output=True, text=True, timeout=60)
self.assertEqual(compiled.returncode, 0, compiled.stdout + compiled.stderr)
return binary
def run_case(self, binary, scenario, *, negative=None):
ran = subprocess.run([str(binary), scenario], capture_output=True, text=True, timeout=10)
if negative:
self.assertNotEqual(ran.returncode, 0)
self.assertIn(negative, ran.stderr)
else:
self.assertEqual(ran.returncode, 0, ran.stdout + ran.stderr)
def test_real_probe_rejects_floating_stuck_and_unstable_lines_without_allocating(self):
with tempfile.TemporaryDirectory(prefix="t114-display-") as directory:
binary = self.build(Path(directory)/"auto", ["-DHELTEC_T114", "-DT114_DISPLAY_AUTODETECT=1"])
self.assertIn(b"meshcore.capability.display.autodetect.t114.v1", binary.read_bytes())
for scenario in ("floating", "stuck-high", "stuck-low", "noise", "biased", "init-fail"):
with self.subTest(scenario=scenario): self.run_case(binary, scenario)
def test_real_probe_accepts_programmable_ids_recovery_and_preserves_wake(self):
with tempfile.TemporaryDirectory(prefix="t114-display-") as directory:
for active in (None, 1):
flags = ["-DHELTEC_T114", "-DT114_DISPLAY_AUTODETECT=1"]
if active is not None: flags.append(f"-DPIN_TFT_LEDA_CTL_ACTIVE={active}")
binary = self.build(Path(directory)/str(active), flags)
for scenario in ("valid", "prime", "programmable", "recover", "wake-fail"):
with self.subTest(active=active, scenario=scenario): self.run_case(binary, scenario)
def test_legacy_t114_and_other_boards_do_not_probe_or_change_reset_timing(self):
with tempfile.TemporaryDirectory(prefix="t114-display-") as directory:
for index, flags in enumerate((["-DHELTEC_T114"], ["-DHELTEC_T114", "-DT114_DISPLAY_AUTODETECT=0"],
["-DT114_DISPLAY_AUTODETECT=1"])):
binary = self.build(Path(directory)/str(index), flags)
self.run_case(binary, "valid")
self.assertNotIn(b"meshcore.capability.display.autodetect.t114.v1", binary.read_bytes())
def test_bias_and_reset_settle_negative_controls_are_detected(self):
with tempfile.TemporaryDirectory(prefix="t114-display-") as directory:
flags = ["-DHELTEC_T114", "-DT114_DISPLAY_AUTODETECT=1"]
binary = self.build(Path(directory)/"bias", flags, old_bias=True)
self.run_case(binary, "biased", negative="invalid panel must remain headless")
binary = self.build(Path(directory)/"settle", flags, old_settle=True)
self.run_case(binary, "valid", negative="initialization reset settle")
binary = self.build(Path(directory)/"turnaround", flags, old_turnaround=True)
self.run_case(binary, "valid", negative="release SDA before command falling edge")
if __name__ == "__main__":
unittest.main()
+144
View File
@@ -0,0 +1,144 @@
"use strict";
const assert = require("assert");
const picker = require("../docs/_javascript/firmware_picker.js");
const source = "a".repeat(40);
const family = "v1.18.0.1.preview1-aaaaaaaa";
const tag = "heltec-t114-v1.18.0.1.preview1";
const mainFamily = "v1.18.0.1-dev-bbbbbbbb";
const roles = ["repeater", "room_server", "sensor", "companion_radio_full"];
const canonical = role => "Heltec_t114_" + role;
const legacy = role => "Heltec_t114_without_display_" + role;
function asset(target, version = family, releaseTag = tag) {
const name = target + "-" + version + ".uf2";
return {name, size: 500000,
browser_download_url: "https://github.com/mikecarper/MeshCore/releases/download/" + releaseTag + "/" + name};
}
function release(releaseTag, assets, date) {
return {name: releaseTag, tag_name: releaseTag, draft: false, prerelease: true,
published_at: date, html_url: "https://github.com/mikecarper/MeshCore/releases/tag/" + releaseTag, assets};
}
function controls(extra = {}) {
return {platform: "NRF52_PLATFORM", display: true, displayAuto: true,
displayController: "st7789", displaySource: source, ...extra};
}
const oldTargets = roles.flatMap(role => [canonical(role), legacy(role)]);
const main = release(mainFamily, oldTargets.concat("Other_repeater").map(target =>
asset(target, mainFamily, mainFamily)), "2026-10-18T00:00:00Z");
const ordinary = picker.buildCatalog([main]);
assert.strictEqual(ordinary.profiles.length, oldTargets.length + 1);
assert(!ordinary.profiles.some(picker.t114AutoDisplayProfile));
assert(!ordinary.profiles.flatMap(picker.boardNotes).some(note => note.includes("detects")));
const singleton = picker.buildCatalog([{...main, assets: [asset(legacy("room_server"), mainFamily, mainFamily)]}]);
assert.strictEqual(singleton.profiles[0].hardware, "Heltec_t114_without_display", "an unmatched historical fallback stays accurate");
const previewTargets = roles.map(canonical).concat(canonical("kiss_modem"));
const preview = release(tag, previewTargets.concat("Other_repeater").map(target => asset(target)), "2026-10-19T00:00:00Z");
const supplemental = {releaseTag: tag, familyTag: family, source, profiles: Object.fromEntries(
previewTargets.map(target => [target, target.endsWith("kiss_modem") ?
{platform: "NRF52_PLATFORM", display: false} : controls()]))};
const metadata = {familyTag: mainFamily, profiles: {}, supplementalReleases: [supplemental]};
const releases = [main, preview];
const before = JSON.stringify(releases);
const catalog = picker.buildCatalog(releases, metadata);
assert.strictEqual(catalog.releaseSet.familyTag, mainFamily, "the latest main family is unchanged");
assert.deepStrictEqual(catalog.profiles.map(p => p.target).sort(), previewTargets.concat("Other_repeater").sort());
assert.strictEqual(catalog.profiles.find(p => p.target === "Other_repeater").files[0].releaseTag, mainFamily);
assert(catalog.rows.some(row => row.target === legacy("repeater")), "legacy exact downloads remain available");
assert(!catalog.rows.some(row => row.target === "Other_repeater" && row.releaseTag === tag), "a board preview cannot import another board's assets");
assert.strictEqual(JSON.stringify(releases), before, "published releases/assets are immutable");
for (const role of roles) {
const profile = catalog.profiles.find(p => p.target === canonical(role));
assert(picker.t114AutoDisplayProfile(profile));
assert(profile.files.every(file => file.releaseTag === tag && file.name.includes(family)));
assert(picker.boardNotes(profile).some(note => note.includes("without a screen")));
assert(picker.boardNotes(profile).some(note => note.includes("local USB") && note.includes("LoRa OTA")));
}
assert(!picker.t114AutoDisplayProfile(catalog.profiles.find(p => p.role === "kiss")));
const repeaters = catalog.profiles.filter(p => p.hardware === "Heltec_t114" && p.role === "repeater");
assert.strictEqual(picker.hardwareChoiceLabel("hardware", "Heltec_t114", repeaters), "Heltec T114 (automatic screen detection)");
assert(!picker.hardwareChoiceLabel("hardware", "Heltec_t114", ordinary.profiles).includes("automatic"));
const standalone = picker.buildCatalog([preview], supplemental);
assert.strictEqual(standalone.releaseSet.familyTag, family);
assert.strictEqual(standalone.profiles.length, previewTargets.length);
const newerSource = "c".repeat(40);
const newerFamily = "v1.19.0-dev-cccccccc";
const newer = release(newerFamily, previewTargets.map(target => asset(target, newerFamily, newerFamily)), "2026-11-01T00:00:00Z");
const newerMetadata = {...metadata, source: newerSource, familyTag: newerFamily, profiles: Object.fromEntries(
previewTargets.map(target => [target, target.endsWith("kiss_modem") ?
{platform: "NRF52_PLATFORM", display: false} : controls({displaySource: newerSource})]))};
const superseding = picker.buildCatalog([main, preview, newer], newerMetadata);
assert.strictEqual(superseding.profiles.length, previewTargets.length);
assert(superseding.profiles.every(profile => profile.files.every(file => file.releaseTag === newerFamily)),
"a later qualified main release must replace the earlier T114 preview, including KISS");
for (const changes of [undefined, {...metadata, supplementalReleases: []},
{...metadata, supplementalReleases: [{...supplemental, source: "b".repeat(40)}]},
{...metadata, supplementalReleases: [{...supplemental, familyTag: "v9.9.9-preview1-aaaaaaaa"}]},
{...metadata, supplementalReleases: [{...supplemental, releaseTag: "ikoka-v1.18.0.1.preview1"}]}]) {
const fallback = picker.buildCatalog(releases, changes);
assert.deepStrictEqual(fallback.profiles.map(p => p.target), ordinary.profiles.map(p => p.target), "wrong or absent supplemental proof must retain the main release");
}
for (const wrong of [{displayAuto: false}, {displayController: "ssd1306"}, {display: false},
{platform: "ESP32_PLATFORM"}, {displaySource: "b".repeat(40)}, {displaySource: "a".repeat(8)}]) {
const changed = {...supplemental, profiles: {...supplemental.profiles, [canonical("room_server")]: controls(wrong)}};
const partial = picker.buildCatalog(releases, {...metadata, supplementalReleases: [changed]});
assert.strictEqual(partial.profiles.filter(p => p.role === "room").length, 2, "a rejected new room cannot hide either historical choice");
assert(partial.profiles.some(p => p.target === legacy("room_server")));
assert.strictEqual(partial.profiles.filter(p => p.role === "repeater" && p.hardware === "Heltec_t114").length, 1);
}
const bookmark = "https://mikecarper.github.io/MeshCore/firmware_picker/?hardwareFamily=Heltec_t114&hardware=Heltec_t114_without_display&role=repeater";
assert.strictEqual(picker.selectionFromUrl(bookmark, ordinary.profiles).filters.hardware, "Heltec_t114_without_display");
const selected = picker.selectionFromUrl(bookmark, catalog.profiles);
assert.strictEqual(selected.filters.hardware, "Heltec_t114");
assert.strictEqual(selected.filters.role, "repeater");
assert.deepStrictEqual(selected.unavailable, []);
const wrongRoom = {...supplemental, profiles: {...supplemental.profiles, [canonical("room_server")]: controls({displayAuto: false})}};
const mixed = picker.buildCatalog(releases, {...metadata, supplementalReleases: [wrongRoom]});
assert.strictEqual(picker.selectionFromUrl(bookmark.replace("role=repeater", "role=room"), mixed.profiles).filters.hardware,
"Heltec_t114_without_display", "bookmark normalization is scoped to an available successor for that role");
for (const policy of ["full", "reduced"]) {
const target = canonical("repeater") + "-" + policy;
const oldTarget = legacy("repeater") + "-" + policy;
const profiles = [{target: oldTarget}, {target, controls: controls(), files: [asset(target)]}];
assert.deepStrictEqual(picker.omitT114DisplayDuplicates(profiles), [profiles[1]]);
assert.deepStrictEqual(picker.omitT114DisplayDuplicates([profiles[0]]), [profiles[0]]);
assert.strictEqual(picker.omitT114DisplayDuplicates([{...profiles[0], target: oldTarget + "-ota"}, profiles[1]]).length, 1,
"a migrated role must not retain an old headless recommendation, even when its old OTA policy is unavailable");
}
for (const role of ["repeater", "room_server"]) for (const policy of ["full", "reduced"]) {
const suffix = "_lora_ota_no_external_sensors-" + policy;
const old = {target: legacy(role) + suffix};
const current = {target: canonical(role) + suffix, controls: controls(), files: [asset(canonical(role) + suffix)]};
assert.deepStrictEqual(picker.omitT114DisplayDuplicates([old, current]), [current]);
const otherPolicy = {...current, target: canonical(role) + suffix.replace(policy, policy === "full" ? "reduced" : "full")};
assert.strictEqual(picker.omitT114DisplayDuplicates([old, otherPolicy]).length, 1);
}
const bridge = {target: legacy("repeater_bridge_rs232")};
const merged = {target: canonical("repeater"), controls: controls({rs232: true, rs232Merged: true, rs232Source: source}), files: [asset(canonical("repeater"))]};
assert.deepStrictEqual(picker.omitT114DisplayDuplicates([bridge, merged]), [merged]);
assert.strictEqual(picker.omitT114DisplayDuplicates([bridge, {...merged, controls: controls({rs232: true})}]).length, 1);
const historicalTargets = ["repeater", "room_server"].flatMap(role =>
["full", "reduced"].flatMap(policy => [canonical(role), legacy(role)].map(target =>
target + "_lora_ota_no_external_sensors-" + policy)));
const historicalMain = {...main, assets: main.assets.concat(historicalTargets.map(target => asset(target, mainFamily, mainFamily)))};
const historicalMetadata = {...metadata, profiles: Object.fromEntries(historicalTargets.map(target => [target,
{platform: "NRF52_PLATFORM", display: !target.includes("without_display"), otaRole: "lora-receiver"}]))};
const migrated = picker.buildCatalog([historicalMain, preview], historicalMetadata);
assert(!migrated.profiles.some(profile => historicalTargets.includes(profile.target)),
"a migrated role must recommend no old canonical screen-assumed or headless policy");
assert(historicalTargets.every(target => migrated.rows.some(file => file.target === target)),
"all exact old full/reduced OTA files remain raw compatibility downloads");
const otaBookmark = bookmark + "&ota=lora-receiver";
const stale = picker.selectionFromUrl(otaBookmark, migrated.profiles);
assert.strictEqual(stale.filters.hardware, "Heltec_t114");
assert.strictEqual(stale.filters.role, "repeater");
assert(stale.unavailable.some(value => value.includes("ota")), "an unavailable old OTA policy must be reported rather than silently remapped");
const newLeanTarget = canonical("repeater_lora_ota_no_external_sensors") + "-reduced";
const bothPreview = {...preview, assets: preview.assets.concat(asset(newLeanTarget))};
const bothMetadata = {...metadata, supplementalReleases: [{...supplemental,
profiles: {...supplemental.profiles, [newLeanTarget]: controls({otaRole: "lora-receiver"})}}]};
const both = picker.buildCatalog([historicalMain, bothPreview], bothMetadata);
assert.deepStrictEqual(both.profiles.filter(profile => profile.hardware === "Heltec_t114" && profile.role === "repeater")
.map(profile => profile.target).sort(), [canonical("repeater"), newLeanTarget].sort(),
"real standard and lean-OTA automatic images in the new role family can coexist");
console.log("T114 canonical display detection, scoped preview proof, legacy fallback and bookmark tests passed");
+233
View File
@@ -0,0 +1,233 @@
"""No-build T114 release selection, packaged evidence and picker metadata checks."""
from copy import deepcopy
import json
import os
from pathlib import Path
import shlex
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "scripts"))
import generate_picker_controls as controls
import package_firmware_picker as offline
import t114_profiles as t114
SOURCE = "a" * 40
FAMILY = "v1.18.0.1.preview1-aaaaaaaa"
TAG = "heltec-t114-v1.18.0.1.preview1"
CANONICAL = "Heltec_t114_repeater"
LEGACY = "Heltec_t114_without_display_repeater"
ROLES = ("repeater", "repeater_bridge_rs232", "room_server",
"companion_radio_ble", "companion_radio_usb", "companion_radio_full")
OTA_ROLES = tuple(role + "_lora_ota_no_external_sensors" for role in
("repeater", "repeater_bridge_rs232", "room_server"))
DEFINES = dict(HELTEC_T114="1", T114_DISPLAY_AUTODETECT="1", DISPLAY_CLASS="ST7789Display")
def manifest(target=CANONICAL, proof=True):
return dict(target=target, platform="NRF52_PLATFORM", verified=True,
build_profile="full", source_commit=SOURCE,
capabilities=[t114.CAPABILITY] if proof else [],
verification=[dict(capability=t114.CAPABILITY, source="packaged application",
evidence=t114.MARKER, present=True)] if proof else [])
class T114ReleaseProfileTests(unittest.TestCase):
def test_only_exact_legacy_role_names_map_to_the_canonical_target(self):
for role in ROLES + OTA_ROLES + tuple(role + suffix for role in OTA_ROLES for suffix in ("-full", "-reduced", "-full-ota", "-reduced-ota")):
self.assertEqual(t114.canonical_target("Heltec_t114_without_display_" + role),
"Heltec_t114_" + role)
for target in (CANONICAL, None, "Heltec_t114_without_display_other",
LEGACY + "_unknown", "heltec_t096_without_display_repeater"):
self.assertIsNone(t114.canonical_target(target))
def test_metadata_needs_resolved_display_flags_packaged_proof_and_source(self):
self.assertEqual(t114.runtime_metadata(manifest(), DEFINES), dict(
displayAuto=True, displayController="st7789", displaySource=SOURCE))
self.assertEqual(t114.runtime_metadata(manifest(proof=False), DEFINES), {},
"today's recipes must not relabel an old published manifest")
for changed in (dict(HELTEC_T114="0"), dict(T114_DISPLAY_AUTODETECT="0"),
dict(DISPLAY_CLASS="NullDisplayDriver")):
with self.subTest(defines=changed), self.assertRaises(ValueError):
t114.runtime_metadata(manifest(), {**DEFINES, **changed})
for changed in (dict(platform="ESP32_PLATFORM"), dict(verified=False), dict(verification=[]),
dict(target="other_repeater"), dict(source_commit="a" * 8),
dict(verification=[dict(capability=t114.CAPABILITY, present=True,
source="linked image", evidence=t114.MARKER)]),
dict(verification=[dict(capability=t114.CAPABILITY, present=True,
source="packaged application", evidence="unrelated display text")])):
with self.subTest(manifest=changed), self.assertRaises(ValueError):
t114.runtime_metadata({**manifest(), **changed}, DEFINES)
def test_real_generator_emits_per_image_controls_and_honors_later_flag_overrides(self):
with tempfile.TemporaryDirectory(prefix="t114-controls-") as folder:
stage = Path(folder)
(stage / "companion").mkdir()
(stage / "release-plan.json").write_text(json.dumps(dict(source=SOURCE, groups=[
dict(key="companion", tag=FAMILY)])))
row = manifest("Heltec_t114_companion_radio_full")
row.update(platformio_env="sample", files=[row["target"] + "-" + FAMILY + ".uf2"])
path = stage / "companion/TARGET-MANIFEST.json"
path.write_text(json.dumps([row]))
flags = ["-D" + key + "=" + value for key, value in DEFINES.items()]
config = [["env:sample", [["build_flags", flags]]]]
generated = controls.generate(stage, config)
self.assertEqual(generated["familyTag"], FAMILY)
profile = generated["profiles"][row["target"]]
self.assertTrue(profile["display"] and profile["displayAuto"])
self.assertEqual(profile["displaySource"], SOURCE)
for tail in (["-UT114_DISPLAY_AUTODETECT"], ["-DT114_DISPLAY_AUTODETECT=0"],
["-UDISPLAY_CLASS", "-DDISPLAY_CLASS=NullDisplayDriver"]):
with self.subTest(tail=tail), self.assertRaises(ValueError):
controls.generate(stage, [["env:sample", [["build_flags", flags + tail]]]])
row["capabilities"] = []; row["verification"] = []
path.write_text(json.dumps([row]))
self.assertNotIn("displayAuto", controls.generate(stage, config)["profiles"][row["target"]])
@unittest.skipIf(os.name == "nt", "local release driver uses POSIX locking")
def test_resumed_release_drops_aliases_only_with_exact_qualified_profile(self):
from build_local_release import select_ordinary_full_records
for role in ROLES + OTA_ROLES:
canonical = dict(manifest=manifest("Heltec_t114_" + role), files=[])
legacy = dict(manifest=manifest("Heltec_t114_without_display_" + role, False), files=[])
before = deepcopy([legacy, canonical])
for inputs in ([legacy, canonical], [canonical, legacy]):
self.assertEqual(select_ordinary_full_records(inputs), [canonical])
self.assertEqual([legacy, canonical], before)
for changed in (dict(build_profile="standard"), dict(verification=[]),
dict(target="Heltec_t114_sensor"), dict(platform="ESP32_PLATFORM")):
with self.subTest(role=role, changed=changed), self.assertRaisesRegex(ValueError, "automatic-display successor"):
t114.omit_legacy_display_records([legacy, dict(manifest={**canonical["manifest"], **changed}, files=[])])
with self.assertRaisesRegex(ValueError, "automatic-display successor"):
select_ordinary_full_records([legacy])
for role in OTA_ROLES:
for suffix in ("-full", "-reduced"):
legacy = dict(manifest=manifest("Heltec_t114_without_display_" + role + suffix, False), files=[])
canonical = dict(manifest=manifest("Heltec_t114_" + role + suffix), files=[])
self.assertEqual(t114.omit_legacy_display_records([legacy, canonical]), [canonical])
canonical["manifest"]["target"] += "-ota"
with self.assertRaises(ValueError):
t114.omit_legacy_display_records([legacy, canonical])
for policy in ("full", "reduced"):
canonical = dict(manifest=manifest(), files=[])
canonical["manifest"]["capabilities"].append("sensor.profile." + policy)
legacy = dict(manifest=manifest(LEGACY, False), files=[])
legacy["manifest"]["capabilities"].append("sensor.profile." + policy)
self.assertEqual(t114.omit_legacy_display_records([legacy, canonical]), [canonical])
legacy["manifest"]["capabilities"] = ["sensor.profile." + ("reduced" if policy == "full" else "full")]
with self.assertRaises(ValueError):
t114.omit_legacy_display_records([legacy, canonical])
def test_capability_checker_requires_the_marker_in_the_uploadable_application(self):
with tempfile.TemporaryDirectory(prefix="t114-proof-") as folder:
work = Path(folder)
elf, app, output = work / "firmware.elf", work / "firmware.bin", work / "capabilities.json"
elf.write_bytes(t114.MARKER.encode())
command = [sys.executable, "-B", str(ROOT / "scripts/check_firmware_capabilities.py"),
"--image", str(elf), "--firmware-bin", str(app), "--output", str(output),
"--target", CANONICAL, "--platform", "NRF52_PLATFORM", "--build-profile", "full",
"--expect-application", t114.CAPABILITY + "=" + t114.MARKER]
app.write_bytes(b"display-capable old firmware without automatic detection")
result = subprocess.run(command, capture_output=True, text=True, timeout=20)
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
self.assertFalse(json.loads(output.read_text())["verified"])
app.write_bytes(b"prefix\0" + t114.MARKER.encode() + b"\0suffix")
result = subprocess.run(command, capture_output=True, text=True, timeout=20)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertTrue(t114.qualified_auto_display(json.loads(output.read_text())))
def test_combined_full_companion_and_uart_replace_only_proven_legacy_functions(self):
for role, successor, required in (
("companion_radio_usb", "companion_radio_full", ("companion.usb", "companion.bluetooth")),
("companion_radio_ble", "companion_radio_full", ("companion.usb", "companion.bluetooth")),
("repeater_bridge_rs232", "repeater", ("bridge.rs232", "bridge.rs232.merged"))):
legacy = dict(manifest=manifest("Heltec_t114_without_display_" + role, False), files=[])
primary = dict(manifest=manifest("Heltec_t114_" + successor), files=[])
primary["manifest"]["capabilities"].extend(required)
for capability in required:
primary["manifest"]["verification"].append(dict(capability=capability, present=True,
source="packaged application" if capability.endswith(".merged") else "linked image",
evidence=capability))
self.assertEqual(t114.omit_legacy_display_records([legacy, primary]), [primary])
primary["manifest"]["verification"].pop()
with self.assertRaises(ValueError):
t114.omit_legacy_display_records([legacy, primary])
@unittest.skipIf(os.name == "nt", "Bash release contracts run on Linux/WSL")
def test_bulk_prefers_resolved_auto_recipe_but_direct_alias_builds_stay_available(self):
config = []
for role in ROLES + OTA_ROLES + ("kiss_modem",):
for prefix in ("Heltec_t114_", "Heltec_t114_without_display_"):
flags = ["-D" + key + "=" + value for key, value in DEFINES.items()]
if role == "kiss_modem": flags = ["-DHELTEC_T114=1"]
config.append(["env:" + prefix + role, [["build_flags", flags]]])
program = r'''
set -euo pipefail
source build.sh
pio() { echo 'PlatformIO must not run in this test' >&2; return 99; }
SUPPORTED_PIO_ENVS=()
for role in repeater repeater_bridge_rs232 room_server companion_radio_ble companion_radio_usb companion_radio_full repeater_lora_ota_no_external_sensors repeater_bridge_rs232_lora_ota_no_external_sensors room_server_lora_ota_no_external_sensors kiss_modem; do
for prefix in Heltec_t114_ Heltec_t114_without_display_; do
target=$prefix$role
SUPPORTED_PIO_ENVS+=("$target")
PIO_ENV_PLATFORM_BY_NAME[$target]=NRF52_PLATFORM
PIO_ENV_BOARD_BY_NAME[$target]=heltec_t114
done
done
ALL_PIO_ENVS=("${SUPPORTED_PIO_ENVS[@]}")
PIO_CONFIG_JSON=@CONFIG@
for role in repeater repeater_bridge_rs232 room_server; do
for prefix in Heltec_t114_ Heltec_t114_without_display_; do
# Model generated environments that are absent from pio project config.
PIO_ENV_BUILD_BASE_BY_NAME[${prefix}${role}_lora_ota_no_external_sensors]=${prefix}${role}
done
done
for role in repeater repeater_bridge_rs232 room_server companion_radio_ble companion_radio_usb companion_radio_full repeater_lora_ota_no_external_sensors repeater_bridge_rs232_lora_ota_no_external_sensors room_server_lora_ota_no_external_sensors; do
legacy=Heltec_t114_without_display_$role
canonical=Heltec_t114_$role
[ "$(get_t114_display_replacement "$legacy")" = "$canonical" ]
is_redundant_bulk_build_target "$legacy"
is_known_pio_env "$legacy"
case "$role" in
*_lora_ota_no_external_sensors) [ "$(get_pio_build_env "$legacy")" = "${legacy%_lora_ota_no_external_sensors}" ] ;;
*) [ "$(get_pio_build_env "$legacy")" = "$legacy" ] ;;
esac
! get_t114_display_replacement "$canonical"
done
! is_t114_display_autodetect_build Heltec_t114_kiss_modem
! get_t114_display_replacement Heltec_t114_without_display_kiss_modem
BUILD_PROFILE_FOR_TARGET=full
BUILD_APPLICATION_EXPECTATIONS=() BUILD_EXPECTATIONS=() BUILD_CAPABILITIES=() BUILD_REDUCTIONS=()
declare_build_capability_contract Heltec_t114_repeater NRF52_PLATFORM
[[ " ${BUILD_APPLICATION_EXPECTATIONS[*]} " == *" display.autodetect=meshcore.capability.display.autodetect.t114.v1 "* ]]
PIO_CONFIG_JSON=@OVERRIDDEN@
! get_t114_display_replacement Heltec_t114_without_display_repeater
PIO_CONFIG_JSON=@CONFIG@
PIO_ENV_BOARD_BY_NAME[Heltec_t114_repeater]=other-board
! get_t114_display_replacement Heltec_t114_without_display_repeater
PIO_ENV_BOARD_BY_NAME[Heltec_t114_repeater]=heltec_t114
unset 'PIO_ENV_PLATFORM_BY_NAME[Heltec_t114_repeater]'
! get_t114_display_replacement Heltec_t114_without_display_repeater
'''
overridden = deepcopy(config)
next(row for row in overridden if row[0] == "env:" + CANONICAL)[1][0][1].append("-UT114_DISPLAY_AUTODETECT")
program = program.replace("@CONFIG@", shlex.quote(json.dumps(config)))
program = program.replace("@OVERRIDDEN@", shlex.quote(json.dumps(overridden)))
result = subprocess.run(["bash", "-c", program], cwd=ROOT, capture_output=True, text=True, timeout=30)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
def test_standalone_picker_accepts_exact_scoped_tag_without_renaming_its_asset_family(self):
entry = dict(familyTag=FAMILY, releaseTag=TAG, source=SOURCE, profiles={})
release = dict(tag_name=TAG, name=TAG, assets=[])
html = offline.package([release], entry)
self.assertIn('"releaseTag": "' + TAG + '"', html)
self.assertIn('"familyTag": "' + FAMILY + '"', html)
with self.assertRaisesRegex(ValueError, "match the supplied release family"):
offline.package([{**release, "tag_name": "other-preview"}], entry)
if __name__ == "__main__":
unittest.main()