fossekall-interface 0.1.19 → 0.1.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +41 -18
  2. package/dist/generated/ecu/commands.d.ts +105 -0
  3. package/dist/generated/ecu/commands.js +65 -1
  4. package/dist/generated/ecu/telemetry.d.ts +203 -16
  5. package/dist/generated/ecu/telemetry.js +80 -1
  6. package/package.json +1 -1
package/README.md CHANGED
@@ -1,7 +1,6 @@
1
1
  # fossekall-interface
2
2
 
3
- `fossekall-interface` provides generated TypeScript types and runtime schemas
4
- for Fossekall data objects.
3
+ `fossekall-interface` provides TypeScript interfaces and generated `typed-binary` schemas for avionics commands and telemetry.
5
4
 
6
5
  ## Install
7
6
 
@@ -9,33 +8,58 @@ for Fossekall data objects.
9
8
  npm install fossekall-interface
10
9
  ```
11
10
 
12
- ## Usage
13
-
14
- Import generated objects from the package root:
15
-
16
- ```ts
17
- import { SomeSchema, type SomeType } from "fossekall-interface";
11
+ ## Project Structure
12
+
13
+ ```text
14
+ fossekall-interface/
15
+ scripts/
16
+ generate-index.ts
17
+ src/
18
+ index.ts
19
+ constants.ts
20
+ types.ts
21
+ generated/
22
+ index.ts
23
+ fc/
24
+ index.ts
25
+ commands.ts
26
+ telemetry.ts
27
+ ecu/
28
+ index.ts
29
+ commands.ts
30
+ telemetry.ts
18
31
  ```
19
32
 
20
- The root export surfaces generated modules intended for application
21
- integration and type-safe data handling.
33
+ ## Exports
22
34
 
23
- ## Package Output
35
+ The package root exports three namespaces:
24
36
 
25
- Published artifacts are compiled files from `dist/`, including:
37
+ - mcu: Generated `typed-binary` schemas from the avionics codebase
38
+ - constants: Manually added constants (e.g. IP addresses, port numbers, etc...)
39
+ - types: Utility types
26
40
 
27
- - JavaScript modules
28
- - Type declarations
41
+ ## Build Pipeline
42
+
43
+ Running the build executes two steps:
29
44
 
30
- ## Development
45
+ 1. prebuild: scripts/generate-index.ts regenerates index.ts files under
46
+ src/generated
47
+ 2. build: TypeScript compiles src to dist
31
48
 
32
- From this directory:
49
+ Build commands:
33
50
 
34
51
  ```bash
35
52
  npm install
36
53
  npm run build
37
54
  ```
38
55
 
56
+ ## Package Output
57
+
58
+ Published artifacts are emitted to `.dist/`:
59
+
60
+ - JavaScript modules
61
+ - Type declarations
62
+
39
63
  ## Publishing
40
64
 
41
65
  ```bash
@@ -43,5 +67,4 @@ npm version patch
43
67
  npm publish --access private
44
68
  ```
45
69
 
46
- If publishing with a token, configure `.npmrc` and set `NPM_TOKEN` in your
47
- environment.
70
+ The package runs build automatically during prepack.
package/dist/generated/ecu/commands.d.ts CHANGED
@@ -1,4 +1,15 @@
1
1
  import bin from 'typed-binary';
2
+ export declare const node_bldc_Id: {
3
+ readonly kFuel: 0;
4
+ readonly kOx: 1;
5
+ readonly kCount: 2;
6
+ };
7
+ export type node_bldc_Id = (typeof node_bldc_Id)[keyof typeof node_bldc_Id];
8
+ export declare const BldcCommands_SetBldcCommand: {
9
+ readonly open: 0;
10
+ readonly close: 1;
11
+ };
12
+ export type BldcCommands_SetBldcCommand = (typeof BldcCommands_SetBldcCommand)[keyof typeof BldcCommands_SetBldcCommand];
2
13
  export declare const Event: {
3
14
  readonly Boot: 0;
4
15
  readonly NextState: 1;
@@ -51,6 +62,30 @@ export declare const actuators_servo_StartPolicy: {
51
62
  readonly kNoInterrupt: 1;
52
63
  };
53
64
  export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
65
+ export declare const node_solenoid_Id: {
66
+ readonly kFuelVent: 0;
67
+ readonly kOxVent: 1;
68
+ readonly kN2Fill: 2;
69
+ readonly kOxBleed: 3;
70
+ readonly kN2_200_Supply: 4;
71
+ readonly kN2_200_Bleed: 5;
72
+ readonly kN2_300_Supply: 6;
73
+ readonly kN2_300_Bleed: 7;
74
+ readonly kQD_1: 8;
75
+ readonly kQD_2: 9;
76
+ readonly kCount: 10;
77
+ };
78
+ export type node_solenoid_Id = (typeof node_solenoid_Id)[keyof typeof node_solenoid_Id];
79
+ export declare const SolenoidCommands_SetSolenoidCommand: {
80
+ readonly open: 0;
81
+ readonly close: 1;
82
+ };
83
+ export type SolenoidCommands_SetSolenoidCommand = (typeof SolenoidCommands_SetSolenoidCommand)[keyof typeof SolenoidCommands_SetSolenoidCommand];
84
+ export declare const ControlPolicyCommands_PolicyValue: {
85
+ readonly Disable: 0;
86
+ readonly Enable: 1;
87
+ };
88
+ export type ControlPolicyCommands_PolicyValue = (typeof ControlPolicyCommands_PolicyValue)[keyof typeof ControlPolicyCommands_PolicyValue];
54
89
  export declare const node_regulator_Id: {
55
90
  readonly kOxPrechill: 0;
56
91
  readonly kCount: 1;
@@ -61,6 +96,11 @@ export declare const RegulatorCommands_RegulatorValue: {
61
96
  readonly Enable: 1;
62
97
  };
63
98
  export type RegulatorCommands_RegulatorValue = (typeof RegulatorCommands_RegulatorValue)[keyof typeof RegulatorCommands_RegulatorValue];
99
+ export declare const BldcCommands_SetBldcPayload: import("typed-binary").ObjectSchema<{
100
+ bldc_id: import("typed-binary").ByteSchema;
101
+ command: import("typed-binary").Uint32Schema;
102
+ }>;
103
+ export type BldcCommands_SetBldcPayload = bin.Parsed<typeof BldcCommands_SetBldcPayload>;
64
104
  export declare const FsmCommands_RaiseEventPayload: import("typed-binary").ObjectSchema<{
65
105
  event: import("typed-binary").ByteSchema;
66
106
  current_state: import("typed-binary").ByteSchema;
@@ -84,6 +124,15 @@ export declare const ServoCommands_SetServoPayload: import("typed-binary").Objec
84
124
  start_policy: import("typed-binary").ByteSchema;
85
125
  }>;
86
126
  export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
127
+ export declare const SolenoidCommands_SetSolenoidPayload: import("typed-binary").ObjectSchema<{
128
+ solenoid_id: import("typed-binary").ByteSchema;
129
+ command: import("typed-binary").Uint32Schema;
130
+ }>;
131
+ export type SolenoidCommands_SetSolenoidPayload = bin.Parsed<typeof SolenoidCommands_SetSolenoidPayload>;
132
+ export declare const ControlPolicyCommands_SetManualPolicyPayload: import("typed-binary").ObjectSchema<{
133
+ value: import("typed-binary").ByteSchema;
134
+ }>;
135
+ export type ControlPolicyCommands_SetManualPolicyPayload = bin.Parsed<typeof ControlPolicyCommands_SetManualPolicyPayload>;
87
136
  export declare const RegulatorCommands_SetEnabledPayload: import("typed-binary").ObjectSchema<{
88
137
  regulator_id: import("typed-binary").ByteSchema;
89
138
  value: import("typed-binary").ByteSchema;
@@ -102,6 +151,24 @@ export declare const RegulatorCommands_SetGainsPayload: import("typed-binary").O
102
151
  }>;
103
152
  export type RegulatorCommands_SetGainsPayload = bin.Parsed<typeof RegulatorCommands_SetGainsPayload>;
104
153
  export declare const spec: {
154
+ BldcCommands_SetBldcPayload: {
155
+ id: number;
156
+ schema: import("typed-binary").ObjectSchema<{
157
+ bldc_id: import("typed-binary").ByteSchema;
158
+ command: import("typed-binary").Uint32Schema;
159
+ }>;
160
+ enums: {
161
+ bldc_id: {
162
+ readonly kFuel: 0;
163
+ readonly kOx: 1;
164
+ readonly kCount: 2;
165
+ };
166
+ command: {
167
+ readonly open: 0;
168
+ readonly close: 1;
169
+ };
170
+ };
171
+ };
105
172
  FsmCommands_RaiseEventPayload: {
106
173
  id: number;
107
174
  schema: import("typed-binary").ObjectSchema<{
@@ -199,6 +266,44 @@ export declare const spec: {
199
266
  };
200
267
  };
201
268
  };
269
+ SolenoidCommands_SetSolenoidPayload: {
270
+ id: number;
271
+ schema: import("typed-binary").ObjectSchema<{
272
+ solenoid_id: import("typed-binary").ByteSchema;
273
+ command: import("typed-binary").Uint32Schema;
274
+ }>;
275
+ enums: {
276
+ solenoid_id: {
277
+ readonly kFuelVent: 0;
278
+ readonly kOxVent: 1;
279
+ readonly kN2Fill: 2;
280
+ readonly kOxBleed: 3;
281
+ readonly kN2_200_Supply: 4;
282
+ readonly kN2_200_Bleed: 5;
283
+ readonly kN2_300_Supply: 6;
284
+ readonly kN2_300_Bleed: 7;
285
+ readonly kQD_1: 8;
286
+ readonly kQD_2: 9;
287
+ readonly kCount: 10;
288
+ };
289
+ command: {
290
+ readonly open: 0;
291
+ readonly close: 1;
292
+ };
293
+ };
294
+ };
295
+ ControlPolicyCommands_SetManualPolicyPayload: {
296
+ id: number;
297
+ schema: import("typed-binary").ObjectSchema<{
298
+ value: import("typed-binary").ByteSchema;
299
+ }>;
300
+ enums: {
301
+ value: {
302
+ readonly Disable: 0;
303
+ readonly Enable: 1;
304
+ };
305
+ };
306
+ };
202
307
  RegulatorCommands_SetEnabledPayload: {
203
308
  id: number;
204
309
  schema: import("typed-binary").ObjectSchema<{
package/dist/generated/ecu/commands.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import bin, { Measurer, Schema } from 'typed-binary';
2
- // This file was generated by FRICC on 2026-03-19 10:51:03. Do not edit manually!
2
+ // This file was generated by FRICC on 2026-03-22 13:52:51. Do not edit manually!
3
3
  // The current version of typed-binary does not support 64-bit primitives.
4
4
  // So for we'll implement our own schemas. :)
5
5
  const __littleEndian = true;
@@ -60,6 +60,15 @@ class Float64Schema extends Schema {
60
60
  const u64 = new UInt64Schema();
61
61
  const i64 = new Int64Schema();
62
62
  const f64 = new Float64Schema();
63
+ export const node_bldc_Id = {
64
+ kFuel: 0,
65
+ kOx: 1,
66
+ kCount: 2,
67
+ };
68
+ export const BldcCommands_SetBldcCommand = {
69
+ open: 0,
70
+ close: 1,
71
+ };
63
72
  export const Event = {
64
73
  Boot: 0,
65
74
  NextState: 1,
@@ -106,6 +115,27 @@ export const actuators_servo_StartPolicy = {
106
115
  kPreempt: 0,
107
116
  kNoInterrupt: 1,
108
117
  };
118
+ export const node_solenoid_Id = {
119
+ kFuelVent: 0,
120
+ kOxVent: 1,
121
+ kN2Fill: 2,
122
+ kOxBleed: 3,
123
+ kN2_200_Supply: 4,
124
+ kN2_200_Bleed: 5,
125
+ kN2_300_Supply: 6,
126
+ kN2_300_Bleed: 7,
127
+ kQD_1: 8,
128
+ kQD_2: 9,
129
+ kCount: 10,
130
+ };
131
+ export const SolenoidCommands_SetSolenoidCommand = {
132
+ open: 0,
133
+ close: 1,
134
+ };
135
+ export const ControlPolicyCommands_PolicyValue = {
136
+ Disable: 0,
137
+ Enable: 1,
138
+ };
109
139
  export const node_regulator_Id = {
110
140
  kOxPrechill: 0,
111
141
  kCount: 1,
@@ -114,6 +144,10 @@ export const RegulatorCommands_RegulatorValue = {
114
144
  Disable: 0,
115
145
  Enable: 1,
116
146
  };
147
+ export const BldcCommands_SetBldcPayload = bin.object({
148
+ bldc_id: bin.u8, // node::bldc::Id
149
+ command: bin.u32, // BldcCommands::SetBldcCommand
150
+ });
117
151
  export const FsmCommands_RaiseEventPayload = bin.object({
118
152
  event: bin.u8, // Event
119
153
  current_state: bin.u8, // StateId
@@ -134,6 +168,13 @@ export const ServoCommands_SetServoPayload = bin.object({
134
168
  position_mode: bin.u8, // actuators::servo::PositionMode
135
169
  start_policy: bin.u8, // actuators::servo::StartPolicy
136
170
  });
171
+ export const SolenoidCommands_SetSolenoidPayload = bin.object({
172
+ solenoid_id: bin.u8, // node::solenoid::Id
173
+ command: bin.u32, // SolenoidCommands::SetSolenoidCommand
174
+ });
175
+ export const ControlPolicyCommands_SetManualPolicyPayload = bin.object({
176
+ value: bin.u8, // ControlPolicyCommands::PolicyValue
177
+ });
137
178
  export const RegulatorCommands_SetEnabledPayload = bin.object({
138
179
  regulator_id: bin.u8, // node::regulator::Id
139
180
  value: bin.u8, // RegulatorCommands::RegulatorValue
@@ -149,6 +190,14 @@ export const RegulatorCommands_SetGainsPayload = bin.object({
149
190
  kd: bin.f32, // float
150
191
  });
151
192
  export const spec = {
193
+ BldcCommands_SetBldcPayload: {
194
+ id: 64,
195
+ schema: BldcCommands_SetBldcPayload,
196
+ enums: {
197
+ bldc_id: node_bldc_Id,
198
+ command: BldcCommands_SetBldcCommand,
199
+ },
200
+ },
152
201
  FsmCommands_RaiseEventPayload: {
153
202
  id: 32,
154
203
  schema: FsmCommands_RaiseEventPayload,
@@ -176,6 +225,21 @@ export const spec = {
176
225
  start_policy: actuators_servo_StartPolicy,
177
226
  },
178
227
  },
228
+ SolenoidCommands_SetSolenoidPayload: {
229
+ id: 80,
230
+ schema: SolenoidCommands_SetSolenoidPayload,
231
+ enums: {
232
+ solenoid_id: node_solenoid_Id,
233
+ command: SolenoidCommands_SetSolenoidCommand,
234
+ },
235
+ },
236
+ ControlPolicyCommands_SetManualPolicyPayload: {
237
+ id: 96,
238
+ schema: ControlPolicyCommands_SetManualPolicyPayload,
239
+ enums: {
240
+ value: ControlPolicyCommands_PolicyValue,
241
+ },
242
+ },
179
243
  RegulatorCommands_SetEnabledPayload: {
180
244
  id: 112,
181
245
  schema: RegulatorCommands_SetEnabledPayload,
package/dist/generated/ecu/telemetry.d.ts CHANGED
@@ -30,6 +30,34 @@ export declare const actuators_solenoid_Opening: {
30
30
  readonly kOpen: 2;
31
31
  };
32
32
  export type actuators_solenoid_Opening = (typeof actuators_solenoid_Opening)[keyof typeof actuators_solenoid_Opening];
33
+ export declare const StateId: {
34
+ readonly Safe: 0;
35
+ readonly FuelFill: 1;
36
+ readonly PostFuelFill: 2;
37
+ readonly N2Fill: 3;
38
+ readonly PostN2Fill: 4;
39
+ readonly OxFill: 5;
40
+ readonly PostOxFill: 6;
41
+ readonly Pressurized: 7;
42
+ readonly Armed: 8;
43
+ readonly Burn: 9;
44
+ readonly Shutdown: 10;
45
+ readonly PostBurn: 11;
46
+ readonly Depressurize: 12;
47
+ readonly Calibrate: 13;
48
+ };
49
+ export type StateId = (typeof StateId)[keyof typeof StateId];
50
+ export declare const Event: {
51
+ readonly Boot: 0;
52
+ readonly NextState: 1;
53
+ readonly PreviousState: 2;
54
+ readonly Timeout: 3;
55
+ readonly CalibrateRequest: 4;
56
+ readonly Abort: 5;
57
+ readonly None: 6;
58
+ readonly Count: 7;
59
+ };
60
+ export type Event = (typeof Event)[keyof typeof Event];
33
61
  export declare const actuators_servo_ServoStatus: import("typed-binary").ObjectSchema<{
34
62
  commanded_angle_deg: import("typed-binary").Float32Schema;
35
63
  target_angle_deg: import("typed-binary").Float32Schema;
@@ -60,10 +88,82 @@ export declare const actuators_solenoid_SolenoidStatus: import("typed-binary").O
60
88
  opening: import("typed-binary").ByteSchema;
61
89
  }>;
62
90
  export type actuators_solenoid_SolenoidStatus = bin.Parsed<typeof actuators_solenoid_SolenoidStatus>;
91
+ export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
92
+ message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
93
+ }>;
94
+ export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
95
+ export declare const regulators_RegulatorStatus: import("typed-binary").ObjectSchema<{
96
+ operator_enabled: import("typed-binary").BoolSchema;
97
+ policy_enabled: import("typed-binary").BoolSchema;
98
+ active: import("typed-binary").BoolSchema;
99
+ setpoint: import("typed-binary").Float32Schema;
100
+ kp: import("typed-binary").Float32Schema;
101
+ ki: import("typed-binary").Float32Schema;
102
+ kd: import("typed-binary").Float32Schema;
103
+ integral: import("typed-binary").Float32Schema;
104
+ previous_error: import("typed-binary").Float32Schema;
105
+ last_measurement: import("typed-binary").Float32Schema;
106
+ last_output: import("typed-binary").Float32Schema;
107
+ last_servo_command_: import("typed-binary").Float32Schema;
108
+ last_update_ms: import("typed-binary").Uint32Schema;
109
+ }>;
110
+ export type regulators_RegulatorStatus = bin.Parsed<typeof regulators_RegulatorStatus>;
111
+ export declare const RegulatorStatusEntry: import("typed-binary").ObjectSchema<{
112
+ id: import("typed-binary").ByteSchema;
113
+ name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
114
+ status: import("typed-binary").ObjectSchema<{
115
+ operator_enabled: import("typed-binary").BoolSchema;
116
+ policy_enabled: import("typed-binary").BoolSchema;
117
+ active: import("typed-binary").BoolSchema;
118
+ setpoint: import("typed-binary").Float32Schema;
119
+ kp: import("typed-binary").Float32Schema;
120
+ ki: import("typed-binary").Float32Schema;
121
+ kd: import("typed-binary").Float32Schema;
122
+ integral: import("typed-binary").Float32Schema;
123
+ previous_error: import("typed-binary").Float32Schema;
124
+ last_measurement: import("typed-binary").Float32Schema;
125
+ last_output: import("typed-binary").Float32Schema;
126
+ last_servo_command_: import("typed-binary").Float32Schema;
127
+ last_update_ms: import("typed-binary").Uint32Schema;
128
+ }>;
129
+ }>;
130
+ export type RegulatorStatusEntry = bin.Parsed<typeof RegulatorStatusEntry>;
131
+ export declare const RegulatorStatusArrayPacket: import("typed-binary").ObjectSchema<{
132
+ count: import("typed-binary").ByteSchema;
133
+ timestamp_ms: import("typed-binary").Uint32Schema;
134
+ entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
135
+ id: import("typed-binary").ByteSchema;
136
+ name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
137
+ status: import("typed-binary").ObjectSchema<{
138
+ operator_enabled: import("typed-binary").BoolSchema;
139
+ policy_enabled: import("typed-binary").BoolSchema;
140
+ active: import("typed-binary").BoolSchema;
141
+ setpoint: import("typed-binary").Float32Schema;
142
+ kp: import("typed-binary").Float32Schema;
143
+ ki: import("typed-binary").Float32Schema;
144
+ kd: import("typed-binary").Float32Schema;
145
+ integral: import("typed-binary").Float32Schema;
146
+ previous_error: import("typed-binary").Float32Schema;
147
+ last_measurement: import("typed-binary").Float32Schema;
148
+ last_output: import("typed-binary").Float32Schema;
149
+ last_servo_command_: import("typed-binary").Float32Schema;
150
+ last_update_ms: import("typed-binary").Uint32Schema;
151
+ }>;
152
+ }>>;
153
+ }>;
154
+ export type RegulatorStatusArrayPacket = bin.Parsed<typeof RegulatorStatusArrayPacket>;
155
+ export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
156
+ state_entry_time_ms: import("typed-binary").Uint32Schema;
157
+ state_time_ms: import("typed-binary").Uint32Schema;
158
+ current_state: import("typed-binary").ByteSchema;
159
+ previous_state: import("typed-binary").ByteSchema;
160
+ last_event: import("typed-binary").ByteSchema;
161
+ }>;
162
+ export type fsm_FsmStatus = bin.Parsed<typeof fsm_FsmStatus>;
63
163
  export declare const spec: {
64
- readonly actuators_servo_ServoStatus: {
65
- readonly port: 5003;
66
- readonly schema: import("typed-binary").ObjectSchema<{
164
+ actuators_servo_ServoStatus: {
165
+ port: number;
166
+ schema: import("typed-binary").ObjectSchema<{
67
167
  commanded_angle_deg: import("typed-binary").Float32Schema;
68
168
  target_angle_deg: import("typed-binary").Float32Schema;
69
169
  measured_angle_deg: import("typed-binary").Float32Schema;
@@ -71,13 +171,13 @@ export declare const spec: {
71
171
  mode: import("typed-binary").ByteSchema;
72
172
  power_state: import("typed-binary").ByteSchema;
73
173
  }>;
74
- readonly enums: {
75
- readonly mode: {
174
+ enums: {
175
+ mode: {
76
176
  readonly kUnknown: 0;
77
177
  readonly kPosition: 1;
78
178
  readonly kCalibrate: 2;
79
179
  };
80
- readonly power_state: {
180
+ power_state: {
81
181
  readonly kUnknown: 0;
82
182
  readonly kOff: 1;
83
183
  readonly kBooting: 2;
@@ -85,9 +185,9 @@ export declare const spec: {
85
185
  };
86
186
  };
87
187
  };
88
- readonly BldcTelemetry: {
89
- readonly port: 5000;
90
- readonly schema: import("typed-binary").ObjectSchema<{
188
+ BldcTelemetry: {
189
+ port: number;
190
+ schema: import("typed-binary").ObjectSchema<{
91
191
  valve_position: import("typed-binary").Float32Schema;
92
192
  motor_position: import("typed-binary").Float32Schema;
93
193
  timestamp: UInt64Schema;
@@ -102,27 +202,114 @@ export declare const spec: {
102
202
  position_raw: import("typed-binary").Float32Schema;
103
203
  calibrated: import("typed-binary").ByteSchema;
104
204
  }>;
105
- readonly enums: {};
205
+ enums: {};
106
206
  };
107
- readonly actuators_solenoid_SolenoidStatus: {
108
- readonly port: 5004;
109
- readonly schema: import("typed-binary").ObjectSchema<{
207
+ actuators_solenoid_SolenoidStatus: {
208
+ port: number;
209
+ schema: import("typed-binary").ObjectSchema<{
110
210
  power_state: import("typed-binary").ByteSchema;
111
211
  opening: import("typed-binary").ByteSchema;
112
212
  }>;
113
- readonly enums: {
114
- readonly power_state: {
213
+ enums: {
214
+ power_state: {
115
215
  readonly kUnknown: 0;
116
216
  readonly kOff: 1;
117
217
  readonly kOn: 2;
118
218
  };
119
- readonly opening: {
219
+ opening: {
120
220
  readonly kUnknown: 0;
121
221
  readonly kClosed: 1;
122
222
  readonly kOpen: 2;
123
223
  };
124
224
  };
125
225
  };
226
+ HeartBeatTelemetry: {
227
+ schema: import("typed-binary").ObjectSchema<{
228
+ message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
229
+ }>;
230
+ enums: {};
231
+ };
232
+ RegulatorStatusArrayPacket: {
233
+ port: number;
234
+ schema: import("typed-binary").ObjectSchema<{
235
+ count: import("typed-binary").ByteSchema;
236
+ timestamp_ms: import("typed-binary").Uint32Schema;
237
+ entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
238
+ id: import("typed-binary").ByteSchema;
239
+ name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
240
+ status: import("typed-binary").ObjectSchema<{
241
+ operator_enabled: import("typed-binary").BoolSchema;
242
+ policy_enabled: import("typed-binary").BoolSchema;
243
+ active: import("typed-binary").BoolSchema;
244
+ setpoint: import("typed-binary").Float32Schema;
245
+ kp: import("typed-binary").Float32Schema;
246
+ ki: import("typed-binary").Float32Schema;
247
+ kd: import("typed-binary").Float32Schema;
248
+ integral: import("typed-binary").Float32Schema;
249
+ previous_error: import("typed-binary").Float32Schema;
250
+ last_measurement: import("typed-binary").Float32Schema;
251
+ last_output: import("typed-binary").Float32Schema;
252
+ last_servo_command_: import("typed-binary").Float32Schema;
253
+ last_update_ms: import("typed-binary").Uint32Schema;
254
+ }>;
255
+ }>>;
256
+ }>;
257
+ enums: {};
258
+ };
259
+ fsm_FsmStatus: {
260
+ port: number;
261
+ schema: import("typed-binary").ObjectSchema<{
262
+ state_entry_time_ms: import("typed-binary").Uint32Schema;
263
+ state_time_ms: import("typed-binary").Uint32Schema;
264
+ current_state: import("typed-binary").ByteSchema;
265
+ previous_state: import("typed-binary").ByteSchema;
266
+ last_event: import("typed-binary").ByteSchema;
267
+ }>;
268
+ enums: {
269
+ current_state: {
270
+ readonly Safe: 0;
271
+ readonly FuelFill: 1;
272
+ readonly PostFuelFill: 2;
273
+ readonly N2Fill: 3;
274
+ readonly PostN2Fill: 4;
275
+ readonly OxFill: 5;
276
+ readonly PostOxFill: 6;
277
+ readonly Pressurized: 7;
278
+ readonly Armed: 8;
279
+ readonly Burn: 9;
280
+ readonly Shutdown: 10;
281
+ readonly PostBurn: 11;
282
+ readonly Depressurize: 12;
283
+ readonly Calibrate: 13;
284
+ };
285
+ previous_state: {
286
+ readonly Safe: 0;
287
+ readonly FuelFill: 1;
288
+ readonly PostFuelFill: 2;
289
+ readonly N2Fill: 3;
290
+ readonly PostN2Fill: 4;
291
+ readonly OxFill: 5;
292
+ readonly PostOxFill: 6;
293
+ readonly Pressurized: 7;
294
+ readonly Armed: 8;
295
+ readonly Burn: 9;
296
+ readonly Shutdown: 10;
297
+ readonly PostBurn: 11;
298
+ readonly Depressurize: 12;
299
+ readonly Calibrate: 13;
300
+ };
301
+ last_event: {
302
+ readonly Boot: 0;
303
+ readonly NextState: 1;
304
+ readonly PreviousState: 2;
305
+ readonly Timeout: 3;
306
+ readonly CalibrateRequest: 4;
307
+ readonly Abort: 5;
308
+ readonly None: 6;
309
+ readonly Count: 7;
310
+ };
311
+ };
312
+ };
126
313
  };
127
314
  export default spec;
128
315
  export type Spec = typeof spec;
package/dist/generated/ecu/telemetry.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import bin, { Measurer, Schema } from 'typed-binary';
2
- // This file was generated by FRICC on 2026-03-19 10:00:44. Do not edit manually!
2
+ // This file was generated by FRICC on 2026-03-22 14:02:58. Do not edit manually!
3
3
  // The current version of typed-binary does not support 64-bit primitives.
4
4
  // So for we'll implement our own schemas. :)
5
5
  const __littleEndian = true;
@@ -81,6 +81,32 @@ export const actuators_solenoid_Opening = {
81
81
  kClosed: 1,
82
82
  kOpen: 2,
83
83
  };
84
+ export const StateId = {
85
+ Safe: 0,
86
+ FuelFill: 1,
87
+ PostFuelFill: 2,
88
+ N2Fill: 3,
89
+ PostN2Fill: 4,
90
+ OxFill: 5,
91
+ PostOxFill: 6,
92
+ Pressurized: 7,
93
+ Armed: 8,
94
+ Burn: 9,
95
+ Shutdown: 10,
96
+ PostBurn: 11,
97
+ Depressurize: 12,
98
+ Calibrate: 13,
99
+ };
100
+ export const Event = {
101
+ Boot: 0,
102
+ NextState: 1,
103
+ PreviousState: 2,
104
+ Timeout: 3,
105
+ CalibrateRequest: 4,
106
+ Abort: 5,
107
+ None: 6,
108
+ Count: 7,
109
+ };
84
110
  export const actuators_servo_ServoStatus = bin.object({
85
111
  commanded_angle_deg: bin.f32, // float
86
112
  target_angle_deg: bin.f32, // float
@@ -108,6 +134,41 @@ export const actuators_solenoid_SolenoidStatus = bin.object({
108
134
  power_state: bin.u8, // actuators::solenoid::PowerState
109
135
  opening: bin.u8, // actuators::solenoid::Opening
110
136
  });
137
+ export const HeartBeatTelemetry = bin.object({
138
+ message: bin.arrayOf(bin.i8, 16), // char[16]
139
+ });
140
+ export const regulators_RegulatorStatus = bin.object({
141
+ operator_enabled: bin.bool, // bool
142
+ policy_enabled: bin.bool, // bool
143
+ active: bin.bool, // bool
144
+ setpoint: bin.f32, // float
145
+ kp: bin.f32, // float
146
+ ki: bin.f32, // float
147
+ kd: bin.f32, // float
148
+ integral: bin.f32, // float
149
+ previous_error: bin.f32, // float
150
+ last_measurement: bin.f32, // float
151
+ last_output: bin.f32, // float
152
+ last_servo_command_: bin.f32, // float
153
+ last_update_ms: bin.u32, // unsigned int
154
+ });
155
+ export const RegulatorStatusEntry = bin.object({
156
+ id: bin.u8, // node::regulator::Id
157
+ name: bin.arrayOf(bin.i8, 24), // char[24]
158
+ status: regulators_RegulatorStatus, // regulators::RegulatorStatus
159
+ });
160
+ export const RegulatorStatusArrayPacket = bin.object({
161
+ count: bin.u8, // unsigned char
162
+ timestamp_ms: bin.u32, // unsigned int
163
+ entries: bin.arrayOf(RegulatorStatusEntry, 1), // RegulatorStatusEntry[1]
164
+ });
165
+ export const fsm_FsmStatus = bin.object({
166
+ state_entry_time_ms: bin.u32, // unsigned int
167
+ state_time_ms: bin.u32, // unsigned int
168
+ current_state: bin.u8, // StateId
169
+ previous_state: bin.u8, // StateId
170
+ last_event: bin.u8, // Event
171
+ });
111
172
  export const spec = {
112
173
  actuators_servo_ServoStatus: {
113
174
  port: 5003,
@@ -130,5 +191,23 @@ export const spec = {
130
191
  opening: actuators_solenoid_Opening,
131
192
  },
132
193
  },
194
+ HeartBeatTelemetry: {
195
+ schema: HeartBeatTelemetry,
196
+ enums: {},
197
+ },
198
+ RegulatorStatusArrayPacket: {
199
+ port: 5005,
200
+ schema: RegulatorStatusArrayPacket,
201
+ enums: {},
202
+ },
203
+ fsm_FsmStatus: {
204
+ port: 5001,
205
+ schema: fsm_FsmStatus,
206
+ enums: {
207
+ current_state: StateId,
208
+ previous_state: StateId,
209
+ last_event: Event,
210
+ },
211
+ },
133
212
  };
134
213
  export default spec;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "fossekall-interface",
3
- "version": "0.1.19",
3
+ "version": "0.1.20",
4
4
  "description": "API contracts between client and server (rocket and GUI)",
5
5
  "license": "ISC",
6
6
  "author": "Propulse",