fossekall-interface 0.1.124 → 0.1.125

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 (11) hide show
  1. package/dist/generated/ecu/commands.d.ts +289 -120
  2. package/dist/generated/ecu/commands.js +114 -63
  3. package/dist/generated/ecu/commands.json +569 -0
  4. package/dist/generated/ecu/index.d.ts +2 -0
  5. package/dist/generated/ecu/index.js +2 -0
  6. package/dist/generated/ecu/telemetry.d.ts +640 -211
  7. package/dist/generated/ecu/telemetry.js +284 -95
  8. package/dist/generated/ecu/telemetry.json +913 -0
  9. package/dist/generated/fc/telemetry.d.ts +15 -40
  10. package/dist/generated/fc/telemetry.js +12 -20
  11. package/package.json +1 -1
package/dist/generated/ecu/telemetry.d.ts CHANGED
@@ -5,6 +5,77 @@ declare class UInt64Schema extends Schema<bigint> {
5
5
  write(output: ISerialOutput, value: bigint): void;
6
6
  measure(_: bigint | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
7
7
  }
8
+ declare class Float64Schema extends Schema<number> {
9
+ readonly maxSize = 8;
10
+ read(input: ISerialInput): number;
11
+ write(output: ISerialOutput, value: number): void;
12
+ measure(_: number | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
13
+ }
14
+ export declare const node_bldc_Id: {
15
+ readonly Fuel: 0;
16
+ readonly Ox: 1;
17
+ readonly Count: 2;
18
+ };
19
+ export type node_bldc_Id = (typeof node_bldc_Id)[keyof typeof node_bldc_Id];
20
+ export declare const StateId: {
21
+ readonly Safe: 0;
22
+ readonly N2Fill: 1;
23
+ readonly PostN2Fill: 2;
24
+ readonly OxFill: 3;
25
+ readonly PostOxFill: 4;
26
+ readonly QDDisconnect: 5;
27
+ readonly Pressurized: 6;
28
+ readonly Armed: 7;
29
+ readonly Burn: 8;
30
+ readonly Shutdown: 9;
31
+ readonly PostShutdown: 10;
32
+ readonly Purge: 11;
33
+ readonly Hold: 12;
34
+ };
35
+ export type StateId = (typeof StateId)[keyof typeof StateId];
36
+ export declare const Event: {
37
+ readonly Boot: 0;
38
+ readonly NextState: 1;
39
+ readonly PreviousState: 2;
40
+ readonly Timeout: 3;
41
+ readonly CalibrateRequest: 4;
42
+ readonly BurnwireCut: 5;
43
+ readonly Abort: 6;
44
+ readonly None: 7;
45
+ readonly Count: 8;
46
+ };
47
+ export type Event = (typeof Event)[keyof typeof Event];
48
+ export declare const fsm_AbortReason: {
49
+ readonly None: 0;
50
+ readonly Manual: 1;
51
+ readonly FuelTankOverpressure: 2;
52
+ readonly OxTankOverpressure: 3;
53
+ readonly ChamberUnderpressure: 4;
54
+ };
55
+ export type fsm_AbortReason = (typeof fsm_AbortReason)[keyof typeof fsm_AbortReason];
56
+ export declare const node_pressure_sensor_Id: {
57
+ readonly N2Tank: 0;
58
+ readonly OxTank: 1;
59
+ readonly OxInjector: 2;
60
+ readonly FuelTank: 3;
61
+ readonly FuelInjector: 4;
62
+ readonly FuelInlet: 5;
63
+ readonly Chamber: 6;
64
+ readonly OxSupply: 7;
65
+ readonly N2_300: 8;
66
+ readonly Count: 9;
67
+ };
68
+ export type node_pressure_sensor_Id = (typeof node_pressure_sensor_Id)[keyof typeof node_pressure_sensor_Id];
69
+ export declare const node_servo_Id: {
70
+ readonly MainFuel: 0;
71
+ readonly MainOx: 1;
72
+ readonly OxFill: 2;
73
+ readonly OxBoiloff: 3;
74
+ readonly OxSupply: 4;
75
+ readonly Purge: 5;
76
+ readonly Count: 6;
77
+ };
78
+ export type node_servo_Id = (typeof node_servo_Id)[keyof typeof node_servo_Id];
8
79
  export declare const actuators_servo_ServoMode: {
9
80
  readonly kUnknown: 0;
10
81
  readonly kPosition: 1;
@@ -18,6 +89,18 @@ export declare const actuators_servo_PowerState: {
18
89
  readonly kOn: 3;
19
90
  };
20
91
  export type actuators_servo_PowerState = (typeof actuators_servo_PowerState)[keyof typeof actuators_servo_PowerState];
92
+ export declare const node_solenoid_Id: {
93
+ readonly FuelVent: 0;
94
+ readonly OxVent: 1;
95
+ readonly N2Fill: 2;
96
+ readonly OxHoseBleed: 3;
97
+ readonly N2_300_Supply: 4;
98
+ readonly N2_300_Hose_Bleed: 5;
99
+ readonly QD_1: 6;
100
+ readonly QD_2: 7;
101
+ readonly Count: 8;
102
+ };
103
+ export type node_solenoid_Id = (typeof node_solenoid_Id)[keyof typeof node_solenoid_Id];
21
104
  export declare const actuators_solenoid_PowerState: {
22
105
  readonly kUnknown: 0;
23
106
  readonly kOff: 1;
@@ -30,42 +113,105 @@ export declare const actuators_solenoid_Opening: {
30
113
  readonly kOpen: 2;
31
114
  };
32
115
  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 N2Fill: 1;
36
- readonly PostN2Fill: 2;
37
- readonly OxFill: 3;
38
- readonly PostOxFill: 4;
39
- readonly Prechill: 5;
40
- readonly PostPrechill: 6;
41
- readonly QDDisconnect: 7;
42
- readonly Pressurized: 8;
43
- readonly Armed: 9;
44
- readonly Burn: 10;
45
- readonly Shutdown: 11;
46
- readonly PostShutdown: 12;
47
- readonly Calibrate: 13;
116
+ export declare const node_regulator_Id: {
117
+ readonly OxBoiloff: 0;
118
+ readonly Count: 1;
48
119
  };
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 BurnwireCut: 5;
57
- readonly Abort: 6;
58
- readonly None: 7;
120
+ export type node_regulator_Id = (typeof node_regulator_Id)[keyof typeof node_regulator_Id];
121
+ export declare const proto_can_thermocouple_Id: {
122
+ readonly OxTankBottom: 0;
123
+ readonly OxTankTop: 1;
124
+ readonly FuelTank: 2;
125
+ readonly OxInjector: 3;
126
+ readonly Chamber1: 4;
127
+ readonly FuelInjector: 5;
128
+ readonly Chamber2: 6;
129
+ readonly ExtraNodeOne: 7;
59
130
  readonly Count: 8;
60
131
  };
61
- export type Event = (typeof Event)[keyof typeof Event];
62
- export declare const fsm_AbortReason: {
63
- readonly None: 0;
64
- readonly FuelTankOverpressure: 1;
65
- readonly OxTankOverpressure: 2;
66
- readonly ChamberUnderpressure: 3;
132
+ export type proto_can_thermocouple_Id = (typeof proto_can_thermocouple_Id)[keyof typeof proto_can_thermocouple_Id];
133
+ export declare const node_load_cell_Id: {
134
+ readonly LoadCell1: 0;
135
+ readonly LoadCell2: 1;
136
+ readonly LoadCell3: 2;
137
+ readonly Count: 3;
67
138
  };
68
- export type fsm_AbortReason = (typeof fsm_AbortReason)[keyof typeof fsm_AbortReason];
139
+ export type node_load_cell_Id = (typeof node_load_cell_Id)[keyof typeof node_load_cell_Id];
140
+ export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
141
+ message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
142
+ status_flags: import("typed-binary").ByteSchema;
143
+ }>;
144
+ export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
145
+ export declare const actuators_bldc_BldcTelemetry: import("typed-binary").ObjectSchema<{
146
+ valve_position: import("typed-binary").Float32Schema;
147
+ motor_position: import("typed-binary").Float32Schema;
148
+ current_draw: import("typed-binary").Float32Schema;
149
+ u_p: import("typed-binary").Float32Schema;
150
+ u_i: import("typed-binary").Float32Schema;
151
+ u_d: import("typed-binary").Float32Schema;
152
+ u_total: import("typed-binary").Float32Schema;
153
+ u_raw: import("typed-binary").Float32Schema;
154
+ status_flags: import("typed-binary").ByteSchema;
155
+ }>;
156
+ export type actuators_bldc_BldcTelemetry = bin.Parsed<typeof actuators_bldc_BldcTelemetry>;
157
+ export declare const BldcTelemetryPacket: import("typed-binary").ObjectSchema<{
158
+ bldc_id: import("typed-binary").ByteSchema;
159
+ fsm_state: import("typed-binary").ByteSchema;
160
+ telemetry: import("typed-binary").ObjectSchema<{
161
+ valve_position: import("typed-binary").Float32Schema;
162
+ motor_position: import("typed-binary").Float32Schema;
163
+ current_draw: import("typed-binary").Float32Schema;
164
+ u_p: import("typed-binary").Float32Schema;
165
+ u_i: import("typed-binary").Float32Schema;
166
+ u_d: import("typed-binary").Float32Schema;
167
+ u_total: import("typed-binary").Float32Schema;
168
+ u_raw: import("typed-binary").Float32Schema;
169
+ status_flags: import("typed-binary").ByteSchema;
170
+ }>;
171
+ }>;
172
+ export type BldcTelemetryPacket = bin.Parsed<typeof BldcTelemetryPacket>;
173
+ export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
174
+ state_entry_time_ms: UInt64Schema;
175
+ state_time_ms: UInt64Schema;
176
+ current_state: import("typed-binary").ByteSchema;
177
+ previous_state: import("typed-binary").ByteSchema;
178
+ last_event: import("typed-binary").ByteSchema;
179
+ last_abort_reason: import("typed-binary").ByteSchema;
180
+ }>;
181
+ export type fsm_FsmStatus = bin.Parsed<typeof fsm_FsmStatus>;
182
+ export declare const FsmStatusPacket: import("typed-binary").ObjectSchema<{
183
+ status: import("typed-binary").ObjectSchema<{
184
+ state_entry_time_ms: UInt64Schema;
185
+ state_time_ms: UInt64Schema;
186
+ current_state: import("typed-binary").ByteSchema;
187
+ previous_state: import("typed-binary").ByteSchema;
188
+ last_event: import("typed-binary").ByteSchema;
189
+ last_abort_reason: import("typed-binary").ByteSchema;
190
+ }>;
191
+ timestamp_ms: import("typed-binary").Uint32Schema;
192
+ }>;
193
+ export type FsmStatusPacket = bin.Parsed<typeof FsmStatusPacket>;
194
+ export declare const sensors_pressure_PressureBatch: import("typed-binary").ObjectSchema<{
195
+ t0_ms: import("typed-binary").Uint32Schema;
196
+ dt_us: import("typed-binary").Uint16Schema;
197
+ count: import("typed-binary").ByteSchema;
198
+ seq: import("typed-binary").ByteSchema;
199
+ overrun: import("typed-binary").BoolSchema;
200
+ samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
201
+ }>;
202
+ export type sensors_pressure_PressureBatch = bin.Parsed<typeof sensors_pressure_PressureBatch>;
203
+ export declare const PressureSensorPacket: import("typed-binary").ObjectSchema<{
204
+ sensor_id: import("typed-binary").ByteSchema;
205
+ data: import("typed-binary").ObjectSchema<{
206
+ t0_ms: import("typed-binary").Uint32Schema;
207
+ dt_us: import("typed-binary").Uint16Schema;
208
+ count: import("typed-binary").ByteSchema;
209
+ seq: import("typed-binary").ByteSchema;
210
+ overrun: import("typed-binary").BoolSchema;
211
+ samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
212
+ }>;
213
+ }>;
214
+ export type PressureSensorPacket = bin.Parsed<typeof PressureSensorPacket>;
69
215
  export declare const actuators_servo_ServoStatus: import("typed-binary").ObjectSchema<{
70
216
  commanded_angle_deg: import("typed-binary").Float32Schema;
71
217
  target_angle_deg: import("typed-binary").Float32Schema;
@@ -75,35 +221,39 @@ export declare const actuators_servo_ServoStatus: import("typed-binary").ObjectS
75
221
  power_state: import("typed-binary").ByteSchema;
76
222
  }>;
77
223
  export type actuators_servo_ServoStatus = bin.Parsed<typeof actuators_servo_ServoStatus>;
78
- export declare const BldcTelemetry: import("typed-binary").ObjectSchema<{
79
- valve_position: import("typed-binary").Float32Schema;
80
- motor_position: import("typed-binary").Float32Schema;
81
- timestamp: UInt64Schema;
82
- current_draw: import("typed-binary").Float32Schema;
83
- u_p: import("typed-binary").Float32Schema;
84
- u_i: import("typed-binary").Float32Schema;
85
- u_d: import("typed-binary").Float32Schema;
86
- u_pid: import("typed-binary").Float32Schema;
87
- u_ff: import("typed-binary").Float32Schema;
88
- u_set: import("typed-binary").Float32Schema;
89
- u_total: import("typed-binary").Float32Schema;
90
- position_raw: import("typed-binary").Float32Schema;
91
- calibrated: import("typed-binary").ByteSchema;
224
+ export declare const ServoStatusPacket: import("typed-binary").ObjectSchema<{
225
+ servo_id: import("typed-binary").ByteSchema;
226
+ timestamp_ms: import("typed-binary").Uint32Schema;
227
+ status: import("typed-binary").ObjectSchema<{
228
+ commanded_angle_deg: import("typed-binary").Float32Schema;
229
+ target_angle_deg: import("typed-binary").Float32Schema;
230
+ measured_angle_deg: import("typed-binary").Float32Schema;
231
+ current_ma: import("typed-binary").Float32Schema;
232
+ mode: import("typed-binary").ByteSchema;
233
+ power_state: import("typed-binary").ByteSchema;
234
+ }>;
92
235
  }>;
93
- export type BldcTelemetry = bin.Parsed<typeof BldcTelemetry>;
236
+ export type ServoStatusPacket = bin.Parsed<typeof ServoStatusPacket>;
94
237
  export declare const actuators_solenoid_SolenoidStatus: import("typed-binary").ObjectSchema<{
95
238
  power_state: import("typed-binary").ByteSchema;
96
239
  opening: import("typed-binary").ByteSchema;
97
240
  }>;
98
241
  export type actuators_solenoid_SolenoidStatus = bin.Parsed<typeof actuators_solenoid_SolenoidStatus>;
99
- export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
100
- message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
242
+ export declare const SolenoidStatusPacket: import("typed-binary").ObjectSchema<{
243
+ solenoid_id: import("typed-binary").ByteSchema;
244
+ timestamp_ms: import("typed-binary").Uint32Schema;
245
+ status: import("typed-binary").ObjectSchema<{
246
+ power_state: import("typed-binary").ByteSchema;
247
+ opening: import("typed-binary").ByteSchema;
248
+ }>;
101
249
  }>;
102
- export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
250
+ export type SolenoidStatusPacket = bin.Parsed<typeof SolenoidStatusPacket>;
103
251
  export declare const regulators_RegulatorStatus: import("typed-binary").ObjectSchema<{
104
252
  operator_enabled: import("typed-binary").BoolSchema;
105
253
  policy_enabled: import("typed-binary").BoolSchema;
106
254
  active: import("typed-binary").BoolSchema;
255
+ reserved: import("typed-binary").BoolSchema;
256
+ valveSetpoint: import("typed-binary").Float32Schema;
107
257
  setpoint: import("typed-binary").Float32Schema;
108
258
  kp: import("typed-binary").Float32Schema;
109
259
  ki: import("typed-binary").Float32Schema;
@@ -116,13 +266,15 @@ export declare const regulators_RegulatorStatus: import("typed-binary").ObjectSc
116
266
  last_update_ms: import("typed-binary").Uint32Schema;
117
267
  }>;
118
268
  export type regulators_RegulatorStatus = bin.Parsed<typeof regulators_RegulatorStatus>;
119
- export declare const RegulatorStatusEntry: import("typed-binary").ObjectSchema<{
120
- id: import("typed-binary").ByteSchema;
121
- name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
269
+ export declare const RegulatorStatusPacket: import("typed-binary").ObjectSchema<{
270
+ regulator_id: import("typed-binary").ByteSchema;
271
+ timestamp_ms: import("typed-binary").Uint32Schema;
122
272
  status: import("typed-binary").ObjectSchema<{
123
273
  operator_enabled: import("typed-binary").BoolSchema;
124
274
  policy_enabled: import("typed-binary").BoolSchema;
125
275
  active: import("typed-binary").BoolSchema;
276
+ reserved: import("typed-binary").BoolSchema;
277
+ valveSetpoint: import("typed-binary").Float32Schema;
126
278
  setpoint: import("typed-binary").Float32Schema;
127
279
  kp: import("typed-binary").Float32Schema;
128
280
  ki: import("typed-binary").Float32Schema;
@@ -135,41 +287,26 @@ export declare const RegulatorStatusEntry: import("typed-binary").ObjectSchema<{
135
287
  last_update_ms: import("typed-binary").Uint32Schema;
136
288
  }>;
137
289
  }>;
138
- export type RegulatorStatusEntry = bin.Parsed<typeof RegulatorStatusEntry>;
139
- export declare const RegulatorStatusArrayPacket: import("typed-binary").ObjectSchema<{
140
- count: import("typed-binary").ByteSchema;
290
+ export type RegulatorStatusPacket = bin.Parsed<typeof RegulatorStatusPacket>;
291
+ export declare const proto_can_thermocouple_ThermocoupleSample: import("typed-binary").ObjectSchema<{
292
+ id: import("typed-binary").ByteSchema;
293
+ timestamp_us: UInt64Schema;
294
+ interval_us: import("typed-binary").Float32Schema;
295
+ temperature_c: import("typed-binary").ArraySchema<import("typed-binary").Float32Schema>;
296
+ }>;
297
+ export type proto_can_thermocouple_ThermocoupleSample = bin.Parsed<typeof proto_can_thermocouple_ThermocoupleSample>;
298
+ export declare const ThermocouplePacket: import("typed-binary").ObjectSchema<{
299
+ thermocouple_id: import("typed-binary").ByteSchema;
141
300
  timestamp_ms: import("typed-binary").Uint32Schema;
142
- entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
301
+ data: import("typed-binary").ObjectSchema<{
143
302
  id: import("typed-binary").ByteSchema;
144
- name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
145
- status: import("typed-binary").ObjectSchema<{
146
- operator_enabled: import("typed-binary").BoolSchema;
147
- policy_enabled: import("typed-binary").BoolSchema;
148
- active: import("typed-binary").BoolSchema;
149
- setpoint: import("typed-binary").Float32Schema;
150
- kp: import("typed-binary").Float32Schema;
151
- ki: import("typed-binary").Float32Schema;
152
- kd: import("typed-binary").Float32Schema;
153
- integral: import("typed-binary").Float32Schema;
154
- previous_error: import("typed-binary").Float32Schema;
155
- last_measurement: import("typed-binary").Float32Schema;
156
- last_output: import("typed-binary").Float32Schema;
157
- last_servo_command_: import("typed-binary").Float32Schema;
158
- last_update_ms: import("typed-binary").Uint32Schema;
159
- }>;
160
- }>>;
161
- }>;
162
- export type RegulatorStatusArrayPacket = bin.Parsed<typeof RegulatorStatusArrayPacket>;
163
- export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
164
- state_entry_time_ms: UInt64Schema;
165
- state_time_ms: UInt64Schema;
166
- current_state: import("typed-binary").ByteSchema;
167
- previous_state: import("typed-binary").ByteSchema;
168
- last_event: import("typed-binary").ByteSchema;
169
- last_abort_reason: import("typed-binary").ByteSchema;
303
+ timestamp_us: UInt64Schema;
304
+ interval_us: import("typed-binary").Float32Schema;
305
+ temperature_c: import("typed-binary").ArraySchema<import("typed-binary").Float32Schema>;
306
+ }>;
170
307
  }>;
171
- export type fsm_FsmStatus = bin.Parsed<typeof fsm_FsmStatus>;
172
- export declare const sensors_pressure_PressureBatch: import("typed-binary").ObjectSchema<{
308
+ export type ThermocouplePacket = bin.Parsed<typeof ThermocouplePacket>;
309
+ export declare const sensors_loadcell_LoadCellBatch: import("typed-binary").ObjectSchema<{
173
310
  t0_ms: import("typed-binary").Uint32Schema;
174
311
  dt_us: import("typed-binary").Uint16Schema;
175
312
  count: import("typed-binary").ByteSchema;
@@ -177,9 +314,9 @@ export declare const sensors_pressure_PressureBatch: import("typed-binary").Obje
177
314
  overrun: import("typed-binary").BoolSchema;
178
315
  samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
179
316
  }>;
180
- export type sensors_pressure_PressureBatch = bin.Parsed<typeof sensors_pressure_PressureBatch>;
181
- export declare const PressureSensorData: import("typed-binary").ObjectSchema<{
182
- sensor_id: import("typed-binary").ByteSchema;
317
+ export type sensors_loadcell_LoadCellBatch = bin.Parsed<typeof sensors_loadcell_LoadCellBatch>;
318
+ export declare const LoadCellPacket: import("typed-binary").ObjectSchema<{
319
+ loadcell_id: import("typed-binary").ByteSchema;
183
320
  data: import("typed-binary").ObjectSchema<{
184
321
  t0_ms: import("typed-binary").Uint32Schema;
185
322
  dt_us: import("typed-binary").Uint16Schema;
@@ -189,169 +326,394 @@ export declare const PressureSensorData: import("typed-binary").ObjectSchema<{
189
326
  samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
190
327
  }>;
191
328
  }>;
192
- export type PressureSensorData = bin.Parsed<typeof PressureSensorData>;
329
+ export type LoadCellPacket = bin.Parsed<typeof LoadCellPacket>;
330
+ export declare const actuators_bldc_PidGains: import("typed-binary").ObjectSchema<{
331
+ p: Float64Schema;
332
+ i: Float64Schema;
333
+ d: Float64Schema;
334
+ normalization_factor: Float64Schema;
335
+ }>;
336
+ export type actuators_bldc_PidGains = bin.Parsed<typeof actuators_bldc_PidGains>;
337
+ export declare const SigmoidParameters: import("typed-binary").ObjectSchema<{
338
+ a: Float64Schema;
339
+ b: Float64Schema;
340
+ }>;
341
+ export type SigmoidParameters = bin.Parsed<typeof SigmoidParameters>;
342
+ export declare const actuators_bldc_ControllerConfig: import("typed-binary").ObjectSchema<{
343
+ pressurize_pid_gains: import("typed-binary").ObjectSchema<{
344
+ p: Float64Schema;
345
+ i: Float64Schema;
346
+ d: Float64Schema;
347
+ normalization_factor: Float64Schema;
348
+ }>;
349
+ run_pid_gains: import("typed-binary").ObjectSchema<{
350
+ p: Float64Schema;
351
+ i: Float64Schema;
352
+ d: Float64Schema;
353
+ normalization_factor: Float64Schema;
354
+ }>;
355
+ minimum_position: Float64Schema;
356
+ maximum_position: Float64Schema;
357
+ valve_encoder_offset: Float64Schema;
358
+ can_watchdog_timeout: UInt64Schema;
359
+ end_pressure_ref: Float64Schema;
360
+ pressurizing_time: Float64Schema;
361
+ gear_ratio: import("typed-binary").Float32Schema;
362
+ max_torque: Float64Schema;
363
+ dvdt_nominal: Float64Schema;
364
+ cv_max: Float64Schema;
365
+ control_valve_curve: import("typed-binary").ObjectSchema<{
366
+ a: Float64Schema;
367
+ b: Float64Schema;
368
+ }>;
369
+ main_valve_curve: import("typed-binary").ObjectSchema<{
370
+ a: Float64Schema;
371
+ b: Float64Schema;
372
+ }>;
373
+ }>;
374
+ export type actuators_bldc_ControllerConfig = bin.Parsed<typeof actuators_bldc_ControllerConfig>;
375
+ export declare const BldcConfigTelmetryPacket: import("typed-binary").ObjectSchema<{
376
+ bldc_id: import("typed-binary").ByteSchema;
377
+ config: import("typed-binary").ObjectSchema<{
378
+ pressurize_pid_gains: import("typed-binary").ObjectSchema<{
379
+ p: Float64Schema;
380
+ i: Float64Schema;
381
+ d: Float64Schema;
382
+ normalization_factor: Float64Schema;
383
+ }>;
384
+ run_pid_gains: import("typed-binary").ObjectSchema<{
385
+ p: Float64Schema;
386
+ i: Float64Schema;
387
+ d: Float64Schema;
388
+ normalization_factor: Float64Schema;
389
+ }>;
390
+ minimum_position: Float64Schema;
391
+ maximum_position: Float64Schema;
392
+ valve_encoder_offset: Float64Schema;
393
+ can_watchdog_timeout: UInt64Schema;
394
+ end_pressure_ref: Float64Schema;
395
+ pressurizing_time: Float64Schema;
396
+ gear_ratio: import("typed-binary").Float32Schema;
397
+ max_torque: Float64Schema;
398
+ dvdt_nominal: Float64Schema;
399
+ cv_max: Float64Schema;
400
+ control_valve_curve: import("typed-binary").ObjectSchema<{
401
+ a: Float64Schema;
402
+ b: Float64Schema;
403
+ }>;
404
+ main_valve_curve: import("typed-binary").ObjectSchema<{
405
+ a: Float64Schema;
406
+ b: Float64Schema;
407
+ }>;
408
+ }>;
409
+ }>;
410
+ export type BldcConfigTelmetryPacket = bin.Parsed<typeof BldcConfigTelmetryPacket>;
411
+ export declare const BatteryMonitorTelemetryPacket: import("typed-binary").ObjectSchema<{
412
+ timestamp_ms: import("typed-binary").Uint32Schema;
413
+ voltages: import("typed-binary").ArraySchema<import("typed-binary").Float32Schema>;
414
+ }>;
415
+ export type BatteryMonitorTelemetryPacket = bin.Parsed<typeof BatteryMonitorTelemetryPacket>;
193
416
  export declare const spec: {
194
- actuators_servo_ServoStatus: {
417
+ HeartBeatTelemetry: {
418
+ port: number;
419
+ schema: import("typed-binary").ObjectSchema<{
420
+ message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
421
+ status_flags: import("typed-binary").ByteSchema;
422
+ }>;
423
+ enums: {};
424
+ };
425
+ BldcTelemetryPacket: {
195
426
  port: number;
427
+ fragment: string;
196
428
  schema: import("typed-binary").ObjectSchema<{
197
- commanded_angle_deg: import("typed-binary").Float32Schema;
198
- target_angle_deg: import("typed-binary").Float32Schema;
199
- measured_angle_deg: import("typed-binary").Float32Schema;
200
- current_ma: import("typed-binary").Float32Schema;
201
- mode: import("typed-binary").ByteSchema;
202
- power_state: import("typed-binary").ByteSchema;
429
+ bldc_id: import("typed-binary").ByteSchema;
430
+ fsm_state: import("typed-binary").ByteSchema;
431
+ telemetry: import("typed-binary").ObjectSchema<{
432
+ valve_position: import("typed-binary").Float32Schema;
433
+ motor_position: import("typed-binary").Float32Schema;
434
+ current_draw: import("typed-binary").Float32Schema;
435
+ u_p: import("typed-binary").Float32Schema;
436
+ u_i: import("typed-binary").Float32Schema;
437
+ u_d: import("typed-binary").Float32Schema;
438
+ u_total: import("typed-binary").Float32Schema;
439
+ u_raw: import("typed-binary").Float32Schema;
440
+ status_flags: import("typed-binary").ByteSchema;
441
+ }>;
203
442
  }>;
204
443
  enums: {
205
- mode: {
206
- readonly kUnknown: 0;
207
- readonly kPosition: 1;
208
- readonly kCalibrate: 2;
444
+ bldc_id: {
445
+ readonly Fuel: 0;
446
+ readonly Ox: 1;
447
+ readonly Count: 2;
209
448
  };
210
- power_state: {
211
- readonly kUnknown: 0;
212
- readonly kOff: 1;
213
- readonly kBooting: 2;
214
- readonly kOn: 3;
449
+ fsm_state: {
450
+ readonly Safe: 0;
451
+ readonly N2Fill: 1;
452
+ readonly PostN2Fill: 2;
453
+ readonly OxFill: 3;
454
+ readonly PostOxFill: 4;
455
+ readonly QDDisconnect: 5;
456
+ readonly Pressurized: 6;
457
+ readonly Armed: 7;
458
+ readonly Burn: 8;
459
+ readonly Shutdown: 9;
460
+ readonly PostShutdown: 10;
461
+ readonly Purge: 11;
462
+ readonly Hold: 12;
215
463
  };
464
+ telemetry: {};
216
465
  };
217
466
  };
218
- BldcTelemetry: {
467
+ FsmStatusPacket: {
219
468
  port: number;
220
469
  schema: import("typed-binary").ObjectSchema<{
221
- valve_position: import("typed-binary").Float32Schema;
222
- motor_position: import("typed-binary").Float32Schema;
223
- timestamp: UInt64Schema;
224
- current_draw: import("typed-binary").Float32Schema;
225
- u_p: import("typed-binary").Float32Schema;
226
- u_i: import("typed-binary").Float32Schema;
227
- u_d: import("typed-binary").Float32Schema;
228
- u_pid: import("typed-binary").Float32Schema;
229
- u_ff: import("typed-binary").Float32Schema;
230
- u_set: import("typed-binary").Float32Schema;
231
- u_total: import("typed-binary").Float32Schema;
232
- position_raw: import("typed-binary").Float32Schema;
233
- calibrated: import("typed-binary").ByteSchema;
470
+ status: import("typed-binary").ObjectSchema<{
471
+ state_entry_time_ms: UInt64Schema;
472
+ state_time_ms: UInt64Schema;
473
+ current_state: import("typed-binary").ByteSchema;
474
+ previous_state: import("typed-binary").ByteSchema;
475
+ last_event: import("typed-binary").ByteSchema;
476
+ last_abort_reason: import("typed-binary").ByteSchema;
477
+ }>;
478
+ timestamp_ms: import("typed-binary").Uint32Schema;
234
479
  }>;
235
- enums: {};
480
+ enums: {
481
+ status: {
482
+ current_state: {
483
+ readonly Safe: 0;
484
+ readonly N2Fill: 1;
485
+ readonly PostN2Fill: 2;
486
+ readonly OxFill: 3;
487
+ readonly PostOxFill: 4;
488
+ readonly QDDisconnect: 5;
489
+ readonly Pressurized: 6;
490
+ readonly Armed: 7;
491
+ readonly Burn: 8;
492
+ readonly Shutdown: 9;
493
+ readonly PostShutdown: 10;
494
+ readonly Purge: 11;
495
+ readonly Hold: 12;
496
+ };
497
+ previous_state: {
498
+ readonly Safe: 0;
499
+ readonly N2Fill: 1;
500
+ readonly PostN2Fill: 2;
501
+ readonly OxFill: 3;
502
+ readonly PostOxFill: 4;
503
+ readonly QDDisconnect: 5;
504
+ readonly Pressurized: 6;
505
+ readonly Armed: 7;
506
+ readonly Burn: 8;
507
+ readonly Shutdown: 9;
508
+ readonly PostShutdown: 10;
509
+ readonly Purge: 11;
510
+ readonly Hold: 12;
511
+ };
512
+ last_event: {
513
+ readonly Boot: 0;
514
+ readonly NextState: 1;
515
+ readonly PreviousState: 2;
516
+ readonly Timeout: 3;
517
+ readonly CalibrateRequest: 4;
518
+ readonly BurnwireCut: 5;
519
+ readonly Abort: 6;
520
+ readonly None: 7;
521
+ readonly Count: 8;
522
+ };
523
+ last_abort_reason: {
524
+ readonly None: 0;
525
+ readonly Manual: 1;
526
+ readonly FuelTankOverpressure: 2;
527
+ readonly OxTankOverpressure: 3;
528
+ readonly ChamberUnderpressure: 4;
529
+ };
530
+ };
531
+ };
236
532
  };
237
- actuators_solenoid_SolenoidStatus: {
533
+ PressureSensorPacket: {
238
534
  port: number;
535
+ fragment: string;
239
536
  schema: import("typed-binary").ObjectSchema<{
240
- power_state: import("typed-binary").ByteSchema;
241
- opening: import("typed-binary").ByteSchema;
537
+ sensor_id: import("typed-binary").ByteSchema;
538
+ data: import("typed-binary").ObjectSchema<{
539
+ t0_ms: import("typed-binary").Uint32Schema;
540
+ dt_us: import("typed-binary").Uint16Schema;
541
+ count: import("typed-binary").ByteSchema;
542
+ seq: import("typed-binary").ByteSchema;
543
+ overrun: import("typed-binary").BoolSchema;
544
+ samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
545
+ }>;
242
546
  }>;
243
547
  enums: {
244
- power_state: {
245
- readonly kUnknown: 0;
246
- readonly kOff: 1;
247
- readonly kOn: 2;
248
- };
249
- opening: {
250
- readonly kUnknown: 0;
251
- readonly kClosed: 1;
252
- readonly kOpen: 2;
548
+ sensor_id: {
549
+ readonly N2Tank: 0;
550
+ readonly OxTank: 1;
551
+ readonly OxInjector: 2;
552
+ readonly FuelTank: 3;
553
+ readonly FuelInjector: 4;
554
+ readonly FuelInlet: 5;
555
+ readonly Chamber: 6;
556
+ readonly OxSupply: 7;
557
+ readonly N2_300: 8;
558
+ readonly Count: 9;
253
559
  };
560
+ data: {};
254
561
  };
255
562
  };
256
- HeartBeatTelemetry: {
563
+ ServoStatusPacket: {
564
+ port: number;
565
+ fragment: string;
257
566
  schema: import("typed-binary").ObjectSchema<{
258
- message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
567
+ servo_id: import("typed-binary").ByteSchema;
568
+ timestamp_ms: import("typed-binary").Uint32Schema;
569
+ status: import("typed-binary").ObjectSchema<{
570
+ commanded_angle_deg: import("typed-binary").Float32Schema;
571
+ target_angle_deg: import("typed-binary").Float32Schema;
572
+ measured_angle_deg: import("typed-binary").Float32Schema;
573
+ current_ma: import("typed-binary").Float32Schema;
574
+ mode: import("typed-binary").ByteSchema;
575
+ power_state: import("typed-binary").ByteSchema;
576
+ }>;
259
577
  }>;
260
- enums: {};
578
+ enums: {
579
+ servo_id: {
580
+ readonly MainFuel: 0;
581
+ readonly MainOx: 1;
582
+ readonly OxFill: 2;
583
+ readonly OxBoiloff: 3;
584
+ readonly OxSupply: 4;
585
+ readonly Purge: 5;
586
+ readonly Count: 6;
587
+ };
588
+ status: {
589
+ mode: {
590
+ readonly kUnknown: 0;
591
+ readonly kPosition: 1;
592
+ readonly kCalibrate: 2;
593
+ };
594
+ power_state: {
595
+ readonly kUnknown: 0;
596
+ readonly kOff: 1;
597
+ readonly kBooting: 2;
598
+ readonly kOn: 3;
599
+ };
600
+ };
601
+ };
261
602
  };
262
- RegulatorStatusArrayPacket: {
603
+ SolenoidStatusPacket: {
263
604
  port: number;
605
+ fragment: string;
264
606
  schema: import("typed-binary").ObjectSchema<{
265
- count: import("typed-binary").ByteSchema;
607
+ solenoid_id: import("typed-binary").ByteSchema;
266
608
  timestamp_ms: import("typed-binary").Uint32Schema;
267
- entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
268
- id: import("typed-binary").ByteSchema;
269
- name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
270
- status: import("typed-binary").ObjectSchema<{
271
- operator_enabled: import("typed-binary").BoolSchema;
272
- policy_enabled: import("typed-binary").BoolSchema;
273
- active: import("typed-binary").BoolSchema;
274
- setpoint: import("typed-binary").Float32Schema;
275
- kp: import("typed-binary").Float32Schema;
276
- ki: import("typed-binary").Float32Schema;
277
- kd: import("typed-binary").Float32Schema;
278
- integral: import("typed-binary").Float32Schema;
279
- previous_error: import("typed-binary").Float32Schema;
280
- last_measurement: import("typed-binary").Float32Schema;
281
- last_output: import("typed-binary").Float32Schema;
282
- last_servo_command_: import("typed-binary").Float32Schema;
283
- last_update_ms: import("typed-binary").Uint32Schema;
284
- }>;
285
- }>>;
609
+ status: import("typed-binary").ObjectSchema<{
610
+ power_state: import("typed-binary").ByteSchema;
611
+ opening: import("typed-binary").ByteSchema;
612
+ }>;
286
613
  }>;
287
- enums: {};
614
+ enums: {
615
+ solenoid_id: {
616
+ readonly FuelVent: 0;
617
+ readonly OxVent: 1;
618
+ readonly N2Fill: 2;
619
+ readonly OxHoseBleed: 3;
620
+ readonly N2_300_Supply: 4;
621
+ readonly N2_300_Hose_Bleed: 5;
622
+ readonly QD_1: 6;
623
+ readonly QD_2: 7;
624
+ readonly Count: 8;
625
+ };
626
+ status: {
627
+ power_state: {
628
+ readonly kUnknown: 0;
629
+ readonly kOff: 1;
630
+ readonly kOn: 2;
631
+ };
632
+ opening: {
633
+ readonly kUnknown: 0;
634
+ readonly kClosed: 1;
635
+ readonly kOpen: 2;
636
+ };
637
+ };
638
+ };
288
639
  };
289
- fsm_FsmStatus: {
640
+ RegulatorStatusPacket: {
290
641
  port: number;
642
+ fragment: string;
291
643
  schema: import("typed-binary").ObjectSchema<{
292
- state_entry_time_ms: UInt64Schema;
293
- state_time_ms: UInt64Schema;
294
- current_state: import("typed-binary").ByteSchema;
295
- previous_state: import("typed-binary").ByteSchema;
296
- last_event: import("typed-binary").ByteSchema;
297
- last_abort_reason: import("typed-binary").ByteSchema;
644
+ regulator_id: import("typed-binary").ByteSchema;
645
+ timestamp_ms: import("typed-binary").Uint32Schema;
646
+ status: import("typed-binary").ObjectSchema<{
647
+ operator_enabled: import("typed-binary").BoolSchema;
648
+ policy_enabled: import("typed-binary").BoolSchema;
649
+ active: import("typed-binary").BoolSchema;
650
+ reserved: import("typed-binary").BoolSchema;
651
+ valveSetpoint: import("typed-binary").Float32Schema;
652
+ setpoint: import("typed-binary").Float32Schema;
653
+ kp: import("typed-binary").Float32Schema;
654
+ ki: import("typed-binary").Float32Schema;
655
+ kd: import("typed-binary").Float32Schema;
656
+ integral: import("typed-binary").Float32Schema;
657
+ previous_error: import("typed-binary").Float32Schema;
658
+ last_measurement: import("typed-binary").Float32Schema;
659
+ last_output: import("typed-binary").Float32Schema;
660
+ last_servo_command_: import("typed-binary").Float32Schema;
661
+ last_update_ms: import("typed-binary").Uint32Schema;
662
+ }>;
298
663
  }>;
299
664
  enums: {
300
- current_state: {
301
- readonly Safe: 0;
302
- readonly N2Fill: 1;
303
- readonly PostN2Fill: 2;
304
- readonly OxFill: 3;
305
- readonly PostOxFill: 4;
306
- readonly Prechill: 5;
307
- readonly PostPrechill: 6;
308
- readonly QDDisconnect: 7;
309
- readonly Pressurized: 8;
310
- readonly Armed: 9;
311
- readonly Burn: 10;
312
- readonly Shutdown: 11;
313
- readonly PostShutdown: 12;
314
- readonly Calibrate: 13;
665
+ regulator_id: {
666
+ readonly OxBoiloff: 0;
667
+ readonly Count: 1;
315
668
  };
316
- previous_state: {
317
- readonly Safe: 0;
318
- readonly N2Fill: 1;
319
- readonly PostN2Fill: 2;
320
- readonly OxFill: 3;
321
- readonly PostOxFill: 4;
322
- readonly Prechill: 5;
323
- readonly PostPrechill: 6;
324
- readonly QDDisconnect: 7;
325
- readonly Pressurized: 8;
326
- readonly Armed: 9;
327
- readonly Burn: 10;
328
- readonly Shutdown: 11;
329
- readonly PostShutdown: 12;
330
- readonly Calibrate: 13;
331
- };
332
- last_event: {
333
- readonly Boot: 0;
334
- readonly NextState: 1;
335
- readonly PreviousState: 2;
336
- readonly Timeout: 3;
337
- readonly CalibrateRequest: 4;
338
- readonly BurnwireCut: 5;
339
- readonly Abort: 6;
340
- readonly None: 7;
669
+ status: {};
670
+ };
671
+ };
672
+ ThermocouplePacket: {
673
+ port: number;
674
+ fragment: string;
675
+ schema: import("typed-binary").ObjectSchema<{
676
+ thermocouple_id: import("typed-binary").ByteSchema;
677
+ timestamp_ms: import("typed-binary").Uint32Schema;
678
+ data: import("typed-binary").ObjectSchema<{
679
+ id: import("typed-binary").ByteSchema;
680
+ timestamp_us: UInt64Schema;
681
+ interval_us: import("typed-binary").Float32Schema;
682
+ temperature_c: import("typed-binary").ArraySchema<import("typed-binary").Float32Schema>;
683
+ }>;
684
+ }>;
685
+ enums: {
686
+ thermocouple_id: {
687
+ readonly OxTankBottom: 0;
688
+ readonly OxTankTop: 1;
689
+ readonly FuelTank: 2;
690
+ readonly OxInjector: 3;
691
+ readonly Chamber1: 4;
692
+ readonly FuelInjector: 5;
693
+ readonly Chamber2: 6;
694
+ readonly ExtraNodeOne: 7;
341
695
  readonly Count: 8;
342
696
  };
343
- last_abort_reason: {
344
- readonly None: 0;
345
- readonly FuelTankOverpressure: 1;
346
- readonly OxTankOverpressure: 2;
347
- readonly ChamberUnderpressure: 3;
697
+ data: {
698
+ id: {
699
+ readonly OxTankBottom: 0;
700
+ readonly OxTankTop: 1;
701
+ readonly FuelTank: 2;
702
+ readonly OxInjector: 3;
703
+ readonly Chamber1: 4;
704
+ readonly FuelInjector: 5;
705
+ readonly Chamber2: 6;
706
+ readonly ExtraNodeOne: 7;
707
+ readonly Count: 8;
708
+ };
348
709
  };
349
710
  };
350
711
  };
351
- PressureSensorData: {
712
+ LoadCellPacket: {
352
713
  port: number;
714
+ fragment: string;
353
715
  schema: import("typed-binary").ObjectSchema<{
354
- sensor_id: import("typed-binary").ByteSchema;
716
+ loadcell_id: import("typed-binary").ByteSchema;
355
717
  data: import("typed-binary").ObjectSchema<{
356
718
  t0_ms: import("typed-binary").Uint32Schema;
357
719
  dt_us: import("typed-binary").Uint16Schema;
@@ -362,9 +724,76 @@ export declare const spec: {
362
724
  }>;
363
725
  }>;
364
726
  enums: {
727
+ loadcell_id: {
728
+ readonly LoadCell1: 0;
729
+ readonly LoadCell2: 1;
730
+ readonly LoadCell3: 2;
731
+ readonly Count: 3;
732
+ };
365
733
  data: {};
366
734
  };
367
735
  };
736
+ BldcConfigTelmetryPacket: {
737
+ port: number;
738
+ fragment: string;
739
+ schema: import("typed-binary").ObjectSchema<{
740
+ bldc_id: import("typed-binary").ByteSchema;
741
+ config: import("typed-binary").ObjectSchema<{
742
+ pressurize_pid_gains: import("typed-binary").ObjectSchema<{
743
+ p: Float64Schema;
744
+ i: Float64Schema;
745
+ d: Float64Schema;
746
+ normalization_factor: Float64Schema;
747
+ }>;
748
+ run_pid_gains: import("typed-binary").ObjectSchema<{
749
+ p: Float64Schema;
750
+ i: Float64Schema;
751
+ d: Float64Schema;
752
+ normalization_factor: Float64Schema;
753
+ }>;
754
+ minimum_position: Float64Schema;
755
+ maximum_position: Float64Schema;
756
+ valve_encoder_offset: Float64Schema;
757
+ can_watchdog_timeout: UInt64Schema;
758
+ end_pressure_ref: Float64Schema;
759
+ pressurizing_time: Float64Schema;
760
+ gear_ratio: import("typed-binary").Float32Schema;
761
+ max_torque: Float64Schema;
762
+ dvdt_nominal: Float64Schema;
763
+ cv_max: Float64Schema;
764
+ control_valve_curve: import("typed-binary").ObjectSchema<{
765
+ a: Float64Schema;
766
+ b: Float64Schema;
767
+ }>;
768
+ main_valve_curve: import("typed-binary").ObjectSchema<{
769
+ a: Float64Schema;
770
+ b: Float64Schema;
771
+ }>;
772
+ }>;
773
+ }>;
774
+ enums: {
775
+ bldc_id: {
776
+ readonly LoadCell1: 0;
777
+ readonly LoadCell2: 1;
778
+ readonly LoadCell3: 2;
779
+ readonly Count: 3;
780
+ };
781
+ config: {
782
+ pressurize_pid_gains: {};
783
+ run_pid_gains: {};
784
+ control_valve_curve: {};
785
+ main_valve_curve: {};
786
+ };
787
+ };
788
+ };
789
+ BatteryMonitorTelemetryPacket: {
790
+ port: number;
791
+ schema: import("typed-binary").ObjectSchema<{
792
+ timestamp_ms: import("typed-binary").Uint32Schema;
793
+ voltages: import("typed-binary").ArraySchema<import("typed-binary").Float32Schema>;
794
+ }>;
795
+ enums: {};
796
+ };
368
797
  };
369
798
  export default spec;
370
799
  export type Spec = typeof spec;