CCSDS 133.0-B Space Packet Protocol for OCaml
Port monorepo to latest ocaml-wire (opam pin)
Migrate all consumers to the new wire API:
- wire.c library → wire.3d (Wire_c → Wire_3d)
- Wire.struct_/module_ → Wire.Everparse.struct_/module_
- Wire.Codec: record/|+/seal → Codec.v with Field.v and $
- Wire.bf_uint* → Wire.U8/U16/U16be/U32/U32be
- Wire.UInt32 → Wire.Private.UInt32
- Wire.cases → Wire.lookup, Wire.map now uses labeled args
- Wire.Codec.decode now returns result
- Add wire pin to root.opam.template
+50
-38
+7
-3
bench/bench_space_packet.ml
+7
-3
bench/bench_space_packet.ml
···
16
16
Bytes.set_uint16_be b 4 (i mod 256);
17
17
b)
18
18
19
-
let test_wire_headers =
20
-
Array.map (fun b -> Space_packet.decode_packed_header b 0) test_headers
19
+
let decode_exn b off =
20
+
match Space_packet.decode_packed_header b off with
21
+
| Ok v -> v
22
+
| Error e -> Fmt.failwith "decode: %a" Wire.pp_parse_error e
23
+
24
+
let test_wire_headers = Array.map (fun b -> decode_exn b 0) test_headers
21
25
22
26
(** {1 Raw Baseline (no record allocation)} *)
23
27
···
89
93
90
94
let wire_roundtrip () =
91
95
for i = 0 to Array.length test_headers - 1 do
92
-
let t = Space_packet.decode_packed_header test_headers.(i) 0 in
96
+
let t = decode_exn test_headers.(i) 0 in
93
97
let buf = Bytes.create 6 in
94
98
Space_packet.encode_packed_header t buf 0;
95
99
let _ = buf in
+11
-9
c/SpacePacketHeader.3d
+11
-9
c/SpacePacketHeader.3d
···
1
-
/*++ CCSDS Space Packet Primary Header (133.0-B-2) --*/
1
+
extern typedef struct _WireCtx WireCtx
2
+
3
+
extern unit WireSetU16BE(mutable WireCtx *ctx, UINT32 idx, UINT16BE v)
2
4
3
5
entrypoint
4
-
typedef struct _SpacePacketHeader
6
+
typedef struct _SpacePacketHeader(mutable WireCtx *ctx)
5
7
{
6
-
UINT16BE version : 3;
7
-
UINT16BE type : 1;
8
-
UINT16BE shf : 1;
9
-
UINT16BE apid : 11;
10
-
UINT16BE seq_flags : 2;
11
-
UINT16BE seq_count : 14;
12
-
UINT16BE data_length;
8
+
UINT16BE version : 3 {:act WireSetU16BE(ctx, (UINT32) 0, version); };
9
+
UINT16BE type : 1 {:act WireSetU16BE(ctx, (UINT32) 1, type); };
10
+
UINT16BE shf : 1 {:act WireSetU16BE(ctx, (UINT32) 2, shf); };
11
+
UINT16BE apid : 11 {:act WireSetU16BE(ctx, (UINT32) 3, apid); };
12
+
UINT16BE seq_flags : 2 {:act WireSetU16BE(ctx, (UINT32) 4, seq_flags); };
13
+
UINT16BE seq_count : 14 {:act WireSetU16BE(ctx, (UINT32) 5, seq_count); };
14
+
UINT16BE data_length {:on-success WireSetU16BE(ctx, (UINT32) 6, data_length); return true; };
13
15
} SpacePacketHeader;
14
16
15
17
+1
-1
c/dune
+1
-1
c/dune
+2
-5
c/gen.ml
+2
-5
c/gen.ml
+25
-17
lib/space_packet.ml
+25
-17
lib/space_packet.ml
···
263
263
264
264
(* Wire Codec *)
265
265
let codec =
266
-
let open Wire.Codec in
267
-
let bits n = Wire.bits ~width:n Wire.bf_uint16be in
266
+
let bits n = Wire.bits ~width:n Wire.U16be in
268
267
let bool = Wire.bool (bits 1) in
269
-
let ptype = Wire.cases [ Telemetry; Telecommand ] (bits 1) in
268
+
let ptype = Wire.lookup [ Telemetry; Telecommand ] (bits 1) in
270
269
let seq_flags =
271
-
Wire.cases
270
+
Wire.lookup
272
271
[ Continuation; First_segment; Last_segment; Unsegmented ]
273
272
(bits 2)
274
273
in
275
-
record "SpacePacketHeader"
274
+
let f_version = Wire.Field.v "version" (bits 3) in
275
+
let f_type = Wire.Field.v "type" ptype in
276
+
let f_shf = Wire.Field.v "shf" bool in
277
+
let f_apid = Wire.Field.v "apid" (bits 11) in
278
+
let f_seq_flags = Wire.Field.v "seq_flags" seq_flags in
279
+
let f_seq_count = Wire.Field.v "seq_count" (bits 14) in
280
+
let f_data_length = Wire.Field.v "data_length" Wire.uint16be in
281
+
Wire.Codec.v "SpacePacketHeader"
276
282
(fun version ptype shf apid seq_flags seq_count data_length ->
277
283
{
278
284
version;
···
283
289
sequence_count = seq_count;
284
290
data_length;
285
291
})
286
-
|+ field "version" (bits 3) (fun t -> t.version)
287
-
|+ field "type" ptype (fun t -> t.packet_type)
288
-
|+ field "shf" bool (fun t -> t.secondary_header)
289
-
|+ field "apid" (bits 11) (fun t -> t.apid)
290
-
|+ field "seq_flags" seq_flags (fun t -> t.sequence_flags)
291
-
|+ field "seq_count" (bits 14) (fun t -> t.sequence_count)
292
-
|+ field "data_length" Wire.uint16be (fun t -> t.data_length)
293
-
|> seal
292
+
Wire.Codec.
293
+
[
294
+
(f_version $ fun t -> t.version);
295
+
(f_type $ fun t -> t.packet_type);
296
+
(f_shf $ fun t -> t.secondary_header);
297
+
(f_apid $ fun t -> t.apid);
298
+
(f_seq_flags $ fun t -> t.sequence_flags);
299
+
(f_seq_count $ fun t -> t.sequence_count);
300
+
(f_data_length $ fun t -> t.data_length);
301
+
]
294
302
295
-
let struct_ = Wire.Codec.to_struct codec
303
+
let struct_ = Wire.Everparse.struct_of_codec codec
296
304
297
305
let module_ =
298
-
Wire.module_ ~doc:"CCSDS Space Packet Primary Header (133.0-B-2)"
299
-
"SpacePacketHeader"
300
-
[ Wire.typedef ~entrypoint:true struct_ ]
306
+
Wire.Everparse.Raw.module_
307
+
~doc:"CCSDS Space Packet Primary Header (133.0-B-2)"
308
+
[ Wire.Everparse.Raw.typedef ~entrypoint:true struct_ ]
301
309
302
310
(* Wire Parse/Encode *)
303
311
let decode_packed_header = Wire.Codec.decode codec
+4
-3
lib/space_packet.mli
+4
-3
lib/space_packet.mli
···
211
211
val codec : packed_header Wire.Codec.t
212
212
(** Wire codec for packed header encoding and decoding. *)
213
213
214
-
val struct_ : Wire.struct_
214
+
val struct_ : Wire.Everparse.struct_
215
215
(** Wire struct descriptor for the packed header. *)
216
216
217
-
val module_ : Wire.module_
217
+
val module_ : Wire.Everparse.module_
218
218
(** Wire module descriptor for the space packet. *)
219
219
220
220
(** {1 Wire Parse/Encode} *)
221
221
222
-
val decode_packed_header : bytes -> int -> packed_header
222
+
val decode_packed_header :
223
+
bytes -> int -> (packed_header, Wire.parse_error) result
223
224
(** [decode_packed_header buf off] decodes a packed header from bytes at offset.
224
225
*)
225
226