fossekall-interface 0.1.128 → 0.1.130

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

@@ -0,0 +1,221 @@
+import bin from 'typed-binary';
+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 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 ServoCommands_OpenClose: {
+    readonly Open: 0;
+    readonly Close: 1;
+};
+export type ServoCommands_OpenClose = (typeof ServoCommands_OpenClose)[keyof typeof ServoCommands_OpenClose];
+export declare const actuators_servo_PositionMode: {
+    readonly Absolute: 0;
+    readonly Relative: 1;
+};
+export type actuators_servo_PositionMode = (typeof actuators_servo_PositionMode)[keyof typeof actuators_servo_PositionMode];
+export declare const actuators_servo_StartPolicy: {
+    readonly Preempt: 0;
+    readonly NoInterrupt: 1;
+};
+export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
+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 SolenoidCommands_OpeningType: {
+    readonly Open: 0;
+    readonly Close: 1;
+};
+export type SolenoidCommands_OpeningType = (typeof SolenoidCommands_OpeningType)[keyof typeof SolenoidCommands_OpeningType];
+export declare const FsmCommands_NextStatePayload: import("typed-binary").ObjectSchema<{
+    current_state: import("typed-binary").ByteSchema;
+}>;
+export type FsmCommands_NextStatePayload = bin.Parsed<typeof FsmCommands_NextStatePayload>;
+export declare const FsmCommands_PreviousStatePayload: import("typed-binary").ObjectSchema<{
+    current_state: import("typed-binary").ByteSchema;
+}>;
+export type FsmCommands_PreviousStatePayload = bin.Parsed<typeof FsmCommands_PreviousStatePayload>;
+export declare const FsmCommands_AbortPayload: import("typed-binary").ObjectSchema<{
+    reserved: import("typed-binary").ByteSchema;
+}>;
+export type FsmCommands_AbortPayload = bin.Parsed<typeof FsmCommands_AbortPayload>;
+export declare const FsmCommands_StatusPayload: import("typed-binary").ObjectSchema<{
+    reserved: import("typed-binary").ByteSchema;
+}>;
+export type FsmCommands_StatusPayload = bin.Parsed<typeof FsmCommands_StatusPayload>;
+export declare const ServoCommands_OpenCloseServoPayload: import("typed-binary").ObjectSchema<{
+    servo_id: import("typed-binary").ByteSchema;
+    open_close: import("typed-binary").ByteSchema;
+    duration_ms: import("typed-binary").Uint16Schema;
+    delay_ms: import("typed-binary").Uint16Schema;
+    position_mode: import("typed-binary").ByteSchema;
+    start_policy: import("typed-binary").ByteSchema;
+}>;
+export type ServoCommands_OpenCloseServoPayload = bin.Parsed<typeof ServoCommands_OpenCloseServoPayload>;
+export declare const ServoCommands_SetServoPayload: import("typed-binary").ObjectSchema<{
+    servo_id: import("typed-binary").ByteSchema;
+    angle_deg: import("typed-binary").Float32Schema;
+    duration_ms: import("typed-binary").Uint16Schema;
+    delay_ms: import("typed-binary").Uint16Schema;
+    position_mode: import("typed-binary").ByteSchema;
+    start_policy: import("typed-binary").ByteSchema;
+}>;
+export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
+export declare const SolenoidCommands_OpenCloseSolenoidPayload: import("typed-binary").ObjectSchema<{
+    solenoid_id: import("typed-binary").ByteSchema;
+    opening_type: import("typed-binary").ByteSchema;
+}>;
+export type SolenoidCommands_OpenCloseSolenoidPayload = bin.Parsed<typeof SolenoidCommands_OpenCloseSolenoidPayload>;
+export declare const spec: {
+    FsmCommands_NextStatePayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            current_state: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            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;
+            };
+        };
+    };
+    FsmCommands_PreviousStatePayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            current_state: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            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;
+            };
+        };
+    };
+    FsmCommands_AbortPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            reserved: import("typed-binary").ByteSchema;
+        }>;
+        enums: {};
+    };
+    FsmCommands_StatusPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            reserved: import("typed-binary").ByteSchema;
+        }>;
+        enums: {};
+    };
+    ServoCommands_OpenCloseServoPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            servo_id: import("typed-binary").ByteSchema;
+            open_close: import("typed-binary").ByteSchema;
+            duration_ms: import("typed-binary").Uint16Schema;
+            delay_ms: import("typed-binary").Uint16Schema;
+            position_mode: import("typed-binary").ByteSchema;
+            start_policy: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            servo_id: {
+                readonly OxSupply: 0;
+                readonly Count: 1;
+            };
+            open_close: {
+                readonly Open: 0;
+                readonly Close: 1;
+            };
+            position_mode: {
+                readonly Absolute: 0;
+                readonly Relative: 1;
+            };
+            start_policy: {
+                readonly Preempt: 0;
+                readonly NoInterrupt: 1;
+            };
+        };
+    };
+    ServoCommands_SetServoPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            servo_id: import("typed-binary").ByteSchema;
+            angle_deg: import("typed-binary").Float32Schema;
+            duration_ms: import("typed-binary").Uint16Schema;
+            delay_ms: import("typed-binary").Uint16Schema;
+            position_mode: import("typed-binary").ByteSchema;
+            start_policy: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            servo_id: {
+                readonly OxSupply: 0;
+                readonly Count: 1;
+            };
+            position_mode: {
+                readonly Absolute: 0;
+                readonly Relative: 1;
+            };
+            start_policy: {
+                readonly Preempt: 0;
+                readonly NoInterrupt: 1;
+            };
+        };
+    };
+    SolenoidCommands_OpenCloseSolenoidPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            solenoid_id: import("typed-binary").ByteSchema;
+            opening_type: import("typed-binary").ByteSchema;
+        }>;
+        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;
+            };
+            opening_type: {
+                readonly Open: 0;
+                readonly Close: 1;
+            };
+        };
+    };
+};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/fs/commands.js

@@ -0,0 +1,189 @@
+import bin, { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-06-29 21:55:58. 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 actuators_servo_Id = {
+    OxSupply: 0,
+    Count: 1,
+};
+export const ServoCommands_OpenClose = {
+    Open: 0,
+    Close: 1,
+};
+export const actuators_servo_PositionMode = {
+    Absolute: 0,
+    Relative: 1,
+};
+export const actuators_servo_StartPolicy = {
+    Preempt: 0,
+    NoInterrupt: 1,
+};
+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 SolenoidCommands_OpeningType = {
+    Open: 0,
+    Close: 1,
+};
+export const FsmCommands_NextStatePayload = bin.object({
+    current_state: bin.u8, // StateId
+});
+export const FsmCommands_PreviousStatePayload = bin.object({
+    current_state: bin.u8, // StateId
+});
+export const FsmCommands_AbortPayload = bin.object({
+    reserved: bin.u8, // unsigned char
+});
+export const FsmCommands_StatusPayload = bin.object({
+    reserved: bin.u8, // unsigned char
+});
+export const ServoCommands_OpenCloseServoPayload = bin.object({
+    servo_id: bin.u8, // actuators::servo::Id
+    open_close: bin.u8, // ServoCommands::OpenClose
+    duration_ms: bin.u16, // unsigned short
+    delay_ms: bin.u16, // unsigned short
+    position_mode: bin.u8, // actuators::servo::PositionMode
+    start_policy: bin.u8, // actuators::servo::StartPolicy
+});
+export const ServoCommands_SetServoPayload = bin.object({
+    servo_id: bin.u8, // actuators::servo::Id
+    angle_deg: bin.f32, // float
+    duration_ms: bin.u16, // unsigned short
+    delay_ms: bin.u16, // unsigned short
+    position_mode: bin.u8, // actuators::servo::PositionMode
+    start_policy: bin.u8, // actuators::servo::StartPolicy
+});
+export const SolenoidCommands_OpenCloseSolenoidPayload = bin.object({
+    solenoid_id: bin.u8, // actuators::solenoid::Id
+    opening_type: bin.u8, // SolenoidCommands::OpeningType
+});
+export const spec = {
+    FsmCommands_NextStatePayload: {
+        id: 32,
+        schema: FsmCommands_NextStatePayload,
+        enums: {
+            current_state: StateId,
+        },
+    },
+    FsmCommands_PreviousStatePayload: {
+        id: 33,
+        schema: FsmCommands_PreviousStatePayload,
+        enums: {
+            current_state: StateId,
+        },
+    },
+    FsmCommands_AbortPayload: {
+        id: 34,
+        schema: FsmCommands_AbortPayload,
+        enums: {},
+    },
+    FsmCommands_StatusPayload: {
+        id: 35,
+        schema: FsmCommands_StatusPayload,
+        enums: {},
+    },
+    ServoCommands_OpenCloseServoPayload: {
+        id: 48,
+        schema: ServoCommands_OpenCloseServoPayload,
+        enums: {
+            servo_id: actuators_servo_Id,
+            open_close: ServoCommands_OpenClose,
+            position_mode: actuators_servo_PositionMode,
+            start_policy: actuators_servo_StartPolicy,
+        },
+    },
+    ServoCommands_SetServoPayload: {
+        id: 49,
+        schema: ServoCommands_SetServoPayload,
+        enums: {
+            servo_id: actuators_servo_Id,
+            position_mode: actuators_servo_PositionMode,
+            start_policy: actuators_servo_StartPolicy,
+        },
+    },
+    SolenoidCommands_OpenCloseSolenoidPayload: {
+        id: 80,
+        schema: SolenoidCommands_OpenCloseSolenoidPayload,
+        enums: {
+            solenoid_id: actuators_solenoid_Id,
+            opening_type: SolenoidCommands_OpeningType,
+        },
+    },
+};
+export default spec;

package/dist/generated/fs/commands.json

@@ -0,0 +1,212 @@
+{
+    "version": 1,
+    "structs": {
+        "FsmCommands::NextStatePayload": {
+            "id": 32,
+            "kind": "struct",
+            "type": "FsmCommands::NextStatePayload",
+            "fields": [
+                {
+                    "name": "current_state",
+                    "kind": "enum",
+                    "type": "StateId",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<B"
+        },
+        "FsmCommands::PreviousStatePayload": {
+            "id": 33,
+            "kind": "struct",
+            "type": "FsmCommands::PreviousStatePayload",
+            "fields": [
+                {
+                    "name": "current_state",
+                    "kind": "enum",
+                    "type": "StateId",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<B"
+        },
+        "FsmCommands::AbortPayload": {
+            "id": 34,
+            "kind": "struct",
+            "type": "FsmCommands::AbortPayload",
+            "fields": [
+                {
+                    "name": "reserved",
+                    "kind": "primitive",
+                    "type": "unsigned char",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<B"
+        },
+        "FsmCommands::StatusPayload": {
+            "id": 35,
+            "kind": "struct",
+            "type": "FsmCommands::StatusPayload",
+            "fields": [
+                {
+                    "name": "reserved",
+                    "kind": "primitive",
+                    "type": "unsigned char",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<B"
+        },
+        "ServoCommands::OpenCloseServoPayload": {
+            "id": 48,
+            "kind": "struct",
+            "type": "ServoCommands::OpenCloseServoPayload",
+            "fields": [
+                {
+                    "name": "servo_id",
+                    "kind": "enum",
+                    "type": "actuators::servo::Id",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "open_close",
+                    "kind": "enum",
+                    "type": "ServoCommands::OpenClose",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "duration_ms",
+                    "kind": "primitive",
+                    "type": "unsigned short",
+                    "format_string": "<H"
+                },
+                {
+                    "name": "delay_ms",
+                    "kind": "primitive",
+                    "type": "unsigned short",
+                    "format_string": "<H"
+                },
+                {
+                    "name": "position_mode",
+                    "kind": "enum",
+                    "type": "actuators::servo::PositionMode",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "start_policy",
+                    "kind": "enum",
+                    "type": "actuators::servo::StartPolicy",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<BBHHBB"
+        },
+        "ServoCommands::SetServoPayload": {
+            "id": 49,
+            "kind": "struct",
+            "type": "ServoCommands::SetServoPayload",
+            "fields": [
+                {
+                    "name": "servo_id",
+                    "kind": "enum",
+                    "type": "actuators::servo::Id",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "angle_deg",
+                    "kind": "primitive",
+                    "type": "float",
+                    "format_string": "<f"
+                },
+                {
+                    "name": "duration_ms",
+                    "kind": "primitive",
+                    "type": "unsigned short",
+                    "format_string": "<H"
+                },
+                {
+                    "name": "delay_ms",
+                    "kind": "primitive",
+                    "type": "unsigned short",
+                    "format_string": "<H"
+                },
+                {
+                    "name": "position_mode",
+                    "kind": "enum",
+                    "type": "actuators::servo::PositionMode",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "start_policy",
+                    "kind": "enum",
+                    "type": "actuators::servo::StartPolicy",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<BfHHBB"
+        },
+        "SolenoidCommands::OpenCloseSolenoidPayload": {
+            "id": 80,
+            "kind": "struct",
+            "type": "SolenoidCommands::OpenCloseSolenoidPayload",
+            "fields": [
+                {
+                    "name": "solenoid_id",
+                    "kind": "enum",
+                    "type": "actuators::solenoid::Id",
+                    "format_string": "<B"
+                },
+                {
+                    "name": "opening_type",
+                    "kind": "enum",
+                    "type": "SolenoidCommands::OpeningType",
+                    "format_string": "<B"
+                }
+            ],
+            "format_string": "<BB"
+        }
+    },
+    "enums": {
+        "StateId": {
+            "Safe": 0,
+            "RecoveryFill": 1,
+            "PostRecoveryFill": 2,
+            "N2Fill": 3,
+            "PostN2Fill": 4,
+            "OxFill": 5,
+            "PostOxFill": 6,
+            "QDDisconnect": 7,
+            "Hold": 8
+        },
+        "actuators::servo::Id": {
+            "OxSupply": 0,
+            "Count": 1
+        },
+        "ServoCommands::OpenClose": {
+            "Open": 0,
+            "Close": 1
+        },
+        "actuators::servo::PositionMode": {
+            "Absolute": 0,
+            "Relative": 1
+        },
+        "actuators::servo::StartPolicy": {
+            "Preempt": 0,
+            "NoInterrupt": 1
+        },
+        "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
+        },
+        "SolenoidCommands::OpeningType": {
+            "Open": 0,
+            "Close": 1
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export { default as commandsJson } from "./commands.json";
+export * as commands from "./commands";
+export { default as telemetryJson } from "./telemetry.json";
+export * as telemetry from "./telemetry";

package/dist/generated/fs/index.js

@@ -0,0 +1,4 @@
+export { default as commandsJson } from "./commands.json";
+export * as commands from "./commands";
+export { default as telemetryJson } from "./telemetry.json";
+export * as telemetry from "./telemetry";