@jjlmoya/utils-hardware 1.25.0 → 1.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-hardware",
-    "version": "1.25.0",
+    "version": "1.27.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -15,10 +15,12 @@ import { upsRuntimeCalculator } from '../tool/upsRuntimeCalculator/index';
 import { stereoAudioTest } from '../tool/stereoAudioTest/index';
 import { webBluetoothBleScanner } from '../tool/webBluetoothBleScanner/index';
 import { keyboardChatterTest } from '../tool/keyboardChatterTest/index';
+import { webUsbSerialMonitor } from '../tool/webUsbSerialMonitor/index';
+import { usbPowerBudgetCalculator } from '../tool/usbPowerBudgetCalculator/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, stereoAudioTest, webBluetoothBleScanner],
+  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -30,6 +30,10 @@ export { webBluetoothBleScanner } from './tool/webBluetoothBleScanner/entry';
 export type { WebBluetoothBleScannerLocaleContent } from './tool/webBluetoothBleScanner/entry';
 export { keyboardChatterTest } from './tool/keyboardChatterTest/entry';
 export type { KeyboardChatterTestLocaleContent } from './tool/keyboardChatterTest/entry';
+export { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
+export type { WebUsbSerialMonitorLocaleContent } from './tool/webUsbSerialMonitor/entry';
+export { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry';
+export type { UsbPowerBudgetCalculatorLocaleContent } from './tool/usbPowerBudgetCalculator/entry';
 export { hardwareCategory } from './category';
 import { estimadorSaludBateria } from './tool/batteryHealthEstimator/entry';
 import { pixelesPantalla } from './tool/deadPixelTest/entry';
@@ -47,4 +51,6 @@ import { upsRuntimeCalculator } from './tool/upsRuntimeCalculator/entry';
 import { stereoAudioTest } from './tool/stereoAudioTest/entry';
 import { webBluetoothBleScanner } from './tool/webBluetoothBleScanner/entry';
 import { keyboardChatterTest } from './tool/keyboardChatterTest/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, stereoAudioTest, webBluetoothBleScanner];
+import { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
+import { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry';
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];

package/src/index.ts

@@ -33,3 +33,5 @@ export { UPS_RUNTIME_CALCULATOR_TOOL } from './tool/upsRuntimeCalculator/index';
 export { STEREO_AUDIO_TEST_TOOL } from './tool/stereoAudioTest/index';
 export { WEB_BLUETOOTH_BLE_SCANNER_TOOL } from './tool/webBluetoothBleScanner/index';
 export { KEYBOARD_CHATTER_TEST_TOOL } from './tool/keyboardChatterTest/index';
+export { WEB_USB_SERIAL_MONITOR_TOOL } from './tool/webUsbSerialMonitor/index';
+export { USB_POWER_BUDGET_CALCULATOR_TOOL } from './tool/usbPowerBudgetCalculator/index';

package/src/tests/locale_completeness.test.ts

@@ -22,7 +22,7 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(16);
+    expect(ALL_TOOLS.length).toBe(18);
   });
 });
 

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { hardwareCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have all tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(16);
+      expect(ALL_TOOLS.length).toBe(18);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/usbPowerBudgetCalculator/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import type { KnownLocale } from '../../types';
+import { usbPowerBudgetCalculator } from './index';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await usbPowerBudgetCalculator.i18n[locale]?.();
+---
+
+{content && content.bibliography.length > 0 && <SharedBibliography links={content.bibliography} />}

package/src/tool/usbPowerBudgetCalculator/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'USB-IF - USB Type-C Cable and Connector Specification',
+    url: 'https://www.usb.org/document-library/usb-type-cr-cable-and-connector-specification-release-24',
+  },
+  {
+    name: 'USB-IF - USB Power Delivery Specification',
+    url: 'https://www.usb.org/document-library/usb-power-delivery',
+  },
+  {
+    name: 'IPC - Current carrying capacity and voltage drop fundamentals',
+    url: 'https://www.ipc.org/',
+  },
+];

package/src/tool/usbPowerBudgetCalculator/component.astro

@@ -0,0 +1,266 @@
+---
+import type { KnownLocale } from '../../types';
+import type { UsbPowerBudgetCalculatorUI } from './ui';
+import { usbPowerProfiles } from './logic';
+import './usb-power-budget-calculator.css';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as UsbPowerBudgetCalculatorUI;
+const strings = JSON.stringify(t);
+const profiles = JSON.stringify(usbPowerProfiles);
+---
+
+<div class="upb-shell" id="upb-root" data-ui={strings} data-profiles={profiles} data-status="safe">
+  <div class="upb-board">
+    <div class="upb-board-top">
+      <span class="upb-eyebrow">{t.boardEyebrow}</span>
+      <div class="upb-unit-switch" role="group" aria-label="Unit system">
+        <button type="button" class="is-active" data-unit="metric">{t.metricUnits}</button>
+        <button type="button" data-unit="imperial">{t.imperialUnits}</button>
+      </div>
+    </div>
+
+    <div class="upb-hero" aria-live="polite">
+      <div class="upb-socket upb-source">
+        <span>{t.sourceSocket}</span>
+        <strong id="upb-source-power">15.0 W</strong>
+        <small id="upb-available-power">12.0 W usable</small>
+      </div>
+
+      <div class="upb-cable-stage" aria-label="Animated USB power cable">
+        <svg class="upb-cable-art" viewBox="0 0 520 210" role="img" aria-label="USB cable carrying power from source to device">
+          <defs>
+            <filter id="upb-glow" x="-20%" y="-60%" width="140%" height="220%">
+              <feGaussianBlur stdDeviation="6" result="blur" />
+              <feMerge>
+                <feMergeNode in="blur" />
+                <feMergeNode in="SourceGraphic" />
+              </feMerge>
+            </filter>
+          </defs>
+          <path class="upb-cable-shadow" d="M58 118 C128 38 202 38 260 118 S394 198 462 118" />
+          <path class="upb-cable-body" d="M58 118 C128 38 202 38 260 118 S394 198 462 118" />
+          <path class="upb-cable-core" d="M58 118 C128 38 202 38 260 118 S394 198 462 118" />
+          <path class="upb-cable-spark" d="M58 118 C128 38 202 38 260 118 S394 198 462 118" />
+          <g class="upb-plug upb-plug-left">
+            <rect x="18" y="86" width="54" height="64" rx="14" />
+            <rect x="0" y="100" width="24" height="36" rx="7" />
+            <line x1="14" y1="109" x2="14" y2="127" />
+          </g>
+          <g class="upb-plug upb-plug-right">
+            <rect x="448" y="86" width="54" height="64" rx="14" />
+            <rect x="496" y="100" width="24" height="36" rx="7" />
+            <circle cx="506" cy="118" r="5" />
+          </g>
+        </svg>
+        <span class="upb-flow-chip" id="upb-drop-chip">0.00 V {t.cableLane}</span>
+        <span class="upb-flow-label">{t.energyFlow}</span>
+      </div>
+
+      <div class="upb-socket upb-load">
+        <span>{t.deviceSocket}</span>
+        <strong id="upb-required-power">15.0 W</strong>
+        <small id="upb-device-voltage">4.36 V</small>
+      </div>
+    </div>
+
+    <div class="upb-status-row">
+      <div class="upb-status" id="upb-status" data-status="safe">
+        <span id="upb-status-text">{t.safeStatus}</span>
+        <p id="upb-advice">{t.safeAdvice}</p>
+      </div>
+      <div class="upb-gauge">
+        <div class="upb-gauge-copy">
+          <span>{t.utilization}</span>
+          <strong id="upb-utilization">100%</strong>
+        </div>
+        <div class="upb-gauge-track"><i id="upb-utilization-bar"></i></div>
+      </div>
+    </div>
+  </div>
+
+  <div class="upb-console">
+    <label class="upb-field upb-wide">
+      <span>{t.profileLabel}</span>
+      <select id="upb-profile">
+        {Object.entries(usbPowerProfiles).map(([key, profile]) => <option value={key}>{profile.label}</option>)}
+      </select>
+    </label>
+
+    <div class="upb-field-pair">
+      <label class="upb-field">
+        <span>{t.voltageLabel}</span>
+        <input id="upb-voltage" type="number" min="3" max="48" step="0.1" value="5" />
+      </label>
+      <label class="upb-field">
+        <span>{t.currentLabel}</span>
+        <input id="upb-current" type="number" min="0.1" max="10" step="0.1" value="3" />
+      </label>
+    </div>
+
+    <div class="upb-field-pair">
+      <label class="upb-field">
+        <span id="upb-length-label">{t.cableLengthLabel} (m)</span>
+        <input id="upb-length" type="number" min="0.1" max="10" step="0.1" value="1.5" />
+      </label>
+      <label class="upb-field">
+        <span>{t.wireGaugeLabel}</span>
+        <select id="upb-awg">
+          <option value="20">20 AWG</option>
+          <option value="22">22 AWG</option>
+          <option value="24">24 AWG</option>
+          <option value="26">26 AWG</option>
+          <option value="28" selected>28 AWG</option>
+          <option value="30">30 AWG</option>
+        </select>
+      </label>
+    </div>
+
+    <div class="upb-field-pair">
+      <label class="upb-field">
+        <span>{t.deviceLoadLabel}</span>
+        <input id="upb-load" type="number" min="0.1" max="240" step="0.1" value="7.5" />
+      </label>
+      <label class="upb-field">
+        <span>{t.devicesLabel}</span>
+        <input id="upb-devices" type="number" min="1" max="12" step="1" value="2" />
+      </label>
+    </div>
+
+    <label class="upb-field">
+      <span>{t.headroomLabel}</span>
+      <input id="upb-headroom" type="number" min="0" max="50" step="5" value="20" />
+    </label>
+
+    <div class="upb-metrics">
+      <div><span>{t.headroom}</span><strong id="upb-headroom-watts">-3.0 W</strong></div>
+      <div><span>{t.cableDrop}</span><strong id="upb-cable-drop">0.64 V</strong></div>
+      <div><span>{t.sourcePower}</span><strong id="upb-source-power-small">15.0 W</strong></div>
+      <div><span>{t.requiredPower}</span><strong id="upb-required-power-small">15.0 W</strong></div>
+    </div>
+  </div>
+
+  <script>
+    import { calculateUsbPowerBudget, feetToMeters, metersToFeet } from './logic';
+
+    const root = document.getElementById('upb-root') as HTMLElement | null;
+    const ui = JSON.parse(root?.dataset.ui ?? '{}') as Record<string, string>;
+    const profiles = JSON.parse(root?.dataset.profiles ?? '{}') as Record<string, { voltage: number; current: number }>;
+    const profile = document.getElementById('upb-profile') as HTMLSelectElement | null;
+    const voltage = document.getElementById('upb-voltage') as HTMLInputElement | null;
+    const current = document.getElementById('upb-current') as HTMLInputElement | null;
+    const length = document.getElementById('upb-length') as HTMLInputElement | null;
+    const lengthLabel = document.getElementById('upb-length-label');
+    const awg = document.getElementById('upb-awg') as HTMLSelectElement | null;
+    const load = document.getElementById('upb-load') as HTMLInputElement | null;
+    const devices = document.getElementById('upb-devices') as HTMLInputElement | null;
+    const headroom = document.getElementById('upb-headroom') as HTMLInputElement | null;
+    const unitButtons = Array.from(document.querySelectorAll<HTMLButtonElement>('.upb-unit-switch button'));
+    let unitSystem = 'metric';
+
+    const els = {
+      sourcePower: document.getElementById('upb-source-power'),
+      requiredPower: document.getElementById('upb-required-power'),
+      dropChip: document.getElementById('upb-drop-chip'),
+      status: document.getElementById('upb-status') as HTMLElement | null,
+      statusText: document.getElementById('upb-status-text'),
+      advice: document.getElementById('upb-advice'),
+      deviceVoltage: document.getElementById('upb-device-voltage'),
+      headroomWatts: document.getElementById('upb-headroom-watts'),
+      utilization: document.getElementById('upb-utilization'),
+      cableDrop: document.getElementById('upb-cable-drop'),
+      availablePower: document.getElementById('upb-available-power'),
+      sourcePowerSmall: document.getElementById('upb-source-power-small'),
+      requiredPowerSmall: document.getElementById('upb-required-power-small'),
+      utilizationBar: document.getElementById('upb-utilization-bar') as HTMLElement | null,
+    };
+
+    function numberValue(input: HTMLInputElement | HTMLSelectElement | null, fallback: number): number {
+      const value = Number(input?.value);
+      return Number.isFinite(value) ? value : fallback;
+    }
+
+    function setLengthLabel() {
+      if (!lengthLabel) return;
+      lengthLabel.textContent = `${ui.cableLengthLabel} (${unitSystem === 'metric' ? 'm' : 'ft'})`;
+    }
+
+    function formatWatts(value: number) {
+      return `${value.toFixed(1)} W`;
+    }
+
+    function setText(el: HTMLElement | null, value: string) {
+      if (el) el.textContent = value;
+    }
+
+    function applyResult(key: string, result: ReturnType<typeof calculateUsbPowerBudget>) {
+      setText(els.statusText, ui[`${key}Status`] ?? '');
+      setText(els.advice, ui[`${key}Advice`] ?? '');
+      setText(els.sourcePower, formatWatts(result.sourceWatts));
+      setText(els.sourcePowerSmall, formatWatts(result.sourceWatts));
+      setText(els.requiredPower, formatWatts(result.requiredWatts));
+      setText(els.requiredPowerSmall, formatWatts(result.requiredWatts));
+      setText(els.availablePower, `${formatWatts(result.availableWatts)} ${ui.reservedLabel}`);
+      setText(els.dropChip, `${result.cableDropVolts.toFixed(2)} V ${ui.cableLane}`);
+      setText(els.deviceVoltage, `${result.deviceEndVoltage.toFixed(2)} V`);
+      setText(els.headroomWatts, formatWatts(result.headroomWatts));
+      setText(els.utilization, `${Math.round(result.utilizationPercent)}%`);
+      setText(els.cableDrop, `${result.cableDropVolts.toFixed(2)} V`);
+      if (els.status) els.status.dataset.status = result.status;
+      if (root) root.dataset.status = result.status;
+      if (els.utilizationBar) els.utilizationBar.style.width = `${Math.min(140, Math.max(0, result.utilizationPercent))}%`;
+    }
+
+    function update() {
+      const cableLengthMeters = unitSystem === 'metric'
+        ? numberValue(length, 1.5)
+        : feetToMeters(numberValue(length, 5));
+      const result = calculateUsbPowerBudget({
+        sourceVoltage: numberValue(voltage, 5),
+        sourceCurrent: numberValue(current, 3),
+        cableLengthMeters,
+        wireGaugeAwg: numberValue(awg, 28),
+        deviceLoadWatts: numberValue(load, 7.5),
+        devices: numberValue(devices, 2),
+        headroomPercent: numberValue(headroom, 20),
+      });
+
+      let key = 'over';
+      if (result.status === 'safe') key = 'safe';
+      else if (result.status === 'tight') key = 'tight';
+      applyResult(key, result);
+    }
+
+    profile?.addEventListener('change', () => {
+      const selected = profiles[profile.value];
+      if (!selected || !voltage || !current) return;
+      voltage.value = String(selected.voltage);
+      current.value = String(selected.current);
+      update();
+    });
+
+    unitButtons.forEach((button) => {
+      button.addEventListener('click', () => {
+        const next = button.dataset.unit ?? 'metric';
+        if (next === unitSystem || !length) return;
+        const currentLength = numberValue(length, unitSystem === 'metric' ? 1.5 : 5);
+        length.value = next === 'metric'
+          ? feetToMeters(currentLength).toFixed(2)
+          : metersToFeet(currentLength).toFixed(1);
+        unitSystem = next;
+        unitButtons.forEach((item) => item.classList.toggle('is-active', item === button));
+        setLengthLabel();
+        update();
+      });
+    });
+
+    [voltage, current, length, awg, load, devices, headroom].forEach((input) => input?.addEventListener('input', update));
+    setLengthLabel();
+    update();
+  </script>
+</div>

package/src/tool/usbPowerBudgetCalculator/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { UsbPowerBudgetCalculatorUI } from './ui';
+
+export type UsbPowerBudgetCalculatorLocaleContent = ToolLocaleContent<UsbPowerBudgetCalculatorUI>;
+
+export const usbPowerBudgetCalculator: HardwareToolEntry<UsbPowerBudgetCalculatorUI> = {
+  id: 'usb-power-budget-calculator',
+  icons: {
+    bg: 'mdi:usb-port',
+    fg: 'mdi:lightning-bolt',
+  },
+  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/usbPowerBudgetCalculator/i18n/de.ts

@@ -0,0 +1,169 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { UsbPowerBudgetCalculatorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'usb-leistungsbudget-rechner';
+const title = 'USB Leistungsbudget Rechner';
+const description = 'Prüfen Sie, ob ein USB-Anschluss, Ladegerät, Hub, Kabel oder USB-C PD-Profil Ihre Geräte nach Reserve und Kabelspannungsabfall sicher mit Strom versorgen kann.';
+
+const faqData = [
+  {
+    question: 'Wie erkenne ich, ob ein USB-Anschluss mein Gerät mit Strom versorgen kann?',
+    answer: 'Vergleichen Sie die Gesamtleistung des Geräts mit der USB-Quellleistung, reservieren Sie dann Sicherheitsmarge und schätzen Sie den Kabelspannungsabfall. Ein Setup kann scheitern, selbst wenn die nominale Wattzahl hoch erscheint, wenn das Kabel lang, dünn oder mit hohem Strom bei 5 Volt betrieben wird.',
+  },
+  {
+    question: 'Warum ist die Kabellänge für USB-Strom wichtig?',
+    answer: 'Strom, der durch Kupfer fließt, erzeugt Spannungsabfall. Lange Kabel und dünne Leiter haben mehr Widerstand, sodass das Gerät möglicherweise weniger Spannung erhält als das Ladegerät liefert. Dies ist besonders wichtig für Raspberry Pi-Boards, Festplatten, LED-Streifen, Docks und busbetriebene Hubs.',
+  },
+  {
+    question: 'Welche Sicherheitsmarge sollte ich verwenden?',
+    answer: 'Verwenden Sie mindestens 20 Prozent für normale Elektronik, 30 Prozent für Motoren, Laufwerke, Funkgeräte oder Boards mit Spitzenlasten und mehr, wenn die Adapterqualität unbekannt ist oder das Gerät kontinuierlich laufen muss.',
+  },
+  {
+    question: 'Kann dies USB-C PD-Verhandlungstests ersetzen?',
+    answer: 'Nein. Der Rechner prüft das elektrische Budget. Er verifiziert nicht, ob ein Ladegerät, Kabel-e-Marker, Gerät oder Hub tatsächlich ein bestimmtes Power-Delivery-Profil aushandelt.',
+  },
+];
+
+const howToData = [
+  { name: 'Quellprofil wählen', text: 'Wählen Sie ein gängiges USB- oder USB-C PD-Profil oder bearbeiten Sie Spannung und Strom manuell.' },
+  { name: 'Kabel beschreiben', text: 'Geben Sie Kabellänge und Leiterquerschnitt ein. Dünne Drähte mit hoher AWG-Zahl verursachen mehr Spannungsabfall.' },
+  { name: 'Last hinzufügen', text: 'Geben Sie eine Gerätelast in Watt und die Anzahl der Geräte ein, die dieselbe Quelle teilen.' },
+  { name: 'Status ablesen', text: 'Verwenden Sie Status, Kabelabfall, Endspannung, Auslastung und Reserve, um zu entscheiden, ob das Setup sicher ist.' },
+];
+
+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: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<UsbPowerBudgetCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'USB-Strom ist ein Budget, kein Etikett', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Ein USB-Ladegerät mit 15 W, 45 W oder 100 W beschreibt, was die Quelle unter den richtigen Bedingungen bieten kann. Ihr Gerät sieht nur das Ergebnis nach Protokollverhandlung, Strombegrenzungen, Kabelwiderstand, Steckerqualität, Hub-Verlusten und Lastspitzen. Dieser Rechner konzentriert sich auf die praktische elektrische Frage: Ist nach Kabelabfall und Reservemarge genug Strom für die Hardware vorhanden, die Sie betreiben möchten?',
+    },
+    {
+      type: 'stats',
+      items: [
+        { label: 'USB 2.0 Standardstrom', value: '0,5 A' },
+        { label: 'USB-C Standardmaximum bei 5 V', value: '3 A' },
+        { label: 'Empfohlene Reserve', value: '20%+' },
+      ],
+    },
+    { type: 'title', text: 'So interpretieren Sie das Ergebnis', level: 3 },
+    {
+      type: 'table',
+      headers: ['Status', 'Bedeutung', 'Bester nächster Schritt'],
+      rows: [
+        ['Sicher', 'Die Last passt nach der gewählten Reserve in die Quellleistung und die geschätzte Gerätespannung bleibt gesund.', 'Setup verwenden, aber auf Wärme achten, wenn der Adapter klein oder eingeschlossen ist.'],
+        ['Knapp', 'Die Last liegt nahe an der reservierten Grenze oder der Kabelabfall wird bedeutsam.', 'Kabel kürzen, dickere Leiter wählen, Last reduzieren oder auf ein höheres Leistungsprofil umsteigen.'],
+        ['Über Budget', 'Die Last überschreitet die nutzbare Quellleistung oder die geräteseitige Spannung ist wahrscheinlich zu niedrig.', 'Stärkeres Ladegerät, aktiven Hub, kürzeres Kabel oder ein Gerät verwenden, das eine höhere USB-C PD-Spannung aushandelt.'],
+      ],
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Wenn die Wattzahl ausreicht, das Gerät aber trotzdem zurücksetzt',
+      html: '<p>Der Anlaufstrom kann viel höher sein als die durchschnittliche Wattzahl auf einem Geräteetikett. Eine 5-V-Versorgung verliert bei gleicher Wattzahl schneller Spannung als ein 20-V-PD-Profil, da sie mehr Strom führen muss. Viele billige Kabel verwenden dünne Stromleiter, selbst wenn der Außenmantel robust aussieht, und busbetriebene Hubs teilen ein Upstream-Budget auf alle nachgeschalteten Geräte auf.</p>',
+    },
+    { type: 'title', text: 'Kabelspannungsabfall einfach erklärt', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Spannungsabfall ist der Verlust, der entsteht, wenn Strom durch den Kabelwiderstand fließt. USB-Strom hat zwei Leiter im Strompfad, daher verwendet der Rechner die Hin- und Rückleitungslänge. Ein ein Meter langes Kabel ist elektrisch zwei Meter Kupfer für die Stromschleife. Niedrigere AWG-Zahlen sind dicker und in der Regel besser für hohe Stromlasten.',
+    },
+    {
+      type: 'comparative',
+      items: [
+        { title: 'Kurzes dickes Kabel', description: 'Am besten für Raspberry Pi-Boards, SSD-Gehäuse, Entwicklungskits und USB-C-Docks mit Spitzenstromaufnahme.' },
+        { title: 'Langes dünnes Kabel', description: 'Akzeptabel für Sensoren mit geringem Stromverbrauch oder langsames Laden, aber riskant für Laufwerke, LED-Lasten und Compute-Boards.' },
+        { title: 'Höhere Spannung PD', description: 'Reduziert den Strom für die gleiche Wattzahl, was den Kabelverlust senkt, aber nur, wenn Quelle, Kabel und Gerät dies aushandeln.' },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Praktische Regel',
+      html: 'Wenn der Rechner sagt, dass das Setup knapp ist, behandeln Sie es als Feldwarnung. USB-Ausfälle erscheinen oft als zufällige Verbindungsabbrüche, Unterspannungsausfälle, langsames Laden, verrauschtes Audio oder Speicherfehler, bevor sie wie ein klares Stromproblem aussehen.',
+    },
+    {
+      type: 'summary',
+      title: 'Wofür dieser Rechner am besten geeignet ist',
+      items: [
+        'Planung von USB-Hubs, Einplatinencomputern, externen Laufwerken, Entwicklungsboards, Leuchten, Lüftern und kleinen Laboraufbauten.',
+        'Vergleich von USB 2.0-, USB 3.x-, USB-C- und USB-Power-Delivery-Quellprofilen.',
+        'Abschätzung, ob ein Kabel zu lang oder zu dünn für eine Last ist.',
+        'Wahl einer sinnvollen Reserve vor dem Kauf eines Ladegeräts oder aktiven Hubs.',
+      ],
+    },
+  ],
+  ui: {
+    profileLabel: 'USB-Quellprofil',
+    metricUnits: 'Metrisch',
+    imperialUnits: 'US',
+    voltageLabel: 'Quellspannung (V)',
+    currentLabel: 'Quellstrom (A)',
+    cableLengthLabel: 'Kabellänge',
+    wireGaugeLabel: 'Leiterquerschnitt',
+    deviceLoadLabel: 'Last pro Gerät (W)',
+    devicesLabel: 'Geräte',
+    headroomLabel: 'Reserve (%)',
+    sourcePower: 'Quellleistung',
+    requiredPower: 'Benötigte Leistung',
+    cableDrop: 'Kabelabfall',
+    deviceVoltage: 'Gerätespannung',
+    headroom: 'Reserve',
+    utilization: 'Auslastung',
+    safeStatus: 'Leistungsbudget sieht sicher aus',
+    tightStatus: 'Leistungsbudget ist knapp',
+    overStatus: 'Über Budget oder Spannungsabfall-Risiko',
+    safeAdvice: 'Die Last passt mit der gewählten Reserve. Qualitativ hochwertiges Kabel verwenden und Wärme bei langen Betriebszeiten prüfen.',
+    tightAdvice: 'Sie sind nahe am Limit. Kabellänge reduzieren, dickere Leiter verwenden, Last senken oder ein stärkeres Profil wählen.',
+    overAdvice: 'Dieses Setup wird wahrscheinlich unter Spannungseinbrüche oder Drosselung fallen. Aktiven Hub, stärkeres Netzteil oder ein USB-C PD-Profil mit höherer Spannung verwenden.',
+    busLane: 'USB-Quelle',
+    loadLane: 'Gerätelast',
+    cableLane: 'Abfall',
+    boardEyebrow: 'Live USB-Strompfad',
+    sourceSocket: 'Versorgungsbuchse',
+    deviceSocket: 'Hardware-Last',
+    energyFlow: 'Energiefluss',
+    reservedLabel: 'nutzbar nach Reserve',
+  },
+};