fossekall-interface 0.1.23 → 0.1.24
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.
|
@@ -1,13 +1,25 @@
|
|
|
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;
|
|
5
16
|
readonly PreviousState: 2;
|
|
6
17
|
readonly Timeout: 3;
|
|
7
18
|
readonly CalibrateRequest: 4;
|
|
8
|
-
readonly
|
|
9
|
-
readonly
|
|
10
|
-
readonly
|
|
19
|
+
readonly BurnwireCut: 5;
|
|
20
|
+
readonly Abort: 6;
|
|
21
|
+
readonly None: 7;
|
|
22
|
+
readonly Count: 8;
|
|
11
23
|
};
|
|
12
24
|
export type Event = (typeof Event)[keyof typeof Event];
|
|
13
25
|
export declare const StateId: {
|
|
@@ -51,6 +63,30 @@ export declare const actuators_servo_StartPolicy: {
|
|
|
51
63
|
readonly kNoInterrupt: 1;
|
|
52
64
|
};
|
|
53
65
|
export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
|
|
66
|
+
export declare const node_solenoid_Id: {
|
|
67
|
+
readonly kFuelVent: 0;
|
|
68
|
+
readonly kOxVent: 1;
|
|
69
|
+
readonly kN2Fill: 2;
|
|
70
|
+
readonly kOxBleed: 3;
|
|
71
|
+
readonly kN2_200_Supply: 4;
|
|
72
|
+
readonly kN2_200_Bleed: 5;
|
|
73
|
+
readonly kN2_300_Supply: 6;
|
|
74
|
+
readonly kN2_300_Bleed: 7;
|
|
75
|
+
readonly kQD_1: 8;
|
|
76
|
+
readonly kQD_2: 9;
|
|
77
|
+
readonly kCount: 10;
|
|
78
|
+
};
|
|
79
|
+
export type node_solenoid_Id = (typeof node_solenoid_Id)[keyof typeof node_solenoid_Id];
|
|
80
|
+
export declare const SolenoidCommands_SetSolenoidCommand: {
|
|
81
|
+
readonly open: 0;
|
|
82
|
+
readonly close: 1;
|
|
83
|
+
};
|
|
84
|
+
export type SolenoidCommands_SetSolenoidCommand = (typeof SolenoidCommands_SetSolenoidCommand)[keyof typeof SolenoidCommands_SetSolenoidCommand];
|
|
85
|
+
export declare const ControlPolicyCommands_PolicyValue: {
|
|
86
|
+
readonly Disable: 0;
|
|
87
|
+
readonly Enable: 1;
|
|
88
|
+
};
|
|
89
|
+
export type ControlPolicyCommands_PolicyValue = (typeof ControlPolicyCommands_PolicyValue)[keyof typeof ControlPolicyCommands_PolicyValue];
|
|
54
90
|
export declare const node_regulator_Id: {
|
|
55
91
|
readonly kOxPrechill: 0;
|
|
56
92
|
readonly kCount: 1;
|
|
@@ -61,6 +97,11 @@ export declare const RegulatorCommands_RegulatorValue: {
|
|
|
61
97
|
readonly Enable: 1;
|
|
62
98
|
};
|
|
63
99
|
export type RegulatorCommands_RegulatorValue = (typeof RegulatorCommands_RegulatorValue)[keyof typeof RegulatorCommands_RegulatorValue];
|
|
100
|
+
export declare const BldcCommands_SetBldcPayload: import("typed-binary").ObjectSchema<{
|
|
101
|
+
bldc_id: import("typed-binary").ByteSchema;
|
|
102
|
+
command: import("typed-binary").Uint32Schema;
|
|
103
|
+
}>;
|
|
104
|
+
export type BldcCommands_SetBldcPayload = bin.Parsed<typeof BldcCommands_SetBldcPayload>;
|
|
64
105
|
export declare const FsmCommands_RaiseEventPayload: import("typed-binary").ObjectSchema<{
|
|
65
106
|
event: import("typed-binary").ByteSchema;
|
|
66
107
|
current_state: import("typed-binary").ByteSchema;
|
|
@@ -84,6 +125,15 @@ export declare const ServoCommands_SetServoPayload: import("typed-binary").Objec
|
|
|
84
125
|
start_policy: import("typed-binary").ByteSchema;
|
|
85
126
|
}>;
|
|
86
127
|
export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
|
|
128
|
+
export declare const SolenoidCommands_SetSolenoidPayload: import("typed-binary").ObjectSchema<{
|
|
129
|
+
solenoid_id: import("typed-binary").ByteSchema;
|
|
130
|
+
command: import("typed-binary").Uint32Schema;
|
|
131
|
+
}>;
|
|
132
|
+
export type SolenoidCommands_SetSolenoidPayload = bin.Parsed<typeof SolenoidCommands_SetSolenoidPayload>;
|
|
133
|
+
export declare const ControlPolicyCommands_SetManualPolicyPayload: import("typed-binary").ObjectSchema<{
|
|
134
|
+
value: import("typed-binary").ByteSchema;
|
|
135
|
+
}>;
|
|
136
|
+
export type ControlPolicyCommands_SetManualPolicyPayload = bin.Parsed<typeof ControlPolicyCommands_SetManualPolicyPayload>;
|
|
87
137
|
export declare const RegulatorCommands_SetEnabledPayload: import("typed-binary").ObjectSchema<{
|
|
88
138
|
regulator_id: import("typed-binary").ByteSchema;
|
|
89
139
|
value: import("typed-binary").ByteSchema;
|
|
@@ -102,6 +152,24 @@ export declare const RegulatorCommands_SetGainsPayload: import("typed-binary").O
|
|
|
102
152
|
}>;
|
|
103
153
|
export type RegulatorCommands_SetGainsPayload = bin.Parsed<typeof RegulatorCommands_SetGainsPayload>;
|
|
104
154
|
export declare const spec: {
|
|
155
|
+
BldcCommands_SetBldcPayload: {
|
|
156
|
+
id: number;
|
|
157
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
158
|
+
bldc_id: import("typed-binary").ByteSchema;
|
|
159
|
+
command: import("typed-binary").Uint32Schema;
|
|
160
|
+
}>;
|
|
161
|
+
enums: {
|
|
162
|
+
bldc_id: {
|
|
163
|
+
readonly kFuel: 0;
|
|
164
|
+
readonly kOx: 1;
|
|
165
|
+
readonly kCount: 2;
|
|
166
|
+
};
|
|
167
|
+
command: {
|
|
168
|
+
readonly open: 0;
|
|
169
|
+
readonly close: 1;
|
|
170
|
+
};
|
|
171
|
+
};
|
|
172
|
+
};
|
|
105
173
|
FsmCommands_RaiseEventPayload: {
|
|
106
174
|
id: number;
|
|
107
175
|
schema: import("typed-binary").ObjectSchema<{
|
|
@@ -115,9 +183,10 @@ export declare const spec: {
|
|
|
115
183
|
readonly PreviousState: 2;
|
|
116
184
|
readonly Timeout: 3;
|
|
117
185
|
readonly CalibrateRequest: 4;
|
|
118
|
-
readonly
|
|
119
|
-
readonly
|
|
120
|
-
readonly
|
|
186
|
+
readonly BurnwireCut: 5;
|
|
187
|
+
readonly Abort: 6;
|
|
188
|
+
readonly None: 7;
|
|
189
|
+
readonly Count: 8;
|
|
121
190
|
};
|
|
122
191
|
current_state: {
|
|
123
192
|
readonly Safe: 0;
|
|
@@ -199,6 +268,44 @@ export declare const spec: {
|
|
|
199
268
|
};
|
|
200
269
|
};
|
|
201
270
|
};
|
|
271
|
+
SolenoidCommands_SetSolenoidPayload: {
|
|
272
|
+
id: number;
|
|
273
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
274
|
+
solenoid_id: import("typed-binary").ByteSchema;
|
|
275
|
+
command: import("typed-binary").Uint32Schema;
|
|
276
|
+
}>;
|
|
277
|
+
enums: {
|
|
278
|
+
solenoid_id: {
|
|
279
|
+
readonly kFuelVent: 0;
|
|
280
|
+
readonly kOxVent: 1;
|
|
281
|
+
readonly kN2Fill: 2;
|
|
282
|
+
readonly kOxBleed: 3;
|
|
283
|
+
readonly kN2_200_Supply: 4;
|
|
284
|
+
readonly kN2_200_Bleed: 5;
|
|
285
|
+
readonly kN2_300_Supply: 6;
|
|
286
|
+
readonly kN2_300_Bleed: 7;
|
|
287
|
+
readonly kQD_1: 8;
|
|
288
|
+
readonly kQD_2: 9;
|
|
289
|
+
readonly kCount: 10;
|
|
290
|
+
};
|
|
291
|
+
command: {
|
|
292
|
+
readonly open: 0;
|
|
293
|
+
readonly close: 1;
|
|
294
|
+
};
|
|
295
|
+
};
|
|
296
|
+
};
|
|
297
|
+
ControlPolicyCommands_SetManualPolicyPayload: {
|
|
298
|
+
id: number;
|
|
299
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
300
|
+
value: import("typed-binary").ByteSchema;
|
|
301
|
+
}>;
|
|
302
|
+
enums: {
|
|
303
|
+
value: {
|
|
304
|
+
readonly Disable: 0;
|
|
305
|
+
readonly Enable: 1;
|
|
306
|
+
};
|
|
307
|
+
};
|
|
308
|
+
};
|
|
202
309
|
RegulatorCommands_SetEnabledPayload: {
|
|
203
310
|
id: number;
|
|
204
311
|
schema: import("typed-binary").ObjectSchema<{
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-03-
|
|
2
|
+
// This file was generated by FRICC on 2026-03-22 14:17:44. 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,15 +60,25 @@ 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,
|
|
66
75
|
PreviousState: 2,
|
|
67
76
|
Timeout: 3,
|
|
68
77
|
CalibrateRequest: 4,
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
78
|
+
BurnwireCut: 5,
|
|
79
|
+
Abort: 6,
|
|
80
|
+
None: 7,
|
|
81
|
+
Count: 8,
|
|
72
82
|
};
|
|
73
83
|
export const StateId = {
|
|
74
84
|
Safe: 0,
|
|
@@ -106,6 +116,27 @@ export const actuators_servo_StartPolicy = {
|
|
|
106
116
|
kPreempt: 0,
|
|
107
117
|
kNoInterrupt: 1,
|
|
108
118
|
};
|
|
119
|
+
export const node_solenoid_Id = {
|
|
120
|
+
kFuelVent: 0,
|
|
121
|
+
kOxVent: 1,
|
|
122
|
+
kN2Fill: 2,
|
|
123
|
+
kOxBleed: 3,
|
|
124
|
+
kN2_200_Supply: 4,
|
|
125
|
+
kN2_200_Bleed: 5,
|
|
126
|
+
kN2_300_Supply: 6,
|
|
127
|
+
kN2_300_Bleed: 7,
|
|
128
|
+
kQD_1: 8,
|
|
129
|
+
kQD_2: 9,
|
|
130
|
+
kCount: 10,
|
|
131
|
+
};
|
|
132
|
+
export const SolenoidCommands_SetSolenoidCommand = {
|
|
133
|
+
open: 0,
|
|
134
|
+
close: 1,
|
|
135
|
+
};
|
|
136
|
+
export const ControlPolicyCommands_PolicyValue = {
|
|
137
|
+
Disable: 0,
|
|
138
|
+
Enable: 1,
|
|
139
|
+
};
|
|
109
140
|
export const node_regulator_Id = {
|
|
110
141
|
kOxPrechill: 0,
|
|
111
142
|
kCount: 1,
|
|
@@ -114,6 +145,10 @@ export const RegulatorCommands_RegulatorValue = {
|
|
|
114
145
|
Disable: 0,
|
|
115
146
|
Enable: 1,
|
|
116
147
|
};
|
|
148
|
+
export const BldcCommands_SetBldcPayload = bin.object({
|
|
149
|
+
bldc_id: bin.u8, // node::bldc::Id
|
|
150
|
+
command: bin.u32, // BldcCommands::SetBldcCommand
|
|
151
|
+
});
|
|
117
152
|
export const FsmCommands_RaiseEventPayload = bin.object({
|
|
118
153
|
event: bin.u8, // Event
|
|
119
154
|
current_state: bin.u8, // StateId
|
|
@@ -134,6 +169,13 @@ export const ServoCommands_SetServoPayload = bin.object({
|
|
|
134
169
|
position_mode: bin.u8, // actuators::servo::PositionMode
|
|
135
170
|
start_policy: bin.u8, // actuators::servo::StartPolicy
|
|
136
171
|
});
|
|
172
|
+
export const SolenoidCommands_SetSolenoidPayload = bin.object({
|
|
173
|
+
solenoid_id: bin.u8, // node::solenoid::Id
|
|
174
|
+
command: bin.u32, // SolenoidCommands::SetSolenoidCommand
|
|
175
|
+
});
|
|
176
|
+
export const ControlPolicyCommands_SetManualPolicyPayload = bin.object({
|
|
177
|
+
value: bin.u8, // ControlPolicyCommands::PolicyValue
|
|
178
|
+
});
|
|
137
179
|
export const RegulatorCommands_SetEnabledPayload = bin.object({
|
|
138
180
|
regulator_id: bin.u8, // node::regulator::Id
|
|
139
181
|
value: bin.u8, // RegulatorCommands::RegulatorValue
|
|
@@ -149,6 +191,14 @@ export const RegulatorCommands_SetGainsPayload = bin.object({
|
|
|
149
191
|
kd: bin.f32, // float
|
|
150
192
|
});
|
|
151
193
|
export const spec = {
|
|
194
|
+
BldcCommands_SetBldcPayload: {
|
|
195
|
+
id: 64,
|
|
196
|
+
schema: BldcCommands_SetBldcPayload,
|
|
197
|
+
enums: {
|
|
198
|
+
bldc_id: node_bldc_Id,
|
|
199
|
+
command: BldcCommands_SetBldcCommand,
|
|
200
|
+
},
|
|
201
|
+
},
|
|
152
202
|
FsmCommands_RaiseEventPayload: {
|
|
153
203
|
id: 32,
|
|
154
204
|
schema: FsmCommands_RaiseEventPayload,
|
|
@@ -176,6 +226,21 @@ export const spec = {
|
|
|
176
226
|
start_policy: actuators_servo_StartPolicy,
|
|
177
227
|
},
|
|
178
228
|
},
|
|
229
|
+
SolenoidCommands_SetSolenoidPayload: {
|
|
230
|
+
id: 80,
|
|
231
|
+
schema: SolenoidCommands_SetSolenoidPayload,
|
|
232
|
+
enums: {
|
|
233
|
+
solenoid_id: node_solenoid_Id,
|
|
234
|
+
command: SolenoidCommands_SetSolenoidCommand,
|
|
235
|
+
},
|
|
236
|
+
},
|
|
237
|
+
ControlPolicyCommands_SetManualPolicyPayload: {
|
|
238
|
+
id: 96,
|
|
239
|
+
schema: ControlPolicyCommands_SetManualPolicyPayload,
|
|
240
|
+
enums: {
|
|
241
|
+
value: ControlPolicyCommands_PolicyValue,
|
|
242
|
+
},
|
|
243
|
+
},
|
|
179
244
|
RegulatorCommands_SetEnabledPayload: {
|
|
180
245
|
id: 112,
|
|
181
246
|
schema: RegulatorCommands_SetEnabledPayload,
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from
|
|
1
|
+
import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
|
|
2
2
|
declare class UInt64Schema extends Schema<bigint> {
|
|
3
3
|
readonly maxSize = 8;
|
|
4
4
|
read(input: ISerialInput): bigint;
|
|
@@ -102,6 +102,66 @@ export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
|
|
|
102
102
|
message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
|
|
103
103
|
}>;
|
|
104
104
|
export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
|
|
105
|
+
export declare const regulators_RegulatorStatus: import("typed-binary").ObjectSchema<{
|
|
106
|
+
operator_enabled: import("typed-binary").BoolSchema;
|
|
107
|
+
policy_enabled: import("typed-binary").BoolSchema;
|
|
108
|
+
active: import("typed-binary").BoolSchema;
|
|
109
|
+
setpoint: import("typed-binary").Float32Schema;
|
|
110
|
+
kp: import("typed-binary").Float32Schema;
|
|
111
|
+
ki: import("typed-binary").Float32Schema;
|
|
112
|
+
kd: import("typed-binary").Float32Schema;
|
|
113
|
+
integral: import("typed-binary").Float32Schema;
|
|
114
|
+
previous_error: import("typed-binary").Float32Schema;
|
|
115
|
+
last_measurement: import("typed-binary").Float32Schema;
|
|
116
|
+
last_output: import("typed-binary").Float32Schema;
|
|
117
|
+
last_servo_command_: import("typed-binary").Float32Schema;
|
|
118
|
+
last_update_ms: import("typed-binary").Uint32Schema;
|
|
119
|
+
}>;
|
|
120
|
+
export type regulators_RegulatorStatus = bin.Parsed<typeof regulators_RegulatorStatus>;
|
|
121
|
+
export declare const RegulatorStatusEntry: import("typed-binary").ObjectSchema<{
|
|
122
|
+
id: import("typed-binary").ByteSchema;
|
|
123
|
+
name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
|
|
124
|
+
status: import("typed-binary").ObjectSchema<{
|
|
125
|
+
operator_enabled: import("typed-binary").BoolSchema;
|
|
126
|
+
policy_enabled: import("typed-binary").BoolSchema;
|
|
127
|
+
active: import("typed-binary").BoolSchema;
|
|
128
|
+
setpoint: import("typed-binary").Float32Schema;
|
|
129
|
+
kp: import("typed-binary").Float32Schema;
|
|
130
|
+
ki: import("typed-binary").Float32Schema;
|
|
131
|
+
kd: import("typed-binary").Float32Schema;
|
|
132
|
+
integral: import("typed-binary").Float32Schema;
|
|
133
|
+
previous_error: import("typed-binary").Float32Schema;
|
|
134
|
+
last_measurement: import("typed-binary").Float32Schema;
|
|
135
|
+
last_output: import("typed-binary").Float32Schema;
|
|
136
|
+
last_servo_command_: import("typed-binary").Float32Schema;
|
|
137
|
+
last_update_ms: import("typed-binary").Uint32Schema;
|
|
138
|
+
}>;
|
|
139
|
+
}>;
|
|
140
|
+
export type RegulatorStatusEntry = bin.Parsed<typeof RegulatorStatusEntry>;
|
|
141
|
+
export declare const RegulatorStatusArrayPacket: import("typed-binary").ObjectSchema<{
|
|
142
|
+
count: import("typed-binary").ByteSchema;
|
|
143
|
+
timestamp_ms: import("typed-binary").Uint32Schema;
|
|
144
|
+
entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
|
|
145
|
+
id: import("typed-binary").ByteSchema;
|
|
146
|
+
name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
|
|
147
|
+
status: import("typed-binary").ObjectSchema<{
|
|
148
|
+
operator_enabled: import("typed-binary").BoolSchema;
|
|
149
|
+
policy_enabled: import("typed-binary").BoolSchema;
|
|
150
|
+
active: import("typed-binary").BoolSchema;
|
|
151
|
+
setpoint: import("typed-binary").Float32Schema;
|
|
152
|
+
kp: import("typed-binary").Float32Schema;
|
|
153
|
+
ki: import("typed-binary").Float32Schema;
|
|
154
|
+
kd: import("typed-binary").Float32Schema;
|
|
155
|
+
integral: import("typed-binary").Float32Schema;
|
|
156
|
+
previous_error: import("typed-binary").Float32Schema;
|
|
157
|
+
last_measurement: import("typed-binary").Float32Schema;
|
|
158
|
+
last_output: import("typed-binary").Float32Schema;
|
|
159
|
+
last_servo_command_: import("typed-binary").Float32Schema;
|
|
160
|
+
last_update_ms: import("typed-binary").Uint32Schema;
|
|
161
|
+
}>;
|
|
162
|
+
}>>;
|
|
163
|
+
}>;
|
|
164
|
+
export type RegulatorStatusArrayPacket = bin.Parsed<typeof RegulatorStatusArrayPacket>;
|
|
105
165
|
export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
|
|
106
166
|
state_entry_time_ms: import("typed-binary").Uint32Schema;
|
|
107
167
|
state_time_ms: import("typed-binary").Uint32Schema;
|
|
@@ -191,6 +251,33 @@ export declare const spec: {
|
|
|
191
251
|
}>;
|
|
192
252
|
enums: {};
|
|
193
253
|
};
|
|
254
|
+
RegulatorStatusArrayPacket: {
|
|
255
|
+
port: number;
|
|
256
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
257
|
+
count: import("typed-binary").ByteSchema;
|
|
258
|
+
timestamp_ms: import("typed-binary").Uint32Schema;
|
|
259
|
+
entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
|
|
260
|
+
id: import("typed-binary").ByteSchema;
|
|
261
|
+
name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
|
|
262
|
+
status: import("typed-binary").ObjectSchema<{
|
|
263
|
+
operator_enabled: import("typed-binary").BoolSchema;
|
|
264
|
+
policy_enabled: import("typed-binary").BoolSchema;
|
|
265
|
+
active: import("typed-binary").BoolSchema;
|
|
266
|
+
setpoint: import("typed-binary").Float32Schema;
|
|
267
|
+
kp: import("typed-binary").Float32Schema;
|
|
268
|
+
ki: import("typed-binary").Float32Schema;
|
|
269
|
+
kd: import("typed-binary").Float32Schema;
|
|
270
|
+
integral: import("typed-binary").Float32Schema;
|
|
271
|
+
previous_error: import("typed-binary").Float32Schema;
|
|
272
|
+
last_measurement: import("typed-binary").Float32Schema;
|
|
273
|
+
last_output: import("typed-binary").Float32Schema;
|
|
274
|
+
last_servo_command_: import("typed-binary").Float32Schema;
|
|
275
|
+
last_update_ms: import("typed-binary").Uint32Schema;
|
|
276
|
+
}>;
|
|
277
|
+
}>>;
|
|
278
|
+
}>;
|
|
279
|
+
enums: {};
|
|
280
|
+
};
|
|
194
281
|
fsm_FsmStatus: {
|
|
195
282
|
port: number;
|
|
196
283
|
schema: import("typed-binary").ObjectSchema<{
|
|
@@ -1,7 +1,7 @@
|
|
|
1
|
-
import bin, { Measurer, Schema
|
|
2
|
-
// This file was generated by FRICC on 2026-03-23
|
|
1
|
+
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
+
// This file was generated by FRICC on 2026-03-23 21:05:05. Do not edit manually!
|
|
3
3
|
// The current version of typed-binary does not support 64-bit primitives.
|
|
4
|
-
// So for we'll implement our own schemas. :)
|
|
4
|
+
// So for we'll implement our own schemas. :)
|
|
5
5
|
const __littleEndian = true;
|
|
6
6
|
class UInt64Schema extends Schema {
|
|
7
7
|
maxSize = 8;
|
|
@@ -146,6 +146,31 @@ export const actuators_solenoid_SolenoidStatus = bin.object({
|
|
|
146
146
|
export const HeartBeatTelemetry = bin.object({
|
|
147
147
|
message: bin.arrayOf(bin.i8, 16), // char[16]
|
|
148
148
|
});
|
|
149
|
+
export const regulators_RegulatorStatus = bin.object({
|
|
150
|
+
operator_enabled: bin.bool, // bool
|
|
151
|
+
policy_enabled: bin.bool, // bool
|
|
152
|
+
active: bin.bool, // bool
|
|
153
|
+
setpoint: bin.f32, // float
|
|
154
|
+
kp: bin.f32, // float
|
|
155
|
+
ki: bin.f32, // float
|
|
156
|
+
kd: bin.f32, // float
|
|
157
|
+
integral: bin.f32, // float
|
|
158
|
+
previous_error: bin.f32, // float
|
|
159
|
+
last_measurement: bin.f32, // float
|
|
160
|
+
last_output: bin.f32, // float
|
|
161
|
+
last_servo_command_: bin.f32, // float
|
|
162
|
+
last_update_ms: bin.u32, // unsigned int
|
|
163
|
+
});
|
|
164
|
+
export const RegulatorStatusEntry = bin.object({
|
|
165
|
+
id: bin.u8, // node::regulator::Id
|
|
166
|
+
name: bin.arrayOf(bin.i8, 24), // char[24]
|
|
167
|
+
status: regulators_RegulatorStatus, // regulators::RegulatorStatus
|
|
168
|
+
});
|
|
169
|
+
export const RegulatorStatusArrayPacket = bin.object({
|
|
170
|
+
count: bin.u8, // unsigned char
|
|
171
|
+
timestamp_ms: bin.u32, // unsigned int
|
|
172
|
+
entries: bin.arrayOf(RegulatorStatusEntry, 1), // RegulatorStatusEntry[1]
|
|
173
|
+
});
|
|
149
174
|
export const fsm_FsmStatus = bin.object({
|
|
150
175
|
state_entry_time_ms: bin.u32, // unsigned int
|
|
151
176
|
state_time_ms: bin.u32, // unsigned int
|
|
@@ -184,6 +209,11 @@ export const spec = {
|
|
|
184
209
|
schema: HeartBeatTelemetry,
|
|
185
210
|
enums: {},
|
|
186
211
|
},
|
|
212
|
+
RegulatorStatusArrayPacket: {
|
|
213
|
+
port: 5005,
|
|
214
|
+
schema: RegulatorStatusArrayPacket,
|
|
215
|
+
enums: {},
|
|
216
|
+
},
|
|
187
217
|
fsm_FsmStatus: {
|
|
188
218
|
port: 5001,
|
|
189
219
|
schema: fsm_FsmStatus,
|