@jjlmoya/utils-hardware 1.27.0 → 1.29.0

package/src/tool/subwooferCrossoverTest/component.astro

@@ -0,0 +1,253 @@
+---
+import type { KnownLocale } from '../../types';
+import type { SubwooferCrossoverTestUI } from './ui';
+import { Icon } from 'astro-icon/components';
+import './subwoofer-crossover-test.css';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as SubwooferCrossoverTestUI;
+
+const S = JSON.stringify({
+  ready: t.statusReady,
+  running: t.statusRunning,
+  stopped: t.statusStopped,
+  start: t.start,
+  stop: t.stop,
+  safeStart: t.safeStart,
+  dropoutEmpty: t.dropoutEmpty,
+  crossoverEstimate: t.crossoverEstimate,
+});
+---
+
+<div id="sct-root" class="sct-shell" data-s={S}>
+  <section class="sct-console" aria-label={t.sweepLabel}>
+    <div class="sct-stage">
+      <div class="sct-orbit" aria-hidden="true">
+        <div class="sct-ring sct-ring-a"></div>
+        <div class="sct-ring sct-ring-b"></div>
+        <div class="sct-driver">
+          <Icon name="mdi:speaker" class="sct-speaker-icon" />
+        </div>
+      </div>
+
+      <div class="sct-frequency-panel">
+        <span id="sct-status" class="sct-status">{t.statusReady}</span>
+        <output id="sct-frequency" class="sct-frequency" aria-live="polite">200 Hz</output>
+        <div class="sct-meter" aria-hidden="true">
+          <span id="sct-meter-fill" class="sct-meter-fill"></span>
+        </div>
+        <div class="sct-readouts">
+          <span>{t.targetFrequency}: <strong>10 Hz</strong></span>
+          <span>{t.elapsed}: <strong id="sct-elapsed">0.0s</strong></span>
+        </div>
+      </div>
+    </div>
+
+    <div class="sct-controls">
+      <button id="sct-toggle" class="sct-primary" type="button">
+        <Icon name="mdi:play" class="sct-button-icon" />
+        <span>{t.start}</span>
+      </button>
+      <button id="sct-mark" class="sct-secondary" type="button" disabled>
+        <Icon name="mdi:map-marker-radius" class="sct-button-icon" />
+        <span>{t.markDropout}</span>
+      </button>
+      <button id="sct-reset" class="sct-ghost" type="button">
+        <Icon name="mdi:restart" class="sct-button-icon" />
+        <span>{t.reset}</span>
+      </button>
+    </div>
+
+    <div class="sct-tuning">
+      <label class="sct-slider-wrap" for="sct-volume">
+        <span>{t.volume}</span>
+        <input id="sct-volume" class="sct-slider" type="range" min="0" max="0.6" value="0.22" step="0.01" />
+      </label>
+      <label class="sct-slider-wrap" for="sct-duration">
+        <span>{t.duration}</span>
+        <input id="sct-duration" class="sct-slider" type="range" min="20" max="90" value="45" step="5" />
+      </label>
+    </div>
+
+    <div class="sct-result">
+      <div>
+        <span class="sct-result-label">{t.dropoutLabel}</span>
+        <strong id="sct-dropout">{t.dropoutEmpty}</strong>
+      </div>
+      <p id="sct-note">{t.safeStart}</p>
+    </div>
+
+  </section>
+
+  <script>
+    const root = document.getElementById('sct-root');
+    const strings = JSON.parse(root?.dataset?.s ?? '{}') as Record<string, string>;
+    const frequencyDisplay = document.getElementById('sct-frequency');
+    const elapsedDisplay = document.getElementById('sct-elapsed');
+    const meterFill = document.getElementById('sct-meter-fill') as HTMLSpanElement | null;
+    const statusDisplay = document.getElementById('sct-status');
+    const toggleButton = document.getElementById('sct-toggle') as HTMLButtonElement | null;
+    const markButton = document.getElementById('sct-mark') as HTMLButtonElement | null;
+    const resetButton = document.getElementById('sct-reset') as HTMLButtonElement | null;
+    const volumeInput = document.getElementById('sct-volume') as HTMLInputElement | null;
+    const durationInput = document.getElementById('sct-duration') as HTMLInputElement | null;
+    const dropoutDisplay = document.getElementById('sct-dropout');
+    const noteDisplay = document.getElementById('sct-note');
+
+    const startHz = 200;
+    const endHz = 10;
+    let audioContext: AudioContext | null = null;
+    let oscillator: OscillatorNode | null = null;
+    let gainNode: GainNode | null = null;
+    let startTime = 0;
+    let animationId = 0;
+    let running = false;
+    let currentHz = startHz;
+
+    function formatHz(value: number): string {
+      return value >= 100 ? `${Math.round(value)} Hz` : `${value.toFixed(1)} Hz`;
+    }
+
+    function sweepFrequency(elapsed: number, duration: number): number {
+      const progress = Math.min(1, Math.max(0, elapsed / duration));
+      return startHz * Math.pow(endHz / startHz, progress);
+    }
+
+    function setButtonPlaying(isPlaying: boolean): void {
+      if (!toggleButton) return;
+      const label = toggleButton.querySelector('span');
+      toggleButton.dataset.playing = isPlaying ? 'true' : 'false';
+      if (label) label.textContent = isPlaying ? strings.stop! : strings.start!;
+    }
+
+    function getAudioContext(): AudioContext | null {
+      if (audioContext) return audioContext;
+      const win = window as typeof window & { webkitAudioContext?: typeof AudioContext };
+      const Context = win.AudioContext ?? win.webkitAudioContext;
+      if (!Context) return null;
+      audioContext = new Context();
+      return audioContext;
+    }
+
+    function getElapsed(): { elapsed: number; progress: number } {
+      const duration = Number(durationInput?.value ?? 45);
+      const elapsed = running && audioContext ? audioContext.currentTime - startTime : 0;
+      currentHz = running ? sweepFrequency(elapsed, duration) : currentHz;
+      const progress = Math.min(1, Math.max(0, elapsed / duration));
+      return { elapsed, progress };
+    }
+
+    function refreshFrequencyDisplay(elapsed: number, progress: number): void {
+      if (frequencyDisplay) frequencyDisplay.textContent = formatHz(currentHz);
+      if (elapsedDisplay) elapsedDisplay.textContent = `${elapsed.toFixed(1)}s`;
+      if (meterFill) meterFill.style.transform = `scaleX(${1 - progress})`;
+    }
+
+    function updateVisuals(): void {
+      const { elapsed, progress } = getElapsed();
+      refreshFrequencyDisplay(elapsed, progress);
+      if (running && progress < 1) {
+        animationId = requestAnimationFrame(updateVisuals);
+      } else if (running) {
+        stopSweep();
+      }
+    }
+
+    function setupOscillator(context: AudioContext, duration: number, volume: number): void {
+      oscillator = context.createOscillator();
+      gainNode = context.createGain();
+      oscillator.type = 'sine';
+      oscillator.frequency.setValueAtTime(startHz, context.currentTime);
+      oscillator.frequency.exponentialRampToValueAtTime(endHz, context.currentTime + duration);
+      gainNode.gain.setValueAtTime(0.0001, context.currentTime);
+      gainNode.gain.exponentialRampToValueAtTime(Math.max(0.0001, volume), context.currentTime + 0.08);
+      gainNode.gain.setValueAtTime(Math.max(0.0001, volume), context.currentTime + duration - 0.08);
+      gainNode.gain.exponentialRampToValueAtTime(0.0001, context.currentTime + duration);
+      oscillator.connect(gainNode);
+      gainNode.connect(context.destination);
+      oscillator.start();
+      oscillator.stop(context.currentTime + duration);
+    }
+
+    function applyRunningState(): void {
+      root?.classList.add('is-running');
+      if (markButton) markButton.disabled = false;
+      if (statusDisplay) statusDisplay.textContent = strings.running!;
+    }
+
+    function startSweep(): void {
+      const context = getAudioContext();
+      if (!context) return;
+      if (context.state === 'suspended') void context.resume();
+      stopSweep(false);
+      setupOscillator(context, Number(durationInput?.value ?? 45), Number(volumeInput?.value ?? 0.22));
+      startTime = context.currentTime;
+      currentHz = startHz;
+      running = true;
+      applyRunningState();
+      setButtonPlaying(true);
+      updateVisuals();
+    }
+
+    function cleanupAudio(): void {
+      if (gainNode && audioContext) {
+        gainNode.gain.cancelScheduledValues(audioContext.currentTime);
+        gainNode.gain.setTargetAtTime(0.0001, audioContext.currentTime, 0.025);
+      }
+      if (oscillator) {
+        try { oscillator.stop(); } catch { }
+        oscillator.disconnect();
+      }
+      oscillator = null;
+      gainNode = null;
+    }
+
+    function applyStoppedState(): void {
+      root?.classList.remove('is-running');
+      if (markButton) markButton.disabled = true;
+    }
+
+    function stopSweep(resetStatus = true): void {
+      cancelAnimationFrame(animationId);
+      cleanupAudio();
+      running = false;
+      applyStoppedState();
+      if (resetStatus && statusDisplay) statusDisplay.textContent = strings.stopped!;
+      setButtonPlaying(false);
+    }
+
+    toggleButton?.addEventListener('click', () => {
+      if (running) stopSweep();
+      else startSweep();
+    });
+
+    markButton?.addEventListener('click', () => {
+      if (!dropoutDisplay) return;
+      dropoutDisplay.textContent = formatHz(currentHz);
+      if (noteDisplay) {
+        noteDisplay.textContent = `${strings.crossoverEstimate!}: ${formatHz(currentHz)}.`;
+      }
+      stopSweep();
+    });
+
+    resetButton?.addEventListener('click', () => {
+      stopSweep(false);
+      currentHz = startHz;
+      if (dropoutDisplay) dropoutDisplay.textContent = strings.dropoutEmpty!;
+      if (noteDisplay) noteDisplay.textContent = strings.safeStart!;
+      if (statusDisplay) statusDisplay.textContent = strings.ready!;
+      updateVisuals();
+    });
+
+    volumeInput?.addEventListener('input', () => {
+      if (gainNode && audioContext) {
+        gainNode.gain.setTargetAtTime(Number(volumeInput.value), audioContext.currentTime, 0.03);
+      }
+    });
+  </script>
+</div>

package/src/tool/subwooferCrossoverTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { SubwooferCrossoverTestUI } from './ui';
+
+export type SubwooferCrossoverTestLocaleContent = ToolLocaleContent<SubwooferCrossoverTestUI>;
+
+export const subwooferCrossoverTest: HardwareToolEntry<SubwooferCrossoverTestUI> = {
+  id: 'subwoofer-crossover-test',
+  icons: {
+    bg: 'mdi:speaker-wireless',
+    fg: 'mdi:waves-arrow-left',
+  },
+  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/subwooferCrossoverTest/i18n/de.ts

@@ -0,0 +1,188 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { SubwooferCrossoverTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'subwoofer-frequenzweichen-test-online';
+const title = 'Subwoofer Frequenzweichentest';
+const description =
+  'Führe einen Sinus-Sweep von 200 Hz bis 10 Hz in deinem Browser durch, um zu finden, wo dein Subwoofer abfällt, aussetzt oder an die Hauptlautsprecher übergibt.';
+
+const faqData = [
+  {
+    question: 'Was misst ein Subwoofer-Frequenzweichen-Test?',
+    answer:
+      'Er hilft dir, den Punkt zu hören, an dem der Bass zwischen deinen Hauptlautsprechern und dem Subwoofer nicht mehr durchgängig klingt. Eine Lücke, ein plötzlicher Pegelwechsel oder ein fehlender Bereich kann auf eine falsche Übergangsfrequenz, ein Phasenproblem, Raumauslöschung oder die Grenze des Subwoofers hinweisen.',
+  },
+  {
+    question: 'Warum sweeped dieser Test von 200 Hz auf 10 Hz herunter?',
+    answer:
+      'Die meisten Heimkino-Übergangsfrequenzen liegen zwischen 60 Hz und 120 Hz, während viele Kompaktlautsprecher oberhalb oder unterhalb dieses Bereichs an Ausgabe verlieren. Das Heruntersweepen von 200 Hz macht die Lautsprecher-Subwoofer-Übergabe leicht hörbar, bevor der Ton den tiefen Subbass erreicht.',
+  },
+  {
+    question: 'Kann dieser Online-Subwoofer-Basstest Lautsprecher beschädigen?',
+    answer:
+      'Ja, sehr tiefe Frequenzen bei hoher Lautstärke können kleine Lautsprecher überlasten oder einen Subwoofer überfordern. Starte leise, vermeide verstärkte Bassmoden und stoppe sofort, wenn du Klappern, Klopfen oder mechanische Überlastung hörst.',
+  },
+  {
+    question: 'Ist die markierte Ausfallfrequenz die exakte Übergangsfrequenz, die ich einstellen sollte?',
+    answer:
+      'Nein. Betrachte sie als Hörtipp, nicht als Labormessung. Die beste Übergangsfrequenz hängt auch von den Lautsprecherspezifikationen, der Raumaufstellung, der Phase, der Entfernungskorrektur und dem Kalibrierungsziel ab.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Stelle eine sichere Hörlautstärke ein',
+    text: 'Reduziere zuerst die Systemlautstärke. Der Sweep verwendet eine erzeugte Sinuswelle, sodass der Bass auch dann intensiv werden kann, wenn die Browser-Lautstärke moderat erscheint.',
+  },
+  {
+    name: 'Starte den 200 Hz bis 10 Hz Sweep',
+    text: 'Drücke Sweep starten und höre von deinem normalen Sitzplatz aus. Der Ton bewegt sich gleichmäßig durch den Bassbereich, in dem sich Subwoofer, Hauptlautsprecher und Raumakustik überlappen.',
+  },
+  {
+    name: 'Höre auf den Ausfall oder die Übergabe',
+    text: 'Achte auf den Moment, in dem der Bass schwächer wird, verschwindet, den Ort wechselt oder zwischen Subwoofer und Hauptlautsprechern ungleichmäßig klingt.',
+  },
+  {
+    name: 'Markiere die Frequenz',
+    text: 'Drücke Ausfall markieren am ersten deutlichen Problempegel. Verwende diese Frequenz als Hinweis zur Anpassung von Übergangsfrequenz, Phase, Aufstellung oder Raumkorrektur.',
+  },
+];
+
+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, index) => ({
+    '@type': 'HowToStep',
+    position: index + 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: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<SubwooferCrossoverTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'Finde Die Basslücke Zwischen Deinen Lautsprechern Und Dem Subwoofer', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Ein Subwoofer sollte nicht wie eine separate Box in der Ecke klingen. Der Bass sollte gleichmäßig bleiben, wenn die Töne von deinen Hauptlautsprechern in den Sub übergehen. Dieser Test sweeped von <strong>200 Hz bis 10 Hz</strong>, damit du genau die Zone hören kannst, in der die Übergabe schwach, dröhnend, ortbar oder stumm wird.',
+    },
+    {
+      type: 'table',
+      headers: ['Was du hörst', 'Was es normalerweise bedeutet', 'Was du zuerst versuchen solltest'],
+      rows: [
+        ['Bass verschwindet um 70-100 Hz', 'Subwoofer und Lautsprecher löschen sich gegenseitig nahe der Übergangsfrequenz aus.', 'Phase umkehren, Entfernung/Verzögerung anpassen, dann den Sweep wiederholen.'],
+        ['Bass dröhnt in einem schmalen Band', 'Raummode oder zu viel Überlappung zwischen Lautsprechern und Subwoofer.', 'Übergangsfrequenz leicht senken oder Subwoofer/Hörposition verschieben.'],
+        ['Bass scheint vom Subwoofer-Standort zu kommen', 'Übergangsfrequenz zu hoch oder Subwoofer-Pegel zu heiß.', '80 Hz oder niedriger versuchen und Subwoofer-Verstärkung reduzieren.'],
+        ['Tiefbass verblasst unter 30-40 Hz', 'Normale Ausdehnungsgrenze vieler Subs, besonders kompakter Modelle.', 'Subwoofer-Spezifikation prüfen, bevor du ein Problem verfolgst, das physikalisch sein könnte.'],
+      ],
+    },
+    { type: 'title', text: 'Was Dir Die Ausfallfrequenz Sagt', level: 3 },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Verwende die markierte Frequenz als Abstimmungshinweis',
+      badge: 'Hörtipps',
+      html: '<p>Wenn der markierte Punkt nahe deiner AVR-Übergangsfrequenz liegt, ist das Problem wahrscheinlich Integration: Phase, Entfernung, Polarität, Pegel oder die Steilheit der Filter. Liegt der markierte Punkt viel tiefer, hörst du vielleicht, wie der Subwoofer an seine Leistungsgrenze stößt. Ändert sich das Problem stark, wenn du deinen Kopf bewegst, dominiert der Raum das Ergebnis.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Übliche Übergangsfrequenzbereiche',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Lautsprechertyp', 'Typischer Übergangsfrequenz-Startpunkt', 'Warum'],
+      rows: [
+        ['Kleine Satelliten', '100-150 Hz', 'Winzige Gehäuse können normalerweise keinen sauberen oberen Bass bei Kino-Lautstärken wiedergeben.'],
+        ['Regallautsprecher', '70-100 Hz', 'Oft genug Bass für eine saubere Übergabe, ohne den Sub ortbar zu machen.'],
+        ['Standlautsprecher', '50-80 Hz', 'Größere Tieftöner können mehr Mittelbass bewältigen, aber der Raum kann trotzdem Subwoofer-Bassmanagement bevorzugen.'],
+        ['THX-Setup', '80 Hz', 'Ein praktischer Standardwert, der für viele Systeme gut funktioniert und Tiefbass zum Sub leitet.'],
+      ],
+    },
+    { type: 'title', text: 'Übergangsfrequenzproblem Oder Raumproblem?', level: 3 },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Übergangsfrequenz oder Phasenproblem',
+          description: 'Die Schwachstelle erscheint nahe der Übergangsfrequenz und verbessert sich nach Änderung von Phase, Polarität, Entfernung oder Übergangsfrequenz-Einstellung.',
+          points: ['Normalerweise vom gleichen Sitzplatz aus wiederholbar.', 'Oft um 60-120 Hz zentriert.'],
+        },
+        {
+          title: 'Raumauslöschung',
+          description: 'Die Schwachstelle ändert sich drastisch, wenn du deinen Kopf bewegst, den Sitzplatz wechselst oder den Subwoofer ein kurzes Stück verschiebst.',
+          points: ['Sehr positionsabhängig.', 'Oft mehr durch Aufstellung als durch Einstellungen zu lösen.'],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Beste Art, den Test durchzuführen',
+      html: 'Setze dich dorthin, wo du tatsächlich Filme schaust oder Musik hörst. Stehe nicht neben dem Subwoofer. Eine Übergangsfrequenz, die neben dem Gehäuse gut klingt, kann auf dem Sofa immer noch eine Lücke hinterlassen.',
+    },
+    {
+      type: 'summary',
+      title: 'Was nach dem Sweep zu ändern ist',
+      items: [
+        'Liegt die Lücke nahe der aktuellen Übergangsfrequenz, probiere 10-Hz-Änderungen und wiederhole den Sweep.',
+        'Teste den Phasenschalter oder die Verzögerungseinstellung des Subwoofers, wenn das schwache Band nahe der Übergangsfrequenz liegt.',
+        'Wird der Bass an einem Sitzplatz stärker und verschwindet an einem anderen, verschiebe den Subwoofer, bevor du alle AVR-Einstellungen änderst.',
+        'Nach Aufstellungs- oder Übergangsfrequenzänderungen führe die Raumkorrektur erneut aus, damit der Receiver das neue Setup misst.',
+        'Verwende die markierte Frequenz als Leitfaden für die Abstimmung und bestätige dann mit Musik, Filmen und vertrauten Basslinien.',
+      ],
+    },
+  ],
+  ui: {
+    sweepLabel: 'Subwoofer-Tieffrequenz-Sweep',
+    currentFrequency: 'Aktuelle Frequenz',
+    targetFrequency: 'Ziel',
+    elapsed: 'Verstrichen',
+    statusReady: 'Bereit für Tief-Sweep',
+    statusRunning: 'Sweepe nach unten',
+    statusStopped: 'Sweep gestoppt',
+    start: 'Sweep starten',
+    stop: 'Sweep stoppen',
+    markDropout: 'Ausfall markieren',
+    reset: 'Zurücksetzen',
+    volume: 'Ausgabepegel',
+    duration: 'Sweep-Dauer',
+    safeStart: 'Starte mit niedriger Lautstärke und markiere dann die erste Frequenz, bei der der Bass schwer hörbar wird.',
+    roomNote: 'Raumposition und Phase können das Ergebnis drastisch verändern.',
+    dropoutLabel: 'Markierter Punkt',
+    dropoutEmpty: 'Noch nicht markiert',
+    crossoverEstimate: 'Geschätzter Ausfallpunkt',
+  },
+};

package/src/tool/subwooferCrossoverTest/i18n/en.ts

@@ -0,0 +1,188 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { SubwooferCrossoverTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'subwoofer-crossover-test';
+const title = 'Subwoofer Crossover Test';
+const description =
+  'Run a 200 Hz to 10 Hz sine sweep in your browser to find where your subwoofer fades, drops out, or hands off to your main speakers.';
+
+const faqData = [
+  {
+    question: 'What does a subwoofer crossover test measure?',
+    answer:
+      'It helps you hear the point where bass stops sounding continuous between your main speakers and subwoofer. A gap, sudden level change, or missing range can point to an incorrect crossover frequency, phase issue, room cancellation, or subwoofer limit.',
+  },
+  {
+    question: 'Why does this test sweep from 200 Hz down to 10 Hz?',
+    answer:
+      'Most home theater crossovers sit between 60 Hz and 120 Hz, while many compact speakers start losing output above or below that range. Sweeping down from 200 Hz makes the speaker-to-subwoofer handoff easy to hear before the tone reaches deep sub-bass.',
+  },
+  {
+    question: 'Can this online subwoofer bass test damage speakers?',
+    answer:
+      'Yes, very low frequencies at high volume can overdrive small speakers or stress a subwoofer. Start quietly, avoid boosted bass modes, and stop immediately if you hear rattling, knocking, or mechanical distress.',
+  },
+  {
+    question: 'Is the marked dropout frequency the exact crossover setting I should use?',
+    answer:
+      'No. Treat it as a listening clue, not a lab measurement. The best crossover setting also depends on speaker specifications, room placement, phase, distance correction, and calibration target.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Set a safe listening level',
+    text: 'Lower your system volume first. The sweep uses a generated sine wave, so the bass can become intense even when the browser volume looks modest.',
+  },
+  {
+    name: 'Start the 200 Hz to 10 Hz sweep',
+    text: 'Press Start sweep and listen from your normal seat. The tone moves steadily through the bass range where subwoofers, main speakers, and room acoustics overlap.',
+  },
+  {
+    name: 'Listen for the dropout or handoff',
+    text: 'Pay attention to the moment where bass becomes weaker, disappears, changes location, or sounds uneven between the subwoofer and main speakers.',
+  },
+  {
+    name: 'Mark the frequency',
+    text: 'Press Mark dropout at the first clear problem point. Use that frequency as a clue for adjusting crossover, phase, placement, or room correction.',
+  },
+];
+
+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, index) => ({
+    '@type': 'HowToStep',
+    position: index + 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: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<SubwooferCrossoverTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'Find The Bass Gap Between Your Speakers And Subwoofer', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'A subwoofer should not sound like a separate box in the corner. Bass should stay even as notes move from your main speakers into the sub. This test sweeps from <strong>200 Hz down to 10 Hz</strong> so you can hear the exact zone where the handoff becomes weak, boomy, localizable, or silent.',
+    },
+    {
+      type: 'table',
+      headers: ['What you hear', 'What it usually means', 'What to try first'],
+      rows: [
+        ['Bass vanishes around 70-100 Hz', 'Subwoofer and speakers may be cancelling each other near the crossover.', 'Flip phase, adjust distance/delay, then repeat the sweep.'],
+        ['Bass gets boomy around one narrow band', 'Room mode or too much overlap between speakers and subwoofer.', 'Lower crossover slightly or move the subwoofer/listening position.'],
+        ['Bass seems to come from the subwoofer location', 'Crossover may be too high or subwoofer level may be too hot.', 'Try 80 Hz or lower and reduce subwoofer gain.'],
+        ['Deep bass fades below 30-40 Hz', 'Normal extension limit for many subs, especially compact models.', 'Check the subwoofer specification before chasing a problem that may be physical.'],
+      ],
+    },
+    { type: 'title', text: 'What The Dropout Frequency Tells You', level: 3 },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Use the marked frequency as a tuning clue',
+      badge: 'Listening clues',
+      html: '<p>If the marked point is close to your AVR crossover, the problem is probably integration: phase, distance, polarity, level, or the slope of the filters. If the marked point is much lower, you may be hearing the subwoofer running out of output. If the problem changes a lot when you move your head, the room is dominating the result.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Common Crossover Ranges',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Speaker type', 'Typical crossover starting point', 'Why'],
+      rows: [
+        ['Small satellites', '100-150 Hz', 'Tiny cabinets usually cannot play clean upper bass at theater levels.'],
+        ['Bookshelf speakers', '70-100 Hz', 'Often enough bass for a clean handoff without making the sub easy to locate.'],
+        ['Floorstanding speakers', '50-80 Hz', 'Larger woofers can handle more mid-bass, but the room may still prefer subwoofer bass management.'],
+        ['THX-style setup', '80 Hz', 'A practical default that works well for many systems and keeps deep bass routed to the sub.'],
+      ],
+    },
+    { type: 'title', text: 'Crossover Problem Or Room Problem?', level: 3 },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Crossover or phase issue',
+          description: 'The weak spot appears near the crossover frequency and improves after changing phase, polarity, distance, or crossover setting.',
+          points: ['Usually repeatable from the same seat.', 'Often centered around 60-120 Hz.'],
+        },
+        {
+          title: 'Room cancellation',
+          description: 'The weak spot changes dramatically when you move your head, change seats, or move the subwoofer a short distance.',
+          points: ['Very position dependent.', 'Often solved by placement more than settings.'],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Best way to run the test',
+      html: 'Sit where you actually watch movies or listen to music. Do not stand next to the subwoofer. A crossover that sounds good beside the cabinet can still leave a hole at the sofa.',
+    },
+    {
+      type: 'summary',
+      title: 'What to change after the sweep',
+      items: [
+        'If the hole is near the current crossover, try 10 Hz changes and repeat the sweep.',
+        'Try the subwoofer phase switch or delay setting if the weak band sits near the crossover.',
+        'If the bass gets stronger in one seat and disappears in another, move the subwoofer before changing every AVR setting.',
+        'After placement or crossover changes, rerun room correction so the receiver measures the new setup.',
+        'Use the marked frequency to guide tuning, then confirm with music, movies, and familiar bass lines.',
+      ],
+    },
+  ],
+  ui: {
+    sweepLabel: 'Subwoofer low-frequency sweep',
+    currentFrequency: 'Current frequency',
+    targetFrequency: 'Target',
+    elapsed: 'Elapsed',
+    statusReady: 'Ready for low sweep',
+    statusRunning: 'Sweeping down',
+    statusStopped: 'Sweep stopped',
+    start: 'Start sweep',
+    stop: 'Stop sweep',
+    markDropout: 'Mark dropout',
+    reset: 'Reset',
+    volume: 'Output level',
+    duration: 'Sweep duration',
+    safeStart: 'Start at low volume, then mark the first frequency where bass becomes hard to hear.',
+    roomNote: 'Room position and phase can change the result dramatically.',
+    dropoutLabel: 'Marked point',
+    dropoutEmpty: 'Not marked yet',
+    crossoverEstimate: 'Estimated dropout point',
+  },
+};