fossekall-interface 0.1.128 → 0.1.131

package/dist/generated/fs/telemetry.d.ts

@@ -0,0 +1,361 @@
+import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
+declare class UInt64Schema extends Schema<bigint> {
+    readonly maxSize = 8;
+    read(input: ISerialInput): bigint;
+    write(output: ISerialOutput, value: bigint): void;
+    measure(_: bigint | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
+}
+export declare const StateId: {
+    readonly Safe: 0;
+    readonly RecoveryFill: 1;
+    readonly PostRecoveryFill: 2;
+    readonly N2Fill: 3;
+    readonly PostN2Fill: 4;
+    readonly OxFill: 5;
+    readonly PostOxFill: 6;
+    readonly QDDisconnect: 7;
+    readonly Hold: 8;
+};
+export type StateId = (typeof StateId)[keyof typeof StateId];
+export declare const Event: {
+    readonly Boot: 0;
+    readonly NextState: 1;
+    readonly PreviousState: 2;
+    readonly Timeout: 3;
+    readonly Abort: 4;
+    readonly None: 5;
+    readonly Count: 6;
+};
+export type Event = (typeof Event)[keyof typeof Event];
+export declare const fsm_AbortReason: {
+    readonly None: 0;
+    readonly Manual: 1;
+};
+export type fsm_AbortReason = (typeof fsm_AbortReason)[keyof typeof fsm_AbortReason];
+export declare const sensors_pressure_Id: {
+    readonly OxSupply: 0;
+    readonly N2_200: 1;
+    readonly N2_300: 2;
+    readonly Count: 3;
+};
+export type sensors_pressure_Id = (typeof sensors_pressure_Id)[keyof typeof sensors_pressure_Id];
+export declare const actuators_servo_Id: {
+    readonly OxSupply: 0;
+    readonly Count: 1;
+};
+export type actuators_servo_Id = (typeof actuators_servo_Id)[keyof typeof actuators_servo_Id];
+export declare const actuators_servo_PowerState: {
+    readonly Unknown: 0;
+    readonly Off: 1;
+    readonly Booting: 2;
+    readonly On: 3;
+};
+export type actuators_servo_PowerState = (typeof actuators_servo_PowerState)[keyof typeof actuators_servo_PowerState];
+export declare const actuators_solenoid_Id: {
+    readonly OxBleed: 0;
+    readonly N2_200_Supply: 1;
+    readonly N2_200_Bleed: 2;
+    readonly N2_300_Supply: 3;
+    readonly N2_300_Bleed: 4;
+    readonly QD_1: 5;
+    readonly QD_2: 6;
+    readonly Count: 7;
+};
+export type actuators_solenoid_Id = (typeof actuators_solenoid_Id)[keyof typeof actuators_solenoid_Id];
+export declare const actuators_solenoid_PowerState: {
+    readonly Unknown: 0;
+    readonly Off: 1;
+    readonly On: 2;
+};
+export type actuators_solenoid_PowerState = (typeof actuators_solenoid_PowerState)[keyof typeof actuators_solenoid_PowerState];
+export declare const actuators_solenoid_Opening: {
+    readonly Unknown: 0;
+    readonly Closed: 1;
+    readonly Open: 2;
+};
+export type actuators_solenoid_Opening = (typeof actuators_solenoid_Opening)[keyof typeof actuators_solenoid_Opening];
+export declare const sensors_load_cell_Id: {
+    readonly LoadCell0: 0;
+    readonly LoadCell1: 1;
+    readonly LoadCell2: 2;
+    readonly Count: 3;
+};
+export type sensors_load_cell_Id = (typeof sensors_load_cell_Id)[keyof typeof sensors_load_cell_Id];
+export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
+    message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+    status_flags: import("typed-binary").ByteSchema;
+}>;
+export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
+export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
+    state_entry_time_ms: UInt64Schema;
+    state_time_ms: UInt64Schema;
+    current_state: import("typed-binary").ByteSchema;
+    previous_state: import("typed-binary").ByteSchema;
+    last_event: import("typed-binary").ByteSchema;
+    last_abort_reason: import("typed-binary").ByteSchema;
+}>;
+export type fsm_FsmStatus = bin.Parsed<typeof fsm_FsmStatus>;
+export declare const FsmStatusPacket: import("typed-binary").ObjectSchema<{
+    status: import("typed-binary").ObjectSchema<{
+        state_entry_time_ms: UInt64Schema;
+        state_time_ms: UInt64Schema;
+        current_state: import("typed-binary").ByteSchema;
+        previous_state: import("typed-binary").ByteSchema;
+        last_event: import("typed-binary").ByteSchema;
+        last_abort_reason: import("typed-binary").ByteSchema;
+    }>;
+    timestamp_ms: import("typed-binary").Uint32Schema;
+}>;
+export type FsmStatusPacket = bin.Parsed<typeof FsmStatusPacket>;
+export declare const sensors_pressure_PressureBatch: import("typed-binary").ObjectSchema<{
+    t0_us: UInt64Schema;
+    dt_us: import("typed-binary").Uint32Schema;
+    count: import("typed-binary").ByteSchema;
+    seq: import("typed-binary").ByteSchema;
+    samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+}>;
+export type sensors_pressure_PressureBatch = bin.Parsed<typeof sensors_pressure_PressureBatch>;
+export declare const PressureSensorPacket: import("typed-binary").ObjectSchema<{
+    sensor_id: import("typed-binary").ByteSchema;
+    pressure_batch: import("typed-binary").ObjectSchema<{
+        t0_us: UInt64Schema;
+        dt_us: import("typed-binary").Uint32Schema;
+        count: import("typed-binary").ByteSchema;
+        seq: import("typed-binary").ByteSchema;
+        samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+    }>;
+}>;
+export type PressureSensorPacket = bin.Parsed<typeof PressureSensorPacket>;
+export declare const actuators_servo_ServoStatus: import("typed-binary").ObjectSchema<{
+    commanded_angle_deg: import("typed-binary").Float32Schema;
+    target_angle_deg: import("typed-binary").Float32Schema;
+    measured_angle_deg: import("typed-binary").Float32Schema;
+    current_ma: import("typed-binary").Float32Schema;
+    power_state: import("typed-binary").ByteSchema;
+}>;
+export type actuators_servo_ServoStatus = bin.Parsed<typeof actuators_servo_ServoStatus>;
+export declare const ServoStatusPacket: import("typed-binary").ObjectSchema<{
+    servo_id: import("typed-binary").ByteSchema;
+    timestamp_ms: import("typed-binary").Uint32Schema;
+    status: import("typed-binary").ObjectSchema<{
+        commanded_angle_deg: import("typed-binary").Float32Schema;
+        target_angle_deg: import("typed-binary").Float32Schema;
+        measured_angle_deg: import("typed-binary").Float32Schema;
+        current_ma: import("typed-binary").Float32Schema;
+        power_state: import("typed-binary").ByteSchema;
+    }>;
+}>;
+export type ServoStatusPacket = bin.Parsed<typeof ServoStatusPacket>;
+export declare const actuators_solenoid_SolenoidStatus: import("typed-binary").ObjectSchema<{
+    power_state: import("typed-binary").ByteSchema;
+    opening: import("typed-binary").ByteSchema;
+    current_ma: import("typed-binary").Float32Schema;
+}>;
+export type actuators_solenoid_SolenoidStatus = bin.Parsed<typeof actuators_solenoid_SolenoidStatus>;
+export declare const SolenoidStatusPacket: import("typed-binary").ObjectSchema<{
+    solenoid_id: import("typed-binary").ByteSchema;
+    timestamp_ms: import("typed-binary").Uint32Schema;
+    status: import("typed-binary").ObjectSchema<{
+        power_state: import("typed-binary").ByteSchema;
+        opening: import("typed-binary").ByteSchema;
+        current_ma: import("typed-binary").Float32Schema;
+    }>;
+}>;
+export type SolenoidStatusPacket = bin.Parsed<typeof SolenoidStatusPacket>;
+export declare const sensors_load_cell_LoadCellBatch: import("typed-binary").ObjectSchema<{
+    t0_us: UInt64Schema;
+    dt_us: import("typed-binary").Uint32Schema;
+    count: import("typed-binary").ByteSchema;
+    seq: import("typed-binary").ByteSchema;
+    samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+}>;
+export type sensors_load_cell_LoadCellBatch = bin.Parsed<typeof sensors_load_cell_LoadCellBatch>;
+export declare const LoadCellPacket: import("typed-binary").ObjectSchema<{
+    load_cell_id: import("typed-binary").ByteSchema;
+    data: import("typed-binary").ObjectSchema<{
+        t0_us: UInt64Schema;
+        dt_us: import("typed-binary").Uint32Schema;
+        count: import("typed-binary").ByteSchema;
+        seq: import("typed-binary").ByteSchema;
+        samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+    }>;
+}>;
+export type LoadCellPacket = bin.Parsed<typeof LoadCellPacket>;
+export declare const spec: {
+    HeartBeatTelemetry: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
+            message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+            status_flags: import("typed-binary").ByteSchema;
+        }>;
+        enums: {};
+    };
+    FsmStatusPacket: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
+            status: import("typed-binary").ObjectSchema<{
+                state_entry_time_ms: UInt64Schema;
+                state_time_ms: UInt64Schema;
+                current_state: import("typed-binary").ByteSchema;
+                previous_state: import("typed-binary").ByteSchema;
+                last_event: import("typed-binary").ByteSchema;
+                last_abort_reason: import("typed-binary").ByteSchema;
+            }>;
+            timestamp_ms: import("typed-binary").Uint32Schema;
+        }>;
+        enums: {
+            status: {
+                current_state: {
+                    readonly Safe: 0;
+                    readonly RecoveryFill: 1;
+                    readonly PostRecoveryFill: 2;
+                    readonly N2Fill: 3;
+                    readonly PostN2Fill: 4;
+                    readonly OxFill: 5;
+                    readonly PostOxFill: 6;
+                    readonly QDDisconnect: 7;
+                    readonly Hold: 8;
+                };
+                previous_state: {
+                    readonly Safe: 0;
+                    readonly RecoveryFill: 1;
+                    readonly PostRecoveryFill: 2;
+                    readonly N2Fill: 3;
+                    readonly PostN2Fill: 4;
+                    readonly OxFill: 5;
+                    readonly PostOxFill: 6;
+                    readonly QDDisconnect: 7;
+                    readonly Hold: 8;
+                };
+                last_event: {
+                    readonly Boot: 0;
+                    readonly NextState: 1;
+                    readonly PreviousState: 2;
+                    readonly Timeout: 3;
+                    readonly Abort: 4;
+                    readonly None: 5;
+                    readonly Count: 6;
+                };
+                last_abort_reason: {
+                    readonly None: 0;
+                    readonly Manual: 1;
+                };
+            };
+        };
+    };
+    PressureSensorPacket: {
+        port: number;
+        fragment: string;
+        packed: null;
+        schema: import("typed-binary").ObjectSchema<{
+            sensor_id: import("typed-binary").ByteSchema;
+            pressure_batch: import("typed-binary").ObjectSchema<{
+                t0_us: UInt64Schema;
+                dt_us: import("typed-binary").Uint32Schema;
+                count: import("typed-binary").ByteSchema;
+                seq: import("typed-binary").ByteSchema;
+                samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+            }>;
+        }>;
+        enums: {
+            sensor_id: {
+                readonly OxSupply: 0;
+                readonly N2_200: 1;
+                readonly N2_300: 2;
+                readonly Count: 3;
+            };
+            pressure_batch: {};
+        };
+    };
+    ServoStatusPacket: {
+        port: number;
+        fragment: string;
+        schema: import("typed-binary").ObjectSchema<{
+            servo_id: import("typed-binary").ByteSchema;
+            timestamp_ms: import("typed-binary").Uint32Schema;
+            status: import("typed-binary").ObjectSchema<{
+                commanded_angle_deg: import("typed-binary").Float32Schema;
+                target_angle_deg: import("typed-binary").Float32Schema;
+                measured_angle_deg: import("typed-binary").Float32Schema;
+                current_ma: import("typed-binary").Float32Schema;
+                power_state: import("typed-binary").ByteSchema;
+            }>;
+        }>;
+        enums: {
+            servo_id: {
+                readonly OxSupply: 0;
+                readonly Count: 1;
+            };
+            status: {
+                power_state: {
+                    readonly Unknown: 0;
+                    readonly Off: 1;
+                    readonly Booting: 2;
+                    readonly On: 3;
+                };
+            };
+        };
+    };
+    SolenoidStatusPacket: {
+        port: number;
+        fragment: string;
+        schema: import("typed-binary").ObjectSchema<{
+            solenoid_id: import("typed-binary").ByteSchema;
+            timestamp_ms: import("typed-binary").Uint32Schema;
+            status: import("typed-binary").ObjectSchema<{
+                power_state: import("typed-binary").ByteSchema;
+                opening: import("typed-binary").ByteSchema;
+                current_ma: import("typed-binary").Float32Schema;
+            }>;
+        }>;
+        enums: {
+            solenoid_id: {
+                readonly OxBleed: 0;
+                readonly N2_200_Supply: 1;
+                readonly N2_200_Bleed: 2;
+                readonly N2_300_Supply: 3;
+                readonly N2_300_Bleed: 4;
+                readonly QD_1: 5;
+                readonly QD_2: 6;
+                readonly Count: 7;
+            };
+            status: {
+                power_state: {
+                    readonly Unknown: 0;
+                    readonly Off: 1;
+                    readonly On: 2;
+                };
+                opening: {
+                    readonly Unknown: 0;
+                    readonly Closed: 1;
+                    readonly Open: 2;
+                };
+            };
+        };
+    };
+    LoadCellPacket: {
+        port: number;
+        fragment: string;
+        schema: import("typed-binary").ObjectSchema<{
+            load_cell_id: import("typed-binary").ByteSchema;
+            data: import("typed-binary").ObjectSchema<{
+                t0_us: UInt64Schema;
+                dt_us: import("typed-binary").Uint32Schema;
+                count: import("typed-binary").ByteSchema;
+                seq: import("typed-binary").ByteSchema;
+                samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+            }>;
+        }>;
+        enums: {
+            load_cell_id: {
+                readonly LoadCell0: 0;
+                readonly LoadCell1: 1;
+                readonly LoadCell2: 2;
+                readonly Count: 3;
+            };
+            data: {};
+        };
+    };
+};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/fs/telemetry.js

@@ -0,0 +1,250 @@
+import bin, { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-06-29 21:56:01. Do not edit manually!
+// The current version of typed-binary does not support 64-bit primitives.
+// So for we'll implement our own schemas. :) 
+const __littleEndian = true;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const StateId = {
+    Safe: 0,
+    RecoveryFill: 1,
+    PostRecoveryFill: 2,
+    N2Fill: 3,
+    PostN2Fill: 4,
+    OxFill: 5,
+    PostOxFill: 6,
+    QDDisconnect: 7,
+    Hold: 8,
+};
+export const Event = {
+    Boot: 0,
+    NextState: 1,
+    PreviousState: 2,
+    Timeout: 3,
+    Abort: 4,
+    None: 5,
+    Count: 6,
+};
+export const fsm_AbortReason = {
+    None: 0,
+    Manual: 1,
+};
+export const sensors_pressure_Id = {
+    OxSupply: 0,
+    N2_200: 1,
+    N2_300: 2,
+    Count: 3,
+};
+export const actuators_servo_Id = {
+    OxSupply: 0,
+    Count: 1,
+};
+export const actuators_servo_PowerState = {
+    Unknown: 0,
+    Off: 1,
+    Booting: 2,
+    On: 3,
+};
+export const actuators_solenoid_Id = {
+    OxBleed: 0,
+    N2_200_Supply: 1,
+    N2_200_Bleed: 2,
+    N2_300_Supply: 3,
+    N2_300_Bleed: 4,
+    QD_1: 5,
+    QD_2: 6,
+    Count: 7,
+};
+export const actuators_solenoid_PowerState = {
+    Unknown: 0,
+    Off: 1,
+    On: 2,
+};
+export const actuators_solenoid_Opening = {
+    Unknown: 0,
+    Closed: 1,
+    Open: 2,
+};
+export const sensors_load_cell_Id = {
+    LoadCell0: 0,
+    LoadCell1: 1,
+    LoadCell2: 2,
+    Count: 3,
+};
+export const HeartBeatTelemetry = bin.object({
+    message: bin.arrayOf(bin.i8, 16), // char[16]
+    status_flags: bin.u8, // unsigned char
+});
+export const fsm_FsmStatus = bin.object({
+    state_entry_time_ms: u64, // unsigned long long
+    state_time_ms: u64, // unsigned long long
+    current_state: bin.u8, // StateId
+    previous_state: bin.u8, // StateId
+    last_event: bin.u8, // Event
+    last_abort_reason: bin.u8, // fsm::AbortReason
+});
+export const FsmStatusPacket = bin.object({
+    status: fsm_FsmStatus, // fsm::FsmStatus
+    timestamp_ms: bin.u32, // unsigned int
+});
+export const sensors_pressure_PressureBatch = bin.object({
+    t0_us: u64, // unsigned long long
+    dt_us: bin.u32, // unsigned int
+    count: bin.u8, // unsigned char
+    seq: bin.u8, // unsigned char
+    samples: bin.arrayOf(bin.i16, 20), // short[20]
+});
+export const PressureSensorPacket = bin.object({
+    sensor_id: bin.u8, // sensors::pressure::Id
+    pressure_batch: sensors_pressure_PressureBatch, // sensors::pressure::PressureBatch
+});
+export const actuators_servo_ServoStatus = bin.object({
+    commanded_angle_deg: bin.f32, // float
+    target_angle_deg: bin.f32, // float
+    measured_angle_deg: bin.f32, // float
+    current_ma: bin.f32, // float
+    power_state: bin.u8, // actuators::servo::PowerState
+});
+export const ServoStatusPacket = bin.object({
+    servo_id: bin.u8, // actuators::servo::Id
+    timestamp_ms: bin.u32, // unsigned int
+    status: actuators_servo_ServoStatus, // actuators::servo::ServoStatus
+});
+export const actuators_solenoid_SolenoidStatus = bin.object({
+    power_state: bin.u8, // actuators::solenoid::PowerState
+    opening: bin.u8, // actuators::solenoid::Opening
+    current_ma: bin.f32, // float
+});
+export const SolenoidStatusPacket = bin.object({
+    solenoid_id: bin.u8, // actuators::solenoid::Id
+    timestamp_ms: bin.u32, // unsigned int
+    status: actuators_solenoid_SolenoidStatus, // actuators::solenoid::SolenoidStatus
+});
+export const sensors_load_cell_LoadCellBatch = bin.object({
+    t0_us: u64, // unsigned long long
+    dt_us: bin.u32, // unsigned int
+    count: bin.u8, // unsigned char
+    seq: bin.u8, // unsigned char
+    samples: bin.arrayOf(bin.i16, 20), // short[20]
+});
+export const LoadCellPacket = bin.object({
+    load_cell_id: bin.u8, // sensors::load_cell::Id
+    data: sensors_load_cell_LoadCellBatch, // sensors::load_cell::LoadCellBatch
+});
+export const spec = {
+    HeartBeatTelemetry: {
+        port: 57005,
+        schema: HeartBeatTelemetry,
+        enums: {},
+    },
+    FsmStatusPacket: {
+        port: 5001,
+        schema: FsmStatusPacket,
+        enums: {
+            status: {
+                current_state: StateId,
+                previous_state: StateId,
+                last_event: Event,
+                last_abort_reason: fsm_AbortReason,
+            },
+        },
+    },
+    PressureSensorPacket: {
+        port: 5002,
+        fragment: "sensor_id",
+        packed: null,
+        schema: PressureSensorPacket,
+        enums: {
+            sensor_id: sensors_pressure_Id,
+            pressure_batch: {},
+        },
+    },
+    ServoStatusPacket: {
+        port: 5003,
+        fragment: "servo_id",
+        schema: ServoStatusPacket,
+        enums: {
+            servo_id: actuators_servo_Id,
+            status: {
+                power_state: actuators_servo_PowerState,
+            },
+        },
+    },
+    SolenoidStatusPacket: {
+        port: 5004,
+        fragment: "solenoid_id",
+        schema: SolenoidStatusPacket,
+        enums: {
+            solenoid_id: actuators_solenoid_Id,
+            status: {
+                power_state: actuators_solenoid_PowerState,
+                opening: actuators_solenoid_Opening,
+            },
+        },
+    },
+    LoadCellPacket: {
+        port: 5007,
+        fragment: "loadcell_id",
+        schema: LoadCellPacket,
+        enums: {
+            load_cell_id: sensors_load_cell_Id,
+            data: {},
+        },
+    },
+};
+export default spec;