@jjlmoya/utils-hardware 1.26.0 → 1.28.0

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',
+  },
+};

package/src/tool/usbPowerBudgetCalculator/i18n/en.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-power-budget-calculator';
+const title = 'USB Power Budget Calculator';
+const description = 'Check whether a USB port, charger, hub, cable, or USB-C PD profile can safely power your devices after headroom and cable voltage drop.';
+
+const faqData = [
+  {
+    question: 'How do I know if a USB port can power my device?',
+    answer: 'Compare the total device wattage with the USB source wattage, then reserve headroom and estimate cable voltage drop. A setup can fail even when nominal watts look high if the cable is long, thin, or carrying high current at 5 volts.',
+  },
+  {
+    question: 'Why does cable length matter for USB power?',
+    answer: 'Current flowing through copper creates voltage drop. Long cables and thin conductors have more resistance, so the device may receive less voltage than the charger provides. This is especially important for Raspberry Pi boards, hard drives, LED strips, docks, and bus-powered hubs.',
+  },
+  {
+    question: 'What headroom should I use?',
+    answer: 'Use at least 20 percent for normal electronics, 30 percent for motors, drives, radios, or boards with burst loads, and more if the adapter quality is unknown or the device must run continuously.',
+  },
+  {
+    question: 'Can this replace USB-C PD negotiation testing?',
+    answer: 'No. The calculator checks the electrical budget. It does not verify whether a charger, cable e-marker, device, or hub actually negotiates a specific Power Delivery profile.',
+  },
+];
+
+const howToData = [
+  { name: 'Choose a source profile', text: 'Select a common USB or USB-C PD profile, or edit voltage and current manually.' },
+  { name: 'Describe the cable', text: 'Enter cable length and conductor gauge. Thin high-number AWG wires cause more voltage drop.' },
+  { name: 'Add the load', text: 'Enter one device load in watts and the number of devices sharing the same source.' },
+  { name: 'Read the status', text: 'Use the status, cable drop, end voltage, utilization, and headroom to decide whether the setup is safe.' },
+];
+
+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: 'en',
+};
+
+export const content: ToolLocaleContent<UsbPowerBudgetCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'USB power is a budget, not a label', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'A USB charger marked 15 W, 45 W, or 100 W describes what the source can offer under the right conditions. Your device only sees the result after protocol negotiation, current limits, cable resistance, connector quality, hub losses, and load spikes. This calculator focuses on the practical electrical question: after cable drop and reserve margin, is there enough power left for the hardware you want to run?',
+    },
+    {
+      type: 'stats',
+      items: [
+        { label: 'USB 2.0 default current', value: '0.5 A' },
+        { label: 'USB-C default maximum at 5 V', value: '3 A' },
+        { label: 'Recommended reserve', value: '20%+' },
+      ],
+    },
+    { type: 'title', text: 'How to interpret the result', level: 3 },
+    {
+      type: 'table',
+      headers: ['Status', 'Meaning', 'Best next step'],
+      rows: [
+        ['Safe', 'The load fits inside the source rating after the selected reserve, and the estimated device voltage remains healthy.', 'Use the setup, but keep an eye on heat if the adapter is small or enclosed.'],
+        ['Tight', 'The load is close to the reserved limit or the cable drop is becoming meaningful.', 'Shorten the cable, choose thicker conductors, reduce the load, or move to a higher power profile.'],
+        ['Over budget', 'The load exceeds the usable source power or the device-end voltage is likely too low.', 'Use a stronger charger, powered hub, shorter cable, or a device that negotiates a higher USB-C PD voltage.'],
+      ],
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'When watts are enough but the device still resets',
+      html: '<p>Startup current can be much higher than the average wattage printed on a device label. A 5 V supply loses voltage faster than a 20 V PD profile for the same wattage because it must carry more current. Many low-cost cables use thin power conductors even when the outer jacket looks substantial, and bus-powered hubs share one upstream budget across every downstream device.</p>',
+    },
+    { type: 'title', text: 'Cable voltage drop in plain terms', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Voltage drop is the loss created when current flows through cable resistance. USB power has two conductors in the power path, so the calculator uses round-trip length. A one-meter cable is electrically two meters of copper for the power loop. Lower AWG numbers are thicker and usually better for high current loads.',
+    },
+    {
+      type: 'comparative',
+      items: [
+        { title: 'Short thick cable', description: 'Best for Raspberry Pi boards, SSD enclosures, development kits, and USB-C docks that draw burst current.' },
+        { title: 'Long thin cable', description: 'Acceptable for low power sensors or charging slowly, but risky for drives, LED loads, and compute boards.' },
+        { title: 'Higher voltage PD', description: 'Reduces current for the same wattage, which lowers cable loss, but only if the source, cable, and device negotiate it.' },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Practical rule',
+      html: 'If the calculator says the setup is tight, treat it as a field warning. USB failures often appear as random disconnects, brownouts, slow charging, noisy audio, or storage errors before they look like a clear power problem.',
+    },
+    {
+      type: 'summary',
+      title: 'What this calculator is best for',
+      items: [
+        'Planning USB hubs, single-board computers, external drives, development boards, lights, fans, and small lab setups.',
+        'Comparing USB 2.0, USB 3.x, USB-C, and USB Power Delivery source profiles.',
+        'Estimating whether a cable is too long or too thin for a load.',
+        'Choosing a sensible reserve before buying a charger or powered hub.',
+      ],
+    },
+  ],
+  ui: {
+    profileLabel: 'USB source profile',
+    metricUnits: 'Metric',
+    imperialUnits: 'US',
+    voltageLabel: 'Source voltage (V)',
+    currentLabel: 'Source current (A)',
+    cableLengthLabel: 'Cable length',
+    wireGaugeLabel: 'Power wire gauge',
+    deviceLoadLabel: 'Load per device (W)',
+    devicesLabel: 'Devices',
+    headroomLabel: 'Reserve headroom (%)',
+    sourcePower: 'Source power',
+    requiredPower: 'Required power',
+    cableDrop: 'Cable drop',
+    deviceVoltage: 'Device voltage',
+    headroom: 'Headroom',
+    utilization: 'Utilization',
+    safeStatus: 'Power budget looks safe',
+    tightStatus: 'Power budget is tight',
+    overStatus: 'Over budget or voltage drop risk',
+    safeAdvice: 'The load fits with the selected reserve. Use a quality cable and check heat during long runs.',
+    tightAdvice: 'You are close to the limit. Reduce cable length, use thicker conductors, lower the load, or select a stronger profile.',
+    overAdvice: 'This setup is likely to brown out or throttle. Use a powered hub, stronger adapter, or a higher voltage USB-C PD profile.',
+    busLane: 'USB source',
+    loadLane: 'Device load',
+    cableLane: 'drop',
+    boardEyebrow: 'Live USB power path',
+    sourceSocket: 'Supply socket',
+    deviceSocket: 'Hardware load',
+    energyFlow: 'energy flow',
+    reservedLabel: 'usable after reserve',
+  },
+};