fossekall-interface 0.1.78 → 0.1.79
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.
- package/dist/generated/ecu/commands.d.ts +145 -1
- package/dist/generated/ecu/commands.js +44 -1
- package/dist/generated/ecu/commands.json +186 -0
- package/dist/generated/ecu/telemetry.d.ts +134 -0
- package/dist/generated/ecu/telemetry.js +45 -1
- package/dist/generated/ecu/telemetry.json +187 -0
- package/package.json +1 -1
|
@@ -1,4 +1,16 @@
|
|
|
1
|
-
import bin from 'typed-binary';
|
|
1
|
+
import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
|
|
2
|
+
declare class UInt64Schema extends Schema<bigint> {
|
|
3
|
+
readonly maxSize = 8;
|
|
4
|
+
read(input: ISerialInput): bigint;
|
|
5
|
+
write(output: ISerialOutput, value: bigint): void;
|
|
6
|
+
measure(_: bigint | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
|
|
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
|
+
}
|
|
2
14
|
export declare const node_bldc_Id: {
|
|
3
15
|
readonly Fuel: 0;
|
|
4
16
|
readonly Ox: 1;
|
|
@@ -97,6 +109,87 @@ export declare const BldcCommands_CalibratePayload: import("typed-binary").Objec
|
|
|
97
109
|
id: import("typed-binary").ByteSchema;
|
|
98
110
|
}>;
|
|
99
111
|
export type BldcCommands_CalibratePayload = bin.Parsed<typeof BldcCommands_CalibratePayload>;
|
|
112
|
+
export declare const actuators_bldc_PidGains: import("typed-binary").ObjectSchema<{
|
|
113
|
+
p: Float64Schema;
|
|
114
|
+
i: Float64Schema;
|
|
115
|
+
d: Float64Schema;
|
|
116
|
+
normalization_factor: Float64Schema;
|
|
117
|
+
}>;
|
|
118
|
+
export type actuators_bldc_PidGains = bin.Parsed<typeof actuators_bldc_PidGains>;
|
|
119
|
+
export declare const SigmoidParameters: import("typed-binary").ObjectSchema<{
|
|
120
|
+
a: Float64Schema;
|
|
121
|
+
b: Float64Schema;
|
|
122
|
+
}>;
|
|
123
|
+
export type SigmoidParameters = bin.Parsed<typeof SigmoidParameters>;
|
|
124
|
+
export declare const actuators_bldc_ControllerConfig: import("typed-binary").ObjectSchema<{
|
|
125
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
126
|
+
p: Float64Schema;
|
|
127
|
+
i: Float64Schema;
|
|
128
|
+
d: Float64Schema;
|
|
129
|
+
normalization_factor: Float64Schema;
|
|
130
|
+
}>;
|
|
131
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
132
|
+
p: Float64Schema;
|
|
133
|
+
i: Float64Schema;
|
|
134
|
+
d: Float64Schema;
|
|
135
|
+
normalization_factor: Float64Schema;
|
|
136
|
+
}>;
|
|
137
|
+
minimum_position: Float64Schema;
|
|
138
|
+
maximum_position: Float64Schema;
|
|
139
|
+
valve_encoder_offset: Float64Schema;
|
|
140
|
+
can_watchdog_timeout: UInt64Schema;
|
|
141
|
+
end_pressure_ref: Float64Schema;
|
|
142
|
+
pressurizing_time: Float64Schema;
|
|
143
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
144
|
+
max_torque: Float64Schema;
|
|
145
|
+
dvdt_nominal: Float64Schema;
|
|
146
|
+
cv_max: Float64Schema;
|
|
147
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
148
|
+
a: Float64Schema;
|
|
149
|
+
b: Float64Schema;
|
|
150
|
+
}>;
|
|
151
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
152
|
+
a: Float64Schema;
|
|
153
|
+
b: Float64Schema;
|
|
154
|
+
}>;
|
|
155
|
+
}>;
|
|
156
|
+
export type actuators_bldc_ControllerConfig = bin.Parsed<typeof actuators_bldc_ControllerConfig>;
|
|
157
|
+
export declare const BldcCommands_ConfigureBldcPayload: import("typed-binary").ObjectSchema<{
|
|
158
|
+
id: import("typed-binary").ByteSchema;
|
|
159
|
+
config: import("typed-binary").ObjectSchema<{
|
|
160
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
161
|
+
p: Float64Schema;
|
|
162
|
+
i: Float64Schema;
|
|
163
|
+
d: Float64Schema;
|
|
164
|
+
normalization_factor: Float64Schema;
|
|
165
|
+
}>;
|
|
166
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
167
|
+
p: Float64Schema;
|
|
168
|
+
i: Float64Schema;
|
|
169
|
+
d: Float64Schema;
|
|
170
|
+
normalization_factor: Float64Schema;
|
|
171
|
+
}>;
|
|
172
|
+
minimum_position: Float64Schema;
|
|
173
|
+
maximum_position: Float64Schema;
|
|
174
|
+
valve_encoder_offset: Float64Schema;
|
|
175
|
+
can_watchdog_timeout: UInt64Schema;
|
|
176
|
+
end_pressure_ref: Float64Schema;
|
|
177
|
+
pressurizing_time: Float64Schema;
|
|
178
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
179
|
+
max_torque: Float64Schema;
|
|
180
|
+
dvdt_nominal: Float64Schema;
|
|
181
|
+
cv_max: Float64Schema;
|
|
182
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
183
|
+
a: Float64Schema;
|
|
184
|
+
b: Float64Schema;
|
|
185
|
+
}>;
|
|
186
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
187
|
+
a: Float64Schema;
|
|
188
|
+
b: Float64Schema;
|
|
189
|
+
}>;
|
|
190
|
+
}>;
|
|
191
|
+
}>;
|
|
192
|
+
export type BldcCommands_ConfigureBldcPayload = bin.Parsed<typeof BldcCommands_ConfigureBldcPayload>;
|
|
100
193
|
export declare const FsmCommands_NextStatePayload: import("typed-binary").ObjectSchema<{
|
|
101
194
|
current_state: import("typed-binary").ByteSchema;
|
|
102
195
|
}>;
|
|
@@ -203,6 +296,57 @@ export declare const spec: {
|
|
|
203
296
|
};
|
|
204
297
|
};
|
|
205
298
|
};
|
|
299
|
+
BldcCommands_ConfigureBldcPayload: {
|
|
300
|
+
id: number;
|
|
301
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
302
|
+
id: import("typed-binary").ByteSchema;
|
|
303
|
+
config: import("typed-binary").ObjectSchema<{
|
|
304
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
305
|
+
p: Float64Schema;
|
|
306
|
+
i: Float64Schema;
|
|
307
|
+
d: Float64Schema;
|
|
308
|
+
normalization_factor: Float64Schema;
|
|
309
|
+
}>;
|
|
310
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
311
|
+
p: Float64Schema;
|
|
312
|
+
i: Float64Schema;
|
|
313
|
+
d: Float64Schema;
|
|
314
|
+
normalization_factor: Float64Schema;
|
|
315
|
+
}>;
|
|
316
|
+
minimum_position: Float64Schema;
|
|
317
|
+
maximum_position: Float64Schema;
|
|
318
|
+
valve_encoder_offset: Float64Schema;
|
|
319
|
+
can_watchdog_timeout: UInt64Schema;
|
|
320
|
+
end_pressure_ref: Float64Schema;
|
|
321
|
+
pressurizing_time: Float64Schema;
|
|
322
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
323
|
+
max_torque: Float64Schema;
|
|
324
|
+
dvdt_nominal: Float64Schema;
|
|
325
|
+
cv_max: Float64Schema;
|
|
326
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
327
|
+
a: Float64Schema;
|
|
328
|
+
b: Float64Schema;
|
|
329
|
+
}>;
|
|
330
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
331
|
+
a: Float64Schema;
|
|
332
|
+
b: Float64Schema;
|
|
333
|
+
}>;
|
|
334
|
+
}>;
|
|
335
|
+
}>;
|
|
336
|
+
enums: {
|
|
337
|
+
id: {
|
|
338
|
+
readonly Fuel: 0;
|
|
339
|
+
readonly Ox: 1;
|
|
340
|
+
readonly Count: 2;
|
|
341
|
+
};
|
|
342
|
+
config: {
|
|
343
|
+
pressurize_pid_gains: {};
|
|
344
|
+
run_pid_gains: {};
|
|
345
|
+
control_valve_curve: {};
|
|
346
|
+
main_valve_curve: {};
|
|
347
|
+
};
|
|
348
|
+
};
|
|
349
|
+
};
|
|
206
350
|
FsmCommands_NextStatePayload: {
|
|
207
351
|
id: number;
|
|
208
352
|
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-04-07
|
|
2
|
+
// This file was generated by FRICC on 2026-04-07 12:10:31. 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;
|
|
@@ -143,6 +143,36 @@ export const BldcCommands_SetBldcPayload = bin.object({
|
|
|
143
143
|
export const BldcCommands_CalibratePayload = bin.object({
|
|
144
144
|
id: bin.u8, // node::bldc::Id
|
|
145
145
|
});
|
|
146
|
+
export const actuators_bldc_PidGains = bin.object({
|
|
147
|
+
p: f64, // double
|
|
148
|
+
i: f64, // double
|
|
149
|
+
d: f64, // double
|
|
150
|
+
normalization_factor: f64, // double
|
|
151
|
+
});
|
|
152
|
+
export const SigmoidParameters = bin.object({
|
|
153
|
+
a: f64, // double
|
|
154
|
+
b: f64, // double
|
|
155
|
+
});
|
|
156
|
+
export const actuators_bldc_ControllerConfig = bin.object({
|
|
157
|
+
pressurize_pid_gains: actuators_bldc_PidGains, // actuators::bldc::PidGains
|
|
158
|
+
run_pid_gains: actuators_bldc_PidGains, // actuators::bldc::PidGains
|
|
159
|
+
minimum_position: f64, // double
|
|
160
|
+
maximum_position: f64, // double
|
|
161
|
+
valve_encoder_offset: f64, // double
|
|
162
|
+
can_watchdog_timeout: u64, // unsigned long long
|
|
163
|
+
end_pressure_ref: f64, // double
|
|
164
|
+
pressurizing_time: f64, // double
|
|
165
|
+
gear_ratio: bin.f32, // float
|
|
166
|
+
max_torque: f64, // double
|
|
167
|
+
dvdt_nominal: f64, // double
|
|
168
|
+
cv_max: f64, // double
|
|
169
|
+
control_valve_curve: SigmoidParameters, // SigmoidParameters
|
|
170
|
+
main_valve_curve: SigmoidParameters, // SigmoidParameters
|
|
171
|
+
});
|
|
172
|
+
export const BldcCommands_ConfigureBldcPayload = bin.object({
|
|
173
|
+
id: bin.u8, // node::bldc::Id
|
|
174
|
+
config: actuators_bldc_ControllerConfig, // actuators::bldc::ControllerConfig
|
|
175
|
+
});
|
|
146
176
|
export const FsmCommands_NextStatePayload = bin.object({
|
|
147
177
|
current_state: bin.u8, // StateId
|
|
148
178
|
});
|
|
@@ -215,6 +245,19 @@ export const spec = {
|
|
|
215
245
|
id: node_bldc_Id,
|
|
216
246
|
},
|
|
217
247
|
},
|
|
248
|
+
BldcCommands_ConfigureBldcPayload: {
|
|
249
|
+
id: 67,
|
|
250
|
+
schema: BldcCommands_ConfigureBldcPayload,
|
|
251
|
+
enums: {
|
|
252
|
+
id: node_bldc_Id,
|
|
253
|
+
config: {
|
|
254
|
+
pressurize_pid_gains: {},
|
|
255
|
+
run_pid_gains: {},
|
|
256
|
+
control_valve_curve: {},
|
|
257
|
+
main_valve_curve: {},
|
|
258
|
+
},
|
|
259
|
+
},
|
|
260
|
+
},
|
|
218
261
|
FsmCommands_NextStatePayload: {
|
|
219
262
|
id: 32,
|
|
220
263
|
schema: FsmCommands_NextStatePayload,
|
|
@@ -55,6 +55,192 @@
|
|
|
55
55
|
],
|
|
56
56
|
"format_string": "<B"
|
|
57
57
|
},
|
|
58
|
+
"BldcCommands::ConfigureBldcPayload": {
|
|
59
|
+
"id": 67,
|
|
60
|
+
"kind": "struct",
|
|
61
|
+
"type": "BldcCommands::ConfigureBldcPayload",
|
|
62
|
+
"fields": [
|
|
63
|
+
{
|
|
64
|
+
"name": "id",
|
|
65
|
+
"kind": "enum",
|
|
66
|
+
"type": "node::bldc::Id",
|
|
67
|
+
"format_string": "<B"
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"name": "config",
|
|
71
|
+
"kind": "struct",
|
|
72
|
+
"type": "actuators::bldc::ControllerConfig",
|
|
73
|
+
"fields": [
|
|
74
|
+
{
|
|
75
|
+
"name": "pressurize_pid_gains",
|
|
76
|
+
"kind": "struct",
|
|
77
|
+
"type": "actuators::bldc::PidGains",
|
|
78
|
+
"fields": [
|
|
79
|
+
{
|
|
80
|
+
"name": "p",
|
|
81
|
+
"kind": "primitive",
|
|
82
|
+
"type": "double",
|
|
83
|
+
"format_string": "<d"
|
|
84
|
+
},
|
|
85
|
+
{
|
|
86
|
+
"name": "i",
|
|
87
|
+
"kind": "primitive",
|
|
88
|
+
"type": "double",
|
|
89
|
+
"format_string": "<d"
|
|
90
|
+
},
|
|
91
|
+
{
|
|
92
|
+
"name": "d",
|
|
93
|
+
"kind": "primitive",
|
|
94
|
+
"type": "double",
|
|
95
|
+
"format_string": "<d"
|
|
96
|
+
},
|
|
97
|
+
{
|
|
98
|
+
"name": "normalization_factor",
|
|
99
|
+
"kind": "primitive",
|
|
100
|
+
"type": "double",
|
|
101
|
+
"format_string": "<d"
|
|
102
|
+
}
|
|
103
|
+
],
|
|
104
|
+
"format_string": "<dddd"
|
|
105
|
+
},
|
|
106
|
+
{
|
|
107
|
+
"name": "run_pid_gains",
|
|
108
|
+
"kind": "struct",
|
|
109
|
+
"type": "actuators::bldc::PidGains",
|
|
110
|
+
"fields": [
|
|
111
|
+
{
|
|
112
|
+
"name": "p",
|
|
113
|
+
"kind": "primitive",
|
|
114
|
+
"type": "double",
|
|
115
|
+
"format_string": "<d"
|
|
116
|
+
},
|
|
117
|
+
{
|
|
118
|
+
"name": "i",
|
|
119
|
+
"kind": "primitive",
|
|
120
|
+
"type": "double",
|
|
121
|
+
"format_string": "<d"
|
|
122
|
+
},
|
|
123
|
+
{
|
|
124
|
+
"name": "d",
|
|
125
|
+
"kind": "primitive",
|
|
126
|
+
"type": "double",
|
|
127
|
+
"format_string": "<d"
|
|
128
|
+
},
|
|
129
|
+
{
|
|
130
|
+
"name": "normalization_factor",
|
|
131
|
+
"kind": "primitive",
|
|
132
|
+
"type": "double",
|
|
133
|
+
"format_string": "<d"
|
|
134
|
+
}
|
|
135
|
+
],
|
|
136
|
+
"format_string": "<dddd"
|
|
137
|
+
},
|
|
138
|
+
{
|
|
139
|
+
"name": "minimum_position",
|
|
140
|
+
"kind": "primitive",
|
|
141
|
+
"type": "double",
|
|
142
|
+
"format_string": "<d"
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
"name": "maximum_position",
|
|
146
|
+
"kind": "primitive",
|
|
147
|
+
"type": "double",
|
|
148
|
+
"format_string": "<d"
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
"name": "valve_encoder_offset",
|
|
152
|
+
"kind": "primitive",
|
|
153
|
+
"type": "double",
|
|
154
|
+
"format_string": "<d"
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
"name": "can_watchdog_timeout",
|
|
158
|
+
"kind": "primitive",
|
|
159
|
+
"type": "unsigned long long",
|
|
160
|
+
"format_string": "<Q"
|
|
161
|
+
},
|
|
162
|
+
{
|
|
163
|
+
"name": "end_pressure_ref",
|
|
164
|
+
"kind": "primitive",
|
|
165
|
+
"type": "double",
|
|
166
|
+
"format_string": "<d"
|
|
167
|
+
},
|
|
168
|
+
{
|
|
169
|
+
"name": "pressurizing_time",
|
|
170
|
+
"kind": "primitive",
|
|
171
|
+
"type": "double",
|
|
172
|
+
"format_string": "<d"
|
|
173
|
+
},
|
|
174
|
+
{
|
|
175
|
+
"name": "gear_ratio",
|
|
176
|
+
"kind": "primitive",
|
|
177
|
+
"type": "float",
|
|
178
|
+
"format_string": "<f"
|
|
179
|
+
},
|
|
180
|
+
{
|
|
181
|
+
"name": "max_torque",
|
|
182
|
+
"kind": "primitive",
|
|
183
|
+
"type": "double",
|
|
184
|
+
"format_string": "<d"
|
|
185
|
+
},
|
|
186
|
+
{
|
|
187
|
+
"name": "dvdt_nominal",
|
|
188
|
+
"kind": "primitive",
|
|
189
|
+
"type": "double",
|
|
190
|
+
"format_string": "<d"
|
|
191
|
+
},
|
|
192
|
+
{
|
|
193
|
+
"name": "cv_max",
|
|
194
|
+
"kind": "primitive",
|
|
195
|
+
"type": "double",
|
|
196
|
+
"format_string": "<d"
|
|
197
|
+
},
|
|
198
|
+
{
|
|
199
|
+
"name": "control_valve_curve",
|
|
200
|
+
"kind": "struct",
|
|
201
|
+
"type": "SigmoidParameters",
|
|
202
|
+
"fields": [
|
|
203
|
+
{
|
|
204
|
+
"name": "a",
|
|
205
|
+
"kind": "primitive",
|
|
206
|
+
"type": "double",
|
|
207
|
+
"format_string": "<d"
|
|
208
|
+
},
|
|
209
|
+
{
|
|
210
|
+
"name": "b",
|
|
211
|
+
"kind": "primitive",
|
|
212
|
+
"type": "double",
|
|
213
|
+
"format_string": "<d"
|
|
214
|
+
}
|
|
215
|
+
],
|
|
216
|
+
"format_string": "<dd"
|
|
217
|
+
},
|
|
218
|
+
{
|
|
219
|
+
"name": "main_valve_curve",
|
|
220
|
+
"kind": "struct",
|
|
221
|
+
"type": "SigmoidParameters",
|
|
222
|
+
"fields": [
|
|
223
|
+
{
|
|
224
|
+
"name": "a",
|
|
225
|
+
"kind": "primitive",
|
|
226
|
+
"type": "double",
|
|
227
|
+
"format_string": "<d"
|
|
228
|
+
},
|
|
229
|
+
{
|
|
230
|
+
"name": "b",
|
|
231
|
+
"kind": "primitive",
|
|
232
|
+
"type": "double",
|
|
233
|
+
"format_string": "<d"
|
|
234
|
+
}
|
|
235
|
+
],
|
|
236
|
+
"format_string": "<dd"
|
|
237
|
+
}
|
|
238
|
+
],
|
|
239
|
+
"format_string": "<dddddddddddQddfddddddd"
|
|
240
|
+
}
|
|
241
|
+
],
|
|
242
|
+
"format_string": "<BdddddddddddQddfddddddd"
|
|
243
|
+
},
|
|
58
244
|
"FsmCommands::NextStatePayload": {
|
|
59
245
|
"id": 32,
|
|
60
246
|
"kind": "struct",
|
|
@@ -334,6 +334,87 @@ export declare const LoadCellPacket: import("typed-binary").ObjectSchema<{
|
|
|
334
334
|
}>;
|
|
335
335
|
}>;
|
|
336
336
|
export type LoadCellPacket = bin.Parsed<typeof LoadCellPacket>;
|
|
337
|
+
export declare const actuators_bldc_PidGains: import("typed-binary").ObjectSchema<{
|
|
338
|
+
p: Float64Schema;
|
|
339
|
+
i: Float64Schema;
|
|
340
|
+
d: Float64Schema;
|
|
341
|
+
normalization_factor: Float64Schema;
|
|
342
|
+
}>;
|
|
343
|
+
export type actuators_bldc_PidGains = bin.Parsed<typeof actuators_bldc_PidGains>;
|
|
344
|
+
export declare const SigmoidParameters: import("typed-binary").ObjectSchema<{
|
|
345
|
+
a: Float64Schema;
|
|
346
|
+
b: Float64Schema;
|
|
347
|
+
}>;
|
|
348
|
+
export type SigmoidParameters = bin.Parsed<typeof SigmoidParameters>;
|
|
349
|
+
export declare const actuators_bldc_ControllerConfig: import("typed-binary").ObjectSchema<{
|
|
350
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
351
|
+
p: Float64Schema;
|
|
352
|
+
i: Float64Schema;
|
|
353
|
+
d: Float64Schema;
|
|
354
|
+
normalization_factor: Float64Schema;
|
|
355
|
+
}>;
|
|
356
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
357
|
+
p: Float64Schema;
|
|
358
|
+
i: Float64Schema;
|
|
359
|
+
d: Float64Schema;
|
|
360
|
+
normalization_factor: Float64Schema;
|
|
361
|
+
}>;
|
|
362
|
+
minimum_position: Float64Schema;
|
|
363
|
+
maximum_position: Float64Schema;
|
|
364
|
+
valve_encoder_offset: Float64Schema;
|
|
365
|
+
can_watchdog_timeout: UInt64Schema;
|
|
366
|
+
end_pressure_ref: Float64Schema;
|
|
367
|
+
pressurizing_time: Float64Schema;
|
|
368
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
369
|
+
max_torque: Float64Schema;
|
|
370
|
+
dvdt_nominal: Float64Schema;
|
|
371
|
+
cv_max: Float64Schema;
|
|
372
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
373
|
+
a: Float64Schema;
|
|
374
|
+
b: Float64Schema;
|
|
375
|
+
}>;
|
|
376
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
377
|
+
a: Float64Schema;
|
|
378
|
+
b: Float64Schema;
|
|
379
|
+
}>;
|
|
380
|
+
}>;
|
|
381
|
+
export type actuators_bldc_ControllerConfig = bin.Parsed<typeof actuators_bldc_ControllerConfig>;
|
|
382
|
+
export declare const BldcConfigTelmetryPacket: import("typed-binary").ObjectSchema<{
|
|
383
|
+
bldc_id: import("typed-binary").ByteSchema;
|
|
384
|
+
config: import("typed-binary").ObjectSchema<{
|
|
385
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
386
|
+
p: Float64Schema;
|
|
387
|
+
i: Float64Schema;
|
|
388
|
+
d: Float64Schema;
|
|
389
|
+
normalization_factor: Float64Schema;
|
|
390
|
+
}>;
|
|
391
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
392
|
+
p: Float64Schema;
|
|
393
|
+
i: Float64Schema;
|
|
394
|
+
d: Float64Schema;
|
|
395
|
+
normalization_factor: Float64Schema;
|
|
396
|
+
}>;
|
|
397
|
+
minimum_position: Float64Schema;
|
|
398
|
+
maximum_position: Float64Schema;
|
|
399
|
+
valve_encoder_offset: Float64Schema;
|
|
400
|
+
can_watchdog_timeout: UInt64Schema;
|
|
401
|
+
end_pressure_ref: Float64Schema;
|
|
402
|
+
pressurizing_time: Float64Schema;
|
|
403
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
404
|
+
max_torque: Float64Schema;
|
|
405
|
+
dvdt_nominal: Float64Schema;
|
|
406
|
+
cv_max: Float64Schema;
|
|
407
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
408
|
+
a: Float64Schema;
|
|
409
|
+
b: Float64Schema;
|
|
410
|
+
}>;
|
|
411
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
412
|
+
a: Float64Schema;
|
|
413
|
+
b: Float64Schema;
|
|
414
|
+
}>;
|
|
415
|
+
}>;
|
|
416
|
+
}>;
|
|
417
|
+
export type BldcConfigTelmetryPacket = bin.Parsed<typeof BldcConfigTelmetryPacket>;
|
|
337
418
|
export declare const spec: {
|
|
338
419
|
HeartBeatTelemetry: {
|
|
339
420
|
port: number;
|
|
@@ -655,6 +736,59 @@ export declare const spec: {
|
|
|
655
736
|
data: {};
|
|
656
737
|
};
|
|
657
738
|
};
|
|
739
|
+
BldcConfigTelmetryPacket: {
|
|
740
|
+
port: number;
|
|
741
|
+
fragment: string;
|
|
742
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
743
|
+
bldc_id: import("typed-binary").ByteSchema;
|
|
744
|
+
config: import("typed-binary").ObjectSchema<{
|
|
745
|
+
pressurize_pid_gains: import("typed-binary").ObjectSchema<{
|
|
746
|
+
p: Float64Schema;
|
|
747
|
+
i: Float64Schema;
|
|
748
|
+
d: Float64Schema;
|
|
749
|
+
normalization_factor: Float64Schema;
|
|
750
|
+
}>;
|
|
751
|
+
run_pid_gains: import("typed-binary").ObjectSchema<{
|
|
752
|
+
p: Float64Schema;
|
|
753
|
+
i: Float64Schema;
|
|
754
|
+
d: Float64Schema;
|
|
755
|
+
normalization_factor: Float64Schema;
|
|
756
|
+
}>;
|
|
757
|
+
minimum_position: Float64Schema;
|
|
758
|
+
maximum_position: Float64Schema;
|
|
759
|
+
valve_encoder_offset: Float64Schema;
|
|
760
|
+
can_watchdog_timeout: UInt64Schema;
|
|
761
|
+
end_pressure_ref: Float64Schema;
|
|
762
|
+
pressurizing_time: Float64Schema;
|
|
763
|
+
gear_ratio: import("typed-binary").Float32Schema;
|
|
764
|
+
max_torque: Float64Schema;
|
|
765
|
+
dvdt_nominal: Float64Schema;
|
|
766
|
+
cv_max: Float64Schema;
|
|
767
|
+
control_valve_curve: import("typed-binary").ObjectSchema<{
|
|
768
|
+
a: Float64Schema;
|
|
769
|
+
b: Float64Schema;
|
|
770
|
+
}>;
|
|
771
|
+
main_valve_curve: import("typed-binary").ObjectSchema<{
|
|
772
|
+
a: Float64Schema;
|
|
773
|
+
b: Float64Schema;
|
|
774
|
+
}>;
|
|
775
|
+
}>;
|
|
776
|
+
}>;
|
|
777
|
+
enums: {
|
|
778
|
+
bldc_id: {
|
|
779
|
+
readonly LoadCell1: 0;
|
|
780
|
+
readonly LoadCell2: 1;
|
|
781
|
+
readonly LoadCell3: 2;
|
|
782
|
+
readonly Count: 3;
|
|
783
|
+
};
|
|
784
|
+
config: {
|
|
785
|
+
pressurize_pid_gains: {};
|
|
786
|
+
run_pid_gains: {};
|
|
787
|
+
control_valve_curve: {};
|
|
788
|
+
main_valve_curve: {};
|
|
789
|
+
};
|
|
790
|
+
};
|
|
791
|
+
};
|
|
658
792
|
};
|
|
659
793
|
export default spec;
|
|
660
794
|
export type Spec = typeof spec;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-04-07
|
|
2
|
+
// This file was generated by FRICC on 2026-04-07 12:10:34. 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;
|
|
@@ -285,6 +285,36 @@ export const LoadCellPacket = bin.object({
|
|
|
285
285
|
loadcell_id: bin.u8, // node::load_cell::Id
|
|
286
286
|
data: sensors_loadcell_LoadCellBatch, // sensors::loadcell::LoadCellBatch
|
|
287
287
|
});
|
|
288
|
+
export const actuators_bldc_PidGains = bin.object({
|
|
289
|
+
p: f64, // double
|
|
290
|
+
i: f64, // double
|
|
291
|
+
d: f64, // double
|
|
292
|
+
normalization_factor: f64, // double
|
|
293
|
+
});
|
|
294
|
+
export const SigmoidParameters = bin.object({
|
|
295
|
+
a: f64, // double
|
|
296
|
+
b: f64, // double
|
|
297
|
+
});
|
|
298
|
+
export const actuators_bldc_ControllerConfig = bin.object({
|
|
299
|
+
pressurize_pid_gains: actuators_bldc_PidGains, // actuators::bldc::PidGains
|
|
300
|
+
run_pid_gains: actuators_bldc_PidGains, // actuators::bldc::PidGains
|
|
301
|
+
minimum_position: f64, // double
|
|
302
|
+
maximum_position: f64, // double
|
|
303
|
+
valve_encoder_offset: f64, // double
|
|
304
|
+
can_watchdog_timeout: u64, // unsigned long long
|
|
305
|
+
end_pressure_ref: f64, // double
|
|
306
|
+
pressurizing_time: f64, // double
|
|
307
|
+
gear_ratio: bin.f32, // float
|
|
308
|
+
max_torque: f64, // double
|
|
309
|
+
dvdt_nominal: f64, // double
|
|
310
|
+
cv_max: f64, // double
|
|
311
|
+
control_valve_curve: SigmoidParameters, // SigmoidParameters
|
|
312
|
+
main_valve_curve: SigmoidParameters, // SigmoidParameters
|
|
313
|
+
});
|
|
314
|
+
export const BldcConfigTelmetryPacket = bin.object({
|
|
315
|
+
bldc_id: bin.u8, // node::load_cell::Id
|
|
316
|
+
config: actuators_bldc_ControllerConfig, // actuators::bldc::ControllerConfig
|
|
317
|
+
});
|
|
288
318
|
export const spec = {
|
|
289
319
|
HeartBeatTelemetry: {
|
|
290
320
|
port: 57005,
|
|
@@ -375,5 +405,19 @@ export const spec = {
|
|
|
375
405
|
data: {},
|
|
376
406
|
},
|
|
377
407
|
},
|
|
408
|
+
BldcConfigTelmetryPacket: {
|
|
409
|
+
port: 5008,
|
|
410
|
+
fragment: 'bldc_id',
|
|
411
|
+
schema: BldcConfigTelmetryPacket,
|
|
412
|
+
enums: {
|
|
413
|
+
bldc_id: node_load_cell_Id,
|
|
414
|
+
config: {
|
|
415
|
+
pressurize_pid_gains: {},
|
|
416
|
+
run_pid_gains: {},
|
|
417
|
+
control_valve_curve: {},
|
|
418
|
+
main_valve_curve: {},
|
|
419
|
+
},
|
|
420
|
+
},
|
|
421
|
+
},
|
|
378
422
|
};
|
|
379
423
|
export default spec;
|
|
@@ -611,6 +611,193 @@
|
|
|
611
611
|
}
|
|
612
612
|
],
|
|
613
613
|
"format_string": "<BIHBB?hhhhhhhhhhhhhhhhhhhh"
|
|
614
|
+
},
|
|
615
|
+
"BldcConfigTelmetryPacket": {
|
|
616
|
+
"port": 5008,
|
|
617
|
+
"fragment": "bldc_id",
|
|
618
|
+
"kind": "struct",
|
|
619
|
+
"type": "BldcConfigTelmetryPacket",
|
|
620
|
+
"fields": [
|
|
621
|
+
{
|
|
622
|
+
"name": "bldc_id",
|
|
623
|
+
"kind": "enum",
|
|
624
|
+
"type": "node::load_cell::Id",
|
|
625
|
+
"format_string": "<B"
|
|
626
|
+
},
|
|
627
|
+
{
|
|
628
|
+
"name": "config",
|
|
629
|
+
"kind": "struct",
|
|
630
|
+
"type": "actuators::bldc::ControllerConfig",
|
|
631
|
+
"fields": [
|
|
632
|
+
{
|
|
633
|
+
"name": "pressurize_pid_gains",
|
|
634
|
+
"kind": "struct",
|
|
635
|
+
"type": "actuators::bldc::PidGains",
|
|
636
|
+
"fields": [
|
|
637
|
+
{
|
|
638
|
+
"name": "p",
|
|
639
|
+
"kind": "primitive",
|
|
640
|
+
"type": "double",
|
|
641
|
+
"format_string": "<d"
|
|
642
|
+
},
|
|
643
|
+
{
|
|
644
|
+
"name": "i",
|
|
645
|
+
"kind": "primitive",
|
|
646
|
+
"type": "double",
|
|
647
|
+
"format_string": "<d"
|
|
648
|
+
},
|
|
649
|
+
{
|
|
650
|
+
"name": "d",
|
|
651
|
+
"kind": "primitive",
|
|
652
|
+
"type": "double",
|
|
653
|
+
"format_string": "<d"
|
|
654
|
+
},
|
|
655
|
+
{
|
|
656
|
+
"name": "normalization_factor",
|
|
657
|
+
"kind": "primitive",
|
|
658
|
+
"type": "double",
|
|
659
|
+
"format_string": "<d"
|
|
660
|
+
}
|
|
661
|
+
],
|
|
662
|
+
"format_string": "<dddd"
|
|
663
|
+
},
|
|
664
|
+
{
|
|
665
|
+
"name": "run_pid_gains",
|
|
666
|
+
"kind": "struct",
|
|
667
|
+
"type": "actuators::bldc::PidGains",
|
|
668
|
+
"fields": [
|
|
669
|
+
{
|
|
670
|
+
"name": "p",
|
|
671
|
+
"kind": "primitive",
|
|
672
|
+
"type": "double",
|
|
673
|
+
"format_string": "<d"
|
|
674
|
+
},
|
|
675
|
+
{
|
|
676
|
+
"name": "i",
|
|
677
|
+
"kind": "primitive",
|
|
678
|
+
"type": "double",
|
|
679
|
+
"format_string": "<d"
|
|
680
|
+
},
|
|
681
|
+
{
|
|
682
|
+
"name": "d",
|
|
683
|
+
"kind": "primitive",
|
|
684
|
+
"type": "double",
|
|
685
|
+
"format_string": "<d"
|
|
686
|
+
},
|
|
687
|
+
{
|
|
688
|
+
"name": "normalization_factor",
|
|
689
|
+
"kind": "primitive",
|
|
690
|
+
"type": "double",
|
|
691
|
+
"format_string": "<d"
|
|
692
|
+
}
|
|
693
|
+
],
|
|
694
|
+
"format_string": "<dddd"
|
|
695
|
+
},
|
|
696
|
+
{
|
|
697
|
+
"name": "minimum_position",
|
|
698
|
+
"kind": "primitive",
|
|
699
|
+
"type": "double",
|
|
700
|
+
"format_string": "<d"
|
|
701
|
+
},
|
|
702
|
+
{
|
|
703
|
+
"name": "maximum_position",
|
|
704
|
+
"kind": "primitive",
|
|
705
|
+
"type": "double",
|
|
706
|
+
"format_string": "<d"
|
|
707
|
+
},
|
|
708
|
+
{
|
|
709
|
+
"name": "valve_encoder_offset",
|
|
710
|
+
"kind": "primitive",
|
|
711
|
+
"type": "double",
|
|
712
|
+
"format_string": "<d"
|
|
713
|
+
},
|
|
714
|
+
{
|
|
715
|
+
"name": "can_watchdog_timeout",
|
|
716
|
+
"kind": "primitive",
|
|
717
|
+
"type": "unsigned long long",
|
|
718
|
+
"format_string": "<Q"
|
|
719
|
+
},
|
|
720
|
+
{
|
|
721
|
+
"name": "end_pressure_ref",
|
|
722
|
+
"kind": "primitive",
|
|
723
|
+
"type": "double",
|
|
724
|
+
"format_string": "<d"
|
|
725
|
+
},
|
|
726
|
+
{
|
|
727
|
+
"name": "pressurizing_time",
|
|
728
|
+
"kind": "primitive",
|
|
729
|
+
"type": "double",
|
|
730
|
+
"format_string": "<d"
|
|
731
|
+
},
|
|
732
|
+
{
|
|
733
|
+
"name": "gear_ratio",
|
|
734
|
+
"kind": "primitive",
|
|
735
|
+
"type": "float",
|
|
736
|
+
"format_string": "<f"
|
|
737
|
+
},
|
|
738
|
+
{
|
|
739
|
+
"name": "max_torque",
|
|
740
|
+
"kind": "primitive",
|
|
741
|
+
"type": "double",
|
|
742
|
+
"format_string": "<d"
|
|
743
|
+
},
|
|
744
|
+
{
|
|
745
|
+
"name": "dvdt_nominal",
|
|
746
|
+
"kind": "primitive",
|
|
747
|
+
"type": "double",
|
|
748
|
+
"format_string": "<d"
|
|
749
|
+
},
|
|
750
|
+
{
|
|
751
|
+
"name": "cv_max",
|
|
752
|
+
"kind": "primitive",
|
|
753
|
+
"type": "double",
|
|
754
|
+
"format_string": "<d"
|
|
755
|
+
},
|
|
756
|
+
{
|
|
757
|
+
"name": "control_valve_curve",
|
|
758
|
+
"kind": "struct",
|
|
759
|
+
"type": "SigmoidParameters",
|
|
760
|
+
"fields": [
|
|
761
|
+
{
|
|
762
|
+
"name": "a",
|
|
763
|
+
"kind": "primitive",
|
|
764
|
+
"type": "double",
|
|
765
|
+
"format_string": "<d"
|
|
766
|
+
},
|
|
767
|
+
{
|
|
768
|
+
"name": "b",
|
|
769
|
+
"kind": "primitive",
|
|
770
|
+
"type": "double",
|
|
771
|
+
"format_string": "<d"
|
|
772
|
+
}
|
|
773
|
+
],
|
|
774
|
+
"format_string": "<dd"
|
|
775
|
+
},
|
|
776
|
+
{
|
|
777
|
+
"name": "main_valve_curve",
|
|
778
|
+
"kind": "struct",
|
|
779
|
+
"type": "SigmoidParameters",
|
|
780
|
+
"fields": [
|
|
781
|
+
{
|
|
782
|
+
"name": "a",
|
|
783
|
+
"kind": "primitive",
|
|
784
|
+
"type": "double",
|
|
785
|
+
"format_string": "<d"
|
|
786
|
+
},
|
|
787
|
+
{
|
|
788
|
+
"name": "b",
|
|
789
|
+
"kind": "primitive",
|
|
790
|
+
"type": "double",
|
|
791
|
+
"format_string": "<d"
|
|
792
|
+
}
|
|
793
|
+
],
|
|
794
|
+
"format_string": "<dd"
|
|
795
|
+
}
|
|
796
|
+
],
|
|
797
|
+
"format_string": "<dddddddddddQddfddddddd"
|
|
798
|
+
}
|
|
799
|
+
],
|
|
800
|
+
"format_string": "<BdddddddddddQddfddddddd"
|
|
614
801
|
}
|
|
615
802
|
},
|
|
616
803
|
"enums": {
|