fossekall-interface 0.1.148 → 0.1.150
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.js +1 -1
- package/dist/generated/ecu/telemetry.js +1 -1
- package/dist/generated/fc/commands.d.ts +33 -1
- package/dist/generated/fc/commands.js +22 -3
- package/dist/generated/fc/commands.json +26 -2
- package/dist/generated/fc/index.d.ts +1 -0
- package/dist/generated/fc/index.js +1 -0
- package/dist/generated/fc/telemetry.d.ts +418 -0
- package/dist/generated/fc/telemetry.js +228 -0
- package/dist/generated/fc/telemetry.json +287 -21
- package/dist/generated/fs/commands.js +1 -1
- package/dist/generated/fs/telemetry.js +1 -1
- package/package.json +1 -1
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-07-
|
|
2
|
+
// This file was generated by FRICC on 2026-07-18 11:21:17. 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;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-07-
|
|
2
|
+
// This file was generated by FRICC on 2026-07-18 11:21:20. 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;
|
|
@@ -1,3 +1,35 @@
|
|
|
1
|
-
|
|
1
|
+
import bin from 'typed-binary';
|
|
2
|
+
export declare const Commands_StateCommands: {
|
|
3
|
+
readonly IDLE: 0;
|
|
4
|
+
readonly OPEN_FILLING: 1;
|
|
5
|
+
readonly OPEN_RECOVERY_FILL: 2;
|
|
6
|
+
readonly EXPECT_LIFTOFF: 3;
|
|
7
|
+
readonly OPEN_FLOTATION_FILL: 4;
|
|
8
|
+
readonly SEPERATION: 5;
|
|
9
|
+
readonly FLOTATION: 6;
|
|
10
|
+
};
|
|
11
|
+
export type Commands_StateCommands = (typeof Commands_StateCommands)[keyof typeof Commands_StateCommands];
|
|
12
|
+
export declare const Commands_FSMStateCommand: import("typed-binary").ObjectSchema<{
|
|
13
|
+
command: import("typed-binary").ByteSchema;
|
|
14
|
+
}>;
|
|
15
|
+
export type Commands_FSMStateCommand = bin.Parsed<typeof Commands_FSMStateCommand>;
|
|
16
|
+
export declare const spec: {
|
|
17
|
+
Commands_FSMStateCommand: {
|
|
18
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
19
|
+
command: import("typed-binary").ByteSchema;
|
|
20
|
+
}>;
|
|
21
|
+
enums: {
|
|
22
|
+
command: {
|
|
23
|
+
readonly IDLE: 0;
|
|
24
|
+
readonly OPEN_FILLING: 1;
|
|
25
|
+
readonly OPEN_RECOVERY_FILL: 2;
|
|
26
|
+
readonly EXPECT_LIFTOFF: 3;
|
|
27
|
+
readonly OPEN_FLOTATION_FILL: 4;
|
|
28
|
+
readonly SEPERATION: 5;
|
|
29
|
+
readonly FLOTATION: 6;
|
|
30
|
+
};
|
|
31
|
+
};
|
|
32
|
+
};
|
|
33
|
+
};
|
|
2
34
|
export default spec;
|
|
3
35
|
export type Spec = typeof spec;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-07-
|
|
1
|
+
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
+
// This file was generated by FRICC on 2026-07-18 16:20:50. 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,5 +60,24 @@ 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
|
|
63
|
+
export const Commands_StateCommands = {
|
|
64
|
+
IDLE: 0,
|
|
65
|
+
OPEN_FILLING: 1,
|
|
66
|
+
OPEN_RECOVERY_FILL: 2,
|
|
67
|
+
EXPECT_LIFTOFF: 3,
|
|
68
|
+
OPEN_FLOTATION_FILL: 4,
|
|
69
|
+
SEPERATION: 5,
|
|
70
|
+
FLOTATION: 6,
|
|
71
|
+
};
|
|
72
|
+
export const Commands_FSMStateCommand = bin.object({
|
|
73
|
+
command: bin.u8, // Commands::StateCommands
|
|
74
|
+
});
|
|
75
|
+
export const spec = {
|
|
76
|
+
Commands_FSMStateCommand: {
|
|
77
|
+
schema: Commands_FSMStateCommand,
|
|
78
|
+
enums: {
|
|
79
|
+
command: Commands_StateCommands,
|
|
80
|
+
},
|
|
81
|
+
},
|
|
82
|
+
};
|
|
64
83
|
export default spec;
|
|
@@ -1,5 +1,29 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 1,
|
|
3
|
-
"structs": {
|
|
4
|
-
|
|
3
|
+
"structs": {
|
|
4
|
+
"Commands::FSMStateCommand": {
|
|
5
|
+
"kind": "struct",
|
|
6
|
+
"type": "Commands::FSMStateCommand",
|
|
7
|
+
"fields": [
|
|
8
|
+
{
|
|
9
|
+
"name": "command",
|
|
10
|
+
"kind": "enum",
|
|
11
|
+
"type": "Commands::StateCommands",
|
|
12
|
+
"format_string": "<B"
|
|
13
|
+
}
|
|
14
|
+
],
|
|
15
|
+
"format_string": "<B"
|
|
16
|
+
}
|
|
17
|
+
},
|
|
18
|
+
"enums": {
|
|
19
|
+
"Commands::StateCommands": {
|
|
20
|
+
"IDLE": 0,
|
|
21
|
+
"OPEN_FILLING": 1,
|
|
22
|
+
"OPEN_RECOVERY_FILL": 2,
|
|
23
|
+
"EXPECT_LIFTOFF": 3,
|
|
24
|
+
"OPEN_FLOTATION_FILL": 4,
|
|
25
|
+
"SEPERATION": 5,
|
|
26
|
+
"FLOTATION": 6
|
|
27
|
+
}
|
|
28
|
+
}
|
|
5
29
|
}
|
|
@@ -0,0 +1,418 @@
|
|
|
1
|
+
import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
|
|
2
|
+
declare class Float64Schema extends Schema<number> {
|
|
3
|
+
readonly maxSize = 8;
|
|
4
|
+
read(input: ISerialInput): number;
|
|
5
|
+
write(output: ISerialOutput, value: number): void;
|
|
6
|
+
measure(_: number | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
|
|
7
|
+
}
|
|
8
|
+
export declare const STATE_NAME: {
|
|
9
|
+
readonly NONE: 0;
|
|
10
|
+
readonly IDLE: 1;
|
|
11
|
+
readonly READY: 2;
|
|
12
|
+
readonly FILLING: 3;
|
|
13
|
+
readonly SEPARATION_FILLING: 4;
|
|
14
|
+
readonly FLOTATION_FILLING: 5;
|
|
15
|
+
readonly THRUSTING: 6;
|
|
16
|
+
readonly COASTING: 7;
|
|
17
|
+
readonly SEPARATION: 8;
|
|
18
|
+
readonly FLOTATION: 9;
|
|
19
|
+
readonly SHUTDOWN: 10;
|
|
20
|
+
readonly TEST_SEPARATION: 11;
|
|
21
|
+
readonly TEST_FLOTATION: 12;
|
|
22
|
+
};
|
|
23
|
+
export type STATE_NAME = (typeof STATE_NAME)[keyof typeof STATE_NAME];
|
|
24
|
+
export declare const Telemetry_GroundStation_GNSS_DATA: import("typed-binary").ObjectSchema<{
|
|
25
|
+
data_valid: import("typed-binary").ByteSchema;
|
|
26
|
+
numSV: import("typed-binary").ByteSchema;
|
|
27
|
+
lat: Float64Schema;
|
|
28
|
+
lon: Float64Schema;
|
|
29
|
+
hMSL: Float64Schema;
|
|
30
|
+
gSpeed: Float64Schema;
|
|
31
|
+
headMot: Float64Schema;
|
|
32
|
+
hAcc: import("typed-binary").Uint32Schema;
|
|
33
|
+
vAcc: import("typed-binary").Uint32Schema;
|
|
34
|
+
velN: import("typed-binary").Int32Schema;
|
|
35
|
+
velE: import("typed-binary").Int32Schema;
|
|
36
|
+
velD: import("typed-binary").Int32Schema;
|
|
37
|
+
}>;
|
|
38
|
+
export type Telemetry_GroundStation_GNSS_DATA = bin.Parsed<typeof Telemetry_GroundStation_GNSS_DATA>;
|
|
39
|
+
export declare const Telemetry_GroundStation_BME280_DATA: import("typed-binary").ObjectSchema<{
|
|
40
|
+
valid: import("typed-binary").ByteSchema;
|
|
41
|
+
temperature: import("typed-binary").Float32Schema;
|
|
42
|
+
pressure: import("typed-binary").Float32Schema;
|
|
43
|
+
humidity: import("typed-binary").Float32Schema;
|
|
44
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
45
|
+
}>;
|
|
46
|
+
export type Telemetry_GroundStation_BME280_DATA = bin.Parsed<typeof Telemetry_GroundStation_BME280_DATA>;
|
|
47
|
+
export declare const Telemetry_GroundStation_MS5611_DATA: import("typed-binary").ObjectSchema<{
|
|
48
|
+
valid: import("typed-binary").ByteSchema;
|
|
49
|
+
temperature: import("typed-binary").Float32Schema;
|
|
50
|
+
pressure: import("typed-binary").Float32Schema;
|
|
51
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
52
|
+
}>;
|
|
53
|
+
export type Telemetry_GroundStation_MS5611_DATA = bin.Parsed<typeof Telemetry_GroundStation_MS5611_DATA>;
|
|
54
|
+
export declare const Telemetry_Shared_GyroData: import("typed-binary").ObjectSchema<{
|
|
55
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
56
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
57
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
58
|
+
}>;
|
|
59
|
+
export type Telemetry_Shared_GyroData = bin.Parsed<typeof Telemetry_Shared_GyroData>;
|
|
60
|
+
export declare const Telemetry_Shared_AccelerationData: import("typed-binary").ObjectSchema<{
|
|
61
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
62
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
63
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
64
|
+
}>;
|
|
65
|
+
export type Telemetry_Shared_AccelerationData = bin.Parsed<typeof Telemetry_Shared_AccelerationData>;
|
|
66
|
+
export declare const Telemetry_Shared_ImuData: import("typed-binary").ObjectSchema<{
|
|
67
|
+
temperature_C: import("typed-binary").Float32Schema;
|
|
68
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
69
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
70
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
71
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
72
|
+
}>;
|
|
73
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
74
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
75
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
76
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
77
|
+
}>;
|
|
78
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
79
|
+
}>;
|
|
80
|
+
export type Telemetry_Shared_ImuData = bin.Parsed<typeof Telemetry_Shared_ImuData>;
|
|
81
|
+
export declare const Mmc5983maVector: import("typed-binary").ObjectSchema<{
|
|
82
|
+
x: import("typed-binary").Float32Schema;
|
|
83
|
+
y: import("typed-binary").Float32Schema;
|
|
84
|
+
z: import("typed-binary").Float32Schema;
|
|
85
|
+
}>;
|
|
86
|
+
export type Mmc5983maVector = bin.Parsed<typeof Mmc5983maVector>;
|
|
87
|
+
export declare const Mmc5983maVectorRaw: import("typed-binary").ObjectSchema<{
|
|
88
|
+
x: import("typed-binary").Uint32Schema;
|
|
89
|
+
y: import("typed-binary").Uint32Schema;
|
|
90
|
+
z: import("typed-binary").Uint32Schema;
|
|
91
|
+
}>;
|
|
92
|
+
export type Mmc5983maVectorRaw = bin.Parsed<typeof Mmc5983maVectorRaw>;
|
|
93
|
+
export declare const Mmc5983maData: import("typed-binary").ObjectSchema<{
|
|
94
|
+
valid: import("typed-binary").BoolSchema;
|
|
95
|
+
magnetic_gauss: import("typed-binary").ObjectSchema<{
|
|
96
|
+
x: import("typed-binary").Float32Schema;
|
|
97
|
+
y: import("typed-binary").Float32Schema;
|
|
98
|
+
z: import("typed-binary").Float32Schema;
|
|
99
|
+
}>;
|
|
100
|
+
raw: import("typed-binary").ObjectSchema<{
|
|
101
|
+
x: import("typed-binary").Uint32Schema;
|
|
102
|
+
y: import("typed-binary").Uint32Schema;
|
|
103
|
+
z: import("typed-binary").Uint32Schema;
|
|
104
|
+
}>;
|
|
105
|
+
temperature_c: import("typed-binary").Float32Schema;
|
|
106
|
+
timestamp_ms: import("typed-binary").Uint32Schema;
|
|
107
|
+
}>;
|
|
108
|
+
export type Mmc5983maData = bin.Parsed<typeof Mmc5983maData>;
|
|
109
|
+
export declare const Telemetry_GroundStation_STIM377H_DATA: import("typed-binary").ObjectSchema<{
|
|
110
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
111
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
112
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
113
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
114
|
+
}>;
|
|
115
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
116
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
117
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
118
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
119
|
+
}>;
|
|
120
|
+
}>;
|
|
121
|
+
export type Telemetry_GroundStation_STIM377H_DATA = bin.Parsed<typeof Telemetry_GroundStation_STIM377H_DATA>;
|
|
122
|
+
export declare const Telemetry_GroundStation_PressureData: import("typed-binary").ObjectSchema<{
|
|
123
|
+
flotation_pressure: import("typed-binary").Float32Schema;
|
|
124
|
+
separation_pressure: import("typed-binary").Float32Schema;
|
|
125
|
+
}>;
|
|
126
|
+
export type Telemetry_GroundStation_PressureData = bin.Parsed<typeof Telemetry_GroundStation_PressureData>;
|
|
127
|
+
export declare const Telemetry_GroundStation_SensorData: import("typed-binary").ObjectSchema<{
|
|
128
|
+
gnss_data: import("typed-binary").ObjectSchema<{
|
|
129
|
+
data_valid: import("typed-binary").ByteSchema;
|
|
130
|
+
numSV: import("typed-binary").ByteSchema;
|
|
131
|
+
lat: Float64Schema;
|
|
132
|
+
lon: Float64Schema;
|
|
133
|
+
hMSL: Float64Schema;
|
|
134
|
+
gSpeed: Float64Schema;
|
|
135
|
+
headMot: Float64Schema;
|
|
136
|
+
hAcc: import("typed-binary").Uint32Schema;
|
|
137
|
+
vAcc: import("typed-binary").Uint32Schema;
|
|
138
|
+
velN: import("typed-binary").Int32Schema;
|
|
139
|
+
velE: import("typed-binary").Int32Schema;
|
|
140
|
+
velD: import("typed-binary").Int32Schema;
|
|
141
|
+
}>;
|
|
142
|
+
bme_data: import("typed-binary").ObjectSchema<{
|
|
143
|
+
valid: import("typed-binary").ByteSchema;
|
|
144
|
+
temperature: import("typed-binary").Float32Schema;
|
|
145
|
+
pressure: import("typed-binary").Float32Schema;
|
|
146
|
+
humidity: import("typed-binary").Float32Schema;
|
|
147
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
148
|
+
}>;
|
|
149
|
+
ms_data: import("typed-binary").ObjectSchema<{
|
|
150
|
+
valid: import("typed-binary").ByteSchema;
|
|
151
|
+
temperature: import("typed-binary").Float32Schema;
|
|
152
|
+
pressure: import("typed-binary").Float32Schema;
|
|
153
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
154
|
+
}>;
|
|
155
|
+
icm_data: import("typed-binary").ObjectSchema<{
|
|
156
|
+
temperature_C: import("typed-binary").Float32Schema;
|
|
157
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
158
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
159
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
160
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
161
|
+
}>;
|
|
162
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
163
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
164
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
165
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
166
|
+
}>;
|
|
167
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
168
|
+
}>;
|
|
169
|
+
mmc_data: import("typed-binary").ObjectSchema<{
|
|
170
|
+
valid: import("typed-binary").BoolSchema;
|
|
171
|
+
magnetic_gauss: import("typed-binary").ObjectSchema<{
|
|
172
|
+
x: import("typed-binary").Float32Schema;
|
|
173
|
+
y: import("typed-binary").Float32Schema;
|
|
174
|
+
z: import("typed-binary").Float32Schema;
|
|
175
|
+
}>;
|
|
176
|
+
raw: import("typed-binary").ObjectSchema<{
|
|
177
|
+
x: import("typed-binary").Uint32Schema;
|
|
178
|
+
y: import("typed-binary").Uint32Schema;
|
|
179
|
+
z: import("typed-binary").Uint32Schema;
|
|
180
|
+
}>;
|
|
181
|
+
temperature_c: import("typed-binary").Float32Schema;
|
|
182
|
+
timestamp_ms: import("typed-binary").Uint32Schema;
|
|
183
|
+
}>;
|
|
184
|
+
stim_data: import("typed-binary").ObjectSchema<{
|
|
185
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
186
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
187
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
188
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
189
|
+
}>;
|
|
190
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
191
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
192
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
193
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
194
|
+
}>;
|
|
195
|
+
}>;
|
|
196
|
+
pressure_data: import("typed-binary").ObjectSchema<{
|
|
197
|
+
flotation_pressure: import("typed-binary").Float32Schema;
|
|
198
|
+
separation_pressure: import("typed-binary").Float32Schema;
|
|
199
|
+
}>;
|
|
200
|
+
}>;
|
|
201
|
+
export type Telemetry_GroundStation_SensorData = bin.Parsed<typeof Telemetry_GroundStation_SensorData>;
|
|
202
|
+
export declare const Telemetry_GroundStation_KalmanData: import("typed-binary").ObjectSchema<{
|
|
203
|
+
altitude: Float64Schema;
|
|
204
|
+
velocity: Float64Schema;
|
|
205
|
+
}>;
|
|
206
|
+
export type Telemetry_GroundStation_KalmanData = bin.Parsed<typeof Telemetry_GroundStation_KalmanData>;
|
|
207
|
+
export declare const Telemetry_GroundStation_ActuatorStatus: import("typed-binary").ObjectSchema<{
|
|
208
|
+
separation_filling_online: import("typed-binary").BoolSchema;
|
|
209
|
+
flotation_filling_online: import("typed-binary").BoolSchema;
|
|
210
|
+
flotation_online: import("typed-binary").BoolSchema;
|
|
211
|
+
separation_servo_online: import("typed-binary").BoolSchema;
|
|
212
|
+
}>;
|
|
213
|
+
export type Telemetry_GroundStation_ActuatorStatus = bin.Parsed<typeof Telemetry_GroundStation_ActuatorStatus>;
|
|
214
|
+
export declare const Telemetry_GroundStation_SensorStatus: import("typed-binary").ObjectSchema<{
|
|
215
|
+
bme_online: import("typed-binary").BoolSchema;
|
|
216
|
+
ms_online: import("typed-binary").BoolSchema;
|
|
217
|
+
gnss_online: import("typed-binary").BoolSchema;
|
|
218
|
+
icm_online: import("typed-binary").BoolSchema;
|
|
219
|
+
mmc_online: import("typed-binary").BoolSchema;
|
|
220
|
+
stim_online: import("typed-binary").BoolSchema;
|
|
221
|
+
pressure_online: import("typed-binary").BoolSchema;
|
|
222
|
+
}>;
|
|
223
|
+
export type Telemetry_GroundStation_SensorStatus = bin.Parsed<typeof Telemetry_GroundStation_SensorStatus>;
|
|
224
|
+
export declare const Telemetry_GroundStation_HardwareStatus: import("typed-binary").ObjectSchema<{
|
|
225
|
+
pcan1_online: import("typed-binary").BoolSchema;
|
|
226
|
+
pcan2_online: import("typed-binary").BoolSchema;
|
|
227
|
+
networking_thread_online: import("typed-binary").BoolSchema;
|
|
228
|
+
cli_thread_online: import("typed-binary").BoolSchema;
|
|
229
|
+
kalman_thread_online: import("typed-binary").BoolSchema;
|
|
230
|
+
sensor_thread_online: import("typed-binary").BoolSchema;
|
|
231
|
+
fsm_thread_online: import("typed-binary").BoolSchema;
|
|
232
|
+
}>;
|
|
233
|
+
export type Telemetry_GroundStation_HardwareStatus = bin.Parsed<typeof Telemetry_GroundStation_HardwareStatus>;
|
|
234
|
+
export declare const Telemetry_GroundStation_SystemStatus: import("typed-binary").ObjectSchema<{
|
|
235
|
+
actuators: import("typed-binary").ObjectSchema<{
|
|
236
|
+
separation_filling_online: import("typed-binary").BoolSchema;
|
|
237
|
+
flotation_filling_online: import("typed-binary").BoolSchema;
|
|
238
|
+
flotation_online: import("typed-binary").BoolSchema;
|
|
239
|
+
separation_servo_online: import("typed-binary").BoolSchema;
|
|
240
|
+
}>;
|
|
241
|
+
sensors: import("typed-binary").ObjectSchema<{
|
|
242
|
+
bme_online: import("typed-binary").BoolSchema;
|
|
243
|
+
ms_online: import("typed-binary").BoolSchema;
|
|
244
|
+
gnss_online: import("typed-binary").BoolSchema;
|
|
245
|
+
icm_online: import("typed-binary").BoolSchema;
|
|
246
|
+
mmc_online: import("typed-binary").BoolSchema;
|
|
247
|
+
stim_online: import("typed-binary").BoolSchema;
|
|
248
|
+
pressure_online: import("typed-binary").BoolSchema;
|
|
249
|
+
}>;
|
|
250
|
+
hardware: import("typed-binary").ObjectSchema<{
|
|
251
|
+
pcan1_online: import("typed-binary").BoolSchema;
|
|
252
|
+
pcan2_online: import("typed-binary").BoolSchema;
|
|
253
|
+
networking_thread_online: import("typed-binary").BoolSchema;
|
|
254
|
+
cli_thread_online: import("typed-binary").BoolSchema;
|
|
255
|
+
kalman_thread_online: import("typed-binary").BoolSchema;
|
|
256
|
+
sensor_thread_online: import("typed-binary").BoolSchema;
|
|
257
|
+
fsm_thread_online: import("typed-binary").BoolSchema;
|
|
258
|
+
}>;
|
|
259
|
+
current_state: import("typed-binary").Uint32Schema;
|
|
260
|
+
}>;
|
|
261
|
+
export type Telemetry_GroundStation_SystemStatus = bin.Parsed<typeof Telemetry_GroundStation_SystemStatus>;
|
|
262
|
+
export declare const spec: {
|
|
263
|
+
Telemetry_GroundStation_SensorData: {
|
|
264
|
+
port: number;
|
|
265
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
266
|
+
gnss_data: import("typed-binary").ObjectSchema<{
|
|
267
|
+
data_valid: import("typed-binary").ByteSchema;
|
|
268
|
+
numSV: import("typed-binary").ByteSchema;
|
|
269
|
+
lat: Float64Schema;
|
|
270
|
+
lon: Float64Schema;
|
|
271
|
+
hMSL: Float64Schema;
|
|
272
|
+
gSpeed: Float64Schema;
|
|
273
|
+
headMot: Float64Schema;
|
|
274
|
+
hAcc: import("typed-binary").Uint32Schema;
|
|
275
|
+
vAcc: import("typed-binary").Uint32Schema;
|
|
276
|
+
velN: import("typed-binary").Int32Schema;
|
|
277
|
+
velE: import("typed-binary").Int32Schema;
|
|
278
|
+
velD: import("typed-binary").Int32Schema;
|
|
279
|
+
}>;
|
|
280
|
+
bme_data: import("typed-binary").ObjectSchema<{
|
|
281
|
+
valid: import("typed-binary").ByteSchema;
|
|
282
|
+
temperature: import("typed-binary").Float32Schema;
|
|
283
|
+
pressure: import("typed-binary").Float32Schema;
|
|
284
|
+
humidity: import("typed-binary").Float32Schema;
|
|
285
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
286
|
+
}>;
|
|
287
|
+
ms_data: import("typed-binary").ObjectSchema<{
|
|
288
|
+
valid: import("typed-binary").ByteSchema;
|
|
289
|
+
temperature: import("typed-binary").Float32Schema;
|
|
290
|
+
pressure: import("typed-binary").Float32Schema;
|
|
291
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
292
|
+
}>;
|
|
293
|
+
icm_data: import("typed-binary").ObjectSchema<{
|
|
294
|
+
temperature_C: import("typed-binary").Float32Schema;
|
|
295
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
296
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
297
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
298
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
299
|
+
}>;
|
|
300
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
301
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
302
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
303
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
304
|
+
}>;
|
|
305
|
+
timestamp: import("typed-binary").Uint32Schema;
|
|
306
|
+
}>;
|
|
307
|
+
mmc_data: import("typed-binary").ObjectSchema<{
|
|
308
|
+
valid: import("typed-binary").BoolSchema;
|
|
309
|
+
magnetic_gauss: import("typed-binary").ObjectSchema<{
|
|
310
|
+
x: import("typed-binary").Float32Schema;
|
|
311
|
+
y: import("typed-binary").Float32Schema;
|
|
312
|
+
z: import("typed-binary").Float32Schema;
|
|
313
|
+
}>;
|
|
314
|
+
raw: import("typed-binary").ObjectSchema<{
|
|
315
|
+
x: import("typed-binary").Uint32Schema;
|
|
316
|
+
y: import("typed-binary").Uint32Schema;
|
|
317
|
+
z: import("typed-binary").Uint32Schema;
|
|
318
|
+
}>;
|
|
319
|
+
temperature_c: import("typed-binary").Float32Schema;
|
|
320
|
+
timestamp_ms: import("typed-binary").Uint32Schema;
|
|
321
|
+
}>;
|
|
322
|
+
stim_data: import("typed-binary").ObjectSchema<{
|
|
323
|
+
acc: import("typed-binary").ObjectSchema<{
|
|
324
|
+
acc_x_m_per_ss: import("typed-binary").Float32Schema;
|
|
325
|
+
acc_y_m_per_ss: import("typed-binary").Float32Schema;
|
|
326
|
+
acc_z_m_per_ss: import("typed-binary").Float32Schema;
|
|
327
|
+
}>;
|
|
328
|
+
gyro: import("typed-binary").ObjectSchema<{
|
|
329
|
+
gyro_x: import("typed-binary").Float32Schema;
|
|
330
|
+
gyro_y: import("typed-binary").Float32Schema;
|
|
331
|
+
gyro_z: import("typed-binary").Float32Schema;
|
|
332
|
+
}>;
|
|
333
|
+
}>;
|
|
334
|
+
pressure_data: import("typed-binary").ObjectSchema<{
|
|
335
|
+
flotation_pressure: import("typed-binary").Float32Schema;
|
|
336
|
+
separation_pressure: import("typed-binary").Float32Schema;
|
|
337
|
+
}>;
|
|
338
|
+
}>;
|
|
339
|
+
enums: {
|
|
340
|
+
gnss_data: {};
|
|
341
|
+
bme_data: {};
|
|
342
|
+
ms_data: {};
|
|
343
|
+
icm_data: {
|
|
344
|
+
gyro: {};
|
|
345
|
+
acc: {};
|
|
346
|
+
};
|
|
347
|
+
mmc_data: {
|
|
348
|
+
magnetic_gauss: {};
|
|
349
|
+
raw: {};
|
|
350
|
+
};
|
|
351
|
+
stim_data: {
|
|
352
|
+
acc: {};
|
|
353
|
+
gyro: {};
|
|
354
|
+
};
|
|
355
|
+
pressure_data: {};
|
|
356
|
+
};
|
|
357
|
+
};
|
|
358
|
+
Telemetry_GroundStation_KalmanData: {
|
|
359
|
+
port: number;
|
|
360
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
361
|
+
altitude: Float64Schema;
|
|
362
|
+
velocity: Float64Schema;
|
|
363
|
+
}>;
|
|
364
|
+
enums: {};
|
|
365
|
+
};
|
|
366
|
+
Telemetry_GroundStation_SystemStatus: {
|
|
367
|
+
port: number;
|
|
368
|
+
schema: import("typed-binary").ObjectSchema<{
|
|
369
|
+
actuators: import("typed-binary").ObjectSchema<{
|
|
370
|
+
separation_filling_online: import("typed-binary").BoolSchema;
|
|
371
|
+
flotation_filling_online: import("typed-binary").BoolSchema;
|
|
372
|
+
flotation_online: import("typed-binary").BoolSchema;
|
|
373
|
+
separation_servo_online: import("typed-binary").BoolSchema;
|
|
374
|
+
}>;
|
|
375
|
+
sensors: import("typed-binary").ObjectSchema<{
|
|
376
|
+
bme_online: import("typed-binary").BoolSchema;
|
|
377
|
+
ms_online: import("typed-binary").BoolSchema;
|
|
378
|
+
gnss_online: import("typed-binary").BoolSchema;
|
|
379
|
+
icm_online: import("typed-binary").BoolSchema;
|
|
380
|
+
mmc_online: import("typed-binary").BoolSchema;
|
|
381
|
+
stim_online: import("typed-binary").BoolSchema;
|
|
382
|
+
pressure_online: import("typed-binary").BoolSchema;
|
|
383
|
+
}>;
|
|
384
|
+
hardware: import("typed-binary").ObjectSchema<{
|
|
385
|
+
pcan1_online: import("typed-binary").BoolSchema;
|
|
386
|
+
pcan2_online: import("typed-binary").BoolSchema;
|
|
387
|
+
networking_thread_online: import("typed-binary").BoolSchema;
|
|
388
|
+
cli_thread_online: import("typed-binary").BoolSchema;
|
|
389
|
+
kalman_thread_online: import("typed-binary").BoolSchema;
|
|
390
|
+
sensor_thread_online: import("typed-binary").BoolSchema;
|
|
391
|
+
fsm_thread_online: import("typed-binary").BoolSchema;
|
|
392
|
+
}>;
|
|
393
|
+
current_state: import("typed-binary").Uint32Schema;
|
|
394
|
+
}>;
|
|
395
|
+
enums: {
|
|
396
|
+
actuators: {};
|
|
397
|
+
sensors: {};
|
|
398
|
+
hardware: {};
|
|
399
|
+
current_state: {
|
|
400
|
+
readonly NONE: 0;
|
|
401
|
+
readonly IDLE: 1;
|
|
402
|
+
readonly READY: 2;
|
|
403
|
+
readonly FILLING: 3;
|
|
404
|
+
readonly SEPARATION_FILLING: 4;
|
|
405
|
+
readonly FLOTATION_FILLING: 5;
|
|
406
|
+
readonly THRUSTING: 6;
|
|
407
|
+
readonly COASTING: 7;
|
|
408
|
+
readonly SEPARATION: 8;
|
|
409
|
+
readonly FLOTATION: 9;
|
|
410
|
+
readonly SHUTDOWN: 10;
|
|
411
|
+
readonly TEST_SEPARATION: 11;
|
|
412
|
+
readonly TEST_FLOTATION: 12;
|
|
413
|
+
};
|
|
414
|
+
};
|
|
415
|
+
};
|
|
416
|
+
};
|
|
417
|
+
export default spec;
|
|
418
|
+
export type Spec = typeof spec;
|
|
@@ -0,0 +1,228 @@
|
|
|
1
|
+
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
+
// This file was generated by FRICC on 2026-07-18 16:20:50. Do not edit manually!
|
|
3
|
+
// The current version of typed-binary does not support 64-bit primitives.
|
|
4
|
+
// So for we'll implement our own schemas. :)
|
|
5
|
+
const __littleEndian = true;
|
|
6
|
+
class UInt64Schema extends Schema {
|
|
7
|
+
maxSize = 8;
|
|
8
|
+
read(input) {
|
|
9
|
+
const bytes = new Uint8Array(8);
|
|
10
|
+
input.readSlice(bytes, 0, 8);
|
|
11
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
12
|
+
return view.getBigUint64(0, __littleEndian);
|
|
13
|
+
}
|
|
14
|
+
write(output, value) {
|
|
15
|
+
const bytes = new Uint8Array(8);
|
|
16
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
17
|
+
view.setBigUint64(0, value, __littleEndian);
|
|
18
|
+
output.writeSlice(bytes);
|
|
19
|
+
}
|
|
20
|
+
measure(_, measurer = new Measurer()) {
|
|
21
|
+
return measurer.add(8);
|
|
22
|
+
}
|
|
23
|
+
}
|
|
24
|
+
class Int64Schema extends Schema {
|
|
25
|
+
maxSize = 8;
|
|
26
|
+
read(input) {
|
|
27
|
+
const bytes = new Uint8Array(8);
|
|
28
|
+
input.readSlice(bytes, 0, 8);
|
|
29
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
30
|
+
return view.getBigInt64(0, __littleEndian);
|
|
31
|
+
}
|
|
32
|
+
write(output, value) {
|
|
33
|
+
const bytes = new Uint8Array(8);
|
|
34
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
35
|
+
view.setBigInt64(0, value, __littleEndian);
|
|
36
|
+
output.writeSlice(bytes);
|
|
37
|
+
}
|
|
38
|
+
measure(_, measurer = new Measurer()) {
|
|
39
|
+
return measurer.add(8);
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
class Float64Schema extends Schema {
|
|
43
|
+
maxSize = 8;
|
|
44
|
+
read(input) {
|
|
45
|
+
const bytes = new Uint8Array(8);
|
|
46
|
+
input.readSlice(bytes, 0, 8);
|
|
47
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
48
|
+
return view.getFloat64(0, __littleEndian);
|
|
49
|
+
}
|
|
50
|
+
write(output, value) {
|
|
51
|
+
const bytes = new Uint8Array(8);
|
|
52
|
+
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
53
|
+
view.setFloat64(0, value, __littleEndian);
|
|
54
|
+
output.writeSlice(bytes);
|
|
55
|
+
}
|
|
56
|
+
measure(_, measurer = new Measurer()) {
|
|
57
|
+
return measurer.add(8);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
const u64 = new UInt64Schema();
|
|
61
|
+
const i64 = new Int64Schema();
|
|
62
|
+
const f64 = new Float64Schema();
|
|
63
|
+
export const STATE_NAME = {
|
|
64
|
+
NONE: 0,
|
|
65
|
+
IDLE: 1,
|
|
66
|
+
READY: 2,
|
|
67
|
+
FILLING: 3,
|
|
68
|
+
SEPARATION_FILLING: 4,
|
|
69
|
+
FLOTATION_FILLING: 5,
|
|
70
|
+
THRUSTING: 6,
|
|
71
|
+
COASTING: 7,
|
|
72
|
+
SEPARATION: 8,
|
|
73
|
+
FLOTATION: 9,
|
|
74
|
+
SHUTDOWN: 10,
|
|
75
|
+
TEST_SEPARATION: 11,
|
|
76
|
+
TEST_FLOTATION: 12,
|
|
77
|
+
};
|
|
78
|
+
export const Telemetry_GroundStation_GNSS_DATA = bin.object({
|
|
79
|
+
data_valid: bin.u8, // unsigned char
|
|
80
|
+
numSV: bin.u8, // unsigned char
|
|
81
|
+
lat: f64, // double
|
|
82
|
+
lon: f64, // double
|
|
83
|
+
hMSL: f64, // double
|
|
84
|
+
gSpeed: f64, // double
|
|
85
|
+
headMot: f64, // double
|
|
86
|
+
hAcc: bin.u32, // unsigned int
|
|
87
|
+
vAcc: bin.u32, // unsigned int
|
|
88
|
+
velN: bin.i32, // int
|
|
89
|
+
velE: bin.i32, // int
|
|
90
|
+
velD: bin.i32, // int
|
|
91
|
+
});
|
|
92
|
+
export const Telemetry_GroundStation_BME280_DATA = bin.object({
|
|
93
|
+
valid: bin.u8, // unsigned char
|
|
94
|
+
temperature: bin.f32, // float
|
|
95
|
+
pressure: bin.f32, // float
|
|
96
|
+
humidity: bin.f32, // float
|
|
97
|
+
timestamp: bin.u32, // unsigned int
|
|
98
|
+
});
|
|
99
|
+
export const Telemetry_GroundStation_MS5611_DATA = bin.object({
|
|
100
|
+
valid: bin.u8, // unsigned char
|
|
101
|
+
temperature: bin.f32, // float
|
|
102
|
+
pressure: bin.f32, // float
|
|
103
|
+
timestamp: bin.u32, // unsigned int
|
|
104
|
+
});
|
|
105
|
+
export const Telemetry_Shared_GyroData = bin.object({
|
|
106
|
+
gyro_x: bin.f32, // float
|
|
107
|
+
gyro_y: bin.f32, // float
|
|
108
|
+
gyro_z: bin.f32, // float
|
|
109
|
+
});
|
|
110
|
+
export const Telemetry_Shared_AccelerationData = bin.object({
|
|
111
|
+
acc_x_m_per_ss: bin.f32, // float
|
|
112
|
+
acc_y_m_per_ss: bin.f32, // float
|
|
113
|
+
acc_z_m_per_ss: bin.f32, // float
|
|
114
|
+
});
|
|
115
|
+
export const Telemetry_Shared_ImuData = bin.object({
|
|
116
|
+
temperature_C: bin.f32, // float
|
|
117
|
+
gyro: Telemetry_Shared_GyroData, // Telemetry::Shared::GyroData
|
|
118
|
+
acc: Telemetry_Shared_AccelerationData, // Telemetry::Shared::AccelerationData
|
|
119
|
+
timestamp: bin.u32, // unsigned long
|
|
120
|
+
});
|
|
121
|
+
export const Mmc5983maVector = bin.object({
|
|
122
|
+
x: bin.f32, // float
|
|
123
|
+
y: bin.f32, // float
|
|
124
|
+
z: bin.f32, // float
|
|
125
|
+
});
|
|
126
|
+
export const Mmc5983maVectorRaw = bin.object({
|
|
127
|
+
x: bin.u32, // unsigned int
|
|
128
|
+
y: bin.u32, // unsigned int
|
|
129
|
+
z: bin.u32, // unsigned int
|
|
130
|
+
});
|
|
131
|
+
export const Mmc5983maData = bin.object({
|
|
132
|
+
valid: bin.bool, // bool
|
|
133
|
+
magnetic_gauss: Mmc5983maVector, // Mmc5983maVector
|
|
134
|
+
raw: Mmc5983maVectorRaw, // Mmc5983maVectorRaw
|
|
135
|
+
temperature_c: bin.f32, // float
|
|
136
|
+
timestamp_ms: bin.u32, // unsigned int
|
|
137
|
+
});
|
|
138
|
+
export const Telemetry_GroundStation_STIM377H_DATA = bin.object({
|
|
139
|
+
acc: Telemetry_Shared_AccelerationData, // Telemetry::Shared::AccelerationData
|
|
140
|
+
gyro: Telemetry_Shared_GyroData, // Telemetry::Shared::GyroData
|
|
141
|
+
});
|
|
142
|
+
export const Telemetry_GroundStation_PressureData = bin.object({
|
|
143
|
+
flotation_pressure: bin.f32, // float
|
|
144
|
+
separation_pressure: bin.f32, // float
|
|
145
|
+
});
|
|
146
|
+
export const Telemetry_GroundStation_SensorData = bin.object({
|
|
147
|
+
gnss_data: Telemetry_GroundStation_GNSS_DATA, // Telemetry::GroundStation::GNSS_DATA
|
|
148
|
+
bme_data: Telemetry_GroundStation_BME280_DATA, // Telemetry::GroundStation::BME280_DATA
|
|
149
|
+
ms_data: Telemetry_GroundStation_MS5611_DATA, // Telemetry::GroundStation::MS5611_DATA
|
|
150
|
+
icm_data: Telemetry_Shared_ImuData, // Telemetry::Shared::ImuData
|
|
151
|
+
mmc_data: Mmc5983maData, // Mmc5983maData
|
|
152
|
+
stim_data: Telemetry_GroundStation_STIM377H_DATA, // Telemetry::GroundStation::STIM377H_DATA
|
|
153
|
+
pressure_data: Telemetry_GroundStation_PressureData, // Telemetry::GroundStation::PressureData
|
|
154
|
+
});
|
|
155
|
+
export const Telemetry_GroundStation_KalmanData = bin.object({
|
|
156
|
+
altitude: f64, // double
|
|
157
|
+
velocity: f64, // double
|
|
158
|
+
});
|
|
159
|
+
export const Telemetry_GroundStation_ActuatorStatus = bin.object({
|
|
160
|
+
separation_filling_online: bin.bool, // bool
|
|
161
|
+
flotation_filling_online: bin.bool, // bool
|
|
162
|
+
flotation_online: bin.bool, // bool
|
|
163
|
+
separation_servo_online: bin.bool, // bool
|
|
164
|
+
});
|
|
165
|
+
export const Telemetry_GroundStation_SensorStatus = bin.object({
|
|
166
|
+
bme_online: bin.bool, // bool
|
|
167
|
+
ms_online: bin.bool, // bool
|
|
168
|
+
gnss_online: bin.bool, // bool
|
|
169
|
+
icm_online: bin.bool, // bool
|
|
170
|
+
mmc_online: bin.bool, // bool
|
|
171
|
+
stim_online: bin.bool, // bool
|
|
172
|
+
pressure_online: bin.bool, // bool
|
|
173
|
+
});
|
|
174
|
+
export const Telemetry_GroundStation_HardwareStatus = bin.object({
|
|
175
|
+
pcan1_online: bin.bool, // bool
|
|
176
|
+
pcan2_online: bin.bool, // bool
|
|
177
|
+
networking_thread_online: bin.bool, // bool
|
|
178
|
+
cli_thread_online: bin.bool, // bool
|
|
179
|
+
kalman_thread_online: bin.bool, // bool
|
|
180
|
+
sensor_thread_online: bin.bool, // bool
|
|
181
|
+
fsm_thread_online: bin.bool, // bool
|
|
182
|
+
});
|
|
183
|
+
export const Telemetry_GroundStation_SystemStatus = bin.object({
|
|
184
|
+
actuators: Telemetry_GroundStation_ActuatorStatus, // Telemetry::GroundStation::ActuatorStatus
|
|
185
|
+
sensors: Telemetry_GroundStation_SensorStatus, // Telemetry::GroundStation::SensorStatus
|
|
186
|
+
hardware: Telemetry_GroundStation_HardwareStatus, // Telemetry::GroundStation::HardwareStatus
|
|
187
|
+
current_state: bin.u32, // STATE_NAME
|
|
188
|
+
});
|
|
189
|
+
export const spec = {
|
|
190
|
+
Telemetry_GroundStation_SensorData: {
|
|
191
|
+
port: 3001,
|
|
192
|
+
schema: Telemetry_GroundStation_SensorData,
|
|
193
|
+
enums: {
|
|
194
|
+
gnss_data: {},
|
|
195
|
+
bme_data: {},
|
|
196
|
+
ms_data: {},
|
|
197
|
+
icm_data: {
|
|
198
|
+
gyro: {},
|
|
199
|
+
acc: {},
|
|
200
|
+
},
|
|
201
|
+
mmc_data: {
|
|
202
|
+
magnetic_gauss: {},
|
|
203
|
+
raw: {},
|
|
204
|
+
},
|
|
205
|
+
stim_data: {
|
|
206
|
+
acc: {},
|
|
207
|
+
gyro: {},
|
|
208
|
+
},
|
|
209
|
+
pressure_data: {},
|
|
210
|
+
},
|
|
211
|
+
},
|
|
212
|
+
Telemetry_GroundStation_KalmanData: {
|
|
213
|
+
port: 3002,
|
|
214
|
+
schema: Telemetry_GroundStation_KalmanData,
|
|
215
|
+
enums: {},
|
|
216
|
+
},
|
|
217
|
+
Telemetry_GroundStation_SystemStatus: {
|
|
218
|
+
port: 3003,
|
|
219
|
+
schema: Telemetry_GroundStation_SystemStatus,
|
|
220
|
+
enums: {
|
|
221
|
+
actuators: {},
|
|
222
|
+
sensors: {},
|
|
223
|
+
hardware: {},
|
|
224
|
+
current_state: STATE_NAME,
|
|
225
|
+
},
|
|
226
|
+
},
|
|
227
|
+
};
|
|
228
|
+
export default spec;
|
|
@@ -1,15 +1,15 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 1,
|
|
3
3
|
"structs": {
|
|
4
|
-
"Telemetry::SensorData": {
|
|
4
|
+
"Telemetry::GroundStation::SensorData": {
|
|
5
5
|
"port": 3001,
|
|
6
6
|
"kind": "struct",
|
|
7
|
-
"type": "Telemetry::SensorData",
|
|
7
|
+
"type": "Telemetry::GroundStation::SensorData",
|
|
8
8
|
"fields": [
|
|
9
9
|
{
|
|
10
10
|
"name": "gnss_data",
|
|
11
11
|
"kind": "struct",
|
|
12
|
-
"type": "Telemetry::GNSS_DATA",
|
|
12
|
+
"type": "Telemetry::GroundStation::GNSS_DATA",
|
|
13
13
|
"fields": [
|
|
14
14
|
{
|
|
15
15
|
"name": "data_valid",
|
|
@@ -89,7 +89,7 @@
|
|
|
89
89
|
{
|
|
90
90
|
"name": "bme_data",
|
|
91
91
|
"kind": "struct",
|
|
92
|
-
"type": "Telemetry::BME280_DATA",
|
|
92
|
+
"type": "Telemetry::GroundStation::BME280_DATA",
|
|
93
93
|
"fields": [
|
|
94
94
|
{
|
|
95
95
|
"name": "valid",
|
|
@@ -127,7 +127,7 @@
|
|
|
127
127
|
{
|
|
128
128
|
"name": "ms_data",
|
|
129
129
|
"kind": "struct",
|
|
130
|
-
"type": "Telemetry::MS5611_DATA",
|
|
130
|
+
"type": "Telemetry::GroundStation::MS5611_DATA",
|
|
131
131
|
"fields": [
|
|
132
132
|
{
|
|
133
133
|
"name": "valid",
|
|
@@ -159,12 +159,44 @@
|
|
|
159
159
|
{
|
|
160
160
|
"name": "icm_data",
|
|
161
161
|
"kind": "struct",
|
|
162
|
-
"type": "Telemetry::
|
|
162
|
+
"type": "Telemetry::Shared::ImuData",
|
|
163
163
|
"fields": [
|
|
164
164
|
{
|
|
165
|
-
"name": "
|
|
165
|
+
"name": "temperature_C",
|
|
166
|
+
"kind": "primitive",
|
|
167
|
+
"type": "float",
|
|
168
|
+
"format_string": "<f"
|
|
169
|
+
},
|
|
170
|
+
{
|
|
171
|
+
"name": "gyro",
|
|
172
|
+
"kind": "struct",
|
|
173
|
+
"type": "Telemetry::Shared::GyroData",
|
|
174
|
+
"fields": [
|
|
175
|
+
{
|
|
176
|
+
"name": "gyro_x",
|
|
177
|
+
"kind": "primitive",
|
|
178
|
+
"type": "float",
|
|
179
|
+
"format_string": "<f"
|
|
180
|
+
},
|
|
181
|
+
{
|
|
182
|
+
"name": "gyro_y",
|
|
183
|
+
"kind": "primitive",
|
|
184
|
+
"type": "float",
|
|
185
|
+
"format_string": "<f"
|
|
186
|
+
},
|
|
187
|
+
{
|
|
188
|
+
"name": "gyro_z",
|
|
189
|
+
"kind": "primitive",
|
|
190
|
+
"type": "float",
|
|
191
|
+
"format_string": "<f"
|
|
192
|
+
}
|
|
193
|
+
],
|
|
194
|
+
"format_string": "<fff"
|
|
195
|
+
},
|
|
196
|
+
{
|
|
197
|
+
"name": "acc",
|
|
166
198
|
"kind": "struct",
|
|
167
|
-
"type": "Telemetry::AccelerationData",
|
|
199
|
+
"type": "Telemetry::Shared::AccelerationData",
|
|
168
200
|
"fields": [
|
|
169
201
|
{
|
|
170
202
|
"name": "acc_x_m_per_ss",
|
|
@@ -188,24 +220,44 @@
|
|
|
188
220
|
"format_string": "<fff"
|
|
189
221
|
},
|
|
190
222
|
{
|
|
191
|
-
"name": "
|
|
223
|
+
"name": "timestamp",
|
|
224
|
+
"kind": "primitive",
|
|
225
|
+
"type": "unsigned long",
|
|
226
|
+
"format_string": "<L"
|
|
227
|
+
}
|
|
228
|
+
],
|
|
229
|
+
"format_string": "<fffffffL"
|
|
230
|
+
},
|
|
231
|
+
{
|
|
232
|
+
"name": "mmc_data",
|
|
233
|
+
"kind": "struct",
|
|
234
|
+
"type": "Mmc5983maData",
|
|
235
|
+
"fields": [
|
|
236
|
+
{
|
|
237
|
+
"name": "valid",
|
|
238
|
+
"kind": "primitive",
|
|
239
|
+
"type": "bool",
|
|
240
|
+
"format_string": "<?"
|
|
241
|
+
},
|
|
242
|
+
{
|
|
243
|
+
"name": "magnetic_gauss",
|
|
192
244
|
"kind": "struct",
|
|
193
|
-
"type": "
|
|
245
|
+
"type": "Mmc5983maVector",
|
|
194
246
|
"fields": [
|
|
195
247
|
{
|
|
196
|
-
"name": "
|
|
248
|
+
"name": "x",
|
|
197
249
|
"kind": "primitive",
|
|
198
250
|
"type": "float",
|
|
199
251
|
"format_string": "<f"
|
|
200
252
|
},
|
|
201
253
|
{
|
|
202
|
-
"name": "
|
|
254
|
+
"name": "y",
|
|
203
255
|
"kind": "primitive",
|
|
204
256
|
"type": "float",
|
|
205
257
|
"format_string": "<f"
|
|
206
258
|
},
|
|
207
259
|
{
|
|
208
|
-
"name": "
|
|
260
|
+
"name": "z",
|
|
209
261
|
"kind": "primitive",
|
|
210
262
|
"type": "float",
|
|
211
263
|
"format_string": "<f"
|
|
@@ -214,23 +266,55 @@
|
|
|
214
266
|
"format_string": "<fff"
|
|
215
267
|
},
|
|
216
268
|
{
|
|
217
|
-
"name": "
|
|
269
|
+
"name": "raw",
|
|
270
|
+
"kind": "struct",
|
|
271
|
+
"type": "Mmc5983maVectorRaw",
|
|
272
|
+
"fields": [
|
|
273
|
+
{
|
|
274
|
+
"name": "x",
|
|
275
|
+
"kind": "primitive",
|
|
276
|
+
"type": "unsigned int",
|
|
277
|
+
"format_string": "<I"
|
|
278
|
+
},
|
|
279
|
+
{
|
|
280
|
+
"name": "y",
|
|
281
|
+
"kind": "primitive",
|
|
282
|
+
"type": "unsigned int",
|
|
283
|
+
"format_string": "<I"
|
|
284
|
+
},
|
|
285
|
+
{
|
|
286
|
+
"name": "z",
|
|
287
|
+
"kind": "primitive",
|
|
288
|
+
"type": "unsigned int",
|
|
289
|
+
"format_string": "<I"
|
|
290
|
+
}
|
|
291
|
+
],
|
|
292
|
+
"format_string": "<III"
|
|
293
|
+
},
|
|
294
|
+
{
|
|
295
|
+
"name": "temperature_c",
|
|
218
296
|
"kind": "primitive",
|
|
219
297
|
"type": "float",
|
|
220
298
|
"format_string": "<f"
|
|
299
|
+
},
|
|
300
|
+
{
|
|
301
|
+
"name": "timestamp_ms",
|
|
302
|
+
"kind": "primitive",
|
|
303
|
+
"type": "unsigned int",
|
|
304
|
+
"format_string": "<I"
|
|
221
305
|
}
|
|
222
306
|
],
|
|
223
|
-
"format_string": "
|
|
307
|
+
"format_string": "<?fffIIIfI"
|
|
224
308
|
},
|
|
225
309
|
{
|
|
226
310
|
"name": "stim_data",
|
|
227
311
|
"kind": "struct",
|
|
228
|
-
"type": "Telemetry::STIM377H_DATA",
|
|
312
|
+
"type": "Telemetry::GroundStation::STIM377H_DATA",
|
|
229
313
|
"fields": [
|
|
230
314
|
{
|
|
231
315
|
"name": "acc",
|
|
232
316
|
"kind": "struct",
|
|
233
|
-
"type": "Telemetry::AccelerationData",
|
|
317
|
+
"type": "Telemetry::Shared::AccelerationData",
|
|
234
318
|
"fields": [
|
|
235
319
|
{
|
|
236
320
|
"name": "acc_x_m_per_ss",
|
|
@@ -256,7 +340,7 @@
|
|
|
256
340
|
{
|
|
257
341
|
"name": "gyro",
|
|
258
342
|
"kind": "struct",
|
|
259
|
-
"type": "Telemetry::GyroData",
|
|
343
|
+
"type": "Telemetry::Shared::GyroData",
|
|
260
344
|
"fields": [
|
|
261
345
|
{
|
|
262
346
|
"name": "gyro_x",
|
|
@@ -285,7 +369,7 @@
|
|
|
285
369
|
{
|
|
286
370
|
"name": "pressure_data",
|
|
287
371
|
"kind": "struct",
|
|
288
|
-
"type": "Telemetry::PressureData",
|
|
372
|
+
"type": "Telemetry::GroundStation::PressureData",
|
|
289
373
|
"fields": [
|
|
290
374
|
{
|
|
291
375
|
"name": "flotation_pressure",
|
|
@@ -303,8 +387,190 @@
|
|
|
303
387
|
"format_string": "<ff"
|
|
304
388
|
}
|
|
305
389
|
],
|
|
306
|
-
"format_string": "<
|
|
390
|
+
"format_string": "<BBdddddIIiiiBfffIBffIfffffffL?fffIIIfIffffffff"
|
|
391
|
+
},
|
|
392
|
+
"Telemetry::GroundStation::KalmanData": {
|
|
393
|
+
"port": 3002,
|
|
394
|
+
"kind": "struct",
|
|
395
|
+
"type": "Telemetry::GroundStation::KalmanData",
|
|
396
|
+
"fields": [
|
|
397
|
+
{
|
|
398
|
+
"name": "altitude",
|
|
399
|
+
"kind": "primitive",
|
|
400
|
+
"type": "double",
|
|
401
|
+
"format_string": "<d"
|
|
402
|
+
},
|
|
403
|
+
{
|
|
404
|
+
"name": "velocity",
|
|
405
|
+
"kind": "primitive",
|
|
406
|
+
"type": "double",
|
|
407
|
+
"format_string": "<d"
|
|
408
|
+
}
|
|
409
|
+
],
|
|
410
|
+
"format_string": "<dd"
|
|
411
|
+
},
|
|
412
|
+
"Telemetry::GroundStation::SystemStatus": {
|
|
413
|
+
"port": 3003,
|
|
414
|
+
"kind": "struct",
|
|
415
|
+
"type": "Telemetry::GroundStation::SystemStatus",
|
|
416
|
+
"fields": [
|
|
417
|
+
{
|
|
418
|
+
"name": "actuators",
|
|
419
|
+
"kind": "struct",
|
|
420
|
+
"type": "Telemetry::GroundStation::ActuatorStatus",
|
|
421
|
+
"fields": [
|
|
422
|
+
{
|
|
423
|
+
"name": "separation_filling_online",
|
|
424
|
+
"kind": "primitive",
|
|
425
|
+
"type": "bool",
|
|
426
|
+
"format_string": "<?"
|
|
427
|
+
},
|
|
428
|
+
{
|
|
429
|
+
"name": "flotation_filling_online",
|
|
430
|
+
"kind": "primitive",
|
|
431
|
+
"type": "bool",
|
|
432
|
+
"format_string": "<?"
|
|
433
|
+
},
|
|
434
|
+
{
|
|
435
|
+
"name": "flotation_online",
|
|
436
|
+
"kind": "primitive",
|
|
437
|
+
"type": "bool",
|
|
438
|
+
"format_string": "<?"
|
|
439
|
+
},
|
|
440
|
+
{
|
|
441
|
+
"name": "separation_servo_online",
|
|
442
|
+
"kind": "primitive",
|
|
443
|
+
"type": "bool",
|
|
444
|
+
"format_string": "<?"
|
|
445
|
+
}
|
|
446
|
+
],
|
|
447
|
+
"format_string": "<????"
|
|
448
|
+
},
|
|
449
|
+
{
|
|
450
|
+
"name": "sensors",
|
|
451
|
+
"kind": "struct",
|
|
452
|
+
"type": "Telemetry::GroundStation::SensorStatus",
|
|
453
|
+
"fields": [
|
|
454
|
+
{
|
|
455
|
+
"name": "bme_online",
|
|
456
|
+
"kind": "primitive",
|
|
457
|
+
"type": "bool",
|
|
458
|
+
"format_string": "<?"
|
|
459
|
+
},
|
|
460
|
+
{
|
|
461
|
+
"name": "ms_online",
|
|
462
|
+
"kind": "primitive",
|
|
463
|
+
"type": "bool",
|
|
464
|
+
"format_string": "<?"
|
|
465
|
+
},
|
|
466
|
+
{
|
|
467
|
+
"name": "gnss_online",
|
|
468
|
+
"kind": "primitive",
|
|
469
|
+
"type": "bool",
|
|
470
|
+
"format_string": "<?"
|
|
471
|
+
},
|
|
472
|
+
{
|
|
473
|
+
"name": "icm_online",
|
|
474
|
+
"kind": "primitive",
|
|
475
|
+
"type": "bool",
|
|
476
|
+
"format_string": "<?"
|
|
477
|
+
},
|
|
478
|
+
{
|
|
479
|
+
"name": "mmc_online",
|
|
480
|
+
"kind": "primitive",
|
|
481
|
+
"type": "bool",
|
|
482
|
+
"format_string": "<?"
|
|
483
|
+
},
|
|
484
|
+
{
|
|
485
|
+
"name": "stim_online",
|
|
486
|
+
"kind": "primitive",
|
|
487
|
+
"type": "bool",
|
|
488
|
+
"format_string": "<?"
|
|
489
|
+
},
|
|
490
|
+
{
|
|
491
|
+
"name": "pressure_online",
|
|
492
|
+
"kind": "primitive",
|
|
493
|
+
"type": "bool",
|
|
494
|
+
"format_string": "<?"
|
|
495
|
+
}
|
|
496
|
+
],
|
|
497
|
+
"format_string": "<???????"
|
|
498
|
+
},
|
|
499
|
+
{
|
|
500
|
+
"name": "hardware",
|
|
501
|
+
"kind": "struct",
|
|
502
|
+
"type": "Telemetry::GroundStation::HardwareStatus",
|
|
503
|
+
"fields": [
|
|
504
|
+
{
|
|
505
|
+
"name": "pcan1_online",
|
|
506
|
+
"kind": "primitive",
|
|
507
|
+
"type": "bool",
|
|
508
|
+
"format_string": "<?"
|
|
509
|
+
},
|
|
510
|
+
{
|
|
511
|
+
"name": "pcan2_online",
|
|
512
|
+
"kind": "primitive",
|
|
513
|
+
"type": "bool",
|
|
514
|
+
"format_string": "<?"
|
|
515
|
+
},
|
|
516
|
+
{
|
|
517
|
+
"name": "networking_thread_online",
|
|
518
|
+
"kind": "primitive",
|
|
519
|
+
"type": "bool",
|
|
520
|
+
"format_string": "<?"
|
|
521
|
+
},
|
|
522
|
+
{
|
|
523
|
+
"name": "cli_thread_online",
|
|
524
|
+
"kind": "primitive",
|
|
525
|
+
"type": "bool",
|
|
526
|
+
"format_string": "<?"
|
|
527
|
+
},
|
|
528
|
+
{
|
|
529
|
+
"name": "kalman_thread_online",
|
|
530
|
+
"kind": "primitive",
|
|
531
|
+
"type": "bool",
|
|
532
|
+
"format_string": "<?"
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
"name": "sensor_thread_online",
|
|
536
|
+
"kind": "primitive",
|
|
537
|
+
"type": "bool",
|
|
538
|
+
"format_string": "<?"
|
|
539
|
+
},
|
|
540
|
+
{
|
|
541
|
+
"name": "fsm_thread_online",
|
|
542
|
+
"kind": "primitive",
|
|
543
|
+
"type": "bool",
|
|
544
|
+
"format_string": "<?"
|
|
545
|
+
}
|
|
546
|
+
],
|
|
547
|
+
"format_string": "<???????"
|
|
548
|
+
},
|
|
549
|
+
{
|
|
550
|
+
"name": "current_state",
|
|
551
|
+
"kind": "enum",
|
|
552
|
+
"type": "STATE_NAME",
|
|
553
|
+
"format_string": "<I"
|
|
554
|
+
}
|
|
555
|
+
],
|
|
556
|
+
"format_string": "<??????????????????I"
|
|
307
557
|
}
|
|
308
558
|
},
|
|
309
|
-
"enums": {
|
|
559
|
+
"enums": {
|
|
560
|
+
"STATE_NAME": {
|
|
561
|
+
"NONE": 0,
|
|
562
|
+
"IDLE": 1,
|
|
563
|
+
"READY": 2,
|
|
564
|
+
"FILLING": 3,
|
|
565
|
+
"SEPARATION_FILLING": 4,
|
|
566
|
+
"FLOTATION_FILLING": 5,
|
|
567
|
+
"THRUSTING": 6,
|
|
568
|
+
"COASTING": 7,
|
|
569
|
+
"SEPARATION": 8,
|
|
570
|
+
"FLOTATION": 9,
|
|
571
|
+
"SHUTDOWN": 10,
|
|
572
|
+
"TEST_SEPARATION": 11,
|
|
573
|
+
"TEST_FLOTATION": 12
|
|
574
|
+
}
|
|
575
|
+
}
|
|
310
576
|
}
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-07-
|
|
2
|
+
// This file was generated by FRICC on 2026-07-17 19:34:14. 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;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import bin, { Measurer, Schema } from 'typed-binary';
|
|
2
|
-
// This file was generated by FRICC on 2026-07-
|
|
2
|
+
// This file was generated by FRICC on 2026-07-17 19:34:16. 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;
|