# SPDX-License-Identifier: MIT # CUSTOM (TeTeHacko): real version and build timestamp for the `ver` command. # # WIRE THIS INTO EVERY ENV WE FLASH. Without it the node reports the fallback # literal from examples/*/MyMesh.h -- "v1.16.0", "6 Jun 2026" -- which is the # same in every build ever made, so `ver` cannot tell one flash from another. # That is not a cosmetic problem: after a 14-minute BLE DFU onto the T1000-E, # every field the node reported back was byte-for-byte what it said beforehand, # and the only evidence the image had landed was a line in a scrollback buffer. # # extra_scripts = ${nrf52_base.extra_scripts} # pre:tools/build_version.py # # Injects FIRMWARE_VERSION (-tth-, '+' = dirty tree) and # FIRMWARE_BUILD_DATE (compile time). NOTE: the define changes every build = # full rebuild each time (~10-30 s) -- the price for an always-fresh timestamp. # # SCons script, not a module: `Import` and `env` are SCons builtins and # Import("env") has to come first, hence the file-wide ruff exemption. # ruff: noqa: F821, E402 # mypy: disable-error-code="name-defined" if __name__ == "__main__": # run by hand (--help): the header above, nothing else with open(__file__) as _f: for _ln in _f: if not _ln.startswith("#"): break if "SPDX-License-Identifier" not in _ln: print(_ln[2:].rstrip() if _ln.startswith("# ") else "") raise SystemExit(0) Import("env") import os import re import subprocess from datetime import datetime def git(cwd, *args): return subprocess.check_output(("git",) + args, cwd=cwd, stderr=subprocess.DEVNULL).decode().strip() cwd = env.subst("$PROJECT_DIR") # The base version follows the newest upstream release tag that HEAD descends # from, rather than being written here as a literal -- a literal would keep # claiming v1.16.0 long after upstream moved on, which is exactly the kind of # stale-by-construction string this script exists to get rid of. # Upstream tags them per-example ("companion-v1.16.0", "repeater-v1.16.0"), so # match anything carrying a v and strip the prefix. Our own release tags # (`...+tth.`) are excluded so they cannot shadow the upstream base. # So are backup/* tags: `backup/feat-ble-diag-pre-v117-merge` matched *v[0-9]* # and, being the newest tag, won -- so the T1000-E flashed on 10. 8. 2026 reports # a base of "v117-merge". A pre-flight safety tag must never end up in the # version string of the thing it was protecting. base = "nover" try: tag = git(cwd, "describe", "--tags", "--abbrev=0", "--match", "*v[0-9]*", "--exclude", "*+tth*", "--exclude", "backup/*") # Cut at the 'v' that STARTS THE VERSION, not at the first 'v' in the tag: # "room-server-v1.17.0" has one in "server", and find("v") turned the base # into "ver-v1.17.0". Every earlier upstream tag we saw (companion-, repeater-) # happened to have no 'v' in its prefix, so this hid until v1.17.0. m = re.search(r"v[0-9]", tag) base = tag[m.start():] if m else tag except Exception: pass sha, dirty = "nogit", "" try: sha = git(cwd, "rev-parse", "--short=7", "HEAD") if subprocess.call(["git", "diff", "--quiet"], cwd=cwd) != 0: dirty = "+" except Exception: pass # Both strings have to survive the companion protocol's fixed-width fields # (RESP_CODE_DEVICE_INFO in companion_radio/MyMesh.cpp): 20 B for the version # and 12 B for the build date, NUL included, so 19 and 11 usable characters. # Anything longer is silently truncated on the wire -- which first showed up as # a node reporting "v1.16.0-tth-956238c" for SHA 956238c3, and a build date of # "04 Aug 2026 " with the time cut clean off. The repeater's text console has no # such limit, but one format everywhere beats two. VER_LIMIT, DATE_LIMIT = 19, 11 # Budget: base and the dirty marker are never sacrificed -- a lost '+' would # turn an uncommitted build into something that looks reproducible. The SHA # gives up characters instead; git needs 7 for uniqueness in a repo this size, # so this only bites if upstream's version string grows unusually long. marker = "-tth" room = VER_LIMIT - len(base) - len(marker) - len(dirty) version = "%s%s%s%s" % (base, marker, sha[:max(4, room)], dirty) if len(version) > VER_LIMIT: print("build_version.py: WARNING: %r is %d chars, will truncate to %d on " "the companion protocol" % (version, len(version), VER_LIMIT)) # yymmdd hhmm = exactly 11. Not pretty, but complete and sortable; the readable # "%d %b %Y %H:%M" is 17 and lost its time to the 12-byte field. now = datetime.now() build_date = now.strftime("%y%m%d %H%M")[:DATE_LIMIT] # The same instant as an epoch, which VolatileRTCClock uses as its base_time # instead of the hardcoded 15 May 2024 (src/helpers/ArduinoHelpers.h). This is # the ONLY way a node gets a sane clock with no GPS, no I2C RTC, nothing # carrying a correct time on air, and no host attached -- i.e. a bench board. # It is not cosmetic: the RTC stamps every advert the node transmits, and a # receiver drops a stale timestamp as a replay, so a 2024 clock turns into # dropped replies. Measured 7. 8. 2026: bench-board had run 811 days behind since # deployment and every board on the bench was 812 days behind, all because # `time ` was a manual step nobody performed. # # NOT StringifyMacro: this has to reach the compiler as the integer 1786095587, # not as the string "1786095587". SCons renders a (name, value) tuple as # -Dname=value verbatim. # # Costs no extra rebuilds -- FIRMWARE_BUILD_DATE already changes every build, so # the tree is already fully recompiled each time. build_epoch = int(now.timestamp()) # src/helpers/FwUpdate refuses a package built for another target: the env, # plus the image variant when one env is released as several # (FW_OTA_VARIANT=observer-ota -> "SenseCap_Solar_repeater-observer-ota"), or a # full package would silently swap a node's variant. ota_variant = os.environ.get("FW_OTA_VARIANT", "").strip() ota_target = env["PIOENV"] + ("-" + ota_variant if ota_variant else "") if len(ota_target) > 47: # Manifest.target[48] in FwUpdate.cpp, NUL-terminated raise SystemExit("build_version.py: OTA target %r longer than 47 chars" % ota_target) env.Append(CPPDEFINES=[ ("FIRMWARE_VERSION", env.StringifyMacro(version)), ("FIRMWARE_BUILD_DATE", env.StringifyMacro(build_date)), ("FIRMWARE_BUILD_EPOCH", str(build_epoch)), ("FW_OTA_TARGET", env.StringifyMacro(ota_target)), ]) print("build_version.py: %s (Build: %s, epoch %d)" % (version, build_date, build_epoch))