@jjlmoya/utils-drones 1.35.0 → 1.37.0

package/src/tool/fpv-drone-speed-calculator/logic.ts

@@ -0,0 +1,126 @@
+export interface FpvDroneSpeedInputs {
+  motorKv: number;
+  batteryVoltage: number;
+  propellerPitchInches: number;
+  efficiencyPercent: number;
+  aircraftMassGrams: number;
+}
+
+export type SpeedDiagnosis = 'overspeed' | 'high-slip' | 'heavy-load' | 'planning';
+
+export interface SpeedSensitivityPoint {
+  label: 'lower' | 'current' | 'higher';
+  pitchInches: number;
+  speedKmh: number;
+}
+
+export interface FpvDroneSpeedResults {
+  noLoadRpm: number;
+  loadedRpm: number;
+  pitchSpeedKmh: number;
+  estimatedSpeedKmh: number;
+  slipPercent: number;
+  loadPenaltyPercent: number;
+  rpmPerVolt: number;
+  diagnosis: SpeedDiagnosis;
+  sensitivity: SpeedSensitivityPoint[];
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function validInputs(inputs: FpvDroneSpeedInputs): boolean {
+  return inputs.motorKv > 0
+    && inputs.batteryVoltage > 0
+    && inputs.propellerPitchInches > 0
+    && inputs.efficiencyPercent > 0
+    && inputs.aircraftMassGrams > 0;
+}
+
+export function calculateNoLoadRpm(motorKv: number, batteryVoltage: number): number {
+  if (motorKv <= 0 || batteryVoltage <= 0) return 0;
+  return motorKv * batteryVoltage;
+}
+
+export function calculateLoadedRpm(inputs: FpvDroneSpeedInputs): number {
+  if (!validInputs(inputs)) return 0;
+  const noLoadRpm = calculateNoLoadRpm(inputs.motorKv, inputs.batteryVoltage);
+  const efficiencyFactor = 0.82 + clamp(inputs.efficiencyPercent, 50, 98) / 1000;
+  const loadFactor = clamp(0.98 - inputs.aircraftMassGrams / 12000, 0.78, 0.98);
+  return Math.round(noLoadRpm * efficiencyFactor * loadFactor);
+}
+
+export function calculatePitchSpeedKmh(propellerPitchInches: number, rpm: number): number {
+  if (propellerPitchInches <= 0 || rpm <= 0) return 0;
+  return propellerPitchInches * rpm * 0.001524;
+}
+
+export function calculateEstimatedSpeedKmh(pitchSpeedKmh: number, efficiencyPercent: number): number {
+  if (pitchSpeedKmh <= 0 || efficiencyPercent <= 0) return 0;
+  return pitchSpeedKmh * clamp(efficiencyPercent, 50, 98) / 100;
+}
+
+export function calculateSlipPercent(pitchSpeedKmh: number, estimatedSpeedKmh: number): number {
+  if (pitchSpeedKmh <= 0) return 0;
+  return clamp((1 - estimatedSpeedKmh / pitchSpeedKmh) * 100, 0, 60);
+}
+
+export function calculateLoadPenaltyPercent(aircraftMassGrams: number): number {
+  if (aircraftMassGrams <= 0) return 0;
+  return (1 - clamp(0.98 - aircraftMassGrams / 12000, 0.78, 0.98)) * 100;
+}
+
+export function diagnoseSpeed(inputs: FpvDroneSpeedInputs, slipPercent: number): SpeedDiagnosis {
+  const noLoadRpm = calculateNoLoadRpm(inputs.motorKv, inputs.batteryVoltage);
+  if (noLoadRpm > 140000) return 'overspeed';
+  if (slipPercent >= 28) return 'high-slip';
+  if (inputs.aircraftMassGrams >= 2500) return 'heavy-load';
+  return 'planning';
+}
+
+function makeSensitivity(inputs: FpvDroneSpeedInputs, loadedRpm: number): SpeedSensitivityPoint[] {
+  const lowerPitch = Math.max(0.5, inputs.propellerPitchInches - 0.5);
+  const higherPitch = inputs.propellerPitchInches + 0.5;
+  return [
+    { label: 'lower', pitchInches: lowerPitch, speedKmh: calculateEstimatedSpeedKmh(calculatePitchSpeedKmh(lowerPitch, loadedRpm), inputs.efficiencyPercent) },
+    { label: 'current', pitchInches: inputs.propellerPitchInches, speedKmh: calculateEstimatedSpeedKmh(calculatePitchSpeedKmh(inputs.propellerPitchInches, loadedRpm), inputs.efficiencyPercent) },
+    { label: 'higher', pitchInches: higherPitch, speedKmh: calculateEstimatedSpeedKmh(calculatePitchSpeedKmh(higherPitch, loadedRpm), inputs.efficiencyPercent) },
+  ];
+}
+
+function emptyResults(): FpvDroneSpeedResults {
+  return {
+    noLoadRpm: 0,
+    loadedRpm: 0,
+    pitchSpeedKmh: 0,
+    estimatedSpeedKmh: 0,
+    slipPercent: 0,
+    loadPenaltyPercent: 0,
+    rpmPerVolt: 0,
+    diagnosis: 'planning',
+    sensitivity: [],
+  };
+}
+
+export function calculateFpvDroneSpeed(inputs: FpvDroneSpeedInputs): FpvDroneSpeedResults {
+  if (!validInputs(inputs)) return emptyResults();
+
+  const noLoadRpm = calculateNoLoadRpm(inputs.motorKv, inputs.batteryVoltage);
+  const loadedRpm = calculateLoadedRpm(inputs);
+  const pitchSpeedKmh = calculatePitchSpeedKmh(inputs.propellerPitchInches, loadedRpm);
+  const estimatedSpeedKmh = calculateEstimatedSpeedKmh(pitchSpeedKmh, inputs.efficiencyPercent);
+  const slipPercent = calculateSlipPercent(pitchSpeedKmh, estimatedSpeedKmh);
+
+  return {
+    noLoadRpm,
+    loadedRpm,
+    pitchSpeedKmh,
+    estimatedSpeedKmh,
+    slipPercent,
+    loadPenaltyPercent: calculateLoadPenaltyPercent(inputs.aircraftMassGrams),
+    rpmPerVolt: inputs.motorKv,
+    diagnosis: diagnoseSpeed(inputs, slipPercent),
+    sensitivity: makeSensitivity(inputs, loadedRpm),
+  };
+}

package/src/tool/fpv-drone-speed-calculator/seo.astro

@@ -0,0 +1,16 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { fpvDroneSpeedCalculator } from './entry';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const loader = fpvDroneSpeedCalculator.i18n[locale] || fpvDroneSpeedCalculator.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-speed-calculator/ui.ts

@@ -0,0 +1,47 @@
+export interface FpvDroneSpeedUI extends Record<string, string> {
+  presetsLabel: string;
+  presetRacing: string;
+  presetFreestyle: string;
+  presetCruiser: string;
+  unitsLabel: string;
+  metricUnit: string;
+  imperialUnit: string;
+  inputsLabel: string;
+  motorKvLabel: string;
+  batteryVoltageLabel: string;
+  propellerPitchLabel: string;
+  efficiencyLabel: string;
+  aircraftMassLabel: string;
+  calculateFromLabel: string;
+  resultsLabel: string;
+  estimatedSpeedLabel: string;
+  pitchSpeedLabel: string;
+  loadedRpmLabel: string;
+  noLoadRpmLabel: string;
+  slipLabel: string;
+  loadEffectLabel: string;
+  speedLaneLabel: string;
+  sensitivityLabel: string;
+  lowerPitchLabel: string;
+  selectedPitchLabel: string;
+  higherPitchLabel: string;
+  diagnosisLabel: string;
+  diagnosisPlanning: string;
+  diagnosisHighSlip: string;
+  diagnosisHeavyLoad: string;
+  diagnosisOverspeed: string;
+  diagnosisPlanningAdvice: string;
+  diagnosisHighSlipAdvice: string;
+  diagnosisHeavyLoadAdvice: string;
+  diagnosisOverspeedAdvice: string;
+  assumptionsLabel: string;
+  assumptionsText: string;
+  safetyText: string;
+  speedAxisStart: string;
+  speedAxisEnd: string;
+  noLoadCaption: string;
+  loadedCaption: string;
+  slipCaption: string;
+  massUnit: string;
+  speedUnit: string;
+}

package/src/tools.ts

@@ -7,6 +7,8 @@ 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 { DRONE_MOTOR_PROPELLER_CALCULATOR_TOOL } from './tool/drone-motor-propeller-calculator/index';
+import { FPV_DRONE_SPEED_CALCULATOR_TOOL } from './tool/fpv-drone-speed-calculator/index';
+import { DRONE_MISSION_BATTERY_RESERVE_PLANNER_TOOL } from './tool/drone-mission-battery-reserve-planner/index';
 import type { ToolDefinition } from './types';
 
 export const ALL_TOOLS: ToolDefinition[] = [
@@ -18,6 +20,8 @@ export const ALL_TOOLS: ToolDefinition[] = [
   DRONE_BATTERY_C_RATING_CALCULATOR_TOOL,
   FPV_DRONE_THRUST_TO_WEIGHT_RATIO_TOOL,
   DRONE_MOTOR_PROPELLER_CALCULATOR_TOOL,
+  FPV_DRONE_SPEED_CALCULATOR_TOOL,
+  DRONE_MISSION_BATTERY_RESERVE_PLANNER_TOOL,
 ];
 
 export {
@@ -29,4 +33,7 @@ export {
   DRONE_BATTERY_C_RATING_CALCULATOR_TOOL,
   FPV_DRONE_THRUST_TO_WEIGHT_RATIO_TOOL,
   DRONE_MOTOR_PROPELLER_CALCULATOR_TOOL,
+  FPV_DRONE_SPEED_CALCULATOR_TOOL,
+  DRONE_MISSION_BATTERY_RESERVE_PLANNER_TOOL,
 };
+