@jjlmoya/utils-hardware 1.2.0 → 1.5.0

package/src/tool/mousePollingTest/i18n/zh.ts

@@ -0,0 +1,135 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TestRatonUI } from '../ui';
+
+const slug = 'mouse-polling-rate-test';
+const title = '在线鼠标回报率测试';
+const description =
+  '检查鼠标的真实 Hz。使用我们的专业工具验证您的游戏鼠标是否在 1000Hz 或更高频率下工作。';
+
+const faqData = [
+  {
+    question: '什么是鼠标回报率 (Polling Rate)？',
+    answer:
+      '它是鼠标向电脑报告其位置的频率，以 Hz 为单位衡量。1000Hz 的回报率意味着鼠标每 1 毫秒发送一次数据，从而提供更平滑的移动。',
+  },
+  {
+    question: '为什么我的测试不能持续达到 1000Hz？',
+    answer:
+      '浏览器只有在鼠标移动时才能测量回报率。如果您移动缓慢或 CPU 非常繁忙，测量值可能会波动。请快速转圈移动鼠标以获得真实的最高峰值。',
+  },
+  {
+    question: '回报率是否越高越好？',
+    answer:
+      '对于游戏（1000Hz 或更高）来说，通常是的，因为它可以减少延迟。然而，极高的速率（4000Hz 或 8000Hz）会消耗大量 CPU 资源，并非所有游戏都针对这些速率进行了优化。',
+  },
+  {
+    question: '显示器刷新率如何影响鼠标？',
+    answer:
+      '如果您使用 144Hz 或 240Hz 显示器，较低的回报率（125Hz）会使指针看起来有顿挫感。对于高刷新率显示器，至少使用 500Hz 或 1000Hz 是至关重要的。',
+  },
+];
+
+const howToData = [
+  {
+    name: '准备测试区域',
+    text: '将光标置于工具的采集区域内。',
+  },
+  {
+    name: '快速移动鼠标',
+    text: '进行快速、大范围的圆周运动。该工具将计算硬件发送的每个 mousemove 事件之间的时间间隔。',
+  },
+  {
+    name: '观察稳定性图表',
+    text: '检查 Hz 曲线是否平稳或是否存在突然下降，这可能表明无线鼠标受到干扰或 CPU 存在问题。',
+  },
+  {
+    name: '分析响应时间',
+    text: '检查以毫秒为单位的平均延迟（Delay）。一只好的游戏鼠标平均延迟应保持在 1ms 左右。',
+  },
+];
+
+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: 'EUR' },
+  inLanguage: 'zh',
+};
+
+export const content: ToolLocaleContent<TestRatonUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: '常见问题',
+  faq: faqData,
+  bibliographyTitle: '参考资料',
+  bibliography: [
+    {
+      name: 'Gamepad Polling Rate — Logitech',
+      url: 'https://www.logitechg.com/en-us/innovation/delta-zero.html',
+    },
+    {
+      name: 'USB HID Polling Rate — USB Implementers Forum',
+      url: 'https://www.usb.org/hid',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: '鼠标回报率权威指南', level: 2 },
+    {
+      type: 'paragraph',
+      html: '当您在鼠标垫上物理移动鼠标时，这种模拟运动必须转换为电脑理解的数字信号。<strong>回报率 (Polling Rate)</strong> 是鼠标向电脑“报告”其位置的频率。它以赫兹 (Hz) 为单位。',
+    },
+    { type: 'title', text: '回报率等级及其用途', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>125 Hz</strong> — 鼠标每 8 毫秒报告一次。适用于办公，但在 144Hz 显示器上会感到卡顿。 <strong>1000 Hz</strong> — 游戏黄金标准：每 1 毫秒报告一次。平滑移动，无感知延迟。 <strong>8000 Hz</strong> — 尖端技术（Razer, Logitech）。每 0.125 毫秒报告一次，但需要强劲的 CPU。',
+    },
+    { type: 'title', text: '为什么我的 Hz 值会波动？', level: 3 },
+    {
+      type: 'paragraph',
+      html: '完全正常。大多数现代鼠标都有动态回报率以节省电量。如果您移动鼠标缓慢，它发送的报告就会减少，因为新数据较少。只有快速、持续的移动才能使传感器达到其真实的最高峰值。',
+    },
+    { type: 'title', text: '回报率 vs DPI：核心区别', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>DPI (Dots Per Inch)</strong> 是灵敏度：即鼠标每移动一英寸，光标移动多少像素。 <strong>Hz (回报率)</strong> 是更新频率：即该移动报告的平滑度和及时性。这两个参数是相互独立且互补的。',
+    },
+  ],
+  ui: {
+    badge: '鼠标测试',
+    title: '回报率检测器',
+    description: '快速圆周移动鼠标以测量 Hz。',
+    labelAvg: '平均值',
+    labelPeak: '峰值',
+    placeholder: '在此移动鼠标',
+  },
+};

package/src/tool/mousePollingTest/index.ts

@@ -7,10 +7,6 @@ import TestRatonBibliography from './bibliography.astro';
 import type { TestRatonUI } from './ui';
 export type TestRatonLocaleContent = ToolLocaleContent<TestRatonUI>;
 
-import { content as es } from './i18n/es';
-import { content as en } from './i18n/en';
-import { content as fr } from './i18n/fr';
-
 export const testRaton: HardwareToolEntry<TestRatonUI> = {
   id: 'test-raton',
   icons: {
@@ -18,9 +14,21 @@ export const testRaton: HardwareToolEntry<TestRatonUI> = {
     fg: 'mdi:mouse',
   },
   i18n: {
-    es: async () => es,
-    en: async () => en,
-    fr: async () => fr,
+    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/mousePollingTest/logic/RatonManager.ts

@@ -1,3 +1,6 @@
+import { MovingAverage } from './MovingAverage';
+import { StatisticalFilter } from './StatisticalFilter';
+
 export interface UIToolElements {
   avg: HTMLElement | null;
   max: HTMLElement | null;
@@ -10,88 +13,124 @@ export interface UIToolElements {
 export class RatonManager {
   private el: UIToolElements;
   private ctx: CanvasRenderingContext2D | null;
-  private worker: Worker;
   private history: number[] = [];
-  private readonly MAX_HISTORY = 100;
+  private readonly MAX_HISTORY: number = 100;
   private idleTimer: ReturnType<typeof setTimeout> | null = null;
   private lastMouseEvent: MouseEvent | null = null;
+  private lastTime: number = 0;
+  private maxHz: number = 0;
+  private totalHistory: number[] = [];
+  private filter: StatisticalFilter = new StatisticalFilter();
+  private smoother: MovingAverage = new MovingAverage(20);
 
-  constructor(el: UIToolElements, workerUrl: URL) {
+  constructor(el: UIToolElements) {
     this.el = el;
     this.ctx = el.canvas?.getContext('2d') ?? null;
-    this.worker = new Worker(workerUrl, { type: 'module' });
     this.init();
   }
 
   private init(): void {
     window.addEventListener('resize', () => this.resize());
     this.resize();
-
-    this.worker.onmessage = (event) => this.handleWorkerMessage(event.data);
-
-    this.el.area?.addEventListener('mousemove', (e) => this.processMove(e));
+    this.el.area?.addEventListener('mousemove', (e: MouseEvent) => this.processMove(e));
     this.el.area?.addEventListener('mouseleave', () => this.handleMouseLeave());
   }
 
   private resize(): void {
-    if (!this.el.area || !this.el.canvas) return;
-    const rect = this.el.area.getBoundingClientRect();
-    this.el.canvas.width = rect.width;
-    this.el.canvas.height = rect.height;
+    const { area, canvas } = this.el;
+    if (!area || !canvas) return;
+    const rect = area.getBoundingClientRect();
+    canvas.width = rect.width;
+    canvas.height = rect.height;
   }
 
-  private handleWorkerMessage(data: { hz: number; smoothedHz: number; avgHz: number; maxHz: number }): void {
-    const { hz, smoothedHz, avgHz, maxHz } = data;
-    
-    this.history.push(smoothedHz);
+  private processMove(e: MouseEvent): void {
+    this.lastMouseEvent = e;
+    const now: number = performance.now();
+    this.calculateHz(now);
+    this.lastTime = now;
+    this.refreshIdleTimer();
+  }
+
+  private calculateHz(now: number): void {
+    if (this.lastTime <= 0) return;
+    const delta: number = now - this.lastTime;
+    if (delta <= 0.5 || delta >= 200) return;
+
+    const hz: number = 1000 / delta;
+    if (this.filter.isOutlier(hz)) return;
+
+    this.processValidMove(hz);
+  }
+
+  private processValidMove(hz: number): void {
+    const smoothed: number = this.smoother.next(hz);
+    this.history.push(smoothed);
     if (this.history.length > this.MAX_HISTORY) this.history.shift();
     
-    if (this.el.max) this.el.max.textContent = Math.round(maxHz).toString();
-    if (this.el.avg) this.el.avg.textContent = Math.round(avgHz).toString();
+    this.totalHistory.push(hz);
+    if (this.totalHistory.length > 200) this.totalHistory.shift();
+    
+    if (hz > this.maxHz) this.maxHz = hz;
+    const avg: number = this.totalHistory.reduce((acc: number, val: number) => acc + val, 0) / this.totalHistory.length;
     
+    this.updateUI(hz, avg);
+  }
+
+  private refreshIdleTimer(): void {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => this.reset(), 100);
+  }
+
+  private updateUI(hz: number, avg: number): void {
+    const { max, avg: avgEl, placeholder } = this.el;
+    if (max) max.textContent = Math.round(this.maxHz).toString();
+    if (avgEl) avgEl.textContent = Math.round(avg).toString();
+    if (placeholder) placeholder.style.opacity = '0';
+    this.updateFollower(hz);
     this.updateGraph();
+  }
 
-    if (this.el.follower && this.lastMouseEvent) {
-      this.el.follower.textContent = `${Math.round(hz)} Hz`;
-      const rect = this.el.area!.getBoundingClientRect();
-      this.el.follower.style.transform = `translate(${this.lastMouseEvent.clientX - rect.left + 15}px, ${this.lastMouseEvent.clientY - rect.top + 15}px)`;
-      this.el.follower.style.opacity = '1';
-    }
-    
-    if (this.el.placeholder) this.el.placeholder.style.opacity = '0';
+  private updateFollower(hz: number): void {
+    const { follower, area } = this.el;
+    if (!follower || !this.lastMouseEvent || !area) return;
+    follower.textContent = `${Math.round(hz)} Hz`;
+    const rect = area.getBoundingClientRect();
+    const x: number = this.lastMouseEvent.clientX - rect.left + 15;
+    const y: number = this.lastMouseEvent.clientY - rect.top + 15;
+    follower.style.transform = `translate(${x}px, ${y}px)`;
+    follower.style.opacity = '1';
   }
 
   private updateGraph(): void {
-    if (!this.ctx || !this.el.canvas) return;
-    const { width: w, height: h } = this.el.canvas;
-    this.ctx.clearRect(0, 0, w, h);
-    this.ctx.beginPath();
-    this.ctx.strokeStyle = '#10b981';
-    this.ctx.lineWidth = 2;
-    const currentMax = Math.max(1000, ...this.history);
-    const stepX = w / this.MAX_HISTORY;
-    this.history.forEach((hz, i) => {
-      const x = i * stepX;
-      const y = h - (hz / currentMax) * (h * 0.8);
-      if (i === 0) this.ctx!.moveTo(x, y);
-      else this.ctx!.lineTo(x, y);
+    const ctx = this.ctx;
+    const canvas = this.el.canvas;
+    if (!ctx || !canvas) return;
+    const { width: w, height: h } = canvas;
+    ctx.clearRect(0, 0, w, h);
+    ctx.beginPath();
+    ctx.strokeStyle = '#10b981';
+    ctx.lineWidth = 2;
+    const currentMax: number = Math.max(1000, ...this.history);
+    const stepX: number = w / this.MAX_HISTORY;
+    this.history.forEach((hz: number, i: number) => {
+      const x: number = i * stepX;
+      const y: number = h - (hz / currentMax) * (h * 0.8);
+      if (i === 0) ctx.moveTo(x, y);
+      else ctx.lineTo(x, y);
     });
-    this.ctx.stroke();
+    ctx.stroke();
   }
 
-  private processMove(e: MouseEvent): void {
-    this.lastMouseEvent = e;
-    this.worker.postMessage({ time: performance.now() });
-    
-    if (this.idleTimer) clearTimeout(this.idleTimer);
-    this.idleTimer = setTimeout(() => {
-      if (this.el.follower) this.el.follower.style.opacity = '0';
-      this.worker.postMessage('reset');
-    }, 100);
+  private reset(): void {
+    this.lastTime = 0;
+    this.filter.reset();
+    this.smoother.reset();
+    this.totalHistory = [];
+    if (this.el.follower) this.el.follower.style.opacity = '0';
   }
 
   private handleMouseLeave(): void {
-    if (this.el.follower) this.el.follower.style.opacity = '0';
-    this.worker.postMessage('reset');
+    this.reset();
   }
 }

package/src/tool/mousePollingTest/logic/StatisticalFilter.ts

@@ -1,38 +1,30 @@
-export interface FilterConfig {
-  maxThreshold?: number;
-  stdDevMultiplier?: number;
-  minSamples?: number;
-}
-
 export class StatisticalFilter {
   private samples: number[] = [];
-  private readonly config: FilterConfig;
-
-  constructor(config: FilterConfig = {}) {
-    this.config = {
-      maxThreshold: 1100,
-      stdDevMultiplier: 2,
-      minSamples: 20,
-      ...config,
-    };
-  }
+  private readonly MAX_THRESHOLD: number = 10000;
+  private readonly STD_DEV_MULTIPLIER: number = 4;
+  private readonly MIN_SAMPLES: number = 20;
 
   public isOutlier(value: number): boolean {
-    if (this.config.maxThreshold && value > this.config.maxThreshold) {
-      return true;
-    }
+    if (value > this.MAX_THRESHOLD) return true;
 
-    if (this.samples.length < (this.config.minSamples || 20)) {
+    if (this.samples.length < this.MIN_SAMPLES) {
       this.samples.push(value);
       return false;
     }
 
-    const avg = this.samples.reduce((a, b) => a + b, 0) / this.samples.length;
-    const stdDev = Math.sqrt(
-      this.samples.reduce((a, b) => a + Math.pow(b - avg, 2), 0) / this.samples.length
-    );
+    const total: number = this.samples.reduce((acc: number, val: number) => acc + val, 0);
+    const avg: number = total / this.samples.length;
+    
+    const squareDiffs: number = this.samples.reduce((acc: number, val: number) => {
+      const diff: number = val - avg;
+      return acc + (diff * diff);
+    }, 0);
+    
+    const stdDev: number = Math.sqrt(squareDiffs / this.samples.length);
+
+    if (stdDev === 0) return false;
 
-    const isFiltered = Math.abs(value - avg) > stdDev * (this.config.stdDevMultiplier || 2.5);
+    const isFiltered: boolean = Math.abs(value - avg) > stdDev * this.STD_DEV_MULTIPLIER;
 
     if (!isFiltered) {
       this.samples.push(value);

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

@@ -0,0 +1,146 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { ToneGeneratorUI } from '../ui';
+
+const slug = 'ton-frequenz-generator-online';
+const title = 'Online Ton und Frequenzgenerator';
+const description =
+  'Erzeugen Sie Sinus-, Rechteck-, Dreieck- und Sägezahnwellen. Testen Sie Ihre Lautsprecher, Kopfhörer oder Subwoofer mit Frequenzen von 20Hz bis 20kHz.';
+
+const faqData = [
+  {
+    question: 'Wofür wird ein Frequenzgenerator verwendet?',
+    answer:
+      'Er wird verwendet, um den Frequenzgang von Lautsprechern und Kopfhörern zu testen, unerwünschte Resonanzen in Möbeln zu erkennen, Lücken in Ihrem Hörbereich zu finden oder sogar bei Tinnitus durch Notch-Therapie zu helfen.',
+  },
+  {
+    question: 'Was ist eine Sinuswelle im Vergleich zu einer Rechteckwelle?',
+    answer:
+      'Eine Sinuswelle ist ein reiner Ton ohne Oberwellen (glatt und rund). Eine Rechteckwelle ist reich an ungeraden Oberwellen und klingt viel aggressiver oder digitaler. Die Dreieckwelle liegt dazwischen und ist nützlich für die Audiosynthese.',
+  },
+  {
+    question: 'Kann ich meine Lautsprecher mit diesem Tool beschädigen?',
+    answer:
+      'Ja, wenn Sie sehr hohe Lautstärken bei extremen Frequenzen verwenden (insbesondere Bässe unter 30Hz oder Höhen über 15kHz). Beginnen Sie immer mit einer niedrigen Systemlautstärke und erhöhen Sie diese schrittweise.',
+  },
+  {
+    question: 'Wie hoch ist der menschliche Hörbereich?',
+    answer:
+      'Theoretisch 20Hz bis 20.000Hz (20kHz). Mit zunehmendem Alter ist es jedoch normal, die Fähigkeit zu verlieren, Töne über 15kHz zu hören. Dieser Test kann Ihnen helfen, Ihre persönliche Obergrenze zu überprüfen.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Wellenformtyp auswählen',
+    text: 'Wählen Sie zwischen Sinus (rein), Rechteck, Dreieck oder Sägezahn, je nachdem, welche Art von Test Sie durchführen möchten.',
+  },
+  {
+    name: 'Frequenz einstellen',
+    text: 'Bewegen Sie den Schieberegler, um durch das hörbare Spektrum zu navigieren. Verwenden Sie die Shortcuts für 60Hz, 440Hz oder 1kHz, um schnell auf Referenzfrequenzen zuzugreifen.',
+  },
+  {
+    name: 'Lautstärke kontrollieren',
+    text: 'Stellen Sie sicher, dass die Lautstärke Ihrer Lautsprecher niedrig ist, bevor Sie auf Play drücken. Sie können die Verstärkung direkt über das Tool anpassen.',
+  },
+  {
+    name: 'Reaktion analysieren',
+    text: 'Achten Sie auf mögliche Verzerrungen oder Momente, in denen der Ton verschwindet. Dies deutet auf die physikalischen Grenzen Ihrer Audio-Hardware hin.',
+  },
+];
+
+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: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<ToneGeneratorUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliographyTitle: 'Referenzen',
+  bibliography: [
+    {
+      name: 'MDN Web Docs — Web Audio API',
+      url: 'https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API',
+    },
+    {
+      name: 'ISO 226:2023 — Equal-loudness contours',
+      url: 'https://www.iso.org/standard/83117.html',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Alles über Frequenzen und Schallwellen', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Schall ist reine Physik in Bewegung. Mit diesem Tool können Sie Schallwellen in Echtzeit manipulieren, von den tiefsten Bässen, die Sie in Ihrer Brust spüren können, bis hin zu den Ultraschall-Höhen, die nur Tiere wahrnehmen können.',
+    },
+    { type: 'title', text: 'Menschlicher Hörbereich und Presbyakusis', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Ein gesundes menschliches Ohr nimmt Geräusche zwischen <strong>20Hz und 20kHz</strong> wahr. Mit zunehmendem Alter sinkt die Obergrenze: Die meisten Erwachsenen über 50 können Töne über 12kHz nicht mehr hören. Der 17,4kHz-Ton, bekannt als "Mückenton", ist ein klassischer Test, den typischerweise nur Teenager bestehen können.',
+    },
+    { type: 'title', text: 'Wellenformen und ihre Verwendung', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>Sinus:</strong> reiner Ton ohne Oberwellen, wird in medizinischen Hörtests und zur Instrumentenkalibrierung verwendet. <strong>Rechteck:</strong> reich an ungeraden Oberwellen, klingt wie Retro-8-Bit-Konsolen. <strong>Sägezahn:</strong> enthält alle Oberwellen, die Basis für Synthesizer in der elektronischen Musik. <strong>Dreieck:</strong> Mittelpunkt zwischen Sinus und Rechteck — glatter als Rechteck, aber mit mehr harmonischem Gehalt als Sinus.',
+    },
+    { type: 'title', text: 'Lautsprechertest und Reinigung durch Vibration', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Eine niederfrequente Welle (typischerweise <strong>165Hz</strong>) bei maximaler Lautstärke mit Rechteck- oder Sägezahnform zwingt die Lautsprechermembran zu heftigen Vibrationen, wodurch Wassertropfen, die im Gitter gefangen sind, mechanisch ausgestoßen werden. Spielen Sie extrem hohe Frequenzen nicht über längere Zeit bei maximaler Lautstärke ab: Auch wenn Sie sie nicht hören können, kann die Energie die Hochtöner Ihrer Ausrüstung beschädigen.',
+    },
+  ],
+  ui: {
+    badge: 'Audio-Generator',
+    title: 'Frequenzgenerator',
+    description: 'Erzeugen Sie reine Frequenzen für Audiotests.',
+    freqLabel: 'Frequenz',
+    preset60: '60Hz',
+    preset440: '440Hz',
+    preset1k: '1kHz',
+    rangeMin: '20Hz (Sub-Bass)',
+    rangeMax: '20kHz (Ultraschall)',
+    waveLabel: 'Wellenform',
+    waveSine: 'Sinus',
+    waveSquare: 'Rechteck',
+    waveSawtooth: 'Sägezahn',
+    waveTriangle: 'Dreieck',
+    volLabel: 'Lautstärke',
+    btnPlay: 'TON ABSPIELEN',
+    btnStop: 'STOPP',
+  },
+};