Files
heltec-repeater/firmware/main/web/dashboard.js
T

1016 lines
76 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* Local dashboard: explicit device settings writes; CSV names stay in this tab. */
import { hex, senderIdentity } from './identity.js';
import { registryInfo } from './manufacturers.js';
const CAPACITY = 256;
const CSV_BYTES = 256 * 1024;
const CSV_ROWS = 4096;
const CSV_LABEL_LENGTH = 200;
const $ = id => document.getElementById(id);
const state = {
boot: null, cursor: 0, oldest: 0, evicted: 0, rows: [], status: null,
nowUs: 0, receivedAt: 0, lastSuccess: null, connected: false, inFlight: false,
timer: null, error: '', notice: '', paused: false, frozenRows: [], frozenBoot: null,
lastPollStart: -Infinity,
frozenAt: 0, newWhilePaused: 0, labels: new Map(), importGeneration: 0,
};
const expanded = new Set();
// Keep detail spans aligned with the radio column hidden by the phone CSS.
const compactTable = window.matchMedia('(max-width: 560px)');
const outcomes = {
ok: ['good', 'Weitergesendet', 'Das Funkmodul meldet: Senden beendet (TX_DONE). Ob die Nachricht am Ziel angekommen ist, ist nicht bekannt.'],
ok_polled: ['good', 'Weitergesendet', 'Das Ende des Sendens (TX_DONE) wurde durch Abfragen des Funkmoduls erkannt, nicht über dessen Unterbrechungssignal. Ob die Nachricht am Ziel angekommen ist, ist nicht bekannt.'],
crc_failed: ['danger', 'Nicht lesbar · Prüfsumme', 'Die Fehlerprüfung (CRC) ist fehlgeschlagen. Der Absender ist nicht verlässlich lesbar; ein eigener Zählername wird deshalb nicht zugeordnet.'],
bad_length: ['danger', 'Nicht lesbar · Länge', 'Die empfangene Funknachricht hat eine ungültige Länge und wurde nicht weitergesendet.'],
undecodable: ['danger', 'Nicht lesbar · Kodierung', 'Die empfangene Funknachricht konnte nicht in lesbare Daten umgewandelt werden und wurde nicht weitergesendet.'],
t1_too_long: ['danger', 'Nicht lesbar · T1-Länge', 'Die T1-Funknachricht ist länger als vom Empfänger unterstützt und wurde nicht weitergesendet.'],
rx_read_failed: ['danger', 'Nicht lesbar · Funkzugriff', 'Die empfangenen Daten konnten nicht aus dem Funkmodul gelesen werden. Es liegt keine verlässliche Absenderkennung vor.'],
repeat_disabled: ['warning', 'Ausgelassen · ausgeschaltet', 'Die Nachricht wurde lesbar empfangen, aber das Weiterleiten war ausgeschaltet.'],
whitelist: ['warning', 'Ausgelassen · Absenderregel', 'Die Nachricht wurde lesbar empfangen. Der Absender ist laut eingestellter Freigabeliste nicht zum Weiterleiten zugelassen.'],
duplicate: ['warning', 'Ausgelassen · Wiederholung', 'Die Nachricht wurde lesbar empfangen, aber als bereits bekannte Wiederholung nicht noch einmal weitergeleitet.'],
duty_cycle: ['warning', 'Ausgelassen · Sendezeit', 'Die Nachricht wurde absichtlich nicht weitergeleitet, um das eingestellte Sendezeitbudget einzuhalten.'],
hop_policy: ['warning', 'Ausgelassen · Weiterleitungsregel', 'Die Nachricht wurde lesbar empfangen, aber wegen der Regeln zu bereits weitergeleiteten Nachrichten nicht erneut gesendet.'],
encode_failed: ['danger', 'Sendefehler · Vorbereitung', 'Die Daten konnten nicht zum Senden vorbereitet werden. Es wurde kein abgeschlossenes Senden aufgezeichnet.'],
start_failed: ['danger', 'Sendefehler · Start', 'Der Sendestart im Funkmodul ist fehlgeschlagen.'],
radio_timeout: ['danger', 'Sendefehler · Zeitlimit', 'Das Funkmodul meldete eine Zeitüberschreitung beim Senden. Ein abgeschlossenes Senden wurde nicht bestätigt.'],
irq_timeout: ['danger', 'Sendefehler · Bestätigung fehlt', 'Die Software erhielt innerhalb der Frist keine Bestätigung für das Sendeende (TX_DONE). Das beweist nicht, dass gar kein Funksignal ausgesendet wurde.'],
};
const helpTopics = {
flow: ['Was macht das Gerät?', 'Es empfängt wM-Bus-Funknachrichten, wie sie Verbrauchszähler senden. Lesbare Nachrichten werden je nach eingestellten Regeln weitergeleitet. Unter „Einstellungen“ kannst du diese Regeln ausdrücklich ändern; die normale Anzeige verändert sie nicht.\n„Weitergesendet“ heißt: Das Funkmodul hat das Senden beendet. Eine Empfangsbestätigung vom Ziel gibt es hier nicht. Keine angezeigten Signale bedeutet nicht, dass keine Zähler vorhanden sind: Manche senden selten oder liegen außerhalb der Reichweite.'],
readable: ['Lesbar oder nicht lesbar?', 'Die Prüfsumme (CRC) hilft, beschädigte Funknachrichten zu erkennen. Nur erfolgreich geprüfte empfangene Nachrichten bekommen eine Absenderzuordnung und gegebenenfalls deinen eigenen Zählernamen.\n„Lesbar“ bezieht sich auf die Funknachricht, nicht auf den Verbrauchswert. Verschlüsselte Nutzdaten bleiben verschlüsselt. Bei einem Fehler wird nicht aus beschädigten Daten auf einen Zähler geschlossen.'],
signal: ['Wie stark ist das Signal?', 'dBm ist eine Einheit für die empfangene Funkleistung (RSSI). Weniger negativ ist stärker: −60 dBm ist stärker als −90 dBm. Es gibt hier keinen allgemeingültigen Grenzwert für guten Empfang; Störungen und Antenne spielen ebenfalls mit.\nDer Wert gehört zum empfangenen Signal. Er sagt nicht, wie gut das weitergesendete Signal beim Ziel ankommt.'],
formats: ['Was bedeuten C1 und T1?', 'C1 und T1 sind unterschiedliche wM-Bus-Übertragungsarten, die Zähler zum Senden verwenden. A und B bezeichnen den Aufbau der Funknachricht. Das sind keine Qualitätsstufen und keine Zählermodelle.\nDie Tabelle zeigt die Art und das Format des aufgezeichneten Signals. Ein Byte sind 8 Bit; die Länge ist keine Verbrauchsmenge. Unbekannt heißt: nicht sicher erkannt.'],
outcomes: ['Ausgelassen ist kein Sendefehler', '„Ausgelassen“ heißt: Die Nachricht wurde wegen einer Regel bewusst nicht weitergeleitet, etwa bei einer Wiederholung oder verbrauchtem Sendezeitbudget.\n„Nicht lesbar“ bedeutet einen Fehler beim Empfang oder Lesen. „Sendefehler“ bedeutet, dass das Senden nicht erfolgreich bestätigt wurde. „Nur Fehler“ zeigt diese beiden Gruppen, aber keine ausgelassenen Nachrichten.'],
policy: ['Warum nicht jedes Signal weiterleiten?', 'Eine Freigabeliste kann die erlaubten Absender begrenzen. Die Wiederholungserkennung verhindert mehrfaches Senden derselben Nachricht. Die Weiterleitungsregel (Hop-Regel) begrenzt erneutes Weiterleiten bereits weitergeleiteter Nachrichten. Zusätzlich begrenzt das Sendezeitbudget die Funkbelegung.\nDie eingestellte Wartezeit liegt vor dem Sendeversuch. Ein ausgelassenes Signal ist eine bewusste Entscheidung, kein Sendefehler.'],
duty: ['Sendezeit ist begrenzt', 'Funkbänder können gesetzliche Sendezeitgrenzen haben. Das Gerät berechnet die Sendedauer aus der Nachrichtenlänge und zählt abgeschlossene Sendungen in einem gleitenden Zeitfenster. Reicht das eingestellte Budget nicht, werden Nachrichten ausgelassen.\nSekunden (s) sind angerechnete Sendedauer, Prozent ist der verbrauchte Anteil des Budgets. Das ist keine Messung der tatsächlichen Funkbelegung. „Begrenzung aus“ ist nur eine Geräteeinstellung, keine Erlaubnis zu unbegrenztem Senden. Die passende Einstellung hängt von den geltenden Regeln ab.'],
identity: ['Absender ist nicht dein eigener Name', 'Die Kennung stammt aus dem unverschlüsselten Absenderkopf der Funknachricht, nicht aus einem entschlüsselten Zählerstand. Hersteller, Versionsbyte und Gerätetyp helfen bei der Zuordnung; ein genaues Modell wird nicht geraten.\nVerschiedene Absender können dieselbe achtstellige Kennung haben. Vergleiche bei einer Warnung die vollständigen Rohwerte unter „Einzelheiten“. Ein eigener Name ist nur deine Notiz, kein Nachweis der Herkunft.'],
labels: ['Eigene Namen sind optional', 'Du kannst Kennungen mit Namen wie „Wasserzähler Küche“ versehen. Das ändert weder das Gerät noch seine Messdaten. Namen gelten nur für geprüfte empfangene Kennungen, nicht für unlesbare Nachrichten oder vom Gerät erzeugte Testsignale.\nTeilen sich mehrere Absender eine Kennung, bekommen sie denselben Namen. Prüfe dann Hersteller, Version und Typ. Alle Namen bleiben nur im Speicher dieses Browser-Tabs und verschwinden beim Neuladen oder Schließen.'],
csv: ['Zählernamen aus einer CSV-Datei', 'Starte mit „Vorlage herunterladen“. Die erste Zeile muss exakt oms_id,label heißen; die Spalten werden durch Kommas getrennt. Jede Kennung braucht 8 Zeichen (0–9 oder A–F), auch die Nullen am Anfang: 00123456 bleibt 00123456.\nÖffne die Spalte oms_id in Tabellenprogrammen als Text, damit die Nullen erhalten bleiben. Kommas und Zeilenumbrüche im Namen brauchen CSV-Anführungszeichen. Erlaubt sind bis zu 256 KiB, 4.096 Zuordnungen und 200 Zeichen je Name.\nEine gültige Datei ersetzt alle bisherigen Namen in diesem Tab; bei einem Fehler bleibt alles unverändert. Es wird nichts hochgeladen oder dauerhaft im Browser gespeichert.'],
history: ['Wie viel Verlauf bleibt erhalten?', 'Das Gerät hält höchstens 256 abgeschlossene Funknachrichten seit seinem Start im Arbeitsspeicher. Die ältesten fallen heraus; die Diagnose-Summen zählen trotzdem weiter. Ein Geräteneustart löscht diesen Geräteverlauf.\nBei einer Verbindungsunterbrechung bleiben bereits geladene Daten hier sichtbar, sind aber möglicherweise veraltet. Beim Wiederverbinden wird der aktuelle Verlauf geladen. Ohne dauerhafte Speicherung ist das kein vollständiges Langzeitprotokoll. Laufende Sendeversuche erscheinen erst mit ihrem Ergebnis.'],
pause: ['Nur die Anzeige anhalten', 'Die Pause friert nur diese Tabelle samt Zeitabständen ein. Der Empfang, das Weiterleiten, die Diagnose und die Abfrage einmal pro Sekunde laufen weiter.\nBeim Fortsetzen erscheint der aktuelle Verlauf, nicht jede zwischenzeitliche Nachricht: Es bleiben höchstens 256 Einträge. Downloads verwenden auch während der Pause den neuesten geladenen Verlauf, nicht die eingefrorene Ansicht.'],
export: ['Was wird heruntergeladen?', '„Verlauf als CSV“ enthält den neuesten geladenen Verlauf mit Rohwerten, nicht nur die gefilterte oder pausierte Ansicht. Die CSV-Spaltennamen und technischen Codes bleiben unverändert; die Zeitstempel sind Mikrosekunden seit Gerätestart.\n„Kennungen und Namen als CSV“ enthält nur zuordenbare empfangene Kennungen aus diesem Verlauf. Importiere oms_id als Text, um führende Nullen zu bewahren. Mögliche Tabellenformeln erhalten zum Schutz ein vorangestelltes Apostroph.'],
diagnostics: ['Wie aktuell ist der Funkstatus?', 'Die Seite fragt das Gerät höchstens einmal pro Sekunde ab. Die Funkkonfiguration wird ungefähr alle 10 Sekunden geprüft; erst nach mehr als 15 Sekunden gilt diese Prüfung als veraltet. Der Aufgabenstatus des Geräts und die Browser-Verbindung gelten nach mehr als 5 Sekunden als veraltet.\nEin kurzer Sendevorgang kann zwischen zwei Abfragen liegen. Der angezeigte Funkzustand ist eine Momentaufnahme, kein lückenloser Nachweis aller Funkaktivität. „Funk-Reparaturversuche“ zählt Versuche, den Empfang nach einer Störung wiederherzustellen, nicht Geräteneustarts. Ob der Empfang wieder läuft, zeigt der aktuelle Funkzustand.'],
activity: ['Was zählt als letzte Aktivität?', '„Lesbar empfangen“ zeigt den Abstand zur letzten erfolgreich geprüften empfangenen Nachricht. „Senden beendet“ umfasst auch Test- und Kennungssignale, die das Gerät selbst erzeugt.\nDas Funkmodul hat das Sendeende bestätigt; ob ein Empfänger am Ziel die Nachricht erhalten hat, ist unbekannt. Die Abstände beziehen sich auf die Laufzeit seit Gerätestart.'],
counters: ['Summen sind keine Zahl der Zähler', 'Ein Zähler kann viele Funknachrichten senden. Diese Summen zählen Vorgänge seit Gerätestart, nicht verschiedene Zähler. Sie laufen weiter, wenn alte Einträge aus dem Verlauf fallen.\n„Lesbar empfangen“ umfasst auch später ausgelassene Nachrichten. „Weitergesendet“ zählt abgeschlossene Weiterleitungen, nicht eigene Testsignale. „Sendefehler“ und „ausgelassen“ sind getrennt. Nach einem Geräteneustart beginnen die Summen neu.'],
source: ['Empfangen oder vom Gerät erzeugt?', '„Empfangen“ ist eine eingegangene Funknachricht. „Geräte-Test“ und „Geräte-Kennungssignal“ werden vom Heltec-Gerät selbst erzeugt; sie belegen nicht den Empfang eines Zählers und erhalten keinen eigenen Zählernamen.\nDie Rohcodes source und reception bleiben unter „Einzelheiten“ erhalten. CRC beschreibt die Fehlerprüfung beim Empfang, nicht eine Empfangsbestätigung vom Ziel.'],
timing: ['Was bedeuten die Zeitangaben?', 'µs sind Mikrosekunden, ms sind Millisekunden: 1.000 µs = 1 ms. Rohzeitstempel zählen ab Gerätestart, nicht ab Mitternacht.\nDer Sendebeginn ist der Start des Softwarevorgangs einschließlich Treibervorbereitung, nicht der gemessene Beginn des Funksignals. Das Sendeergebnis wird beim Beobachten des Erfolgs oder Fehlers erfasst. Die Dauer dazwischen ist daher nicht die reine Sendezeit.\nEin Ergebnis-Zeitstempel bestätigt bei einer Fehlerzeile kein erfolgreiches Senden. Auch „Weitergesendet“ bestätigt nur das Sendeende am Funkmodul, nicht den Empfang am Ziel.'],
settings: ['Gerätewert, Entwurf und Speicherung', '„Vom Gerät angenommen“ zeigt den zuletzt geladenen Gerätewert, nicht deinen Entwurf. Ändern oder Umschalten im Eingabefeld sendet nichts. Erst der klar benannte Übernehmen-Knopf sendet genau dieses eine Feld. Andere Entwürfe bleiben erhalten, auch beim Nachladen. Beim Neuladen oder Schließen des Tabs gehen Entwürfe verloren.\nNur Wartezeit und Sendezeitbudget werden dauerhaft auf dem Heltec gespeichert. Alle anderen Einstellungen liegen im RAM und kehren nach einem Geräteneustart zu den Startwerten zurück. CSV-Namen bleiben getrennt davon nur in diesem Browser.\n„Angenommen“ bedeutet nicht sofort „im Funkablauf übernommen“: Die Funkaufgabe kopiert einen zusammengehörigen Stand an einer sicheren Grenze. Auch eine übernommene Revision ist kein Nachweis erfolgreicher Hardwarekonfiguration oder Funkübertragung. Bei Konflikten zuerst die aktuellen Gerätewerte mit den Entwürfen vergleichen, den Abgleich bestätigen und dann selbst erneut übernehmen. Es gibt keine automatische Wiederholung von Änderungen.'],
settings_repeat_enabled: ['Weiterleiten ein- oder ausschalten', 'Eingeschaltet: Geeignete empfangene Nachrichten dürfen nach den übrigen Regeln weitergesendet werden. Ausgeschaltet: Das Gerät empfängt weiter, leitet diese Nachrichten aber nicht weiter. Eigene Kennungssignale werden separat eingestellt.\nDer Entwurf allein schaltet nichts um. Erst „Weiterleiten übernehmen“ sendet die Änderung. Diese Einstellung gilt nur bis zum Geräteneustart (RAM).'],
settings_repeat_delay_ms: ['Wartezeit vor dem Weiterleiten', '20 bis 1.000 ms; 1.000 ms sind eine Sekunde. Das ist die Pause vor einem Sendeversuch, nicht die Dauer des Funksignals und nicht das erlaubte Sendezeitbudget. Eine längere Wartezeit ersetzt keine Sendezeitbegrenzung.\nDiese Einstellung wird dauerhaft im Heltec gespeichert und bleibt nach einem Geräteneustart erhalten.'],
settings_duty_budget_ppm: ['Sendezeitbudget in ppm', 'ppm bedeutet Anteile pro Million. 1.000 ppm = 0,1 % = 3,6 Sekunden Sendezeit je gleitender Stunde. Das Fenster wandert mit der Zeit, es beginnt nicht zur vollen Uhrzeit neu. 100.000 ppm entsprechen 10 % beziehungsweise 360 Sekunden.\nErlaubt sind ganze Zahlen von 0 bis 100.000. 0 schaltet nur die Budgetprüfung aus; es ist weder ein Sendestopp noch eine Erlaubnis zu unbegrenztem Senden. Das Gerät rechnet Sendezeiten an, es misst nicht die gesamte tatsächliche Funkbelegung. Vor dem Abschalten oder einem Wert über 1.000 erscheint eine Warnung. Prüfe die für dein Funkband und deinen Einsatz geltenden Vorschriften.\nNur dieses Budget und die Wartezeit werden dauerhaft gespeichert.'],
settings_tx_power: ['Sendeleistung: Funkchip und Verstärker', '−9 bis +2 dBm ist die eingestellte Ausgangsleistung des SX1262-Funkchips, nicht die endgültige abgestrahlte Leistung. Der nachgeschaltete FEM-Verstärker erhöht die Leistung; Antenne und Leitungen beeinflussen sie ebenfalls. +2 dBm hier bedeutet daher nicht +2 dBm an der Antenne.\nMehr Leistung kann Störungen und Stromverbrauch erhöhen. Zulässige Strahlungsleistung und Sendezeit sind getrennte Grenzen. Diese Einstellung bleibt nur im RAM.'],
settings_whitelist: ['Freigabeliste für Zählerkennungen', 'Leer bedeutet: Alle Absenderkennungen sind zugelassen, sofern die übrigen Weiterleitungsregeln passen. Sonst werden nur die aufgeführten Kennungen weitergeleitet. Höchstens acht unterschiedliche Kennungen, eine pro Zeile oder durch Kommas getrennt.\nJede Kennung muss vollständig acht Hex-Zeichen haben (0–9 und A–F), einschließlich führender Nullen: 00123456 ist richtig, 123456 nicht. Keine Namen, kein 0x-Präfix und keine verkürzten Kennungen. Groß- und Kleinbuchstaben bedeuten dasselbe; doppelte Kennungen sind ungültig.\nDas sind Kennungen aus dem Funkkopf, nicht deine lokalen CSV-Namen. Mehrere echte Zähler können dieselbe Kennung verwenden; die Liste ist kein Echtheitsnachweis. Sie gilt nur bis zum Geräteneustart (RAM).'],
settings_beacon_period_ms: ['Eigene Kennungssignale: Intervall', '0 schaltet regelmäßige Kennungssignale aus. Sonst sind 250 bis 600.000 ms erlaubt: von einer Viertelsekunde bis zehn Minuten. Das Heltec-Gerät erzeugt dabei selbst Funknachrichten, es hat dafür keinen Zähler empfangen.\nKennungssignale verursachen zusätzlichen Funkverkehr und belegen Sendezeit. Ein kürzeres Intervall bedeutet häufigere Sendeversuche; das tatsächliche Senden hängt auch von den übrigen Grenzen ab. Diese Einstellung bleibt nur im RAM.'],
settings_test_lfield: ['L-Feld selbst erzeugter Testnachrichten', 'Das L-Feld ist ein Längenwert im Kopf einer Funknachricht. Hier sind ganze Zahlen von 19 bis 200 erlaubt. Diese Einstellung betrifft die vom Gerät erzeugten Testnachrichten, nicht die Länge empfangener Zählernachrichten und nicht die Zählerauswahl.\n„Test-L-Feld übernehmen“ ändert nur den Wert und startet keinen einmaligen Testversand. Größere eigene Nachrichten können mehr Sendezeit benötigen. Bei eigenen T1-Testsendungen begrenzt die Firmware den wirksamen Wert auf 140. Diese Einstellung bleibt nur im RAM.'],
settings_verbose: ['Ausführliches serielles Protokoll', 'Schaltet zusätzliche Diagnoseausgaben auf der seriellen Verbindung des Heltec-Geräts ein oder aus. Das ist für Fehlersuche am angeschlossenen Rechner gedacht, nicht ein ausführlicherer Verlauf in dieser Webseite. Es werden dadurch keine Daten in eine Cloud hochgeladen.\nZusätzliche Ausgaben können das Zeitverhalten beeinflussen. Diese Einstellung bleibt nur im RAM.'],
settings_fem_rx_csd: ['Experiment: FEM-CSD beim Empfang', 'Der FEM ist der externe Funkverstärker. CSD ist eine seiner Steuerleitungen; diese Einstellung verändert deren Zustand beim Empfang. Das ist kein allgemeiner Schalter für besseren Empfang.\nEin ungeeigneter Zustand kann den Empfang verschlechtern oder verhindern. Nur mit Kenntnis der Hardware experimentieren und bei Problemen den vorherigen Gerätewert wiederherstellen. Diese Einstellung bleibt nur im RAM.'],
settings_preamble_bits: ['Experiment: Präambelerkennung', 'Eine Präambel ist das Bitmuster vor einer Funknachricht, das dem Empfänger beim Erkennen hilft. 0 schaltet diesen Detektor aus; 8, 16, 24 oder 32 Bit bestimmen die Erkennungslänge. Das ändert nicht die vom Zähler gesendete Präambel.\nMehr Bit sind nicht automatisch besser: Eine unpassende Erkennung kann Nachrichten übersehen und den Empfang verschlechtern. Bei Problemen den vorherigen Gerätewert wiederherstellen. Diese Einstellung bleibt nur im RAM.'],
settings_wifi: ['Nur das WLAN des Heltec ausschalten', 'Dieser Knopf sendet nach einer Bestätigung den Ausschaltauftrag an das Heltec-Gerät. Er verändert nicht die WLAN-Einstellungen deines Telefons oder Rechners. Danach wird die Verbindung zu dieser Seite getrennt; die letzten Daten bleiben sichtbar, sind aber nicht mehr aktuell. Ungesendete Entwürfe werden nicht übertragen.\nDie Funkweiterleitung läuft gemäß ihren Einstellungen weiter. Zum erneuten Einschalten ist eine Bedienung direkt am Gerät nötig; über das ausgeschaltete WLAN geht es nicht. Schlägt die Antwortübertragung fehl, kann das WLAN trotzdem schon ausgeschaltet sein. Dann bleibt das Ergebnis ausdrücklich unbekannt, und der Auftrag wird nicht automatisch wiederholt.'],
};
let activeHelp = null;
let helpSequence = 0;
function resultInfo(row) {
const result = outcomes[row.outcome] || ['neutral', 'Ergebnis unbekannt', 'Dieses Ergebnis ist noch nicht bekannt. Der unveränderte technische Code steht unter „Einzelheiten“.'];
if (row.source !== 'rx' && (row.outcome === 'ok' || row.outcome === 'ok_polled')) return [result[0], 'Gesendet', result[2]];
return result;
}
function sourceName(source) {
return ({ rx: 'Empfangen', test: 'Geräte-Test', beacon: 'Geräte-Kennungssignal' })[source] || 'Quelle unbekannt';
}
function radioValue(value) { return value === 'unknown' ? 'unbekannt' : value; }
function helpButton(topic, id) {
const button = node('button', '?', 'help-button');
button.type = 'button';
button.id = id;
button.dataset.help = topic;
button.setAttribute('aria-label', `Hilfe: ${helpTopics[topic][0]}`);
button.setAttribute('aria-controls', 'help-popover');
button.setAttribute('aria-expanded', String(activeHelp === id));
return button;
}
function closeHelp(restoreFocus = false) {
if (!activeHelp) return;
const trigger = $(activeHelp);
activeHelp = null;
trigger?.setAttribute('aria-expanded', 'false');
$('help-popover').hidden = true;
if (restoreFocus) (trigger || $('filter')).focus({ preventScroll: true });
}
document.addEventListener('click', event => {
const trigger = event.target.closest('button[data-help]');
if (!trigger) return;
if (!trigger.id) trigger.id = `help-trigger-${++helpSequence}`;
if (activeHelp === trigger.id) { closeHelp(); return; }
closeHelp();
activeHelp = trigger.id;
trigger.setAttribute('aria-expanded', 'true');
const [title, text] = helpTopics[trigger.dataset.help];
setText('help-title', title);
setText('help-text', text);
$('help-popover').hidden = false;
$('help-popover').scrollTop = 0;
$('help-close').focus({ preventScroll: true });
});
document.addEventListener('pointerdown', event => {
if (activeHelp && !event.target.closest('#help-popover, button[data-help]')) closeHelp();
});
document.addEventListener('keydown', event => {
if (event.key === 'Escape' && activeHelp) {
event.preventDefault();
closeHelp(true);
}
});
$('help-close').addEventListener('click', () => closeHelp(true));
function node(tag, text, className) {
const element = document.createElement(tag);
if (text !== undefined) element.textContent = String(text);
if (className) element.className = className;
return element;
}
function setText(id, value) {
const element = $(id);
const text = String(value);
if (element.textContent !== text) element.textContent = text;
}
function count(value) { return Number(value || 0).toLocaleString('de-DE'); }
function decimal(value, digits) {
return Number(value).toLocaleString('de-DE', { minimumFractionDigits: digits, maximumFractionDigits: digits });
}
function uptime(us) {
const seconds = Math.max(0, Math.floor(us / 1e6));
const days = Math.floor(seconds / 86400);
const hours = Math.floor(seconds / 3600) % 24;
const minutes = Math.floor(seconds / 60) % 60;
return `${days ? `${count(days)} T ` : ''}${hours} Std ${minutes} Min ${seconds % 60} s`;
}
function age(timestamp, now = deviceNow()) {
if (!timestamp) return 'Noch nicht';
const seconds = Math.max(0, (now - timestamp) / 1e6);
if (seconds < 1) return 'vor <1 s';
if (seconds < 60) return `vor ${Math.floor(seconds)} s`;
if (seconds < 3600) return `vor ${Math.floor(seconds / 60)} Min ${Math.floor(seconds % 60)} s`;
if (seconds < 86400) return `vor ${Math.floor(seconds / 3600)} Std ${Math.floor(seconds / 60) % 60} Min`;
return `vor ${count(Math.floor(seconds / 86400))} T ${Math.floor(seconds / 3600) % 24} Std`;
}
function deviceNow() {
return state.nowUs + (state.receivedAt ? (performance.now() - state.receivedAt) * 1000 : 0);
}
function senderLabel(identity) {
return identity.labelEligible ? state.labels.get(identity.id) || '' : '';
}
function visibleRows() { return state.paused ? state.frozenRows : state.rows; }
function collisions(rows) {
const identities = new Map();
for (const row of rows) {
const sender = senderIdentity(row);
if (!sender.labelEligible) continue;
if (!identities.has(sender.id)) identities.set(sender.id, new Set());
identities.get(sender.id).add(sender.key);
}
return new Set([...identities].filter(([, keys]) => keys.size > 1).map(([id]) => id));
}
function renderHealth() {
const elapsed = state.lastSuccess === null ? null : (performance.now() - state.lastSuccess) / 1000;
const stale = elapsed !== null && elapsed > 5;
const connection = $('connection');
connection.textContent = settingsState.wifiDisabled ? 'Heltec-WLAN wird ausgeschaltet' : !state.connected ? (state.lastSuccess === null && !state.error ? 'Verbindung wird aufgebaut' : 'Nicht verbunden') : stale ? 'Daten veraltet' : 'Verbunden';
connection.className = `badge ${!state.connected || stale || settingsState.wifiDisabled ? 'warning' : 'good'}`;
setText('connection-age', elapsed === null ? 'Warte auf das Gerät' : `Letzte Abfrage vor ${count(Math.floor(elapsed))} s`);
const notice = $('connection-notice');
notice.className = `notice ${!state.connected || stale || settingsState.wifiDisabled ? 'warning' : ''}`;
notice.hidden = state.connected && !stale && !state.notice && !settingsState.wifiDisabled;
if (settingsState.wifiDisabled) {
notice.textContent = 'Ausschalten des Heltec-WLANs bestätigt. Die Verbindung wird getrennt; automatische Abfragen sind gestoppt. Letzte Daten bleiben sichtbar, sind aber nicht mehr aktuell. Zum Wiedereinschalten direkt am Gerät bedienen.';
} else if (!state.connected) {
notice.textContent = `${state.error || 'Verbindung wird aufgebaut.'} Neuer Versuch automatisch. Bereits geladene Daten bleiben sichtbar, können aber veraltet sein.`;
} else if (stale) {
notice.textContent = 'Seit mehr als 5 Sekunden keine aktuelle Antwort. Der angezeigte Funkzustand kann veraltet sein.';
} else {
notice.textContent = state.notice;
}
if (!state.status) return;
const s = state.status;
const now = deviceNow();
const heartbeatAge = s.heartbeat_us ? Math.max(0, now - s.heartbeat_us) / 1e6 : Infinity;
const sampleAge = s.sampled_at_us ? Math.max(0, now - s.sampled_at_us) / 1e6 : Infinity;
const mode = ({ 2: 'Bereit (RC)', 3: 'Bereit (XOSC)', 4: 'Frequenz wird eingestellt', 5: 'Empfang läuft', 6: 'Sendet gerade' })[s.chip_mode] || 'Zustand unbekannt';
setText('uptime', `Laufzeit ${uptime(now)}`);
// The radio configuration probe runs every 10 seconds; task snapshots
// arrive at least once per second outside bounded radio operations.
const radioStale = heartbeatAge > 15 || sampleAge > 5;
const current = state.connected && !stale && !radioStale && !settingsState.wifiDisabled;
setText('operation-state', !current ? 'Gerätestatus nicht aktuell' : !s.config_intact ? 'Funkkonfiguration prüfen' : `${mode} · Weiterleiten ${s.repeat_enabled ? 'an' : 'aus'}`);
setText('operation-detail', !current ? 'Die letzten Daten bleiben sichtbar. Funkaktivität derzeit nicht sicher beurteilbar.' : `${count(s.rx_valid)} lesbar empfangen · ${count(s.repeats_completed)} weitergesendet`);
setText('radio-state', !s.config_intact ? 'Konfiguration abweichend' : radioStale ? 'Funkstatus veraltet' : mode);
$('radio-state').className = `metric ${!s.config_intact ? 'danger-text' : radioStale ? 'warning-text' : ''}`;
setText('radio-detail', `Zustand ${hex(s.chip_mode)} · Konfiguration ${s.config_intact ? 'intakt' : 'abweichend'} · erfasst ${age(s.sampled_at_us, now)}`);
setText('heartbeat', `Funkprüfung ${age(s.heartbeat_us, now)} · alle 10 s`);
setText('repeat-state', s.repeat_enabled ? 'Eingeschaltet' : 'Ausgeschaltet');
setText('repeat-detail', `Eingestellte Wartezeit ${count(s.repeat_delay_ms)} ms`);
setText('recovery-detail', `${count(s.recoveries)} Funk-Reparaturversuche seit Gerätestart`);
const percent = s.duty_budget_us > 0 ? 100 * s.duty_used_us / s.duty_budget_us : 0;
setText('duty-state', s.duty_budget_us > 0 ? `${decimal(percent, 1)} % verbraucht` : 'Begrenzung aus');
$('duty-state').className = `metric ${percent >= 90 ? 'warning-text' : ''}`;
$('duty-meter').value = Math.min(100, Math.max(0, percent));
$('duty-meter').hidden = s.duty_budget_us === 0;
setText('duty-detail', `${decimal(s.duty_used_us / 1e6, 3)} s verbraucht${s.duty_budget_us > 0 ? ` / ${decimal(s.duty_budget_us / 1e6, 3)} s im gleitenden Zeitfenster` : ' · kein Budget eingestellt'}`);
setText('last-rx', age(s.last_rx_us, now));
setText('last-tx', age(s.last_tx_us, now));
for (const [id, key] of [['count-rx', 'rx_valid'], ['count-rejected', 'rx_rejected'], ['count-repeats', 'repeats_completed'], ['count-skipped', 'skipped'], ['count-failed', 'tx_failed'], ['count-recoveries', 'recoveries']]) setText(id, count(s[key]));
if (!state.paused) {
for (const cell of document.querySelectorAll('[data-event-time]')) cell.textContent = age(Number(cell.dataset.eventTime), now);
}
}
function addDetail(list, title, value, topic, eventId) {
const group = node('div');
const term = node('dt', title, topic ? 'heading-with-help' : '');
if (topic) term.append(helpButton(topic, `event-help-${eventId}-${list.childElementCount}`));
group.append(term, node('dd', value));
list.append(group);
}
function eventRows(row, ambiguous) {
const identity = senderIdentity(row);
const label = senderLabel(identity);
const result = resultInfo(row);
const summary = node('tr');
const time = node('td');
const ageNode = node('span', age(row.timestamp_us, state.paused ? state.frozenAt : deviceNow()));
ageNode.dataset.eventTime = row.timestamp_us;
time.append(ageNode, node('span', `#${row.id}`, 'sub mono'));
const sender = node('td');
if (label) sender.append(node('span', label, 'sender-label'));
sender.append(node('span', identity.trusted ? identity.id || 'Kennung fehlt' : row.source === 'rx' ? 'Absender nicht lesbar' : sourceName(row.source), 'sender-id mono'));
if (identity.trusted) {
sender.append(node('span', `${identity.manufacturer.code || identity.manufacturer.raw} · ${identity.manufacturer.name}`, 'sub'));
sender.append(node('span', `${identity.medium.name}${identity.medium.scoped ? ' · TCH-spezifisch' : ''}`, 'sub'));
} else sender.append(node('span', 'Keine verlässliche Zählerzuordnung', 'sub'));
if (identity.trusted && identity.warnings.length) sender.append(node('span', 'Zuordnung prüfen · Einzelheiten', 'sub row-flag'));
if (ambiguous) sender.append(node('span', 'Kennung mehrfach vergeben', 'sub row-flag'));
const radio = node('td', `${radioValue(row.mode)} / ${radioValue(row.format)}`, 'radio-col');
radio.append(node('span', sourceName(row.source), 'sub'));
radio.append(node('span', `${row.source === 'rx' ? `${count(row.rssi_dbm)} dBm · ` : ''}${count(row.length)} Byte`, 'sub'));
sender.append(node('span', `${sourceName(row.source)} · ${radioValue(row.mode)} / ${radioValue(row.format)}${row.source === 'rx' ? ` · ${count(row.rssi_dbm)} dBm` : ''}`, 'sub mobile-radio'));
const outcome = node('td');
outcome.append(node('span', result[1], `badge ${result[0]}`));
const toggle = node('button', expanded.has(row.id) ? 'Weniger' : 'Einzelheiten', 'detail-toggle');
toggle.type = 'button';
toggle.dataset.detailId = row.id;
toggle.setAttribute('aria-label', `Einzelheiten zur Funknachricht ${row.id}`);
toggle.setAttribute('aria-expanded', String(expanded.has(row.id)));
toggle.setAttribute('aria-controls', `details-${row.id}`);
outcome.append(toggle);
summary.append(time, sender, radio, outcome);
const detail = node('tr', undefined, 'detail-row');
detail.hidden = !expanded.has(row.id);
detail.id = `details-${row.id}`;
const cell = node('td');
cell.colSpan = compactTable.matches ? 3 : 4;
const list = node('dl', undefined, 'detail-grid');
addDetail(list, 'Gerätestart-Kennung / Nachricht', `${state.paused ? state.frozenBoot : state.boot} / #${row.id}`, 'history', row.id);
addDetail(list, 'Ereigniszeit seit Gerätestart', `${row.timestamp_us} µs`, 'timing', row.id);
addDetail(list, 'Quelle / Empfang (Rohcodes)', `${row.source} / ${row.reception}`, 'source', row.id);
addDetail(list, 'Fehlerprüfung (CRC)', row.source === 'rx' ? row.crc_ok ? 'Bestanden' : 'Nicht bestanden' : 'Keine Empfangsprüfung', 'readable', row.id);
addDetail(list, 'Absenderkennung (unveränderter Text)', identity.rawId || 'Nicht verfügbar', 'identity', row.id);
addDetail(list, 'Eigener Zählername', label || 'Keiner', 'labels', row.id);
addDetail(list, 'Herstellerfeld (Rohwert)', identity.manufacturer.raw);
addDetail(list, 'Herstellerzuordnung', identity.trusted ? `${identity.manufacturer.code || 'Ungültige FLAG-Kennung'} · ${identity.manufacturer.name}` : 'Keine Zuordnung ohne erfolgreich geprüften Empfang');
addDetail(list, 'Versionsbyte (keine Modellnummer)', hex(row.version));
addDetail(list, 'Gerätetyp / Messmedium', identity.trusted ? `${identity.medium.raw} · ${identity.medium.name}${identity.medium.scoped ? ' (TCH-spezifische Ausnahme)' : ''}` : `${hex(row.device_type)} · keine Zuordnung`);
addDetail(list, 'Absender vollständig: Kennung / Hersteller / Version / Typ', `${identity.rawId || '—'} / ${hex(row.manufacturer, 4)} / ${hex(row.version)} / ${hex(row.device_type)}`);
addDetail(list, 'Übertragungsart / Format / Länge', `${row.mode} / ${row.format} / ${count(row.length)} Byte`, 'formats', row.id);
addDetail(list, 'Empfangene Signalstärke (RSSI)', row.source === 'rx' ? `${count(row.rssi_dbm)} dBm` : 'Nicht verfügbar: vom Gerät selbst gesendet', 'signal', row.id);
addDetail(list, 'Nachrichten-Prüfwert (Hash, keine Absenderkennung)', row.hash);
addDetail(list, 'Sendevorgang gestartet seit Gerätestart', row.tx_start_us ? `${row.tx_start_us} µs (einschließlich Treibervorbereitung)` : 'Kein Sendestart aufgezeichnet', 'timing', row.id);
addDetail(list, 'Sendeergebnis beobachtet seit Gerätestart', row.tx_done_us ? `${row.tx_done_us} µs` : 'Kein Ergebnis-Zeitstempel');
addDetail(list, 'Empfang / Ereignis bis Start des Sendevorgangs', row.tx_start_us ? `${decimal((row.tx_start_us - row.timestamp_us) / 1000, 3)} ms` : 'Nicht zutreffend');
addDetail(list, 'Dauer des Sendevorgangs bis zum Ergebnis', row.tx_start_us && row.tx_done_us ? `${decimal((row.tx_done_us - row.tx_start_us) / 1000, 3)} ms` : 'Nicht verfügbar');
addDetail(list, 'Abschließendes Ergebnis (Rohcode)', row.outcome, result[0] === 'warning' ? 'policy' : 'outcomes', row.id);
cell.append(list, node('p', result[2], 'small detail-explanation'));
for (const warning of identity.warnings) cell.append(node('p', warning, 'notice warning'));
if (ambiguous) cell.append(node('p', 'Diese Kennung kommt im Verlauf mit verschiedenen Hersteller-, Versions- oder Typwerten vor. Ihr eigener Name gilt für alle diese Absender. Vergleiche die vollständige Absenderkennung, bevor du ein Signal einem Zähler zuordnest.', 'notice warning'));
detail.append(cell);
toggle.addEventListener('click', () => {
if (expanded.has(row.id)) expanded.delete(row.id); else expanded.add(row.id);
detail.hidden = !expanded.has(row.id);
toggle.setAttribute('aria-expanded', String(!detail.hidden));
toggle.textContent = detail.hidden ? 'Einzelheiten' : 'Weniger';
});
return [summary, detail];
}
function renderEvents() {
const rows = visibleRows();
const ambiguity = collisions(rows);
const query = $('filter').value.trim().toLocaleLowerCase('de-DE');
const failures = $('failures').checked;
const filtered = rows.filter(row => {
if (failures && resultInfo(row)[0] !== 'danger') return false;
if (!query) return true;
const identity = senderIdentity(row);
// Corrupt raw header bytes are not searchable as a trusted sender.
return identity.trusted && `${identity.id} ${senderLabel(identity)} ${identity.manufacturer.code} ${identity.manufacturer.name} ${identity.manufacturer.raw}`.toLocaleLowerCase('de-DE').includes(query);
});
const focused = document.activeElement?.dataset.detailId;
const focusedHelp = document.activeElement?.dataset.help ? document.activeElement.id : null;
const fragment = document.createDocumentFragment();
for (const row of filtered) fragment.append(...eventRows(row, ambiguity.has(senderIdentity(row).id)));
$('event-rows').replaceChildren(fragment);
if (focused) document.querySelector(`[data-detail-id="${Number(focused)}"]`)?.focus({ preventScroll: true });
if (focusedHelp) $(focusedHelp)?.focus({ preventScroll: true });
setText('row-count', `${count(filtered.length)} angezeigt / ${count(rows.length)} im Verlauf${state.paused ? ' · pausiert' : ''}`);
setText('display-boot', (state.paused ? state.frozenBoot : state.boot) ? `Gerätestart ${state.paused ? state.frozenBoot : state.boot}` : '');
$('empty-state').hidden = filtered.length > 0;
setText('empty-state', rows.length ? 'Keine Funknachricht passt zu diesem Filter.' : state.boot ? 'Noch keine abgeschlossene Funknachricht im Verlauf. Zähler können selten senden oder außerhalb der Reichweite liegen.' : 'Warte auf den ersten Verlauf …');
const warning = $('ambiguity-notice');
warning.hidden = ambiguity.size === 0;
warning.textContent = `Mehrfach vergebene Kennungen: ${[...ambiguity].slice(0, 8).join(', ')}${ambiguity.size > 8 ? ` und ${count(ambiguity.size - 8)} weitere` : ''}. Hersteller, Version oder Typ unterscheiden sich. Eigene Namen sind deshalb nicht eindeutig. Bitte die Einzelheiten prüfen.`;
}
function renderRetention() {
const range = state.rows.length ? ` Nummern ${state.oldest}–${state.cursor}.` : '';
setText('retention', `${count(state.rows.length)} / ${count(CAPACITY)} Einträge im Geräteverlauf.${range} ${count(state.evicted)} ältere Einträge seit Gerätestart entfernt.`);
$('download-events').disabled = state.rows.length === 0;
$('export-labels').disabled = !state.rows.some(row => senderIdentity(row).labelEligible);
$('pause-notice').hidden = !state.paused;
if (state.paused) setText('pause-notice', `Nur die Anzeige ist pausiert. ${count(state.newWhilePaused)} neue Funknachrichten im Hintergrund geladen. Gerätestatus und Abfragen laufen weiter. Fortsetzen zeigt den aktuellen Verlauf (höchstens 256 Einträge). Eingefrorener Gerätestart: ${state.frozenBoot || 'noch nicht verbunden'}.`);
}
function checkSnapshot(data) {
if (!data || typeof data.boot_id !== 'string' || !data.boot_id || !Number.isSafeInteger(data.cursor) || data.cursor < 0 || !Number.isSafeInteger(data.oldest_id) || data.oldest_id < 0 || !Number.isSafeInteger(data.evicted) || data.evicted < 0 || typeof data.reset !== 'boolean' || !Number.isFinite(data.now_us) || data.now_us < 0 || data.capacity !== CAPACITY || !data.status || !Array.isArray(data.rows) || data.rows.length > CAPACITY) throw new Error('Das Gerät hat ungültige Verlaufsdaten geliefert.');
const numericStatus = ['sampled_at_us', 'heartbeat_us', 'last_rx_us', 'last_tx_us', 'rx_valid', 'rx_rejected', 'repeats_completed', 'tx_failed', 'skipped', 'duty_used_us', 'duty_budget_us', 'recoveries', 'repeat_delay_ms', 'chip_mode'];
if (numericStatus.some(key => !Number.isFinite(data.status[key]) || data.status[key] < 0) || typeof data.status.config_intact !== 'boolean' || typeof data.status.repeat_enabled !== 'boolean') throw new Error('Das Gerät hat einen ungültigen Funkstatus geliefert.');
for (const row of data.rows) {
if (!Number.isSafeInteger(row.id) || row.id < data.oldest_id || row.id > data.cursor || !['timestamp_us', 'tx_start_us', 'tx_done_us', 'length', 'rssi_dbm'].every(key => Number.isFinite(row[key])) || !['hash', 'source', 'mode', 'format', 'reception', 'outcome'].every(key => typeof row[key] === 'string') || typeof row.crc_ok !== 'boolean') throw new Error('Das Gerät hat ungültige Daten zu einer Funknachricht geliefert.');
}
}
async function poll() {
if (state.inFlight || settingsState.wifiDisabled) return;
clearTimeout(state.timer);
const started = performance.now();
const remaining = 1000 - (started - state.lastPollStart);
if (remaining > 0) {
state.timer = setTimeout(poll, remaining);
return;
}
state.lastPollStart = started;
state.inFlight = true;
const requestedCursor = state.cursor;
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 4000);
try {
const response = await fetch(`/api/events?after=${requestedCursor}`, { cache: 'no-store', credentials: 'omit', signal: controller.signal });
if (!response.ok) throw new Error(`Das Gerät meldet HTTP ${response.status}.`);
const data = await response.json();
checkSnapshot(data);
if (settingsState.wifiDisabled) return;
const reconnected = !state.connected && state.lastSuccess !== null;
state.connected = true;
state.error = '';
state.lastSuccess = performance.now();
state.receivedAt = state.lastSuccess;
state.nowUs = data.now_us;
state.status = data.status;
if (state.boot !== null && data.boot_id !== state.boot) {
state.boot = data.boot_id;
state.cursor = 0;
state.oldest = 0;
state.evicted = data.evicted;
state.rows = [];
if (!state.paused) expanded.clear();
state.notice = 'Das Gerät wurde neu gestartet. Der alte Geräteverlauf wurde verworfen; der neue Verlauf wird vollständig geladen. Deine Namen in diesem Tab bleiben erhalten.';
if (settingsState.snapshot && settingsState.snapshot.boot_id !== data.boot_id) {
settingsState.ready = false;
settingsState.message = 'Geräteneustart erkannt. Letzte Einstellungen sind veraltet; Entwürfe bleiben erhalten.';
settingsState.tone = 'warning';
requireSettingsReview('Geräteneustart erkannt. Neue Gerätewerte laden und mit diesem Entwurf vergleichen.');
renderSettings();
if ($('settings-panel').open) loadSettings(true);
}
if (!state.paused) renderEvents();
// Always explicitly fetch after=0 for the new boot, even if this response had reset=true.
} else {
const previousCursor = state.cursor;
state.boot = data.boot_id;
if (data.reset || requestedCursor === 0) {
state.rows = [];
if (!state.paused) expanded.clear();
}
if (requestedCursor > 0 && data.oldest_id > requestedCursor + 1) {
state.notice = `Lücke im Verlauf: ${count(data.oldest_id - requestedCursor - 1)} Einträge wurden entfernt, bevor dieser Browser sie laden konnte. Der aktuelle Geräteverlauf wurde neu abgeglichen.`;
} else if (data.reset && requestedCursor > 0) {
state.notice = 'Das Gerät hat den Verlaufsstand zurückgesetzt. Die alten Einträge wurden durch den aktuellen Geräteverlauf ersetzt.';
} else if (reconnected) {
state.notice = 'Wieder verbunden. Neue Funknachrichten werden wieder geladen. Unter der Tabelle steht, wie viele ältere Einträge entfernt wurden.';
}
const merged = new Map(state.rows.map(row => [row.id, row]));
for (const row of data.rows) merged.set(row.id, row);
state.rows = [...merged.values()].filter(row => row.id >= data.oldest_id && row.id <= data.cursor).sort((a, b) => b.id - a.id).slice(0, CAPACITY);
state.cursor = data.cursor;
state.oldest = data.oldest_id;
state.evicted = data.evicted;
if (state.paused) state.newWhilePaused += data.rows.filter(row => row.id > previousCursor).length;
else {
const retainedIds = new Set(state.rows.map(row => row.id));
for (const id of expanded) if (!retainedIds.has(id)) expanded.delete(id);
if (data.rows.length || data.reset || requestedCursor === 0 || previousCursor !== data.cursor) renderEvents();
}
}
renderRetention();
} catch (error) {
state.connected = false;
state.error = error.name === 'AbortError' ? 'Das Gerät hat nicht rechtzeitig geantwortet.'
: error instanceof SyntaxError ? 'Die Antwort des Geräts konnte nicht gelesen werden.'
: error instanceof TypeError ? 'Das Gerät ist nicht erreichbar. Prüfe, ob dein Telefon mit seinem WLAN verbunden ist.'
: `Der Geräteverlauf konnte nicht geladen werden. ${error.message}`;
} finally {
clearTimeout(timeout);
state.inFlight = false;
renderHealth();
// Start at most once per second; a slow request is never overlapped.
if (!settingsState.wifiDisabled) state.timer = setTimeout(poll, Math.max(0, 1000 - (performance.now() - started)));
}
}
// Accepted device values and local drafts have separate lifetimes.
const settingDefinitions = [
{ key: 'repeat_enabled', title: 'Weiterleiten', kind: 'boolean', hint: 'Empfangene Nachrichten weiterleiten: an oder aus.' },
{ key: 'repeat_delay_ms', title: 'Wartezeit', min: 20, max: 1000, unit: 'ms', persisted: true, hint: '20–1.000 ms vor dem Senden; nicht die Sendezeit.' },
{ key: 'duty_budget_ppm', title: 'Sendezeitbudget', min: 0, max: 100000, unit: 'ppm', persisted: true, hint: '0 = Begrenzung aus. 1.000 ppm = 0,1 % = 3,6 s je gleitender Stunde.' },
{ key: 'tx_power', title: 'Sendeleistung am Funkchip', min: -9, max: 2, unit: 'dBm', hint: '−9 bis +2 dBm am SX1262. Der FEM verstärkt die tatsächliche Sendeleistung.' },
{ key: 'whitelist', title: 'Freigabeliste', kind: 'whitelist', hint: 'Bis zu 8 vollständige achtstellige Hex-Kennungen, eine pro Zeile oder mit Komma. Leer = alle erlaubt.' },
{ key: 'beacon_period_ms', title: 'Kennungssignal-Intervall', min: 250, max: 600000, zero: true, unit: 'ms', expert: true, hint: '0 = aus; sonst 250–600.000 ms. Erzeugt zusätzlichen Funkverkehr.' },
{ key: 'test_lfield', title: 'Test-L-Feld', min: 19, max: 200, expert: true, hint: '19–200; Länge selbst erzeugter Testnachrichten, nicht empfangener Zählernachrichten.' },
{ key: 'verbose', title: 'Ausführliches serielles Protokoll', kind: 'boolean', expert: true, hint: 'Zusätzliche Diagnose auf der seriellen Verbindung, nicht im Web-Verlauf.' },
{ key: 'fem_rx_csd', title: 'FEM-CSD beim Empfang', kind: 'boolean', expert: true, hint: 'Experiment: Kann den Empfang verschlechtern oder verhindern.' },
{ key: 'preamble_bits', title: 'Präambelerkennung', choices: [0, 8, 16, 24, 32], unit: 'Bit', expert: true, hint: '0 = Detektor aus. Experiment: Mehr Bit sind nicht automatisch besser.' },
];
const settingsState = {
snapshot: null, ready: false, loading: false, writing: null, wifiDisabled: false,
timer: null, lastGet: -Infinity, pendingReads: 0, message: '', tone: '',
};
const settingFields = new Map();
function validSettingValue(definition, value) {
if (definition.kind === 'boolean') return typeof value === 'boolean';
if (definition.kind === 'whitelist') return Array.isArray(value) && value.length <= 8
&& value.every(id => typeof id === 'string' && /^[0-9a-f]{8}$/i.test(id))
&& new Set(value.map(id => id.toUpperCase())).size === value.length;
if (!Number.isSafeInteger(value)) return false;
if (definition.choices) return definition.choices.includes(value);
return (definition.zero && value === 0) || (value >= definition.min && value <= definition.max);
}
function checkSettingsSnapshot(data) {
const uint = value => Number.isInteger(value) && value >= 0 && value <= 0xffffffff;
if (!data || typeof data.boot_id !== 'string' || !data.boot_id
|| !uint(data.revision) || data.revision === 0 || !uint(data.applied_revision)
|| data.applied_revision > data.revision || typeof data.csrf_token !== 'string' || !data.csrf_token
|| !data.settings || settingDefinitions.some(definition => !validSettingValue(definition, data.settings[definition.key]))) {
throw new Error('Unbekannte oder ungültige Einstellungsantwort; kein Erfolg bestätigt.');
}
data.settings.whitelist = data.settings.whitelist.map(id => id.toUpperCase());
}
function settingText(definition, value) {
if (definition.kind === 'boolean') return value ? 'Eingeschaltet' : 'Ausgeschaltet';
if (definition.kind === 'whitelist') return value.length ? value.join(', ') : 'Leer – alle Kennungen erlaubt';
if (definition.key === 'duty_budget_ppm') return value === 0 ? '0 ppm – Begrenzung aus'
: `${count(value)} ppm = ${decimal(value / 10000, 4).replace(/0+$/, '').replace(/,$/, '')} % = ${decimal(value * 0.0036, 4).replace(/0+$/, '').replace(/,$/, '')} s je gleitender Stunde`;
if (value === 0 && (definition.zero || definition.choices)) return `0 ${definition.unit} – aus`;
return `${count(value)}${definition.unit ? ` ${definition.unit}` : ''}`;
}
function setSettingInput(field, value) {
field.input.value = field.definition.kind === 'whitelist' ? value.join('\n') : String(value);
}
function readSettingDraft(field) {
const definition = field.definition;
const text = field.input.value.trim();
let value;
if (definition.kind === 'boolean') {
if (text !== 'true' && text !== 'false') throw new Error('Bitte „Eingeschaltet“ oder „Ausgeschaltet“ auswählen.');
value = text === 'true';
} else if (definition.kind === 'whitelist') {
value = text ? text.split(/\r?\n|,/).map(id => id.trim().toUpperCase()) : [];
if (!validSettingValue(definition, value)) throw new Error('Höchstens 8 unterschiedliche Kennungen mit genau 8 Hex-Zeichen (0–9, A–F), inklusive führender Nullen. Eine pro Zeile oder mit Komma; keine leeren Zwischeneinträge. Ganz leer erlaubt alle.');
} else {
if (!/^-?\d+$/.test(text)) throw new Error('Bitte eine ganze Zahl ohne Dezimalstellen, Tausendertrennzeichen oder Exponent eingeben.');
value = Number(text);
}
if (!validSettingValue(definition, value)) throw new Error(definition.choices
? 'Erlaubt sind nur 0, 8, 16, 24 oder 32 Bit.'
: `Erlaubt: ${definition.zero ? '0 (aus) oder ' : ''}${count(definition.min)} bis ${count(definition.max)}${definition.unit ? ` ${definition.unit}` : ''}, als ganze Zahl.`);
return value;
}
function settingMessage(field, message, tone = '') {
field.message.textContent = message;
field.message.className = `small setting-message ${tone ? `${tone}-text` : ''}`;
}
function requireSettingsReview(message) {
for (const field of settingFields.values()) {
if (!field.dirty) continue;
if (!field.review) settingMessage(field, message, 'warning');
field.review = true;
field.reviewCheck.checked = false;
}
}
function acceptSettingsSnapshot(data, submitted = null) {
const previous = settingsState.snapshot;
const changed = previous && (previous.boot_id !== data.boot_id || previous.revision !== data.revision);
if (changed && !submitted) requireSettingsReview(previous.boot_id !== data.boot_id
? 'Geräteneustart erkannt. Dieser Entwurf blieb erhalten; neuen Gerätewert vergleichen und Abgleich bestätigen.'
: 'Der Gerätestand hat sich geändert. Entwurf mit dem aktuellen Gerätewert vergleichen und Abgleich bestätigen.');
settingsState.snapshot = data;
settingsState.ready = true;
for (const field of settingFields.values()) {
if (submitted?.key === field.definition.key && submitted.version === field.version) {
field.dirty = false;
field.review = false;
field.reviewCheck.checked = false;
settingMessage(field, `Vom Gerät angenommen.${field.definition.persisted ? ' Dauerhaft gespeichert.' : ' Nur im RAM.'} Der Übernahmestand der Funkaufgabe steht oben.`, 'good');
}
if (!field.dirty) setSettingInput(field, data.settings[field.definition.key]);
}
}
function renderSettings() {
const s = settingsState;
const snapshot = s.snapshot;
const busy = s.loading || Boolean(s.writing);
const pending = snapshot && snapshot.applied_revision < snapshot.revision;
$('settings-reload').disabled = busy;
$('settings-wifi-disable').disabled = !s.ready || busy || s.wifiDisabled;
const status = $('settings-status');
let message = s.message || 'Noch keine Einstellungen geladen. Zum Laden diesen Bereich öffnen.';
if (pending && !s.wifiDisabled) message += s.ready
? ` Übernahme durch die Funkaufgabe ausstehend.${s.pendingReads >= 30 ? ' Automatische Abfragen nach 30 Versuchen beendet; bitte später „Gerätewerte neu laden“.' : ' Bei geöffnetem Bereich wird höchstens einmal pro Sekunde nachgefragt.'}`
: ' Der zuletzt geladene Stand wartete auf die Funkaufgabe; der aktuelle Übernahmestand ist unbekannt.';
status.textContent = message;
status.className = `notice ${s.tone || (pending ? 'warning' : '')}`;
setText('settings-revision', snapshot
? `Gerätestart ${snapshot.boot_id} · angenommene Revision ${snapshot.revision} · von der Funkaufgabe kopiert: ${snapshot.applied_revision}. Kein Nachweis erfolgreicher Hardwarekonfiguration oder Funkübertragung.`
: 'Angenommene Gerätewerte und Übernahmestand sind noch unbekannt.');
for (const field of settingFields.values()) {
const definition = field.definition;
field.accepted.textContent = snapshot
? `${s.ready ? 'Vom Gerät angenommen (letzte Antwort)' : 'Zuletzt vom Gerät angenommen – möglicherweise veraltet'}: ${settingText(definition, snapshot.settings[definition.key])}`
: 'Vom Gerät angenommen: noch unbekannt';
field.input.disabled = !snapshot || s.wifiDisabled;
field.submit.disabled = !s.ready || busy || !field.dirty || s.wifiDisabled || (field.review && !field.reviewCheck.checked);
field.discard.disabled = !snapshot || Boolean(s.writing) || !field.dirty || s.wifiDisabled;
field.reviewLabel.hidden = !field.review || !field.dirty;
field.reviewCheck.disabled = !s.ready || busy || s.wifiDisabled;
field.draft.textContent = field.dirty ? 'Lokaler Entwurf – noch nicht gesendet.' : 'Kein ungesendeter Entwurf.';
if (field.dirty && definition.key === 'duty_budget_ppm') {
try { field.draft.textContent += ` ${settingText(definition, readSettingDraft(field))}`; } catch { /* The submit action reports validation errors. */ }
}
}
}
function createSettingField(definition) {
const id = `setting-${definition.key}`;
const form = node('form', undefined, 'setting-field');
form.noValidate = true;
const heading = node('div', undefined, 'heading-with-help');
const title = node('h3', definition.title);
title.id = `${id}-title`;
form.setAttribute('aria-labelledby', title.id);
heading.append(title, helpButton(`settings_${definition.key}`, `${id}-help`));
const storage = node('p', definition.persisted ? 'Speicherung beim Übernehmen: dauerhaft im Heltec' : 'Speicherung beim Übernehmen: nur RAM · bis zum Geräteneustart', 'small setting-storage');
const hint = node('p', definition.hint, 'small');
hint.id = `${id}-hint`;
const accepted = node('p', undefined, 'setting-accepted');
accepted.id = `${id}-accepted`;
const label = node('label', `Lokaler Entwurf: ${definition.title}${definition.unit ? ` (${definition.unit})` : ''}`);
label.htmlFor = id;
const input = node(definition.kind === 'whitelist' ? 'textarea' : definition.kind === 'boolean' || definition.choices ? 'select' : 'input', undefined, 'setting-input');
input.id = id;
if (input.tagName === 'SELECT') {
const placeholder = node('option', 'Noch nicht geladen');
placeholder.value = '';
placeholder.disabled = true;
input.append(placeholder);
const options = definition.kind === 'boolean' ? [false, true] : definition.choices;
for (const value of options) {
const option = node('option', settingText(definition, value));
option.value = String(value);
input.append(option);
}
input.value = '';
} else {
input.autocomplete = 'off';
input.spellcheck = false;
if (input.tagName === 'INPUT') {
input.type = 'text';
input.inputMode = definition.min < 0 ? 'text' : 'numeric';
} else {
input.rows = 3;
input.autocapitalize = 'characters';
}
}
const draft = node('p', undefined, 'small setting-draft');
const message = node('p', undefined, 'small setting-message');
message.id = `${id}-message`;
message.setAttribute('role', 'status');
input.setAttribute('aria-describedby', `${hint.id} ${accepted.id} ${message.id}`);
const reviewLabel = node('label', undefined, 'checkbox setting-review');
const reviewCheck = node('input');
reviewCheck.type = 'checkbox';
reviewLabel.append(reviewCheck, node('span', 'Aktuellen Gerätewert mit meinem Entwurf verglichen'));
const actions = node('div', undefined, 'button-row');
const submit = node('button', `${definition.title} übernehmen`);
submit.type = 'submit';
const discard = node('button', 'Letzten Gerätewert einsetzen');
discard.type = 'button';
actions.append(submit, discard);
form.append(heading, storage, hint, accepted, label, input, draft, reviewLabel, actions, message);
const field = { definition, input, accepted, draft, message, reviewLabel, reviewCheck, submit, discard, dirty: false, review: false, version: 0 };
settingFields.set(definition.key, field);
input.addEventListener('input', () => {
field.dirty = true;
field.version++;
field.reviewCheck.checked = false;
input.removeAttribute('aria-invalid');
settingMessage(field, '');
renderSettings();
});
reviewCheck.addEventListener('change', renderSettings);
discard.addEventListener('click', () => {
field.dirty = false;
field.review = false;
field.version++;
input.removeAttribute('aria-invalid');
setSettingInput(field, settingsState.snapshot.settings[definition.key]);
settingMessage(field, 'Lokalen Entwurf durch den zuletzt geladenen Gerätewert ersetzt. Nichts gesendet.');
renderSettings();
});
// Enter in a number field is not consent to send a device change.
form.addEventListener('keydown', event => {
if (event.key === 'Enter' && event.target === input && input.tagName === 'INPUT') event.preventDefault();
});
form.addEventListener('submit', event => { event.preventDefault(); submitSetting(field); });
$(definition.expert ? 'settings-advanced' : 'settings-common').append(form);
}
async function settingsRequest(path, body) {
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 4000);
try {
const options = { cache: 'no-store', credentials: 'omit', signal: controller.signal };
if (body) {
options.method = 'POST';
options.headers = { 'Content-Type': 'application/json', 'X-CSRF-Token': settingsState.snapshot.csrf_token };
options.body = JSON.stringify(body);
}
const response = await fetch(path, options);
let data;
try { data = await response.json(); } catch { throw new Error(`Antwort bei HTTP ${response.status} nicht lesbar; Ergebnis unbekannt.`); }
if (response.status !== 200) {
const error = new Error(typeof data?.error === 'string' && data.error ? data.error : `Unbekannte Antwort (HTTP ${response.status}).`);
error.status = response.status;
throw error;
}
return data;
} finally {
clearTimeout(timeout);
}
}
function settingsError(error) {
if (error.name === 'AbortError') return 'Das Gerät hat nicht rechtzeitig geantwortet.';
if (error instanceof TypeError) return 'Das Gerät ist nicht erreichbar. Verbindung zum Heltec-WLAN prüfen.';
if (error.status === 404 || error.status === 405) return 'Diese Geräte-Firmware bietet die Einstellungs-API nicht an.';
return error.message;
}
async function loadSettings(resetBudget = false) {
const s = settingsState;
if (s.loading || s.writing) return;
clearTimeout(s.timer);
const wait = 1000 - (performance.now() - s.lastGet);
if (wait > 0) { s.timer = setTimeout(() => loadSettings(resetBudget), wait); return; }
if (resetBudget) s.pendingReads = 0;
s.lastGet = performance.now();
s.loading = true;
s.message = 'Gerätewerte werden geladen. Lokale Entwürfe bleiben erhalten.';
s.tone = '';
renderSettings();
try {
const data = await settingsRequest('/api/settings');
checkSettingsSnapshot(data);
acceptSettingsSnapshot(data);
s.pendingReads++;
s.message = 'Gerätewerte geladen. Änderungen werden nur nach deinem ausdrücklichen Übernehmen gesendet.';
if (s.wifiDisabled) {
s.wifiDisabled = false;
setText('settings-wifi-result', 'Das Heltec-Gerät antwortet wieder. Dies bestätigt die Erreichbarkeit; der WLAN-Zustand kann sich noch ändern.');
if (!state.inFlight) poll();
}
} catch (error) {
s.ready = false;
s.message = `${settingsError(error)} Keine aktuellen Einstellungen bestätigt. Letzte Werte und Entwürfe bleiben erhalten. Zum erneuten Versuch „Gerätewerte neu laden“.`;
s.tone = 'danger';
} finally {
s.loading = false;
renderSettings();
schedulePendingSettings();
}
}
function schedulePendingSettings() {
const s = settingsState;
clearTimeout(s.timer);
if (s.ready && !s.wifiDisabled && s.snapshot.applied_revision < s.snapshot.revision
&& s.pendingReads < 30 && $('settings-panel').open && !document.hidden) {
s.timer = setTimeout(() => loadSettings(), Math.max(1000, 1000 - (performance.now() - s.lastGet)));
}
}
async function submitSetting(field) {
const s = settingsState;
if (!s.ready || s.loading || s.writing || s.wifiDisabled || !field.dirty || (field.review && !field.reviewCheck.checked)) return;
let value;
try { value = readSettingDraft(field); } catch (error) {
field.input.setAttribute('aria-invalid', 'true');
settingMessage(field, error.message, 'danger');
field.input.focus();
return;
}
const key = field.definition.key;
if (key === 'duty_budget_ppm' && (value === 0 || value > 1000)
&& !window.confirm(`${value === 0 ? 'Sendezeitbegrenzung wirklich ausschalten? 0 ist kein Sendestopp.' : `Sendezeitbudget wirklich auf ${settingText(field.definition, value)} setzen?`}\n1.000 ppm = 0,1 % = 3,6 s je gleitender Stunde. Höhere Werte oder eine ausgeschaltete Prüfung können geltende Funkvorschriften verletzen. Du bist für die zulässigen Grenzen verantwortlich.\nNur „OK“ sendet diese Änderung.`)) return;
const submitted = { key, value, version: field.version, boot_id: s.snapshot.boot_id, revision: s.snapshot.revision };
s.writing = key;
clearTimeout(s.timer);
settingMessage(field, 'Wird gesendet. Noch keine Annahme bestätigt.');
renderSettings();
let reconcile = false;
try {
const data = await settingsRequest('/api/settings', { boot_id: submitted.boot_id, revision: submitted.revision, key, value });
checkSettingsSnapshot(data);
if (data.boot_id !== submitted.boot_id || data.revision < submitted.revision
|| JSON.stringify(data.settings[key]) !== JSON.stringify(value)) throw new Error('Antwort bestätigt den gesendeten Wert nicht eindeutig; Ergebnis unbekannt.');
acceptSettingsSnapshot(data, submitted);
if (field.version !== submitted.version) settingMessage(field, 'Gesendeter Wert vom Gerät angenommen. Dein inzwischen geänderter Entwurf bleibt ungesendet.', 'warning');
s.pendingReads = 0;
s.message = `${field.definition.title}: vom Gerät angenommen.`;
s.tone = '';
} catch (error) {
const conflict = error.status === 409;
if (error.status === 400) field.input.setAttribute('aria-invalid', 'true');
settingMessage(field, conflict
? `Konflikt: ${settingsError(error)} Aktuelle Gerätewerte werden geladen. Entwürfe vergleichen, Abgleich bestätigen und selbst erneut übernehmen.`
: `${settingsError(error)} ${error.status === 400 ? 'Eingabe wurde abgelehnt.' : error.status === 503 ? 'Speicherung/Übernahme nicht bestätigt.' : 'Ob die Änderung angenommen wurde, ist unbekannt.'} Keine automatische Wiederholung.`, 'danger');
s.message = 'Änderung nicht bestätigt. Meldung am betroffenen Feld beachten.';
s.tone = 'danger';
if (error.status !== 400) {
s.ready = false;
requireSettingsReview('Änderung nicht bestätigt. Nach dem Nachladen Gerätewert mit dem erhaltenen Entwurf vergleichen und Abgleich bestätigen; keine automatische Wiederholung.');
// Keep the actionable server error on the field that was submitted.
settingMessage(field, `${conflict ? 'Konflikt (409): ' : 'Änderung nicht bestätigt: '}${settingsError(error)} Keine automatische Wiederholung. Nach dem Nachladen Gerätewert und Entwurf vergleichen, Abgleich bestätigen und selbst erneut übernehmen.`, 'danger');
reconcile = true;
}
} finally {
s.writing = null;
renderSettings();
if (reconcile) loadSettings(true);
else schedulePendingSettings();
}
}
async function disableSettingsWifi() {
const s = settingsState;
if (!s.ready || s.loading || s.writing || s.wifiDisabled) return;
const drafts = [...settingFields.values()].some(field => field.dirty);
if (!window.confirm(`WLAN des Heltec-Geräts wirklich ausschalten?\nDiese Verbindung wird getrennt. Die Funkweiterleitung läuft gemäß ihren Einstellungen weiter. Wiedereinschalten ist nicht über diese Seite möglich, sondern nur direkt am Gerät.${drafts ? '\nDu hast ungesendete Entwürfe. Sie werden NICHT übernommen.' : ''}\nDas WLAN deines Telefons oder Rechners wird nicht umgestellt.`)) return;
s.writing = 'wifi';
clearTimeout(s.timer);
setText('settings-wifi-result', 'Ausschaltauftrag wird gesendet. Noch keine Bestätigung.');
renderSettings();
let reconcile = false;
try {
const data = await settingsRequest('/api/wifi/disable', { boot_id: s.snapshot.boot_id });
if (data?.ok !== true) throw new Error('Unbekannte Antwort; Ausschalten nicht bestätigt.');
s.wifiDisabled = true;
s.ready = false;
state.connected = false;
clearTimeout(state.timer);
s.message = 'Heltec-WLAN: Ausschaltauftrag bestätigt. Die Verbindung wird getrennt; automatische Abfragen wurden beendet. Letzte Werte können veraltet sein.';
s.tone = 'warning';
setText('settings-wifi-result', 'Ausschalten bestätigt. Zum Wiedereinschalten das Gerät direkt bedienen. Danach wieder mit seinem WLAN verbinden und „Gerätewerte neu laden“.');
renderHealth();
} catch (error) {
s.ready = false;
s.message = 'WLAN-Ausschalten nicht bestätigt. Keine automatische Wiederholung.';
s.tone = 'danger';
setText('settings-wifi-result', `${settingsError(error)} Ob das WLAN bereits ausgeschaltet ist, ist unbekannt. Falls getrennt: zum Wiedereinschalten das Gerät direkt bedienen. Sonst Gerätewerte neu laden und vor einem neuen Auftrag prüfen.`);
requireSettingsReview('Verbindung oder Gerätestand unklar. Nach dem Nachladen Entwürfe mit den aktuellen Gerätewerten vergleichen.');
reconcile = error.status === 409;
} finally {
s.writing = null;
renderSettings();
if (reconcile) loadSettings(true);
}
}
for (const definition of settingDefinitions) createSettingField(definition);
$('settings-reload').addEventListener('click', () => loadSettings(true));
$('settings-wifi-disable').addEventListener('click', disableSettingsWifi);
$('settings-panel').addEventListener('toggle', () => {
if ($('settings-panel').open && !settingsState.wifiDisabled) loadSettings(true);
else clearTimeout(settingsState.timer);
});
document.addEventListener('visibilitychange', () => {
if (document.hidden) clearTimeout(settingsState.timer);
else schedulePendingSettings();
});
renderSettings();
// RFC4180-style parser. Record start lines are preserved for actionable errors.
export function parseCSV(text) {
if (text.charCodeAt(0) === 0xFEFF) text = text.slice(1);
const records = [];
let fields = [], field = '', quoted = false, afterQuote = false, line = 1, startLine = 1;
function fail(message) { throw new Error(`Zeile ${count(startLine)}: ${message}`); }
function pushField() {
fields.push(field);
field = '';
afterQuote = false;
if (fields.length > 2) fail('Es werden genau zwei Spalten erwartet (oms_id,label).');
}
function pushRecord() {
pushField();
if (!(fields.length === 1 && fields[0] === '')) records.push({ line: startLine, fields });
fields = [];
if (records.length > CSV_ROWS + 1) fail(`Mehr als ${count(CSV_ROWS)} Zuordnungen.`);
}
for (let i = 0; i < text.length; i++) {
const char = text[i];
if (quoted) {
if (char === '"') {
if (text[i + 1] === '"') { field += '"'; i++; }
else { quoted = false; afterQuote = true; }
} else if (char === '\r' || char === '\n') {
if (char === '\r' && text[i + 1] === '\n') i++;
field += '\n';
line++;
} else field += char;
} else if (char === ',') {
pushField();
} else if (char === '\r' || char === '\n') {
if (char === '\r' && text[i + 1] === '\n') i++;
pushRecord();
line++;
startLine = line;
} else if (char === '"' && field === '' && !afterQuote) {
quoted = true;
} else {
if (afterQuote) fail('Unerwarteter Text nach dem schließenden Anführungszeichen.');
if (char === '"') fail('Anführungszeichen mitten in einem Feld: Bitte das ganze Feld in Anführungszeichen setzen und enthaltene Anführungszeichen verdoppeln.');
field += char;
}
if (field.length > 2048) fail('Das Feld ist länger als 2.048 Zeichen.');
}
if (quoted) fail('Das schließende Anführungszeichen fehlt.');
if (field !== '' || fields.length || afterQuote) pushRecord();
return records;
}
export function parseLabels(text) {
if (new TextEncoder().encode(text).length > CSV_BYTES) throw new Error('Die Datei ist größer als 256 KiB.');
const records = parseCSV(text);
if (!records.length || records[0].fields.length !== 2 || records[0].fields[0] !== 'oms_id' || records[0].fields[1] !== 'label') throw new Error(`Zeile ${count(records[0]?.line || 1)}: Die Kopfzeile muss exakt oms_id,label lauten.`);
const labels = new Map();
const seen = new Map();
const errors = [];
const warnings = [];
for (const { line, fields } of records.slice(1)) {
if (fields.length !== 2) { errors.push(`Zeile ${count(line)}: Es werden genau zwei Spalten erwartet.`); continue; }
const [raw, label] = fields;
const id = raw.toUpperCase();
if (!/^[0-9A-F]{8}$/.test(id)) { errors.push(`Zeile ${count(line)}: Die Kennung muss genau 8 Zeichen (0–9 oder A–F) enthalten, einschließlich aller führenden Nullen.`); continue; }
if (seen.has(id)) errors.push(`Zeile ${count(line)}: Kennung ${id} ist doppelt vorhanden (zuerst in Zeile ${count(seen.get(id))}).`);
else seen.set(id, line);
if (label.length > CSV_LABEL_LENGTH) errors.push(`Zeile ${count(line)}: Der eigene Name ist länger als ${count(CSV_LABEL_LENGTH)} Zeichen.`);
if (/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(label)) errors.push(`Zeile ${count(line)}: Der eigene Name enthält nicht unterstützte Steuerzeichen.`);
if (!/^[0-9]{8}$/.test(id)) warnings.push(`Zeile ${count(line)}: ${id} enthält A–F statt nur Ziffern (kein BCD). Die Kennung bleibt unverändert als Hexadezimalwert erhalten.`);
labels.set(id, label);
}
if (errors.length) throw new Error(`${errors.slice(0, 20).join('\n')}${errors.length > 20 ? `\n… ${count(errors.length - 20)} weitere Fehler.` : ''}`);
return { labels, warnings };
}
export function csvCell(value) {
let text = value === null || value === undefined ? '' : String(value);
// Do not emit spreadsheet formulas, even after leading whitespace/control bytes.
// Eight-digit hexadecimal IDs cannot trigger this and are never numerically parsed.
if (typeof value === 'string' && (/^[\t\r\n]/.test(text) || /^[\s\u0000-\u001F]*[=+\-@]/.test(text))) text = `'${text}`;
return `"${text.replaceAll('"', '""')}"`;
}
function csvText(rows) { return `\uFEFF${rows.map(row => row.map(csvCell).join(',')).join('\r\n')}\r\n`; }
function download(name, rows) {
const url = URL.createObjectURL(new Blob([csvText(rows)], { type: 'text/csv;charset=utf-8' }));
const link = node('a');
link.href = url;
link.download = name;
document.body.append(link);
link.click();
link.remove();
setTimeout(() => URL.revokeObjectURL(url), 1000);
}
function exportEvents() {
const fields = ['boot_id', 'id', 'timestamp_us', 'tx_start_us', 'tx_done_us', 'meter_id', 'label', 'manufacturer_raw', 'manufacturer_flag', 'manufacturer_name', 'version_raw', 'device_type_raw', 'medium', 'identity_warning', 'ambiguous_id', 'hash', 'length', 'rssi_dbm', 'crc_ok', 'source', 'mode', 'format', 'reception', 'outcome'];
const ambiguity = collisions(state.rows);
const rows = state.rows.map(row => {
const identity = senderIdentity(row);
return [state.boot, row.id, row.timestamp_us, row.tx_start_us, row.tx_done_us, identity.rawId, senderLabel(identity), row.manufacturer, identity.trusted ? identity.manufacturer.code : '', identity.trusted ? identity.manufacturer.name : '', row.version, row.device_type, identity.trusted ? identity.medium.name : '', identity.warnings.join('; '), identity.labelEligible && ambiguity.has(identity.id), row.hash, row.length, row.rssi_dbm, row.crc_ok, row.source, row.mode, row.format, row.reception, row.outcome];
});
download('heltec-funkverlauf.csv', [fields, ...rows]);
}
function exportLabels() {
const ids = [...new Set(state.rows.map(senderIdentity).filter(identity => identity.labelEligible).map(identity => identity.id))].sort();
download('heltec-zaehlernamen.csv', [['oms_id', 'label'], ...ids.map(id => [id, state.labels.get(id) || ''])]);
}
function renderLabels() {
setText('label-count', `${count(state.labels.size)} ${state.labels.size === 1 ? 'Name' : 'Namen'}`);
$('clear-labels').disabled = state.labels.size === 0;
renderEvents();
}
$('filter').addEventListener('input', renderEvents);
$('failures').addEventListener('change', renderEvents);
$('pause').addEventListener('click', () => {
state.paused = !state.paused;
if (state.paused) {
state.frozenRows = state.rows.slice();
state.frozenBoot = state.boot;
state.frozenAt = deviceNow();
state.newWhilePaused = 0;
} else {
state.frozenRows = [];
if (state.frozenBoot !== state.boot) expanded.clear();
}
$('pause').setAttribute('aria-pressed', String(state.paused));
setText('pause', state.paused ? 'Anzeige fortsetzen' : 'Nur Anzeige pausieren');
renderEvents();
renderRetention();
});
$('download-events').addEventListener('click', exportEvents);
$('export-labels').addEventListener('click', exportLabels);
$('sample-labels').addEventListener('click', () => download('heltec-namensvorlage.csv', [['oms_id', 'label'], ['00123456', 'Wasserzähler Küche'], ['00000001', 'Hauswirtschaftsraum, Wärme']]));
$('clear-labels').addEventListener('click', () => {
state.importGeneration++;
state.labels = new Map();
$('label-file').value = '';
$('label-result').className = 'small';
setText('label-result', 'Eigene Namen aus diesem Tab entfernt. Am Gerät wurde nichts geändert.');
renderLabels();
});
$('label-file').addEventListener('change', async event => {
const generation = ++state.importGeneration;
const file = event.target.files[0];
if (!file) return;
let importStep = 'size';
try {
if (file.size > CSV_BYTES) throw new Error('Die Datei ist größer als 256 KiB.');
importStep = 'read';
const bytes = await file.arrayBuffer();
if (generation !== state.importGeneration) return;
importStep = 'decode';
const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
importStep = 'parse';
const parsed = parseLabels(text);
state.labels = parsed.labels;
$('label-result').className = `small ${parsed.warnings.length ? 'warning-text' : 'good-text'}`;
setText('label-result', `${count(state.labels.size)} ${state.labels.size === 1 ? 'Name' : 'Namen'} aus „${file.name}“ übernommen. Vorherige Zuordnungen ersetzt; nichts hochgeladen.${parsed.warnings.length ? `\n${parsed.warnings.slice(0, 8).join('\n')}${parsed.warnings.length > 8 ? `\n… ${count(parsed.warnings.length - 8)} weitere Kennungen mit A–F (kein BCD).` : ''}` : ''}`);
renderLabels();
} catch (error) {
if (generation !== state.importGeneration) return;
$('label-result').className = 'small danger-text';
const message = importStep === 'read' ? 'Die ausgewählte Datei konnte nicht gelesen werden.'
: importStep === 'decode' ? 'Die Datei ist kein gültiger UTF-8-Text. Bitte als CSV mit UTF-8-Kodierung speichern.'
: error.message;
setText('label-result', `Datei nicht übernommen. Alle bisherigen Namen bleiben unverändert.\n${message}`);
} finally {
if (generation === state.importGeneration) event.target.value = '';
}
});
compactTable.addEventListener('change', () => {
for (const cell of document.querySelectorAll('.detail-row > td')) {
cell.colSpan = compactTable.matches ? 3 : 4;
}
});
window.addEventListener('online', () => { if (!state.inFlight) poll(); });
document.addEventListener('visibilitychange', () => { if (!document.hidden && !state.inFlight) poll(); });
setText('registry-note', `Herstellernamen: ${count(registryInfo.count)} eindeutige FLAG-Kennungen aus dem offiziellen Verzeichnis der DLMS User Association, Stand ${registryInfo.date}. Die Namen bestimmen weder Zählermodell noch Treiber.`);
setInterval(renderHealth, 1000);
poll();