diff --git a/src/components/layout/Dashboard.tsx b/src/components/layout/Dashboard.tsx index 451207b..dbc9008 100644 --- a/src/components/layout/Dashboard.tsx +++ b/src/components/layout/Dashboard.tsx @@ -11,6 +11,7 @@ import { type BoardSummary, type WirelessBoardInfo, } from "@/components/widgets/BoardStatusWidget"; +import { AltitudeTape } from "@/components/widgets/AltitudeTape"; import { useBackendConnection } from "@/hooks/useBackendConnection"; import { useBoardConnection } from "@/hooks/useBoardConnection"; @@ -98,7 +99,7 @@ export const Dashboard: FC = () => { return (
{/* Left Side - 3D Model */} -
+
{ {darkMode ? : }
- + +
+
+ +
+ +
+ +
+
{/* Right Side - Data Panels */} -
+
{ + if (typeof override === "number" && Number.isFinite(override) && override > 0) { + return override; + } + + /* Rev 3's barometer has a different max altitude, so we could + apply scaling based on the platform using this function. This + is postponed for now, though. */ + + return DEFAULT_ALTITUDE_MAXIMUM_METERS; +}; + +/* -- View & Presenter -- */ +export interface AltitudeTapeProps { + altitudeMeters: number; + altitudeMaximumMeters?: number; +} + +export const AltitudeTape: FC = ({ + altitudeMeters, + altitudeMaximumMeters, +}) => { + const [hasReceivedReading, setHasReceivedReading] = useState(false); + + useEffect(() => { + if (altitudeMeters > 0 && !hasReceivedReading) { + setHasReceivedReading(true); + } + }, [altitudeMeters, hasReceivedReading]); + + // Inline style rather than a Tailwind class, since the duration is + // computed at runtime from POLLING_INTERVAL_MS and won't survive + // Tailwind's JIT class scanning as a template string. + const trackTransitionStyle = hasReceivedReading + ? { transition: `bottom ${TRACK_TRANSITION_MS}ms` } + : {}; + + const maximum = getAltitudeMaximumMeters(altitudeMaximumMeters); + const safeAltitude = Number.isFinite(altitudeMeters) ? altitudeMeters : 0; + const clampedAltitude = Math.max(0, Math.min(safeAltitude, maximum)); + const fillPercent = maximum > 0 ? (clampedAltitude / maximum) * 100 : 0; + const clampedFillPercent = Math.max(0, Math.min(fillPercent, 100)); + const fillFraction = clampedFillPercent / 100; + + // Both the bar and the pill sit within the space above the ground band, + // so 0% lands right at the top of the ground band instead of the very + // bottom of the container. The top of the container is also reserved, + // meaning the pill position will latch at maxAltitude and keep from + // blocking the unit readout. + const trackPosition = `calc(${fillFraction} * (100% - ${GROUND_BAND_REM}rem - ${TOP_CLEARANCE_REM}rem) + ${GROUND_BAND_REM}rem)`; + + // Widget Layout + return ( +
+
+
+
+
+
+ +
+ Altitude + ({altitudeHandler.getReferenceMode()}) +
+ +
+
+ {altitudeHandler.getDisplayString(altitudeMeters)} +
+
+
+ ); +}; \ No newline at end of file diff --git a/src/components/widgets/SensorReadingWidget.tsx b/src/components/widgets/SensorReadingWidget.tsx index 646ec5c..e81bd03 100644 --- a/src/components/widgets/SensorReadingWidget.tsx +++ b/src/components/widgets/SensorReadingWidget.tsx @@ -1,10 +1,11 @@ import type { FC } from "react"; +import ConversionFactors, { altitudeHandler, accelerationHandler } from "@/utils/units/units" export interface SensorData { - quat_w: number; - quat_x: number; - quat_y: number; - quat_z: number; + w: number; + x: number; + y: number; + z: number; alt: number; long: number; lat: number; @@ -18,7 +19,7 @@ export interface SensorReadingWidgetProps { interface DataItem { label: string; - value: number; + value: string; } interface DataGroupProps { @@ -26,18 +27,6 @@ interface DataGroupProps { data: DataItem[]; } -function padNumber(value: number, length = 6): string { - const str = String(value); - if (str.startsWith("-")) { - return `-${str.slice(1).padStart(length, "0")}`; - } - return str.padStart(length, "0"); -} - -function formatValue(value: number): string { - return value === 0 ? "0" : padNumber(value); -} - const DataGroup: FC = ({ title, data }) => (

{title}

@@ -45,7 +34,7 @@ const DataGroup: FC = ({ title, data }) => ( {data.map(({ label, value }) => (
{label} - {formatValue(value)} + {value}
))}
@@ -53,16 +42,16 @@ const DataGroup: FC = ({ title, data }) => ( ); export const SensorReadingWidget: FC = ({ sensorData }) => { - const { - quat_w, - quat_x, - quat_y, - quat_z, - alt, - long, + const { + w, /* unit quaternions (orientation) */ + x, + y, + z, + alt, /* alt (m) */ + long, /* last GPS ping */ lat, - acc_z, - roll_rate, + acc_z, /* accel on thrust axis */ + roll_rate /* rate of body roll */ } = sensorData; return ( @@ -72,17 +61,25 @@ export const SensorReadingWidget: FC = ({ sensorData } +
diff --git a/src/hooks/useSensorData.ts b/src/hooks/useSensorData.ts index 26080e0..17fc5ab 100644 --- a/src/hooks/useSensorData.ts +++ b/src/hooks/useSensorData.ts @@ -3,6 +3,9 @@ import { api } from "@/utils/api"; import { MockFlight } from "@/utils/mock"; import type { SensorData } from "@/components/widgets/SensorReadingWidget"; +/** Used for renderers to determine the fastest possible update rate */ +export const POLLING_INTERVAL_MS = 40; + /** * Raw sensor payload shape coming from the backend / mock flight source. * Field names mirror the device's wire format before conversion to the @@ -21,18 +24,16 @@ interface RawSensorPacket { length?: number; } -const POLLING_INTERVAL_MS = 40; - const INITIAL_SENSOR_DATA: SensorData = { - quatW: 1, - quatX: 0, - quatY: 0, - quatZ: 0, - altitude: 0, - longitude: 0, - latitude: 0, - accelerationZ: 0, - rollRate: 0, + w: 1, + x: 0, + y: 0, + z: 0, + alt: 0, + long: 0, + lat: 0, + acc_z: 0, + roll_rate: 0, }; /** Formats a raw numeric value, falling back to the previous value when invalid. */ @@ -43,24 +44,22 @@ function toFixedOrPrevious(value: number | undefined, previous: number, digits = return Number(Number(value).toFixed(digits)); } -function parseSensorData(data: RawSensorPacket | null, prevState: SensorData): SensorData { +function parseSensorData(data: RawSensorPacket | null | undefined, prevState: SensorData): SensorData { if (!data) { return prevState; } return { - quatW: toFixedOrPrevious(data.quat_w, prevState.quatW, 6), - quatX: toFixedOrPrevious(data.quat_x, prevState.quatX, 6), - quatY: toFixedOrPrevious(data.quat_y, prevState.quatY, 6), - quatZ: toFixedOrPrevious(data.quat_z, prevState.quatZ, 6), - - altitude: toFixedOrPrevious(data.alt, prevState.altitude), - - longitude: data.lat !== 0 || data.long !== 0 ? (data.long ?? prevState.longitude) : prevState.longitude, - latitude: data.lat !== 0 || data.long !== 0 ? (data.lat ?? prevState.latitude) : prevState.latitude, - - accelerationZ: toFixedOrPrevious(data.acc_z, prevState.accelerationZ), - rollRate: toFixedOrPrevious(data.roll_rate, prevState.rollRate), + w: toFixedOrPrevious(data.quat_w, prevState.w, 6), + x: toFixedOrPrevious(data.quat_x, prevState.x, 6), + y: toFixedOrPrevious(data.quat_y, prevState.y, 6), + z: toFixedOrPrevious(data.quat_z, prevState.z, 6), + + alt: toFixedOrPrevious(data.alt, prevState.alt), + long: data.lat !== 0 || data.long !== 0 ? (data.long ?? prevState.long) : prevState.long, + lat: data.lat !== 0 || data.long !== 0 ? (data.lat ?? prevState.lat) : prevState.lat, + acc_z: toFixedOrPrevious(data.acc_z, prevState.acc_z), + roll_rate: toFixedOrPrevious(data.roll_rate, prevState.roll_rate), }; } @@ -74,7 +73,7 @@ export const useSensorData = ( const fetchData = useCallback(async () => { try { - const result: RawSensorPacket = mock + const result: RawSensorPacket | undefined = mock ? await MockFlight.getSensorData(rowCount) : (await api.getSensorData()).data; diff --git a/src/utils/Three.tsx b/src/utils/Three.tsx index 25dd6f8..5cca347 100644 --- a/src/utils/Three.tsx +++ b/src/utils/Three.tsx @@ -1,12 +1,12 @@ declare module "three"; declare module "three/examples/jsm/loaders/STLLoader"; declare module "three/examples/jsm/effects/OutlineEffect.js"; - + import * as THREE from "three"; import { useEffect, useRef, type FC } from "react"; import { STLLoader } from "three/examples/jsm/loaders/STLLoader"; import { OutlineEffect } from "three/examples/jsm/effects/OutlineEffect.js"; - + export interface MyThreeProps { w: number; x: number; @@ -14,14 +14,14 @@ export interface MyThreeProps { z: number; lightMode: boolean; } - + interface OutlineParameters { thickness: number; color: number[]; alpha: number; visible: boolean; } - + interface OutlinedMesh extends THREE.Mesh { material: THREE.MeshStandardMaterial & { userData: { @@ -29,70 +29,117 @@ interface OutlinedMesh extends THREE.Mesh { }; }; } - + const GRID_SIZE = 20; const GRID_DIVISIONS = 20; const GRID_OFFSET = 6; const BG_TRANSITION_DURATION_MS = 300; - + /** - * Converts a quaternion (w, x, y, z) to a THREE.Quaternion, normalising it - * first so an unnormalised or zero quaternion never breaks the renderer. + * Change-of-basis quaternion mapping the firmware body frame + * (+X = nose/roll axis, +Y = right/pitch axis, +Z = down/yaw axis, + * right-handed) onto Three.js's world frame (+Y up, right-handed). + * + * At the identity orientation the model's nose points along Three's + * +Y (see baseQuat below), so firmware's roll axis (body +X) must map + * onto world +Y for a roll command to spin the model about its own + * nose-to-tail axis on screen. + * + * A single 90° rotation about one coordinate axis can satisfy that + * roll mapping on its own, but it only swaps the *other* two axes + * with each other rather than assigning each firmware axis its own + * distinct world axis — that's what caused pitch and yaw to swap. + * What's actually needed is a full cyclic permutation of all three + * axes: X_fw -> Y_three, Y_fw -> Z_three, Z_fw -> X_three. That + * specific permutation is a 120° rotation about the (1,1,1) diagonal. + * + * NOTE: this axis/angle must match the firmware's actual inertial + * reference convention. Verify empirically — command a pure roll and + * confirm the model spins about its own nose-to-tail axis, then pure + * pitch and pure yaw and confirm each tips the nose in the expected + * plane — before relying on this in flight-critical contexts. If any + * single axis turns the wrong direction (mirrored) once the plane of + * rotation is otherwise correct, that's a separate, per-axis sign fix + * rather than a change to this permutation. + */ +const FRAME_QUAT = new THREE.Quaternion().setFromAxisAngle( + new THREE.Vector3(1, 1, 1).normalize(), + (2 * Math.PI) / 3, +); +const FRAME_QUAT_INV = FRAME_QUAT.clone().invert(); + +/** + * Converts a firmware body-frame quaternion (w, x, y, z) into a + * THREE.Quaternion expressed in Three's world frame. + * + * Two things happen here: + * 1. Reordering into THREE's (x, y, z, w) constructor convention. + * 2. Re-expressing the rotation in Three's coordinate system via + * similarity transform (conjugation), since firmware's body-frame + * axes are not the same axes as Three's world frame axes. This is + * NOT the same as composing two rotations (simple multiplication) — + * conjugation is what's required when changing the basis a + * rotation is expressed in, rather than combining two rotations + * that already live in the same frame. + * + * Falls back to identity if the input quaternion is degenerate. */ function toThreeQuat(w: number, x: number, y: number, z: number): THREE.Quaternion { const q = new THREE.Quaternion(x, y, z, w); // THREE: (x, y, z, w) const len = q.length(); - // Fall back to identity if the quaternion is degenerate if (len < 1e-6) return new THREE.Quaternion(0, 0, 0, 1); - return q.normalize(); + q.normalize(); + + // Re-express the firmware-frame rotation in Three's world frame + return FRAME_QUAT.clone().multiply(q).multiply(FRAME_QUAT_INV); } - + export const MyThree: FC = ({ w, x, y, z, lightMode }) => { const refContainer = useRef(null); const rendererRef = useRef(null); const sceneRef = useRef(null); const rocketRef = useRef(null); const ambientLightRef = useRef(null); - + const bgColor = lightMode ? 0x272727 : 0xcacaca; - + // darkmode : lightmode const rocketOutlineColor = lightMode ? new THREE.Color(20, 20, 20) : new THREE.Color(0, 0, 0); const rocketOutlineThickness = lightMode ? 0.005 : 0.0075; const rocketOutlineAlpha = lightMode ? 0.4 : 0.8; - + const ambientLightIntensity = lightMode ? 0.4 : 0.85; - + // Animate scene background + outline/lighting when lightMode changes useEffect(() => { const scene = sceneRef.current; const rocket = rocketRef.current; const ambient = ambientLightRef.current; if (!scene || !rocket || !ambient || !scene.background) return; - + const startColor = (scene.background as THREE.Color).clone(); const endColor = new THREE.Color(bgColor); const startTime = performance.now(); - + function animateBackground() { const elapsed = performance.now() - startTime; const t = Math.min(elapsed / BG_TRANSITION_DURATION_MS, 1); - + (scene.background as THREE.Color).copy(startColor).lerp(endColor, t); - + if (t < 1) { requestAnimationFrame(animateBackground); } else { (scene.background as THREE.Color).copy(endColor); } } - + animateBackground(); - + ambient.intensity = ambientLightIntensity; - + const outline = rocket.material.userData.outlineParameters; outline.color[0] = rocketOutlineColor.r; outline.color[1] = rocketOutlineColor.g; @@ -107,43 +154,43 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { rocketOutlineThickness, rocketOutlineAlpha, ]); - + // One-time scene setup useEffect(() => { const container = refContainer.current; if (!container) return; - + const width = container.clientWidth; const height = container.clientHeight; - + const scene = new THREE.Scene(); scene.background = new THREE.Color(bgColor); const camera = new THREE.PerspectiveCamera(80, width / height, 0.1, 1000); const renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(width, height); - + rendererRef.current = renderer; sceneRef.current = scene; - + container.appendChild(renderer.domElement); - + const loader = new STLLoader(); const effect = new OutlineEffect(renderer); - + loader.load("/NautilusModel.stl", (geometry) => { const posAttr = geometry.attributes.position; const vertexCount = posAttr.count; - + geometry.computeBoundingBox(); const bbox = geometry.boundingBox; if (!bbox) return; - + const minZ = bbox.min.z; const maxZ = bbox.max.z; const height3d = maxZ - minZ; const thresholdZ = minZ + Math.floor(0.855 * height3d); - + const finsMask = new Float32Array(vertexCount); for (let i = 0; i < vertexCount; i++) { const x = posAttr.getX(i); @@ -155,7 +202,7 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { finsMask[i] = 0.0; } } - + const colors = new Float32Array(vertexCount * 3); for (let i = 0; i < vertexCount; i++) { const z = posAttr.getZ(i); @@ -172,14 +219,14 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { colors[i * 3 + 1] = 0.9; colors[i * 3 + 2] = 0.9; } - + if (finsMask[i] > 0.9) { colors[i * 3 + 0] = 1.0; colors[i * 3 + 1] = 0.051; colors[i * 3 + 2] = 0.051; } } - + geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3)); const material = new THREE.MeshStandardMaterial({ color: 0xfafafa, @@ -187,18 +234,18 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { flatShading: true, vertexColors: true, }); - + material.userData.outlineParameters = { thickness: rocketOutlineThickness, color: rocketOutlineColor.toArray(), alpha: rocketOutlineAlpha, visible: true, } satisfies OutlineParameters; - + const realRocket = new THREE.Mesh(geometry, material) as unknown as OutlinedMesh; realRocket.scale.set(0.01, 0.01, 0.005); realRocket.position.set(0, 0, 0); - + // Apply the model-space base rotation as a quaternion. // The STL's "up" axis is +Z; we rotate it to Three.js's +Y up-axis // (-90° around X) so that a unit quaternion (w=1, x=y=z=0) shows the @@ -207,45 +254,48 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { new THREE.Vector3(1, 0, 0), -Math.PI / 2, ); - - // Compose with the incoming orientation quaternion. + + // Compose with the incoming orientation quaternion. toThreeQuat now + // performs the firmware-body-frame -> Three-world-frame conversion + // internally (via similarity transform), so orientQuat is already + // expressed in Three's world frame here. const orientQuat = toThreeQuat(w, x, y, z); realRocket.quaternion.copy(orientQuat.clone().multiply(baseQuat)); - + rocketRef.current = realRocket; - + scene.add(realRocket); }); - + // Grid setup const gridXZ = new THREE.GridHelper(GRID_SIZE, GRID_DIVISIONS, 0x000000, 0x000000); gridXZ.position.y = -GRID_OFFSET; scene.add(gridXZ); - + const gridYZ = new THREE.GridHelper(GRID_SIZE, GRID_DIVISIONS, 0x000000, 0x000000); gridYZ.rotation.z = Math.PI / 2; gridYZ.position.x = -GRID_SIZE / 2; gridYZ.position.y = -GRID_OFFSET + GRID_SIZE / 2; scene.add(gridYZ); - + const gridXY = new THREE.GridHelper(GRID_SIZE, GRID_DIVISIONS, 0x000000, 0x000000); gridXY.rotation.x = Math.PI / 2; gridXY.position.z = -GRID_SIZE / 2; gridXY.position.y = -GRID_OFFSET + GRID_SIZE / 2; scene.add(gridXY); - + // Lighting & camera camera.position.set(10, 7, 10); camera.lookAt(0, 0, 0); - + const ambient = new THREE.AmbientLight(0xffffff, ambientLightIntensity); ambientLightRef.current = ambient; scene.add(ambient); - + const directional = new THREE.DirectionalLight(0xffffee, 1); directional.position.set(-20, 10, 100); scene.add(directional); - + const axesOffset = 0.1; const axes = new THREE.AxesHelper(GRID_SIZE); axes.position.set( @@ -254,7 +304,7 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { -(GRID_SIZE / 2) + axesOffset, ); scene.add(axes); - + // Animation loop let animationFrameId: number; const animate = () => { @@ -262,7 +312,7 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { effect.render(scene, camera); }; animate(); - + const handleResize = () => { if (!refContainer.current) return; const newWidth = refContainer.current.clientWidth; @@ -272,7 +322,7 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { camera.updateProjectionMatrix(); }; window.addEventListener("resize", handleResize); - + return () => { cancelAnimationFrame(animationFrameId); window.removeEventListener("resize", handleResize); @@ -286,25 +336,27 @@ export const MyThree: FC = ({ w, x, y, z, lightMode }) => { // reactively in the lightMode effect above rather than recreating the scene. // eslint-disable-next-line react-hooks/exhaustive-deps }, []); - + useEffect(() => { const rocket = rocketRef.current; if (!rocket) return; - + // Base rotation: -90° around X so the STL's +Z nose maps to Three.js +Y const baseQuat = new THREE.Quaternion().setFromAxisAngle( new THREE.Vector3(1, 0, 0), -Math.PI / 2, ); - + + // toThreeQuat converts from the firmware body frame into Three's + // world frame (see FRAME_QUAT above), so this is now expressed in + // the same frame the model's rest pose lives in. const orientQuat = toThreeQuat(w, x, y, z); - + // Apply: first orient in world space, then apply base model correction rocket.quaternion.copy(orientQuat.clone().multiply(baseQuat)); }, [w, x, y, z]); - - + return
; }; - -export default MyThree; + +export default MyThree; \ No newline at end of file diff --git a/src/utils/units/accelerationUnits.ts b/src/utils/units/accelerationUnits.ts new file mode 100644 index 0000000..a6595bc --- /dev/null +++ b/src/utils/units/accelerationUnits.ts @@ -0,0 +1,97 @@ +import ConversionFactors, {type UnitsHandler} from "@/utils/units/units" + +export { AccelerationUnits, AccelerationUnitsHandler }; + +enum AccelerationUnits { + G_FORCE, + METERS_PER_SECOND_SQUARED +} + +class AccelerationUnitsHandler implements UnitsHandler { + /* Shared members for unitsHandler. Not typed for inheritance reasons. */ + systemUnits = AccelerationUnits.G_FORCE; + + /** + * Convert the internal measurement to the system's configured + * display units. + * + * @param input The input readout (as SI unit) + * @returns The output readout (as system units) + */ + convertToDisplay(input: number): number { + /* Convert to display unit */ + switch (this.systemUnits) { + case AccelerationUnits.METERS_PER_SECOND_SQUARED: + break; /* SI/input units */ + + default: + console.error("Invalid altitude units.") /* intentional fallthrough to G */ + case AccelerationUnits.G_FORCE: + input /= ConversionFactors.GRAVITY_MPS; + break; + } + + return input; + } + + /** + * Retrieve a short unit string to append to the readout. + * + * @returns A shortened form of the unit string + */ + getDisplayUnitShort(): string { + let out: string = "" + switch (this.systemUnits) { + case AccelerationUnits.METERS_PER_SECOND_SQUARED: + out += "m/s²"; // yay unicode + break; + default: + console.error("Invalid altitude units."); /* intentional fallthrough to g */ + case AccelerationUnits.G_FORCE: + out += "g"; + break; + } + + return out; + } + + /** + * Retrieve the full unit string to append to the readout. + * + * @returns The unit string + */ + getDisplayUnitLong(): string { + let out: string = "" + switch (this.systemUnits) { + case AccelerationUnits.METERS_PER_SECOND_SQUARED: + out += "meters per second squared"; // yay unicode + break; + default: + console.error("Invalid altitude units."); /* intentional fallthrough to g */ + case AccelerationUnits.G_FORCE: + out += "times the force of gravity"; + break; + } + + return out; + } + + /** + * Retrieve a string with the correct units for display. + * + * @param input The input value (as SI) + * @returns A string with the output value and its associated units + */ + getDisplayString(input: number): string { + if(this.systemUnits == AccelerationUnits.G_FORCE) + { + /* Give an extra decimal for G-force since there's less precision before the decimal */ + return this.convertToDisplay(input).toFixed(3) + " " + this.getDisplayUnitShort(); + } + else + { + return this.convertToDisplay(input).toFixed(2) + " " + this.getDisplayUnitShort(); + } + } + +} \ No newline at end of file diff --git a/src/utils/units/altitudeUnits.ts b/src/utils/units/altitudeUnits.ts new file mode 100644 index 0000000..67e6eda --- /dev/null +++ b/src/utils/units/altitudeUnits.ts @@ -0,0 +1,134 @@ +import ConversionFactors, {type UnitsHandler} from "@/utils/units/units" + +export { AltitudeUnits, AltitudeMode, AltitudeUnitsHandler }; + +enum AltitudeUnits { + FEET, + METERS +} + +enum AltitudeMode { + QNH, /* Sea Level Reference Elevation */ + QFE /* Airfield Reference Elevation */ +} + +class AltitudeUnitsHandler implements UnitsHandler { + /* Shared members for unitsHandler. Not typed for inheritance reasons. */ + systemUnits = AltitudeUnits.FEET; + + /* Altitude only */ + mode: AltitudeMode = AltitudeMode.QNH; + referenceElevation: number = -0.1; + + /** + * Convert the internal measurement to the system's configured + * display units. + * + * @param input The input readout (as SI unit) + * @returns The output readout (as system units) + */ + convertToDisplay(input: number): number { + /* Convert to altitude relative to reference */ + switch (this.mode) { + case AltitudeMode.QFE: + if (this.referenceElevation < 0) { + break; /* use QNH if no reference elevation defined. assumes we'd never launch from below sea level */ + } + input -= this.referenceElevation; /* negative altitudes allowed */ + default: + console.error("Invalid altitude reference mode."); /* intentional fallthrough to QNH */ + case AltitudeMode.QNH: + break; /* do nothing */ + } + + /* Convert to display unit */ + switch (this.systemUnits) { + case AltitudeUnits.METERS: + break; /* SI/input units */ + + default: + console.error("Invalid altitude units.") /* intentional fallthrough to feet */ + case AltitudeUnits.FEET: + input *= ConversionFactors.METERS_TO_FEET; + break; + } + + return input; + } + + /** + * Retrieve a short unit string to append to the readout. + * + * @returns A shortened form of the unit string + */ + getDisplayUnitShort(): string { + let out: string = "" + switch (this.systemUnits) { + case AltitudeUnits.METERS: + out += "m"; + break; + default: + console.error("Invalid altitude units."); /* intentional fallthrough to feet */ + case AltitudeUnits.FEET: + out += "ft"; + break; + } + + /* Extra step for altitude: reference mode */ + if(this.referenceElevation >= 0 && this.mode == AltitudeMode.QFE) { + out += " AGL"; + } + + return out; + } + + /** + * Retrieve the full unit string to append to the readout. + * + * @returns The unit string + */ + getDisplayUnitLong(): string { + let out: string = "" + switch (this.systemUnits) { + case AltitudeUnits.METERS: + out += "meters"; + break; + default: + console.error("Invalid altitude units."); /* intentional fallthrough to feet */ + case AltitudeUnits.FEET: + out += "feet"; + break; + } + + /* Extra step for altitude: reference mode */ + if(this.referenceElevation >= 0 && this.mode == AltitudeMode.QFE) { + out += " AGL"; + } + + return out; + } + + /** + * Retrieve a string with the correct units for display. + * + * @param input The input value (as SI) + * @returns A string with the output value and its associated units + */ + getDisplayString(input: number): string { + return this.convertToDisplay(input).toFixed(0) + " " + this.getDisplayUnitShort(); + } + + /** + * For altitude only: Retrieve the altitude reference mode in use + * + * @returns A string describing the altitude reference mode + */ + getReferenceMode(): string { + if(this.referenceElevation >= 0 && this.mode == AltitudeMode.QFE) { + return "QFE"; + } + else { + return "QNH"; + } + } +} \ No newline at end of file diff --git a/src/utils/units/units.ts b/src/utils/units/units.ts new file mode 100644 index 0000000..5ae45f0 --- /dev/null +++ b/src/utils/units/units.ts @@ -0,0 +1,61 @@ +/* Export all handlers */ +// Altitude +import { AltitudeUnitsHandler } from "@/utils/units/altitudeUnits" +export * from "@/utils/units/altitudeUnits" +// Acceleration +import { AccelerationUnitsHandler } from "@/utils/units/accelerationUnits" +export * from "@/utils/units/accelerationUnits" + +/* All exported units handlers should be defined here */ +export const altitudeHandler = new AltitudeUnitsHandler(); +export const accelerationHandler = new AccelerationUnitsHandler(); + +export { type UnitsHandler }; + +/** + * Enumerated type with constant conversion factors used by this module. + */ +enum ConversionFactors { + METERS_TO_FEET = 3.280839895, + GRAVITY_MPS = 9.80665 +} +export default ConversionFactors; + +/** + * Interface for all unit converters to follow for portability. + */ +interface UnitsHandler { + /* Shared members for unitsHandler. Not typed for inheritance reasons. */ + systemUnits: any + + /** + * Convert the internal measurement to the system's configured + * display units. + * + * @param input The input readout (as SI unit) + * @returns The output readout (as system units) + */ + convertToDisplay(input: number): number + + /** + * Retrieve a short unit string to append to the readout. + * + * @returns A shortened form of the unit string + */ + getDisplayUnitShort(): string + + /** + * Retrieve the full unit string to append to the readout. + * + * @returns The unit string + */ + getDisplayUnitLong(): string + + /** + * Retrieve a string with the correct units for display. + * + * @param input The input value (as SI) + * @returns A string with the output value and its associated units + */ + getDisplayString(input: number): string +} \ No newline at end of file