@jjlmoya/utils-drones 1.22.0 → 1.24.0

package/src/tool/fpv-drone-thrust-to-weight-ratio/logic.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import {
+  calculateTotalMaxThrust,
+  calculateTwr,
+  calculateHoverThrottle,
+  calculateCurrentThrust,
+  calculateZeroToHundred,
+  calculateRecommendedCamAngle,
+  calculateWindResistance,
+  calculateMaxPitchAngle,
+  evaluateAgilityTier,
+  evaluateBetaflightTune,
+  calculateTwrMetrics,
+  type DroneTwrInputs,
+} from './logic';
+
+describe('FPV Drone Flight Dynamics Logic', () => {
+  it('calculates total max thrust', () => {
+    expect(calculateTotalMaxThrust(4, 1950)).toBe(7800);
+    expect(calculateTotalMaxThrust(0, 1950)).toBe(0);
+  });
+
+  it('calculates TWR ratio accurately', () => {
+    expect(calculateTwr(7800, 680)).toBeCloseTo(11.47, 2);
+  });
+
+  it('calculates realistic exponential hover throttle', () => {
+    const hover5in = calculateHoverThrottle(11.47);
+    expect(hover5in).toBeGreaterThan(20);
+    expect(hover5in).toBeLessThan(35);
+  });
+
+  it('calculates dynamic thrust from stick position', () => {
+    expect(calculateCurrentThrust(7800, 0)).toBe(0);
+    expect(calculateCurrentThrust(7800, 100)).toBe(7800);
+    expect(calculateCurrentThrust(7800, 50)).toBeCloseTo(2239, -1);
+  });
+
+  it('calculates 0-100 km/h acceleration time', () => {
+    const time5in = calculateZeroToHundred(11.47);
+    expect(time5in).toBeGreaterThan(0.2);
+    expect(time5in).toBeLessThan(0.4);
+  });
+
+  it('calculates recommended FPV camera angle', () => {
+    const camAngle = calculateRecommendedCamAngle(11.47);
+    expect(camAngle).toBeGreaterThan(30);
+    expect(camAngle).toBeLessThanOrEqual(55);
+  });
+
+  it('calculates wind resistance rating', () => {
+    const wind = calculateWindResistance(11.47);
+    expect(wind).toBeGreaterThan(80);
+    expect(wind).toBeLessThan(120);
+  });
+
+  it('calculates max pitch angle', () => {
+    expect(calculateMaxPitchAngle(11.47)).toBeGreaterThan(80);
+    expect(calculateMaxPitchAngle(1.0)).toBe(0);
+  });
+
+  it('evaluates flight agility tier', () => {
+    expect(evaluateAgilityTier(1.5)).toBe('underpowered');
+    expect(evaluateAgilityTier(3.0)).toBe('cinematic');
+    expect(evaluateAgilityTier(6.5)).toBe('freestyle');
+    expect(evaluateAgilityTier(10.0)).toBe('acro_pro');
+    expect(evaluateAgilityTier(15.0)).toBe('racing_extreme');
+  });
+
+  it('evaluates Betaflight tune advice', () => {
+    const tune5in = evaluateBetaflightTune(11.47, 680);
+    expect(tune5in.tpaSetting).toContain('0.65');
+    expect(tune5in.dynamicIdleSetting).toContain('5.5%');
+  });
+
+  it('computes full aggregate metrics on live inputs', () => {
+    const inputs: DroneTwrInputs = {
+      auwGrams: 680,
+      motorCount: 4,
+      thrustPerMotorGrams: 1950,
+      propellerSizeInches: 5.1,
+      propellerPitchInches: 4.3,
+      bladeCount: 3,
+      throttleStickPercent: 75,
+    };
+    const results = calculateTwrMetrics(inputs);
+    expect(results.twrRatio).toBeCloseTo(11.47, 2);
+    expect(results.currentThrustGrams).toBeGreaterThan(4000);
+    expect(results.instantGForce).toBeGreaterThan(6);
+    expect(results.agilityTier).toBe('acro_pro');
+    expect(results.tuneAdvice.tpaSetting).toBeDefined();
+  });
+});

package/src/tool/fpv-drone-thrust-to-weight-ratio/logic.ts

@@ -0,0 +1,147 @@
+export type AgilityTier = 'underpowered' | 'cinematic' | 'freestyle' | 'acro_pro' | 'racing_extreme';
+
+export interface DroneTwrInputs {
+  auwGrams: number;
+  motorCount: number;
+  thrustPerMotorGrams: number;
+  propellerSizeInches: number;
+  propellerPitchInches: number;
+  bladeCount: number;
+  throttleStickPercent: number;
+}
+
+export interface BetaflightTuneAdvice {
+  tpaSetting: string;
+  dynamicIdleSetting: string;
+  propwashRisk: string;
+}
+
+export interface DroneTwrResults {
+  totalMaxThrustGrams: number;
+  twrRatio: number;
+  hoverThrottlePercent: number;
+  currentThrottlePercent: number;
+  currentThrustGrams: number;
+  instantGForce: number;
+  zeroToHundredTimeSec: number;
+  recommendedCamAngleDeg: number;
+  windResistanceKmh: number;
+  maxPitchAngleDeg: number;
+  agilityTier: AgilityTier;
+  tuneAdvice: BetaflightTuneAdvice;
+}
+
+export function calculateTotalMaxThrust(motorCount: number, thrustPerMotorGrams: number): number {
+  if (motorCount <= 0 || thrustPerMotorGrams <= 0) return 0;
+  return motorCount * thrustPerMotorGrams;
+}
+
+export function calculateTwr(totalThrustGrams: number, auwGrams: number): number {
+  if (totalThrustGrams <= 0 || auwGrams <= 0) return 0;
+  return totalThrustGrams / auwGrams;
+}
+
+export function calculateHoverThrottle(twr: number): number {
+  if (twr <= 1) return 100;
+  const linearFraction = 1 / twr;
+  const throttlePercent = Math.pow(linearFraction, 1 / 1.8) * 100;
+  return Math.min(100, Math.max(5, Math.round(throttlePercent * 10) / 10));
+}
+
+export function calculateCurrentThrust(maxThrust: number, throttlePercent: number): number {
+  if (maxThrust <= 0 || throttlePercent <= 0) return 0;
+  const normalized = Math.min(100, Math.max(0, throttlePercent)) / 100;
+  const factor = Math.pow(normalized, 1.8);
+  return Math.round(maxThrust * factor);
+}
+
+export function calculateZeroToHundred(twr: number): number {
+  if (twr <= 1.05) return 0;
+  const netAccelMps2 = (twr - 1) * 9.81;
+  const targetVelocityMps = 100 / 3.6;
+  const timeSec = targetVelocityMps / netAccelMps2;
+  return Math.max(0.2, Math.round(timeSec * 100) / 100);
+}
+
+export function calculateRecommendedCamAngle(twr: number): number {
+  if (twr <= 1.2) return 15;
+  const cruiseTwr = Math.max(1.05, twr * 0.35);
+  const radians = Math.acos(1 / cruiseTwr);
+  const degrees = Math.round(radians * (180 / Math.PI));
+  return Math.min(55, Math.max(15, degrees));
+}
+
+export function calculateWindResistance(twr: number): number {
+  if (twr <= 0) return 0;
+  const baseKmh = Math.sqrt(Math.max(0, twr - 0.5)) * 28;
+  return Math.min(160, Math.round(baseKmh));
+}
+
+export function calculateMaxPitchAngle(twr: number): number {
+  if (twr <= 1.05) return 0;
+  const radians = Math.acos(1 / twr);
+  return Math.min(85, Math.round(radians * (180 / Math.PI)));
+}
+
+export function evaluateAgilityTier(twr: number): AgilityTier {
+  if (twr < 2.0) return 'underpowered';
+  if (twr < 4.0) return 'cinematic';
+  if (twr < 8.0) return 'freestyle';
+  if (twr < 13.0) return 'acro_pro';
+  return 'racing_extreme';
+}
+
+function getTpaSetting(twr: number): string {
+  if (twr >= 12) return 'TPA 0.75 @ 1250';
+  if (twr >= 8) return 'TPA 0.65 @ 1350';
+  return 'TPA 0.45 @ 1500';
+}
+
+function getDynamicIdleSetting(auwGrams: number): string {
+  if (auwGrams < 100) return 'Idle 4.0% (Micro)';
+  if (auwGrams > 1000) return 'Idle 6.0% (Heavy)';
+  return 'Idle 5.5% (Standard 5")';
+}
+
+function getPropwashRisk(twr: number): string {
+  if (twr >= 10) return 'High Authority (Low Wash)';
+  if (twr >= 5) return 'Moderate (Tune D-Term)';
+  return 'High Wash Sensitivity';
+}
+
+export function evaluateBetaflightTune(twr: number, auwGrams: number): BetaflightTuneAdvice {
+  return {
+    tpaSetting: getTpaSetting(twr),
+    dynamicIdleSetting: getDynamicIdleSetting(auwGrams),
+    propwashRisk: getPropwashRisk(twr),
+  };
+}
+
+export function calculateTwrMetrics(inputs: DroneTwrInputs): DroneTwrResults {
+  const totalMaxThrustGrams = calculateTotalMaxThrust(inputs.motorCount, inputs.thrustPerMotorGrams);
+  const twrRatio = calculateTwr(totalMaxThrustGrams, inputs.auwGrams);
+  const hoverThrottlePercent = calculateHoverThrottle(twrRatio);
+  const currentThrustGrams = calculateCurrentThrust(totalMaxThrustGrams, inputs.throttleStickPercent);
+  const instantGForce = inputs.auwGrams > 0 ? Math.round((currentThrustGrams / inputs.auwGrams) * 100) / 100 : 0;
+  const zeroToHundredTimeSec = calculateZeroToHundred(twrRatio);
+  const recommendedCamAngleDeg = calculateRecommendedCamAngle(twrRatio);
+  const windResistanceKmh = calculateWindResistance(twrRatio);
+  const maxPitchAngleDeg = calculateMaxPitchAngle(twrRatio);
+  const agilityTier = evaluateAgilityTier(twrRatio);
+  const tuneAdvice = evaluateBetaflightTune(twrRatio, inputs.auwGrams);
+
+  return {
+    totalMaxThrustGrams,
+    twrRatio,
+    hoverThrottlePercent,
+    currentThrottlePercent: inputs.throttleStickPercent,
+    currentThrustGrams,
+    instantGForce,
+    zeroToHundredTimeSec,
+    recommendedCamAngleDeg,
+    windResistanceKmh,
+    maxPitchAngleDeg,
+    agilityTier,
+    tuneAdvice,
+  };
+}

package/src/tool/fpv-drone-thrust-to-weight-ratio/seo.astro

@@ -0,0 +1,16 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { fpvDroneThrustToWeightRatio } from './entry';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const loader = fpvDroneThrustToWeightRatio.i18n[locale] || fpvDroneThrustToWeightRatio.i18n.en;
+const content = await loader?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/fpv-drone-thrust-to-weight-ratio/storage.ts

@@ -0,0 +1,19 @@
+import type { DroneTwrInputs } from './logic';
+
+const STORAGE_KEY = 'jjl_drone_twr_inputs';
+
+export function loadSavedInputs(): Partial<DroneTwrInputs> {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return {};
+    return JSON.parse(raw) as Partial<DroneTwrInputs>;
+  } catch {
+    return {};
+  }
+}
+
+export function saveInputs(inputs: DroneTwrInputs): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(inputs));
+  } catch {}
+}

package/src/tool/fpv-drone-thrust-to-weight-ratio/ui.ts

@@ -0,0 +1,58 @@
+export interface FpvDroneThrustToWeightRatioUI {
+  [key: string]: string;
+  title: string;
+  subtitle: string;
+  presetsHeader: string;
+  customPreset: string;
+  whoop1sPreset: string;
+  freestyle35Preset: string;
+  freestyle5Preset: string;
+  longrange7Preset: string;
+  cinelifter8Preset: string;
+  specsHeader: string;
+  auwGramsLabel: string;
+  motorCountLabel: string;
+  thrustPerMotorLabel: string;
+  propellerSizeLabel: string;
+  propellerPitchLabel: string;
+  bladeCountLabel: string;
+  blade2Option: string;
+  blade3Option: string;
+  blade4Option: string;
+  throttleStickHeader: string;
+  throttleStickLabel: string;
+  snapIdleLabel: string;
+  snapHoverLabel: string;
+  snapCruiseLabel: string;
+  snapPunchLabel: string;
+  telemetryHeader: string;
+  twrRatioLabel: string;
+  hoverThrottleLabel: string;
+  currentThrustLabel: string;
+  instantGForceLabel: string;
+  zeroToHundredLabel: string;
+  recommendedCamAngleLabel: string;
+  windResistanceLabel: string;
+  totalMaxThrustLabel: string;
+  maxPitchAngleLabel: string;
+  tuningHeader: string;
+  tpaRecommendationLabel: string;
+  dynamicIdleLabel: string;
+  propwashRiskLabel: string;
+  tierUnderpoweredTitle: string;
+  tierUnderpoweredDesc: string;
+  tierCinematicTitle: string;
+  tierCinematicDesc: string;
+  tierFreestyleTitle: string;
+  tierFreestyleDesc: string;
+  tierAcroProTitle: string;
+  tierAcroProDesc: string;
+  tierRacingExtremeTitle: string;
+  tierRacingExtremeDesc: string;
+  hudThrustCurveTitle: string;
+  hudHoverMarker: string;
+  hudCurrentStickMarker: string;
+  hudGForceLabel: string;
+  hudTiltAngleLabel: string;
+  hudVectorPowerLabel: string;
+}

package/src/tools.ts

@@ -5,6 +5,7 @@ import { GPS_COORDINATES_CONVERTER_TOOL } from './tool/gps-coordinates-converter
 import { DRONE_POWER_ANALYZER_TOOL } from './tool/drone-power-analyzer/index';
 import { GSD_FLIGHT_PLANNER_TOOL } from './tool/gsd-flight-planner/index';
 import { DRONE_BATTERY_C_RATING_CALCULATOR_TOOL } from './tool/drone-battery-c-rating-calculator/index';
+import { FPV_DRONE_THRUST_TO_WEIGHT_RATIO_TOOL } from './tool/fpv-drone-thrust-to-weight-ratio/index';
 import type { ToolDefinition } from './types';
 
 export const ALL_TOOLS: ToolDefinition[] = [
@@ -14,6 +15,7 @@ export const ALL_TOOLS: ToolDefinition[] = [
   DRONE_POWER_ANALYZER_TOOL,
   GSD_FLIGHT_PLANNER_TOOL,
   DRONE_BATTERY_C_RATING_CALCULATOR_TOOL,
+  FPV_DRONE_THRUST_TO_WEIGHT_RATIO_TOOL,
 ];
 
 export {
@@ -23,4 +25,5 @@ export {
   DRONE_POWER_ANALYZER_TOOL,
   GSD_FLIGHT_PLANNER_TOOL,
   DRONE_BATTERY_C_RATING_CALCULATOR_TOOL,
+  FPV_DRONE_THRUST_TO_WEIGHT_RATIO_TOOL,
 };