@jjlmoya/utils-drones 1.20.0 → 1.22.0

package/src/tool/drone-battery-c-rating-calculator/dom-views.ts

@@ -0,0 +1,119 @@
+import type { BatteryCalculationResults, BatteryInputs, SafetyStatus } from './logic';
+import type { SafetyEvaluation } from './evaluator';
+
+export interface DOMResultElements {
+  claimedMaxCurrent: HTMLElement;
+  realisticCRating: HTMLElement;
+  realisticMaxCurrent: HTMLElement;
+  totalPeakDraw: HTMLElement;
+  voltageSag: HTMLElement;
+  sagNominalVoltage: HTMLElement;
+  flightTimeFullThrottle: HTMLElement;
+  flightTimeHover: HTMLElement;
+  burstRatingRequired: HTMLElement;
+  safetyBadge: HTMLElement;
+  statusTitle: HTMLElement;
+  statusDesc: HTMLElement;
+  svgContainer: HTMLElement;
+}
+
+export function formatTimeSeconds(seconds: number): string {
+  if (!seconds || seconds <= 0 || !Number.isFinite(seconds)) return '0s';
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.round(seconds % 60);
+  if (mins === 0) return `${secs}s`;
+  return `${mins}m ${secs}s`;
+}
+
+function getSafetyColor(status: SafetyStatus): string {
+  if (status === 'danger') return '#ef4444';
+  if (status === 'warning') return '#f59e0b';
+  return '#10b981';
+}
+
+function renderCellsSVG(cellCount: number, statusColor: string, sagNominalVoltageV: number): string {
+  const cellWidth = Math.min(42, Math.floor(260 / cellCount));
+  return Array.from({ length: cellCount }, (_, i) => {
+    const x = 35 + i * (cellWidth + 5);
+    const cellSagV = (sagNominalVoltageV / cellCount).toFixed(2);
+    return `<g>
+      <rect x="${x}" y="55" width="${cellWidth}" height="90" rx="6" fill="var(--n-svg-inner, #1e293b)" stroke="${statusColor}" stroke-width="2"/>
+      <rect x="${x + 3}" y="61" width="${cellWidth - 6}" height="35" rx="3" fill="${statusColor}" fill-opacity="0.2"/>
+      <circle cx="${x + cellWidth / 2}" cy="78" r="4" fill="${statusColor}"/>
+      <text x="${x + cellWidth / 2}" y="112" fill="var(--n-text, #f8fafc)" font-size="11" font-weight="800" text-anchor="middle">S${i + 1}</text>
+      <text x="${x + cellWidth / 2}" y="132" fill="var(--n-text-muted, #94a3b8)" font-size="10" font-weight="600" text-anchor="middle">${cellSagV}V</text>
+    </g>`;
+  }).join('');
+}
+
+function renderGaugeHUD(results: BatteryCalculationResults, statusColor: string): string {
+  const maxCapA = Math.max(1, results.realisticMaxCurrentA);
+  const ratio = Math.min(100, Math.round((results.totalPeakDrawA / maxCapA) * 100));
+  const strokeDash = 251;
+  const strokeOffset = strokeDash - (strokeDash * ratio) / 100;
+  return `<g transform="translate(390, 20)">
+    <rect x="0" y="0" width="150" height="160" rx="14" fill="var(--n-svg-card, #0f172a)" stroke="var(--n-svg-stroke, #334155)" stroke-width="2" />
+    <text x="75" y="24" fill="var(--n-text-muted, #94a3b8)" font-size="10" font-weight="700" text-anchor="middle" letter-spacing="0.5">CURRENT STRESS</text>
+    <circle cx="75" cy="85" r="40" fill="none" stroke="var(--n-svg-inner, #1e293b)" stroke-width="9" />
+    <circle cx="75" cy="85" r="40" fill="none" stroke="${statusColor}" stroke-width="9" stroke-dasharray="${strokeDash}" stroke-dashoffset="${strokeOffset}" stroke-linecap="round" transform="rotate(-90 75 85)" />
+    <text x="75" y="88" fill="var(--n-text, #f8fafc)" font-size="16" font-weight="900" text-anchor="middle">${ratio}%</text>
+    <text x="75" y="102" fill="var(--n-text-muted, #94a3b8)" font-size="9" text-anchor="middle">PEAK LOAD</text>
+    <rect x="15" y="125" width="120" height="24" rx="12" fill="${statusColor}" fill-opacity="0.2" stroke="${statusColor}" stroke-width="1"/>
+    <text x="75" y="141" fill="${statusColor}" font-size="10" font-weight="800" text-anchor="middle" letter-spacing="0.5">${results.safetyStatus.toUpperCase()}</text>
+  </g>`;
+}
+
+export function renderBatterySVG(inputs: BatteryInputs, results: BatteryCalculationResults): string {
+  const statusColor = getSafetyColor(results.safetyStatus);
+  const cellCount = Math.max(1, Math.min(8, inputs.cellCount));
+  const cellsHtml = renderCellsSVG(cellCount, statusColor, results.sagNominalVoltageV);
+  const gaugeHtml = renderGaugeHUD(results, statusColor);
+
+  return `<svg viewBox="0 0 560 210" width="100%" height="210" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+      <filter id="glowEffect" x="-20%" y="-20%" width="140%" height="140%">
+        <feGaussianBlur stdDeviation="5" result="blur" />
+        <feComposite in="SourceGraphic" in2="blur" operator="over" />
+      </filter>
+    </defs>
+    <path d="M 310 100 Q 340 70 370 100" stroke="#ef4444" stroke-width="5" fill="none" stroke-linecap="round"/>
+    <path d="M 310 110 Q 340 140 370 110" stroke="var(--n-text, #000000)" stroke-width="5" fill="none" stroke-linecap="round"/>
+    <rect x="365" y="95" width="22" height="20" rx="4" fill="#eab308" stroke="#ca8a04" stroke-width="2"/>
+    <rect x="20" y="30" width="310" height="140" rx="14" fill="var(--n-svg-card, #0f172a)" stroke="var(--n-svg-stroke, #334155)" stroke-width="2"/>
+    <rect x="20" y="30" width="310" height="140" rx="14" fill="none" stroke="${statusColor}" stroke-width="2" filter="url(#glowEffect)" opacity="0.4"/>
+    <text x="35" y="48" fill="var(--n-primary, #0284c7)" font-size="12" font-weight="800" letter-spacing="1">${inputs.cellCount}S ${inputs.chemistry.toUpperCase()} PACK (${inputs.capacitymAh} mAh)</text>
+    <g>${cellsHtml}</g>
+    ${gaugeHtml}
+    <text x="35" y="192" fill="${statusColor}" font-size="11" font-weight="700">Real Discharge: ${results.realisticMaxCurrentA.toFixed(1)}A (${results.realisticCRating}C)</text>
+    <text x="330" y="192" fill="var(--n-text-muted, #94a3b8)" font-size="11" font-weight="600" text-anchor="end">Peak Draw: ${results.totalPeakDrawA.toFixed(1)}A</text>
+  </svg>`;
+}
+
+function updatePrimaryMetrics(elements: DOMResultElements, results: BatteryCalculationResults): void {
+  if (elements.claimedMaxCurrent) elements.claimedMaxCurrent.textContent = `${results.claimedMaxCurrentA.toFixed(1)} A`;
+  if (elements.realisticCRating) elements.realisticCRating.textContent = `${results.realisticCRating} C`;
+  if (elements.realisticMaxCurrent) elements.realisticMaxCurrent.textContent = `${results.realisticMaxCurrentA.toFixed(1)} A`;
+  if (elements.totalPeakDraw) elements.totalPeakDraw.textContent = `${results.totalPeakDrawA.toFixed(1)} A`;
+  if (elements.voltageSag) elements.voltageSag.textContent = `-${results.voltageSagV.toFixed(2)} V`;
+}
+
+function updateSecondaryMetrics(elements: DOMResultElements, results: BatteryCalculationResults): void {
+  if (elements.sagNominalVoltage) elements.sagNominalVoltage.textContent = `${results.sagNominalVoltageV.toFixed(1)} V`;
+  if (elements.flightTimeFullThrottle) elements.flightTimeFullThrottle.textContent = formatTimeSeconds(results.flightTimeFullThrottleSec);
+  if (elements.flightTimeHover) elements.flightTimeHover.textContent = formatTimeSeconds(results.flightTimeHoverSec);
+  if (elements.burstRatingRequired) elements.burstRatingRequired.textContent = `${results.burstRatingRequired.toFixed(0)} C`;
+}
+
+export function updateDOMMetrics(elements: DOMResultElements, results: BatteryCalculationResults): void {
+  updatePrimaryMetrics(elements, results);
+  updateSecondaryMetrics(elements, results);
+}
+
+export function updateDOMSafety(elements: DOMResultElements, evalData: SafetyEvaluation): void {
+  if (elements.safetyBadge) {
+    elements.safetyBadge.className = `sc-safety-badge ${evalData.badgeClass}`;
+    elements.safetyBadge.textContent = evalData.title;
+  }
+  if (elements.statusTitle) elements.statusTitle.textContent = evalData.title;
+  if (elements.statusDesc) elements.statusDesc.textContent = evalData.description;
+}

package/src/tool/drone-battery-c-rating-calculator/drone-battery-c-rating-calculator.css

@@ -0,0 +1,300 @@
+:root {
+  --n-bg: #f8fafc;
+  --n-surface: #fff;
+  --n-card-bg: rgba(255, 255, 255, 0.95);
+  --n-border: #cbd5e1;
+  --n-text: #0f172a;
+  --n-text-muted: #475569;
+  --n-primary: #0284c7;
+  --n-primary-hover: #0369a1;
+  --n-accent: #38bdf8;
+  --n-success: #10b981;
+  --n-warning: #f59e0b;
+  --n-danger: #ef4444;
+  --n-svg-card: #f1f5f9;
+  --n-svg-inner: #fff;
+  --n-svg-stroke: #cbd5e1;
+  --n-radius: 16px;
+  --n-shadow: 0 10px 30px -5px rgba(0, 0, 0, 0.08);
+}
+
+.theme-dark {
+  --n-bg: #0b0f19;
+  --n-surface: #111827;
+  --n-card-bg: rgba(17, 24, 39, 0.9);
+  --n-border: #1f2937;
+  --n-text: #f9fafb;
+  --n-text-muted: #9ca3af;
+  --n-primary: #38bdf8;
+  --n-primary-hover: #7dd3fc;
+  --n-accent: #0ea5e9;
+  --n-success: #34d399;
+  --n-warning: #fbbf24;
+  --n-danger: #f87171;
+  --n-svg-card: #0f172a;
+  --n-svg-inner: #1e293b;
+  --n-svg-stroke: #334155;
+  --n-shadow: 0 10px 30px -5px rgba(0, 0, 0, 0.5);
+}
+
+.sc-main-card {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 2rem;
+  background-color: var(--n-card-bg);
+  border: 1px solid var(--n-border);
+  border-radius: var(--n-radius);
+  padding: 2rem;
+  box-shadow: var(--n-shadow);
+  backdrop-filter: blur(12px);
+  color: var(--n-text);
+  margin-bottom: 2rem;
+}
+
+@media (min-width: 1024px) {
+  .sc-main-card {
+    grid-template-columns: 380px 1fr;
+  }
+}
+
+.sc-sidebar {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.sc-section-title {
+  font-size: 1.1rem;
+  font-weight: 700;
+  color: var(--n-text);
+  margin-bottom: 0.8rem;
+}
+
+.sc-preset-group {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.sc-preset-chip {
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  color: var(--n-text);
+  border-radius: 8px;
+  padding: 0.45rem 0.85rem;
+  font-size: 0.85rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.sc-preset-chip:hover {
+  border-color: var(--n-primary);
+  color: var(--n-primary);
+}
+
+.sc-preset-chip.active {
+  background-color: var(--n-primary);
+  border-color: var(--n-primary);
+  color: #fff;
+  box-shadow: 0 0 12px rgba(56, 189, 248, 0.3);
+}
+
+.sc-field-group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+
+.sc-field-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.sc-field-header label {
+  font-size: 0.85rem;
+  font-weight: 600;
+  color: var(--n-text-muted);
+}
+
+.sc-input {
+  width: 100%;
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 8px;
+  padding: 0.55rem 0.8rem;
+  color: var(--n-text);
+  font-size: 0.95rem;
+  outline: none;
+  transition: border-color 0.2s ease;
+}
+
+.sc-input:focus {
+  border-color: var(--n-primary);
+}
+
+.sc-slider {
+  width: 100%;
+  accent-color: var(--n-primary);
+  cursor: pointer;
+  margin-top: 0.2rem;
+}
+
+.sc-custom-select {
+  position: relative;
+  width: 100%;
+}
+
+.sc-select-trigger {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 8px;
+  padding: 0.6rem 0.8rem;
+  color: var(--n-text);
+  font-size: 0.95rem;
+  cursor: pointer;
+  user-select: none;
+}
+
+.sc-select-trigger svg {
+  transition: transform 0.2s ease;
+  fill: var(--n-text-muted);
+}
+
+.sc-custom-select.open .sc-select-trigger svg {
+  transform: rotate(180deg);
+}
+
+.sc-select-dropdown {
+  display: none;
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  right: 0;
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 8px;
+  box-shadow: var(--n-shadow);
+  z-index: 50;
+  overflow: hidden;
+}
+
+.sc-custom-select.open .sc-select-dropdown {
+  display: block;
+}
+
+.sc-select-option {
+  padding: 0.6rem 0.8rem;
+  font-size: 0.9rem;
+  color: var(--n-text);
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.sc-select-option:hover,
+.sc-select-option.active {
+  background-color: var(--n-primary);
+  color: #fff;
+}
+
+.sc-display-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.sc-header-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.sc-safety-badge {
+  padding: 0.5rem 1.2rem;
+  border-radius: 20px;
+  font-weight: 700;
+  font-size: 0.85rem;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.status-optimal {
+  background-color: rgba(16, 185, 129, 0.15);
+  color: var(--n-success);
+  border: 1px solid var(--n-success);
+}
+
+.status-warning {
+  background-color: rgba(245, 158, 11, 0.15);
+  color: var(--n-warning);
+  border: 1px solid var(--n-warning);
+}
+
+.status-danger {
+  background-color: rgba(239, 68, 68, 0.15);
+  color: var(--n-danger);
+  border: 1px solid var(--n-danger);
+}
+
+.sc-svg-wrapper {
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 12px;
+  padding: 1rem;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.sc-results-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(190px, 1fr));
+  gap: 1rem;
+}
+
+.sc-metric-card {
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 12px;
+  padding: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+
+.sc-metric-label {
+  font-size: 0.8rem;
+  color: var(--n-text-muted);
+  font-weight: 600;
+}
+
+.sc-metric-value {
+  font-size: 1.35rem;
+  font-weight: 800;
+  color: var(--n-text);
+}
+
+.sc-status-box {
+  background-color: var(--n-surface);
+  border: 1px solid var(--n-border);
+  border-radius: 12px;
+  padding: 1.2rem;
+}
+
+.sc-status-box h4 {
+  font-size: 1rem;
+  font-weight: 700;
+  margin-bottom: 0.4rem;
+  color: var(--n-text);
+}
+
+.sc-status-box p {
+  font-size: 0.9rem;
+  color: var(--n-text-muted);
+  line-height: 1.5;
+}

package/src/tool/drone-battery-c-rating-calculator/entry.ts

@@ -0,0 +1,27 @@
+import type { DronesToolEntry, ToolLocaleContent } from '../../types';
+import type { DroneBatteryCRatingCalculatorUI } from './ui';
+
+export type { DroneBatteryCRatingCalculatorUI };
+export type DroneBatteryCRatingCalculatorLocaleContent = ToolLocaleContent<DroneBatteryCRatingCalculatorUI>;
+
+export const droneBatteryCRatingCalculator: DronesToolEntry<DroneBatteryCRatingCalculatorUI> = {
+  id: 'drone-battery-c-rating-calculator',
+  icons: { bg: 'mdi:battery-charging-100', fg: 'mdi:flash-auto' },
+  i18n: {
+    es: () => import('./i18n/es').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+  },
+};

package/src/tool/drone-battery-c-rating-calculator/evaluator.ts

@@ -0,0 +1,37 @@
+import type { SafetyStatus } from './logic';
+import type { DroneBatteryCRatingCalculatorUI } from './ui';
+
+export interface SafetyEvaluation {
+  status: SafetyStatus;
+  badgeClass: string;
+  title: string;
+  description: string;
+}
+
+export function evaluateSafetyPresentation(
+  status: SafetyStatus,
+  ui: DroneBatteryCRatingCalculatorUI
+): SafetyEvaluation {
+  if (status === 'optimal') {
+    return {
+      status,
+      badgeClass: 'status-optimal',
+      title: ui.statusOptimalTitle,
+      description: ui.statusOptimalDesc,
+    };
+  }
+  if (status === 'warning') {
+    return {
+      status,
+      badgeClass: 'status-warning',
+      title: ui.statusWarningTitle,
+      description: ui.statusWarningDesc,
+    };
+  }
+  return {
+    status,
+    badgeClass: 'status-danger',
+    title: ui.statusDangerTitle,
+    description: ui.statusDangerDesc,
+  };
+}

package/src/tool/drone-battery-c-rating-calculator/i18n/de.ts

@@ -0,0 +1,192 @@
+import type { DroneBatteryCRatingCalculatorLocaleContent } from '../entry';
+import type { WithContext, SoftwareApplication, FAQPage, HowTo } from 'schema-dts';
+import type { SEOSection } from '../../../types';
+import { BIBLIOGRAPHY_ITEMS } from '../bibliography';
+
+const slug = 'lipo-c-rate-rechner-drohne';
+const title = 'Drohnen LiPo Akku C Rate und Dauerentladungs Rechner';
+const description = 'Berechnen Sie den realistischen Dauerentladestrom, die C-Rate, den Spannungsabfall und die Flugsicherheit von LiPo-Akkus für Drohnen basierend auf Innenwiderstand und Motorverbrauch.';
+
+const ui = {
+  title: 'Drohnen LiPo Akku C Rate Rechner',
+  subtitle: 'Analysieren Sie reale Dauerentladung Peak Anforderungen und Spannungsabfall für Multikopter',
+  lipoSpecsHeader: 'Akkuspezifikationen',
+  capacityLabel: 'Kapazität (mAh)',
+  claimedCRatingLabel: 'Angegebene C Rate',
+  cellCountLabel: 'Zellenzahl (Serie)',
+  chemistryLabel: 'Akkuchemie',
+  internalResistanceLabel: 'Innenwiderstand pro Zelle (mΩ)',
+  quadSpecsHeader: 'Stromverbrauch des Kopters',
+  motorCountLabel: 'Motoranzahl',
+  peakMotorCurrentLabel: 'Spitzenstrom pro Motor (Ampere)',
+  auxCurrentLabel: 'Zusatzverbraucher (VTX FC Kamera) (Ampere)',
+  presetSelectLabel: 'Schnelleinstellungen',
+  customPreset: 'Benutzerdefiniert',
+  whoopPreset: '1S TinyWhoop',
+  freestyle5Preset: '6S 5 Zoll Freestyle',
+  cinewhoopPreset: '4S 3 Zoll CineWhoop',
+  longRange7Preset: '6S 7 Zoll Long Range',
+  racing5Preset: '6S 5 Zoll Racing',
+  resultsHeader: 'Leistungs und Performance Analyse',
+  claimedMaxCurrentLabel: 'Angegebener Maximalstrom',
+  realisticCRatingLabel: 'Realistische Dauer C Rate',
+  realisticMaxCurrentLabel: 'Realistischer Dauerstrom',
+  totalPeakDrawLabel: 'Gesamter Spitzenstrom',
+  voltageSagLabel: 'Geschätzter Spannungsabfall',
+  sagNominalVoltageLabel: 'Nennspannung unter Last',
+  flightTimeFullThrottleLabel: 'Vollgas Flugzeit',
+  flightTimeHoverLabel: 'Geschätzte Schwebeflugzeit',
+  safetyStatusLabel: 'Sicherheitsdiagnose',
+  statusOptimalTitle: 'Sicherer und Optimaler Akku',
+  statusOptimalDesc: 'Der Akku kann den Spitzenstrom ohne übermäßige Erwärmung oder starken Spannungsabfall problemlos liefern. Hohe Lebensdauer der Zellen garantiert.',
+  statusWarningTitle: 'Moderate Thermische und Spannungs Belastung',
+  statusWarningDesc: 'Der Spitzenstrom liegt nahe an der realistischen Akkugrenze. Bei schnellen Vollgas Punches ist mit leichtem Voltage Sag zu rechnen.',
+  statusDangerTitle: 'Hohes Überlastungs und Sag Risiko',
+  statusDangerDesc: 'Der Spitzenstrom übersteigt die reale Kapazität des Akkus. Hohes Risiko von Voltage Sag, Zellüberhitzung und vorzeitiger Alterung.',
+  lipoVisualizerTitle: 'Live LiPo Status Visualisierung',
+  cellVoltageLabel: 'Zellenspannung',
+  batteryHealthLabel: 'Akkubelastung',
+  burstRatingRequiredLabel: 'Erforderliche Peak C-Rate',
+  currentRatioLabel: 'Strom-Lastverhältnis',
+};
+
+const faqItems = [
+  {
+    question: 'Was bedeutet die C-Rate bei LiPo-Akkus?',
+    answer: 'Die C-Rate gibt die maximale kontinuierliche Entladerate im Verhältnis zur Akkukapazität an. Ein 1500-mAh-Akku mit 100C kann theoretisch 150 Ampere liefern.',
+  },
+  {
+    question: 'Warum unterscheidet sich die beworbene von der realen C-Rate?',
+    answer: 'Hersteller werben oft mit Peak-Werten unter Laborbedingungen. Die tatsächliche Dauerleistung hängt direkt vom Innenwiderstand der einzelnen Zellen ab.',
+  },
+  {
+    question: 'Wie wirkt sich der Innenwiderstand auf Spannung und Hitze aus?',
+    answer: 'Ein hoher Innenwiderstand wirkt wie ein störender Widerstand in der Zelle. Bei hoher Stromabgabe fällt die Spannung ab und Energie wird in Hitze umgewandelt.',
+  },
+  {
+    question: 'Wie vermeide ich Voltage Sag beim Freestyle-Fliegen?',
+    answer: 'Verwenden Sie Akkus mit niedrigem Innenwiderstand, wählen Sie eine Sicherheitsreserve von mindestens 15 Prozent über dem Spitzenverbrauch und fliegen Sie nicht unter 3.5V pro Zelle.',
+  },
+];
+
+const howToSteps = [
+  {
+    name: 'Voreinstellung wählen oder Akkudaten eingeben',
+    text: 'Geben Sie Kapazität in mAh, angegebene C-Rate, Zellenzahl und den durchschnittlichen Innenwiderstand pro Zelle ein.',
+  },
+  {
+    name: 'Motoren und Elektronik konfigurieren',
+    text: 'Tragen Sie die Anzahl der Motoren, den Spitzenstrom pro Motor bei Vollgas sowie den Zusatzverbrauch ein.',
+  },
+  {
+    name: 'Sicherheitsdiagnose und Realamperestrom prüfen',
+    text: 'Vergleichen Sie den realistischen Dauerstrom mit dem Spitzenverbrauch des Kopters für einen sicheren Flug.',
+  },
+];
+
+const seoSections: SEOSection[] = [
+  {
+    type: 'title',
+    text: 'Verständnis von LiPo C-Rate und Realleistung bei Drohnen',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Die Auswahl des richtigen LiPo-Akkus für eine FPV-Drohne erfordert das Verständnis der Zusammenhänge zwischen Kapazität, C-Rate und Stromverbrauch. Während Hersteller oft Werte von 100C oder mehr angeben, wird die reale Dauerentladung durch den Innenwiderstand und die Wärmeableitung begrenzt. Dieser Rechner ermittelt die realistische Dauerstromabgabe mit echten Sicherheitsreserven.',
+  },
+  {
+    type: 'title',
+    text: 'Vergleichstabelle für RC Akku Chemien',
+    level: 2,
+  },
+  {
+    type: 'table',
+    headers: ['Chemie', 'Nennspannung', 'Max. Spannung', 'Energiedichte', 'Peak Entladung', 'Empfohlener Einsatz'],
+    rows: [
+      ['LiPo (Standard)', '3.7V', '4.20V', 'Hoch', '100C - 150C', '5 Zoll FPV Freestyle und Racing'],
+      ['LiHV (High Voltage)', '3.8V', '4.35V', 'Sehr hoch', '80C - 120C', 'TinyWhoops und Mikro-Kopter'],
+      ['Li-Ion (18650/21700)', '3.6V', '4.20V', 'Maximum', '15C - 35C', '7 Zoll Long Range Kopter'],
+      ['LiFePO4', '3.3V', '3.65V', 'Moderat', '30C - 50C', 'Ladestationen auf dem Feld'],
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Einfluss von Voltage Sag und Innenwiderstand auf die Performance',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Voltage Sag bezeichnet den plötzlichen Spannungseinbruch unter hoher Last. Wenn Strom durch den Innenwiderstand fließt, entsteht Wärme statt Schub. Ein gealterter Akku führt zu frühzeitigen Niedrigspannungswarnungen im OSD der FPV-Brille.',
+  },
+  {
+    type: 'list',
+    items: [
+      'Niedriger Innenwiderstand (1-4 mΩ pro Zelle): Maximale Leistung, minimaler Sag und kühle Temperaturen.',
+      'Moderater Innenwiderstand (5-10 mΩ pro Zelle): Solide Standard-Performance für Freestyle.',
+      'Hoher Innenwiderstand (>12 mΩ pro Zelle): Deutlicher Leistungsverlust, starker Sag und rasche Erwärmung.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Akkuoptimierung für Freestyle Racing und Long Range',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Jeder Flugstil stellt unterschiedliche Anforderungen an die Energieversorgung. 5-Zoll-Freestyle-Kopter erzeugen Stromspitzen von über 120 Ampere, während 7-Zoll-Long-Range-Kopter gleichmäßige Effizienz benötigen. Die passende Abstimmung schützt vor Stromausfällen im Flug.',
+  },
+  {
+    type: 'tip',
+    title: 'Tipp zur Akkupflege',
+    html: 'Lagern Sie Ihre LiPo-Akkus bei Nichtgebrauch stets bei 3.80V bis 3.85V pro Zelle. Voll geladene Akkus, die länger als 48 Stunden liegen gelassen werden, verringern dauerhaft ihre Leistungsfähigkeit.',
+  },
+];
+
+const schemas: DroneBatteryCRatingCalculatorLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqItems.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    description,
+    step: howToSteps.map((s, index) => ({
+      '@type': 'HowToStep',
+      position: index + 1,
+      name: s.name,
+      text: s.text,
+    })),
+  } as WithContext<HowTo>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilityApplication',
+    operatingSystem: 'All',
+    offers: {
+      '@type': 'Offer',
+      price: '0',
+      priceCurrency: 'EUR',
+    },
+  } as WithContext<SoftwareApplication>,
+];
+
+export const content: DroneBatteryCRatingCalculatorLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo: seoSections,
+  faq: faqItems,
+  howTo: howToSteps,
+  bibliography: BIBLIOGRAPHY_ITEMS,
+  schemas,
+};