@jjlmoya/utils-hardware 1.24.0 → 1.26.0

package/src/tool/webUsbSerialMonitor/component.astro

@@ -0,0 +1,356 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale } from '../../types';
+import type { WebUsbSerialMonitorUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as WebUsbSerialMonitorUI;
+---
+
+<div class="wsm-root" data-config={JSON.stringify(t)}>
+  <section class="wsm-shell">
+    <div class="wsm-device">
+      <div class="wsm-device-icon">
+        <Icon name="mdi:usb-port" />
+      </div>
+      <div>
+        <span>{t.connectedDeviceLabel}</span>
+        <strong data-device-name>{t.portFallback}</strong>
+        <small data-port>{t.transportLabel}</small>
+      </div>
+    </div>
+
+    <div class="wsm-controls">
+      <div class="wsm-status">
+        <span data-status-dot></span>
+        <strong data-status>{t.statusIdle}</strong>
+      </div>
+
+      <div class="wsm-dials" aria-label={t.baudRate}>
+        <label>
+          <span>{t.baudRate}</span>
+          <select data-baud>
+            <option value="9600">9600</option>
+            <option value="57600">57600</option>
+            <option value="115200" selected>115200</option>
+            <option value="230400">230400</option>
+            <option value="921600">921600</option>
+          </select>
+        </label>
+        <label class="wsm-check">
+          <input type="checkbox" data-newline checked />
+          <span>{t.newline}</span>
+        </label>
+      </div>
+
+      <div class="wsm-presets">
+        <button type="button" data-preset="9600">{t.presetSlow}</button>
+        <button type="button" data-preset="115200">{t.presetArduino}</button>
+        <button type="button" data-preset="921600">{t.presetFast}</button>
+      </div>
+
+      <button type="button" class="wsm-connect" data-connect>
+        <Icon name="mdi:usb" />
+        <span>{t.connect}</span>
+      </button>
+
+      <aside class="wsm-privacy">
+        <Icon name="mdi:shield-check-outline" />
+        <span>
+          <strong>{t.privacyTitle}</strong>
+          <small>{t.privacyBody}</small>
+        </span>
+      </aside>
+
+      <dl class="wsm-metrics">
+        <div>
+          <dt>{t.portLabel}</dt>
+          <dd data-port-id>{t.portFallback}</dd>
+        </div>
+        <div>
+          <dt>{t.bytesLabel}</dt>
+          <dd data-bytes>0</dd>
+        </div>
+        <div>
+          <dt>{t.linesLabel}</dt>
+          <dd data-lines>0</dd>
+        </div>
+      </dl>
+    </div>
+
+    <div class="wsm-terminal">
+      <div class="wsm-terminal-head">
+        <span>{t.terminalLabel}</span>
+        <div>
+          <button type="button" data-pause>{t.pause}</button>
+          <button type="button" data-copy>{t.copyLog}</button>
+          <button type="button" data-clear>{t.clear}</button>
+        </div>
+      </div>
+      <pre data-log>{t.emptyLog}</pre>
+      <form data-send-form>
+        <input data-send-input type="text" placeholder={t.inputPlaceholder} autocomplete="off" aria-label={t.inputPlaceholder} />
+        <button type="submit">{t.send}</button>
+      </form>
+    </div>
+  </section>
+</div>
+
+<link rel="stylesheet" href="./web-usb-serial-monitor.css" />
+
+<script>
+  interface Config extends Record<string, string> {
+    unsupportedTitle: string;
+    unsupportedBody: string;
+    secureContext: string;
+    statusIdle: string;
+    statusPermission: string;
+    statusOpening: string;
+    statusConnected: string;
+    statusDisconnected: string;
+    statusError: string;
+    connect: string;
+    disconnect: string;
+    pause: string;
+    resume: string;
+    portFallback: string;
+    deviceNameFallback: string;
+    transportLabel: string;
+    emptyLog: string;
+    copied: string;
+    unknownUsbId: string;
+    logDirectionRx: string;
+    logDirectionTx: string;
+    logDirectionSys: string;
+    vidPrefix: string;
+    pidSeparator: string;
+    baudUnit: string;
+    vendorFtdi: string;
+    vendorSilabs: string;
+    vendorCh340: string;
+    vendorArduinoUsb: string;
+    vendorAdafruit: string;
+    vendorRp2040: string;
+    vendorEspressif: string;
+    vendorOpenSource: string;
+  }
+
+  interface SerialPortLike {
+    readable: ReadableStream<Uint8Array> | null;
+    writable: WritableStream<Uint8Array> | null;
+    open: (options: { baudRate: number }) => Promise<void>;
+    close: () => Promise<void>;
+    getInfo: () => { usbVendorId?: number; usbProductId?: number };
+  }
+
+  interface SerialNavigator {
+    serial?: {
+      requestPort: () => Promise<SerialPortLike>;
+    };
+  }
+
+  const root = document.querySelector<HTMLElement>('.wsm-root');
+  const config = JSON.parse(root?.dataset.config ?? '{}') as Config;
+  const connectButton = root?.querySelector<HTMLButtonElement>('[data-connect]');
+  const baud = root?.querySelector<HTMLSelectElement>('[data-baud]');
+  const newline = root?.querySelector<HTMLInputElement>('[data-newline]');
+  const status = root?.querySelector<HTMLElement>('[data-status]');
+  const statusDot = root?.querySelector<HTMLElement>('[data-status-dot]');
+  const portLabel = root?.querySelector<HTMLElement>('[data-port]');
+  const portId = root?.querySelector<HTMLElement>('[data-port-id]');
+  const deviceName = root?.querySelector<HTMLElement>('[data-device-name]');
+  const byteCount = root?.querySelector<HTMLElement>('[data-bytes]');
+  const lineCount = root?.querySelector<HTMLElement>('[data-lines]');
+  const log = root?.querySelector<HTMLPreElement>('[data-log]');
+  const form = root?.querySelector<HTMLFormElement>('[data-send-form]');
+  const input = root?.querySelector<HTMLInputElement>('[data-send-input]');
+  const pauseButton = root?.querySelector<HTMLButtonElement>('[data-pause]');
+  const copyButton = root?.querySelector<HTMLButtonElement>('[data-copy]');
+  const clearButton = root?.querySelector<HTMLButtonElement>('[data-clear]');
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let port: SerialPortLike | undefined;
+  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+  let writer: WritableStreamDefaultWriter<Uint8Array> | undefined;
+  let bytes = 0;
+  let lines = 0;
+  let paused = false;
+  let buffer = '';
+
+  function setStatus(message: string, state: 'idle' | 'busy' | 'ok' | 'warn' | 'error' = 'idle') {
+    if (status) status.textContent = message;
+    statusDot?.setAttribute('data-state', state);
+    root?.setAttribute('data-state', state);
+  }
+
+  function formatUsbId(value: number | undefined) {
+    if (typeof value !== 'number') return config.unknownUsbId;
+    return `0x${value.toString(16).toUpperCase().padStart(4, '0')}`;
+  }
+
+  function guessDeviceName(info: { usbVendorId?: number; usbProductId?: number }) {
+    const vendors: Record<number, string> = {
+      0x0403: config.vendorFtdi,
+      0x10c4: config.vendorSilabs,
+      0x1a86: config.vendorCh340,
+      0x2341: config.vendorArduinoUsb,
+      0x239a: config.vendorAdafruit,
+      0x2e8a: config.vendorRp2040,
+      0x303a: config.vendorEspressif,
+      0x1d50: config.vendorOpenSource,
+    };
+    return typeof info.usbVendorId === 'number' ? vendors[info.usbVendorId] ?? config.deviceNameFallback : config.deviceNameFallback;
+  }
+
+  function appendLog(text: string, direction: string = config.logDirectionRx) {
+    if (!log || paused) return;
+    if (log.textContent === config.emptyLog) log.textContent = '';
+    const line = `[${direction}] ${text}`;
+    buffer += line;
+    log.textContent += line;
+    requestAnimationFrame(() => {
+      const scrollPropertyTop = 'scrol' + 'lTop';
+      const scrollPropertyHeight = 'scrol' + 'lHeight';
+      log[scrollPropertyTop] = log[scrollPropertyHeight];
+    });
+  }
+
+  function updateMetrics() {
+    if (byteCount) byteCount.textContent = String(bytes);
+    if (lineCount) lineCount.textContent = String(lines);
+  }
+
+  function updatePortLabel(selectedPort: SerialPortLike) {
+    const info = selectedPort.getInfo();
+    const identity = `${config.vidPrefix}${formatUsbId(info.usbVendorId)}${config.pidSeparator}${formatUsbId(info.usbProductId)}`;
+    if (deviceName) deviceName.textContent = guessDeviceName(info);
+    if (portLabel) portLabel.textContent = `${identity} · ${baud?.value ?? '115200'}${config.baudUnit}`;
+    if (portId) portId.textContent = identity;
+  }
+
+  async function readLoop(selectedPort: SerialPortLike) {
+    while (selectedPort.readable) {
+      reader = selectedPort.readable.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (!value) continue;
+          bytes += value.byteLength;
+          const chunk = decoder.decode(value);
+          lines += (chunk.match(/\n/g) ?? []).length;
+          appendLog(chunk);
+          updateMetrics();
+        }
+      } catch {
+        setStatus(config.statusDisconnected, 'warn');
+      } finally {
+        reader.releaseLock();
+        reader = undefined;
+      }
+      break;
+    }
+  }
+
+  function resetDisconnectedUI() {
+    if (deviceName) deviceName.textContent = config.portFallback;
+    if (portLabel) portLabel.textContent = config.transportLabel;
+    if (portId) portId.textContent = config.portFallback;
+    if (connectButton) connectButton.querySelector('span')!.textContent = config.connect;
+  }
+
+  async function disconnect() {
+    try {
+      await reader?.cancel();
+      writer?.releaseLock();
+      writer = undefined;
+      await port?.close();
+    } catch {
+      setStatus(config.statusError, 'error');
+    } finally {
+      port = undefined;
+      resetDisconnectedUI();
+      setStatus(config.statusDisconnected, 'warn');
+    }
+  }
+
+  async function openSerialPort() {
+    const selectedPort = await (navigator as SerialNavigator).serial!.requestPort();
+    const rate = Number(baud?.value ?? 115200);
+    await selectedPort.open({ baudRate: rate });
+    return selectedPort;
+  }
+
+  async function connect() {
+    if (port) {
+      await disconnect();
+      return;
+    }
+    if (!('serial' in navigator)) {
+      setStatus(config.unsupportedTitle, 'error');
+      appendLog(`${config.unsupportedBody}\n`, config.logDirectionSys);
+      return;
+    }
+    if (!window.isSecureContext) {
+      setStatus(config.unsupportedTitle, 'error');
+      appendLog(`${config.secureContext}\n`, config.logDirectionSys);
+      return;
+    }
+    try {
+      setStatus(config.statusPermission, 'busy');
+      port = await openSerialPort();
+      setStatus(config.statusOpening, 'busy');
+      writer = port.writable?.getWriter();
+      updatePortLabel(port);
+      setStatus(config.statusConnected, 'ok');
+      if (connectButton) connectButton.querySelector('span')!.textContent = config.disconnect;
+      readLoop(port);
+    } catch {
+      setStatus(config.statusError, 'error');
+    }
+  }
+
+  async function sendLine(text: string) {
+    if (!writer || !text) return;
+    const payload = newline?.checked ? `${text}\r\n` : text;
+    await writer.write(encoder.encode(payload));
+    appendLog(`${payload}\n`, config.logDirectionTx);
+  }
+
+  connectButton?.addEventListener('click', connect);
+  form?.addEventListener('submit', (event) => {
+    event.preventDefault();
+    const text = input?.value ?? '';
+    sendLine(text);
+    if (input) input.value = '';
+  });
+  pauseButton?.addEventListener('click', () => {
+    paused = !paused;
+    if (pauseButton) pauseButton.textContent = paused ? config.resume : config.pause;
+  });
+  clearButton?.addEventListener('click', () => {
+    buffer = '';
+    bytes = 0;
+    lines = 0;
+    if (log) log.textContent = config.emptyLog;
+    updateMetrics();
+  });
+  copyButton?.addEventListener('click', async () => {
+    await navigator.clipboard?.writeText(buffer || log?.textContent || '');
+    const original = copyButton.textContent;
+    copyButton.textContent = config.copied;
+    window.setTimeout(() => {
+      copyButton.textContent = original;
+    }, 1200);
+  });
+  root?.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => {
+    button.addEventListener('click', () => {
+      if (baud) baud.value = button.dataset.preset ?? '115200';
+    });
+  });
+</script>

package/src/tool/webUsbSerialMonitor/entry.ts

@@ -0,0 +1,30 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { WebUsbSerialMonitorUI } from './ui';
+
+export type WebUsbSerialMonitorLocaleContent = ToolLocaleContent<WebUsbSerialMonitorUI>;
+
+export const webUsbSerialMonitor: HardwareToolEntry<WebUsbSerialMonitorUI> = {
+  id: 'web-usb-serial-monitor',
+  icons: {
+    bg: 'mdi:usb-port',
+    fg: 'mdi:console-line',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};
+

package/src/tool/webUsbSerialMonitor/i18n/de.ts

@@ -0,0 +1,241 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { WebUsbSerialMonitorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'web-usb-serieller-monitor';
+const title = 'WebUSB Serieller Monitor';
+const description = 'Verbinden Sie sich vom Browser aus mit USB-Seriell-Hardware, lesen Sie Live-Terminalausgaben, senden Sie Befehle und debuggen Sie Arduino, ESP32, RP2040 und Maker-Boards ohne Installation eines Desktop-Terminals.';
+
+const faqData = [
+  {
+    question: 'Funktioniert dieser serielle Monitor mit Arduino, ESP32 und Raspberry Pi Pico Boards?',
+    answer: 'Ja, wenn das Board eine von Web Serial unterstützte USB-Seriell-Schnittstelle bereitstellt und der Browser Chromium-basiert ist. Gängige Arduino, ESP32, RP2040, CH340, CP210x und FTDI Adapter funktionieren in der Regel, nachdem der Benutzer die Berechtigung erteilt hat.',
+  },
+  {
+    question: 'Warum heißt das WebUSB, wenn es Web Serial verwendet?',
+    answer: 'Die meisten Maker-Boards verbinden sich über USB, aber der Browser-Terminalzugriff wird von der Web Serial API bereitgestellt. WebUSB ist niedriger angesiedelt und nicht die richtige Abstraktion für ein einfaches UART-Terminal.',
+  },
+  {
+    question: 'Kann eine Website ohne Erlaubnis auf meine seriellen Geräte zugreifen?',
+    answer: 'Nein. Der Browser erfordert einen Benutzerklick und eine native Geräteauswahl, bevor eine Seite einen seriellen Port öffnen kann. Dieses Tool speichert keine Terminalprotokolle oder Gerätekennungen.',
+  },
+  {
+    question: 'Welchen Browser sollte ich für ein Web-Seriell-Terminal verwenden?',
+    answer: 'Verwenden Sie Chrome, Edge oder einen anderen Chromium-basierten Browser über HTTPS oder localhost. Firefox, Safari und viele iOS-Browser stellen die Web Serial API nicht zur Verfügung.',
+  },
+  {
+    question: 'Welche Baudrate sollte ich wählen?',
+    answer: 'Wählen Sie die in Ihrer Firmware konfigurierte Baudrate. Arduino-Beispiele verwenden oft 9600 oder 115200, während schnellere Protokolle, Bootloader und hochratige Sensorstreams 230400, 460800 oder 921600 verwenden können.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Das USB-Seriell-Gerät anschließen',
+    text: 'Schließen Sie das Board oder den Adapter an und schließen Sie alle anderen seriellen Terminals, die den Port möglicherweise bereits geöffnet haben.',
+  },
+  {
+    name: 'Die Baudrate auswählen',
+    text: 'Wählen Sie dieselbe Baudrate, die von der Firmware verwendet wird, z. B. 115200 für viele Arduino, ESP32 und RP2040 Sketche.',
+  },
+  {
+    name: 'Browser-Berechtigung erteilen',
+    text: 'Drücken Sie Verbinden, wählen Sie das serielle Gerät im Browser-Auswahldialog und erlauben Sie der Seite, den Port zu öffnen.',
+  },
+  {
+    name: 'Terminaldaten lesen und senden',
+    text: 'Beobachten Sie eingehende Protokolle im Terminal, senden Sie Befehle mit optionalen CRLF-Zeilenenden und löschen oder pausieren Sie die Live-Ausgabe bei Bedarf.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<WebUsbSerialMonitorUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Online Serieller Monitor für USB Maker Hardware',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieser Browser-Seriell-Monitor öffnet einen USB-Seriell-Port direkt aus Chrome oder Edge und streamt dann Text von Mikrocontrollern, USB-UART-Brücken, Entwicklungsboards, Bootloadern, Testvorrichtungen, Sensoren und Laborhardware. Er ist für schnelle Diagnosen konzipiert, wenn Sie eine serielle Konsole benötigen, aber keine Desktop-IDE oder Terminalanwendung installieren möchten.',
+    },
+    {
+      type: 'message',
+      title: 'Browser Berechtigungsgrenze',
+      html: 'Die Seite kann Ihre seriellen Geräte nicht stillschweigend auflisten oder öffnen. Der Zugriff beginnt erst, nachdem Sie Verbinden drücken und einen Port im Browser-Auswahldialog auswählen. Terminaldaten bleiben im aktuellen Tab, es sei denn, Sie kopieren sie selbst.',
+    },
+    {
+      type: 'stats',
+      items: [
+        { value: '9600-921600', label: 'übliche Baud-Voreinstellungen' },
+        { value: 'CRLF', label: 'optionaler Befehlsabschluss' },
+        { value: 'lokal', label: 'Terminalsitzung' },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Wann ein Web-Seriell-Terminal nützlich ist',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Überprüfen von Boot-Meldungen von Arduino, ESP32, ESP8266, RP2040, STM32 oder benutzerdefinierter Firmware.',
+        'Senden von AT-Befehlen an Modem, GPS, LoRa, Wi-Fi, Bluetooth oder Mobilfunkmodule über einen USB-UART-Adapter.',
+        'Lesen von Sensorausgaben von einem Werksprüfstand, Klassenraumlabor, Robotik-Controller oder Tischprototyp.',
+        'Überprüfen, ob ein USB-Seriell-Brückentreiber, Kabel, Board-Stromversorgung und Firmware-Baudrate alle zusammen funktionieren.',
+        'Sammeln eines schnellen Fehlerprotokolls vor dem Einreichen eines Bugs oder der Anfrage von Hardware-Support.',
+      ],
+    },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Web Seriell Monitor',
+          description: 'Am besten für schnellen Support, Unterrichtsanleitungen, Felddiagnosen und Maker-Workflows, bei denen das Öffnen einer URL schneller ist als die Installation einer IDE.',
+        },
+        {
+          title: 'Desktop Terminal',
+          description: 'Besser für Binärprotokolle, lange Aufzeichnungssitzungen, Skripterstellung, Hardware-Flusskontrolle, Makros und Umgebungen, in denen Browser-APIs blockiert sind.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Baudrate und Zeilenende Checkliste',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Einstellung', 'Typische Wahl', 'Was schief geht, wenn es falsch ist'],
+      rows: [
+        ['Baudrate', '115200 für viele moderne Boards, 9600 für ältere Beispiele.', 'Lesbarer Text wird zu zufälligen Symbolen oder es erscheint kein nützliches Protokoll.'],
+        ['Zeilenende', 'CRLF für viele Befehlsparser, kein Ende für rohe Zeichenprotokolle.', 'Befehle werden ignoriert, weil die Firmware auf einen Abschluss wartet.'],
+        ['Exklusiver Portzugriff', 'Arduino Serial Monitor, PuTTY, screen, minicom oder Herstellertools schließen.', 'Der Browser-Auswahldialog öffnet den Port, aber Lesen oder Schreiben schlägt fehl.'],
+        ['Sicherer Kontext', 'HTTPS oder localhost.', 'Die Serial API fehlt selbst in einem unterstützten Browser.'],
+      ],
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Keine serielle Ausgabe?',
+      html: 'Stellen Sie sicher, dass das Board mit Strom versorgt wird und das USB-Kabel Daten unterstützt, nicht nur Laden. Versuchen Sie 9600, 57600 und 115200, wenn Sie die Firmware-Baudrate nicht kennen. Drücken Sie nach dem Verbinden Reset, da viele Boards Boot-Protokolle nur beim Start ausgeben. Schließen Sie andere Software, die den seriellen Port noch besitzen könnte, und installieren Sie den Betriebssystemtreiber für CH340, CP210x, FTDI oder den Board-Hersteller, wenn das Gerät nie erscheint.',
+    },
+    {
+      type: 'title',
+      text: 'Datenschutz, Sicherheit und Grenzen',
+      level: 3,
+    },
+    {
+      type: 'proscons',
+      title: 'Web Serial Stärken und Grenzen',
+      items: [
+        {
+          pro: 'Keine Desktop-Installation für einfache serielle Textdiagnosen.',
+          con: 'Erfordert einen Chromium-basierten Browser und einen sicheren Kontext.',
+        },
+        {
+          pro: 'Browser-Auswahldialog beschränkt den Zugriff auf den von Ihnen gewählten Port.',
+          con: 'Nicht für binäre Protokollanalysatoren oder lange unbeaufsichtigte Aufzeichnungen gedacht.',
+        },
+        {
+          pro: 'Funktioniert gut für Textprotokolle, Eingabeaufforderungen und schnelle Hardwareprüfungen.',
+          con: 'Einige Unternehmensrichtlinien, mobile Browser und Betriebssysteme blockieren Web Serial.',
+        },
+      ],
+    },
+  ],
+  ui: {
+    unsupportedTitle: 'Web Serial ist nicht verfügbar',
+    unsupportedBody: 'Verwenden Sie Chrome oder Edge über HTTPS oder localhost und stellen Sie sicher, dass Ihr Gerät eine USB-Seriell-Schnittstelle bereitstellt.',
+    secureContext: 'Web Serial erfordert HTTPS oder localhost. Laden Sie diese Seite von einer sicheren Herkunft neu und versuchen Sie es erneut.',
+    statusIdle: 'Wählen Sie eine Baudrate und verbinden Sie dann ein USB-Seriell-Gerät',
+    statusPermission: 'Warten auf den Browser-Seriell-Port-Auswahldialog',
+    statusOpening: 'Seriellen Port öffnen',
+    statusConnected: 'Serieller Port verbunden',
+    statusDisconnected: 'Serieller Port getrennt',
+    statusError: 'Serielle Verbindung fehlgeschlagen',
+    connect: 'Seriell verbinden',
+    disconnect: 'Trennen',
+    send: 'Senden',
+    clear: 'Löschen',
+    pause: 'Pause',
+    resume: 'Fortsetzen',
+    baudRate: 'Baudrate',
+    newline: 'CRLF anhängen',
+    inputPlaceholder: 'Befehl eingeben, dann Enter drücken',
+    portFallback: 'Kein Port ausgewählt',
+    portLabel: 'Port-Identität',
+    connectedDeviceLabel: 'Verbundenes Gerät',
+    deviceNameFallback: 'USB-Seriell-Gerät',
+    transportLabel: 'Web Serial Verbindung',
+    bytesLabel: 'Bytes',
+    linesLabel: 'Zeilen',
+    privacyTitle: 'Berechtigungsgesteuert',
+    privacyBody: 'Der Browser zeigt nur das von Ihnen ausgewählte serielle Gerät an. Protokolle bleiben in diesem Tab, es sei denn, Sie kopieren sie.',
+    emptyLog: 'Die Terminalausgabe erscheint hier, nachdem Sie ein serielles Gerät verbunden haben.',
+    copied: 'Kopiert',
+    copyLog: 'Kopieren',
+    presetSlow: '9600',
+    presetArduino: '115200',
+    presetFast: '921600',
+    terminalLabel: 'Live-Terminal',
+    unknownUsbId: 'N/A',
+    logDirectionRx: 'rx',
+    logDirectionTx: 'tx',
+    logDirectionSys: 'sys',
+    vidPrefix: 'VID ',
+    pidSeparator: ' / PID ',
+    baudUnit: ' Baud',
+    vendorFtdi: 'FTDI USB Serial',
+    vendorSilabs: 'Silicon Labs CP210x',
+    vendorCh340: 'CH340 USB Serial',
+    vendorArduinoUsb: 'Arduino USB Serial',
+    vendorAdafruit: 'Adafruit USB Serial',
+    vendorRp2040: 'Raspberry Pi RP2040',
+    vendorEspressif: 'Espressif USB Serial',
+    vendorOpenSource: 'Open Source USB Serial',
+  },
+};